SpringMVC

最新推荐文章于 2024-06-16 09:46:44 发布

Ayu___

最新推荐文章于 2024-06-16 09:46:44 发布

阅读量159

点赞数

文章标签： servlet java spring

本文链接：https://blog.csdn.net/Ayu___/article/details/128134725

版权

1、SpringMVC简介

1.1、什么是MVC

MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分
M：Model，模型层，指工程中的JavaBean，作用是处理数据
JavaBean分为两类：

一类称为实体类Bean：专门存储业务数据的，如 Student、User 等
一类称为业务处理 Bean：指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问。
V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据
C：Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器
MVC的工作流程： 用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器

1.2、什么是SpringMVC

SpringMVC是Spring的一个后续产品，是Spring的一个子项目
注：三层架构分为表述层（或表示层）、业务逻辑层、数据访问层，表述层表示前台页面和后台servlet

1.3、SpringMVC的特点

Spring 家族原生产品，与 IOC 容器等基础设施无缝对接
基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一处理
表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案
代码清新简洁，大幅度提升开发效率
内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可
性能卓著，尤其适合现代大型、超大型互联网项目要求

2、入门案例

配置web.xml

   url-pattern中/和/*的区别：
/:匹配浏览器向服务器发送的所有请求（不包括.jsp）
 /*:匹配浏览器向服务器发送的所有请求（包括.jsp）

<!--注册SpringMVC的前端控制器DispatcherServlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>

SpringMVC的配置文件默认的位置和名称：
位置：WEB-INF下
名称：-servlet.xml，当前配置下的配置文件名为SpringMVC-servlet.xml

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"
       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.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"/>
                        <property name="templateMode" value="HTML5"/>
                        <property name="characterEncoding" value="UTF-8" />
                    </bean>
                </property>
            </bean>
        </property>
    </bean>
</beans>

入门案例

@Controller
public class HelloController {
    //此次的'/'相当于http://localhost:8080/SpringMVC/
    //浏览器访问http://localhost:8080/SpringMVC/将会交给这个函数处理
    @RequestMapping("/")
    public String protal(){
        return "index";//返回逻辑视图
    }
    @RequestMapping("/hello")
    public String hello(){
        return "success";
    }

}

1.当springmvc的配置文件不使用默认位置和名称时，可以进行配置
2.将Servlet初始化时间提前到服务器启动的时候

    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--当springmvc的配置文件不使用默认位置和名称时，可以进行配置-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <!--将Servlet初始化时间提前到服务器启动的时候-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>

3、@RequestMapping注解

@RequestMapping标识一个类：设置映射请求的请求路径的初始信息
@RequestMapping标识一个方法：设置映射请求请求路径的具体信息

@Controller
@RequestMapping("/test")
public class TestRequestMappingController {
    //此时请求映射所映射的请求的请求路径为：/test/hello
    @RequestMapping("/hello")
    public String hello(){
        return "index";
    }
}

value属性

@RequestMapping注解的value属性通过请求的请求地址匹配请求映射
@RequestMapping注解的value属性是一个字符串类型的数组，表示该请求映射能够匹配多个请求地址所对应的请求 @RequestMapping({"/hello","/abc"})
@RequestMapping注解的value属性必须设置，至少通过请求地址匹配请求映射

method属性

@RequestMapping注解的method属性通过请求的请求方式（get或post）匹配请求映射
@RequestMapping注解的method属性是一个RequestMethod类型的数组，表示该请求映射能够匹配多种请求方式的请求，若当前请求的请求地址满足请求映射的value属性，但是请求方式不满足method属性，则浏览器报错405：Request method ‘POST’ not supported

    @RequestMapping(value = {"index"},
            method = {RequestMethod.GET,RequestMethod.POST})

注：对于处理指定请求方式的控制器方法，SpringMVC中提供了@RequestMapping的派生注解

处理get请求的映射–>@GetMapping
处理post请求的映射–>@PostMapping
处理put请求的映射–>@PutMapping
处理delete请求的映射–>@DeleteMapping

params属性（了解）

作用：通过请求的请求参数匹配请求映射，即浏览器发送的请求的请求参数必须满足params属性的配置

“param”：要求请求映射所匹配的请求必须携带param请求参数
“!param”：要求请求映射所匹配的请求必须不能携带param请求参数
“param=value”：要求请求映射所匹配的请求必须携带param请求参数且param=value
“param!=value”：要求请求映射所匹配的请求可以不携带param请求参数，如果携带但是param!=value
注：若当前请求满足@RequestMapping注解的value和method属性，但是不满足params属性，此时页面回报错400：Parameter conditions “username, password!=123456” not met for actual request parameters: username={admin}, password={123456}

headers属性（了解）

@RequestMapping注解的headers属性通过请求的请求头信息匹配请求映射
@RequestMapping注解的headers属性是一个字符串类型的数组，可以通过四种表达式设置请求头信
息和请求映射的匹配关系

“header”：要求请求映射所匹配的请求必须携带header请求头信息
“!header”：要求请求映射所匹配的请求必须不能携带header请求头信息
“header=value”：要求请求映射所匹配的请求必须携带header请求头信息且header=value
“header!=value”：要求请求映射所匹配的请求不必须携带header请求头信息且header!=value
若当前请求满足@RequestMapping注解的value和method属性，但是不满足headers属性，此时页面
显示404错误，即资源未找到

SpringMVC支持ant风格的路径

？：表示任意的单个字符(不包括?)
*：表示任意的0个或多个字符(不包括?和/)
**：表示任意层数的任意目录,注意：使用方式只能/**/，**只能写在双斜线中，前后不能有任何其他字符
注意：在使用**时，只能使用/**/xxx的方式

SpringMVC支持路径中的占位符（重点)

原始方式：/deleteUser?id=1
rest方式：/user/delete/1
SpringMVC路径中的占位符常用于RESTful风格中，当请求路径中将某些数据通过路径的方式传输到服务器中，就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，再通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形参。

    @RequestMapping("/hello/rest/{username}/{id}")
    public String testRest(@PathVariable("username")String username,@PathVariable("id") Integer id){
        System.out.println("id"+id);
        return "success";
    }

4、SpringMVC获取请求参数

1、通过ServletAPI获取

将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象。

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

2、通过控制器方法的形参获取请求参数

在控制器方法的形参位置，设置和请求参数同名的形参，当浏览器发送请求，匹配到请求映射时，在DispatcherServlet中就会将请求参数赋值给相应的形参。

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

（1）@RequestParam解决请求参数与形参名称不同

@RequestParam是将请求参数和控制器方法的形参创建映射关系
@RequestParam注解一共有三个属性：

value：指定为形参赋值的请求参数的参数名
required：设置是否必须传输此请求参数，默认值为true。若设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置defaultValue属性，则页面报错400：Required String parameter ‘xxx’ is not present；若设置为false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为null
defaultValue：不管required属性值为true或false，当value所指定的请求参数没有传输或传输的值为""时，则使用默认值为形参赋值

    public String getParam(@RequestParam(value = "userName",required = false,defaultValue = "lxy") String username, String password){}

（2）@RequestHeader

@RequestHeader是将请求头信息和控制器方法的形参创建映射关系
@RequestHeader注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

（3）@CookieValue

@CookieValue是将cookie数据和控制器方法的形参创建映射关系
@CookieValue注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

(4) 通过POJO获取请求参数

可以在控制器方法的形参位置设置一个实体类类型的形参，此时若浏览器传输的请求参数的参数名和实体类中的属性名一致，那么请求参数就会为此属性赋值。

    @RequestMapping("/param/pojo")
    public String getByPojo(User user){
        System.out.println("user = " + user);
        return "success";
    }

(5)解决获取请求参数的乱码问题

解决获取请求参数的乱码问题，可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter，但是必须在web.xml中进行注册。

<!--配置Spring的编码过滤器-->
    <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>
            <!--同时设置request编码-->
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

注：SpringMVC中处理编码的过滤器一定要配置到其他过滤器之前，否则无效

（6）@PathVariable

获取请求路径中的参数信息

 @GetMapping("/car/{id}/owner/{username}")
    public Map<String,Object> getCar(@PathVariable("id") Integer id,
                                     @PathVariable("username") String name,
                                     @PathVariable Map<String,String> pv){


        Map<String,Object> map = new HashMap<>();

        map.put("id",id);
        map.put("name",name);
        map.put("pv",pv);//map中包含所有路径参数
        return map;
    }

5、域对象共享数据

5.1、使用ModelAndView向request域对象共享数据

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

5.2、使用Model、map、ModelMap向request域对象共享数据

    @RequestMapping("/test/model")
    public String testModel(Model model){
        model.addAttribute("testRequestScope","this is model ");
        return "success";
    }

    @RequestMapping("/test/modelMap")
    public String testModelMap(ModelMap modelMap){
        modelMap.addAttribute("testRequestScope","this is modelMap ");
        return "success";
    }

    @RequestMapping("/test/map")
    public String testModel(Map map){
        map.put("testRequestScope","this is map ");
        return "success";
    }
}

Model、ModelMap、Map类型的参数其实本质上都是 BindingAwareModelMap 类型的

5.3、向session域共享数据

使用ServletAPI

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

5.4、使用向request域对象共享数据

    @RequestMapping("/test/application")
    public String testServletContext(HttpSession session){
        ServletContext servletContext = session.getServletContext();
        servletContext.setAttribute("testApplicationScope","this is Application ");
        return "success";
    }

6、SpringMVC的视图

SpringMVC中的视图是View接口，视图的作用渲染数据，将模型Model中的数据展示给用户
SpringMVC视图的种类很多，默认有转发视图和重定向视图

当工程引入jstl的依赖，转发视图会自动转换为JstlView
若使用的视图技术为Thymeleaf，在SpringMVC的配置文件中配置了Thymeleaf的视图解析器，由此视图解析器解析之后所得到的是ThymeleafView

6.1、ThymeleafView

当控制器方法中所设置的视图名称没有任何前缀时，此时的视图名称会被SpringMVC配置文件中所配置的视图解析器解析，视图名称拼接视图前缀和视图后缀所得到的最终路径，会通过转发的方式实现跳转

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

6.2、转发视图

SpringMVC中默认的转发视图是InternalResourceView
SpringMVC中创建转发视图的情况：当控制器方法中所设置的视图名称以"forward:"为前缀时，创建InternalResourceView视图，此时的图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀"forward:“去掉，剩余部分作为最终路径通过转发的方式实现跳转
例如"forward:/”，“forward:/employee”

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

以这种方式进行页面转发不会进行thymleaf页面渲染。

6.3、重定向视图

SpringMVC中默认的重定向视图是RedirectView，当控制器方法中所设置的视图名称以"redirect:"为前缀时，创建RedirectView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀"redirect:“去掉，剩余部分作为最终路径通过重定向的方式实现跳转
例如"redirect:/”，“redirect:/employee”

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

注：重定向视图在解析时，会先将redirect:前缀去掉，然后会判断剩余部分是否以/开头，若是则会自动拼接上下文路径

6.4、视图控制器view-controller

当控制器方法中，仅仅用来实现页面跳转，即只需要设置视图名称时，可以将处理器方法使用view-controller标签进行表示

    <!--开启mvc的注解驱动-->
    <mvc:annotation-driven />

    <!--
        视图控制器：为当前的请求直接设置视图名称实现页面跳转
        若设置视图控制器，则只有视图控制器所设置的请求会被处理，其他的请求将全部404
        此时必须在配置一个标签：<mvc:annotation-driven />
    -->
    <mvc:view-controller path="/" view-name="index"></mvc:view-controller>

7、RESTful

7.1、RESTful简介

REST：Representational State Transfer，表现层资源状态转移。

①资源

资源是一种看待服务器的方式，即，将服务器看作是由很多离散的资源组成。每个资源是服务器上一个
可命名的抽象概念。因为资源是一个抽象的概念，所以它不仅仅能代表服务器文件系统中的一个文件、
数据库中的一张表等等具体的东西，可以将资源设计的要多抽象有多抽象，只要想象力允许而且客户端
应用开发者能够理解。与面向对象设计类似，资源是以名词为核心来组织的，首先关注的是名词。一个
资源可以由一个或多个URI来标识。URI既是资源的名称，也是资源在Web上的地址。对某个资源感兴
趣的客户端应用，可以通过资源的URI与其进行交互。

7.2、RESTful的实现

具体说，就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。
它们分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE
用来删除资源。
REST 风格提倡 URL 地址使用统一的风格设计，从前到后各个单词使用斜杠分开，不使用问号键值对方
式携带请求参数，而是将要发送给服务器的数据作为 URL 地址的一部分，以保证整体风格的一致性。
在这里插入图片描述

7.3、HiddenHttpMethodFilter

由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？SpringMVC 提供了 HiddenHttpMethodFilter 帮助我们将 POST 请求转换为 DELETE 或 PUT 请求

HiddenHttpMethodFilter 处理put和delete请求的条件：

a>当前请求的请求方式必须为post
b>当前请求必须传输请求参数_method
满足以上条件，HiddenHttpMethodFilter 过滤器就会将当前请求的请求方式转换为请求参数_method的值，因此请求参数_method的值才是最终的请求方式
在web.xml中注册HiddenHttpMethodFilter

    <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>

<form th:action="@{/user/5}" method="post">
    <input type="hidden" name="_method" value="delete">
    <input type="submit" value="删除">
</form>

//@RequestMapping(value = "/user",method = RequestMethod.GET)
@GetMapping("/user")
    public String getUser(){
        System.out.println(" * 查询所有用户信息-->/user-->get");
        return "success";
    }
    @RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
    public String getUserById(@PathVariable("id")Integer id){
        System.out.println(" * 根据id查询用户信息-->/user/"+id+"-->get");
        return "success";
    }
    @RequestMapping(value = "/user",method = RequestMethod.POST)
   // @PostMapping()
    public String insertUser(){
        System.out.println("* 添加用户信息-->/user-->post");
        return "success";
    }

    @RequestMapping(value = "/user",method = RequestMethod.PUT)
  //  @PutMapping()
    public String updateUser(){
        System.out.println(" * 修改用户信息-->/user-->put");
        return "success";
    }


    @RequestMapping(value = "/user/{id}",method = RequestMethod.DELETE)
    //@DeleteMapping()
    public String deleteUserById(@PathVariable("id")Integer id){
        System.out.println(" * 删除用户信息-->/user/"+id+"-->delete");
        return "success";
    }

增删改查实例

    @Autowired
    private EmployeeDao employeeDao;
    @RequestMapping(value = "/employee",method = RequestMethod.GET)
    public String getAllUser(Model model){
        Collection<Employee> employees = employeeDao.getAll();
        model.addAttribute("employees",employees);
        return "employeeList";
    }
    @RequestMapping(value = "employee",method = RequestMethod.POST)
    public String addUser(Employee employee){
        employeeDao.save(employee);
        //重定向到列表功能
        return "redirect:/employee";
    }
    @RequestMapping(value = "/employee/{id}",method = RequestMethod.GET)
    public String toUpdate(@PathVariable("id")Integer id,Model model){
        Employee employee = employeeDao.get(id);
        model.addAttribute("employee",employee);
        return "update_employee";
    }
    @RequestMapping(value = "employee",method = RequestMethod.PUT)
    public String updateUser(Employee employee){
        employeeDao.save(employee);
        //重定向到列表功能
        return "redirect:/employee";
    }
    @RequestMapping(value = "/employee/{id}",method = RequestMethod.DELETE)
    public String deleteUser(@PathVariable("id")Integer id,Model model){
        employeeDao.delete(id);
        return "redirect:/employee";
    }

9、SpringMVC处理ajax请求

9.1 axio发送ajax请求

axios({
           url:"",//请求路径
           method:"",//请求方式
           //以name=value&name=value的方式发送的请求参数
           //不管使用的请求方式是get或post，请求参数都会被拼接到请求地址后
           //此种方式的请求参数可以通过request.getParameter()获取
           params:{},
           //以json格式发送的请求参数
           //请求参数会被保存到请求报文的请求体传输到服务器
           //此种方式的请求参数不可以通过request.getParameter()获取
           data:{}
       }).then(response=>{
           console.log(response.data);
       });

（1） params形式发送数据（url拼接参数）

此时的请求参数可以通过request.getParameter()获取，对应
SpringMVC中，可以直接通过控制器方法的形参获取此类请求参数

<script type="text/javascript">
    var vue = new Vue({
        el:"#app",
        methods:{
            testAjax(){
                axios.post(
                    "/spring_mvc/test/ajax?id=1001",
                    {username:"lxy",password:"1101"}
                ).then(response=>{
                    console.log(response.data);
                });
            }
        }
    });

    @RequestMapping("/test/ajax")
    public void testA(Integer id, HttpServletResponse response) throws IOException {
        System.out.println("id = " + id);
        response.getWriter().write("hello,lxy");
    }

（2）data形式发送数据

此时无法通过request.getParameter()获取，之前我们使用操作json的相关jar包gson或jackson处理此类请求参数，可以将其转换为指定的实体类对象或map集合。在SpringMVC中，直接使用@RequestBody注解标识控制器方法的形参即可将此类请求参数转换为java对象。

<script type="text/javascript">
    var vue = new Vue({
        el:"#app",
        methods:{
            testAjaxJson(){
                axios.post(
                    "/spring_mvc/test/requestBody/map",
                {username:"lxy",password:"1101",age:18,gender:"female"}
            ).then(response=>{
                console.log(response.data)
                });
            }
        }
    });

使用@RequestBody获取json格式的请求参数的条件：
1、导入jackson的依赖

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

2、SpringMVC的配置文件中设置开启mvc的注解驱动

<!--开启mvc的注解驱动-->
<mvc:annotation-driven />

3、在控制器方法的形参位置，设置json格式的请求参数要转换成的java类型（实体类或map）的参数，并使用@RequestBody注解标识

    @RequestMapping("/test/requestBody/json")
    public void testB(@RequestBody User user, HttpServletResponse response) throws IOException {
        response.getWriter().write("hello,requestBody");
        System.out.println("user = " + user);
    }
    @RequestMapping("/test/requestBody/map")
    public void testB(@RequestBody Map<String,Object> map, HttpServletResponse response) throws IOException {
        response.getWriter().write("hello,requestBody-MAP");
        System.out.println("map = " + map);
    }

9.2 @ResponseBody

@ResponseBody用于标识一个控制器方法，可以将该方法的返回值直接作为响应报文的响应体响应到浏览器。

    <a th:href="@{/test/responseBody/str}">测试RequestBodyStr</a>

    @RequestMapping("/test/responseBody/str")
    @ResponseBody
    public String testResponseBody(){
        return "LXY SUCCESS";
    }

在这里插入图片描述

9.3 @ResponseBody响应浏览器json数据

服务器处理ajax请求之后，大多数情况都需要向浏览器响应一个java对象，此时必须将java对象转换为json字符串才可以响应到浏览器，之前我们使用操作json数据的jar包gson或jackson将java对象转换为json字符串。在SpringMVC中，我们可以直接使用@ResponseBody注解实现此功能。
@ResponseBody响应浏览器json数据的条件：
1、导入jackson的依赖
2、SpringMVC的配置文件中设置开启mvc的注解驱动
3、使用@ResponseBody注解标识控制器方法，在方法中，将需要转换为json字符串并响应到浏览器的java对象作为控制器方法的返回值，此时SpringMVC就可以将此对象直接转换为json字符串并响应到浏览器

响应对象

    @RequestMapping("/test/responseBody/json")
    @ResponseBody
    public User testResponseBodyJson(){
        User user = new User("lxy", "000930", 18, "femal");
        return user;
    }

在这里插入图片描述

响应Map集合

    @RequestMapping("/test/responseBody/json")
    @ResponseBody
    public Map<String,Object> testResponseBodyJson(){
        User user1 = new User("lxy1", "000930", 18, "femal");
        User user2 = new User("lxy2", "000930", 18, "femal");
        User user3 = new User("lxy3", "000930", 18, "femal");
        Map<String,Object> map = new HashMap<>();
        map.put("001",user1);
        map.put("002",user3);
        map.put("003",user3);
        return map;
    }

在这里插入图片描述

响应List

    public List<User> testResponseBodyJson(){
        User user1 = new User("lxy1", "000930", 18, "femal");
        User user2 = new User("lxy2", "000930", 18, "femal");
        User user3 = new User("lxy3", "000930", 18, "femal");
        List<User> users = Arrays.asList(user1, user2, user3);
        return users;
    }

在这里插入图片描述

9.4、@RestController注解

@RestController注解是springMVC提供的一个复合注解，标识在控制器的类上，就相当于为类添加了@Controller注解，并且为其中的每个方法添加了@ResponseBody注解

10、文件上传和下载

10.1、文件下载

ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文。
使用ResponseEntity实现下载文件的功能

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

10.2、文件上传

文件上传要求form表单的请求方式必须为post，并且添加属性enctype=“multipart/form-data”
SpringMVC中将上传的文件封装到MultipartFile对象中，通过此对象可以获取文件相关信息
上传步骤：
①添加依赖：

        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>

②在SpringMVC的配置文件中添加配置：

	<!--必须通过文件解析器的解析才能将文件转换为MultipartFile对象-->
    <!--此处必须设置id 因为是根据id获取的这个bean-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>

③前端与控制器方法：

    <form th:action="@{/test/up}" method="post" enctype="multipart/form-data">
        头像：<input type="file" name="photo"><br>
        <input type="submit" value="上传">
    </form>

	@RequestMapping("/test/up")
    public String testUp(MultipartFile photo,HttpSession session) throws IOException {
        //获取上传的文件的文件名
        String originalFilename = photo.getOriginalFilename();
        //获取servletContext对象
        ServletContext servletContext = session.getServletContext();
        //获取当前工程下photo目录的真实路径
        String photoPath = servletContext.getRealPath("photo");
        //创建photoPath所对应的File对象
        File file = new File(photoPath);
        //判断file所对应的目录是否存在
        if (!file.exists()){
            file.mkdir();
        }
        String finalPath = photoPath + File.separator +originalFilename;
        photo.transferTo(new File(finalPath));
        return "success";
    }

解决文件上传过程中的重名问题：
将名称设置为永远不重复的。

        //获取上传的文件的文件名
        String originalFilename = photo.getOriginalFilename();
        //获取上传文件的后缀名
        String hzName = originalFilename.substring(originalFilename.lastIndexOf("."));
        //获取UUID
        String uuid = UUID.randomUUID().toString();
        //拼接新的文件名
        originalFilename = uuid + hzName;

11、拦截器

11.1、拦截器的配置

SpringMVC中的拦截器用于拦截控制器方法的执行
SpringMVC中的拦截器需要实现HandlerInterceptor
SpringMVC的拦截器必须在SpringMVC的配置文件中进行配置：

    <mvc:interceptors>
        <!--bean和ref标签所配置的拦截器默认对DispatcherServlet处理的所有的请求进行拦截-->
<!--        <ref bean="firstInterceptor" />-->
<!--        <bean class="com.atguigu.interceptor.FirstInterceptor"/>-->
        <mvc:interceptor>
            <!--配置需要拦截的请求的请求路径，/**表示所有请求-->
            <mvc:mapping path="/**"/>
            <!--配置需要排除拦截的请求的请求路径-->
            <mvc:exclude-mapping path="/abc"/>
            <ref bean="firstInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

11.2、拦截器的三个抽象方法

SpringMVC中的拦截器有三个抽象方法：

preHandle：控制器方法执行之前执行preHandle()，其boolean类型的返回值表示是否拦截或放行，返回true为放行，即调用控制器方法；返回false表示拦截，即不调用控制器方法
postHandle：控制器方法执行之后执行postHandle()
afterCompletion：处理完视图和模型数据，渲染视图完毕之后执行afterCompletion()

11.3、多个拦截器的执行顺序

①若每个拦截器的preHandle()都返回true，此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关：
preHandle()会按照配置的顺序执行，而postHandle()和afterCompletion()会按照配置的反序执行
②若某个拦截器的preHandle()返回了false，preHandle()返回false的拦截器和它之前的拦截器的preHandle()都会执行。postHandle()都不执行。preHandle()返回false的拦截器之前的拦截器的afterCompletion()会执行

12、异常处理器

12.1、基于配置的异常处理

SpringMVC提供了一个处理控制器方法执行过程中所出现的异常的接口：HandlerExceptionResolver
HandlerExceptionResolver接口的实现类有：DefaultHandlerExceptionResolver和SimpleMappingExceptionResolver
SpringMVC提供了自定义的异常处理器SimpleMappingExceptionResolver，使用方式：

    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <property name="exceptionMappings">
            <props>
                <!--
                    properties的键表示处理器方法执行过程中出现的异常
                    properties的值表示若出现指定异常时，设置一个新的视图名称，跳转到指定页面
                    -->
                <prop key="java.lang.ArithmeticException">error</prop>
            </props>
        </property>
        <!-- exceptionAttribute属性设置一个属性名，将出现的异常信息在请求域中进行共享 -->
        <property name="exceptionAttribute" value="ex"></property>
    </bean>

12.2、基于注解的异常处理

//@ControllerAdvice将当前类标识为异常处理的组件
@ControllerAdvice
public class ExceptionController {
	//@ExceptionHandler用于设置所标识方法处理的异常
	@ExceptionHandler(ArithmeticException.class)
	//ex表示当前请求处理中出现的异常对象
	public String handleArithmeticException(Exception ex, Model model){
		model.addAttribute("ex", ex);
		return "error";
	}
}

13、注解配置SpringMVC

使用配置类和注解代替web.xml和SpringMVC配置文件的功能
13.1、创建初始化类，代替web.xml

package com.atguigu.config;

import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.filter.HiddenHttpMethodFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

import javax.servlet.Filter;
//用来代替web.xml
public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    //设置一个配置类代替Spring配置文件
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    @Override
    //设置一个配置类代替SpringMVC配置文件
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    @Override
    //设置SpringMVC的前端控制器DispatcherServlet
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    @Override
    protected Filter[] getServletFilters() {
        //创建编码过滤器
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceEncoding(true);
        //创建处理请求方式的过滤器
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();

        return new Filter[]{characterEncodingFilter,hiddenHttpMethodFilter};
    }
}

13.2、创建SpringConfig配置类，代替spring的配置文件

@Configuration
public class SpringConfig {
//ssm整合之后，spring的配置信息写在此类中
}

13.3、创建WebConfig配置类，代替SpringMVC的配置文件

//springmvc的配置
//将类标识为配置类
@Configuration
//扫描组件
@ComponentScan("com.atguigu.controller")
//开启mvc的注解驱动
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override//默认的servlet处理静态资源
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Override//配置视图解析器
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
    }
    @Bean//文件上传解析器
    //这个注解可以将标识方法的返回值作为bean进行管理,id为方法的方法名
    public CommonsMultipartResolver multipartResolver(){
        return new CommonsMultipartResolver();
    }

    @Override//拦截器
    public void addInterceptors(InterceptorRegistry registry) {
        FirstInterceptor firstInterceptor = new FirstInterceptor();
        registry.addInterceptor(firstInterceptor).addPathPatterns("/**").excludePathPatterns("/abc");

    }

    @Override//异常解析器
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        Properties prop = new Properties();
        prop.setProperty("java.lang.ArithmeticException","error");
        exceptionResolver.setExceptionMappings(prop);
        exceptionResolver.setExceptionAttribute("ex");
        resolvers.add(exceptionResolver);
    }
    //配置生成模板解析器
    @Bean
    public ITemplateResolver templateResolver() {
        WebApplicationContext webApplicationContext =
                ContextLoader.getCurrentWebApplicationContext();
// ServletContextTemplateResolver需要一个ServletContext作为构造参数，可通过WebApplicationContext 的方法获得
        ServletContextTemplateResolver templateResolver = new
                ServletContextTemplateResolver(
                webApplicationContext.getServletContext());
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setCharacterEncoding("UTF-8");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        return templateResolver;
    }
    //生成模板引擎并为模板引擎注入模板解析器
    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver
                                                       templateResolver) {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
        return templateEngine;
    }
    //生成视图解析器并未解析器注入模板引擎
    @Bean
    public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setCharacterEncoding("UTF-8");
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }
}

Ayu___

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC

MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分M：Model，模型层，指工程中的JavaBean，作用是处理数据一类称为实体类Bean：专门存储业务数据的，如 Student、User 等一类称为业务处理 Bean：指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问。V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据，控制层，指工程中的servlet，作用是接收请求和响应浏览器。
复制链接

扫一扫