Spring学习（三）：MVC

一、什么是MVC

MVC（Model-View-Controller）是一种软件设计模式，用于组织和管理应用程序的代码结构。它将应用程序分为三个主要部分，即模型（Model）、视图（View）和控制器（Controller），每个部分都有特定的职责和功能。

以下是 MVC 模式中各个组成部分的概述：

• 模型（Model）：模型代表应用程序的数据和业务逻辑。它负责处理数据的读取、存储、验证和处理，以及执行应用程序的核心业务逻辑。模型通常是独立于用户界面的，可以被多个视图和控制器共享。
• 视图（View）：视图是用户界面的表示，负责展示数据给用户，并接收用户的输入。它通常是模型的可视化表现形式，负责将模型的数据呈现给用户，并根据用户的操作更新界面。视图不处理业务逻辑，只负责显示和接收用户的操作。
• 控制器（Controller）：控制器是模型和视图之间的协调者，负责处理用户的输入、更新模型的数据以及更新视图的显示。它接收用户的操作请求，调用相应的模型方法进行数据处理和更新，并在必要时更新视图以反映最新的数据。

MVC 的核心思想是将应用程序的逻辑和数据分离，使其更易于理解、扩展和维护。通过将应用程序的不同部分分离，MVC 模式提供了更好的代码组织和可重用性。在 MVC 中，用户与视图进行交互，视图通过控制器将用户的操作转发给模型进行处理，模型根据业务逻辑进行数据处理，然后通知视图进行更新。这种分离和协作的方式使得应用程序的不同部分能够独立地开发和测试，同时也提高了代码的可维护性和重用性。

举例来说，当浏览器发送一个查询请求，要求查询用户信息时，Controller通过jdbc调用数据库方法获得对应的User对象，然后将user对象传递给user.jsp渲染，并发送回浏览器。

---

二、Servlet

Servlet 是 Java 编程语言中的一种特殊类，用于处理 Web 应用程序中的动态内容和 HTTP 请求。Servlet 提供了一种基于服务器的编程模型，允许开发者通过编写 Java 代码来处理客户端的请求并生成相应的响应。

实际上Servlet就是一个API接口，它需要底层的Web服务器实现HTTP协议的解析处理，但也以此将底层解析代码对开发者屏蔽。使用者只需要关注上层的api接口的调用即可。我们使用Servlet API编写自己的Servlet来处理HTTP请求，Web服务器实现Servlet API接口，实现底层功能。

用法关键在于继承HttpServlet，覆写doPost, doGet等方法，并调用业务方法，返回HttpResponse。

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

// WebServlet注解表示这是一个Servlet，并映射到地址/:
@WebServlet(urlPatterns = "/")
public class UserServlet extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String action = request.getParameter("action");

        if (action != null) {
            switch (action) {
                case "register":
                    handleRegistration(request, response);
                    break;
                case "login":
                    handleLogin(request, response);
                    break;
                default:
                    response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Invalid action");
            }
        } else {
            response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Action parameter is missing");
        }
    }

    private void handleRegistration(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 处理用户注册逻辑
        // 从 request 中获取用户提交的注册信息
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        // 执行用户注册操作，例如将用户信息存储到数据库中

        // 返回注册成功的响应
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("");
        out.println("
Registration successful
");
        out.println("
Welcome, " + username + "!
");
        out.println("");
    }

    private void handleLogin(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 处理用户登录逻辑
        // 从 request 中获取用户提交的登录信息
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        // 执行用户登录验证操作，例如从数据库中检查用户名和密码是否匹配

        // 返回登录成功或失败的响应
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("");
        if (username.equals("admin") && password.equals("password")) {
            out.println("
Login successful
");
            out.println("
Welcome back, " + username + "!
");
        } else {
            out.println("
Login failed
");
            out.println("
Invalid username or password.
");
        }
        out.println("");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

UserServlet 类继承了 HttpServlet 并重写了 doPost 方法来处理客户端的 POST 请求。根据请求中的 action 参数的不同值，分别调用 handleRegistration 和 handleLogin 方法来处理用户注册和登录逻辑。

要将Servlet部署到支持Servlet api的web服务器（Servlet容器如 Apache Tomcat），你需要将编译后的类文件（例如 UserServlet.class）放置在正确的目录结构中，并在 web.xml 文件（位于 WEB-INF 目录下）中进行配置。

具体配置参考 lxf Servlet教程

---

三、MVC框架原理和实现

参考lxf mvc高级开发
在使用Servlet的案例中，我们可以注意到，一个Servlet只能处理一个url下的Get Post请求，例如如果一个 Servlet 映射到路径 /users，它将处理所有以 /users 开头的请求路径。

如果有一个MVC框架，能够通过一个底层的DispatchServlet，存储所有的url到方法的映射，那就不需要重复继承和编写Servlet相关代码，上层被映射的方法可以组织成一个纯粹的Java类，只需要关注control部分的业务逻辑即可

public class UserController {
    @GetMapping("/signin")
    public ModelAndView signin() {
        ...
    }

    @PostMapping("/signin")
    public ModelAndView doSignin(SignInBean bean) {
        ...
    }

    @GetMapping("/signout")
    public ModelAndView signout(HttpSession session) {
        ...
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

以以上代码为例，如果Servlet可以直接将doGet中与业务逻辑无关的内容实现，把Controller业务逻辑需要的功能抽象为新的类，返回值再通过ModelAndView传送给Servlet，由Servlet交给底层渲染引擎得到View，就可以使代码更加简洁，扩展性更强。

MVC框架原理：

我们需要在MVC框架中创建一个接收所有请求的Servlet，通常我们把它命名为DispatcherServlet，它总是映射到/，然后，根据不同的Controller的方法定义的@Get或@Post的Path决定调用哪个方法，最后，获得方法返回的ModelAndView后，渲染模板，写入HttpServletResponse，即完成了整个MVC的处理。

结构如下

DispatchServlet编写

@WebServlet(urlPatterns = "/")
public class DispatcherServlet extends HttpServlet {
    private Map<String, GetDispatcher> getMappings = new HashMap<>(); //需要存储请求路径到某个具体方法的映射
    private Map<String, PostDispatcher> postMappings = new HashMap<>();
}

//处理一个GET请求是通过GetDispatcher对象完成的，它需要如下信息
class GetDispatcher {
    Object instance; // Controller实例
    Method method; // Controller方法
    String[] parameterNames; // 方法参数名称
    Class<?>[] parameterClasses; // 方法参数类型
}
1
2
3
4
5
6
7
8
9
10
11
12
13

使用invoke处理真正的请求

class GetDispatcher {
    ...
    public ModelAndView invoke(HttpServletRequest request, HttpServletResponse response) {
        Object[] arguments = new Object[parameterClasses.length];
        for (int i = 0; i < parameterClasses.length; i++) {
            String parameterName = parameterNames[i];
            Class<?> parameterClass = parameterClasses[i];
            if (parameterClass == HttpServletRequest.class) {
                arguments[i] = request;
            } else if (parameterClass == HttpServletResponse.class) {
                arguments[i] = response;
            } else if (parameterClass == HttpSession.class) {
                arguments[i] = request.getSession();
            } else if (parameterClass == int.class) {
                arguments[i] = Integer.valueOf(getOrDefault(request, parameterName, "0"));
            } else if (parameterClass == long.class) {
                arguments[i] = Long.valueOf(getOrDefault(request, parameterName, "0"));
            } else if (parameterClass == boolean.class) {
                arguments[i] = Boolean.valueOf(getOrDefault(request, parameterName, "false"));
            } else if (parameterClass == String.class) {
                arguments[i] = getOrDefault(request, parameterName, "");
            } else {
                throw new RuntimeException("Missing handler for type: " + parameterClass);
            }
        }
        return (ModelAndView) this.method.invoke(this.instance, arguments);
    }

    private String getOrDefault(HttpServletRequest request, String name, String defaultValue) {
        String s = request.getParameter(name);
        return s == null ? defaultValue : s;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

Dispatch核心流程

public class DispatcherServlet extends HttpServlet {
    ...
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");
        resp.setCharacterEncoding("UTF-8");
        String path = req.getRequestURI().substring(req.getContextPath().length());
        // 根据路径查找GetDispatcher:
        GetDispatcher dispatcher = this.getMappings.get(path);
        if (dispatcher == null) {
            // 未找到返回404:
            resp.sendError(404);
            return;
        }
        // 调用Controller方法获得返回值:
        ModelAndView mv = dispatcher.invoke(req, resp);
        // 允许返回null:
        if (mv == null) {
            return;
        }
        // 允许返回`redirect:`开头的view表示重定向:
        if (mv.view.startsWith("redirect:")) {
            resp.sendRedirect(mv.view.substring(9));
            return;
        }
        // 将模板引擎渲染的内容写入响应:
        PrintWriter pw = resp.getWriter();
        this.viewEngine.render(mv, pw);
        pw.flush();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

这样使得上层代码编写更灵活。例如，一个显示用户资料的请求可以这样写

@GetMapping("/user/profile")
public ModelAndView profile(HttpServletResponse response, HttpSession session) {
    User user = (User) session.getAttribute("user");
    if (user == null) {
        // 未登录，跳转到登录页:
        return new ModelAndView("redirect:/signin");
    }
    if (!user.isManager()) {
        // 权限不够，返回403:
        response.sendError(403);
        return null;
    }
    return new ModelAndView("/profile.html", Map.of("user", user));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

最后一步是在DispatcherServlet的init()方法中初始化所有Get和Post的映射，以及用于渲染的模板引擎：

public class DispatcherServlet extends HttpServlet {
    private Map<String, GetDispatcher> getMappings = new HashMap<>();
    private Map<String, PostDispatcher> postMappings = new HashMap<>();
    private ViewEngine viewEngine;

    @Override
    public void init() throws ServletException {
        this.getMappings = scanGetInControllers();
        this.postMappings = scanPostInControllers();
        this.viewEngine = new ViewEngine(getServletContext());
    }
    ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13

如何扫描所有Controller以获取所有标记有@GetMapping和@PostMapping的方法,使用反射.