MeiMing_104

Spring笔记(四)(黑马)(web层解决方案-SpringMVC)

01、Spring MVC 简介

1.1 SpringMVC概述

SpringMVC是一个基于Spring开发的MVC轻量级框架，Spring3.0后发布的组件，SpringMVC和Spring可以无缝整合，使用DispatcherServlet作为前端控制器，且内部提供了处理器映射器、处理器适配器、视图解析器等组件，可以简化JavaBean封装，Json转化、文件上传等操作。

用户请求–> SpringMVC框架(前端控制器)
SpringMVC框架分发请求到不同的Controller

1.2 SpringMVC快速入门

导入Spring整合SpringMVC的坐标

<dependency>
  <groupId>org.springframeworkgroupId>
  <artifactId>spring-webmvcartifactId>
  <version>5.3.7version>
dependency>

在web.xml中配置SpringMVC的前端控制器ServletDispatcher


<servlet>
    <servlet-name>DispatcherServletservlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    <init-param>
        
        <param-name>contextConfigLocationparam-name>
        <param-value>classpath:spring-mvc.xmlparam-value>
    init-param>
    
    <load-on-startup>2load-on-startup>
servlet>
<servlet-mapping>
    <servlet-name>DispatcherServletservlet-name>
    <url-pattern>/url-pattern>
servlet-mapping>

编写一个控制器Controller，配置映射信息，并交给SpringMVC容器管理

@Controller
public class QuickController {
    @RequestMapping("/show")
    public void show(){
        System.out.println("show ...");
    }
}

测试，访问http://localhost:8080/show

页面报错：

控制台正常打印show ...

改进: 将controller层中的show()方法返回值改为String,并添加上相应的页面

@Controller
public class QuickController {
    @RequestMapping("/show")
    public String show(){
        System.out.println("show ...");
        return "/show.jsp";
    }
}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>title>
head>
<body>
    <h1>showh1>
body>
html>

访问页面结果：

1.3 Controller中访问容器中的Bean

DispatcherServlet在进行初始化时，加载的spring-mvc.xml配置文件创建的SpringMVC容器，那么web层 Controller被扫描进入到了容器中，而之前Spring容器中的Service是否可以获取到呢？下面搭建Spring的web环境进行验证

创建service层

public interface QuickService {
}

@Service
public class QuickServiceImpl implements QuickService {
}

创建Spring的配置文件applicationContext.xml，配置Spring包扫描


<context:component-scan base-package="com.mem.service"/>

在web.xml中配置ContextLoadListener及初始参数



<context-param>
    <param-name>contextConfigLocationparam-name>
    <param-value>classpath:applicationContext.xmlparam-value>
context-param>

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
listener>

在Controller层注入QuickService对象

@Controller
public class QuickController {

    @Autowired
    private QuickService quickService;

    @RequestMapping("/show")
    public String show(){
        System.out.println("show ...");
        System.out.println("quickService:"+quickService);
        return "/show.jsp";
    }
}

测试：控制台打印出quickService的地址quickService:com.mem.service.impl.QuickServiceImpl@5f87226c

流程：

服务器启动时ServletContext对象创建，ContextLoaderListener监听器执行

内部加载applicationContext.xml文件，spring组件扫描执行(扫描service包)

解析@Service注解，加入Spring容器

controller层使用@Autowired在SpringMVC容器中，注入Service

Spring系列第24篇：父子容器详解_路人甲Java的博客-CSDN博客

1.4 SpringMVC关键组件浅析

上面已经完成的快速入门的操作，也在不知不觉中完成的Spring和SpringMVC的整合，我们只需要按照规则去定义Controller和业务方法就可以。但是在这个过程中，肯定是很多核心功能类参与到其中，这些核心功能类，一般称为组件。当请求到达服务器时，是哪个组件接收的请求，是哪个组件帮我们找到的Controller，是哪个组件帮我们调用的方法，又是哪个组件最终解析的视图？

先简单了解一下以上三个重要组件的关系：

SpringMVC的默认组件，SpringMVC 在前端控制器 DispatcherServlet加载时，就会进行初始化操作，在进行初始化时，就会加载SpringMVC默认指定的一些组件，这些默认组件配置在 DispatcherServlet.properties 文件中，该文件存在与spring-webmvc-5.3.7.jar包下的 org\springframework\web\servlet\DispatcherServlet.properties

这些默认的组件是在DispatcherServlet中进行初始化加载的，在DispatcherServlet中存在集合存储着这些组件， SpringMVC的默认组件会在 DispatcherServlet 中进行维护，但是并没有存储在与SpringMVC的容器中

public class DispatcherServlet extends FrameworkServlet {
    //存储处理器映射器
    private List<HandlerMapping> handlerMappings;
    //存储处理器适配器
    private List<HandlerAdapter> handlerAdapters;
    //存储视图解析器
    private List<ViewResolver> viewResolvers;
    // ... 省略其他代码 ...

    protected void initStrategies(ApplicationContext context) {
        this.initMultipartResolver(context);
        this.initLocaleResolver(context);
        this.initThemeResolver(context);
        this.initHandlerMappings(context); // 以这个为例
        this.initHandlerAdapters(context);
        this.initHandlerExceptionResolvers(context);
        this.initRequestToViewNameTranslator(context);
        this.initViewResolvers(context);
        this.initFlashMapManager(context);
    }
    private void initHandlerMappings(ApplicationContext context) {
    	// 获取DispatcherServlet.properties文件中的三个类
        this.handlerMappings = this.getDefaultStrategies(context, HandlerMapping.class);
    }
}

配置组件代替默认组件，如果不想使用默认组件，可以将替代方案使用Spring Bean的方式进行配置，例如，在 spring-mvc.xml中配置RequestMappingHandlerMapping


<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>

当我们在Spring容器中配置了HandlerMapping，则就不会在加载默认的HandlerMapping策略了，原理比较简单， DispatcherServlet 在进行HandlerMapping初始化时，先从SpringMVC容器中找是否存在HandlerMapping，如果存在直接取出容器中的HandlerMapping，在存储到 DispatcherServlet 中的handlerMappings集合中去。

02、Spring MVC 的请求处理

2.1 请求映射路径的配置

配置映射路径，映射器处理器才能找到Controller的方法资源，目前主流映射路径配置方式就是@RequestMapping

@RequestMapping

@RequestMapping注解，主要使用在控制器的方法上，用于标识客户端访问资源路径，常用的属性有value、path 、method、headers、params等。当@RequestMapping只有一个访问路径需要指定时，使用value属性、path属性或省略value和path，当有多个属性时，value和path不能省略

@RequestMapping(value = "/show")//使用value属性指定一个访问路径
public String show(){}
@RequestMapping(value = {"/show","/haohao","/abc"})//使用value属性指定多个访问路径
public String show(){}
@RequestMapping(path = "/show")//使用path属性指定一个访问路径
public String show(){}
@RequestMapping(path = {"/show","/haohao","/abc"})//使用path属性指定多个访问路径
public String show(){}
@RequestMapping("/show")//如果只设置访问路径时，value和path可以省略
public String show(){}
@RequestMapping({"/show","/haohao","/abc"})
public String show(){}

当@RequestMapping 需要限定访问方式时，可以通过method属性设置

//请求地址是/show,且请求方式必须是POST才能匹配成功
@RequestMapping(value = "/show",method = RequestMethod.POST)
public String show(){}

method的属性值是一个枚举类型，源码如下：

public enum RequestMethod {
    GET,
    HEAD,
    POST,
    PUT,
    PATCH,
    DELETE,
    OPTIONS,
    TRACE;
    private RequestMethod() {
    }
}

@GetMapping

当请求方式是GET时，我们可以使用@GetMapping替代@RequestMapping

@GetMapping("/show")
public String show(){}

@PostMapping

当请求方式是POST时，我们可以使用@PostMapping替代@RequestMapping

@PostMapping("/show")
public String show(){}

@RequestMapping 在类上使用，@RequestMapping 、@GetMapping、@PostMapping还可以使用在 Controller类上，使用在类上后，该类所有方法都公用该@RequestMapping设置的属性，访问路径则为类上的映射地址+方法上的映射地址，例如：

@Controller
@RequestMapping("/xxx")
public class UserController implements ApplicationContextAware, ServletContextAware {
    @GetMapping("/aaa")
    public ModelAndView aaa(HttpServletResponse response) throws IOException, ModelAndViewDefiningException {
        return null;
    }
}

此时的访问路径为：/xxx/aaa

2.2 请求数据的接收

接收普通请求数据,同名形参

接收普通请求数据，当客户端提交的数据是普通键值对形式时，直接使用同名形参接收即可
比如路径为：http://localhost:8080/show?username=haohao&age=35
数据接收如下：

@GetMapping("/show")
public String show(String username, int age){
    System.out.println(username+"=="+age);
    return "/index.jsp";
}

接收普通请求数据,不同名形参

接收普通请求数据，当请求参数的名称与方法参数名不一致时，可以使用@RequestParam注解进行标注
比如路径为：http://localhost:8080/show?username=haohao&age=35
数据接收如下：

@GetMapping("/show")
public String show(@RequestParam(name = "username",required = true) String name, int age){
    System.out.println(name+"=="+age);
    return "/index.jsp";
}

接收数组或集合数据,同名形参

接收数组或集合数据，客户端传递多个同名参数时，可以使用数组接收
比如路径为：http://localhost:8080/show?hobbies=eat&hobbies=sleep
数据接收如下：

@GetMapping("/show")
public String show(String[] hobbies){
    for (String hobby : hobbies) {
		System.out.println(hobby);
    }
    return "/index.jsp";
}

客户端传递多个同名参数时，也可以使用单列集合接收，但是需要使用@RequestParam告知框架传递的参数是要同名设置的，不是对象属性设置的

@GetMapping("/show")
public String show(@RequestParam List<String> hobbies){
    for (String hobby : hobbies) {
		System.out.println(hobby);
    }
    return "/index.jsp";
}

接收数组或集合数据，不同形参

接收数组或集合数据，客户端传递多个不同命参数时，也可以使用Map进行接收，同样需要用 @RequestParam 进行修饰
比如路径为：http://localhost:8080/show?username=haohao&age=35
数据接收如下：

@GetMapping("/show")
public String show(@RequestParam Map<String,Object> params){
    params.forEach((key,value)->{
    	System.out.println(key+"=="+value);
    });
    return "/index.jsp";
}

接收实体JavaBean属性数据

接收实体JavaBean属性数据，单个JavaBean数据：提交的参数名称只要与Java的属性名一致，就可以进行自动封装
比如路径为：http://localhost:8080/show?username=haohao&age=35&hobbies=eat&hobbies=sleep
数据接收如下：

public class User {
    private String username;
    private Integer age;
    private String[] hobbies;
    private Date birthday;
    private Address address;
    //... 省略get和set方法 ... 
}
public class Address {
    private String city;
    private String area;
}

@GetMapping("/show")
public String show(User user){
	System.out.println(user);
    return "/index.jsp";
}

接收实体JavaBean属性数据，嵌套JavaBean数据：提交的参数名称用 . 去描述嵌套对象的属性关系即可
http://localhost:8080/show?username=haohao&address.city=tianjin&address.area=jinghai

接收Json数据格式数据

接收Json数据格式数据，Json数据都是以请求体的方式提交的，且不是原始的键值对格式的，所以我们要使用 @RequestBody注解整体接收该数据。
比如路径为：http://localhost:8080/show，请求方式:post

{
  "username":"haohao",
  "age":18,
  "hobbies":["eat","sleep"],
  "birthday":"1986-01-01",
  "address":{
    "city":"tj",
    "area":"binhai"
  }
}

数据接收如下：

@PostMapping("/show")
public String show((@RequestBody String body){
    System.out.println(body);
    return "/index.jsp";
}

改进：使用Json工具（ jackson ）将Json格式的字符串转化为JavaBean进行操作 (手动)

@PostMapping("/show")
public String show(@RequestBody String body) throws IOException {
    System.out.println(body);
    //获取ObjectMapper
    ObjectMapper objectMapper = new ObjectMapper();
    //将json格式字符串转化成指定的User
    User user = objectMapper.readValue(body, User.class);
    System.out.println(user);
    return "/index.jsp";
}

改进：配置RequestMappingHandlerAdapter，指定消息转换器，就不用手动转换json格式字符串了(自动)


<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
  <property name="messageConverters">
    <list>
      <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
    list>
  property>
bean>

配置RequestMappingHandlerAdapter，直接用对象接收

@PostMapping("/show")
public String show(@RequestBody User user){
    System.out.println(user);
    return "/index.jsp";
}

配置RequestMappingHandlerAdapter，使用Map接收json格式字符串

@PostMapping("/show")
public String show(@RequestBody Map map){
    System.out.println(map);
    return "/index.jsp";
}

接收Restful风格数据

什么是Rest风格？
Rest（Representational State Transfer）表象化状态转变（表述性状态转变），在2000年被提出，基于HTTP、URI 、xml、JSON等标准和协议，支持轻量级、跨平台、跨语言的架构设计。是Web服务的一种新网络应用程序的设计风格和开发方式。
Restful风格的请求，常见的规则有如下三点：

用URI表示某个模块资源，资源名称为名词；

用请求方式表示模块具体业务动作，例如：GET表示查询、POST表示插入、PUT表示更新、DELETE表示删除

用HTTP响应状态码表示结果，国内常用的响应包括三部分：状态码、状态信息、响应数据

使用Rest风格：
接收Restful风格数据，Restful请求数据一般会在URL地址上携带，可以使用注解 @PathVariable(占位符参数名称)
http://localhost:8080/user/100

@PostMapping("/user/{id}")
public String findUserById(@PathVariable("id") Integer id){
    System.out.println(id);
    return "/index.jsp";
}

请求URL资源地址包含多个参数情况:http://localhost:8080/user/haohao/18

@PostMapping("/user/{username}/{age}")
public String findUserByUsernameAndAge(@PathVariable("username") String username,
                                       @PathVariable("age") Integer age){
    System.out.println(username+"=="+age);
    return "/index.jsp";
}

接收文件上传的数据，文件上传的表单需要一定的要求，如下：
- 表单的提交方式必须是POST
- 表单的enctype属性必须是multipart/form-data
- 文件上传项需要有name属性

<form action="" enctype="multipart/form-data" method="post">
	<input type="file" name="myFile">
form>

服务器端，由于映射器适配器需要文件上传解析器，而该解析器默认未被注册，所以手动注册


<bean id="multipartResolver" 
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  <property name="defaultEncoding" value="UTF-8"/>
  <property name="maxUploadSizePerFile" value="1048576"/>
  <property name="maxUploadSize" value="3145728"/>
  <property name="maxInMemorySize" value="1048576"/>
bean>

而CommonsMultipartResolver底层使用的Apache的是Common-fileuplad等工具API进行的文件上传

<dependency>
  <groupId>commons-fileuploadgroupId>
  <artifactId>commons-fileuploadartifactId>
  <version>1.4version>
dependency>

使用MultipartFile类型接收上传文件

@PostMapping("/fileUpload")
public String fileUpload(@RequestBody MultipartFile myFile) throws IOException {
    System.out.println(myFile);
    //获得上传的文件的流对象
    InputStream inputStream = myFile.getInputStream();
    //使用commons-io存储到C:\haohao\abc.txt位置
    FileOutputStream outputStream = new FileOutputStream("C:\\Users\\haohao\\"+myFile.getOriginalFilename());
    IOUtils.copy(inputStream,outputStream);
    //关闭资源
    inputStream.close();
    outputStream.close();
return "/index.jsp";
}

若接收多个文件，变为数组即可

接收Http请求头数据，接收指定名称的请求头

@GetMapping("/headers")
public String headers(@RequestHeader("Accept-Encoding") String acceptEncoding){
    System.out.println("Accept-Encoding:"+acceptEncoding);
    return "/index.jsp";
}

接收所有的请求头信息

@GetMapping("/headersMap")
public String headersMap(@RequestHeader Map<String,String> map){
    map.forEach((k,v)->{
    	System.out.println(k+":"+v);
    });
    return "/index.jsp";
}

获得客户端携带的Cookie数据

@GetMapping("/cookies")
public String cookies(@CookieValue(value = "JSESSIONID",defaultValue = "") String jsessionid){
    System.out.println(jsessionid);
    return "/index.jsp";
}

获得转发Request域中数据，在进行资源之间转发时，有时需要将一些参数存储到request域中携带给下一个资源

@GetMapping("/request1")
public String request1(HttpServletRequest request){
    //存储数据
    request.setAttribute("username","haohao");
    return "/request2";
}

@GetMapping("/request2")
public String request2(@RequestAttribute("username") String username){
    System.out.println(username);
    return "/index.jsp";
}

请求参数乱码的解决方案，Spring已经提供好的CharacterEncodingFilter来进行编码过滤

2.3 Javaweb常用对象的获取

获得Javaweb常见原生对象，有时在我们的Controller方法中需要用到Javaweb的原生对象，例如：Request、 Response等，我们只需要将需要的对象以形参的形式写在方法上，SpringMVC框架在调用Controller方法时，会自动传递实参：

@GetMapping("/javawebObject")
public String javawebObject(HttpServletRequest request, HttpServletResponse response, 
HttpSession session){
    System.out.println(request);
    System.out.println(response);
    System.out.println(session);
    return "/index.jsp";
}

2.4 请求静态资源

静态资源请求失效的原因，当DispatcherServlet的映射路径配置为 / 的时候，那么就覆盖的Tomcat容器默认的缺省 Servlet，在Tomcat的config目录下有一个web.xml 是对所有的web项目的全局配置，其中有如下配置：

url-pattern配置为 / 的Servlet我们称其为缺省的Servlet，作用是：当其他Servlet都匹配不成功时，就找缺省的Servlet ，静态资源由于没有匹配成功的Servlet，所以会找缺省的DefaultServlet，该DefaultServlet具备二次去匹配静态资源的功能。
但是我们配置DispatcherServlet后就将其覆盖掉了，而DispatcherServlet会将请求的静态资源的名称当成Controller的映射路径去匹配，即静态资源访问不成功了！

静态资源请求的三种解决方案：
第一种方案：
在web.xml中，可以再次激活Tomcat的DefaultServlet，Servlet的url-pattern的匹配优先级是：精确匹配>目录匹配> 扩展名匹配>缺省匹配，所以可以指定某个目录下或某个扩展名的资源使用DefaultServlet进行解析：

第二种方案：
在spring-mvc.xml中去配置静态资源映射，匹配映射路径的请求到指定的位置去匹配资源

第三种方案：
在spring-mvc.xml中去配置mvc:default-servlet-handler，该方式是注册了一个 DefaultServletHttpRequestHandler 处理器，静态资源的访问都由该处理器去处理，这也是开发中使用最多的

2.5 注解驱动mvc:annotation-driven标签

静态资源配置的第二第三种方式我们可以正常访问静态资源了，但是Controller又无法访问了，报错404，即找不到对应的资源

原因分析：
第二种方式是通过SpringMVC去解析mvc命名空间下的resources标签完成的静态资源解析、
第三种方式式通过SpringMVC去解析mvc命名空间下的default-servlet-handler标签完成的静态资源解析、
根据前面所学习的自定义命名空间的解析的知识，可以发现不管是以上哪种方式，最终都会注册SimpleUrlHandlerMapping

又结合组件浅析知识点，一旦SpringMVC容器中存在 HandlerMapping 类型的组件时，前端控制器 DispatcherServlet在进行初始化时，就会从容器中获得HandlerMapping ，不在加载 dispatcherServlet.properties 中默认处理器映射器策略，那也就意味着RequestMappingHandlerMapping不会被加载到了。

RequestMappingHandlerMapping的作用是：解析@RequestMapping(“”)注解的，最后容器中没有RequestMappingHandlerMapping的bean 也就没办法识别里面的内容了

解决方法：
手动将RequestMappingHandlerMapping也注册到SpringMVC容器中就可以了，这样DispatcherServlet在进行初始化时，就会从容器中同时获得RequestMappingHandlerMapping存储到DispatcherServlet中名为 handlerMappings的List集合中，对@RequestMapping 注解进行解析。

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>

根据上面的讲解，可以总结一下，要想使用@RequestMapping正常映射到资源方法，同时静态资源还能正常访问，还可以将请求json格式字符串和JavaBean之间自由转换，我们就需要在spring-mvc.xml中进行如下配置：


<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <property name="messageConverters">
        <list>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        list>
    property>
bean>

其实，spring作为一个暖男，将上述配置浓缩成了一个简单的配置标签，那就是mvc的注解驱动，该标签内部会帮我们注册RequestMappingHandlerMapping、注册 RequestMappingHandlerAdapter并注入Json消息转换器等，上述配置就可以简化成如下：


<mvc:default-servlet-handler/>

<mvc:annotation-driven/>

PS: mvc:annotation-driven/ 标签在不同的版本中，帮我们注册的组件不同。
Spring 3.0.X 版本注册是 DefaultAnnotationHandlerMapping 和 AnnotationMethodHandlerAdapter，由于框架的发展，从Spring 3.1.X 开始注册组件变为 RequestMappingHandlerMapping和RequestMappingHandlerAdapter

03、Spring MVC 的响应处理

3.1 传统同步业务数据响应

Spring的接收请求的部分我们讲完了，下面在看一下Spring怎么给客户端响应数据，响应数据主要分为两大部分：

传统同步方式：准备好模型数据，在跳转到执行页面进行展示，此方式使用越来越少了，基于历史原因，一些旧项目还在使用；
前后端分离异步方式：前端使用Ajax技术+Restful风格与服务端进行Json格式为主的数据交互，目前市场上几乎都是此种方式了。

传统方式

传统同步业务在数据响应时，SpringMVC又涉及如下四种形式：

请求资源转发；
请求资源重定向；
响应模型数据；
直接回写数据给客户端；

请求资源转发

请求资源重定向

响应模型数据，响应模型数据本质也是转发，在转发时可以准备模型数据

@RequestMapping("/resp3")
public ModelAndView resp3(ModelAndView modelAndView){
    // ModelAndView封装模型数据和视图名
    // 设置模型数据
    User user = new User();
    user.setUsername("haohao");
    user.setAge(18);
    modelAndView.addObject("user",user);
    // 设置试图名，在页面中展示模型数据
    modelAndView.setViewName("/show.jsp");
    return modelAndView;
}

访问：

直接回写数据，直接通过方法的返回值返回给客户端的字符串，但是SpringMVC默认的方法返回值是视图，可以通过 @ResponseBody 注解显示的告知此处的返回值不要进行视图处理，是要以响应体的方式处理的

@RequestMapping("/resp4")
@ResponseBody
public String resp4(){
    return "hello world!";
}

3.2 前后端分类异步业务数据响应

其实此处的回写数据，跟上面回写数据给客户端的语法方式一样，只不过有如下一些区别：

同步方式回写数据，是将数据响应给浏览器进行页面展示的，而异步方式回写数据一般是回写给Ajax引擎的，即谁访问服务器端，服务器端就将数据响应给谁
同步方式回写的数据，一般就是一些无特定格式的字符串，而异步方式回写的数据大多是Json格式字符串

回写普通数据使用@ResponseBody标注方法，直接返回字符串即可，此处不在说明；回写Json格式的字符串，即将直接拼接Json格式的字符串或使用工具将JavaBean转换成Json格式的字符串回写

@GetMapping("/ajax/resp1")
@ResponseBody
public String resp1(){
    return "{\"username\":\"haohao\",\"age\":18}";
}

@GetMapping("/ajax/resp2")
@ResponseBody
public String resp2() throws JsonProcessingException {
    //创建JavaBean
    User user = new User();
    user.setUsername("haohao");
    user.setAge(19);
    //使用Jackson转换成json格式的字符串
    String json = new ObjectMapper().writeValueAsString(user);
    return json;
}

在讲解SringMVC接收请求数据时，客户端提交的Json格式的字符串，也是使用Jackson进行的手动转换成JavaBean ，可以当我们使用了@RequestBody时，直接用JavaBean就接收了Json格式的数据，原理其实就是SpringMVC底层帮我们做了转换，此处@ResponseBody也可以将JavaBean自动给我们转换成Json格式字符串回响应

@GetMapping("/ajax/resp3")
@ResponseBody
public User resp3() throws JsonProcessingException {
    //创建JavaBean
    User user = new User();
    user.setUsername("haohao");
    user.setAge(20);
    //直接返回User对象
    return user;
}

@ResponseBody注解使用优化，在进行前后端分离开发时，Controller的每个方法都是直接回写数据的，所以每个方法上都得写@ResponseBody，可以将@ResponseBody写到Controller上，那么该Controller中的所有方法都具备了返回响应体数据的功能了

@Controller
@ResponseBody
public class ResponseController2 {


    @GetMapping("/ajax/resp1")
    //    @ResponseBody
    public String resp1(){
        return "{\"username\":\"haohao\",\"age\":18}";
    }

    @GetMapping("/ajax/resp2")
    //    @ResponseBody
    public String resp2() throws JsonProcessingException {
        //创建JavaBean
        User user = new User();
        user.setUsername("haohao");
        user.setAge(19);
        //使用Jackson转换成json格式的字符串
        String json = new ObjectMapper().writeValueAsString(user);
        return json;
    }
}

进一步优化，可以使用@RestController替代@Controller和@ResponseBody，@RestController内部具备的这两个注解的功能

@RestController
public class ResponseController2 {


    @GetMapping("/ajax/resp1")
    //    @ResponseBody
    public String resp1(){
        return "{\"username\":\"haohao\",\"age\":18}";
    }

    @GetMapping("/ajax/resp2")
    //    @ResponseBody
    public String resp2() throws JsonProcessingException {
        //创建JavaBean
        User user = new User();
        user.setUsername("haohao");
        user.setAge(19);
        //使用Jackson转换成json格式的字符串
        String json = new ObjectMapper().writeValueAsString(user);
        return json;
    }
}

04、Spring MVC 的拦截器

4.1 拦截器 Interceptor简介

SpringMVC的拦截器Interceptor规范，主要是对Controller资源访问时进行拦截操作的技术，当然拦截后可以进行权限控制，功能增强等都是可以的。拦截器有点类似 Javaweb 开发中的Filter，拦截器与Filter的区别如下图：

由上图，对Filter 和 Interceptor 做个对比：

实现了HandlerInterceptor接口，且被Spring管理的Bean都是拦截器，接口定义如下：

public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }

    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}

HandlerInterceptor接口方法的作用及其参数、返回值详解如下：

4.2 拦截器快速入门

编写MyInterceptor1实现HandlerInterceptor接口：

public class MyInterceptor1 implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("Controller方法执行之前...");
        return true; // 放行
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("Controller方法执行之后...");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("渲染视图结束，整个流程完毕...");
    }
}

在spring-mvc.xml中，配置Interceptor


<mvc:interceptors>
  <mvc:interceptor>
    
    <mvc:mapping path="/**"/>
    <bean class="com.mem.interceptor.MyInterceptor1">bean>
  mvc:interceptor>
mvc:interceptors>

controller层，业务代码

// 测试拦截器
@RequestMapping("/interceptor_req")
public String interceptor_req(){
    System.out.println("interceptor_req ...");
    return "/show.jsp";
}

测试：
当MyInterceptor1的preHandle返回true，则打印

Controller方法执行之前...
interceptor_req ...
Controller方法执行之后...
渲染视图结束，整个流程完毕...

当MyInterceptor1的preHandle返回false，则打印

Controller方法执行之前...

4.3 拦截器执行顺序

拦截器三个方法的执行顺序
当Interceptor1和Interceptor2处于放行，Interceptor3处于不放行时，三个方法的执行顺序如下：

拦截器执行顺序取决于 interceptor 的配置顺序


<mvc:interceptors>
  <mvc:interceptor>
    
    <mvc:mapping path="/**"/>
    <bean class="com.mem.interceptor.MyInterceptor1">bean>
  mvc:interceptor>
  <mvc:interceptor>
    
    <mvc:mapping path="/**"/>
    <bean class="com.mem.interceptor.MyInterceptor2">bean>
  mvc:interceptor>
mvc:interceptors>

4.4 拦截器执行原理

请求到来时先会使用组件HandlerMapping去匹配Controller的方法（Handler）和符合拦截路径的Interceptor， Handler和多个Interceptor被封装成一个HandlerExecutionChain的对象 HandlerExecutionChain 定义如下：

public class HandlerExecutionChain {
    // 映射的Controller的方法
    private final Object handler;
    // 当前Handler匹配的拦截器集合
    private final List<HandlerInterceptor> interceptorList;
}

执行过程：

在DispatcherServlet的doDispatch方法中执行拦截器

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    // 根据请求信息获取HandlerExecutionChain
    HandlerExecutionChain mappedHandler = this.getHandler(processedRequest);
	// 获取处理器适配器
    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
    // 执行Interceptor的前置方法，前置方法如果返回false，则该流程结束
    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
        return;
    }
	// 执行handler，一般是HandlerMethod
    ModelAndView mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    // 执行后置方法
    mappedHandler.applyPostHandle(processedRequest, response, mv);
    // 执行最终方法
    this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
}

跟踪 HandlerExecutionChain的applyPreHandle方法源码：

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
    // 对interceptorList进行遍历,正向遍历,与此同时使用interceptorIndex进行计数
    for(int i = 0; i < this.interceptorList.size(); this.interceptorIndex = i++) {
        // 取出每一个Interceptor对象
        HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
        // 调用Interceptor的preHandle方法，如果返回false，则直接执行Interceptor的最终方法
        if (!interceptor.preHandle(request, response, this.handler)) {
            // 执行Interceptor的最终方法
            this.triggerAfterCompletion(request, response, (Exception)null);
            return false;
        }
    }
    return true;
}

跟踪 HandlerExecutionChain的applyPostHandle方法源码：

void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv) throws Exception {
    // 对interceptorList进行遍历，逆向遍历
    for(int i = this.interceptorList.size() - 1; i >= 0; --i) {
        // 取出每一个Interceptor
        HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
        // 执行Interceptor的postHandle方法
        interceptor.postHandle(request, response, this.handler, mv);
    }
}

跟踪HandlerExecutionChain的triggerAfterCompletion方法源码：

void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) {
	// 逆向遍历interceptorList，遍历的个数为执行的applyPreHandle次数-1
    for(int i = this.interceptorIndex; i >= 0; --i) {
        // 取出每一个Interceptor
        HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
        try {
            // 执行Interceptor的afterCompletion方法
            interceptor.afterCompletion(request, response, this.handler, ex);
        } catch (Throwable var7) {
            logger.error("HandlerInterceptor.afterCompletion threw exception", var7);
        }
    }
}

流程图：

05、Spring MVC 的全注解开发

5.1 spring-mvc.xml 中组件转化为注解形式

跟之前全注解开发思路一致， xml配置文件使用核心配置类替代，xml中的标签使用对应的注解替代



<context:component-scan base-package="com.mem.controller"/>



<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  <property name="defaultEncoding" value="UTF-8"/>
  <property name="maxUploadSizePerFile" value="1048576"/>
  <property name="maxUploadSize" value="3145728"/>
  <property name="maxInMemorySize" value="1048576"/>
bean>



<mvc:default-servlet-handler/>

<mvc:annotation-driven/>

<mvc:interceptors>
  <mvc:interceptor>
    
    <mvc:mapping path="/**"/>
    <bean class="com.mem.interceptor.MyInterceptor1">bean>
  mvc:interceptor>
mvc:interceptors>

第一步，第二步，可以利用之前所学的spring的配置类来搞定

组件扫描，可以通过@ComponentScan注解完成；
文件上传解析器multipartResolver可以通过非自定义Bean的注解配置方式，即@Bean注解完成

@Configuration
// 
@ComponentScan("com.mem.controller")
public class SpringMVCConfig {
    /**
     * 
     *     
     *     
     *     
     *     
     * 
     */
    @Bean
    public CommonsMultipartResolver multipartResolver(){
        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
        multipartResolver.setDefaultEncoding("UTF-8");
        multipartResolver.setMaxUploadSizePerFile(1048576);
        multipartResolver.setMaxUploadSize(3145728);
        multipartResolver.setMaxInMemorySize(1048576);
        return multipartResolver;
    }
}

第三步，非Bean的配置(mvc:default-servlet-handler/、mvc:annotation-driven/、mvc:interceptors) 该怎么办呢？
SpringMVC 提供了一个注解@EnableWebMvc，我们看一下源码，内部通过@Import导入了DelegatingWebMvcConfiguration类

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({DelegatingWebMvcConfiguration.class})
public @interface EnableWebMvc {
}

@Configuration(proxyBeanMethods = false)
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
    private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
	// 从容器中注入 WebMvcConfigurer 类型的Bean
    @Autowired(required = false)
    public void setConfigurers(List<WebMvcConfigurer> configurers) {
        if (!CollectionUtils.isEmpty(configurers)) {
            this.configurers.addWebMvcConfigurers(configurers);
        }
    }
}

首先先看下父类WebMvcConfigurationSupport：

public class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {
	// 将 RequestMappingHandlerMapping 放入容器
    @Bean
    public RequestMappingHandlerMapping requestMappingHandlerMapping(
        @Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager, 
        @Qualifier("mvcConversionService") FormattingConversionService conversionService, 
        @Qualifier("mvcResourceUrlProvider") ResourceUrlProvider resourceUrlProvider) {
        RequestMappingHandlerMapping mapping = this.createRequestMappingHandlerMapping();
        // 中间省略
        return mapping;
    }

    // 将 RequestMappingHandlerAdapter 放入容器
    @Bean
    public RequestMappingHandlerAdapter requestMappingHandlerAdapter(
        @Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager, 
        @Qualifier("mvcConversionService") FormattingConversionService conversionService, 
        @Qualifier("mvcValidator") Validator validator) {
        RequestMappingHandlerAdapter adapter = this.createRequestMappingHandlerAdapter();
        return adapter;
    }
}

这一步的效果等同于mvc:annotation-driven/注解驱动

其次：查看WebMvcConfigurer 的源码
WebMvcConfigurer类型的Bean会被注入进来，然后被自动调用，所以可以实现WebMvcConfigurer接口，完成一些解析器、默认Servlet等的指定，WebMvcConfigurer接口定义如下：

public interface WebMvcConfigurer {
    //配置默认Servet处理器,代替标签
    default void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) { }
    //添加拦截器,代替标签
    default void addInterceptors(InterceptorRegistry registry) { }
    //添加资源处理器
    default void addResourceHandlers(ResourceHandlerRegistry registry) { }
    //添加视图控制器
    default void addViewControllers(ViewControllerRegistry registry) { }
    //配置视图解析器
    default void configureViewResolvers(ViewResolverRegistry registry) { }
    //添加参数解析器
    default void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) { }
    //... 省略其他代码 ...
}

实现：
创建MyWebMvcConfigurer实现WebMvcConfigurer接口，实现addInterceptors 和 configureDefaultServletHandling方法

@Component
public class MyWebMvcConfigurer implements WebMvcConfigurer {
    // 替代 
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 创建拦截器对象，进行注册
        // Interceptor 的执行顺序也取决于添加顺序
        registry.addInterceptor(new MyInterceptor1()).addPathPatterns("/**");
    }

    // 替代 
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        // 开启DefaultServlet,就可以处理静态资源了
        configurer.enable();
    }
}

创建实现类在包扫描区域内

最后，在SpringMVC核心配置类上添加@EnableWebMvc注解

@Configuration
// 
@ComponentScan("com.mem.controller")
@EnableWebMvc
public class SpringMVCConfig {
    /**
     * 
     *     
     *     
     *     
     *     
     * 
     */
    @Bean
    public CommonsMultipartResolver multipartResolver(){
        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
        multipartResolver.setDefaultEncoding("UTF-8");
        multipartResolver.setMaxUploadSizePerFile(1048576);
        multipartResolver.setMaxUploadSize(3145728);
        multipartResolver.setMaxInMemorySize(1048576);
        return multipartResolver;
    }
}

5.2 DispatcherServlet 加载核心配置类

现在是使用SpringMVCConfig核心配置类替代了spring-mvc.xml，怎么加载呢？


<servlet>
  <servlet-name>DispatcherServletservlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
  
  
  
  
  
  
  <init-param>
    <param-name>contextClassparam-name>
    <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContextparam-value>
  init-param>
  <init-param>
    <param-name>contextConfigLocationparam-name>
    <param-value>com.mem.config.SpringMVCConfigparam-value>
  init-param>
  
  <load-on-startup>2load-on-startup>
servlet>

方法2：参照Spring的 ContextLoaderListener加载核心配置类的做法，定义了一个AnnotationConfigWebApplicationContext，通过代码注册核心配置类

5.3 消除web.xml

目前，几乎消除了配置文件，但是web工程的入口还是使用的web.xml进行配置的，如下



<context-param>
  <param-name>contextConfigLocationparam-name>
  <param-value>classpath:applicationContext.xmlparam-value>
context-param>

<listener>
  <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
listener>

<servlet>
  <servlet-name>DispatcherServletservlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
  
  <init-param>
    <param-name>contextClassparam-name>
    <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContextparam-value>
  init-param>
  <init-param>
    <param-name>contextConfigLocationparam-name>
    <param-value>com.mem.config.SpringMVCConfigparam-value>
  init-param>
  
  <load-on-startup>2load-on-startup>
servlet>
<servlet-mapping>
  <servlet-name>DispatcherServletservlet-name>
  <url-pattern>/url-pattern>
servlet-mapping>

1）Servlet3.0环境中，web容器提供了javax.servlet.ServletContainerInitializer接口，实现了该接口后，在对应的类加载路径的META-INF/services 目录创建一个名为javax.servlet.ServletContainerInitializer的文件，文件内容指定具体的ServletContainerInitializer实现类，那么，当web容器启动时就会运行这个初始化器做一些组件内的初始化工作；

在resources目录下新建META-INF/services/javax.servlet.ServletContainerInitializer，内容为com.mem.init.MyServletContainerInitializer
新建MyServletContainerInitializer，内容如下：

2）基于这个特性，Spring就定义了一个SpringServletContainerInitializer实现了ServletContainerInitializer接口;

@HandlesTypes({WebApplicationInitializer.class})
public class SpringServletContainerInitializer implements ServletContainerInitializer {
    public SpringServletContainerInitializer() {
    }

    public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext) throws ServletException {
        List<WebApplicationInitializer> initializers = Collections.emptyList();
        Iterator var4;
        if (webAppInitializerClasses != null) {
            initializers = new ArrayList(webAppInitializerClasses.size());
            var4 = webAppInitializerClasses.iterator();

            while(var4.hasNext()) {
                Class<?> waiClass = (Class)var4.next();
                if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) && WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
                    try {
                        ((List)initializers).add((WebApplicationInitializer)ReflectionUtils.accessibleConstructor(waiClass, new Class[0]).newInstance());
                    } catch (Throwable var7) {
                        throw new ServletException("Failed to instantiate WebApplicationInitializer class", var7);
                    }
                }
            }
        }

        if (((List)initializers).isEmpty()) {
            servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
        } else {
            servletContext.log(((List)initializers).size() + " Spring WebApplicationInitializers detected on classpath");
            AnnotationAwareOrderComparator.sort((List)initializers);
            var4 = ((List)initializers).iterator();

            while(var4.hasNext()) {
                WebApplicationInitializer initializer = (WebApplicationInitializer)var4.next();
                initializer.onStartup(servletContext);
            }

        }
    }
}

3）而SpringServletContainerInitializer会查找实现了WebApplicationInitializer的类，Spring又提供了一个 WebApplicationInitializer的基础实现类AbstractAnnotationConfigDispatcherServletInitializer，当我们编写类继承AbstractAnnotationConfigDispatcherServletInitializer时，容器就会自动发现我们自己的类，在该类中我们就可以配置Spring和SpringMVC的入口了。

源码分析：

public abstract class AbstractAnnotationConfigDispatcherServletInitializer extends AbstractDispatcherServletInitializer {
	// 设置spring的核心配置类
    @Nullable
    protected abstract Class<?>[] getRootConfigClasses();
	// 设置SpringMVC的核心配置类
    @Nullable
    protected abstract Class<?>[] getServletConfigClasses();
}

public abstract class AbstractDispatcherServletInitializer extends AbstractContextLoaderInitializer {
	// 配置DispatcherServlet的映射路径
	protected abstract String[] getServletMappings();
}

实现：
按照下面的配置就可以完全省略web.xml

public class MyAbstractAnnotationConfigDispatcherServletInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    //提供Spring容器的核心配置类
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    @Override
    // 提供SpringMVC容器的核心配置类
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMVCConfig.class};
    }

    @Override
    // 提供前端控制器的映射路径
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

06、Spring MVC 的组件原理刨析

6.1 前端控制初始化

前端控制器DispatcherServlet是SpringMVC的入口，也是SpringMVC的大脑，主流程的工作都是在此完成的，梳理一下DispatcherServlet 代码。
DispatcherServlet 本质是个Servlet，当配置了 load-on-startup 时，会在服务器启动时就执行创建和执行初始化init方法，每次请求都会执行service方法
DispatcherServlet 的初始化主要做了两件事：

获得了一个 SpringMVC 的ApplicationContext容器；
注册了 SpringMVC的九大组件。

删减版继承关系图

结论：SpringMVC 的ApplicationContext容器创建时机，Servlet 规范的 init(ServletConfig config) 方法经过子类重写，最终会调用 FrameworkServlet 抽象类的initWebApplicationContext() 方法，该方法中最终获得一个根 Spring容器（Spring产生的），一个子Spring容器（SpringMVC产生的）
源码刨析：
先来看看Servlet规范的init(ServletConfig)方法：

public interface Servlet {
    // 被子类GenericServlet所重写
    void init(ServletConfig var1) throws ServletException;
    ServletConfig getServletConfig();
    void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
    String getServletInfo();
    void destroy();
}

接着我们来看子类GenericServlet，重写的init(ServletConfig)，并扩展了init()留给子类实现

public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
    // 重写父类的init(ServletConfig config)
    public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
    }
    // 留给子类实现(这里指的是HttpServletBean)
    public void init() throws ServletException {
    }
}

接着我们来看子类HttpServletBean，重写的init()，并扩展了initServletBean()留给子类实现

public abstract class HttpServletBean extends HttpServlet implements EnvironmentCapable, EnvironmentAware {
    public final void init() throws ServletException {
        PropertyValues pvs = new HttpServletBean.ServletConfigPropertyValues(this.getServletConfig(), this.requiredProperties);
        if (!pvs.isEmpty()) {
            try {
                BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
                ResourceLoader resourceLoader = new ServletContextResourceLoader(this.getServletContext());
                bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, this.getEnvironment()));
                this.initBeanWrapper(bw);
                bw.setPropertyValues(pvs, true);
            } catch (BeansException var4) {
                if (this.logger.isErrorEnabled()) {
                    this.logger.error("Failed to set bean properties on servlet '" + this.getServletName() + "'", var4);
                }

                throw var4;
            }
        }
    	// 让子类重写，为了添加额外的初始化工作
        this.initServletBean();
    }
	// 由子类(FrameworkServlet)去重写
    protected void initServletBean() throws ServletException {
    }
}

接着我们来看子类FrameworkServlet，重写的initServletBean()，并扩展了initServletBean()留给子类实现

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
    protected final void initServletBean() throws ServletException {
        try {
            // 在这里创建SpringMVC容器
            this.webApplicationContext = this.initWebApplicationContext();
            //模板设计模式，供子类覆盖实现，但是子类DispatcherServlet没做使用
            this.initFrameworkServlet();
        } catch (RuntimeException | ServletException var4) {
            this.logger.error("Context initialization failed", var4);
            throw var4;
        }
    }
    // 在这里创建SpringMVC容器
    protected WebApplicationContext initWebApplicationContext() {
        // 创建Spring容器，作为SpringMVC的父容器存在
        //获得根容器，其实就是通过 ContextLoaderListener 创建的ApplicationContext
    	//如果配置了ContextLoaderListener则获得根容器，没配置获得的是null
        WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
    	//定义SpringMVC容器，ApplicationContext子容器
        WebApplicationContext wac = null;
        // 1. 全注解方式时，在调用此方法之前，已经创建好SpringMVC容器了
        if (this.webApplicationContext != null) {
            wac = this.webApplicationContext;
            if (wac instanceof ConfigurableWebApplicationContext) {
                ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext)wac;
                if (!cwac.isActive()) {
                    if (cwac.getParent() == null) {
                        // 全注解方式时，设置父容器
                        cwac.setParent(rootContext);
                    }
                	// 配置和刷新SpringMVC容器
                    this.configureAndRefreshWebApplicationContext(cwac);
                }
            }
        }
        if (wac == null) {
            wac = this.findWebApplicationContext();
        }
        if (wac == null) {
            // 2. web.xml 方式时，用这个方法创建
            // 判断如果为空，则创建SpringMVC的容器
            wac = this.createWebApplicationContext(rootContext);
        }
        if (!this.refreshEventReceived) {
            synchronized(this.onRefreshMonitor) {
                this.onRefresh(wac);
            }
        }
        //将SpringMVC子容器存储到ServletContext域中
        //key名是：org.springframework.web.servlet.FrameworkServlet.CONTEXT.DispatcherServlet
        if (this.publishContext) {
            String attrName = this.getServletContextAttributeName();
            this.getServletContext().setAttribute(attrName, wac);
        }
        return wac;
    }
	// 过渡方法
    protected WebApplicationContext createWebApplicationContext(@Nullable WebApplicationContext parent) {
        return this.createWebApplicationContext((ApplicationContext)parent);
    }
	// 创建SpringMVC的容器
    protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
        Class<?> contextClass = this.getContextClass();
        if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
            throw new ApplicationContextException("Fatal initialization error in servlet with name '" + this.getServletName() + "': custom WebApplicationContext class [" + contextClass.getName() + "] is not of type ConfigurableWebApplicationContext");
        } else {
            //实例化子容器ApplicationContext
            ConfigurableWebApplicationContext wac = (ConfigurableWebApplicationContext)BeanUtils.instantiateClass(contextClass);
            wac.setEnvironment(this.getEnvironment());
            // web.xml 方式时，设置父容器
            // 在这里设置SpringMVC的父容器(Spring容器)
            // 需要一个Bean时，先从SpringMVC容器中查找，如果没有的话再去Spring容器中找
            wac.setParent(parent);
            //获得web.xml配置的classpath:spring-mvc.xml
            String configLocation = this.getContextConfigLocation();
            if (configLocation != null) {
                //为子容器设置配置加载路径
                wac.setConfigLocation(configLocation);
            }
            // 配置和刷新SpringMVC容器
            // 初始化子容器(就是加载spring-mvc.xml配置的Bean)
            this.configureAndRefreshWebApplicationContext(wac);
            return wac;
        }
    }
    // 配置和刷新SpringMVC容器
	protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
        if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
            if (this.contextId != null) {
                wac.setId(this.contextId);
            } else {
                wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + ObjectUtils.getDisplayString(this.getServletContext().getContextPath()) + '/' + this.getServletName());
            }
        }

        wac.setServletContext(this.getServletContext());
        wac.setServletConfig(this.getServletConfig());
        wac.setNamespace(this.getNamespace());
        wac.addApplicationListener(new SourceFilteringListener(wac, new FrameworkServlet.ContextRefreshListener()));
        ConfigurableEnvironment env = wac.getEnvironment();
        if (env instanceof ConfigurableWebEnvironment) {
            ((ConfigurableWebEnvironment)env).initPropertySources(this.getServletContext(), this.getServletConfig());
        }

        this.postProcessWebApplicationContext(wac);
        this.applyInitializers(wac);
        // 重点在这：(之前ioc容器初始化，构造的过程)
        wac.refresh();
    }
    
	// 内部类：用于监听ContextRefreshedEvent事件
    private class ContextRefreshListener implements ApplicationListener<ContextRefreshedEvent> {
        private ContextRefreshListener() {
        }

        public void onApplicationEvent(ContextRefreshedEvent event) {
            // 监听到ContextRefreshedEvent事件时执行onApplicationEvent方法
            FrameworkServlet.this.onApplicationEvent(event);
        }
    }
	// 监听到ContextRefreshedEvent事件时执行onApplicationEvent方法
    public void onApplicationEvent(ContextRefreshedEvent event) {
        this.refreshEventReceived = true;
        synchronized(this.onRefreshMonitor) {
            // 空实现
            this.onRefresh(event.getApplicationContext());
        }
    }
	// 为了子类(DispatcherServlet)扩展
    protected void onRefresh(ApplicationContext context) {
    }
}

父容器和子容器概念和关系：

父容器：Spring 通过ContextLoaderListener为入口产生的applicationContext容器，内部主要维护的是 applicationContext.xml（或相应配置类）配置的Bean信息；

子容器：SpringMVC通过DispatcherServlet的init() 方法产生的applicationContext容器，内部主要维护的是spring-mvc.xml（或相应配置类）配置的Bean信息，且内部还通过parent属性维护这父容器的引用。

Bean的检索顺序：根据上面子父容器的概念，可以知道Controller存在与子容器中，而Controller中要注入 Service时，会先从子容器本身去匹配，匹配不成功时在去父容器中去匹配，于是最终从父容器中匹配到的 UserService，这样子父容器就可以进行联通了。但是父容器只能从自己容器中进行匹配，不能从子容器中进行匹配。

接着查看wac.refresh()源码，在AbstractApplicationContext中：

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
    public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                beanPostProcess.end();
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                // 完成刷新，底层发布一个事件
                this.finishRefresh();
            } catch (BeansException var10) {
            	// ...
            } finally {
                // ...
            }
        }
    }
    // 完成刷新，底层发布一个事件,在FrameworkServlet类中的内部类监听
    protected void finishRefresh() {
        // ...
        // 发布一个ContextRefreshedEvent类型的事件，在FrameworkServlet类中的内部类监听
        this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this)));
        // ...
    }
}

由父类(FrameworkServlet)监听到ContextRefreshedEvent类型的事件，执行onRefresh()方法，接着我们来看子类DispatcherServlet，重写的onRefresh()

public class DispatcherServlet extends FrameworkServlet {
    // 重写父类中的onRefresh方法
	protected void onRefresh(ApplicationContext context) {
        // 初始化策略
        this.initStrategies(context);
    }
	// 注册九大组件
    protected void initStrategies(ApplicationContext context) {
        //1、初始化文件上传解析器
        this.initMultipartResolver(context);
        //2、初始化国际化解析器
        this.initLocaleResolver(context);
        //3、初始化模板解析器
        this.initThemeResolver(context);
        //4、初始化处理器映射器
        this.initHandlerMappings(context);
        //5、初始化处理器适配器
        this.initHandlerAdapters(context);
        //6、初始化处理器异常解析器
        this.initHandlerExceptionResolvers(context);
        //7、初始化请求视图转换器
        this.initRequestToViewNameTranslator(context);
        //8、初始化视图解析器
        this.initViewResolvers(context);
        //9、初始化lashMapManager策略组件
        this.initFlashMapManager(context);
    }
}

总结：重点在于AbstractApplicationContext类发布事件(ContextRefreshedEvent),FrameworkServlet类的内部类(ContextRefreshListener)监听到了事件，然后由子类DispatcherServlet重写父类的onRefresh()方法，从而实现注册九大组件

以 this.initHandlerMappings(context) 为例，进一步看一下初始化处理器映射器的细节：

public class DispatcherServlet extends FrameworkServlet {
    //定义List容器存储HandlerMapping
	private List<HandlerMapping> handlerMappings;
    //初始化HandlerMapping的方法
    private void initHandlerMappings(ApplicationContext context) {
        //初始化集合为null
        this.handlerMappings = null;
        //detectAllHandlerMappings默认为true，代表是否从所有容器中(父子容器)检测 HandlerMapping
        if (this.detectAllHandlerMappings) {
            //从Spring容器中去匹配HandlerMapping
            Map<String, HandlerMapping> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
            //如果从容器中获取的HandlerMapping不为null就加入到事先定义好的handlerMappings容器中
            if (!matchingBeans.isEmpty()) {
                this.handlerMappings = new ArrayList(matchingBeans.values());
                AnnotationAwareOrderComparator.sort(this.handlerMappings);
            }
        } else {
            //...
        }
    	//如果从容器中没有获得HandlerMapping，意味着handlerMappings集合是空的
        if (this.handlerMappings == null) {
            //加载默认的HandlerMapping，就是加载DispatcherServlet.properties文件中的键值对
            this.handlerMappings = this.getDefaultStrategies(context, HandlerMapping.class);
        }
        // ...
    }
}

总结：初始化这些组件，默认先从容器中寻找，如果容器有就用容器的，如果容器没有，就用默认的。

加上@EnableWebMvc后，向容器中注入了4个HandlerMapping，如下图：

查看RequestMappingHandlerMapping中的mappingRegistry.registry中的映射地址

去掉@EnableWebMvc注解后，就获取默认的3个HandlerMapping，如下图：

6.2 前端控制器执行主流程

上面讲解了一下，当服务器启动时，DispatcherServlet 会执行初始化操作，接下来，每次访问都会执行service 方法，我们先宏观的看一下执行流程，在去研究源码和组件执行细节

重点掌握HandlerExecutionChain如何生产的，HandlerAdapter如何调用controller方法，并传值的？

源码刨析：
首先看一下Servlet接口中的service方法，注意这个service的参数是没有Http的

public interface Servlet {
    void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
}

接着，看HttpServlet中重写的service(ServletRequest,ServletResponse)方法，发现他调用了service(HttpServletRequest, HttpServletResponse)

public abstract class HttpServlet extends GenericServlet {
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        if (req instanceof HttpServletRequest && res instanceof HttpServletResponse) {
            HttpServletRequest request = (HttpServletRequest)req;
            HttpServletResponse response = (HttpServletResponse)res;
            // 调用service，参数是Http类型的
            this.service(request, response);
        } else {
            throw new ServletException("non-HTTP request or response");
        }
    }
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getMethod();
        long lastModified;
        if (method.equals("GET")) {
            lastModified = this.getLastModified(req);
            if (lastModified == -1L) {
                this.doGet(req, resp);
            } else {
                long ifModifiedSince = req.getDateHeader("If-Modified-Since");
                if (ifModifiedSince < lastModified) {
                    this.maybeSetLastModified(resp, lastModified);
                    this.doGet(req, resp);
                } else {
                    resp.setStatus(304);
                }
            }
        } else if (method.equals("HEAD")) {
            lastModified = this.getLastModified(req);
            this.maybeSetLastModified(resp, lastModified);
            this.doHead(req, resp);
        } else if (method.equals("POST")) {
            this.doPost(req, resp);
        } else if (method.equals("PUT")) {
            this.doPut(req, resp);
        } else if (method.equals("DELETE")) {
            this.doDelete(req, resp);
        } else if (method.equals("OPTIONS")) {
            this.doOptions(req, resp);
        } else if (method.equals("TRACE")) {
            this.doTrace(req, resp);
        } else {
        }
    }
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_get_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_post_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }
    // do...
}

接着，我们看一下HttpServlet的子类(FrameworkServlet)，重写的service(HttpServletRequest, HttpServletResponse)方法：

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
        if (httpMethod != HttpMethod.PATCH && httpMethod != null) {
            // 调用父类的service方法
            super.service(request, response);
        } else {
            this.processRequest(request, response);
        }
    }
    // 父类中的doGet/doPost/do...都是调用子类重写的doGet...方法
    protected final void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.processRequest(request, response);
    }

    protected final void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.processRequest(request, response);
    }
    // do...
    
    protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        try {
            //调用本类中的doService方法
            this.doService(request, response);
        } catch (IOException | ServletException var16) {
        }
    }
	// 由子类(DispatcherServlet)实现
    protected abstract void doService(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
}

接着我们来看子类(DispatcherServlet)实现的doService方法

public class DispatcherServlet extends FrameworkServlet {
    protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // ...
        try {
            this.doDispatch(request, response);
        } finally {
        }
    }
    // 核心流程都在这个方法里
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        try {
            try {
                ModelAndView mv = null;
                Object dispatchException = null;

                try {
                    processedRequest = this.checkMultipart(request);
                    multipartRequestParsed = processedRequest != request;
                    // 获取HandlerExecutionChain对象
                    mappedHandler = this.getHandler(processedRequest);
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }

                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
                    String method = request.getMethod();
                    boolean isGet = HttpMethod.GET.matches(method);
                    if (isGet || HttpMethod.HEAD.matches(method)) {
                        long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                        if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
                            return;
                        }
                    }
                	// 执行拦截器的前置方法
                    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                        return;
                    }
                	// 执行目标方法
                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }
                	
                    this.applyDefaultViewName(processedRequest, mv);
                    // 执行拦截器的后置方法
                    mappedHandler.applyPostHandle(processedRequest, response, mv);
                } catch (Exception var20) {
                    dispatchException = var20;
                } catch (Throwable var21) {
                    dispatchException = new NestedServletException("Handler dispatch failed", var21);
                }

                this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
            } catch (Exception var22) {
                // 执行拦截器的最终方法
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
            } catch (Throwable var23) {
            }

        } finally {
         

        }
    }

    // 返回HandlerExecutionChain对象
    @Nullable
    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        if (this.handlerMappings != null) {
            Iterator var2 = this.handlerMappings.iterator();

            while(var2.hasNext()) {
                HandlerMapping mapping = (HandlerMapping)var2.next();
                HandlerExecutionChain handler = mapping.getHandler(request);
                if (handler != null) {
                    return handler;
                }
            }
        }

        return null;
    }
    
}

调用mapping.getHandler(request)方法，找实现类AbstractHandlerMapping的getHandler(HttpServletRequest)方法

public abstract class AbstractHandlerMapping extends WebApplicationObjectSupport implements HandlerMapping, Ordered, BeanNameAware {
    @Nullable
    public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        // 获取controller方法，抽象成handler
        Object handler = this.getHandlerInternal(request);
        if (handler == null) {
            handler = this.getDefaultHandler();
        }

        if (handler == null) {
            return null;
        } else {
            // ...
        	// 返回一个HandlerExecutionChain对象，调用
            HandlerExecutionChain executionChain = this.getHandlerExecutionChain(handler, request);
            return executionChain;
        }
    }
    // 实际创建HandlerExecutionChain 对象的地方
    protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
        HandlerExecutionChain chain = handler instanceof HandlerExecutionChain ? (HandlerExecutionChain)handler : new HandlerExecutionChain(handler);
        Iterator var4 = this.adaptedInterceptors.iterator();
    	// 循环所有拦截器对象
        while(var4.hasNext()) {
            HandlerInterceptor interceptor = (HandlerInterceptor)var4.next();
            if (interceptor instanceof MappedInterceptor) {
                MappedInterceptor mappedInterceptor = (MappedInterceptor)interceptor;
                // 判断是否匹配
                if (mappedInterceptor.matches(request)) {
                    // 向HandlerExecutionChain对象中加入拦截器
                    chain.addInterceptor(mappedInterceptor.getInterceptor());
                }
            } else {
                chain.addInterceptor(interceptor);
            }
        }
        return chain;
    }
}

获取完HandlerExecutionChain对象后，执行拦截器前置，目标，后置方法，这里我们主要讲解目标方法的执行，查看实现类RequestMappingHandlerAdapter的 handleInternal() 方法 (由mv = ha.handle()进行调用)

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter implements BeanFactoryAware, InitializingBean {
    protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        this.checkRequest(request);
        ModelAndView mav;
        if (this.synchronizeOnSession) {

        } else {
            // 调用invokeHandlerMethod()方法
            mav = this.invokeHandlerMethod(request, response, handlerMethod);
        }
        return mav;
    }

    @Nullable
    protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        try {
        	// 调用invokeAndHandle()方法
            invocableMethod.invokeAndHandle(webRequest, mavContainer, new Object[0]);
        } finally {
        }
        return var15;
    }
}

接着查看ServletInvocableHandlerMethod类的invokeAndHandle()方法：

public class ServletInvocableHandlerMethod extends InvocableHandlerMethod {
    public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
        // 调用父类中的invokeForRequest()方法
        Object returnValue = this.invokeForRequest(webRequest, mavContainer, providedArgs);
    }
}

接着查看父类的invokeForRequest()方法：

public class InvocableHandlerMethod extends HandlerMethod {

    @Nullable
    public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
        // 获取请求中的参数
        Object[] args = this.getMethodArgumentValues(request, mavContainer, providedArgs);
        if (logger.isTraceEnabled()) {
            logger.trace("Arguments: " + Arrays.toString(args));
        }
    	// 执行doInvoke方法
        return this.doInvoke(args);
    }
    
    @Nullable
    protected Object doInvoke(Object... args) throws Exception {
        Method method = this.getBridgedMethod();
        ReflectionUtils.makeAccessible(method);

        try {
            // 最终，利用反射，调用method.invoke(getBean,args)方法
            return KotlinDetector.isSuspendingFunction(method) ? CoroutinesUtils.invokeSuspendingFunction(method, this.getBean(), args) : method.invoke(this.getBean(), args);
        }
    }
}

07、Spring MVC 的异常处理机制

7.1 SpringMVC异常处理流程

异常分为编译时异常和运行时异常，对于编译时异常，我们通过try-catch 进行捕获，捕获后自行处理，而运行时异常是不可预期的，就需要规范编码来避免。
在SPringMVC中，不管是编译异常还是运行时异常，都可以最终由SpringMVC提供的异常处理器进行统一处理，这样就避免了随时随地地捕获处理地繁琐性。
当然除了繁琐之外，我们在进行前后端异步开发时，往往返回统一格式地结果给客户端，例如：{"code": 200,"message":"","data":{"username":"haohao","age":18}}，即使报异常了，也不能把状态码500直接扔给客户端丢给用户，需要将异常转换成符合上面格式地数据响应给客户端更友好。

SpringMVC处理异常的思路是：一路向上抛，都抛给前端控制器DispatcherServlet，DispatcherServlet再调用异常处理器ExceptionResolver进行处理，如下图：

7.2 SpringMVC的异常处理方式

SpringMVC提供了以下三种处理异常的方式：

简单异常处理器：使用SpringMVC内置的异常处理器SimpleMappingExceptionResolver；
自定义异常处理器：实现HandlerExceptionResolver接口，自定义异常进行处理；
注解方式：使用@ControllerAdvice+@ExceptionHandler来处理。

初始化：
新建一个异常测试Controller：

@RestController
public class ExceptionController {
    /**
     * 模拟运行时异常
     * @return
     */
    @RequestMapping("/exception1")
    public String exceptionMethod1(){
        int i = 1/0;
        return "Hello Exception";
    }
    /**
     * 模拟编译异常
     * @return
     */
    @RequestMapping("/exception2")
    public String exceptionMethod2() throws FileNotFoundException {
        FileInputStream inputStream = new FileInputStream("C:/xx/xx/xx.xx");
        return "Hello Exception";
    }
}

没加上异常处理时的效果
访问exception1时报除零异常：

访问exception2时报找不到文件异常：

改善1：加上简单异常处理器(SimpleMappingExceptionResolver)，对不同的异常进行不同的跳转友好页面，操作如下

在配置类上加一个SimpleMappingExceptionResolver类型的Bean

@Configuration
@ComponentScan("com.mem.controller")
@EnableWebMvc
public class SpringMVCConfig {
    // 配置简单的异常处理器类
    @Bean
    public SimpleMappingExceptionResolver simpleMappingExceptionResolver(){
        SimpleMappingExceptionResolver simpleMappingExceptionResolver = new SimpleMappingExceptionResolver();
        // 不管是什么异常，统一的响应一个友好页面
        //        simpleMappingExcepti
        onResolver.setDefaultErrorView("/error1.html");
        // 区分异常类型，根据不同的异常类型，跳转不同的视图
        Properties properties = new Properties();// 键值对，key:异常的全限定名，value：跳转的视图名
        properties.setProperty("java.lang.RuntimeException","/error1.html");
        properties.setProperty("java.io.FileNotFoundException","/error2.html");
        simpleMappingExceptionResolver.setExceptionMappings(properties);
        return simpleMappingExceptionResolver;
    }
}

添加错误页面

此时访问exception1时，进入error1.html

访问exception2时，进入error2.html

改善2：自定义异常处理器，实现HandlerExceptionResolver接口，操作如下：

添加自定义异常处理器类

@Component
public class MyHandlerExceptionResolver implements HandlerExceptionResolver {
    /**
     *
     * @param request 请求
     * @param response 响应
     * @param handler Controller层的方法的封装
     * @param e 异常，可以用于判断
     * @return
     */
    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception e) {
        System.out.println("request:"+request);
        System.out.println("response:"+response);
        System.out.println("handler:"+handler);
        System.out.println("e:"+e);

        // 1. 可以简单的响应一个友好的提示页面
        ModelAndView modelAndView = new ModelAndView();
        if(e instanceof RuntimeException ){
            modelAndView.setViewName("/error1.html");
        }else{
            modelAndView.setViewName("/error2.html");
        }
        return modelAndView;
    }
}

此时访问exception1时，进入error1.html
控制台输出：

访问exception2时，进入error2.html
控制台输出：

自定义异常处理器还可以以json形式返回：
修改MyHandlerExceptionResolver的resolveException方法：

@Component
public class MyHandlerExceptionResolver implements HandlerExceptionResolver {
    /**
     *
     * @param request 请求
     * @param response 响应
     * @param handler Controller层的方法的封装
     * @param e 异常，可以用于判断
     * @return
     */
    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception e) {
        System.out.println("request:"+request);
        System.out.println("response:"+response);
        System.out.println("handler:"+handler);
        System.out.println("e:"+e);

        // 1. 可以简单的响应一个友好的提示页面
        //        ModelAndView modelAndView = new ModelAndView();
        //        if(e instanceof RuntimeException ){
        //            modelAndView.setViewName("/error1.html");
        //        }else{
        //            modelAndView.setViewName("/error2.html");
        //        }

        // 2. 前后端分离开发，响应json格式的字符串 {"code": 200,"message":"","data":{"username":"haohao","age":18}}
        String resultJson = "{\"code\": 500,\"message\":\"异常\",\"data\":{\"username\":\"haohao\",\"age\":18}}";
        try {
            response.getWriter().write(resultJson);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        return null;
    }
}

此时访问exception1或exception2时，返回如下json串

改善3：使用注解的方式，更加灵活(常用)
新建类(ExceptionByAnno)：

@ControllerAdvice
public class ExceptionByAnno {

    @ExceptionHandler(RuntimeException.class)
    public ModelAndView RuntimeExceptionResolverMethod(Exception exception){
        System.out.println("exception:"+exception); // exception:java.lang.ArithmeticException: / by zero
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/error1.html");
        return modelAndView;
    }

    @ExceptionHandler(IOException.class)
    @ResponseBody
    public Result IOExceptionResolverMethod(Exception exception){
        System.out.println("exception:"+exception); // exception:java.io.FileNotFoundException: C:\xx\xx\xx.xx (系统找不到指定的路径。)
        Result result = new Result(500,"","");
        return result;
    }

    @ExceptionHandler(FileNotFoundException.class)
    public ModelAndView FileNotFoundExceptionResolverMethod(Exception exception){
        System.out.println("exception:"+exception); // exception:java.io.FileNotFoundException: C:\xx\xx\xx.xx (系统找不到指定的路径。)
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/error2.html");
        return modelAndView;
    }

}

IOExceptionResolverMethod和FileNotFoundExceptionResolverMethod都能对exception2进行处理，如果两个都开启，优先选中更匹配的(FileNotFoundExceptionResolverMethod)

7.3 异常处理机制原理刨析

只看，异常处理器如何响应的源码

两种模式

返回视图的，即RuntimeExceptionResolverMethod方法
返回对象的，即IOExceptionResolverMethod方法

源码刨析：
从DispatcherServlet的doDispatch方法来看

public class DispatcherServlet extends FrameworkServlet {
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    	// 处理异常的代码在这
        this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
    }
    private void processDispatchResult(HttpServletRequest request, HttpServletResponse response, @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv, @Nullable Exception exception) throws Exception {
        // 这里是调用异常处理的方法
        // 当访问的方法是返回视图的这种模式时，会将返回的视图赋值给mv 如图1所示
        // 当访问的方法是返回字符串的这种模式时，会将返回的字符串放入response响应的缓存里面 如图2所示
        mv = this.processHandlerException(request, response, handler, exception);
    }
}

图一：此时mv的view="/error1.html",是因为在RuntimeExceptionResolverMethod方法中设置了view

图二：此时 mv 是空，bytesWritten = 35 是因为返回内容{"code":500,"message":"","data":""}长度为35

7.4 SpringMVC 常用的异常解析器

SpringMVC相关的处理器异常解析器继承体系如下：

HandlerExceptionResolverComposite 是一个组合体，内部包含了ExceptionHandlerExceptionResolver + DefaultHandlerExceptionResolver + ResponseStatusExceptionResolver

完结撒花

你可能感兴趣的:(spring,笔记,java)

10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
git常用命令笔记咩酱-小羊 git 笔记
###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
509. 斐波那契数(每日一题) lzyprime
lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
拥有断舍离的心态，过精简生活--《断舍离》读书笔记爱吃丸子的小樱桃
不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
高端密码学院笔记285 柚子_b4b4
高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
Day17笔记-高阶函数 ~在杰难逃~ Python 笔记 python 开发语言 pycharm 数据分析
高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
数据仓库——维度表一致性墨染丶eye 背诵数据仓库
数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
【Git】常见命令(仅笔记) 好想有猫猫 Git Linux学习笔记 git 笔记 elasticsearch linux c++
文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
SpringBlade dict-biz/list 接口 SQL 注入漏洞文章永久免费只为良心 oracle 数据库
SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
为什么你总是对下属不满意? ZhaoWu1050
【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
母亲节如何做小红书营销美橙传媒
小红书的一举一动引起了外界的高度关注。通过爆款笔记和流行话题，我们可以看到“干货”类型的内容在小红书中偏向实用的生活经验共享和生活指南非常受欢迎。根据运营社的分析，这种现象是由小红书用户心智和内容社区背后机制共同决定的。首先，小红书将使用“强搜索”逻辑为用户提供特定的“搜索场景”。在“我必须这样生活”中，大量使用了满足小红书站用户喜好和需求的内容。内容社区自制的高质量内容也吸引了寻找营销新途径的品
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
读书笔记|《遇见孩子，遇见更好的自己》5 抹茶社长
为人父母意味着放弃自己的过去，不要对以往没有实现的心愿耿耿于怀，只有这样，孩子们才能做回自己。985909803.jpg孩子在与父母保持亲密的同时更需要独立，唯有这样，孩子才会成为孩子，父母才会成其为父母。有耐心的人生往往更幸福，给孩子留点余地。认识到养儿育女是对耐心的考验。为失败做好心理准备，教会孩子控制情绪。了解自己的底线，说到底线，有一点很重要，父母之所以发脾气，真正的原因往往在于他们自己，
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
java数字签名三种方式知了ing java jdk
以下3钟数字签名都是基于jdk7的 1，RSA String password="test"; // 1.初始化密钥 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(51
Hibernate学习笔记 caoyong Hibernate
1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 2>、搭建Hibernate的开发环境 a>、添加jar包: aa>、hibernatte开发包中/lib/required/所
设计模式之装饰器模式Decorator（结构型）漂泊一剑客 Decorator
1. 概述若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。
读取磁盘文件txt，并输入String 一炮送你回车库 String
public static void main(String[] args) throws IOException { String fileContent = readFileContent("d:/aaa.txt"); System.out.println(fileContent);
js三级联动下拉框 3213213333332132 三级联动
//三级联动省/直辖市<select id="province"></select> 市/省直辖<select id="city"></select> 县/区 <select id="area"></select>
erlang之parse_transform编译选项的应用 616050468 parse_transform 游戏服务器属性同步 abstract_code
最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
JAVA JSON的解析 darkranger java
// { // “Total”：“条数”， // Code: 1, // // “PaymentItems”:[ // { // “PaymentItemID”:”支款单ID”, // “PaymentCode”:”支款单编号”, // “PaymentTime”:”支款日期”, // ”ContractNo”:”合同号”， //
POJ-1273-Drainage Ditches aijuans ACM_POJ
POJ-1273-Drainage Ditches http://poj.org/problem?id=1273 基本的最大流，按LRJ的白书写的 #include<iostream> #include<cstring> #include<queue> using namespace std; #define INF 0x7fffffff int ma
工作流Activiti5表的命名及含义 atongyeye 工作流 Activiti
activiti5 - http://activiti.org/designer/update在线插件安装 activiti5一共23张表 Activiti的表都以ACT_开头。第二部分是表示表的用途的两个字母标识。用途也和服务的API对应。 ACT_RE_*: 'RE'表示repository。这个前缀的表包含了流程定义和流程静态资源（图片，规则，等等）。 A
android的广播机制和广播的简单使用百合不是茶 android 广播机制广播的注册
Android广播机制简介在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
Spring事务传播行为详解 bijian1013 java spring 事务传播行为
在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。 Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
eidtplus operate 征客丶 eidtplus
开启列模式: Alt+C 鼠标选择 OR Alt+鼠标左键拖动列模式替换或复制内容(多行): 右键-->格式-->填充所选内容-->选择相应操作 OR Ctrl+Shift+V(复制多行数据,必须行数一致) -------------------------------------------------------
【Kafka一】Kafka入门 bit1129 kafka
这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧下载Kafka http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 2.10表示Scala的版本，而0.8.1.1表示Kafka
Spring 事务实现机制 BlueSkator spring 代理事务
Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口
bootstrap源码学习与示例：bootstrap-dropdown（转帖） BreakingBad bootstrap dropdown
bootstrap-dropdown组件是个烂东西，我读后的整体感觉。一个下拉开菜单的设计： <ul class="nav pull-right"> <li id="fat-menu" class="dropdown">
读《研磨设计模式》-代码笔记-中介者模式-Mediator bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /* * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 * * 在我看来，Mediator模式是把多个对象（
常用代码记录 chenjunt3 UI Excel J#
1、单据设置某行或某字段不能修改 //i是行号,"cash"是字段名称 getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false); //取得单据表体所有项用以上语句做循环就能设置整行了 getBillC
搜索引擎与工作流引擎 comsci 算法工作搜索引擎网络应用
最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想) -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
oracle Health Monitor daizj oracle Health Monitor
About Health Monitor Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. About Health Monitor Checks Health M
JSON字符串转换为对象 dieslrae java json
作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.
C语言学习八结构体，综合应用，学生管理系统 dcj3sjt126com C语言
实现功能的代码： # include <stdio.h> # include <malloc.h> struct Student { int age; float score; char name[100]; }; int main(void) { int len; struct Student * pArr; int i,
vagrant学习笔记 dcj3sjt126com vagrant
想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant 1. vagrant virtualbox 下载安装 https://www.vagrantup.com/downloads.html https://www.virtualbox.org/wiki/Downloads 查看安装在命令行输入vagrant 2.
14.性能优化-优化-软件配置优化 frank1234 软件配置性能优化
1.Tomcat线程池修改tomcat的server.xml文件： <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
一个不错的shell 脚本教程入门级 HarborChung linux shell
一个不错的shell 脚本教程入门级建立一个脚本　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。　　如同其他语言一样
Spring4新特性——核心容器的其他改进 jinnianshilongnian spring 动态代理 spring4 依赖注入
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
Linux设置tomcat开机启动 liuxingguome tomcat linux 开机自启动
执行命令sudo gedit /etc/init.d/tomcat6 然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 #!/bin/bash # # /etc/rc.d/init.d/tomcat # init script for tomcat precesses
第13章 Ajax进阶（下） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
Troubleshooting Crystal Reports off BW blueoxygen BO
http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE Quite useful, especially this part: SAP BW connectivity For t
Java开发熟手该当心的11个错误 tomcat_oracle java jvm 多线程单元测试
#1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目可以在属性文件中配置，那么使它成为
正则表达式大全 yang852220741 html 编程正则表达式
今天向大家分享正则表达式大全，它可以大提高你的工作效率正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。一、校验数字的表达式数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$