SpringMVC学习笔记

<?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>com.hgc</groupId>
     <artifactId>ch01-hello-springmvc</artifactId>
     <version>1.0-SNAPSHOT</version>
     <packaging>war</packaging>
 
     <name>ch01-hello-springmvc Maven Webapp</name>
     <!-- FIXME change it to the project's website -->
     <url>http://www.example.com</url>
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <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>
             <scope>provided</scope>
         </dependency>
 
         <!--jsp依赖-->
         <dependency>
             <groupId>javax.servlet.jsp</groupId>
             <artifactId>jsp-api</artifactId>
             <version>2.2</version>
         </dependency>
 
         <!--SpringMVC依赖-->
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-webmvc</artifactId>
             <version>5.3.7</version>
         </dependency>
 
 
     </dependencies>
 
     <build>
 
     </build>
 </project>

2、重点：在web.xml文件中注册SpringMVC框架的核心对象DispatcherServlet

DispatcherServlet叫做中央调度器，是一个Servlet，它的父类是HttpServlet
DispatcherServlet也叫前端控制器(front controller)
DispatcherServlet负责接收用户提交的请求，调用其它的控制器对象，并把请求的处理结果显示给用户

<?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">
     
     <!--
         声明，注册springmvc的核心对象DispatcherServlet
         需要在tomcat服务器启动后，创建DispatcherServlet对象的实例。
         为什么要创建DispatcherServlet对象实例呢？
         因为DispatcherServlet在创建过程中，会同时创建springmvc容器对象，
         读取springmvc的配置文件，把这个配置文件中的对象都创建好，当用户发起
         请求时就可以直接使用对象了
 
         servlet的初始化会执行init()方法，DispatcherServlet在init()中{
             // 创建容器，读取配置文件
             WebApplicationContext wac = new ClassPathXmlApplicationContext("springmvc.xml");
             // 把容器对象放入到ServletContext中
             getServletContext().setAttribute(key, wac);
         }
 
         springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml
     -->
     <servlet>
         <servlet-name>springmvc</servlet-name>
         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
         <!--自定义springmvc读取的配置文件的位置-->
         <init-param>
             <!--springmvc的配置文件的位置的属性-->
             <param-name>contextConfigLocation</param-name>
             <!--自定义文件的位置-->
             <param-value>classpath:springmvc.xml</param-value>
         </init-param>
 
         <!--
             在tomcat启动后，创建servlet对象
             load-on-startup：表示tomcat启动后创建对象的顺序，它的值是整数，数值越小，创建的时间越早。大于等于0的整数
         -->
         <load-on-startup>1</load-on-startup>
     </servlet>
 
     <servlet-mapping>
         <servlet-name>springmvc</servlet-name>
 
         <!--
             使用框架的时候,url-pattern可以使用两种值
             1.使用扩展名,语法: *.xxxx   xxxx是自定义扩展名 常用的方式  *.do *.action *.mvc等等
 
             2.使用斜杠 "/"
         -->
         <url-pattern>*.do</url-pattern>
     </servlet-mapping>
     
 </web-app>

3、创建一个发起请求的页面(index.jsp)

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>第一个springmvc项目</title>
 </head>
 <body>
     <p><a href="some.do">发起some.do请求</a></p>
 </body>
 </html>

4、创建控制器（处理器）类

package com.hgc.controller;
 
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.servlet.ModelAndView;
 
 /*
     @Controller:创建处理器对象,对象放在springmvc容器中.
     位置:在类的上面
 
     能处理请求的都是控制器(处理器):MyController能处理请求,叫做后端控制器(back controller)
  */
 @Controller
 public class MyController {
     /*
         处理用户提交的请求,springmvc中是使用方法来处理的..
         方法是自定义的,可以有多种返回值,多种参数,方法名称自定义
      */
 
     /*
         准备使用doSome方法处理some.do请求.
         @RequestMapping:请求映射,作用是把一个请求地址和一个方法绑定在一起.一个请求指定一个方法处理
             属性:value 是一个String,表示请求的uri地址的(some.do)
                  value的值必须是唯一的,不能重复.在使用时,推荐以"/"开头
             位置:在方法的上面,常用的      在类的上面
             说明:使用@RequestMapping修饰的方法叫做处理器方法或者控制器方法
             使用@RequestMapping修饰的方法可以处理请求,类似servlet中的doGet doPost
 
         返回值:ModelAndView 表示本次请求的处理结果
             Model:数据,请求处理完成后,要显示给用户的数据
             View:视图,比如jsp等等.
      */
     @RequestMapping(value = "/some.do")
     public ModelAndView doSome(){
         ModelAndView mv = new ModelAndView();
         // 添加数据,框架在请求最后把数据放入到request作用域
         mv.addObject("msg", "hello SpringMVC");
         mv.addObject("fun", "执行的doSome方法");
         // 指定视图,指定视图的完整路径
         // 框架对视图执行的forward操作,request.getRequestDispatcher("/show.jsp").forward(request, response)
         // mv.setViewName("/show.jsp");
         // mv.setViewName("/WEB-INF/view/show.jsp");
 
         // 当配置了视图解析器后，可以使用逻辑名称（文件名）,指定视图
         // 框架会使用视图解析器的前缀 + 逻辑名称 + 后缀 组成完整路径,就是字符串连接操作
         mv.setViewName("show");
         // 返回mv
         return mv;
 
     }
 }

5、创建一个作为结果的jsp，显示请求的处理结果

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>显示结果</title>
 </head>
 <body>
     <h3>msg数据:${msg}</h3><br>
     <h3>fun数据:${fun}</h3><br>
 
 </body>
 </html>

6、创建SpringMVC的配置文件

声明组件扫描器，执行@Controller注解所在的包名
声明视图解析器，帮助处理视图的

<?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">
 
     <!--使用注解的方式，就要声明组件扫描器-->
     <context:component-scan base-package="com.hgc.controller"/>
 
     <!--声明springmvc框架中的视图解析器,帮助开发人员设置视图文件的路径-->
     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
         <!--前缀：视图文件的路径-->
         <property name="prefix" value="/WEB-INF/view/"/>
         <!--后缀：视图文件的扩展名-->
         <property name="suffix" value=".jsp"/>
     </bean>
 </beans>

7、测试

打开浏览器，在地址栏输入：http://localhost:8080/some.do

8、结果

SpringMVC中常用的两个注解

@Controller

@Controller：创建控制器类的对象，接收请求，处理请求

@RequestMapping

@RequestMapping：请求映射，把请求绑定到一个方法，让这个方法处理请求

@RequestMapping的两个属性

value：请求的uri地址，唯一值
method：请求的方式，使用RequestMethod类的枚举值例如：RequestMethod.GET

接收用户提交的参数

可以直接出现在处理器方法上的参数

HttpServletRequest HttpServletResponse HttpSession 这三个可以直接出现在参数的位置

逐个接收参数，处理器方法的形参名和请求中参数名一样，按名称对应赋值

/*
     逐个接收请求参数:   处理器方法的形参和请求参数的名称必须一致。按名称对应赋值
  */
 @RequestMapping(value = "/receiveParam.do")
 public ModelAndView doSome(String name, Integer age){
     ModelAndView mv = new ModelAndView();
     mv.addObject("name", name);
     mv.addObject("age", age);
     mv.setViewName("show");
     return mv;
 }

解决请求中post方式有中文乱码的问题

使用过滤器

<!--字符过滤器-->
 <filter>    
     <filter-name>characterEncodingFilter</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>
     <!--强制请求对象使用encoding编码的值-->
     <init-param>
         <param-name>forceRequestEncoding</param-name>
         <param-value>true</param-value>
     </init-param>
     <!--强制应答对象使用encoding编码的值-->
     <init-param>
         <param-name>forceResponseEncoding</param-name>
         <param-value>true</param-value>
     </init-param>
 </filter>
 
 <filter-mapping>
     <filter-name>characterEncodingFilter</filter-name>
     <!--表示强制所有的请求先通过过滤器处理-->
     <url-pattern>/*</url-pattern>
 </filter-mapping>

逐个接收中，请求参数名和形参名不一样，使用@RequestParam解决问题

/*
     @RequestParam：逐个接收参数中，能解决处理方法的形参名和请求参数名称不一致的问题
     位置：在处理方法的形参前面添加
     属性：
         value：请求中参数的名称
         required: 默认为true，表示请求中必须包含这个参数
  */
 
 @RequestMapping(value = "/receiveParam2.do")
 public ModelAndView doOther(@RequestParam(value = "rname", required = true) String name,
                             @RequestParam(value = "rage", required = false) Integer age){
     ModelAndView mv = new ModelAndView();
     mv.addObject("name", name);
     mv.addObject("age", age);
     mv.setViewName("show");
     return mv;
 }

使用java对象接收请求的参数，要求属性名和请求参数名相同

/*
     使用java对象接收请求参数，java对象的属性名必须和请求参数名一致，还需要提供setter and getter
  */
 @RequestMapping(value = "/receiveObject.do")
 public ModelAndView doThird(Student student){
     ModelAndView mv = new ModelAndView();
     mv.addObject("name", student.getName());
     mv.addObject("age", student.getAge());
     mv.setViewName("show");
     return mv;
 }

SpringMVC处理器方法的形参还可以是Map，List等集合类型，数组也可以

处理器方法的返回值：表示请求的处理结果

返回：ModelAndView

ModelAndView：表示数据和视图，对视图执行forward

@RequestMapping(value = "returnModelAndView.do")
 public ModelAndView doReturnModelAndView(String name, Integer age){
     ModelAndView modelAndView = new ModelAndView();
     modelAndView.addObject("name", name);
     modelAndView.addObject("age", age);
     modelAndView.setViewName("show");
     return modelAndView;
 }

返回：String

String：表示数据，如果方法上有@ResponseBody注解，那么String表示数据，表示数据时，会有中文乱码的问题，需要使用@RequestMapping中的produces属性来指定字符集：text/plain;charset=utf-8

返回String表示数据

/*
     返回值String 既可以表示数据，又可以表示视图
     当处理方法上面有@ResponseBody注解时，String表示数据
     处理方法上面没有@ResponseBody注解时，String表示视图。
 
     会有中文乱码问题：需要使用@RequestMapping的produces属性来指定contextType
  */
 @ResponseBody
 @RequestMapping(value = "/returnStringDate.do", produces = "text/plain;charset=utf-8")
 public String doReturnStringData(String name, Integer age) {
     Student student = new Student();
     student.setAge(1);
     return "Hello SpringMVC 返回String表示数据";
 }

返回String表示视图

String：表示视图，表示视图的话，可以是逻辑名称(文件名，不带后缀)，也可以是完整视图路径，对视图执行forward

@RequestMapping(value = "/returnString.do")
 public String doReturnString(HttpServletRequest request, String name, Integer age) {
     // 这里我们可以自己手动添加数据
     request.setAttribute("name", name);
     request.setAttribute("age", age);
 
     // 使用完整视图路径，不能注册视图解析器
     //return "/WEB-INF/view/show.jsp";
 
     // 使用逻辑名称，必须注册视图解析器
     return "show";
 }

返回：void

void：返回值本身不能表示数据和视图，可以响应ajax请求

 @RequestMapping(value = "/returnVoid.do")
 public void doReturnVoid(HttpServletResponse response, String name, Integer age) throws IOException {
     Student student = new Student();
     student.setAge(age);
     student.setName(name);
 
     String json = "{}";
     if (student != null) {
         ObjectMapper om = new ObjectMapper();
         json = om.writeValueAsString(student);
     }
 
     response.setContentType("application/json;charset=utf-8");
     PrintWriter writer = response.getWriter();
     writer.println(json);
     writer.flush();
     writer.close();
 }

返回：对象

返回对象：表示数据的，响应ajax请求

/*
     @ResponseBody:用来完成json字符串输出到浏览器的功能
  */
 @RequestMapping(value = "/returnStudent.do")
 @ResponseBody
 public Student doReturnStudent(String name, Integer age) {
     Student student = new Student();
     student.setName(name);
     student.setAge(age);
     return student;
 }

SpringMVC处理器方法放回对象，转为json响应ajax步骤

1、加入处理java到json转换工具库的依赖

<!--Jackson包-->
 <dependency>
     <groupId>com.fasterxml.jackson.core</groupId>
     <artifactId>jackson-core</artifactId>
     <version>2.9.0</version>
 </dependency>
 <dependency>
     <groupId>com.fasterxml.jackson.core</groupId>
     <artifactId>jackson-databind</artifactId>
     <version>2.9.0</version>
 </dependency>
 <dependency>
     <groupId>com.fasterxml.jackson.core</groupId>
     <artifactId>jackson-annotations</artifactId>
     <version>2.9.0</version>
 </dependency>

2、在SpringMVC配置文件中加入注解驱动

 <!--
 
     1、用来完成将java对象转换为json格式字符串的功能的
 
     2、如果在web.xml中servlet-mapping的url-pattern设置的是/，而不是如.do。
     表示将所有的文件，包含静态资源文件都交给spring mvc处理。
     就需要用到<mvc:annotation-driven />了。
     如果不加，DispatcherServlet则无法区分请求是资源文件还是mvc的注解，而导致controller的请求报404错误。
 
 -->
 <mvc:annotation-driven/>

3、在处理器方法上加入@ResponseBody注解

SpringMVC中关于url-pattern的问题

设置中央调度器的url-pattern是 "/"：导致静态资源访问失败都是404 动态资源可以正常访问

<?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>springmvc</servlet-name>
         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
         <init-param>
             <param-name>contextConfigLocation</param-name>
             <param-value>classpath:springmvc.xml</param-value>
         </init-param>
         <load-on-startup>1</load-on-startup>
     </servlet>
     <servlet-mapping>
         <servlet-name>springmvc</servlet-name>
         <!--
         使用 "/"
         当项目中使用了 "/" , 它就会代理tomcat中的default。
         导致所有的静态资源都给DispatcherServlet处理，默认情况下DispatcherServlet没有处理静态资源的能力
         也就是没有控制器对象能处理静态资源的访问。所以静态资源都是404
 
         动态资源some.do是可以访问的，因为程序中有MyController控制器对象，来处理some.do请求
 
         -->
         <url-pattern>/</url-pattern>
     </servlet-mapping>
 </web-app>

第一种解决静态资源访问的方案：在SpringMVC的配置文件中加入两个标签

<mvc:default-servlet-handler/>

<!--注解驱动-->
<!--default-servlet-handler 和 @RequestMapping注解有冲突，需要加入annotation-driven 解决问题-->
<mvc:annotation-driven/>

原理：加入DefaultServletHttpRequestHandler对象，让这个对象处理静态资源的访问

第二种处理静态资源

使用框架中的mvc:resources标签，由框架自己处理静态资源的访问

<!--
     第二种处理静态资源的方式
     mvc:resources 加入后框架会创建ResourceHttpRequestHandler这个处理器对象。
     让这个对象处理静态资源的访问，不依赖tomcat服务器。
     mapping：访问静态资源的uri地址，使用通配符  **
     location：静态资源在项目中的目录位置
 
     images/** : 表示  images/p1.jgp   images/user/logo.gif   images/order/history/list.phg
 
     mvc:resources和@RequestMapping有一定冲突，需要加入注解驱动
 
     当项目中有很多类静态资源时，可以在webapp目录下创建一个static目录，将所有静态资源都放在static目录下
     只需要一个<mvc:resources>标签即可配置完成
 
 -->
 <mvc:resources mapping="/static/**" location="/static/"/>

SSM整合开发

涉及的容器

SSM整合有两个容器

SpringMVC容器：管理Controller，视图等对象
Spring容器：管理Service，dao对象

创建容器的方式

创建SpringMVC容器

使用中央调度器DispatcherServlet

创建Spring容器

使用监听器ContextLoaderListener

涉及的配置文件

数据库属性配置文件
MyBatis主配置问价
Spring配置文件
SpringMVC配置文件

开发步骤

1、加入依赖

<?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>com.hgc</groupId>
     <artifactId>ch06-ssm</artifactId>
     <version>1.0-SNAPSHOT</version>
     <packaging>war</packaging>
 
     <name>ch06-ssm Maven Webapp</name>
     <!-- FIXME change it to the project's website -->
     <url>http://www.example.com</url>
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <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>
             <scope>provided</scope>
         </dependency>
         <!--jsp依赖-->
         <dependency>
             <groupId>javax.servlet.jsp</groupId>
             <artifactId>jsp-api</artifactId>
             <version>2.1</version>
             <scope>provided</scope>
         </dependency>
         <!--SpringMVC依赖-->
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-webmvc</artifactId>
             <version>5.3.7</version>
         </dependency>
         <!--做事务的-->
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-tx</artifactId>
             <version>5.3.7</version>
         </dependency>
         <!--Spring连接数据库的依赖-->
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-jdbc</artifactId>
             <version>5.3.7</version>
         </dependency>
         <!--Jackson包-->
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
             <version>2.9.0</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
             <version>2.9.0</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-annotations</artifactId>
             <version>2.9.0</version>
         </dependency>
         <!--MyBatis依赖-->
         <dependency>
             <groupId>org.mybatis</groupId>
             <artifactId>mybatis</artifactId>
             <version>3.5.7</version>
         </dependency>
         <!--mybatis和spring集成的依赖-->
         <dependency>
             <groupId>org.mybatis</groupId>
             <artifactId>mybatis-spring</artifactId>
             <version>2.0.6</version>
         </dependency>
         <!--mysql驱动-->
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
             <version>8.0.25</version>
         </dependency>
         <!--阿里的连接池-->
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>druid</artifactId>
             <version>1.2.6</version>
         </dependency>
         <!--lombok-->
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
             <version>1.18.4</version>
         </dependency>
     </dependencies>
 
     <build>
 
         <!--用来扫描main/java/src下面的xx.xml和xx.properties文件的-->
         <resources>
             <resource>
                 <directory>src/main/java</directory>
                 <includes>
                     <include>**/*.properties</include>
                     <include>**/*.xml</include>
                 </includes>
             </resource>
             <!--扫描src/main/resources下的所有配置文件-->
             <resource>
                 <directory>src/main/resources</directory>
                 <includes>
                     <include>**/*.*</include>
                 </includes>
             </resource>
         </resources>
     </build>
 </project>

2、写web.xml

注册DispatcherServlet，创建SpringMVC容器对象，才能创建Controller类对象。创建Servlet，才能接收请求
注册Spring的监听器：ContextLoaderListener，目的：创建Spring的容器对象，才能创建Servlet，dao对象
注册字符集过滤器，解决post请求有中文乱码的问题

<?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">
     <!--注册中央调度器 创建springmvc容器 创建servlet-->
     <servlet>
         <servlet-name>springmvc</servlet-name>
         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
         <init-param>
             <param-name>contextConfigLocation</param-name>
             <param-value>classpath:conf/dispatcherServlet.xml</param-value>
         </init-param>
         <load-on-startup>1</load-on-startup>
     </servlet>
     <servlet-mapping>
         <servlet-name>springmvc</servlet-name>
         <url-pattern>*.do</url-pattern>
     </servlet-mapping>
     
     <!--注册监听器 创建spring容器-->
     <context-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>classpath:conf/applicationContext.xml</param-value>
     </context-param>
     <listener>
         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
     </listener>
 
     <!--注册字符集过滤器-->
     <filter>
         <filter-name>characterEncodingFilter</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>
         <init-param>
             <param-name>forceRequestEncoding</param-name>
             <param-value>true</param-value>
         </init-param>
         <init-param>
             <param-name>forceResponseEncoding</param-name>
             <param-value>true</param-value>
         </init-param>
     </filter>
     <filter-mapping>
         <filter-name>characterEncodingFilter</filter-name>
         <url-pattern>/*</url-pattern>
     </filter-mapping>
 
 </web-app>

3、创建包：controller service dao domain 等包

4、写SpringMVC Spring MyBatis等配置文件

Mybatis配置文件

<?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE configuration
         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 <configuration>
 
     <!--settings:控制mybatis全局行为-->
     <settings>
         <!--增加日志-->
         <setting name="logImpl" value="STDOUT_LOGGING"/>
     </settings>
     
 </configuration>

Spring配置文件

<?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">
     <!--声明数据库属性配置文件的位置-->
     <context:property-placeholder location="classpath:conf/jdbc.properties"/>
     <!--声明数据源-->
     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
         <property name="url" value="${jdbc.url}"/>
         <property name="username" value="${jdbc.username}"/>
         <property name="password" value="${jdbc.password}"/>
     </bean>
 
     <!--声明sqlSessionFactory-->
     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
         <property name="dataSource" ref="dataSource"/>
         <property name="configLocation" value="classpath:conf/mybatis.xml"/>
     </bean>
 
     <!--声明dao-->
     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
         <property name="basePackage" value="com.hgc.dao"/>
     </bean>
 
 
     <!--声明service的注解@Services所在的包名位置-->
     <context:component-scan base-package="com.hgc.service"/>
 
     <!--事务配置：注解的配置，aspectj的配置-->
 
     
 </beans>

SpringMVC配置文件

<?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 https://www.springframework.org/schema/mvc/spring-mvc.xsd">
 
     <!--组件扫描器-->
     <context:component-scan base-package="com.hgc.controller"/>
 
     <!--视图解析器-->
     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
         <property name="prefix" value="/WEB-INF/jsp/"/>
         <property name="suffix" value=".jsp"/>
     </bean>
 
     <!--注解驱动-->
     <mvc:annotation-driven/>
 
     <!--如果注册中央调度器时，在url-pattern中写的是 / 的话，需要加这个来解决静态资源访问404的问题-->
     <mvc:default-servlet-handler/>
 
 </beans>

5、写代码

实体类
dao接口和mapper文件
service和实现类
controller

6、写jsp页面

转发和重定向

转发：forward

/*
     请求转发
     语法：mv.setViewName("forward:视图完整路径");
     特点：不和视图解析器一同工作
     用途：能够转发不在WEB-INF/view目录下的jsp
  */
 @RequestMapping(value = "/forward.do")
 public ModelAndView doForward(){
     ModelAndView mv = new ModelAndView();
     mv.addObject("msg", "转发操作，能够转发不在WEB-INF/view目录下的jsp");
     mv.setViewName("forward:/show.jsp");
     return mv;
 }

重定向

重定向：redirect

/*
     重定向
     语法：mv.setViewName("redirect:视图完整路径");
     特点；不和视图解析器一同工作
 
     框架对重定向的操作：
         1.框架会把Model中的简单类型的数据，转为String使用，作为show2.jsp的get请求参数使用
             目的是在doRedirect.do 和 show2.jsp 两次请求之间传递参数
         2.在目标show2.jsp页面可以使用参数集合对象${param.参数名}获取请求参数
         3.重定向不能访问/WEB-INF资源
  */
 @RequestMapping(value = "/redirect.do")
 public ModelAndView doRedirect(String name, Integer age){
     ModelAndView mv = new ModelAndView();
     mv.addObject("msg", "重定向");
     mv.addObject("myname", name);
     mv.addObject("myage", age);
     mv.setViewName("redirect:/show2.jsp");
     return mv;
 }

特点

特点

都不和视图解析器一同工作，就好像项目中没有配置视图解析器一样

异常处理

package com.hgc.handler;
 
 import com.hgc.exception.AgeException;
 import com.hgc.exception.NameException;
 import org.springframework.web.bind.annotation.ControllerAdvice;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.servlet.ModelAndView;
 
 // 注意这个注解
 @ControllerAdvice
 public class UserExceptionHandler {
 
     /*
         异常处理方法的定义和处理器方法的定义完全相同
         有一个参数Exception exception，表示发生的异常
      */
 
     /*
         @ExceptionHandler的value属性，表示当发生这个异常时由这个方法来处理
      */
     @ExceptionHandler(value = NameException.class)
     public ModelAndView doNameException(Exception exception) {
         ModelAndView mv = new ModelAndView();
         mv.addObject("msg", "姓名必须是：张三。不然就会出错，不信你再试试");
         mv.addObject("ex", exception);
         mv.setViewName("nameError");
         return mv;
     }
 
     @ExceptionHandler(value = AgeException.class)
     public ModelAndView doAgeException(Exception exception) {
         ModelAndView mv = new ModelAndView();
         mv.addObject("msg", "年龄必须在200岁一下，不然会认为你是老妖怪");
         mv.addObject("ex", exception);
         mv.setViewName("ageError");
         return mv;
     }
 
     /*
         当不写value值时，表示如果发生了NameException和AgeException之外的异常，都由这个方法处理
         这个方法只能有一个，就相当与条件判断中的else分支，只能有一个
      */
     @ExceptionHandler
     public ModelAndView doOtherException(Exception exception) {
         ModelAndView mv = new ModelAndView();
         mv.addObject("msg", "发生了不可描述的异常");
         mv.addObject("ex", exception);
         mv.setViewName("defaultError");
         return mv;
     }
 
 }

拦截器

注册一个拦截器

<mvc:interceptors>
     <mvc:interceptor>
         <!--声明选哟拦截的请求的uri-->
         <!--可以使用通配符 ** 表示任意字符-->
         <mvc:mapping path="/**"/>
         <!--声明拦截器的位置-->
         <bean class="com.hgc.handler.MyInterceptor"/>
     </mvc:interceptor>
 </mvc:interceptors>

注册0个或多个拦截器

<!--声明拦截器
     拦截器可以有0个或多个
     在框架中保存多个拦截器是ArrayList，
     按照声明的先后顺序放入到ArrayList中
 -->
 <mvc:interceptors>
     <!--声明第一个拦截器-->
     <mvc:interceptor>
         <!--声明选哟拦截的请求的uri-->
         <!--可以使用通配符 ** 表示任意字符-->
         <mvc:mapping path="/**"/>
         <!--声明拦截器的位置-->
         <bean class="com.hgc.handler.MyInterceptor"/>
     </mvc:interceptor>
     <!--声明第二个拦截器-->
     <mvc:interceptor>
         <mvc:mapping path="/**"/>
         <bean class="com.hgc.handler.MyInterceptor2"/>
     </mvc:interceptor>
 </mvc:interceptors>

使用拦截器

package com.hgc.handler;
 
 import org.springframework.web.servlet.HandlerInterceptor;
 import org.springframework.web.servlet.ModelAndView;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.util.Date;
 
 public class MyInterceptor implements HandlerInterceptor {
 
         long begin = 0;
     /*
         preHandle 在 处理方法之前执行，通常用来做登录验证
         preHandle 在 MyController.doSome()方法之前执行
         参数：
             Object handler：表示被拦截的请求
         返回值：
             true：表示请求通过验证，然后请求由处理方法处理
             false：表示请求没有通过验证，请求到此处就停止了，后面两个方法也不会执行
      */
     @Override
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
         begin = System.currentTimeMillis();
         System.out.println("preHandle()方法在处理方法之前执行");
         //request.getRequestDispatcher("/tips.jsp").forward(request, response);
         //return false;
         return true;
     }
 
     /*
         postHandle 在 处理方法之后执行
         postHandle 在 MyController.doSome()方法之后执行
         参数：
             Object handler:表示被拦截的请求
             ModelAndView modelAndView：用来接收处理方法的返回值，在这个方法能够修改处理方法的返回值，影响最后的结果
      */
     @Override
     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
         System.out.println("postHandle()方法在处理方法之后执行");
         // 在拦截器中增加数据
         modelAndView.addObject("myDate", new Date());
         // 修改视图
         modelAndView.setViewName("other");
 
     }
 
     /*
         afterCompletion 在 请求完成后执行(在框架中，执行了forward就算请求完成了)
         参数：
             Object handler：表示被拦截的请求
             Exception ex：请求执行完后抛出的异常
         用途；一般用来做资源回收
      */
     @Override
     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
         long end = System.currentTimeMillis();
         System.out.println("afterCompletion()方法在请求完成后执行");
         System.out.println("执行时间：" + (end - begin));
     }
 }

=========================================================================作者：晚枫

链接：https://blog.csdn.net/q2570558854/article/details/121161439

晚枫2000

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC学习笔记

SpringMVC概述SpringMVC是做web开发的框架，实际上是Spring框架中的一个模块SpringMVC的使用就是基于Spring容器的概念，SpringMVC会创建容器：WebApplicationContext，SpringMVC作为容器是创建和管理控制器对象的，使用@Controller创建控制器对象SpringMVC底层访问依然是Servlet-----DispatcherServlet（中央调度器）创建WebApplicationContext对象，读取配置文件，进而
复制链接

扫一扫