JavaWeb-MVC

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

所以问题就来了：一个新的类 到底往哪个目录下的哪个文件夹里写？ 此时解决办法就是：需要一个模式去规范，到底哪个类该往哪里写。

MVC设计模式

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

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

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

 

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

一个Java类 ，满足以下要求，则可称为一个JavaBean

1. public修饰的类，提供public 无参构造方法
2. 所有属性 都是private
3. 提供getter和setter方法

 

从使用层面来看，JavaBean分为2大类：

1. 封装业务逻辑的JavaBean(eg:LoginDao.java 封装了登录逻辑)
2. 封装数据的JavaBean(实体类：eg：Student.java Vadio.java 。往往对应于数据库中的一张表，即数据库中有个Student表，项目中就有个Student.java类)通常:表名=类名，列名=属性名

JavaBean是一个可以重复使用的组件，通过编写一个组件来实现某种通用功能，“一次编写、任何地方执行、任何地方重     用”。

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

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

 

三层架构

三层架构 通常意义上的三层架构就是将整个业务应用划分为：表现层（UI）、业务逻辑层（BLL）、数据访问层（DAL）。区分层次的目的即为了“高内聚，低耦合”的思想。

1、表现层（UI）：通俗讲就是展现给用户的界面，即用户在使用一个系统的时候他的所见所得。 jsp/html

2、业务逻辑层（BLL）：针对具体问题的操作，也可以说是对数据层的操作，对数据业务逻辑处理。servlet,service

3、数据访问层（DAL）：该层所做事务直接操作数据库，针对数据的增添、删除、修改、更新、查找等。dao

 

表现层实现的代表作品是Struts,springmvc框架， 业务层实现的代表作品是Spring，

持久层实现的代表作品是Hibernate,mybatis。

层就相当于一个黑盒子，我们不用知道它内部怎么实现，只需要知道如何去调用它就行了。每层只与上下相邻的两   层打交道。当一层内部由于技术变迁发生变化时，只要接口不变，其他层不用做任何改变。分层之后灵活性提高，   也便于团队分工开发。

 

三层架构和MVC的区别与联系

三层架构是基于业务逻辑来分的，而MVC是基于页面来分的。

三层架构的分层模式是典型的上下关系，上层依赖于下层。但MVC作为表现模式是不存在上下关系的，而是相互协作关系。即使将MVC当作架构模式，也不是分层模式。MVC和三层架构基本没有可比性，是应用于不同领域的技术。

 

编写一个MVC框架

传统的方式的弊端：几乎每一个功能都要新写一个Servlet。

我们想要达到的一个效果就是，写一个Servlet，里面就包含了我们需要的那些功能。这样也能提前建立我们对框架的认知。

基本流程：Servlet->映射器->调用方法->返回结果

当用户请求Servlet的时候，会先去HandlerMapping去找方法。

DispatcherServlet

public class DispatcherServlet extends javax.servlet.http.HttpServlet {
    @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 {
        //1.    获取用户请求的uri   /xx.do
        String uri = req.getRequestURI();
        HandlerMapping.MVCMapping mapping = HandlerMapping.get(uri);
        if( mapping == null){
            resp.sendError(404,"MVC：映射地址不存在："+uri);
            return;
        }
        Object obj = mapping.getObj();
        Method method = mapping.getMethod();
        Object result = null;
        try {
            result = method.invoke(obj, req, resp);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        switch (mapping.getType()){
            case TEXT:
                resp.getWriter().write((String)result);
                break;
            case VIEW:
                resp.sendRedirect((String)result);
                break;
        }
    }
}

HandlerMapping

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


    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 mapping = new MVCMapping(obj,m,ResponseType.TEXT);
                                Object o = data.put(((ResponseBody) annotation).value(),mapping);
                                if(o != null){
                                    //存在了重复的请求地址
                                    throw new RuntimeException("请求地址重复："+((ResponseBody) annotation).value());
                                }
                            }else if(annotation instanceof ResponseView){
                                //说明此方法，用于返回界面给客户端
                                MVCMapping mapping = new MVCMapping(obj,m,ResponseType.VIEW);
                                Object o =  data.put(((ResponseView) annotation).value(),mapping);
                                if(o != null){
                                    //存在了重复的请求地址
                                    throw new RuntimeException("请求地址重复："+((ResponseView) annotation).value());
                                }
                            }
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 映射对象，每一个对象封装了一个方法，用于处理请求
     */
    public static class MVCMapping{
        private Object obj;
        private Method method;
        private ResponseType type;

        public MVCMapping() {
        }

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

        public Object getObj() {
            return obj;
        }

        public void setObj(Object obj) {
            this.obj = obj;
        }

        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;
        }
    }
}

ResponseBody

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

ResponseView

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

ResponseType

public enum ResponseType {
    TEXT,VIEW;
}

在src目录下放一个application.properties配置文件

#配置每一个处理请求的类
#每一个类中包含0-n个用于处理请求的方法
a=com.test.UserController
b=com.test2.xxxController

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>DispatcherServlet</servlet-name>
        <servlet-class>com.vv.mvc.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contentConfigLocation</param-name>
            <param-value>application.properties</param-value>
        </init-param>
        <load-on-startup>0</load-on-startup><!--当服务启动的时候就加载Servlet-->
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>*.do</url-pattern><!--所有以.do结尾的请求-->
    </servlet-mapping>
</web-app>

请求举例：