1. Modelo de arquitetura de três camadas (MVC)
A. Modelo de desenvolvimento tradicional Modelo 1
No início do desenvolvimento Java Web, JSP era responsável pela solicitação e resposta e chamava os métodos relacionados ao banco de dados em JavaBean, que era chamado de modo Model1. A arquitetura dessa abordagem é bastante simples, mas as responsabilidades funcionais do JSP não são únicas e é difícil obter a reutilização do código. Ao mesmo tempo, há um sério acoplamento entre JSP e JavaBean, o que não é favorável à manutenção.
B. Modelo de desenvolvimento tradicional Modelo 2
A fim de resolver os problemas acima, a tecnologia Servlet surgiu. Todas as solicitações do usuário serão interceptadas primeiro pelo Servlet, então o Java Bean correspondente será selecionado de acordo com a solicitação e o resultado será exibido pelo JSP.
A arquitetura de desenvolvimento é geralmente baseada em duas arquiteturas, B / S (navegador / servidor) e C / S (cliente / servidor). No desenvolvimento JavaEE, quase todos são baseados na arquitetura B / S. A arquitetura padrão de três camadas inclui: camada de apresentação, camada de negócios e camada de persistência.
Camada de apresentação : é a camada da web que costumamos dizer, responsável por receber solicitações do cliente, incluindo parâmetros de solicitação, e responder aos resultados ao cliente. Normalmente, o cliente usa o protocolo http para solicitar a camada da web, e a camada da web precisa receber a solicitação http e responder ao serviço de atendimento ao cliente por meio da resposta http.
A camada de apresentação pode ser dividida em uma camada de controle e uma camada de exibição: a camada de controle é responsável por receber as solicitações e seus parâmetros, e a camada de exibição é responsável por exibir os resultados.
Camada de negócios : a camada de serviço que costumamos dizer, responsável pelo processamento da lógica de negócios. A camada de negócios pode contar com a camada de persistência ao realizar o processamento de negócios.Se você deseja persistir os dados, você precisa garantir a consistência das coisas (as transações devem ser colocadas na camada de negócios para controle).
Camada de persistência : é a camada dao que costumamos dizer, responsável pelas operações de persistência de dados.
Modelo de desenvolvimento MVC:
M: O modelo do modelo é na verdade o objeto JavaBean que usamos para armazenar dados em desenvolvimento.
V: visão da vista, usada para exibir os resultados, como JSP, HTML.
C: Controller Controller, responsável por interagir com os usuários e receber solicitações, como Servlet.
C. Spring MVC
Spring MVC é uma estrutura da web leve baseada no tipo orientado a solicitação do padrão MVC implementado por Java. Uma classe Java simples pode ser usada como um controlador para processar solicitações por meio de um conjunto de anotações sem a necessidade de implementar nenhuma interface. Também oferece suporte Solicitação de estilo RESTful. E por ser um produto subsequente da estrutura do Spring, é muito fácil usar a integração do Spring. Simplesmente entenda que Spring MVC é uma estrutura baseada em spring, que é uma atualização e extensão de servlet. (A camada inferior do desenvolvimento web é o servlet)
O Spring MVC pode criar objetos de controlador para receber solicitações do usuário e retornar resultados de processamento e colocá-los no contêiner Spring MVC. O objeto controlador que criamos usando a anotação @Controller é apenas um objeto de uma classe comum em vez de um servlet (o servlet deve herdar HttpServlet), mas o Spring MVC fornece ao objeto controlador as funções de recebimento de parâmetros e retorno de resultados.
A entrada do Spring MVC é DispatcherServlet e todos os pedidos são encaminhados ao objeto Controller responsável pelo processamento via DispatcherServlet.
Experiência de uso:
0. Crie um novo projeto web maven
Se você usar o maven para construir automaticamente, pode modificar o arquivo de configuração do maven (settings.xml) para usar o espelhamento da nuvem Alibaba:
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
https://maven.apache.org/xsd/settings-1.0.0.xsd">
<mirrors>
<mirror>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<mirrorOf>central</mirrorOf>
</mirror>
</mirrors>
</settings>
Depois que a compilação automática for concluída, também precisamos adicionar manualmente main / java, main / resource, a estrutura do projeto é a seguinte:
1. Importar dependências
Uma vez que os projetos construídos automaticamente são frequentemente diferentes de nosso ambiente de uso, precisamos ajustar manualmente o pom.xml
<?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>org.example</groupId>
<artifactId>SpringMVC-01</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!--JDK版本-->
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!--servlet依赖-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>
<!--springmvc依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
</dependencies>
</project>2. Registre DispatcherServlet em web.xml
O projeto da web construído automaticamente por maven usa uma versão do aplicativo da web baixa, então nós mudamos para 4.0.
O controlador frontal DispatcherServlet (também chamado de dispatcher central) é um servlet herdado de HttpServlet; é usado para receber solicitações do usuário, chamar o objeto controlador responsável pelo processamento da solicitação e retornar os resultados do processamento; no método init () do DispatcherServlet , Criou um objeto de contêiner SpringMVC e o colocou em ServletContext.
<?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">
<!--注册DispatcherServlet,配置Tomcat启动后就创建-->
<servlet>
<!--SpringMVC容器创建时,读取的配置文件默认为<servlet-name>-servlet.xml-->
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<!--自定义SpringMVC读取的配置文件的位置-->
<param-name>contextConfigLocation</param-name>
<!--类路径下的springmvc.xml文件(resources目录就是类路径)-->
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!--Tomcat启动后,创建对象的顺序-->
<load-on-startup>1</load-on-startup>
</servlet>
<!--配置DispatcherServlet拦截哪些请求-->
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<!--
使用框架时,url-pattern可以使用两种
1. 扩展名 *代表通配符,匹配任意长度的路径 只看扩展名 *.do *.action 等
2. 使用 "/"
-->
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>3. Crie uma página index.jsp para iniciar a solicitação
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<p>第一个项目</p>
<a href="some.do">发起请求</a>
</body>
</html>4. Criar controlador de classe
1) Use @Controller para declarar que este é um objeto controlador e injete-o no contêiner Spring MVC.
2) Use @RequestingMapping para declarar o caminho da solicitação. Os métodos modificados com @RequestingMapping são chamados de métodos de processador ou métodos de controlador, que são usados para processar solicitações, semelhantes aos métodos doGet, doPost e serviço em servlets.
3) Modelo: Após o processamento da solicitação de armazenamento, os dados serão devolvidos ao usuário
Visualização: armazena a visualização usada para exibir os dados, como jsp
package com.zzt.Controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class MyController {
@RequestMapping("/some.do")
public ModelAndView doSome(){
ModelAndView modelAndView = new ModelAndView();
// 存放数据 框架会自动将数据放到request作用域
modelAndView.addObject("msg","hello-word");
// 指定视图的路径 框架会自动通过forward进行请求转发 request.getRequestDispatcher("/show.jsp").forward(..)
modelAndView.setViewName("/show.jsp");
return modelAndView;
}
}
5. Crie uma página para exibir os resultados
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<p>请求的参数为:${requestScope.get("msg")}</p>
</body>
</html>6. Crie o arquivo de configuração SpringMVC
Como usamos a anotação @Controller para anotar a classe do controlador, precisamos configurar o scanner para escanear o pacote e injetar automaticamente a classe de entidade no contêiner
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">
<!--声明组件扫描器-->
<context:component-scan base-package="com.zzt.Controller"/>
</beans>