如何自己构建一个类似springmvc的框架（springmvc原理理解）

构建一个类似springmvc的框架

大致结构:

• DispatcherServlet,接收所有请求，然后进行分发
• 自定义Controller注解,RequestMapping注解
• 设置ViewResolver 视图解析器

大致步骤:

1. 把controller和注解进行关联，可以使用url找到对应的方法
2. 解析springmvc.xml进行扫包
3. 把类和url关联到一起

 

1.自定义controller注解类

/*
自定义的controller注解类
 */
//target的作用是声明该注解可以标记类还是方法还是方法还是属性的，Type代表该注解作用在类上面
//Retention标记该注解什么时候生效，runtime代表运行时生效
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface HainaController {
    //这其实相当于是一个value属性，用来给controller类设置url
    String value() default "";
}

可以通过自己设定的注解，来设置controller类，实现在项目中通过url能够访问到这个类

2.自定义requestmapping注解类

//可以用在类上，也可以用在方法上
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface HainaRequestMapping {
    String value() default "";
}

通过自己设定的注解，这个注解注释的方法，能够在项目中通过url直接调用该方法

 

3.设置视图解析类

/*
 *视图解析器
 */
public class HainaViewResolver {

    private String prefix;
    private String suffix;

    public String jspMapping (String value){
        //给视图拼接前缀和后缀
        return this.prefix + value + this.suffix;
    }

    public String getPrefix() {
        return prefix;
    }

    public void setPrefix(String prefix) {
        this.prefix = prefix;
    }

    public String getSuffix() {
        return suffix;
    }

    public void setSuffix(String suffix) {
        this.suffix = suffix;
    }
}

 

将url中的方法字段传入视图解析器，就可以调用相应的方法

 

4.自定义分发器DispatcherServlet

/**
 * 自定义的分发器
 */
public class HainaDispatcherServlet extends HttpServlet {
    //用来保存url和controller对象的集合
    private Map<String, Object> controllerMap = new HashMap<>();
    //用来保存url和方法之间的映射
    private Map<String, Method> requestMappingMap = new HashMap<>();

    private HainaViewResolver resolver = new HainaViewResolver();

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String uri = req.getRequestURI();//获取uri
        System.out.println(uri);
        String controllerUri = uri.split("/")[2];//获取controller
        System.out.println("controller:" + controllerUri);
        String methodUri = uri.split("/")[3];//获取方法名
        System.out.println("method:" + methodUri);
        //通过路径找到对应的controller对象和方法对象
        Object obj = controllerMap.get(controllerUri);
        Method method = requestMappingMap.get(methodUri);

        try {
            //使用反射，调用对应的方法，返回值实际就是页面的名字
            String result = (String) method.invoke(obj);
            //把视图名拼接完整
            String url = resolver.jspMapping(result);
            //使用请求转发的形式跳转到对应的视图上
            req.getRequestDispatcher(url).forward(req, resp);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //初始化
    @Override
    public void init(ServletConfig config) throws ServletException {
        //1.扫描controller，创建对应的实例对象，存入自定义容器中
        scanController(config);
        //2.初始化url和方法映射的容器
        initRequestMapping();

        resolver.setPrefix("/");
        resolver.setSuffix(".jsp");
    }

    //解析springmvc.xml文件，扫描文件中配置的包名中的使用了HainaController注解标注的类
    private void scanController(ServletConfig config) {
        SAXReader reader = new SAXReader();
        //这里其实是在读取web.xml文件的配置，通过web.xml文件，读取到对应springmvc
        //文件的名称，然后拼接好完整路径
        String path = config.getServletContext().getRealPath("")
                + "\\WEB-INF\\classes\\"
                + config.getInitParameter("contextConfigLocation");
        System.out.println("path:" + path);
        try {
            Document root = reader.read(path);
            Element rootElement = root.getRootElement();

            Iterator it = rootElement.elementIterator();
            while (it.hasNext()) {
                Element next = (Element) it.next();
                if ("component-scan".equals(next.getName())) {
                    //获取要扫描的包名
                    String packageName = next.attributeValue("base-package");

                    //有了包名之后，我们就需要根据包名，找到该包下的所有类名，然后根据类名
                    //创建出对应的class对象
                    List<String> list = getClassNameList(packageName);
                    for (String str : list) {
                        //使用类反射，将类名加载进内存，转换成class类型对象
                        Class clazz = Class.forName(str);
                        //判断是否使用了HainaController注解标注
                        if (clazz.isAnnotationPresent(HainaController.class)) {
                            //获取当前类上标注的注解，获取到之后，我们可以获取该注解中配置的路径
                            HainaController annotation = (HainaController) clazz.getAnnotation(HainaController.class);
                            //路径都用/开头，所以在获取的时候，我们把斜杠过滤掉
                            String value = annotation.value().substring(1);

                            //这样，路径以及它对应的类就都有了，我们可以把路径作为key，类的对象作为value，存入map中
                            //方便之后我们使用url来找对应的类和方法
                            controllerMap.put(value, clazz.newInstance());
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("controllerMap:" + controllerMap);
    }

    //获取所有类名
    public List<String> getClassNameList(String packageName) {
        String packagePath = packageName.replace(".", "/");
        //获取类加载器，通过类加载器去找文件路径
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        URL url = loader.getResource(packagePath);//获取文件的路径
        List<String> result = new ArrayList<>();
        if (url != null) {
            File file = new File(url.getPath());
            //获取当前包下的所有文件
            File[] files = file.listFiles();
            for (File child : files) {
                //拼接完整的包名加类名
                String className = packageName + "." + child.getName()
                        .replace(".class", "");
                result.add(className);
            }
        }
        System.out.println(result);
        return result;
    }

    //初始化url和方法的映射关系
    private void initRequestMapping() {
        //遍历controllerMap，获取里面的所有key
        for (String str : controllerMap.keySet()) {
            //通过key，取出对应的值，然后调用getclass方法，把对象转换成class类型
            //因为只有class类型的对象，才可以获取该类里的所有方法
            Class<?> clazz = controllerMap.get(str).getClass();

            Method[] methods = clazz.getMethods();
            //遍历每个方法，看看方法有没有被requestmapping注解标注
            for (Method method : methods) {
                if (method.isAnnotationPresent(HainaRequestMapping.class)) {
                    //获取当前方法的requestMapping注解对象
                    HainaRequestMapping annotation = method.getAnnotation(HainaRequestMapping.class);
                    System.out.println("annotation:" + annotation);
                    String value = annotation.value().substring(1);
                    //把url和方法对象，添加到map中
                    requestMappingMap.put(value, method);
                }
            }
        }
        System.out.println("requestMappingMap:" + requestMappingMap);
    }
}

 

 springmvc本质上就是通过一个servlet类来接收所有的请求，并且将这些请求分发到指定注解的controller类中，再调用controller类中指定注解的方法。

 

5.springmvc.xml文件的配置

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
    <component-scan base-package="com.haina.springmvc"></component-scan>

    <bean class="com.haina.springmvc.HainaViewResolver">
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
</beans>

 

6.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">
    
    <servlet>
        <servlet-name>myDispatcher</servlet-name>
        <servlet-class>com.haina.springmvc.HainaDispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>springmvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>myDispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

 

7.测试，创建testcontroller类进行测试

@HainaController("/haina")
public class TestController {

    @HainaRequestMapping("/test")
    public String abc(){
        System.out.println("come in controller");
        return "test";
    }
}

 

测试结果：

 

 

 成功访问controller类，并且调用了abc方法