javaWeb------MVC设计模式。看完之后手撕MVC

JavaWEB MVC

写Java Web项⽬时会发现，⼀个中型或者⼤型项⽬ 随着代码的增多，会发现：代码既可以写在src⽬录下，也可以写在WebContent⽬录下。src下可以建很多包 ，WebContent下可以建很多⽂件夹。

所以问题就来了：⼀个新的类 到底往哪个⽬录下的哪个⽂件夹⾥写？

此时解决办法就是：需要⼀个模式去规范，到底哪个类该往哪⾥写。

MVC设计模式

在Web MVC模式下，模型⽆法主动推数据给视图，如果⽤户想要视图更新，需要再发送⼀次请求（即请求-响应模型）。

M：(Model) 模型 : 应⽤程序的核⼼功能，管理这个模块中⽤的数据和值（bean,dao）；

JavaBeans :是Java中⼀种特殊的类（换⾔之：JavaBean就是⼀个Java类）.

⼀个Java类 ，满⾜以下要求，则可称为⼀个JavaBean

a. public修饰的类，提供public ⽆参构造⽅法

b. 所有属性 都是private

C. 提供getter和setter⽅法

从使⽤层⾯来看，JavaBean分为2⼤类：

a. 封装业务逻辑的JavaBean(eg:LoginDao.java 封装了登录逻辑)

b. 封装数据的JavaBean(实体类：eg：Student.java Vadio.java 。往往对应于数据库中的⼀张表，即数据库中有个Student表，项⽬中就有个Student.java类)通常:表名=类名，列名=属性名

JavaBean是⼀个可以重复使⽤的组件，通过编写⼀个组件来实现某种通⽤功能，“⼀次编写、任何地⽅执

⾏、任何地⽅重⽤”。

V：(View )视图: 视图提供模型的展示，管理模型如何显示给⽤户，它是应⽤程序的外观；（jsp/html）

C：(Controller)控制器: 对⽤户的输⼊做出反应，管理⽤户和视图的交互，是连接模型和视图的枢纽。（servlet/service）

MVC⽤于将web（UI）层进⾏职责解耦

Web MVC中的M(模型)-V(视图)-C(控制器)概念和标准MVC概念⼀样，我们再看⼀下Web MVC标准架构，如下图所示：

代码来咯！！！！！！

当服务器启动的时候，dispatcherservlet就会加载配置文件，会在handlermapping里存储一堆的方法，当用户去请求dispatcherservlet的时候首先去handlermapping去找有没有用来处理这个请求的方法，如果没有抛出404，如果有的话就去调用这个方法。方法的话一定是加了自己定义的注解才会被收录进去。

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>DispatcherServlet</servlet-name>
        <servlet-class>com.zx.mvc.DispatcherServlet</servlet-class>
        <!--        当servlet启动时就会加载这个配置文件-->
        <init-param>
            <param-name>contentConfigLocation</param-name>
            <param-value>application.properties</param-value>
        </init-param>
        <!--        当服务器启动时就会加载这个servlet-->
        <load-on-startup>0</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <!--        所有以*.do结尾的请求都会走DispatcherServlet-->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

注解

package com.zx.mvc;

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
/**
 * 作用：被此注解添加的方法，用于处理请求
 * 返回的内容会以文字形式返回到客户端
 */
public @interface ResponseBody {
    String value();
}

package com.zx.mvc;

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
/**
 * 作用：被此注解添加的方法，用于处理请求
 * 返回的内容会直接重定向到页面
 */
public @interface ResponseView {
    String value();
}

枚举

package com.zx.mvc;

public enum ResponseType {
    //响应的类型
    TEXT,VIEW;
}

处理类

package com.zx.mvc;

import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * 映射器（包含了大量的网址与方法的对应关系）
 */
public class HandlerMapping {
    //用于MVC映射的对象
    private static Map<String, MVCMapping> data = new HashMap<>();

    /**
     * 用于获取请求所对应的方法
     *
     * @return
     */
    public static MVCMapping get(String uri) {
        return data.get(uri);
    }

    /**
     * 加载方法
     *
     * @param is
     */
    public static void load(InputStream is) {
        Properties ppt = new Properties();
        //加载配置文件
        try {
            ppt.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //取出配置文件里所有的值，是一个个的类
        Collection<Object> values = ppt.values();
        //循环遍历所有的值
        for (Object cla : values) {
            //转换为字符串，拿到类的名称对其进行反射的处理
            String className = (String) cla;
            //通过反射的方式创建对象,再去获取里边每一个方法
            try {
                //加载配置文件中描述的每一个类
                Class c = Class.forName(className);
                //通过无参的构造方法去创建对象，通过配置文件找到类型，把这个类型对象进行创建
                Object obj = c.getConstructor().newInstance();
                //获取类中所有的方法
                Method[] methods = c.getMethods();
                for (Method m : methods) {
                    //获取方法中的注解
                    Annotation[] as = m.getAnnotations();
                    if (as != null) {
                        //遍历单个方法中的注解
                        for (Annotation annotation : as) {
                            if (annotation instanceof ResponseBody) {
                                //说明此方法用于返回字符串给客户端
                                MVCMapping mvcMapping = new MVCMapping(obj, m, ResponseType.TEXT);
                                //键:注解的值，值:用于MVC映射的对象
                                Object o = data.put(((ResponseBody) annotation).value(), mvcMapping);
                                if (o != null) {
                                    //说明存在了重复的请求地址
                                    throw new RuntimeException("请求地址重复"+((ResponseBody) annotation).value());
                                }
                            } else if (annotation instanceof ResponseView) {
                                //说明此方法用于返回视图界面给客户端
                                MVCMapping mvcMapping = new MVCMapping(obj, m, ResponseType.VIEW);
                                //键:注解的值，值:用于MVC映射的对象
                                Object o = data.put(((ResponseView) annotation).value(), mvcMapping);
                                if (o != null) {
                                    //说明存在了重复的请求地址
                                    throw new RuntimeException("请求地址重复"+((ResponseView) annotation).value());
                                }
                            }
                        }
                    }

                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 用于MVC映射的对象
     * 每一个对象封装了一个方法处理请求
     */
    public static class MVCMapping {
        //包含对象和方法，枚举
        private Object object;
        private Method method;
        private ResponseType type;

        public MVCMapping(Object object, Method method, ResponseType type) {
            this.object = object;
            this.method = method;
            this.type = type;
        }

        public MVCMapping() {
        }

        public Object getObject() {
            return object;
        }

        public void setObject(Object object) {
            this.object = object;
        }

        public Method getMethod() {
            return method;
        }

        public void setMethod(Method method) {
            this.method = method;
        }

        public ResponseType getType() {
            return type;
        }

        public void setType(ResponseType type) {
            this.type = type;
        }
    }
}

servlet

package com.zx.mvc;

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.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

public class DispatcherServlet extends HttpServlet {
    /**
     * 初始化方法
     *
     * @param config
     * @throws ServletException
     */
    @Override
    public void init(ServletConfig config) throws ServletException {
        //获取初始化文件
        String path = config.getInitParameter("contentConfigLocation");
        //加载配置文件,获得一个输入流
        InputStream is = DispatcherServlet.class.getClassLoader().getResourceAsStream(path);
        //使用映射器加载加载配置文件
        HandlerMapping.load(is);
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取用户请求的uri 访问的地址
        String requestURI = req.getRequestURI();
        //得到一个MVCMapping对象
        HandlerMapping.MVCMapping mvcMapping = HandlerMapping.get(requestURI);
        if (mvcMapping == null) {
            resp.sendError(404, "自定义MVC:映射地址不存在" + requestURI);
            return;
        }
        Object object = mvcMapping.getObject();
        Method method = mvcMapping.getMethod();
        Object result = null;
        try {
            result = method.invoke(object, req, resp);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        switch (mvcMapping.getType()) {
            case TEXT:
                resp.getWriter().write((String) result);
                break;
            case VIEW:
                resp.sendRedirect((String) result);
                break;
        }
    }
}