【JavaWeb】封装一个MVC框架

框架参考自：

https://www.bilibili.com/video/BV1gV411r7ct

在老师的基础上添加了

1、POST参数处理

2、Tomcat8版本下中文乱码处理

3、可声明请求方式

框架需要的全部依赖：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.jack2048</groupId>

    <artifactId>MVC-Framework</artifactId>

    <version>1.0-SNAPSHOT</version>

    <properties>

        <maven.compiler.source>8</maven.compiler.source>

        <maven.compiler.target>8</maven.compiler.target>

    </properties>

    <packaging>jar</packaging>

    <dependencies>

        <!-- https://mvnrepository.com/artifact/commons-io/commons-io -->

        <dependency>

            <groupId>commons-io</groupId>

            <artifactId>commons-io</artifactId>

            <version>2.11.0</version>

        </dependency>

        <dependency>

            <groupId>commons-beanutils</groupId>

            <artifactId>commons-beanutils</artifactId>

            <version>1.7.0</version>

        </dependency>

        <dependency>

            <groupId>org.javassist</groupId>

            <artifactId>javassist</artifactId>

            <version>3.26.0-GA</version> <!-- <version>3.12.1-GA</version> -->

        </dependency>

        <dependency>

            <groupId>com.alibaba</groupId>

            <artifactId>fastjson</artifactId>

            <version>1.2.78</version>

        </dependency>

        <dependency>

            <groupId>javax.servlet</groupId>

            <artifactId>javax.servlet-api</artifactId>

            <version>4.0.1</version>

            <scope>provided</scope>

        </dependency>

        <dependency>

            <groupId>javax.servlet</groupId>

            <artifactId>jstl</artifactId>

            <version>1.2</version>

        </dependency>

        <dependency>

            <groupId>javax.servlet.jsp</groupId>

            <artifactId>javax.servlet.jsp-api</artifactId>

            <version>2.3.3</version>

        </dependency>

        <!-- https://mvnrepository.com/artifact/org.reflections/reflections -->

        <dependency>

            <groupId>org.reflections</groupId>

            <artifactId>reflections</artifactId>

            <version>0.9.11</version>  <!-- <version>0.9.12</version> 此版本 Reflections已经不适用了字符串构造  -->

        </dependency>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>4.12</version>

            <scope>test</scope>

        </dependency>

    </dependencies>

</project>

注解一栏：

@Controller仅用于标记注册类

package cn.jack2048.framework.annotation;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

 * 只能注解在类上面

 * 用于标识为Controller，提供给Servlet进行调用

 *

 */

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

public @interface Controller {

}

@RequestMapping标记

package cn.jack2048.framework.annotation;

import cn.jack2048.framework.constant.MethodType;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

 * 支持在类上和方法上配置映射路径 和设置请求方式

 */

@Target({ElementType.METHOD, ElementType.TYPE})

@Retention(RetentionPolicy.RUNTIME)

public @interface RequestMapping {

    String value() default "";

    MethodType methodType() default MethodType.GET;

}

请求方式枚举类：

package cn.jack2048.framework.constant;

/**

 * 定义请求方式

 * MethodType

 *

 */

public enum MethodType {

    GET("doGet"), POST("doPost"), DELETE("doDelete"), PUT("doPut") , HEAD("doHEAD") , TRACE("doTrace");

    private final String type;

    MethodType(String type) {

        this.type = type;

    }

    public String getType() {

        return type;

    }

}

中文乱码过滤器：

过滤器参考自乐字节

https://www.bilibili.com/video/BV1SP4y147wJ?p=69

对于Tomcat版本的确认进行了改进

package cn.jack2048.framework.filter;

import cn.jack2048.framework.constant.ServletConstants;

import cn.jack2048.framework.util.RequestWrapper;

import cn.jack2048.framework.util.ServletUtil;

import javax.servlet.*;

import javax.servlet.http.HttpServletRequest;

import java.io.IOException;

/**

 * @WebFilter(value = {"/*", "/**"})

 *  过滤器注解不能决定过滤链的顺序，不推荐使用注解过滤器，所以还是要手动配置

 */

public class CharacterEncodingFilter implements Filter {

    @Override

    public void init(FilterConfig filterConfig) throws ServletException {

    }

    /**

     * 乱码处理

     *

     * @param servletRequest

     * @param servletResponse

     * @param filterChain

     * @throws IOException

     * @throws ServletException

     */

    @Override

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        HttpServletRequest req = (HttpServletRequest) servletRequest;

        String method = req.getMethod();

        String tomcatMajorVersion = ServletUtil.getTomcatMajorVersion(req);

        Integer tmv = Integer.valueOf(tomcatMajorVersion);

        // 如果Tomcat版本小于8 （8以下的版本） 且为 GET请求

        if (8 > tmv && ServletConstants.REQUEST_METHOD_GET.equalsIgnoreCase(method)) {

            RequestWrapper requestWrapper = new RequestWrapper(req);

            filterChain.doFilter(requestWrapper, servletResponse);

            return;

        }

        /**

         * Tomcat所有版本都不会处理非GET请求的乱码，默认设置即可

         *

         */

        if (! ServletConstants.REQUEST_METHOD_GET.equals(method)) {

            req.setCharacterEncoding(ServletConstants.CHARSET_TYPE_UTF8);

        }

        filterChain.doFilter(req, servletResponse);

    }

    @Override

    public void destroy() {

    }

}

主版本获取方法：

    /**

     * 获取Tomcat主版本号

     * @param request

     * @return

     */

    public static String getTomcatMajorVersion(HttpServletRequest request) {

        ServletContext servletContext = request.getServletContext();

        String serverInfo = servletContext.getServerInfo(); // Apache Tomcat/8.5.70 获取完整版本信息

        int i = serverInfo.indexOf("/");

        serverInfo = serverInfo.substring(i + 1); // 8.5.70 获取版本号

        int i2 = serverInfo.indexOf(".");

        String majorVersion =  serverInfo.substring(0, i2); // 8 获取主版本号

        return majorVersion;

    }

Wrrapper包装类：

package cn.jack2048.framework.util;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletRequestWrapper;

import java.nio.charset.StandardCharsets;

public class RequestWrapper extends HttpServletRequestWrapper {

    private HttpServletRequest httpServletRequest;

    public RequestWrapper(HttpServletRequest request) {

        super(request);

        this.httpServletRequest = request;

    }

    /**

     * GET 请求重写Parameter方法处理

     * @param name

     * @return

     */

    @Override

    public String getParameter(String name) {

        String value = this.httpServletRequest.getParameter(name);

        if(null != value && !"".equals(value)) {

            try {

                value = new String(value.getBytes(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8);

            } catch (Exception exception) {

                exception.printStackTrace();

            }

        }

        return value;

    }

}

注解的作用在于被反射机制获取到被注解标注的类，以方便保存反射需要使用的信息

package cn.jack2048.framework.util;

import cn.jack2048.framework.annotation.Controller;

import cn.jack2048.framework.annotation.RequestMapping;

import cn.jack2048.framework.constant.MethodType;

import cn.jack2048.framework.model.Mapping;

import javassist.ClassClassPath;

import javassist.ClassPool;

import javassist.CtMethod;

import javassist.bytecode.AttributeInfo;

import javassist.bytecode.CodeAttribute;

import javassist.bytecode.LocalVariableAttribute;

import javassist.bytecode.MethodInfo;

import org.reflections.Reflections;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.math.BigDecimal;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.util.*;

public class ClassUtil {

    public static Set<Class<?>> generalReferType; // 基本常用类型

    public static Set<String> allBasicType; // 基本数据类型

    public static Set<Class<?>> dateType; // 日期类型

    private static Map<String, Mapping> allMapping;  // 创建集中容器

    static {

        allMapping = getAllRequestMapping("cn.jack2048.controller");

        generalReferType = new HashSet<>();

        generalReferType.add(String.class);

        generalReferType.add(Byte.class);

        generalReferType.add(Character.class);

        generalReferType.add(Short.class);

        generalReferType.add(Integer.class);

        generalReferType.add(Long.class);

        generalReferType.add(BigDecimal.class);

        generalReferType.add(Float.class);

        generalReferType.add(Double.class);

        generalReferType.add(Boolean.class);

        allBasicType = new HashSet<>();

        allBasicType.add("boolean");

        allBasicType.add("byte");

        allBasicType.add("char");

        allBasicType.add("short");

        allBasicType.add("int");

        allBasicType.add("long");

        allBasicType.add("float");

        allBasicType.add("double");

        dateType = new HashSet<>();

        dateType.add(Date.class);

        dateType.add(LocalDate.class);

        dateType.add(LocalDateTime.class);

    }

    public static Map<String, Mapping> getAllRequestMapping(String packagePath) {

        try {

            Reflections reflections = new Reflections(packagePath);

            Map<String, Mapping> mappingMap = new HashMap<>();

            ClassPool classPool = ClassPool.getDefault();

            // 获取指定包名下面所有的带有@Controller注解的类对象

            Set<Class<?>> controllerClassSet = reflections.getTypesAnnotatedWith(Controller.class);

            // 对每一个@Controller注解的类处理

            for (Class<?> controllerClass : controllerClassSet) {

                // System.out.println(controllerClass.getName());

                Object newInstance = controllerClass.newInstance();

                String baseUri = "";

                // 检查这个类是否还有@RequestMapping注解

                RequestMapping requestMappingForClass = controllerClass.getDeclaredAnnotation(RequestMapping.class);

                // 如果类中有此注解

                if (null != requestMappingForClass) {

                    baseUri = requestMappingForClass.value();

                }

                // 获取所有私有方法

                Method[] declaredMethods = controllerClass.getDeclaredMethods();

                // 寻找带有@RequestMapping注解的方法

                for (Method declaredMethod : declaredMethods) {

                    RequestMapping requestMappingForMethod = declaredMethod.getAnnotation(RequestMapping.class);

                    if (null == requestMappingForMethod) continue; // 该方法没有标注此注解，直接忽略

                    String methodUri = requestMappingForMethod.value(); // 有此注解，获取对应的uri

                    MethodType methodType = requestMappingForMethod.methodType();  // 有此注解，获取对应的请求方法

                    final String FULL_URI = baseUri + methodUri; // 拼接完整uri

                    // 除了方法之外，方法的参数信息也需要进行保存

                    classPool.insertClassPath(new ClassClassPath(controllerClass));

                    CtMethod ctMethod = classPool.getMethod(controllerClass.getName(), declaredMethod.getName());

                    MethodInfo methodInfo = ctMethod.getMethodInfo();

                    CodeAttribute codeAttribute = methodInfo.getCodeAttribute();

                    AttributeInfo attribute = codeAttribute.getAttribute(LocalVariableAttribute.tag);

                    LocalVariableAttribute attribute2 = (LocalVariableAttribute) attribute;

                    Map<String, Class<?>> methodParams = new LinkedHashMap<>(); // 需要保证顺序

                    Class<?>[] parameterTypes = declaredMethod.getParameterTypes();

                    if (null != attribute2) {

                        int pos = Modifier.isStatic( ctMethod.getModifiers()) ? 0 : 1;

                        // for (int i = 0; i < declaredMethod.getParameterCount(); i++) {

                        for (int i = 0; i < declaredMethod.getParameterCount(); i++) {

                            String paraName = attribute2.variableName(i + pos);

                            methodParams.put(paraName, parameterTypes[i]);

                        }

                    }

                    mappingMap.put(FULL_URI, new Mapping(newInstance, declaredMethod, methodType, methodParams));

                }

            }

            return mappingMap;

        } catch (Exception exception) {

            exception.printStackTrace();

            return null;

        }

    }

    public static Mapping getRequestMapping(String uri) {

        return allMapping.get(uri);

    }

}

用于存储调用方法的实体类Bean：

package cn.jack2048.framework.model;

import cn.jack2048.framework.constant.MethodType;

import java.lang.reflect.Method;

import java.util.Map;

/**

 * 用于存储 url路径对应的类和方法？

 *

 */

public class Mapping {

    private Object Object; // 需要执行的Controller实例

    private Method method; // 需要执行的Controller实例方法

    private MethodType methodType; // 该方法声明的请求方式

    // key代表方法名称 value表示数据类型 约定要求：不允许使用重载！

    private Map<String, Class<?>> methodParams; // 方法的参数列表信息

    public Mapping(java.lang.Object object, Method method, MethodType methodType, Map<String, Class<?>> methodParams) {

        Object = object;

        this.method = method;

        this.methodType = methodType;

        this.methodParams = methodParams;

    }

    public java.lang.Object getObject() {

        return Object;

    }

    public Method getMethod() {

        return method;

    }

    public MethodType getMethodType() {

        return methodType;

    }

    public Map<String, Class<?>> getMethodParams() {

        return methodParams;

    }

}

核心中枢：派发Servlet

这里处理的东西有点多

1、根据uri匹配寻找对应封装对象

2、执行前的校验，例如路径是否符合，请求方式是否符合

3、封装请求参数（Post参数）

4、为了做参数可扩展，对参数注入写了一大段包装参数的逻辑在其中

5、调用封装对象携带的要执行方法（开发的业务逻辑）

6、执行完成之后对返回结果要处理的信息（字符串走重定向和转发，其他类型一律转JSON返回）

老师还是非常厉害的，最后还特意对数组类型做了处理，支持了逗号分割

我自己写为了精炼表达内容，和老师视频里面的写法就不一样了

package cn.jack2048.framework.servlet;

import cn.jack2048.framework.model.Mapping;

import cn.jack2048.framework.util.ClassUtil;

import cn.jack2048.framework.util.DateConverter;

import cn.jack2048.framework.util.DateUtil;

import cn.jack2048.framework.util.ServletUtil;

import com.alibaba.fastjson.JSON;

import org.apache.commons.beanutils.BeanUtils;

import org.apache.commons.beanutils.ConvertUtils;

import javax.servlet.ServletConfig;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.IOException;

import java.io.PrintWriter;

import java.lang.reflect.Method;

import java.math.BigDecimal;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.*;

import static cn.jack2048.framework.constant.ServletConstants.POST_PARAM_KEY;

public  class DispatchServlet extends HttpServlet {

    // private Class<?> thisClass = this.getClass();

    private static Mapping currentMapping;

    private static Map<String, Mapping> allRequestMapping;

    public static final String REDIRECT = "redirect:";

    public static String dispatchPath = "/WEB-INF/jsp/";

    public static String fileSuffix = ".jsp";

    @Override

    public void init(ServletConfig config) throws ServletException {

        super.init(config);

        // 注册转换器

        ConvertUtils.register(DateConverter.dateConverter, Date.class);

        ConvertUtils.register(DateConverter.dateConverter, LocalDate.class);

        ConvertUtils.register(DateConverter.dateConverter, LocalDateTime.class);

        String cp = config.getInitParameter("controllerPackage");

        String dp = config.getInitParameter("dispatchPath");

        String fs = config.getInitParameter("fileSuffix");

        allRequestMapping = ClassUtil.getAllRequestMapping(null == cp ? "cn.jack2048.controller" : cp);

        if (dp != null && !"".equals(dp)) dispatchPath = dp.trim();

        if (fs != null && !"".equals(fs)) fileSuffix = fs.trim();

    }

    private Object parseToCustomType(Class<?> parameterType, HttpServletRequest request) {

        Object o = null;

        try {

            o = parameterType.newInstance();

            BeanUtils.populate(o, request.getParameterMap());

            BeanUtils.populate(o, (Map) request.getAttribute(POST_PARAM_KEY));

        } catch (Exception e) {

            e.printStackTrace();

        }

        return o;

    }

    /**

     * 对于其他类型参数专门定义一个方法进行处理

     * @param parameterType

     * @return

     */

    private Object processingOtherType(Class<?> parameterType, String paramName, HttpServletRequest request) throws ParseException {

        // 请求对象解析请求参数名称，返回该参数值

        String paramValue = request.getParameter(paramName);

        String typeName = parameterType.getTypeName();

        Map<String, Object> postParam = (Map<String, Object>)request.getAttribute(POST_PARAM_KEY);

        Object paramValueInPost = postParam.get(paramName);

        Class<?> componentType = parameterType.getComponentType(); // 获取组合类型

        String[] values = request.getParameterValues(paramName); // 请求存放的一组值

        boolean isBasicType = ClassUtil.allBasicType.contains(typeName);

        boolean isGeneralReferType = ClassUtil.generalReferType.contains(parameterType);

        boolean isDateType = ClassUtil.dateType.contains(parameterType);

        boolean isComponentType = null != componentType;

        boolean isEmptyValue = (null == paramValue) || "".equals(paramValue);

        boolean isEmptyPostValue = (null == paramValueInPost) || "".equals(paramValueInPost);

        Object param = null;

        // 上述类型全不不匹配 且get参数和post参数也找不到此名称，则执行此自定义引用类型处理

        if (isEmptyValue && isEmptyPostValue && !isBasicType && !isGeneralReferType && ! isDateType && !isComponentType) param = parseToCustomType(parameterType, request);

        if (isEmptyValue && !isEmptyPostValue) { // 如果get参数找不到，但是post参数有，也就是说get有，就不用post

            paramValue = paramValueInPost.toString();

        }

        paramValue = paramName.trim();

        if (isBasicType) {

            // 基本数据类型处理

            param =

                    "int".equals(typeName) ? Integer.valueOf(paramValue).intValue()

                    : "long".equals(typeName) ? Long.valueOf(paramValue).longValue()

                    : "short".equals(typeName) ? Short.valueOf(paramValue).shortValue()

                    : "byte".equals(typeName) ? Byte.valueOf(paramValue).byteValue()

                    : "boolean".equals(typeName) ? Boolean.valueOf(paramValue).booleanValue()

                    : "float".equals(typeName) ? Float.valueOf(paramValue).floatValue()

                    : "double".equals(typeName) ? Double.valueOf(paramValue).doubleValue()

                    : "char".equals(typeName) ? Character.valueOf(paramValue.charAt(0)) : 0;

        }

        else if (isGeneralReferType) {

            // 一般对象类型处理

            param =

                    parameterType == String.class ?  paramValue

                    : parameterType == BigDecimal.class ? BigDecimal.valueOf(Long.valueOf(paramValue))

                    : parameterType == Long.class ? Long.valueOf(paramValue)

                    : parameterType == Integer.class ? Integer.valueOf(paramValue)

                    : parameterType == Double.class ? Double.valueOf(paramValue)

                    : parameterType == Float.class ? Float.valueOf(paramValue)

                    : parameterType == Short.class ? Short.valueOf(paramValue)

                    : parameterType == Byte.class ? Byte.valueOf(paramValue)

                    : parameterType == Boolean.class ? Boolean.valueOf(paramValue)

                    : parameterType == Character.class ? paramValue.charAt(0) : null;

        }

        else if (isDateType) {

            // 日期格式判断

            param =

                    parameterType == java.util.Date.class && DateUtil.PATTEN_DATE.matcher(paramValue).matches() ? DateUtil.parseToDate(paramValue, DateUtil.FORMAT_DATE)

                    : parameterType == java.util.Date.class && DateUtil.PATTEN_DATETIME.matcher(paramValue).matches() ? DateUtil.parseToDate(paramValue, DateUtil.FORMAT_DATETIME)

                    : parameterType == java.time.LocalDate.class && DateUtil.PATTEN_DATE.matcher(paramValue).matches() ? DateUtil.parseToLocalDate(paramValue)

                    : parameterType == java.time.LocalDateTime.class && DateUtil.PATTEN_DATETIME.matcher(paramValue).matches()? DateUtil.parseToLocalDateTime(paramValue)

                    : null;

        }

        // 数组类型，条件 1反射得到的参数是组合类型， 2请求得到的参数组不能空  3参数组个数大于0

        else if (isComponentType && null != values && values.length > 0) {

            int len = values.length;

            // if (! ClassUtil.generalReferType.contains(componentType)) return null;

            if (componentType == String.class) {

                List<String> stringList = new ArrayList<>();

                for (int i = 0; i < len; i++) {

                    String[] split = values[i].split(","); // 需要支持逗号分割处理

                    for (String s : split) stringList.add(s);

                }

                param = stringList.toArray(new String[stringList.size()]);

            }

            else if (componentType == Integer.class) {

                List<Integer> integerList = new ArrayList<>();

                for (int i = 0; i < len; i++) {

                    String[] split = values[i].split(","); // 需要支持逗号分割处理

                    for (String s : split) integerList.add(Integer.valueOf(s));

                }

                param = integerList.toArray(new Integer[integerList.size()]);

            }

            else if (componentType == Long.class) {

                List<Long> longList = new ArrayList<>();

                for (int i = 0; i < len; i++) {

                    String[] split = values[i].split(","); // 需要支持逗号分割处理

                    for (String s : split) longList.add(Long.valueOf(s));

                }

                param = longList.toArray(new Long[longList.size()]);

            }

            else if (componentType == Character.class) {

                List<Character> characterList = new ArrayList<>();

                for (int i = 0; i < len; i++) {

                    String[] split = values[i].split(","); // 需要支持逗号分割处理

                    for (String s : split) characterList.add(Character.valueOf(s.charAt(0)));

                }

                param = characterList.toArray(new Character[characterList.size()]);

            }

            else if (componentType == Double.class) {

                List<Double> doubleList = new ArrayList<>();

                for (int i = 0; i < len; i++) {

                    String[] split = values[i].split(","); // 需要支持逗号分割处理

                    for (String s : split) doubleList.add(Double.valueOf(s));

                }

                param = doubleList.toArray(new Double[doubleList.size()]);

            }

            else if (componentType == Float.class) {

                List<Float> floatList = new ArrayList<>();

                for (int i = 0; i < len; i++) {

                    String[] split = values[i].split(","); // 需要支持逗号分割处理

                    for (String s : split) floatList.add(Float.valueOf(s));

                }

                param = floatList.toArray(new Float[floatList.size()]);

            }

            else if (componentType == BigDecimal.class) {

                List<BigDecimal> bigDecimalList = new ArrayList<>();

                for (int i = 0; i < len; i++) {

                    String[] split = values[i].split(","); // 需要支持逗号分割处理

                    for (String s : split) bigDecimalList.add(BigDecimal.valueOf(Long.valueOf(s)));

                }

                param = bigDecimalList.toArray(new BigDecimal[bigDecimalList.size()]);

            }

            else if (componentType == Short.class) {

                List<Short> shortList = new ArrayList<>();

                for (int i = 0; i < len; i++) {

                    String[] split = values[i].split(","); // 需要支持逗号分割处理

                    for (String s : split) shortList.add(Short.valueOf(s));

                }

                param = shortList.toArray(new Short[shortList.size()]);

            }

            else if (componentType == Byte.class) {

                List<Byte> byteList = new ArrayList<>();

                for (int i = 0; i < len; i++) {

                    String[] split = values[i].split(","); // 需要支持逗号分割处理

                    for (String s : split) byteList.add(Byte.valueOf(s));

                }

                param = byteList.toArray(new Byte[byteList.size()]);

            }

            else if (componentType == Date.class) {

                SimpleDateFormat simpleDateFormat = new SimpleDateFormat(DateUtil.FORMAT_DATE);

                List<Date> dateList = new ArrayList<>();

                for (int i = 0; i < len; i++) {

                    String[] split = values[i].split(","); // 需要支持逗号分割处理

                    for (String s : split) dateList.add(simpleDateFormat.parse(s)); // 这里有异常，让方法抛出去了

                }

                param = dateList.toArray(new Date[dateList.size()]);

            }

            else if (componentType == LocalDate.class) {

                List<LocalDate> localDateList = new ArrayList<>();

                for (int i = 0; i < len; i++) {

                    String[] split = values[i].split(","); // 需要支持逗号分割处理

                    for (String s : split) localDateList.add(LocalDate.parse(s, DateTimeFormatter.ofPattern(DateUtil.FORMAT_DATE)));

                }

                param = localDateList.toArray(new LocalDate[localDateList.size()]);

            }

            else if (componentType == LocalDateTime.class) {

                List<LocalDateTime> localDateTimeList = new ArrayList<>();

                for (int i = 0; i < len; i++) {

                    String[] split = values[i].split(","); // 需要支持逗号分割处理

                    for (String s : split) localDateTimeList.add(LocalDateTime.parse(s, DateTimeFormatter.ofPattern(DateUtil.FORMAT_DATETIME))); // 这里有异常，让方法抛出去了

                }

                param = localDateTimeList.toArray(new LocalDateTime[localDateTimeList.size()]);

            }

        }

        return param;

    }

    @Override

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {

        try {

            System.out.println("doGet detected");

            // 得到此映射的要执行的方法

            Method currentMappingMethod = this.currentMapping.getMethod();

            Map<String, Class<?>> methodParams = this.currentMapping.getMethodParams();

            // 参数处理

            Object result = null;

            int parameterCount = currentMappingMethod.getParameterCount();

            if (0 != parameterCount) { // 如果存在参数

                Object[] paramList = new Object[parameterCount]; // 预备入参容器

                int idx = 0;

                for (String paramName : methodParams.keySet()) {

                    Class<?> paramType = methodParams.get(paramName);

                    paramList[idx ++] =

                            // request对象和response对象方法要求了，就直接丢进去

                            paramType == HttpServletRequest.class ? req

                            : paramType == HttpServletResponse.class ? resp

                            // 其他要做特殊处理

                            : processingOtherType(paramType, paramName, req);

                }

                result = currentMappingMethod.invoke(currentMapping.getObject(), paramList);

            } else { // 无参直接获取

                result = currentMappingMethod.invoke(currentMapping.getObject());

            }

            // 不做参数处理， 约定只有Request & Response 直接调用

            // Object invoke = currentMappingMethod.invoke(currentMapping.getObject(), req, resp);

            // 对结果的处理

            if (null == result) return;

            else if (result instanceof String) {

                String string = (String) result;

                // 先判断是不是重定向

                if (string.startsWith(REDIRECT)) {

                    String path = string.substring(REDIRECT.length());

                    // 再判断是不是外部链接？

                    if( path.startsWith("http")) {

                        resp.sendRedirect(path);

                        return;

                    }

                    resp.sendRedirect(req.getContextPath() + path);

                    return;

                }

                // 默认是做跳转处理 跳转不支持对html静态文件处理乱码

                // req.getRequestDispatcher(string).forward(req, resp);

                req.getRequestDispatcher(this.dispatchPath  + string + this.fileSuffix).forward(req, resp);

                return;

            } else  { // 剩余类型全部转换成JSON字符串

                resp.setContentType("application/json; charset=utf-8;");

                String jsonString = JSON.toJSONString(result);

                PrintWriter writer = resp.getWriter();

                writer.write(jsonString);

                return;

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    @Override

    protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        System.out.println("doHead detected");

        this.doGet(req, resp);

    }

    @Override

    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        System.out.println("doPost detected");

        this.doGet(req, resp);

    }

    @Override

    protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        System.out.println("doPut detected");

        this.doGet(req, resp);

    }

    @Override

    protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        System.out.println("doDelete detected");

        this.doGet(req, resp);

    }

    @Override

    protected void doOptions(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        System.out.println("doOptions detected");

        this.doGet(req, resp);

    }

    @Override

    protected void doTrace(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        System.out.println("doTrace detected");

        this.doGet(req, resp);

    }

    @Override

    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        try {

            // 获取请求的URI

            String requestURI = req.getRequestURI();

            requestURI  = requestURI.replace(req.getContextPath(), "");// 移除工程路径

            // 根据此路径获取对应的映射模型

            Mapping mapping = this.allRequestMapping.get(requestURI);

            resp.setHeader("Content-Type", "text/html; charset=utf-8;"); // 响应中文乱码处理， 请求乱码还没处理，放在过滤器中实现

            // 用户不一定正确请求到Uri, 无法访问则需要走404

             if (null == mapping) {

                 // resp.setStatus(404);

                 PrintWriter writer = resp.getWriter();

                 writer.write("请求的路径不存在：404" + requestURI);

                 writer.close();

                 return;

             }

            this.currentMapping = mapping;

            // 获取来自请求的请求方法

            String methodFromRequest = req.getMethod();

            // 获取映射模型描述的请求方法

            String methodFromMapping = mapping.getMethodType().toString();

            // 获取对应要执行的方法名称

            String methodName = mapping.getMethodType().getType();

            // 如果并不匹配请求方法

            if(!methodFromMapping.equals(methodFromRequest)) {

                Class<BackupServlet> backupServletClass = BackupServlet.class;

                Method declaredMethod = backupServletClass.getDeclaredMethod(methodName, HttpServletRequest.class, HttpServletResponse.class);

                declaredMethod.invoke(backupServletClass.newInstance(), req, resp);

                return;

            }

            // 通过@MethodType注解存储的名称 来调用具体某一个请求方式的方法

            Method doMethod = DispatchServlet.class.getDeclaredMethod(methodName, HttpServletRequest.class, HttpServletResponse.class);

            // doMethod.invoke(this, req, resp);

            Map<String, Object> postParam = ServletUtil.getPostParam(req);

            req.setAttribute(POST_PARAM_KEY, postParam);

            // DispatchServlet instance = DispatchServlet.class.newInstance();

            // instance.currentMapping = mapping;

            doMethod.invoke(this, req, resp);

        } catch (Exception e) {

            e.printStackTrace(); // 控制台输出异常信息

            resp.setStatus(500);

            PrintWriter writer = resp.getWriter();

            writer.println("服务器内部异常：500");

            e.printStackTrace(writer);

            writer.close();

        }

    }

}

这里BackupServlet是因为设置405不匹配请求方式的需要才设置的

因为反射机制不可以调用抽象类，所以写子类来套用

package cn.jack2048.framework.servlet;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.IOException;

public class BackupServlet extends HttpServlet {

    @Override

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        super.doGet(req, resp);

    }

    @Override

    protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        super.doHead(req, resp);

    }

    @Override

    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        super.doPost(req, resp);

    }

    @Override

    protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        super.doPut(req, resp);

    }

    @Override

    protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        super.doDelete(req, resp);

    }

    @Override

    protected void doOptions(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        super.doOptions(req, resp);

    }

    @Override

    protected void doTrace(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        super.doTrace(req, resp);

    }

}

关于自定义类型处理的补充

自定义类型在老师的视频中使用了BeanUtil自动装填参数

但是日期类型是不支持的，这里是我对照的一点写法

package cn.jack2048.framework.util;

import org.apache.commons.beanutils.Converter;

import java.text.SimpleDateFormat;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.Date;

public class DateConverter implements Converter {

    @Override

    public Object convert(Class aClass, Object o) {

        try {

            if (null == o || "".equals(o)) return null;

            if (o instanceof String) {

                String s = o.toString().trim();

                if (aClass.equals(Date.class)) return new SimpleDateFormat(DateUtil.FORMAT_DATE).parse(s);

                else if (aClass.equals(LocalDate.class)) return LocalDate.parse(s, DateTimeFormatter.ofPattern(DateUtil.FORMAT_DATE));

                else if (aClass.equals(LocalDateTime.class)) return LocalDateTime.parse(s, DateTimeFormatter.ofPattern(DateUtil.FORMAT_DATETIME));

            }

            return o;

        } catch (Exception e) {

            e.printStackTrace();

            return null;

        }

    }

    public static DateConverter dateConverter = new DateConverter();

}

日期工具类：

package cn.jack2048.framework.util;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.Date;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class DateUtil {

    // 格式1 yyyy-MM-dd

    public static final String FORMAT_DATE = "yyyy-MM-dd";

    public static final String FORMAT_REGEXP_DATE = "\\d{4}-\\d{2}-\\d{2}";

    public static final Pattern PATTEN_DATE = Pattern.compile(FORMAT_REGEXP_DATE);

    // 格式2 yyyy-MM-dd HH:mm:ss

    public static final String FORMAT_DATETIME = "yyyy-MM-dd HH:mm:ss";

    public static final String FORMAT_REGEXP_DATETIME = "\\d{4}-\\d{2}-\\d{2}\\s{1}\\d{2}:\\d{2}:\\d{2}";

    public static final Pattern PATTEN_DATETIME = Pattern.compile(FORMAT_REGEXP_DATETIME);

    public static Date parseToDate(String timeString, String dateFormat) {

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateFormat);

        try {

            return simpleDateFormat.parse(timeString);

        } catch (ParseException e) {

            e.printStackTrace();

            return null;

        }

    }

    public static LocalDate parseToLocalDate(String timeString) {

        return LocalDate.parse(timeString, DateTimeFormatter.ofPattern(FORMAT_DATE));

    }

    public static LocalDateTime parseToLocalDateTime(String timeString) {

        return LocalDateTime.parse(timeString, DateTimeFormatter.ofPattern(FORMAT_DATETIME));

    }

    public static boolean matchDateFormat(String val) {

        // 编译正则表达式

        Pattern pattern1 = Pattern.compile(FORMAT_REGEXP_DATE);

        Pattern pattern2 = Pattern.compile(FORMAT_REGEXP_DATETIME);

        // 忽略大小写的写法

        // Pattern pat = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);

        Matcher matcher1 = PATTEN_DATE.matcher(val);

        Matcher matcher2 = PATTEN_DATETIME.matcher(val);

        return matcher1.matches() || matcher2.matches();

    }

}

封装Post参数摘要自某个博客，我也忘记了。。。

    /**

     * 从POST请求中获取参数

     * @param request

     * @return

     * @throws Exception

     */

    public static Map<String, Object> getPostParam(HttpServletRequest request) throws Exception {

        // 返回参数

        Map<String, Object> params = new HashMap<>();

        // 获取内容格式

        String contentType = request.getContentType();

        if (null == contentType || "".equals(contentType)) throw new ServletException("没有设置请求头项Content-Type!!!");

        else contentType = contentType.split(";")[0];

        // form表单格式  表单形式可以从 ParameterMap中获取

        if (ServletConstants.CONTENT_TYPE_VALUE_URL_ENCODED2.equalsIgnoreCase(contentType)) {

            // 获取参数

            Map<String, String[]> parameterMap = request.getParameterMap();

            if (parameterMap != null) {

                for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {

                    params.put(entry.getKey(), entry.getValue()[0]);

                }

            }

        }

        // json格式 json格式需要从request的输入流中解析获取

        if (ServletConstants.CONTENT_TYPE_VALUE_JSON2.equalsIgnoreCase(contentType)) {

            // 使用 commons-io中 IOUtils 类快速获取输入流内容

            String paramJson = IOUtils.toString(request.getInputStream(), StandardCharsets.UTF_8);

            Map parseObject = JSON.parseObject(paramJson, Map.class);

            params.putAll(parseObject);

        }

        return params ;

    }

一些写了一点点的常量：

package cn.jack2048.framework.constant;

public interface ServletConstants {

    int HTTP_STATUS_REDIRECT = 302;

    String CONTENT_TYPE_KEY = "Content-Type";

    String CONTENT_TYPE_VALUE_JSON = "application/json;charset=utf-8;";

    String CONTENT_TYPE_VALUE_JSON2 = "application/json";

    String CONTENT_TYPE_VALUE_URL_ENCODED = "application/x-www-form-urlencoded;charset=utf-8;";

    String CONTENT_TYPE_VALUE_URL_ENCODED2 = "application/x-www-form-urlencoded";

    String CONTENT_TYPE_VALUE_FORM_DATA = "multipart/form-data;charset=UTF-8;";

    String REQUEST_METHOD_GET = "GET";

    String REQUEST_METHOD_POST = "POST";

    String REQUEST_METHOD_DELETE = "DELETE";

    String REQUEST_METHOD_PUT = "PUT";

    String POST_PARAM_KEY = "postParam";

    String CHARSET_TYPE_UTF8 = "UTF-8";

    String STATIC_RESOURCE = "svg,png,jpg,jpeg,gif,bmp,css,js";

}

测试的Controller

package cn.jack2048.controller;

import cn.jack2048.framework.annotation.Controller;

import cn.jack2048.framework.annotation.RequestMapping;

import cn.jack2048.framework.constant.MethodType;

import cn.jack2048.framework.constant.ServletConstants;

import cn.jack2048.framework.servlet.DispatchServlet;

import cn.jack2048.model.Account;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.util.Arrays;

import java.util.Date;

import java.util.HashMap;

import java.util.Map;

@Controller

@RequestMapping("/test")

public class TestController {

    /**

     * 成功跳转测试

     * @param request

     * @param response

     */

    // @RequestMethod(MethodType.GET)

    @RequestMapping("/testMethod")

    public void testMethod(HttpServletRequest request, HttpServletResponse response) {

        System.out.println("testMethod");

    }

    /**

     *

     *  POST请求测试

     * @param request

     * @param response

     */

    // @RequestMethod(MethodType.POST)

    @RequestMapping(value = "/testMethod2", methodType = MethodType.POST)

    public void testMethod2(HttpServletRequest request, HttpServletResponse response) {

        System.out.println("testMethod2");

    }

    /**

     * 内部重定向测试

     * http://localhost:8080/mvc-framework/test/innerRedirect

     * @return

     */

    @RequestMapping("/innerRedirect")

    public String innerRedirect() {

        return DispatchServlet.REDIRECT + "/html/index.html";

    }

    /**

     * 外部重定向测试

     * http://localhost:8080/mvc-framework/test/outerRedirect

     * @return

     */

    @RequestMapping("/outerRedirect")

    public String outerRedirect() {

        return DispatchServlet.REDIRECT + "https://www.baidu.com/";

    }

    /**

     * jsp跳转测试

     * http://localhost:8080/mvc-framework/test/dispatchTest

     * @return

     */

    @RequestMapping("/dispatchTest")

    public String dispatchTest() {

        return "index";

    }

    /**

     * 响应JSON数据测试

     * http://localhost:8080/mvc-framework/test/jsonTest

     * @return

     */

    @RequestMapping("/jsonTest")

    public Map<String, Object> jsonTest() {

        Map<String, Object> map = new HashMap<>();

        map.put("status", 100);

        map.put("msg", "ok");

        map.put("data", "json数据响应成功！");

        return map;

    }

    /**

     * 获取参数测试

     * http://localhost:8080/mvc-framework/test/getParamTest

     * @return

     */

    @RequestMapping("/getParamTest")

    public void getParamTest(String a, int b, boolean c) {

        System.out.println(a + " " + b + " " + c);

    }

    /**

     * 日期数据测试

     * http://localhost:8080/mvc-framework/test/getDateTest

     * @return

     */

    @RequestMapping("/getDateTest")

    public void getDateTest(Date date) {

        System.out.println(date);

    }

    /**

     * 自定义对象测试

     * http://localhost:8080/mvc-framework/test/getAccount

     * @return

     */

    @RequestMapping("/getAccount")

    public void getAccount(Account account) {

        System.out.println(account);

    }

    /**

     * 数组类型

     * http://localhost:8080/mvc-framework/test/getArray

     * @return

     */

    @RequestMapping("/getArray")

    public void getArray(Integer[] ints) {

        System.out.println(Arrays.toString(ints));

    }

    /**

     * POST数据处理

     * http://localhost:8080/mvc-framework/test/postParamTest

     * @return

     */

    @RequestMapping("/postParamTest")

    public void postParamTest(HttpServletRequest request) {

        Map<String, Object> params = (Map<String, Object>)request.getAttribute(ServletConstants.POST_PARAM_KEY);

        for (String s : params.keySet()) {

            System.out.println(new StringBuffer(s).append(" -> ").append( params.get(s)));

        }

    }

}

测试的自定义类型：

package cn.jack2048.model;

import java.time.LocalDate;

import java.util.Date;

public class Account {

    private String username;

    private String password;

    private Integer id;

    public Date getBirth() {

        return birth;

    }

    public void setBirth(Date birth) {

        this.birth = birth;

    }

    public Account(String username, String password, Integer id, Date birth) {

        this.username = username;

        this.password = password;

        this.id = id;

        this.birth = birth;

    }

    private Date birth;

    public Account() {

    }

    public Account add(String username, String password, Integer id) {

        return new Account(username, password, id);

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

    public Account(String username, String password, Integer id) {

        this.username = username;

        this.password = password;

        this.id = id;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    @Override

    public String toString() {

        return "Account{" +

                "username='" + username + '\'' +

                ", password='" + password + '\'' +

                ", id=" + id +

                ", birth=" + birth +

                '}';

    }

}

Web.xml配置的信息：

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"

         version="4.0">

    <!--  阻止静态资源被DispatchServlet访问到 提前放行，注意，不要改变这个排放顺序 -->

    <servlet-mapping>

        <servlet-name>default</servlet-name>

        <url-pattern>*.html</url-pattern>

        <url-pattern>*.js</url-pattern>

        <url-pattern>*.css</url-pattern>

        <url-pattern>*.png</url-pattern>

        <url-pattern>*.jpg</url-pattern>

        <url-pattern>*.jpeg</url-pattern>

        <url-pattern>*.gif</url-pattern>

    </servlet-mapping>

    <servlet>

        <servlet-name>DispatchServlet</servlet-name>

        <servlet-class>cn.jack2048.framework.servlet.DispatchServlet</servlet-class>

        <load-on-startup>1</load-on-startup>

    </servlet>

    <servlet-mapping>

        <servlet-name>DispatchServlet</servlet-name>

        <url-pattern>/</url-pattern>

    </servlet-mapping>

    <!-- 请求乱码过滤 -->

    <filter>

        <filter-name>CharacterEncodingFilter</filter-name>

        <filter-class>cn.jack2048.framework.filter.CharacterEncodingFilter</filter-class>

    </filter>

    <filter-mapping>

        <filter-name>CharacterEncodingFilter</filter-name>

        <url-pattern>/**</url-pattern>

    </filter-mapping>

</web-app>

工具类的测试：

import cn.jack2048.framework.model.Mapping;

import cn.jack2048.framework.util.ClassUtil;

import cn.jack2048.framework.util.DateUtil;

import cn.jack2048.model.Account;

import javassist.*;

import javassist.bytecode.AttributeInfo;

import javassist.bytecode.CodeAttribute;

import javassist.bytecode.LocalVariableAttribute;

import javassist.bytecode.MethodInfo;

import org.junit.Test;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.lang.reflect.Parameter;

import java.util.Map;

public class ClassUtilTest {

    /**

     * 根据包名获取指定路径下所有带某一注解的类

     *

     */

    @Test

    public void getAllClassUnderPackagePath() throws InvocationTargetException, IllegalAccessException {

        Map<String, Mapping> allRequestMapping = ClassUtil.getAllRequestMapping("cn.jack2048.controller");

        Mapping mapping = allRequestMapping.get("/test/testMethod2");

        Object object = mapping.getObject();

        Method method = mapping.getMethod();

//        Object invoke = method.invoke(object);

//        System.out.println(mapping.getMethodType());

    }

    @Test

    public void substringTest() {

        final String s = "redirect:";

        String a =  "redirect:asd1ewd2ee3";

        System.out.println(a.substring(s.length()));

    }

    @Test

    public void paramNameTest() {

        Class<Account> accountClass = Account.class;

        Method[] declaredMethods = accountClass.getDeclaredMethods();

        for (Method declaredMethod : declaredMethods) {

            Parameter[] parameters = declaredMethod.getParameters();

            System.out.print(declaredMethod.getName() + " : ");

            for (Parameter parameter : parameters) {

                String name = parameter.getName(); // JDK编译会缩减标识符号名称 1编译配置不简化标识符， 2使用第三方组件实现

                Class<?> type = parameter.getType();

                System.out.print(type.getName() + " : " + name + ", ");

            }

            System.out.println(" \n");

        }

    }

    @Test

    public void paramNameTest2() throws Exception {

        Class<Account> accountClass = Account.class;

        Method addMethod = accountClass.getDeclaredMethod("add", String.class, String.class, Integer.class);

        ClassPool classPool = ClassPool.getDefault();

        ClassPath classPath = classPool.insertClassPath(new ClassClassPath(accountClass));

        CtMethod ctMethod = classPool.getMethod(accountClass.getName(), addMethod.getName());

        MethodInfo methodInfo = ctMethod.getMethodInfo();

        CodeAttribute codeAttribute = methodInfo.getCodeAttribute();

        AttributeInfo attribute = codeAttribute.getAttribute(LocalVariableAttribute.tag);

        LocalVariableAttribute attribute2 = (LocalVariableAttribute) attribute;

        if (null != attribute2) {

            int pos = Modifier.isStatic( ctMethod.getModifiers()) ? 0 : 1;

            for (int i = 0; i < addMethod.getParameterCount(); i++) {

                String paraName = attribute2.variableName(i + pos);

                System.out.println(paraName);

            }

        }

    }

    @Test

    public void dateTest() {

        String time = "2021-09-31 16:24:33";

        String time2 = "2021-09-31";

        System.out.println( DateUtil.matchDateFormat(time));

        System.out.println( DateUtil.matchDateFormat(time2));

    }

}

写到这里发现还有一些问题：

1、老师视频里面是没有处理html跳转的，结果发现html跳转是乱码的

原因是因为静态资源已经交给defaultServlet来处理放行的，也就是Tomcat来处理

解决办法是给defaultServlet再配置一个字符编码参数

2、写的是一个单体服务的架构，所以，不存在跨域访问的情况，但是如果要跨域肯定是需要设置的

使用过滤器再实现跨域访问的放行

package cn.dzz.framework.web.filter;

import javax.servlet.*;

import javax.servlet.http.HttpServletResponse;

import java.io.IOException;

public class CorsFilter implements Filter {

    @Override

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        // 强转HttpServletResponse对象使用

        HttpServletResponse resp = (HttpServletResponse) servletResponse;

        // resp.setContentType("text/html;charset=UTF-8"); // 一些请求是响应数据做接口调用，不应该写死

        //禁用缓存，确保网页信息是最新数据

        resp.setHeader("Pragma","No-cache");

        resp.setHeader("Cache-Control","no-cache");

        // 添加参数，允许任意domain访问

        resp.setHeader("Access-Control-Allow-Origin", "*");

        resp.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, HEAD, DELETE, PUT");

        resp.setHeader("Access-Control-Max-Age", "3600");

        resp.setHeader("Access-Control-Allow-Headers",

                "X-Requested-With, Content-Type, Authorization, Accept, Origin, User-Agent, Content-Range, Content-Disposition, Content-Description");

        resp.setDateHeader("Expires", -10);

        filterChain.doFilter(servletRequest, resp);

    }

}

对web.xml的配置

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"

         version="4.0">

    <!--  阻止静态资源被DispatchServlet访问到 提前放行，注意，不要改变这个排放顺序 -->

    <servlet>

        <servlet-name>default</servlet-name> <!-- 防止静态资源乱码配置 -->

        <init-param>

            <param-name>fileEncoding</param-name>

            <param-value>UTF-8</param-value>

        </init-param>

    </servlet>

    <servlet-mapping>

        <servlet-name>default</servlet-name>

        <url-pattern>*.html</url-pattern>

        <url-pattern>*.js</url-pattern>

        <url-pattern>*.css</url-pattern>

        <url-pattern>*.png</url-pattern>

        <url-pattern>*.jpg</url-pattern>

        <url-pattern>*.jpeg</url-pattern>

        <url-pattern>*.gif</url-pattern>

    </servlet-mapping>

    <welcome-file-list>

        <welcome-file>index.jsp</welcome-file>

    </welcome-file-list>

    <servlet>

        <servlet-name>DispatchServlet</servlet-name>

        <servlet-class>cn.dzz.framework.web.servlet.DispatchServlet</servlet-class>

        <init-param>

            <param-name>controllerPackage</param-name>

            <param-value>cn.dzz.controller</param-value>

        </init-param>

        <load-on-startup>1</load-on-startup>

    </servlet>

    <servlet-mapping>

        <servlet-name>DispatchServlet</servlet-name>

        <url-pattern>/</url-pattern>

    </servlet-mapping>

    <filter>

        <filter-name>CorsFilter</filter-name>

        <filter-class>cn.dzz.framework.web.filter.CorsFilter</filter-class>

    </filter>

    <filter-mapping>

        <filter-name>CorsFilter</filter-name>

        <url-pattern>/**</url-pattern>

        <url-pattern>/*</url-pattern>

        <url-pattern>/</url-pattern>

    </filter-mapping>

    <!-- 请求乱码过滤 -->

    <filter>

        <filter-name>CharacterEncodingFilter</filter-name>

        <filter-class>cn.dzz.framework.web.filter.CharacterEncodingFilter</filter-class>

    </filter>

    <filter-mapping>

        <filter-name>CharacterEncodingFilter</filter-name>

        <url-pattern>/**</url-pattern>

        <url-pattern>/*</url-pattern>

        <url-pattern>/</url-pattern>

    </filter-mapping>

</web-app>