SpringMVC详解

<!-- 配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理 -->
<servlet>
  <servlet-name>springMVC</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet- class>
</servlet>
<servlet-mapping>
  <servlet-name>springMVC</servlet-name>
<!--
设置springMVC的核心控制器所能处理的请求的请求路径
/所匹配的请求可以是/login或.html或.js或.css方式的请求路径 但是/不能匹配.jsp请求路径的请求
（jsp本质是servlet）
-->
  <url-pattern>/</url-pattern>
</servlet-mapping>

<servlet>
  <servlet-name>springMVC</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet- class>
  <!-- springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml -->
  <!-- 通过初始化参数指定SpringMVC配置文件的位置和名称 -->
  <init-param>
  <!-- contextConfigLocation为固定值 -->
    <param-name>contextConfigLocation</param-name>
  <!--  使用classpath:表示从类路径查找配置文件，例如maven工程中的
            src/main/resources -->
    <param-value>classpath:springMVC.xml</param-value>
  </init-param>
<!--
作为框架的核心组件，在启动过程中有大量的初始化操作要做 而这些操作放在第一次请求时才执行会严重影响访问速度 因此需要通过此标签将启动控制DispatcherServlet的初始化时间提前到服务器启动时
-->
  <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
  <servlet-name>springMVC</servlet-name>
  <url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 注：
<url-pattern>标签中使用/和/*的区别：
/所匹配的请求可以是/login或.html或.js或.css方式的请求路径，但是/不能匹配.jsp请求路径的请     求
因此就可以避免在访问jsp页面时，该请求被DispatcherServlet处理，从而找不到相应的页面
/*则能够匹配所有请求，例如在使用过滤器时，若需要对所有请求进行过滤，就需要使用/*的写     法
-->

@Controller
public class HelloController {
}

<!-- 自动扫描包 -->
<context:component-scan   base-package="com.atguigu.mvc.controller"/>
<!-- 配置Thymeleaf视图解析器 -->
<bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
  //可以配置多个，使用优先级来区分
  <property name="order" value="1"/>  
  <property name="characterEncoding" value="UTF-8"/>
  <property name="templateEngine">
    <bean  class="org.thymeleaf.spring5.SpringTemplateEngine">
      <property name="templateResolver">
        <bean     class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
          <!-- 视图前缀 -->
          <property name="prefix" value="/WEB-INF/templates/"/>
          <!-- 视图后缀 -->
          <property name="suffix" value=".html"/>
          //模板模型为HTML5 
          <property name="templateMode" value="HTML5"/>
          <property name="characterEncoding" value="UTF-8" />
        </bean>
      </property>
    </bean>
  </property>
</bean>
<!--
处理静态资源，例如html、js、css、jpg 若只设置该标签，则只能访问静态资源，其他请求则无法访问 此时必须设置<mvc:annotation-driven/>解决问题
-->
<mvc:default-servlet-handler/>
<!-- 开启mvc注解驱动 -->
<mvc:annotation-driven>
  <mvc:message-converters>
    <!-- 处理响应中文内容乱码 -->
    <bean class="org.springframework.http.converter.StringHttpMessageConverter">
      <property name="defaultCharset" value="UTF-8" />
      <property name="supportedMediaTypes">
        <list>
          <value>text/html</value>
          <value>application/json</value>
        </list>
      </property>
    </bean>
  </mvc:message-converters>
</mvc:annotation-driven>

<?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>
        <!-- springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml -->
        <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启动后创建对象的顺序。它的值是整数，数值越小，
         tomcat创建对象的时间就越早
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!-- 使用框架的时候，url-pattern可以使用两种值
         1.使用扩展名方式，语法 *.xxx(xxx是自定义的扩展名)
         例如:http://localhost:8080/myweb/some.do
        2.使用斜杠 “/”
         -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

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

<?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.mvc.controller"/>
</beans>

/**
 * @Controller:创建处理器对象,对象放在springmvc容器中 位置：在类的上面
 * 和spring中讲的@Service，@Component实际上都一样
 * 能够处理请求的都是控制器(处理器)，MyController叫做后端控制器
 */
@Controller
public class MyController {
    /**
     * @RequestMapping：请求映射，作用是把一个请求地址和一个方法绑定在一起。 一个请求指定一个方法处理
     * 属性：1.value 是一个String，表示请求的url地址(比如some.do)
     * value的值必须是唯一的，不能重复
     * 位置：1.在方法的上面
     * 2.在类的上面
     * 说明：使用@RequestMapping修饰的方法叫做处理器方法或者控制器方法
     * 使用@RequestMapping修饰的方法可以处理请求，类似Servlet中的doGet，doPost
     * 返回值：ModelAndView
     * Model:数据，请求处理完成后，要显示给用户的数据
     * View：视图，比如jsp等等
     */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome() {
        ModelAndView mv = new ModelAndView();
        //添加数据,框架在请求的最后把数据放入到request作用域
        //request.setAttribute("msg","欢迎使用springmvc做web开发");
        mv.addObject("msg", "欢迎使用springmvc做web开发");
        mv.addObject("fun", "执行的是doSome方法");
//        指定视图，指定视图的完整路径
//        框架对视图执行的forward操作，request.getRequestDispatcher("/show.jsp").forward(...)
        mv.setViewName("/show.jsp");
        return mv;
    }
}dkd

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>show.jsp</h3>
<h3>msg数据：${msg}</h3>
<h3>fun数据：${fun}</h3>
</body>
</html>

@RequestMapping(
value = {"/testRequestMapping", "/test"},
method = {RequestMethod.GET, RequestMethod.POST}
)
public String testRequestMapping(){ return "success";

<a   th:href="@{/testRest/1/admin}">测试路径中的占位符-->/testRest</a><br>

@RequestMapping("/testRest/{id}/{username}")
public String testRest(@PathVariable("id") String id, @PathVariable("username") String username){
  System.out.println("id:"+id+",username:"+username);
  return "success";
}
//最终输出的内容为-->id:1,username:admin

@RequestMapping("/testParam")
public String testParam(HttpServletRequest request){
   String username = request.getParameter("username");      
   String password = request.getParameter("password");
   System.out.println("username:"+username+",password:"+password); 
   return "success";

<a th:href="@{/testParam(username='admin',password=123456)}">
测试获取请求参数-->/testParam</a><br>

@RequestMapping("/testParam")
public String testParam(String username, String password){          
  System.out.println("username:"+username+",password:"+password); 
  return "success";
}

<form th:action="@{/testpojo}" method="post"> 
  用户名：<input type="text" name="username"><br> 
  密码：<input type="password" name="password"><br>
  性别：<input type="radio" name="sex" value="男">男<input type="radio" name="sex" value="女">女<br>
  年龄：<input type="text" name="age"><br>
  邮箱：<input type="text" name="email"><br>
     <input type="submit">
</form>

@RequestMapping("/testpojo") public String testPOJO(User user){
  System.out.println(user); 
  return "success";
}
//最终结果-->User{id=null, username='张三', password='123', age=23, sex='男', email='123@qq.com'}

<!--配置springMVC的编码过滤器-->
<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>forceResponseEncoding</param-name>
    <param-value>true</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>CharacterEncodingFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request){
  request.setAttribute("testScope", "hello,servletAPI");
    return "success";
}

@RequestMapping("/testModelAndView") 
public ModelAndView testModelAndView(){
  /**
  * ModelAndView有Model和View的功能
  * Model主要用于向请求域共享数据
  * View主要用于设置视图，实现页面跳转
  */
  ModelAndView mav = new ModelAndView();
  //向请求域共享数据
  mav.addObject("testScope","hello,ModelAndView");
  //设置视图，实现页面跳转 
  mav.setViewName("success"); 
  return mav;
}

@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap){ 
  modelMap.addAttribute("testScope", "hello,ModelMap"); 
  return "success";
}

@RequestMapping("/testSession")
public String testSession(HttpSession session){ 
  session.setAttribute("testSessionScope", "hello,session"); 
  return "success";
}

@RequestMapping("/testApplication")
public String testApplication(HttpSession session){
  ServletContext application = session.getServletContext();
  application.setAttribute("testApplicationScope", "hello,application"); 
  return "success";
}

<bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
    <property name="order" value="1"/>
    <property name="characterEncoding" value="UTF-8"/>
    <property name="templateEngine">
        <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
            <property name="templateResolver">
                <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
    
                    <!-- 视图前缀 -->
                    <property name="prefix" value="/WEB-INF/templates/"/>
    
                    <!-- 视图后缀 -->
                    <property name="suffix" value=".html"/>
                    <property name="templateMode" value="HTML5"/>
                    <property name="characterEncoding" value="UTF-8" />
                </bean>
            </property>
        </bean>
    </property>
</bean>

@RequestMapping("/testHello") 
public String testHello(){
  return "hello";
}

@RequestMapping("/testForward") 
public String testForward(){
  return "forward:/testHello";
}

@RequestMapping("/testRedirect") 
public String testRedirect(){
  return "redirect:/testHello";
}

<!--
path：设置处理的请求地址
view-name：设置请求地址所对应的视图名称
-->
<mvc:view-controller  path="/testView"  view-name="success"></mvc:view-controller>

<mvc:annotation-driven />

<filter>
  <filter-name>HiddenHttpMethodFilter</filter-name>
  <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter- class>
</filter>
<filter-mapping>
  <filter-name>HiddenHttpMethodFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

String paramValue = request.getParameter(this.methodParam); 

<form th:action="@{/testRequestBody}" method="post">
   用户名：<input type="text" name="username"><br> 
   密码：<input type="password" name="password"><br>
   <input type="submit">
</form>

@RequestMapping("/testRequestBody")
public String testRequestBody(@RequestBody String requestBody){     
    System.out.println("requestBody:"+requestBody);
  return "success";
}

@RequestMapping("/testRequestEntity")
public String testRequestEntity(RequestEntity<String> requestEntity){   
  System.out.println("requestHeader:"+requestEntity.getHeaders());  
  System.out.println("requestBody:"+requestEntity.getBody());
  return "success";
}

@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody(){ 
  return "success";
}

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.12.1</version>
</dependency>

<mvc:annotation-driven /> 

@RequestMapping("/testResponseUser")
@ResponseBody
public User testResponseUser(){
  return new User(1001,"admin","123456",23,"男");
}

@RequestMapping("/testDown")
public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException {
//获取ServletContext对象
ServletContext servletContext = session.getServletContext();
//获取服务器中文件的真实路径
String realPath = servletContext.getRealPath("/static/img/1.jpg");
//创建输入流
InputStream is = new FileInputStream(realPath);
//创建字节数组
byte[] bytes = new byte[is.available()];
//将流读到字节数组中 is.read(bytes);
//创建HttpHeaders对象设置响应头信息
MultiValueMap<String, String> headers = new HttpHeaders();
//设置要下载方式以及下载文件的名字
headers.add("Content-Disposition","attachment;filename=1.jpg");
//设置响应状态码
HttpStatus statusCode = HttpStatus.OK;
//创建ResponseEntity对象
ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, statusCode);
//关闭输入流
is.close();
return responseEntity;
}

<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
<dependency>
  <groupId>commons-fileupload</groupId>
  <artifactId>commons-fileupload</artifactId>
  <version>1.3.1</version>
</dependency>

<!--必须通过文件解析器的解析才能将文件转换为MultipartFile对象-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
</bean>

@RequestMapping("/testUp")
public String testUp(MultipartFile photo, HttpSession session) throws IOException {
//获取上传的文件的文件名
String fileName = photo.getOriginalFilename();
//处理文件重名问题
String hzName = fileName.substring(fileName.lastIndexOf("."));
fileName = UUID.randomUUID().toString() + hzName;
//获取服务器中photo目录的路径
ServletContext servletContext = session.getServletContext(); 
String photoPath = servletContext.getRealPath("photo");
File file = new File(photoPath); 
if(!file.exists()){
  file.mkdir();
}
String finalPath = photoPath + File.separator + fileName;
//实现上传功能
photo.transferTo(new File(finalPath));
  return "success";
}