1. Concepto
MVC
MVC es un modelo arquitectónico que divide el desarrollo del programa en tres niveles: Modo, Vista y Controlador. Las capas están separadas entre sí y funcionan juntas. La capa de Vista se enfoca en la presentación de datos, la capa de Modelo se enfoca en la composición de los datos comerciales de soporte, y el Controlador completa el procesamiento de lógica de negocios y la transferencia de datos.
El siguiente es un patrón de diseño MVC: Primero, la solicitud del usuario llega al controlador frontal del controlador frontal, que reenvía la solicitud al controlador que puede manejar la solicitud. El controlador realiza el procesamiento comercial y genera datos comerciales y los devuelve al controlador frontal. El controlador frontal reenvía los datos comerciales recibidos a la plantilla de página, Ver plantilla, los presenta como la página final y los devuelve al controlador frontal. Finalmente, el controlador frontal devuelve la página final al usuario. En este modo, el controlador frontal es responsable de la programación de la distribución, el controlador es responsable del procesamiento de los datos comerciales y la plantilla de visualización es responsable de representar la página. La idea central de MVC es separar el procesamiento y la presentación de los datos comerciales.
Flujo de ejecución de Spring MVC
- El usuario envía una solicitud al servidor, esta solicitud primero irá al controlador frontal DispatcherServlet (también llamado controlador central).
- DispatcherServlet llamará al mapeador del procesador HandlerMapping después de recibir la solicitud para obtener la cadena de ejecución donde se procesa la solicitud. La llamada cadena de ejecución se refiere al uso de un interceptor Interceptor envuelto alrededor del controlador del procesador real, un cierto procesamiento previo antes de que la solicitud llegue al controlador, y algunas operaciones se realizan después de que el controlador devuelve el resultado de la ejecución antes de devolver el resultado.
- DispatcherServlet llama al adaptador de procesador HandlerAdapter, diciéndole qué adaptador debe ejecutarse.
- Adaptador de procesador HandlerAdapter para ejecutar Controller y obtener ModelAndView (datos y vista), y volver a DispatcherServlet capa por capa
- DispatcherServlet entrega ModelAndView a ViewReslover para analizar y luego vuelve a la vista real.
- DispatcherServlet llena los datos del modelo en la vista
- DispatcherServlet responde el resultado al usuario
2. Use Spring MVC
Configuración de archivo
Como se muestra en la imagen de la izquierda a continuación, administre una tabla de clientes para completar la visualización de consultas de información del usuario y aumentar las funciones. Primero cree un proyecto web a través de Maven y agregue manualmente modelos, vistas, controladores y otras clases. La estructura del proyecto se muestra a continuación.
Primero configure las dependencias utilizadas por el proyecto en el archivo pom.xml, como servlet, mysql-connector, spring-webmvc, etc.
Luego, introduzca dos archivos de configuración en el archivo web.xml : el archivo de configuración de contexto de Spring Framework application-context.xml y el archivo de configuración de Spring MVC mvc-dispatcher-servlet.xml. Al configurar DispatcherServlet, especifique la ubicación del archivo de configuración a través de <init-param> contextConfigLocation; de lo contrario, SpringMVC encuentra automáticamente el archivo /web-INF/$servlet-name$-servlet.xml de acuerdo con <servlet-name> de forma predeterminada
Cabe señalar aquí que la ruta de coincidencia <url-pattern> "/" solo puede coincidir con URL similares a / customer / view, "/ *" no solo puede coincidir / customer / view, sino también /view.jsp, /view.html y otras URL con sufijo.
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>Archetype Created Web Application</display-name>
<!--配置Spring的上下文context-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>WEB-INF/config/application-context.xml</param-value>
</context-param>
<!--配置DispatcherServlet-->
<servlet>
<servlet-name>mvc-dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/config/mvc-dispatcher-servlet.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>mvc-dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
El siguiente es el archivo application-context.xml , en el que la administración de beans basada en anotaciones está habilitada y las clases en com.mvc se escanean automáticamente, y los beans anotados en @Controller se excluyen a través del filtro de exclusión, porque la clase @Controller se entrega al DispatcherServlet Administrar
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!-- 启动基于注解的Bean管理 -->
<context:annotation-config></context:annotation-config>
<!-- 扫描com.mvc下的Bean -->
<context:component-scan base-package="com.mvc">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
</beans>El siguiente es el archivo mvc-dispatcher-servlet.xml , en el que se activa la gestión de beans anotados y se busca la clase @Controller, y se inicia HandlerMapping. DispatcherServlet no solo administra el controlador, sino que también administra la vista. Configure ViewResolver como una página de plantilla JSTL y agregue un prefijo y sufijo a la página. Por ejemplo, el controlador devuelve el éxito de la cadena. Agregar el prefijo y el sufijo se convierte en /WEB-INF/jsps/success.jsp, para que pueda encontrar la página correspondiente.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 激活注解 -->
<context:annotation-config></context:annotation-config>
<!-- 让DispatchServlet只搜索@Controller注解的类 -->
<context:component-scan base-package="com.mvc">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- 让DispatchServlet启用基于注解的HandlerMapping -->
<mvc:annotation-driven/>
<!-- 映射静态资源目录 -->
<mvc:resources mapping="/resources/**" location="/resources"/>
<!-- 配置ViewResolver为JstlView，并为其添加前后缀 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
<property name="prefix" value="/WEB-INF/jsps/"/>
<property name="suffix" value=".jsp"/>
</bean>
</beans>Controlador de escritura
La siguiente implementación muestra el nombre del usuario visitando la página con la url / customer / view? CustomerId = 3. El atributo de valor predeterminado de @RequestMapping especifica la ruta de url asignada para la clase CustomerController y el método viewCustomer (). También puede especificar el tipo de url de respuesta a través del atributo method = RequestMethod.POST.
En el método viewCustomer (), primero obtenga el parámetro customerId en la url a través de la anotación @RequestParam , y luego complete la operación de consultar la base de datos basada en la identificación llamando al CustomerService y devuelva un objeto de cliente. El controlador luego vincula el objeto al objeto Modelo. Spring MVC transporta información de datos a través del objeto Modelo , y la página frontal puede obtener directamente al cliente del objeto Modelo.
Finalmente, se devuelve la cadena de página "customer_view", y el Servlet Dispatcher unirá la posición de página correcta de acuerdo con la cadena. No solo se puede escribir directamente la cadena de página, sino que también se puede realizar la función de redireccionamiento para "redirect / forward:" + page.
@Controller
@RequestMapping("/customer")
public class CustomerController {
private CustomerService customerService;
@Autowired
public void setCustomerService(CustomerService customerService) {
this.customerService = customerService;
}
@RequestMapping("/view")
public String viewCustomer(@RequestParam("customerId") int id, Model model) {
Customer customer = customerService.queryById(id);
model.addAttribute(customer); //将customer对象绑定到model中
return "customer_view";
}
}Lo anterior es obtener el parámetro a través de @RequestParam y devolver el objeto a través del objeto Modelo. También puede usar el objeto HttpRequest tradicional para obtener los parámetros y vincular los datos
@RequestMapping("/view")
public String viewCustomer(HttpServletRequest request){
int id=Integer.parseInt(request.getParameter("customerId")); //获取参数
Customer customer=customerService.queryName(id);
request.setAttribute("customer",customer); //绑定返回对象
return "customer_view";
}Si la URL accedida tiene el formato RESTful / customer / view / 3, puede obtener los parámetros a través de @PathVariable. El mapa se usa aquí para llevar la información del objeto del cliente al front end.
@RequestMapping("/view/{customerId}")
public String viewCustomer(@PathVariable("customerId")int id, Map<String,Object> model){
Customer customer=customerService.queryName(id);
model.put("customer",customer);
return "customer_view";
}Finalmente, la información del objeto del cliente se muestra mediante la expresión EL en la página customer_view.jsp de la siguiente manera
<h2>编号：${customer.id}，名字：${customer.name}</h2>
Enlace de datos de formulario
SpringMVC completará automáticamente el enlace de los datos del formulario al objeto. Debe tenerse en cuenta que el nombre del atributo del formulario debe ser el mismo que el del atributo del objeto. El siguiente es un formulario para enviar un objeto cliente, cuyo nombre es id y el nombre corresponde a los atributos id y name del objeto Customer, respectivamente.
<form action="<%=request.getContextPath()%>/customer/save" method="post">
id：<input type="text" name="id">
用户名：<input type="text" name="name">
<input type="submit" value="提交">
</form>Reciba el objeto del cliente en forma de parámetros en el Controlador y guárdelo en la base de datos a través del CustomerService. Luego, redirija la página a la página / customer / view y pase el customerId como la identificación del objeto del cliente que acaba de guardar.
@RequestMapping(value = "/save",method = RequestMethod.POST)
public String saveCustomer(Customer customer){
System.out.println(customer.getId()+customer.getName());
customerService.addCustomer(customer);
return "redirect:view?customerId="+customer.getId();
}Vale la pena señalar que los chinos estarán confusos cuando se envíe el formulario. Esto es necesario para establecer el método de codificación en UTF-8 en el archivo web.xml
<filter>
<filter-name>characterEncoding</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter </filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>Carga de archivos
Para usar la carga de archivos en Spring MVC, primero introduzca la dependencia de Maven commons-fileupload en el archivo pom.xml, y luego configure el bean CommonMultipartResolver en mvc-dispatcher-servlet.xml
<bean class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="maxUploadSize" value="10485760"/> <!--文件最大10M=10485760字节-->
<property name="defaultEncoding" value="UTF-8"/>
<property name="resolveLazily" value="true"/> <!--开启文件延迟解析-->
</bean>El formulario de envío del archivo es el siguiente: especifique el enctype como multipart / form y el nombre del archivo como imgFile
<form method="post" action="<%=request.getContextPath()%>/customer/uploadImg" enctype="multipart/form-data">
<input type="file" name="imgFile">
<input type="submit" value="提交">
</form>Reciba la imagen en el controlador y guárdela, realice la operación del archivo a través del objeto MultipartFile, su isEmpty () se usa para determinar si el archivo está vacío, getInputStream () para obtener la secuencia del archivo, getOriginalFilename () para obtener el nombre del archivo. Copie el archivo al objeto de archivo recién creado en el servidor a través del método copyInputStreamToFile () de FileUtils
@RequestMapping(value = "/uploadImg",method = RequestMethod.POST)
public String uploadImg(@RequestParam("imgFile") MultipartFile multipartFile) throws IOException {
if (!multipartFile.isEmpty()){
FileUtils.copyInputStreamToFile(multipartFile.getInputStream(),
new File("D:\\Temp\\Pictures",multipartFile.getOriginalFilename()));
}
return "redirect:upload";
}Devolver datos JSON
A veces necesitamos que el servidor no devuelva una página, sino datos en formato JSON para que el front-end pueda completar funciones como la carga asincrónica. Para usar Json en Spring MVC, primero debemos introducir la dependencia jackson-databind a través de maven. Luego configure ContentNegotiatingViewResolver en mvc-dispatcher-servlet.xml para devolver datos en formato JSON de forma predeterminada.
<bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
<property name="defaultViews">
<list>
<bean class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/>
</list>
</property>
</bean>Después de eso, configure el método en el Controlador para devolver directamente el objeto de tipo Cliente y agregue la anotación @ResponseBody
@RequestMapping("/json_data")
public @ResponseBody Customer getJsonData(@RequestParam("customerId") int id){
return customerService.queryById(id);
}Acceder a la url a través de un navegador devuelve los datos en formato JSON como se muestra a continuación
3. Interceptor
El interceptor en Spring MVC puede implementarse heredando la interfaz HandlerInterceptor. Esta interfaz tiene tres métodos, de los cuales preHandler () es el método para interceptar la solicitud antes de que llegue al Controlador real. Tiene un valor de retorno. Si es verdadero, la solicitud se libera y falso significa interceptar Solicitud Por ejemplo, en este método, se verifica si el usuario ha iniciado sesión y solo se libera la verificación; de lo contrario, se reenvía a la página de inicio de sesión mediante solicitud. postHandler () es el método ejecutado por el interceptor después de devolver el resultado del controlador. Los parámetros de este método incluyen el objeto ModelAndView además de la solicitud, la respuesta y el controlador. Este objeto representa los datos y la información de vista devuelta por el controlador. El objeto modifica los datos devueltos y la página de vista. El método afterCompletion () es el método después de que el interceptor finaliza la ejecución, similar al destructor, en el que generalmente se realizan las operaciones de destrucción de objetos y cierre de la conexión.
public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("请求到达拦截器...");
if (request.getSession().getAttribute("username") == null){ //验证是否已登录
request.getRequestDispatcher("/WEB-INF/jsps/login.jsp").forward(request,response);
return false;
}else
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("返回结果到达拦截器...");
modelAndView.addObject("msg","这是拦截器返回时添加的信息"); //修改返回的数据信息
modelAndView.setViewName("/customer/add_customer"); //修改返回的视图页面
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("拦截器执行结束");
}
}Después de eso, el interceptor debe registrarse en el archivo mvc-dispatcher-servlet.xml, donde <mvc: mapping> especifica la ruta de solicitud para que el interceptor intercepte.
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/customer_view"/>
<bean class="com.mvc.interceptor.LoginInterceptor"/>
</mvc:interceptor>
</mvc:interceptors>