• SSM框架-SpringMVC(二)

    目录

    1 SpringMVC处理Ajax请求

    1.1 @RequestBody

    1.2 @RequestBody获取json格式的请求参数

    1.3 @ResponseBody

    1.4、@ResponseBody响应浏览器json数据

    1.5 @RestController注解

    2 文件上传和下载

    2.1 文件下载

    2.2 上传文件

    3 拦截器

    3.1 拦截器的三个抽象方法

    3.2 拦截器的配置

    3.3 多个拦截器的执行顺序

    4 异常处理器

    4.1 基于配置的异常处理

    4.2 基于注解的异常处理

    5 注解配置SpringMVC

    5.1 创建初始化类代理web.xml

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

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

    1 SpringMVC处理Ajax请求

    1.1 @RequestBody

    @RequestBody 可以获取请求体信息，使用 @RequestBody 注解标识控制器方法的形参，当前请求的请求体就会为当前注解所标识的形参赋值
    get是没有请求体的，所以我们必须使用post请求： 
    1. <form th:action="@{/test/requestBody}" method="post">
    2.     用户名:<input type="text" name="username"><br>
    3.     密码:<input type="password" name="password"><br>
    4.     <input type="submit" value="登录">
    5. form>
    1.     @RequestMapping(value = "/test/requestBody",method = RequestMethod.POST)
    2.     public String testRequesttBody(@RequestBody String requestBody){
    3.         System.out.println("requestBody:"+requestBody);
    4.         return "success";
    5.     }

    一个注解就能获得请求体的信息非常的方便。不过这里使用中文会发生乱码，暂时不知道啥情况

    1.2 @RequestBody获取json格式的请求参数

    在使用了axios发送ajax请求之后，浏览器发送到服务器的请求参数有两种格式：

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

    （2）{key:value,key:value,...} ，此时无法通过 request.getParameter() 获取，之前我们使用操作
    json 的相关 jar 包 gson 或 jackson 处理此类请求参数，可以将其转换为指定的实体类对象或 map 集
    合。在 SpringMVC 中，直接使用 @RequestBody 注解标识控制器方法的形参即可将此类请求参数
    转换为 java 对象
    使用@RequestBody获取json格式的请求参数的条件：
    第一步： 导入 jackson 的依赖 
    1.         <dependency>
    2.             <groupId>com.fasterxml.jackson.coregroupId>
    3.             <artifactId>jackson-databindartifactId>
    4.             <version>2.12.1version>
    5.         dependency>

    第二步：SpringMVC的配置文件中设置开启mvc的注解驱动 

    <mvc:annotation-driven/>

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

    1. html>
    2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>首页title>
    6. head>
    7. <body>
    8. <div id="app">
    9.     <h1>index.htmlh1>
    10.     <input type="button" value="使用@RequestBody注解处理json格式的请求参数" @click="testRequestBody()"><br>
    11.     <a th:href="@{/test/ResponseBody}">测试@ResponseBody注解响应浏览器数据a><br>
    12.     <input type="button" value="使用@ResponseBody注解响应json格式的数据" @click="testResponseBody()"><br>
    13. div>
    14.  
    15. <script type="text/javascript" th:src="@{/js/vue.js}">script>
    16. <script type="text/javascript" th:src="@{/js/axios.min.js}">script>
    17. <script type="text/javascript">
    18.  
    19.     /**
    20.      * axios({
    21.            url:"",//请求路径
    22.            method:"",//请求方式
    23.            //以name=value&name=value的方式发送的请求参数
    24.            //不管使用的请求方式是get或post，请求参数都会被拼接到请求地址后
    25.            //此种方式的请求参数可以通过request.getParameter()获取
    26.            params:{},
    27.            //以json格式发送的请求参数
    28.            //请求参数会被保存到请求报文的请求体传输到服务器
    29.            //此种方式的请求参数不可以通过request.getParameter()获取
    30.            data:{}
    31.        }).then(response=>{
    32.            console.log(response.data);
    33.        });
    34.      */
    35.  
    36.     var vue = new Vue({
    37.         el:"#app",
    38.         methods:{
    39.             testRequestBody(){
    40.                 axios.post(
    41.                     "/springmvc/test/RequestBody/json",
    42.                     {username:"admin",password:"123456",age:23,gender:"男"}
    43.                 ).then(response=>{
    44.                     console.log(response.data);
    45.                 });
    46.             },
    47.             testResponseBody(){
    48.                 axios.post("/springmvc/test/ResponseBody/json").then(response=>{
    49.                     console.log(response.data);
    50.                 });
    51.             }
    52.         }
    53.     });
    54. script>
    55. body>
    56. html>

    需要注意的是要想访问我们复制过来的js等静态文件需要在springmvc配置文件假如配置：

    1.     <mvc:default-servlet-handler />
    2.  
    3.     <mvc:annotation-driven/>

    因为：配置默认的servlet处理静态资源，当前工程的web.xml配置的前端控制器DispatcherServlet的url-pattern是/。tomcat的web.xml配置的DefaultServlet的url-pattern也是/ 。此时，浏览器发送的请求会优先被DispatcherServlet进行处理，但是DispatcherServlet无法处理静态资源。若配置了，此时浏览器发送的所有请求都会被DefaultServlet处理。若配置了和 浏览器发送的请求会先被DispatcherServlet处理，无法处理在交给DefaultServlet处理。

    1.     @RequestMapping(value = "/test/RequestBody/json")
    2.     public void testRequestBody(@RequestBody String requestBody, HttpServletResponse response) throws IOException {
    3.         System.out.println(requestBody);
    4.         response.getWriter().write("hello,ajax");
    5.     }

    这是使用一个字符串类型参数接收请求体，我们可以使用类来接收。

    1.     public void testRequestBody(@RequestBody User user, HttpServletResponse response) throws IOException {
    2.         System.out.println(user);
    3.         response.getWriter().write("hello,RequestBody");
    4.     }

    1.3 @ResponseBody

    我们之前控制器方法返回值是会跳转到一个页面如下：

    <a th:href="@{/test/ResponseBody}">测试@ResponseBody注解响应浏览器数据a><br>
    1.     @RequestMapping("/test/ResponseBody")
    2.     public String testResponseBody(){
    3.         //此时会跳转到逻辑视图success所对应的页面
    4.         return "success";
    5.     }

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

    1.4、@ResponseBody响应浏览器json数据

    服务器处理 ajax 请求之后，大多数情况都需要向浏览器响应一个 java 对象，此时必须将 java 对象转换为json字符串才可以响应到浏览器，之前我们使用操作 json 数据的 jar 包 gson 或 jackson 将 java 对象转换为json字符串。在 SpringMVC 中，我们可以直接使用 @ResponseBody 注解实现此功能
    @ResponseBody 响应浏览器 json 数据的条件：
    第一步： 导入 jackson 的依赖
    这个我们之前就导入过了
    第二步： SpringMVC 的配置文件中设置开启 mvc 的注解驱动
    这个我们可以设置过了
    第三步：使用@ResponseBody 注解标识控制器方法，在方法中，将需要转换为 json 字符串并响应到浏览器的java 对象作为控制器方法的返回值，此时 SpringMVC 就可以将此对象直接转换为 json 字符串并响应到浏览器 
    1.     public User testResponseBodyJson(){
    2.         User user = new User(1001, "admin", "123456", 20, "男");
    3.         return user;
    4.     }

    我们可以响应实体类，也可以响应list集合和map集合：

    1.     public List testResponseBodyJson(){
    2.         User user1 = new User(1001, "admin1", "123456", 20, "男");
    3.         User user2 = new User(1002, "admin2", "123456", 20, "男");
    4.         User user3 = new User(1003, "admin3", "123456", 20, "男");
    5.         List list = Arrays.asList(user1, user2, user3);
    6.         return list;
    7.     }

    1.     public Map testResponseBodyJson(){
    2.         User user1 = new User(1001, "admin1", "123456", 20, "男");
    3.         User user2 = new User(1002, "admin2", "123456", 20, "男");
    4.         User user3 = new User(1003, "admin3", "123456", 20, "男");
    5.         Map map = new HashMap<>();
    6.         map.put("1001", user1);
    7.         map.put("1002", user2);
    8.         map.put("1003", user3);
    9.         return map;
    10.     }

    1.5 @RestController注解

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

    2 文件上传和下载

    2.1 文件下载

    ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文， 使用 ResponseEntity 实现下载文件的功能
    我们先准备一张图片放在服务器中： 

    <a th:href="@{/test/down}">下载图片a>
    1.     @RequestMapping("/test/down")
    2.     public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws
    3.             IOException {
    4.         //获取ServletContext对象
    5.         ServletContext servletContext = session.getServletContext();
    6.         //获取服务器中文件的真实路径
    7.         String realPath = servletContext.getRealPath("img");
    8.         realPath = realPath + File.separator + "1.jpg";
    9.         //创建输入流
    10.         InputStream is = new FileInputStream(realPath);
    11.         //创建字节数组
    12.         byte[] bytes = new byte[is.available()];
    13.         //将流读到字节数组中
    14.         is.read(bytes);
    15.         //创建HttpHeaders对象设置响应头信息
    16.         MultiValueMap headers = new HttpHeaders();
    17.         //设置要下载方式以及下载文件的名字
    18.         headers.add("Content-Disposition", "attachment;filename=1.jpg");
    19.         //设置响应状态码
    20.         HttpStatus statusCode = HttpStatus.OK;
    21.         //创建ResponseEntity对象
    22.         ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, statusCode);
    23.         //关闭输入流
    24.         is.close();
    25.         return responseEntity;
    26.     }

    以上代码可以当做一个模板，需要下载别的文件时，我们只要改一下路径即可。

    2.2 上传文件

    文件上传要求 form 表单的请求方式必须为 post ，并且添加属性 enctype="multipart/form-data"
    SpringMVC 中将上传的文件封装到 MultipartFile 对象中，通过此对象可以获取文件相关信息
    第一步：添加依赖： 
    1.         <dependency>
    2.             <groupId>commons-fileuploadgroupId>
    3.             <artifactId>commons-fileuploadartifactId>
    4.             <version>1.3.1version>
    5.         dependency>

    第二步：在SpringMVC的配置文件中添加配置：

    这里一定要配置id名称而且必须是这个名称

    1.     
    2.     <bean id="multipartResolver"
    3.           class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    4.     bean>

    第三步：控制器方法和前端页面

    1.     <form th:action="@{/test/up}" method="post" enctype="multipart/form-data">
    2.         头像:<input type="file" name="photo"><br>
    3.         <input type="submit" value="上传">
    4.     form>
    1.     @RequestMapping("/test/up")
    2.     public String testUp(MultipartFile photo, HttpSession session) throws IOException {
    3.         //获取上传的文件的文件名
    4.         String fileName = photo.getOriginalFilename();
    5.         //获取上传的文件的后缀名
    6.         String hzName = fileName.substring(fileName.lastIndexOf("."));
    7.         //获取uuid
    8.         String uuid = UUID.randomUUID().toString();
    9.         //拼接一个新的文件名
    10.         fileName = uuid + hzName;
    11.         //获取ServletContext对象
    12.         ServletContext servletContext = session.getServletContext();
    13.         //获取当前工程下photo目录的真实路径
    14.         String photoPath = servletContext.getRealPath("photo");
    15.         //创建photoPath所对应的File对象
    16.         File file = new File(photoPath);
    17.         //判断file所对应目录是否存在
    18.         if(!file.exists()){
    19.             file.mkdir();
    20.         }
    21.         String finalPath = photoPath + File.separator + fileName;
    22.         //上传文件
    23.         photo.transferTo(new File(finalPath));
    24.         return "success";
    25.     }

    注意我们用以下代码拼接一个新的文件名，因为假如我们上传的文件名相同的文件，它会覆盖前面的文件，我们可以手动将文件名修改：

    3 拦截器

    3.1 拦截器的三个抽象方法

    • preHandle()：在控制器方法执行之前执行，其返回值表示对控制器方法的拦截(false)或放行(true)
    • postHandle()：在控制器方法执行之后执行
    • afterCompletion()：在控制器方法执行之后，且渲染视图完毕之后执行

    我们创建一个类实现这三个方法

    1. package com.itzw.controller;
    2.  
    3. import org.springframework.stereotype.Controller;
    4. import org.springframework.web.servlet.HandlerInterceptor;
    5. import org.springframework.web.servlet.ModelAndView;
    6.  
    7. import javax.servlet.http.HttpServletRequest;
    8. import javax.servlet.http.HttpServletResponse;
    9.  
    10. @Controller
    11. public class FirstInterceptor implements HandlerInterceptor {
    12.  
    13.     @Override
    14.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    15.         System.out.println("FirstInterceptor-->preHandle");
    16.         return true;
    17.     }
    18.  
    19.     @Override
    20.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    21.         System.out.println("FirstInterceptor-->postHandle");
    22.     }
    23.  
    24.     @Override
    25.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    26.         System.out.println("FirstInterceptor-->afterCompletion");
    27.     }
    28. }

    3.2 拦截器的配置

    SpringMVC 中的拦截器用于拦截控制器方法的执行
    SpringMVC 中的拦截器需要实现 HandlerInterceptor
    SpringMVC 的拦截器必须在 SpringMVC 的配置文件中进行配置：
    第一种方式：将实现拦截器的类配置到这个标签里 
    1.     <mvc:interceptors>
    2.         <bean class="com.itzw.interceptor.FirstInterceptor"/>
    3.     mvc:interceptors>

    第二种方式：在外面配置bean然后再引入

    1.     <bean id="interceptor" class="com.itzw.interceptor.FirstInterceptor"/>
    2.     <mvc:interceptors>
    3.         
    4.         <ref bean="interceptor"/>
    5.     mvc:interceptors>

    第三种方式：不在外面配置bean，直接使用注解，控制加扫描的方式

    1.     <mvc:interceptors>
    2.         
    3.         <ref bean="firstInterceptor"/>
    4.     mvc:interceptors>

    值得注意的是：bean和ref标签所配置的拦截器默认对DIspatcherServlet处理的所有的请求进行拦截，即使是不存在路径也会拦截，那我要是不想拦截某个路径呢？

    进行如上配置，如果配置的是“/*”则表示拦截所有一层目录比如“/x”，但是“/x/y”就不会拦截了。

    3.3 多个拦截器的执行顺序

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

    4 异常处理器

    4.1 基于配置的异常处理

     

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

    编写异常处理器：

    其中key的值表示处理器方法执行过程中出现的异常，而它的值表示出现异常时跳转到指定视图

    我们还可以通过配置输出异常信息：

    <property name="exceptionAttribute" value="ex">property>
    exceptionAttribute 属性设置一个属性名，将出现的异常信息在请求域中进行共享，我们在error页面接收这个信息： 
    "${ex}">

    4.2 基于注解的异常处理

    我们需要单独写一个类来代替配置：

    1. package com.itzw.controller;
    2.  
    3. import org.springframework.ui.Model;
    4. import org.springframework.web.bind.annotation.ControllerAdvice;
    5. import org.springframework.web.bind.annotation.ExceptionHandler;
    6.  
    7. @ControllerAdvice
    8. public class ExceptionTest {
    9.  
    10.     @ExceptionHandler(ArithmeticException.class)
    11.     public String test(Model model, Exception ex){
    12.         model.addAttribute("ex",ex);
    13.         return "error";
    14.     }
    15. }

    @ControllerAdvice将当前类标识为异常处理器的组件；@ExceptionHandler用于设置所表示方法处理的异常；ex表示当前请求处理中出现的异常对象

    5 注解配置SpringMVC

    5.1 创建初始化类代理web.xml

    在 Servlet3.0 环境中，容器会在类路径中查找实现 javax.servlet.ServletContainerInitializer 接口的类，如果找到的话就用它来配置Servlet 容器。 Spring 提供了这个接口的实现，名为
    SpringServletContainerInitializer ，这个类反过来又会查找实现 WebApplicationInitializer 的类并将配置的任务交给它们来完成。Spring3.2 引入了一个便利的 WebApplicationInitializer 基础实现，名为AbstractAnnotationConfigDispatcherServletInitializer，当我们的类扩展了
    AbstractAnnotationConfigDispatcherServletInitializer 并将其部署到 Servlet3.0 容器的时候，容器自
    动发现它，并用它来配置 Servlet 上下文。
    我们创建一个类继承接口 AbstractAnnotationConfigDispatcherServletInitializer，重写接口的三个必须重写的方法，这些方法的作用分别为： 指定spring的配置类；指定SpringMVC的配置类；指定DispatcherServlet的映射规则，即url-pattern。web.xml文件还配置了过滤器，我们也要重写，如下： 
    1. package com.itzw.config;
    2.  
    3. import org.springframework.web.filter.CharacterEncodingFilter;
    4. import org.springframework.web.filter.HiddenHttpMethodFilter;
    5. import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
    6.  
    7. import javax.servlet.Filter;
    8.  
    9. public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {
    10.  
    11.     /**
    12.      * 指定Spring的配置类
    13.      * @return
    14.      */
    15.     @Override
    16.     protected Class[] getRootConfigClasses() {
    17.         return new Class[]{SpringConfig.class};
    18.     }
    19.  
    20.     /**
    21.      * 指定SpringMVC的配置类
    22.      * @return
    23.      */
    24.     @Override
    25.     protected Class[] getServletConfigClasses() {
    26.         return new Class[]{WebConfig.class};
    27.     }
    28.  
    29.     /**
    30.      * 指定DispatcherServlet的映射规则，即url-pattern
    31.      * @return
    32.      */
    33.     @Override
    34.     protected String[] getServletMappings() {
    35.         return new String[]{"/"};
    36.     }
    37.  
    38.     /**
    39.      * 设置当前的过滤器
    40.      * @return
    41.      */
    42.     @Override
    43.     protected Filter[] getServletFilters() {
    44.         //创建编码过滤器
    45.         CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
    46.         characterEncodingFilter.setEncoding("UTF-8");
    47.         characterEncodingFilter.setForceEncoding(true);
    48.         //创建处理请求方式的过滤器
    49.         HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
    50.         return new Filter[]{characterEncodingFilter,hiddenHttpMethodFilter};
    51.     }
    52. }

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

    1. package com.itzw.config;
    2.  
    3. import org.springframework.context.annotation.Configuration;
    4.  
    5. @Configuration
    6. public class SpringConfig {
    7. }

    这个以后需要我们再详细配置，之前我们学spring的时候就使用过这个。@Configuration的作用是将类标识为配置类

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

    SpringMVC配置文件配置的内容包括：扫描组件、视图解析器、默认的servlet、mvc的注解驱动 、视图控制器、文件上传解析器、拦截器、异常解析器
    我们一个个配置：

    首先我们实现接口WebMvcConfigurer

    注解@EnableWebMvc用来开启mvc注解驱动，对应配置文件的

    注解@ComponentScan用来扫描组件，对应配置文件的

    1. package com.itzw.config;
    2.  
    3. import org.springframework.context.annotation.ComponentScan;
    4. import org.springframework.context.annotation.Configuration;
    5. import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
    6. import org.springframework.web.servlet.config.annotation.EnableWebMvc;
    7. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    8.  
    9. @Configuration
    10. //扫描组件
    11. @ComponentScan("com.itzw.controller")
    12. //开启mvc注解驱动
    13. @EnableWebMvc
    14. public class WebConfig implements WebMvcConfigurer {
    15.     
    16. }

    我们再重写这个接口的方法实现其它功能：

    配置默认的servlet处理静态资源（css、js等资源），固定配置如下：

    1.     @Override
    2.     public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
    3.         configurer.enable();
    4.     }

    对应配置文件的：

    配置视图解析器：

    1.     @Override
    2.     public void addViewControllers(ViewControllerRegistry registry) {
    3.         registry.addViewController("/").setViewName("index");
    4.     }

    对应配置文件的：

    配置文件上传解析器：固定写法

    1.     @Bean
    2.     public CommonsMultipartResolver multipartResolver(){
    3.         return new CommonsMultipartResolver();
    4.     }

    这个方法需要我们自己写，其中@Bean注解可以将表示的方法的返回值作为bean进行管理，bean的id为方法的方法名。对应配置文件中的：

    1.     
    2.     <bean id="multipartResolver"
    3.           class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    4.     bean>

    配置拦截器：

    配置拦截器首先我们要有个拦截器，还记得拦截器怎么创建吗？

    1. package com.itzw.interceptor;
    2.  
    3. import org.springframework.web.servlet.HandlerInterceptor;
    4. import org.springframework.web.servlet.ModelAndView;
    5.  
    6. import javax.servlet.http.HttpServletRequest;
    7. import javax.servlet.http.HttpServletResponse;
    8.  
    9. public class FirstInterceptor implements HandlerInterceptor {
    10.     @Override
    11.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    12.         return true;
    13.     }
    14.  
    15.     @Override
    16.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    17.     }
    18.  
    19.     @Override
    20.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    21.     }
    22. }

    然后配置拦截器：

    1.     public void addInterceptors(InterceptorRegistry registry) {
    2.         FirstInterceptor firstInterceptor = new FirstInterceptor();
    3.         //拦截所有路径
    4.         registry.addInterceptor(firstInterceptor).addPathPatterns("/**");
    5.     }

    对应的配置文件为：

    1.     <mvc:interceptors>
    2.         
    3.         <ref bean="firstInterceptor"/>
    4.         <mvc:interceptor>
    5.             <mvc:mapping path="/**"/>
    6.             <mvc:exclude-mapping path="/a/b"/>
    7.             <ref bean="firstInterceptor"/>
    8.         mvc:interceptor>
    9.     mvc:interceptors>

    配置异常解析器：

    1.     @Override
    2.     public void configureHandlerExceptionResolvers(List resolvers) {
    3.         SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
    4.         Properties prop = new Properties();
    5.         prop.setProperty("java.lang.ArithmeticException","error");
    6.         exceptionResolver.setExceptionMappings(prop);
    7.         exceptionResolver.setExceptionAttribute("ex");
    8.         resolvers.add(exceptionResolver);
    9.     }

    对应配置文件：

    1.     <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    2.         <property name="exceptionMappings">
    3.             <props>
    4.                 <prop key="java.lang.ArithmeticException">errorprop>
    5.             props>
    6.         property>
    7.         <property name="exceptionAttribute" value="ex">property>
    8.     bean>

    配置视图解析器：

    1.     //配置生成模板解析器
    2.     @Bean
    3.     public ITemplateResolver templateResolver() {
    4.         WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
    5.         // ServletContextTemplateResolver需要一个ServletContext作为构造参数，可通过WebApplicationContext 的方法获得
    6.         ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver(
    7.                 webApplicationContext.getServletContext());
    8.         templateResolver.setPrefix("/WEB-INF/templates/");
    9.         templateResolver.setSuffix(".html");
    10.         templateResolver.setCharacterEncoding("UTF-8");
    11.         templateResolver.setTemplateMode(TemplateMode.HTML);
    12.         return templateResolver;
    13.     }
    14.  
    15.     //生成模板引擎并为模板引擎注入模板解析器
    16.     @Bean
    17.     public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver) {
    18.         SpringTemplateEngine templateEngine = new SpringTemplateEngine();
    19.         templateEngine.setTemplateResolver(templateResolver);
    20.         return templateEngine;
    21.     }
    22.  
    23.     //生成视图解析器并未解析器注入模板引擎
    24.     @Bean
    25.     public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
    26.         ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
    27.         viewResolver.setCharacterEncoding("UTF-8");
    28.         viewResolver.setTemplateEngine(templateEngine);
    29.         return viewResolver;
    30.     }

    对应的配置文件是：

    1.     
    2.     <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
    3.         <property name="order" value="1"/>
    4.         <property name="characterEncoding" value="UTF-8"/>
    5.         <property name="templateEngine">
    6.             <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
    7.                 <property name="templateResolver">
    8.                     <bean
    9.                             class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
    10.                         
    11.                         <property name="prefix" value="/WEB-INF/templates/"/>
    12.                         
    13.                         <property name="suffix" value=".html"/>
    14.                         <property name="templateMode" value="HTML5"/>
    15.                         <property name="characterEncoding" value="UTF-8" />
    16.                     bean>
    17.                 property>
    18.             bean>
    19.         property>
    20.     bean>

    这样就配置完成了，之前我们遇到的需要配置的东西都用注解的方式实现了。
    下面我们就可以将SSM三个框架整合在一起了。

  • 相关阅读:
    浏览器中输入URL后到底发生了什么？
    HTML+CSS：rem、vw / vh移动适配、媒体查询
    uniapp接口请求api封装，规范化调用
    2.1 C++面向对象编程_访问控制和继承
    ERP编制物料清单 金蝶
    maven打包把代码包和依赖包分开打包
    百度文心一言4.0抢先体验教程！
    如何通过工单管理系统提高服务质量和客户满意度？
    API(3) StringBuffer类和StringBulider类
    uni-app的支付与打包上传
  • 原文地址：https://blog.csdn.net/weixin_46051964/article/details/128176955