1. 映射请求-映射动态资源-参数处理
      服务器接收参数后
       需要按照映射关系调用controller的方法，同时将获取的请求参数，以方法参数的形式传递
      controller方法在接收参数时，希望框架可以按需求实现类型转换
       框架在接收参数，传递参数中，还需按照controller的需求要处理参数
      controller方法的参数列表
      public void t1(String bname,@RequestParam(“num”)int num , int[] nums , HttpServletRequest req , Car car,MuliptartFile excel)

    2. 响应
      框架参数处理完毕后，就可以根据映射关系调用controller方法，传参
       controller中获得参数后的业务处理，就有具体的业务程序完成(controller，service，dao)
      业务程序处理完毕后，需要响应
       直接响应
      直接响应文本字符串
       直接响应集合对象(需要转换成json格式的字符串再响应)
      间接响应
       转发 (携带数据)
      重定向 (携带数据)
       原来响应直接在业务程序中完成
      现在响应由框架完成
       框架实现哪种响应，需要由业务程序告知
      业务程序如何告知框架，需要按照框架的规则告知
      1. 响应内容以返回值的形式返回给框架
      2. 如果是间接响应，直接返回值
       如果不需要携带数据
      return “05.jsp” 转发
      return “redirect:05.jsp” 重定向
      如果需要携带数据
       返回一个框架提供ModelAndView对象 ```java package org.duyi.web7;

    import java.util.HashMap; import java.util.Map; import java.util.Set;

    public class ModelAndView { private String viewName ;// 05.jsp //request.setAttribute(key1,value1); //request.setAttribute(key2,value2); //request.setAttribute(key3,value3); private Map values = new HashMap<>();//存数据

    1. public String getViewName() {
    2.     return viewName;
    3. }
    5. public void setViewName(String viewName) {
    6.     this.viewName = viewName;
    7. }
    9. public void addObject(String key,Object value){
    10.     values.put(key,value) ;
    11. }
    12. public Object getObject(String key){
    13.     return values.get(key) ;
    14. }
    16. public Set<String> getObjectNames(){
    17.     return values.keySet() ;
    18. }

    }

    1.     * 转发： 数据会request.setAttribute()<br />    * 重定向：数据会以?的形式跟在url的后面 (只支持String)<br />              3. 如果是直接响应，在返回值同时，需要为方法增加一个@ResponseBody的注解<br />只表示一种状态不需要属性
    2. ```java
    3. package org.duyi.web7.annotation;
    5. import java.lang.annotation.ElementType;
    6. import java.lang.annotation.Retention;
    7. import java.lang.annotation.RetentionPolicy;
    8. import java.lang.annotation.Target;
    10. @Target(ElementType.METHOD)    //在方法上写
    11. @Retention(RetentionPolicy.RUNTIME)
    12. public @interface ResponseBody {
    13. }
    1.       * 如果返回String，int，double等简单类型，直接以String返回<br />         * 如果是其他类型，则认为需要转换成json
    1. package com.controller;
    4. import com.domain.Car;
    5. import org.duyi.web7.ModelAndView;
    6. import org.duyi.web7.MulitpartFile;
    7. import org.duyi.web7.annotation.Controller;
    8. import org.duyi.web7.annotation.RequestMapping;
    9. import org.duyi.web7.annotation.RequestParam;
    10. import org.duyi.web7.annotation.ResponseBody;
    12. import javax.servlet.http.HttpServletRequest;
    14. @Controller
    15. public class TestController {
    16.     //test1
    17.     public void t1(){
    18.         System.out.println("测试1");
    19.     }
    21.     //test11
    22.     public void t1(int i,String s){}
    24.     //test2
    25.     @RequestMapping("/test2")
    26.     public void t2(@RequestParam("cname")String s , @RequestParam("price") int[] price,Car car, HttpServletRequest req){
    27.         //request
    28.     }
    30.     @RequestMapping("/test3")
    31.     public void t3(Car car){
    32.         System.out.println(car);
    33.     }
    35.     @RequestMapping("/test4")
    36.     public void t4(@RequestParam("cname") String cname , @RequestParam("file") MulitpartFile file){
    37.         System.out.println(cname);
    38.     }
    40.     @RequestMapping("/test5")
    41.     public String t5(){
    42.         return "07.jsp" ;
    43.     }
    45.     @RequestMapping("/test6")
    46.     public ModelAndView t6(){
    47.         ModelAndView mv = new ModelAndView();
    48.         mv.setViewName("07.jsp");
    49.         mv.addObject("cname","benz");
    50.         mv.addObject("price",400000);
    51.         return mv ;
    52.     }
    54.     @RequestMapping("/test7")
    55.     public ModelAndView t7(){
    56.         ModelAndView mv = new ModelAndView();
    57.         mv.setViewName("redirect:07.jsp");
    58.         mv.addObject("cname","benz");
    59.         mv.addObject("price",400000);
    60.         return mv ;
    61.     }
    63.     @RequestMapping("/test8")
    64.     @ResponseBody
    65.     public String t8(){
    66.         return "hello" ;
    67.     }
    69.     @RequestMapping("/test9")
    70.     @ResponseBody
    71.     public Car t9(){
    72.         Car car = new Car(1,"audi","white",50000);
    73.         return car ;
    74.     }
    75. }
    1. package org.duyi.web7;
    3. import com.alibaba.fastjson.JSON;
    4. import org.apache.commons.fileupload.FileItem;
    5. import org.apache.commons.fileupload.FileUploadException;
    6. import org.apache.commons.fileupload.disk.DiskFileItemFactory;
    7. import org.apache.commons.fileupload.servlet.ServletFileUpload;
    8. import org.dom4j.Document;
    9. import org.dom4j.DocumentException;
    10. import org.dom4j.Element;
    11. import org.dom4j.io.SAXReader;
    12. import org.duyi.web7.annotation.Controller;
    13. import org.duyi.web7.annotation.RequestMapping;
    14. import org.duyi.web7.annotation.RequestParam;
    15. import org.duyi.web7.annotation.ResponseBody;
    17. import javax.servlet.ServletException;
    18. import javax.servlet.http.HttpServlet;
    19. import javax.servlet.http.HttpServletRequest;
    20. import javax.servlet.http.HttpServletResponse;
    21. import javax.servlet.http.HttpSession;
    22. import java.io.*;
    23. import java.lang.reflect.InvocationTargetException;
    24. import java.lang.reflect.Method;
    25. import java.lang.reflect.Parameter;
    26. import java.util.*;
    28. public class DispatcherServlet extends HttpServlet {
    30.     /*
    31.         缓存请求映射信息
    32.         key  = "/test1"
    33.         value = mappingInfo{目标对象，目标方法}
    34.      */
    35.     Map<String,MappingInfo> mappingInfoMap = new HashMap<>();
    37.     /*
    38.         单实例存储controller对象
    39.         key="com.controller.TestController"
    40.         value= new Object
    41.      */
    42.     Map<String,Object> controllerMap = new HashMap<>();
    44.     /**
    45.      * 读取各种配置信息
    46.      *      (目前只有请求映射信息)
    47.      * @throws ServletException
    48.      */
    49.     @Override
    50.     public void init() throws ServletException {
    51.         //目前配置信息来自于两个部分，而且两个部分都可能存在
    53.         String xmlPath = super.getInitParameter("classpath");
    54.         if(xmlPath != null && !"".equals(xmlPath)){
    55.             //指定了配置文件，需要读取配置文件
    56.             readXml(xmlPath);
    57.         }
    59.         String packagePath = super.getInitParameter("controller-scan") ;
    60.         if(packagePath != null && !"".equals(packagePath)){
    61.             try {
    62.                 //指定了包路径，需要读取包下类中的注解信息
    63.                 readAnnotation(packagePath);
    64.             } catch (ClassNotFoundException e) {
    65.                 e.printStackTrace();
    66.             } catch (IllegalAccessException e) {
    67.                 e.printStackTrace();
    68.             } catch (InstantiationException e) {
    69.                 e.printStackTrace();
    70.             }
    71.         }
    73.     }
    75.     //读取xml配置文件
    76.     public void readXml(String path){
    77.         //path="mvc.xml"
    78.         //D:\ideaworkspace2\web-demo\out\artifacts\web_demo_war_exploded\WEB-INF\classes\mvc.xml
    79.         path = Thread.currentThread().getContextClassLoader()
    80.                 .getResource(path).getPath();
    81.         try {
    82.             InputStream is = new FileInputStream(path) ;
    83.             //使用dom,sax读取xml内容
    84.             SAXReader reader = new SAXReader() ;
    85.             Document document = reader.read(is) ;
    87.             //解析mapping标签
    88.             parseMappingElement(document);
    90.             //解析multipart-encoding
    91.             parseMultipartEncodingElement(document);
    92.             //解析其他标签
    95.         } catch (FileNotFoundException e) {
    96.             e.printStackTrace();
    97.         } catch (DocumentException e) {
    98.             e.printStackTrace();
    99.         } catch (IllegalAccessException e) {
    100.             e.printStackTrace();
    101.         } catch (InstantiationException e) {
    102.             e.printStackTrace();
    103.         } catch (ClassNotFoundException e) {
    104.             e.printStackTrace();
    105.         } catch (NoSuchMethodException e) {
    106.             e.printStackTrace();
    107.         }
    108.     }
    110.     private String multipartEncoding ;
    111.     //读取<multipart-encoding>标签
    112.     private void parseMultipartEncodingElement(Document document){
    113.         Element mulipartEncodingElement = (Element) document.selectSingleNode("mvc/multipart-encoding");
    114.         if(mulipartEncodingElement == null)
    115.             return ;
    116.         multipartEncoding = mulipartEncodingElement.getText() ;
    118.     }
    120.     //读取xml中<mapping>请求映射信息
    121.     private void parseMappingElement(Document document) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException {
    122.         //按照标签的嵌套规则，找到需要的所有mapping标记
    123.        List<Element> mappingElements =  document.selectNodes("mvc/mapping") ;
    124.        for(Element mappingElement : mappingElements ){
    125.            /*
    126.                 获得标签指定的属性值
    127.                 标签中记载着请求与响应对应关系
    128.                 此时(初始化)获得这个对应关系，不是次使用
    129.                 后面请求的时候用
    130.                 所以需要存储起来，组成对象
    131.             */
    132.            String path = mappingElement.attributeValue("path") ;
    133.            String classname = mappingElement.attributeValue("class") ; // com.controller.TestController
    134.            String methodname = mappingElement.attributeValue("method") ; // t1
    136.            //反射创建目标对象
    137.            Class clazz = Class.forName(classname) ;
    138.            Object controller =  getSingleController(classname);
    140.            //通过反射，根据方法名获得方法对象 t1() , t2(int , String)
    141.            //获得mapping标签的子标签<type> 存储目标方法对应的参数列表
    142.            List<Element> typeElements = mappingElement.selectNodes("type") ;
    143.            //创建一个与配置文件中<type>数量相同的Class数组，准备装载目标方法对应的参数列表类型
    144.            Class[] types = new Class[typeElements.size()] ;
    145.            int i = 0 ;
    146.            for(Element typeElement : typeElements){
    147.                //<type> 获得标签的文本内容 "int"
    148.                String typeStr = typeElement.getText() ;
    149.                //"int" ->int.class
    150.                types[i++] = castStringToClass(typeStr) ;
    151.            }
    152.            Method method = clazz.getMethod(methodname,types ) ;
    154.            MappingInfo info = new MappingInfo(path,controller,method) ;
    155.            mappingInfoMap.put(path,info) ;
    156.        }
    157.     }
    159.     /*
    160.      *  将字符串表示的类型转换成对应的Class类型
    161.      *  "int" -> int.class
    162.      *  "java.lang.String" -> String.class -> Class.forName("java.lang.String")
    163.      */
    164.     private Class castStringToClass(String typeStr) throws ClassNotFoundException {
    165.         if("int".equals(typeStr)){
    166.             return int.class;
    167.         }
    168.         if("long".equals(typeStr)){
    169.             return long.class;
    170.         }
    171.         if("double".equals(typeStr)){
    172.             return double.class;
    173.         }
    174.         //除去8种基本类型，以外的都是引用类型，写的都是全名，反射生成Class , java.lang.Integer
    175.         return Class.forName(typeStr) ;
    176.     }
    178.     public Object getSingleController(String classname) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
    179.         Class clazz = Class.forName(classname);
    180.         Object controller =  controllerMap.get(classname);
    181.         if(controller == null){
    182.             controller = clazz.newInstance() ;
    183.             controllerMap.put(classname,controller);
    184.         }
    185.         return controller ;
    186.     }
    188.     //读取注解
    189.     public void readAnnotation(String packagePath) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
    190.         //packagePath = "com.controller,com.controller2,.."
    191.         //需要框架从指定的2个包中找到请映射的注解
    192.         //packagePathArray = {"com.controller","com.controller2"};
    193.         String[] packagePathArray = packagePath.split(",") ;
    194.         for(String ppath : packagePathArray){
    195.             //ppath = "com.controller"
    196.             //要想完成反射，只有包路径还不够，还需要类名 com.controller + TestController
    197.             //如何获得类名
    198.             //不能通过反射获得包中类
    199.             //可以通过File操作获得文件夹中的文件名->去掉后缀，就是类名
    200.             // "com.controller" -> "com/controller"
    201.             String dirPath = ppath.replace(".","/");
    202.             // dirPath ="F:\dmc\idea_workspace\web-demo\out\artifacts\web_demo_war_exploded\WEB-INF\classes\com\controller"
    203.             try {
    204.                 dirPath = Thread.currentThread().getContextClassLoader()
    205.                         .getResource(dirPath).getPath();
    206.             }catch(NullPointerException e){
    207.                 //指定的包路径有错误
    208.                 System.out.println("logging : package path not found ["+dirPath+"]");
    209.                 //当前不存在包就不在检索了
    210.                 continue ;
    211.                 //throw new FileNotFoundException(dirPath);
    212.             }
    213.             File dir = new File(dirPath);
    215.             //获得文件夹中所有子内容名字 (子文件夹，子文件)
    216.             String[] fnames = dir.list() ;
    217.             for(String fname : fnames){
    218.                 //fname="TestController.class
    219.                 if(fname.endsWith(".class")){
    220.                     int i = fname.indexOf(".") ;
    222.                     //className="TestController"
    223.                     String className = fname.substring(0,i);
    224.                     //className = "com.controller.TestController"
    225.                     className = ppath + "." + className ;
    227.                     Class clazz = Class.forName(className);
    228.                     Controller c = (Controller) clazz.getAnnotation(Controller.class);
    229.                     if(c == null){
    230.                         //当前包中的这个类没有设置@Controller,类中没有请求映射信息
    231.                         continue ;
    232.                     }
    233.                     //有@Controller,类中有请求映射关系
    234.                     //遍历类中所有的方法，找到@RequestMapping
    235.                     Method[] methodArray = clazz.getMethods() ;
    236.                     for(Method method : methodArray){
    237.                         RequestMapping rm = method.getAnnotation(RequestMapping.class);
    238.                         if(rm == null){
    239.                             continue ;
    240.                         }
    241.                         //方法中有@RequestMapping，表示是一个请求映射的方法
    242.                         String path = rm.value();
    243.                         Object controller =  getSingleController(className);
    245.                         MappingInfo info = new MappingInfo(path,controller,method) ;
    246.                         Object obj = mappingInfoMap.get(path);
    247.                         if(obj != null ){
    248.                             //当前请求映射关系已经存在
    249.                             //去重 continue
    250.                             //覆盖 map.put
    251.                             //抛出异常 throw new Exception
    252.                         }
    254.                         mappingInfoMap.put(path,info) ;
    255.                     }
    256.                 }
    257.             }
    258.         }
    259.     }
    261.     //-----------------------------------------------------------------------------------------------------------------------------------------------
    262.     //------------------------------------初始化处理结束-----------------------------------------------------------------------------------------------
    263.     //-----------------------------------------------------------------------------------------------------------------------------------------------
    265.     @Override
    266.     protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    267.         //请求映射，根据请求调用controller的具体方法
    269.         //获得请求 /test1
    270.         //req.getRequestURL(); // http://localhost:8080/web-demo/test1
    271.         String uri = req.getRequestURI() ;// /web-demo/test1
    272.         System.out.println(uri);
    273.         String root = req.getContextPath() ;// /web-demo
    274.         String path = uri.replace(root,""); // /test1
    276.         //根据请求找到对应的mappinginfo 映射信息
    277.         MappingInfo info = mappingInfoMap.get(path) ;
    278.         if(info == null){
    279.             //没有找到与之匹配映射请求 （xml和注解）
    280.             //没有需要调用的controller和方法
    281.             //有可能此次请求的是一些文件资源.html , .css , .js , .jpg
    282.             //之前在没有框架的时候，为什么可以访问这些静态文件呢
    283.             //原因是tomcat提供了一个专门处理静态资源访问的DefaultServlet
    284.             //该servlet处理的请求模式就是 /
    285.             //现在我们的DispatcherServlet一般也建议配置成 /
    286.             //就会覆盖tomcat自带的DefaultServlet
    287.             //就不会再自动处理静态资源了
    288.             //就需要框架来处理静态资源
    289.             handleStaticResource(path,req,resp);
    290.         }else{
    291.             try {
    292.                 //找到映射信息了，就按照映射信息分发请求，调用controller.method
    293.                 handleDynamicResource(info,req,resp);
    294.             } catch (InvocationTargetException e) {
    295.                 e.printStackTrace();
    296.             } catch (IllegalAccessException e) {
    297.                 e.printStackTrace();
    298.             } catch (InstantiationException e) {
    299.                 e.printStackTrace();
    300.             }
    301.         }
    304.     }
    306.     /*
    307.         处理动态资源请求
    308.      */
    309.     private void handleDynamicResource(MappingInfo info,HttpServletRequest req,HttpServletResponse resp) throws InvocationTargetException, IllegalAccessException, InstantiationException, IOException, ServletException {
    310.         //获得参数
    311.         Map<String,Object> paramMap = receiveParams(req);
    312.         //处理参数
    313.         Object[] paramValues = handleParam(paramMap,info,req,resp) ;
    315.         //调用mappinginfo中的对象的方法，传递参数
    316.         Object result = info.getMethod().invoke( info.getController() , paramValues ) ;
    318.         //根据result返回值，实现响应
    319.         handleResponse(result,info.getMethod(),req,resp);
    320.     }
    322.     private void handleResponse(Object result,Method method,HttpServletRequest req,HttpServletResponse resp) throws IOException, ServletException {
    323.         if(result == null){
    324.             //不需要框架响应
    325.             return ;
    326.         }
    327.         ResponseBody rb = method.getAnnotation(ResponseBody.class);
    328.         if(rb != null){
    329.             //有@ResponseBody 直接响应
    330.             if(
    331.                     result instanceof String ||
    332.                     result instanceof Integer ||
    333.                     result instanceof Long ||
    334.                     result instanceof Boolean){
    335.                 //简单类型，都变成字符串，直接响应
    336.                 resp.getWriter().write(result.toString());
    337.             }else{
    338.                 //不是简单类型，就是集合对象，需要转换成json再响应
    339.                 //    直接把返回值转换为json
    340.                 String json = JSON.toJSONString(result) ;
    341.                 resp.setContentType("text/json");    //类型转换
    342.                 resp.getWriter().write(json);    //响应回去
    343.             }
    344.         }else{
    345.             // 间接响应
    346.             if(result instanceof String){
    347.                 //不需要携带数据
    348.                 String _result = (String) result;
    349.                 if(_result.startsWith("redirect:")){
    350.                     //重定向 "redirect:05.jsp"
    351.                     // "05.jsp"
    352.                     _result = _result.replace("redirect:","");
    353.                     resp.sendRedirect(_result);
    354.                 }else{
    355.                     //转发 "05.jsp"
    356.                     req.getRequestDispatcher(_result).forward(req,resp);
    357.                 }
    358.             }else{
    359.                 //就是ModelAndView，需要携带数据
    360.                 ModelAndView _result = (ModelAndView) result;
    361.                 // path="05.jsp" / "redirect:05.jsp"
    362.                 String path = _result.getViewName() ;
    363.                 if(path.startsWith("redirect:")){
    364.                     //重定向携带数据 05.jsp?...
    365.                     path = path.replace("redirect:","");
    366.                     path+="?" ;
    368.                     Set<String> names = _result.getObjectNames() ;
    369.                     for(String name : names){
    370.                         Object value = _result.getObject(name);
    371.                         path+=name+"="+value+"&";
    372.                     }
    373.                     //05.jsp?a=1&b=2&c=3
    374.                     resp.sendRedirect(path);
    375.                 }else{
    376.                     //转发携带数据，
    377.                     //req.setAttribute(name,value)
    378.                     Set<String> names = _result.getObjectNames() ;
    379.                     for(String name : names){
    380.                         Object value = _result.getObject(name);
    381.                         req.setAttribute(name,value);
    382.                     }
    383.                     req.getRequestDispatcher(path).forward(req,resp);
    384.                 }
    385.             }
    386.         }
    387.     }
    389.     /*
    390.         按照请求映射关系要调用的那个目标方法
    391.         获得目标方法的参数列表
    392.         根据参数列表获得所需要的参数
    393.         并将参数组装Object[]中
    394.      */
    395.     private Object[] handleParam(Map<String,Object> paramMap,MappingInfo info,HttpServletRequest req , HttpServletResponse resp) throws IllegalAccessException, InstantiationException, InvocationTargetException {
    396.         Method method = info.getMethod() ;
    397.         Parameter[] parameters = method.getParameters() ;
    398.         //创建一个与方法参数列表同长度的数组装载参数数据(实参)
    399.         Object[] paramValues = new Object[ parameters.length ]  ;
    400.         int i = 0 ;
    401.         for(Parameter parameter : parameters){
    402.             RequestParam rp = parameter.getAnnotation(RequestParam.class);
    403.             Class paramType = parameter.getType() ;
    404.             if(rp != null){
    405.                 //证明有这个注解  @RequestParam("cname") String cname
    406.                 //表示需要请求传递的一个叫cname名字的参数
    407.                 //请求传递的参数之前已经处理过了
    408.                 //处理后将请求传递的参数存入了paramMap集合中，key=cname,value=[]
    409.                 String key = rp.value() ;// cname
    410.                 Object value = paramMap.get(key) ;
    411.                 if(value == null){
    412.                     //当前所需要的的参数没有值，默认是null，之间找下一个参数值
    413.                     i++ ;
    414.                     continue ;
    415.                 }
    416.                 //如果参数值存在，起初只有2种表现形成 String[] , MulitpartFile[]
    418.                 //将此次需要的参数value，转换成方法中定义的需要参数类型
    419.                 paramValues[i++] = castType(value,paramType);
    421.             }else{
    422.                 //没有@RequestParam注解
    423.                 //可能是request，response，session，domain（组装参数User,Car,Goods）
    424.                 if(paramType == HttpServletRequest.class){
    425.                     paramValues[i++] = req ;
    426.                 }else if(paramType == HttpServletResponse.class){
    427.                     paramValues[i++] = resp ;
    428.                 }else if(paramType == HttpSession.class){
    429.                     paramValues[i++] = req.getSession() ;
    430.                 }else{
    431.                     //是一个domain类型，假设是paramType = Car.class
    432.                     //将此次请求的多个参数，最终组成一个car对象
    433.                     Object paramObject = paramType.newInstance() ; //new Car()
    434.                     //通过反射获得对象中的属性名，根据属性名找到与之同名的参数，为属性赋值
    435.                     //为了更好的符合java封装的特性，不建议通过反射找属性，建议通过反射找对应的set方法
    436.                     Method[] methods = paramType.getMethods() ;
    437.                     for(Method m : methods){
    438.                         String mname = m.getName() ;
    439.                         if(mname.startsWith("set")){
    440.                             //是一个set方法，有对应的属性 setCname --> cname
    441.                             String key = mname.substring(3) ;//去掉set-->Cname
    442.                             key = key.substring(0,1).toLowerCase() + key.substring(1) ;// cname
    443.                             Object value = paramMap.get(key) ;
    444.                             if(value == null){
    445.                                 i++ ;
    446.                                 continue ;
    447.                             }
    448.                             //根据domain的set方法(属性名)找到了与之对应的参数
    449.                             //该参数起初只是String[],MultipartFile[]类型
    450.                             //需要转换成domain中属性的类型
    451.                             Class domainParamType = m.getParameterTypes()[0] ; // void setCname(String cname) -> String
    452.                             Object v = castType(value,domainParamType) ;
    453.                             m.invoke(paramObject,v) ;// car.setCname(cname);
    454.                         }
    455.                     }
    456.                     //循环结束，找到了所有的set方法，为对象的属性赋值，赋值结束将对象参数保存
    457.                     paramValues[i++] = paramObject;
    459.                 }
    460.             }
    462.         }
    464.         return paramValues ;
    465.     }
    467.     /*
    468.     将原始类型的参数数据，转换成目标方法所需要的类型
    469.     原始类型：String[] , MulipatrFile[]
    470.     目标类型：int,long,double,String,int[],long[],String[],Integer,Integer[],
    471.             MultiparFile , MultipartFile[]
    473.      */
    474.     private Object castType(Object value , Class paramType){
    475.         if(paramType == String.class){
    476.             String str = ((String[])value)[0] ;
    477.             return str ;
    478.         }
    479.         if(paramType == int.class || paramType==Integer.class){
    480.             String str = ((String[])value)[0] ;
    481.             int num = Integer.parseInt(str) ;
    482.             return num ;
    483.         }
    485.         if(paramType == long.class || paramType==Long.class){
    486.             String str = ((String[])value)[0] ;
    487.             long num = Long.parseLong(str) ;
    488.             return num ;
    489.         }
    491.         if(paramType == double.class || paramType==Double.class){
    492.             String str = ((String[])value)[0] ;
    493.             double num = Double.parseDouble(str) ;
    494.             return  num ;
    495.         }
    497.         if(paramType == String[].class){
    498.             return value ;
    499.         }
    501.         //url?cname=1&cname=2&cname3 =》框架会存储成数组[1,2,3]
    502.         if(paramType == int[].class){
    503.             String[] ss =  (String[])value ;
    504.             int[] nums = new int[ss.length];
    505.             for(int j=0;j< ss.length;j++){
    506.                 nums[j] = Integer.parseInt(ss[j]);
    507.             }
    508.             return nums ;
    509.         }
    511.         if(paramType == Integer[].class){
    512.             String[] ss =  (String[])value ;
    513.             Integer[] nums = new Integer[ss.length];
    514.             for(int j=0;j< ss.length;j++){
    515.                 nums[j] = Integer.valueOf(ss[j]);
    516.             }
    517.             return nums ;
    518.         }
    520.         if(paramType == MulitpartFile.class){
    521.             return ((MulitpartFile[])value)[0];
    522.         }
    524.         if(paramType == MulitpartFile[].class)
    525.             return value ;
    527.         return null ;
    528.     }
    530.     /*
    531.      * 接收请求传递从参数
    532.      * 将参数处理后装入map
    533.      *  map.key就是请求传递参数key <input type="uname" />  map.key=uname
    534.      *  map.value 可能是一个 String[] 也可能是一个 文件[] -> Object表示
    535.      */
    536.     private Map<String,Object> receiveParams(HttpServletRequest req){
    537.         Map<String,Object> paramMap = new HashMap<>();
    538.         //参数有2种可能 (普通请求，文件上传请求)
    539.         //如果普通请求按照文件上传方式处理，会抛出异常
    540.         //如果文件上传请求按照普通请求处理会得不到参数
    541.         try{
    542.             //假设是文件上传方式传递参数
    543.             DiskFileItemFactory factory = new DiskFileItemFactory();
    544.             ServletFileUpload upload = new ServletFileUpload(factory) ;
    545.             //该行会判断是否是文件上传请求，是否配置了enctype="multipart/form-data"，如果不是会抛出异常
    546.             List<FileItem> fis = upload.parseRequest(req) ;
    548.             //确实是一个文件上传的请求，同时因为上一行代码，已经将请求的参数都组成了FileItem对象，装入了List集合
    549.             for(FileItem fi : fis){
    550.                 //拿到了一个参数
    551.                 if(fi.isFormField()){
    552.                     // 是一个普通参数，String
    553.                     String key = fi.getFieldName() ;// <input name="uname" />
    554.                     String value = fi.getString(multipartEncoding) ;
    556.                     String[] values = (String[]) paramMap.get(key);
    557.                     if(values == null){
    558.                         //还没有存储过当前这个名字的参数
    559.                         values = new String[]{value} ;
    560.                         paramMap.put(key,values) ;
    561.                     }else{
    562.                         //当前名字的参数之前存储过，将当前的数据装入数组，数组扩容+1
    563.                         values = Arrays.copyOf(values,values.length+1) ;
    564.                         values[ values.length-1 ] = value ;
    565.                         paramMap.put(key,values) ;
    566.                     }
    567.                 }else{
    568.                     // 是一个文件参数
    569.                     String key = fi.getFieldName() ; // <input type="file" name="excel" />
    571.                     String fileName = fi.getName() ; //文件名 1.jpg
    572.                     long size = fi.getSize() ;//获得文件大小
    573.                     String contentType = fi.getContentType() ; //文件的类型
    574.                     InputStream is = fi.getInputStream() ;//文件内容
    576.                     MulitpartFile file = new MulitpartFile(key,fileName,size,contentType,is);
    578.                     MulitpartFile[] files = (MulitpartFile[]) paramMap.get(key);
    579.                     if(files == null){
    580.                         //当前名字的文件参数之前没有
    581.                         files = new MulitpartFile[]{file} ;
    582.                         paramMap.put(key,files);
    583.                     }else{
    584.                         //之前存储过这个名字的文件参数
    585.                         files = Arrays.copyOf(files,files.length+1);
    586.                         files[ files.length-1 ] = file ;
    587.                         paramMap.put(key,files) ;
    588.                     }
    589.                 }
    590.             }
    592.         }catch(FileUploadException e){
    593.             //出现异常表示不是文件上传方式，再按照普通方式处理
    594.             Enumeration<String> names = req.getParameterNames();
    595.             while(names.hasMoreElements()){
    596.                 String name = names.nextElement() ; // name="uname"
    597.                 String[] values = req.getParameterValues(name);
    598.                 paramMap.put(name,values) ;
    599.             }
    600.         } catch (UnsupportedEncodingException e) {
    601.             e.printStackTrace();
    602.         } catch (IOException e) {
    603.             e.printStackTrace();
    604.         }
    607.         return paramMap ;
    608.     }
    610.     /*
    611.         处理静态资源，在mapping映射信息中没有找到就表示静态资源
    612.      */
    613.     private void handleStaticResource(String path,HttpServletRequest req,HttpServletResponse resp) throws IOException {
    614.         if(path.equals("/")){
    615.             //获得/表示的默认资源->/index.html
    616.             path = req.getServletPath();
    617.         }
    618.         //path="/index.html"
    619.         //根据请求的相对路径，找到对应文件在服务器端存储的绝对路径
    620.         //Thread.currentThread...()获得classes目录下的文件路径
    621.         //request.getServletContext().realPath()获得服务器目录下的文件路径
    622.         //path ="F:\dmc\idea_workspace\web-demo\out\artifacts\web_demo_war_exploded\index.html"
    623.         String fpath = req.getServletContext().getRealPath(path);
    624.         File file = new File(fpath) ;
    625.         if(!file.exists()){
    626.             //能执行当前方法，表示此次请求的不是一个动态资源
    627.             //文件不存在，表示此次请求的静态资源不存在
    628.             //表示此次没有找到对应的资源
    629.             resp.sendError(404,"["+path+"]");
    630.             return ;
    631.         }
    633.         InputStream is = new FileInputStream(file);
    634.         OutputStream os = resp.getOutputStream() ;
    635.         byte[] bs = new byte[0x100] ;//16*16=256
    636.         while(true){
    637.             int len = is.read(bs) ;
    638.             if(len == -1)break ;
    639.             os.write(bs,0,len);
    640.         }
    641.         os.flush();
    642.         is.close();
    643.     }
    644. }