深入浅出boot2.0 第9,10章 Spring MVC

阳光穿透心脏的1/2处 2023-02-17 15:54 142阅读 0赞

## SpringMVC 介绍 ##

*  视图 view
 *  数据模型 model
 *  视图解析器 viewResolver
 *  处理适配器 HandlerAdapter

### 设计理念 ###

*  model — view—controller
 *  http请求 ——控制器—— 业务层
 *  控制器——相应请求——视图层
 *  业务层（包含nosql缓存）——数据访问层（关系数据库，包含事务）

### 流程 ###

*  围绕DispatcherServlet
 *  加入@ResponseBody是 没有经过视图解析器和视图渲染的

1.  http Request——dispatcher servlet
2.  处理器映射：定位控制器 相应方法(handlerMapping)
    
    1.  处理器执行链：包含处理器 及其拦截器(handlerExecutionChain)
    2.  dispatcher servlet
3.  处理适配器：运行处理器 （HandlerAdapter）
4.  模型与视图：获取视图和模型数据 （Model And View)——dispatcher servlet
5.  视图解析器：定位视图资源 (viewResolver)
6.  视图：将数据模型渲染展示（view）

*  请求 到达—— dispatcher servlet
 *  dispatcher servlet 找 ——处理器映射 （handlerMapping）找——处理器执行链（handlerExecutionChain）
 *  返回到 dispatcher servlet ，在找 —— 处理适配器 （handlerAdapter)—— 最后生成 model and view
 *  返回到 dispatcher servlet，找 视图解析器
 *  找 视图，将数据渲染展示

### 1.控制器 ###

@Controller
    @RequestMapping("/user")
    public class UserController { 
    
    	@Autowired
    	private UserService userService = null;
    
    	// 展示用户详情
    	@RequestMapping("details")
    	public ModelAndView details(Long id) { 
    		// 访问模型层得到数据
    		User user = userService.getUser(id);
    		// 模型和视图
    		ModelAndView mv = new ModelAndView();
    		// 定义模型视图
    		mv.setViewName("user/details");
    		// 加入数据模型
    		mv.addObject("user", user);
    		// 返回模型和视图
    		return mv;
    	}
    }

*  @RequestMapping(“details”) 请求路径，MVC 启动时，就被扫描到 HandlerMapping（处理器映射）的机制中存储
 *  用户发起 DispatcherServlet拦截后，HandlerMapper机制 找到对应的控制器 进行相应
 *  HandlerMapping 返回一个 HandlerExecutionChain对象
 *  handlerExecutionChain
    
        public class HandlerExecutionChain { 
            private static final Log logger = LogFactory.getLog(HandlerExecutionChain.class);
            private final Object handler;//包含一个处理器
            @Nullable
            private HandlerInterceptor[] interceptors;
            @Nullable
            private List<HandlerInterceptor> interceptorList;
            private int interceptorIndex;
        }
    
     *  private final Object handler;//包含一个处理器，对控制器的封装
     *  控制器有多个参数，处理器就可读入http和上下文的相关参数
     *  执行完后，又可以通过配置信息，对控制器的返回结果进行处理
     *  处理器包含控制器方法的逻辑，还有处理器的拦截器 interceptor
     *  得到了处理器 我们有普通的http请求，BeanName的请求 和 webSocket请求
     *  还需要一个适配器去 运行 HandlerExecutionChain 对象包含的处理器
     *  这就是 HandlerAdapter 接口的实现类
        
         *  最常用的是：HttpRequestHandlerAdapter

### 2.jsp pom ###

<dependency>
                <groupId>org.apache.tomcat.embed</groupId>
                <artifactId>tomcat-embed-jasper</artifactId>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>jstl</artifactId>
                <scope>provided</scope>
            </dependency>

### 3. properties配置 ###

*  为了定制 InternalResourceViewResolver初始化，配置
    
        spring.mvc.view.prefix=/WEB-INF/jsp/ 
        spring.mvc.view.suffix=.jsp
    
     *  比如控制器返回：user/details ，则会找 /WEB-INF/jsp/user/detail.jsp

### 4.jsp视图 ###

<%@ page pageEncoding="UTF-8"%>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
    <html>
        <head>
            <title>用户详情</title>
        </head>
        <body>
        
            <center>
                <table border="1">
                    <tr>
                        <td>标签</td>
                        <td>值</td>
                    </tr>
                    <tr>
                        <td>用户编号</td>
                        <td><c:out value="${user.id}"></c:out></td>
                    </tr>
                    <tr>
                        <td>用户名称</td>
                        <td><c:out value="${user.userName}"></c:out></td>
                    </tr>
                    <tr>
                        <td>用户备注</td>
                        <td><c:out value="${user.note}"></c:out></td>
                    </tr>
                </table>
            </center>
        </body>
    </html>

### 启动类 ###

@SpringBootApplication(scanBasePackages = "com.springboot.chapter9")
    @MapperScan(basePackages="com.springboot.chapter9", annotationClass = Mapper.class)
    public class Chapter9Application { 
    
    	public static void main(String[] args) { 
    		SpringApplication.run(Chapter9Application.class, args);
    	}
    }

### 使用JSON视图 ###

@RequestMapping("/detailsForJson")
    	public ModelAndView detailsForJson(Long id) { 
    		// 访问模型层得到数据
    		//User user = userService.getUser(id);
    		User user=new User();
    		user.setId(111L);
    		user.setUserName("张三");
    		// 模型和视图
    		ModelAndView mv = new ModelAndView();
    		// 生成JSON视图
    		MappingJackson2JsonView jsonView = new MappingJackson2JsonView();
    		mv.setView(jsonView);
    		// 加入模型
    		mv.addObject("user", user);
    		return mv;
    	}

## Spring MVC 下的流程 ##

1.请求 —— 
    
    2.dispatcherServlet —— handlerMapping (@RequestMapping提供URI和其他配置) —— handlerExecutionChain (返回包含控制器逻辑的处理器)
    
    —— dispatcherServlet
    
    —— 3.运行处理器 ——httpRequestHandlerAdapter
    
    ——4.modelAndView (视图名称：user/details数据模型为用户模型)
    
    ——dispatcherServlet
    
    ——5. InternalResourceViewResolver  定位视图 ，前缀+视图名称+ 后缀
    
    ——6. dispatcherServlet —— 将用户模型渲染到视图展示。 details.jsp
    ‘

## 定制Spring MVC 的初始化 ##

*  Spring MVC 3.1开始，支持无web.xml
 *  提供了 WebMvcConfigurer
 *  Spring Boot中 配置类 WebMVCAutoConfiguration定义 (继承上面的)
    
     *  有一个静态内部类，WebMvcAutoConfigurationAdapter
 *  WebMvcConfigurer 初始化接口，java 8的接口
 *  WebMvcAutoConfigurationAdapter 继承上面，是boot的 配置类WebMVCAutoConfiguration 的内部类
 *  会读取 Spring MVC的属性来初始化组件。

spring:
      mvc:
        async:
          request-timeout:  #异步请求的超时时间
        contentnegotiation:
          favor-parameter: false #是否使用请求参数 （默认format) 来确认请求的媒体类型
        date-format:  #废弃，日期的格式配置
        dispatch-trace-request: false #是否支持trace请求
        dispatch-options-request: false #是否支持options请求
        favicon:
          enabled: false #废弃，是否启用图标
        formcontent:
          putfilter:
            enabled: false #废弃
        locale: af #默认国际化选项
        log-request-details: false
        log-resolved-exception: false #是否启用警告日志解决问题
        servlet:
          load-on-startup: -1
        static-path-pattern: /** #指定静态文件
        throw-exception-if-no-handler-found: false #找不到请求，就炮NoHandlerFoundException异常
        view:
          prefix:  #前缀
          suffix:  #后缀

## spring MVC实例 ##

@RequestMapping("/table")
    	public ModelAndView table() { 
    		// 访问模型层得到数据
    		List<User> userList = userService.findUsers(null, null);
    		// 模型和视图
    		ModelAndView mv = new ModelAndView();
    		// 定义模型视图
    		mv.setViewName("user/table");
    		// 加入数据模型
    		mv.addObject("userList", userList);
    		// 返回模型和视图
    		return mv;
    	}
    
    	@RequestMapping("/list")
    	@ResponseBody
    	public List<User> list(@RequestParam(value = "userName", required = false) String userName,
    			@RequestParam(value = "note", required = false) String note) { 
    		// 访问模型层得到数据
    		List<User> userList = userService.findUsers(userName, note);
    		return userList;
    	}
    
    @Repository
    public interface UserDao { 
    	
    	User getUser(Long id);
    
    	List<User> findUsers(@Param("userName") String userName, @Param("note") String note);
    }

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.hua.testj.UserDao">
    
    	<select id="getUser" resultType="user">
    		select id, user_name as userName, note from t_user where id = #{id}
    	</select>
    	
    	<select id="findUsers" resultType="user">
    	   select id, user_name as userName, note from t_user
    	   <where>
    	        <if test="userName != null"> and user_name like concat('%', #{userName}, '%')</if>
    	        <if test="note != null"> and note like concat('%', #{note}, '%')</if>
    	   </where>
    	</select>
    	
    </mapper>
    
    
    <if test="userName != null"> and user_name like concat('%', #{userName}, '%')</if>
    like concat('%', #{userName}, '%')

### jsp ###

<%@ page pageEncoding="UTF-8"%>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
    <!DOCTYPE html>
    <html>
    <head>
    	<meta charset="UTF-8">
    	<title>用户列表</title>
    	<link rel="stylesheet" type="text/css"
    		  href="../../easyui/themes/default/easyui.css">
    	<link rel="stylesheet" type="text/css"
    		  href="../../easyui/themes/icon.css">
    	<link rel="stylesheet" type="text/css" href="../../easyui/demo/demo.css">
    	<script type="text/javascript" src="../../easyui/jquery.min.js"></script>
    	<script type="text/javascript" src="../../easyui/jquery.easyui.min.js"></script>
    	<script type="text/javascript">
    		// 定义事件方法
    		function onSearch() {
    			// 指定请求路径
    			var opts = $("#dg").datagrid("options");
    			opts.url = "./list";
    			// 获取查询参数
    			var userName = $("#userName").val();
    			var note = $("#note").val();
    			// 组织参数
    			var params = {};
    			if (userName != null && userName.trim() != '') {
    				params.userName = userName;
    			}
    			if (note != null && note.trim() != '') {
    				params.note = note;
    			}
    			// 重新载入表格数据
    			$("#dg").datagrid('load', params);
    		}
    	</script>
    </head>
    <body>
    <div style="margin: 20px 0;"></div>
    <div class="easyui-layout" style="width: 100%; height: 350px;">
    	<div data-options="region:'north'" style="height: 50px">
    		<form id="searchForm" method="post">
    			<table>
    				<tr>
    					<td>用户名称：</td>
    					<td><input id="userName" name="userName"
    							   class="easyui-textbox" data-options="prompt:'输入用户名称...'"
    							   style="width: 100%; height: 32px"></td>
    					<td>备注</td>
    					<td><input id="note" name="note" class="easyui-textbox"
    							   data-options="prompt:'输入备注...'" style="width: 100%; height: 32px">
    					</td>
    					<td><a href="#" class="easyui-linkbutton"
    						   data-options="iconCls:'icon-search'" style="width: 80px"
    						   οnclick="onSearch()">查询</a></td>
    				</tr>
    			</table>
    		</form>
    	</div>
    	<div data-options="region:'center',title:'用户列表',iconCls:'icon-ok'">
    		<table id="dg" class="easyui-datagrid"
    			   ,
    			   data-options="border:false,singleSelect:true,
    fit:true,fitColumns:true">
    			<thead>
    			<tr>
    				<th data-options="field:'id'" width="80">编号</th>
    				<th data-options="field:'userName'" width="100">用户名称</th>
    				<th data-options="field:'note'" width="80">备注</th>
    			</tr>
    			</thead>
    			<tbody>
    			
    			<c:forEach items="${userList}" var="user">
    				<tr>
    					<td>${user.id}</td>
    					<td>${user.userName}</td>
    					<td>${user.note}</td>
    				</tr>
    			</c:forEach>
    			</tbody>
    		</table>
    	</div>
    </div>
    </body>

*      /easyui/ 放在与webapp的子目录

# 深入 Spring MVC开发 #

## 处理器映射 ##

*  就会将注解 @RequestMapping所配置的内容 保存到 处理器映射 HandlerMapping 机制中去
 *  通过 HandlerMapping 进行匹配
 *  找到对应的处理器
 *  并且将处理器拦截保存到 handlerExecutionChain 对象中
 *  返回给 dispatcherServlet
 *  handlerMapping任务是：将请求定位到具体的处理器上

@Target({ ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Mapping
    public @interface RequestMapping { 
        String name() default ""; //请求映射名称
    
        @AliasFor("path")
        String[] value() default { }; //通过路径映射
    
        @AliasFor("value")
        String[] path() default { }; //路径映射回 path配置项
    
        RequestMethod[] method() default { };//限定只相应http请求类型
        //默认所有。 get post head options put trace
    
        String[] params() default { }; //存在http参数时才相应
    
        String[] headers() default { };//限定请求头存在对应的参数
    
        String[] consumes() default { };//限定http请求体 提交类型。 application/json test/html
    
        String[] produces() default { };//限定返回的内容类型，仅当http请求头中 accept类型中包含该指定类型时 才返回
    }

*  spring 4.3 后，@GetMapping @PostMapping @PatchMapping @PutMapping
 *  @DeleteMapping

## 获取控制器参数 ##

*  处理器是对控制器的包装
 *  在进入控制器方法之前，会对http的参数 和 上下文进行解析。

### 无注解获取 ###

*  允许参数为空，参数名称 和 http请求的参数名称一致

@RequestMapping("/my")
    @Controller
    public class MyController { 
    	/** * 在无注解下获取参数，要求参数名称和HTTP请求参数名称一致. * @param intVal -- 整数 * @param longVal -- 长整形 * @param str --字符串 * @return 响应JSON参数 */
    	// HTTP GET请求
    	@GetMapping("/no/annotation")
    	@ResponseBody
    	public Map<String, Object> noAnnotation(Integer intVal, Long longVal, String str) { 
    		Map<String, Object> paramsMap = new HashMap<>();
    		paramsMap.put("intVal", intVal);
    		paramsMap.put("longVal", longVal);
    		paramsMap.put("str", str);
    		return paramsMap;
    	}
    }

*   *  http://localhost:8080/user/no/annotation?intVal=10&longVal=200

### @RequestParam获取参数 ###

*  RequestParam 确定前后端参数名称的映射关系
    
        /** * 通过注解@RequestParam获取参数 * @param intVal -- 整数 * @param longVal-- 长整形 * @param str --字符串 * @return 响应JSON数据集 */
        	@GetMapping("/annotation")
        	@ResponseBody
        	public Map<String, Object> requestParam(
                @RequestParam("int_val") Integer intVal,
        		@RequestParam("long_val") Long longVal, 
                @RequestParam("str_val") String strVal) { 
                
        		Map<String, Object> paramsMap = new HashMap<>();
        		paramsMap.put("intVal", intVal);
        		paramsMap.put("longVal", longVal);
        		paramsMap.put("strVal", strVal);
        		return paramsMap;
        	}
    
     *  默认情况下 RequestParam 不能为空
     *  想要为空 @RequestParam(value = “long\_val”,required = false)
     *  http://localhost:8080/my/annotation?int\_val=10&str\_val=哈哈

### 传递数组 ###

@GetMapping("/requestArray")
    	@ResponseBody
    	public Map<String, Object> requestArray(int[] intArr, Long[] longArr, String[] strArr) { 
    		Map<String, Object> paramsMap = new HashMap<>();
    		paramsMap.put("intArr", intArr);
    		paramsMap.put("longArr", longArr);
    		paramsMap.put("strArr", strArr);
    		return paramsMap;
    	}

*  已经支持 用 逗号分隔 的数组
 *  http://localhost:8080/my/requestArray?intArr=1,2,3,4

### 传递json ###

<%@ page pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>新增用户用户</title>
    
    <script src="https://code.jquery.com/jquery-3.2.0.js">
    </script>
    <script type="text/javascript">
    $(document).ready(function() {
        $("#submit").click(function() {
            var userName = $("#userName").val();
            var note = $("#note").val();
            if ($.trim(userName)=='') {
                alert("用户名不能为空！");
                return;
            }
            var params = {
                userName : userName,
                note : note
            };
            $.post({
                url : "./insert",
                // 此处需要告知传递参数类型为JSON，不能缺少
                contentType : "application/json",
                // 将JSON转化为字符串传递
                data : JSON.stringify(params),
                // 成功后的方法
                success : function(result) {
                    if (result == null || result.id == null) {
                        alert("插入失败");
                        return;
                    }
                    alert("插入成功");
                }
            });
        });
    });
    </script>
    </head>
    <body>
        <div style="margin: 20px 0;"></div>
        <form id="insertForm">
            <table>
                <tr>
                    <td>用户名称：</td>
                    <td><input id="userName" name="userName"></td>
                </tr>
                <tr>
                    <td>备注</td>
                    <td><input id="note" name="note"></td>
                </tr>
                <tr>
                    <td></td>
                    <td align="right"><input id="submit" type="button" value="提交" /></td>
                </tr>
            </table>
        </form>
    </body>

@Controller
    @RequestMapping("/user")
    public class UserController { 
    	// 注入用户服务类
    	@Autowired
    	private UserService userService = null;
    
    	/** * 打开请求页面 * @return 字符串，指向页面 */
    	@GetMapping("/add")
    	public String add() { 
    		return "/user/add";
    	}
    
    	/** * 新增用户 * @param user 通过@RequestBody注解得到JSON参数 * @return 回填id后的用户信息 */
    	@PostMapping("/insert")
    	@ResponseBody
    	public User insert(@RequestBody User user) { 
    		userService.insertUser(user);
    		return user;
    	}
    }

### 通过 URL传递参数 ###

*  rest ，编号为1，url 为： /user/1

// {...}代表占位符，还可以配置参数名称
    	@GetMapping("/{id}")
    	// 响应为JSON数据集
    	@ResponseBody
    	// @PathVariable通过名称获取参数
    	public User get(@PathVariable("id") Long id) { 
    		return userService.getUser(id);
    	}

### 获取格式化参数 ###

*  日期： yyyy-MM-dd
 *  金额 约定为 货币符号 和 逗号 。 $1,000,00.00
 *  @DataTimeFormat
 *  @NumberFormat
    
        <%@ page pageEncoding="UTF-8"%>
        <!DOCTYPE html>
        <html>
        <head>
        <meta charset="UTF-8">
        <title>格式化</title>
        </head>
        <body>
        	<form action="./commit" method="post">
        		<table>
        			<tr>
        				<td>日期（yyyy-MM-dd）</td>
        				<td><input type="text" name="date" value="2017-08-08" /></td>
        			</tr>
        			<tr>
        				<td>金额（#,###.##）</td>
        				<td><input type="text" name="number" value="1,234,567.89" /></td>
        			</tr>
        			<tr>
        				<td colspan="2" align="right"><input type="submit" value="提交" />
        				</td>
        			</tr>
        		</table>
        	</form>
        </body>
        </html>
    
        // 映射JSP页面
        	@GetMapping("/format/form")
        	public String showFormat() { 
        		return "/format/formatter";
        	}
        
        	// 获取提交参数
        	@PostMapping("/format/commit")
        	@ResponseBody
        	public Map<String, Object> format(Date date,
        			@NumberFormat(pattern = "#,###.##") Double number) { 
        		Map<String, Object> dataMap = new HashMap<>();
        		dataMap.put("date", date);
        		dataMap.put("number", number);
        		return dataMap;
        	}
    
     *      spring.mvc.date-format=yyyy-MM-dd 
            或者：
            @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) Date date
            @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     *      value="2017-08-08"  data传递string 可以解析
            正规的传递为：2020-06-12 00:00:00 。后台要想要时分秒，用string接收吧
            value="1,234,567.89" 必须设置格式化，才能被识别

## 自定义参数转换规则 ##

*  密文传输
 *  转换规则还包括，控制器返回后的处理。
 *  http请求包含， 请求头header，请求体body，url。上下文环境 和 客户端交互的会话session机制
 *  消息转换是 请求体的转换
 *  
 *  先从 http请求 和 上下文环境 得到参数
 *  简易参数 以简单的转换器 （spring MVC 已经提供）
 *  转换 http请求体 body，调用 httpMessageConverter接口
 *

@PostMapping("/insert")
    	@ResponseBody
    	public User insert(@RequestBody User user) { 
    		userService.insertUser(user);
    		return user;
    	}

*  httpMessageConverter
    
     *  canRead
     *  canWrite
     *  getSupportedMediaTypes
     *  read
     *  write
 *  参数标注@RequestBody，首先会调度 canRead方法确定请求体 是否可读
 *  可读后，使用read方法，将前端提交的json转换为控制器
 *  性别前端传递控制器的是整数，而控制器参数却是一个枚举，需要自定义参数转换规则
 *  处理器转换参数的过程，
 *  是通过webDataBinder机制来获取参数的，
 *  解析Http请求的上下文，
 *  在控制器的 调用之前转换参数 并且 提供验证的功能
 *  为调用控制器方法做准备
 *  处理器会 从 HTTP 请求中 读取数据，然后通过三种接口来进行 各类参数转换
    
     *  convert
     *  formatter
     *  genericConverter
 *  这三种接口 都采用了 注册机 的机制，默认MVC已经在注册机内 注册了许多的转换器
 *  整型 长整型 字符串
 *  当需要自定义转换规则时，只需要在注册机上注册自己的转换器就可以了。
 *  webDataBinder 还有一个功能，那就是验证转换结果
 *  有了参数的转换和验证，最终控制器就 可以得到 合法的结果
 *  处理 内部处理逻辑 httpMessageConverter
    
    1.  WebDataBinder
    
     *  converter 普通转换器 integer，从http得到字符串转成integer
     *  formatter 格式化转换器，日期
     *  genericConverter http参数 转换成数组
    
    1.  Java Pojo
    2.  验证机制
    3.  调用控制器
 *  数据类型的转换，MVC提供了一个服务机制，ConversionService接口
 *  默认用 DefaultFormattingConversionService
 *  Boot 还提供了特殊的机制来管理 这些转换器
 *  WebMVCAutoConfiguration 定义了内部类 WebMvcAutoConfigurationAdapter
 *

### 一对一转换器 ###

/** * 自定义字符串用户转换器 */
    @Component
    public class StringToUserConverter implements Converter<String, User> { 
        /** * 转换方法 */
        @Override
        public User convert(String userStr) { 
            User user = new User();
            String []strArr = userStr.split("-");
            Long id = Long.parseLong(strArr[0]);
            String userName = strArr[1];
            String note = strArr[2];
            user.setId(id);
            user.setUserName(userName);
            user.setNote(note);
            return user;
        }
    }

*      @GetMapping("/converter")@ResponseBodypublic User getUserByConverter(User user) {   return user;}

{ 
        "id": 1,
        "userName": "张三",
        "note": "备注一下"
    }

### GenericConverter集合 和 数组 转换 ###

*  MVC 会使用 StringToCollectionConverter转换它
 *  会把 字符串用逗号 分隔 为 一个个的子 字符串
 *  然后根据 原类型 String，目标类型 User ，找到对应的转换器
 *  StringToCollectionConver —— StringToUserConverter
 *      @GetMapping("/list")
          	@ResponseBody
          	public List<User> list(List<User> userList) { 
          		return userList;
          	}
 *  http://localhost:8080/user/list?userList=1-张三-备注一下,2-李四-备注二下

## 数据验证 ##

*  参数转换之后，需要验证参数的合法性
 *  JSR-303注解验证,默认会引入 hibernate validator
 *  自定义验证规则

### jsr-303验证 ###

#### pom ####

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-validation</artifactId>
            </dependency>

#### java ####

public class ValidatorPojo { 
    
    	// 非空判断
    	@NotNull(message = "id不能为空")
    	private Long id;
    
    	@Future(message = "需要一个将来日期") // 只能是将来的日期
    	// @Past //只能去过去的日期
    	@DateTimeFormat(pattern = "yyyy-MM-dd") // 日期格式化转换
    	@NotNull // 不能为空
    	private Date date;
    
    	@NotNull // 不能为空
    	@DecimalMin(value = "0.1") // 最小值0.1元
    	@DecimalMax(value = "10000.00") // 最大值10000元
    	private Double doubleValue = null;
    
    	@Min(value = 1, message = "最小值为1") // 最小值为1
    	@Max(value = 88, message = "最大值为88") // 最大值88
    	@NotNull // 不能为空
    	private Integer integer;
    
    	@Range(min = 1, max = 888, message = "范围为1至888") // 限定范围
    	private Long range;
    
    	// 邮箱验证
    	@Email(message = "邮箱格式错误")
    	private String email;
    
    	@Size(min = 20, max = 30, message = "字符串长度要求20到30之间。")
    	private String size;
    }

#### pojo.jsp ####

<%@ page pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>测试JSR-303</title>
    
    <script src="https://code.jquery.com/jquery-3.2.0.js"></script>
    <script type="text/javascript">
    	$(document).ready(function() {
    		// 请求验证的POJO
    		var pojo = {
    			id : null,
    			date : '2017-08-08',
    			doubleValue : 999999.09,
    			integer : 100,
    			range : 1000,
    			email : 'email',
    			size : 'adv1212',
    			regexp : 'a,b,c,d'
    		}
    		$.post({
    			url : "./validate",
    			// 此处需要告知传递参数类型为JSON，不能缺少
    			contentType : "application/json",
    			// 将JSON转化为字符串传递
    			data : JSON.stringify(pojo),
    			// 成功后的方法
    			success : function(result) {
    			}
    		});
    	});
    </script>
    </head>
    <body></body>
    </html>

#### controller ####

@GetMapping("/valid/page")
        public String validPage() { 
            return "/validator/pojo";
        }
    
    	/*** * 解析验证参数错误 * @param vp —— 需要验证的POJO，使用注解@Valid 表示验证 * @param errors 错误信息，它由Spring MVC通过验证POJO后自动填充 * @return 错误信息Map */
    	@RequestMapping(value = "/valid/validate")
    	@ResponseBody
    	public Map<String, Object> validate(
    	        @Valid @RequestBody ValidatorPojo vp, Errors errors) { 
    	    Map<String, Object> errMap = new HashMap<>();
    	    // 获取错误列表
    	    List<ObjectError> oes = errors.getAllErrors();
    	    for (ObjectError oe : oes) { 
    	        String key = null;
    	        String msg = null;
    	        // 字段错误
    	        if (oe instanceof FieldError) { 
    	            FieldError fe = (FieldError) oe;
    	            key = fe.getField();// 获取错误验证字段名
    	        } else { 
    	            // 非字段错误
    	            key = oe.getObjectName();// 获取验证对象名称
    	        }
    	        // 错误信息
    	        msg = oe.getDefaultMessage();
    	        errMap.put(key, msg);
    	    }
    	    return errMap;
    	}

#### 测试 ####

http://localhost:8080/user/valid/validate
    		{ 
    			id : null,
    			date : '2017-08-08',
    			doubleValue : 999999.09,
    			integer : 100,
    			range : 1000,
    			email : 'email',
    			size : 'adv1212',
    			regexp : 'a,b,c,d'
    		}
    
            { 
                "date":"需要一个将来日期",
                "size":"字符串长度要求20到30之间。",
                "range":"范围为1至888",
                "integer":"最大值为88",
                "doubleValue":"必须小于或等于10000.00",
                "id":"id不能为空",
                "email":"邮箱格式错误"
            }

*  验证购买的总价格 = 单价 X 数量 ，验证不了

### 参数验证机制 ###

*  参数转换的时候，存在 WebDataBinder机制管理
 *  Spring会自动的 根据上下文 通过转换器 转换出 控制器 所需的参数
 *  还 允许注册 验证器 validator
 *  还允许使用注解 @InitBinder ，作用是 允许在进入控制器方法前 修改 WebDataBinder机制
    
        public interface Validator { 
            //判定当前验证器是否支持 class 类型
            boolean supports(Class<?> var1);
        	//如果supports返回true，则这个方法执行逻辑
            void validate(@Nullable Object var1, Errors var2);
        }

#### 自定义验证器 ####

public class UserValidator implements Validator { 
    	
    	// 该验证器只是支持User类验证
    	@Override
    	public boolean supports(Class<?> clazz) { 
    		return clazz.equals(User.class);
    	}
    
    	// 验证逻辑
    	@Override
    	public void validate(Object target, Errors errors) { 
    		// 对象为空
    		if (target == null) { 
    			// 直接在参数处报错，这样就不能进入控制器的方法了
    			errors.rejectValue("", null, "用户不能为空");
    			return;
    		}
    		// 强制转换
    		User user = (User) target;
    		// 用户名非空串
    		if (StringUtils.isEmpty(user.getUserName())) { 
    			// 增加错误，可以进入控制器方法
    			errors.rejectValue("userName", null, "用户名不能为空");
    		}
    	}
    }

#### 绑定 ####

*  要绑定给 webDataBinder
 *  @InitBinder
 *  执行控制器方法前，处理器会先执行 被 @InitBinder标注的方法
 *      /** * 调用控制器前先执行这个方法 * #控制器已经不需要 @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date date * @param binder */
          	@InitBinder
          	public void initBinder(WebDataBinder binder) { 
          		// 绑定验证器
          		binder.setValidator(new UserValidator());
          		// 定义日期参数格式，参数不再需注解@DateTimeFormat，boolean参数表示是否允许为空
          		binder.registerCustomEditor(Date.class, new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), false));
          	}
 *      /** * * @param user * -- 用户对象用StringToUserConverter转换 * @param Errors * --验证器返回的错误 * @param date * -- 因为WebDataBinder已经绑定了格式，所以不再需要注解 * @return 各类数据 */
          	@GetMapping("/validator")
          	@ResponseBody
          	public Map<String, Object> validator(@Valid User user, Errors Errors, Date date) { 
          		Map<String, Object> map = new HashMap<>();
          		map.put("user", user);
          		map.put("date", date);
          		// 判断是否存在错误
          		if (Errors.hasErrors()) { 
          			// 获取全部错误
          			List<ObjectError> oes = Errors.getAllErrors();
          			for (ObjectError oe : oes) { 
          				// 判定是否字段错误
          				if (oe instanceof FieldError) { 
          					// 字段错误
          					FieldError fe = (FieldError) oe;
          					map.put(fe.getField(), fe.getDefaultMessage());
          				} else { 
          					// 对象错误
          					map.put(oe.getObjectName(), oe.getDefaultMessage());
          				}
          			}
          		}
          		return map;
          	}
 *  Errors Errors 通过验证器 验证后 得到的错误信息

#### 测试 ####

{ 
        "date": "2017-12-31T16:00:00.000+00:00",
        "userName": "用户名不能为空",
        "user": { 
            "id": 1,
            "userName": "",
            "note": "备注"
        }
    }
    http://localhost:8080/user/validator?user=1--备注&date=2018-01-01

## 数据模型 ##

*  绑定数据，为 试图渲染做准备
 *  模型和视图 modelAndView
    
     *  view object
     *  model modelMap
     *  status httpStatus
     *  cleared boolean
 *  modelMap
    
     *  继承：linkedHashMap
     *  modelmap
     *  extendedModelMap
     *  bindingAwareModelMap
 *  在控制器方法的参数中 使用ModelAndView Model或 ModelMap作为参数
 *  会自动创建数据模型对象

### controller ###

@RequestMapping("/data")
    @Controller
    public class DataModelController { 
        // 注入用户服务类
        @Autowired
        private UserService userService = null;
        
        // 测试Model接口
        @GetMapping("/model")
        public String useModel(Long id, Model model) { 
            User user = userService.getUser(id);
            model.addAttribute("user", user);
            // 这里返回字符串，在Spring MVC中，会自动创建ModelAndView且绑定名称
            return "data/user";
        }
        
        // 测试modelMap类
        @GetMapping("/modelMap")
        public ModelAndView useModelMap(Long id, ModelMap modelMap) { 
            User user = userService.getUser(id);
            ModelAndView mv = new ModelAndView();
            // 设置视图名称
            mv.setViewName("data/user");
            // 设置数据模型，此处modelMap并没有和mv绑定，这步系统会自动处理
            modelMap.put("user", user);
            return mv;
        }
        
        // 测试ModelAndView
        @GetMapping("/mav")
        public ModelAndView useModelAndView(Long id, ModelAndView mv) { 
            User user = userService.getUser(id);
            // 设置数据模型
            mv.addObject("user", user);
            // 设置视图名称
            mv.setViewName("data/user");
            return mv;
        }
    }

### jsp ###

<%@ page language="java" contentType="text/html; charset=UTF-8"  
    pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
    "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>用户信息</title>
    </head>
    <body>
        <table>
            <tr>
                <td>编号</td>
                <td>${user.id}</td>
            </tr>
            <tr>
                <td>用户名</td>
                <td>${user.userName}</td>
            </tr>
            <tr>
                <td>备注</td>
                <td>${user.note}</td>
            </tr>
        </table>
    </body>
    </html>

## 视图 和 视图 解析器 ##

*  是渲染 数据模型 展示给用户的组件
 *  逻辑视图 和 非逻辑视图
 *  逻辑视图需要视图解析器 viewResolver （可用InternalResourceViewResolver）进一步定位，才能找到 视图将数据模型 进行渲染
 *  非逻辑视图：不需要进一步定位，直接将数据模型渲染出来即可
 *  还有 Excel PDF 等

### 视图的设计 ###

public interface View { 
        //响应状态属性
        String RESPONSE_STATUS_ATTRIBUTE = View.class.getName() + ".responseStatus";
        //路径变量
        String PATH_VARIABLES = View.class.getName() + ".pathVariables";
        //选择内容类型
        String SELECTED_CONTENT_TYPE = View.class.getName() + ".selectedContentType";
    
        //响应类型：获取 http响应类型，文本，json，文件
        @Nullable
        default String getContentType() { 
            return null;
        }
    	//渲染方式。将数据模型 渲染到数据。model数据模型，
    	void render(@Nullable Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
    			throws Exception;
    }

*  pdf视图
    
     *  AbstractPdfView
 *  Json视图
    
     *  abstractJacksonView
     *  MappingJackson2JsonView
 *  Excel视图
    
     *  abstractXlsView
     *  abstractXlsView
     *  abstractXlsxStreamingView
 *  逻辑视图
    
     *  abstractURLBasedView
     *  InternalResourceView
     *  InternalResourceView
        
         *  jstlView (Jsp视图)

# PDF视图 #

*  AbstractPdfView 是非逻辑视图，不需要视图解析器去定位
    
        protected abstract void buildPdfDocument(
                
                Map<String, Object> model,  //数据模型
                Document document, //
                PdfWriter writer,
        		HttpServletRequest request, 
                HttpServletResponse response
                
                ) throws Exception;

#### pom ####

<dependency>
                <groupId>org.xhtmlrenderer</groupId>
                <artifactId>core-renderer</artifactId>
                <version>R8</version>
            </dependency>
            <dependency>
                <groupId>com.itextpdf</groupId>
                <artifactId>itextpdf</artifactId>
                <version>5.5.13</version> //或12版本
            </dependency>

#### 定义PDF导出的接口 ####

public interface PdfExportService {
    	public void make(Map<String, Object> model, Document document,
                         PdfWriter writer, HttpServletRequest request,
                         HttpServletResponse response);
    }

#### 导出PDF视图类 ####

*  继承 AbstractPdfView，调度 PdfExportService 的make方法

public class PdfView extends AbstractPdfView { 
        // 导出服务接口
        private PdfExportService pdfExportService = null;
        
        // 创建对象的时候载入导出服务接口
        public PdfView(PdfExportService pdfExportService) { 
            this.pdfExportService = pdfExportService;
        }
        
        // 调用接口实现
        @Override
        protected void buildPdfDocument(Map<String, Object> model, Document document,
                                        PdfWriter writer, HttpServletRequest request,
                                        HttpServletResponse response) throws Exception { 
            // 调用导出服务接口类
            pdfExportService.make(model, document, writer, request, response);
        }
    }

#### 用户控制器 导出PDF数据 ####

// 导出接口
    	@GetMapping("/export/pdf")
    	public ModelAndView exportPdf(String userName, String note) { 
    		// 查询用户信息列表
    		List<User> userList = userService.findUsers(userName, note);
    		// 定义PDF视图
    		View view = new PdfView(exportService());
    		ModelAndView mv = new ModelAndView();
    		// 设置视图
    		mv.setView(view);
    		// 加入数据模型
    		mv.addObject("userList", userList);
    		return mv;
    	}
    
    	// 导出PDF自定义
    	@SuppressWarnings("unchecked")
    	private PdfExportService exportService() { 
    		// 使用Lambda表达式定义自定义导出
    		return (model, document, writer, request, response) -> { 
    			try { 
    				// A4纸张
    				document.setPageSize(PageSize.A4);
    				// 标题
    				document.addTitle("用户信息");
    				// 换行
    				document.add(new Chunk("\n"));
    				// 表格，3列
    				PdfPTable table = new PdfPTable(3);
    				// 单元格
    				PdfPCell cell = null;
    				// 字体，定义为蓝色加粗
    				Font f8 = new Font();
    				f8.setColor(Color.BLUE);
    				f8.setStyle(Font.BOLD);
    				// 标题
    				cell = new PdfPCell(new Paragraph("id", f8));
    				// 居中对齐
    				cell.setHorizontalAlignment(1);
    				// 将单元格加入表格
    				table.addCell(cell);
    				cell = new PdfPCell(new Paragraph("user_name", f8));
    				// 居中对齐
    				cell.setHorizontalAlignment(1);
    				table.addCell(cell);
    				cell = new PdfPCell(new Paragraph("note", f8));
    				cell.setHorizontalAlignment(1);
    				table.addCell(cell);
    				// 获取数据模型中的用户列表
    				List<User> userList = (List<User>) model.get("userList");
    				for (User user : userList) { 
    					document.add(new Chunk("\n"));
    					cell = new PdfPCell(new Paragraph(user.getId() + ""));
    					table.addCell(cell);
    					cell = new PdfPCell(new Paragraph(user.getUserName()));
    					table.addCell(cell);
    					String note = user.getNote() == null ? "" : user.getNote();
    					cell = new PdfPCell(new Paragraph(note));
    					table.addCell(cell);
    				}
    				// 在文档中加入表格
    				document.add(table);
    			} catch (DocumentException e) { 
    				e.printStackTrace();
    			}
    		};
    	}

*  得到用户列表
 *  设置上PDF视图
 *  设置上数据模型

<dependency>
                <groupId>bouncycastle</groupId>
                <artifactId>bcmail-jdk14</artifactId>
                <version>138</version>
            </dependency> //最新版配合起来缺这个文件

*  访问：http://localhost:8080/user/export/pdf 。启动报错，无关紧要

# 文件上传 #

*  DispatcherServlet会使用适配器模式
 *  将HTTPServletRequest接口对象转换为 Multipart HttpServletRequest
 *  此接口扩展了 httpServletRequest接口的所有方法
 *  MultipartRequest
    
     *  getFileNames
     *  getFile
     *  getFiles
     *  getFileMap
     *  getMultiFileMap
     *  getMultPart ContentType
 *  Multipart HttpServletRequest 继承 上面 和 HTTPServletRequest
    
     *  getRequestMethod
     *  getRequestHeaders
     *  getMultipartHeaders
 *  Abstract MultipartHttpServlet Request 抽象类，继承上面
    
     *  Default Multipart HttpservletRequest
     *  Standard Multipart HttpServlet Request
 *  MVC 会将 HTTPServletRequest 转成 Multipart HttpServlet Request
 *  配置 Multipart HttpServlet Request 通过 MultipartResolver接口
    
     *  CommonsMultipartResolver 需要依赖第三方包，渐渐被废弃
     *  StandardServlet Multipart Resolver

### 文件上传配置 ###

# 是否启用 Spring MVC 多分部上传功能
    spring.servlet.multipart.enabled=false
    # 将文件写入磁盘，值可以使用的后缀 MB 或 KB 来表示 兆字节 或 字节大小
    spring.servlet.multipart.file-size-threshold=0
    
    # 中间这3个需要配置
    # 指定默认上传的文件夹
    spring.servlet.multipart.location=e:/springboot
    # 限制单个文件最大大小，这里设置为5M。
    spring.servlet.multipart.max-file-size=5242880
    # 限制所有文件最大大小,这里设置为20M
    spring.servlet.multipart.max-request-size=20MB 不能写MB，需要Long类型
    
    #是否延迟 多部件 文件 请求的参数 和 文件的解析
    spring.servlet.multipart.resolve-lazily=false

*  根据这些配置，自动生成：StandardServlet Multipart Resolver
 *  可以使用 Servlet Api的part接口，或 MVC 的 MultipartFile 接口 （需要第三方包）

### jsp ###

<%@ page language="java" contentType="text/html; charset=UTF-8"
             pageEncoding="UTF-8" %>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
    "http://www.w3.org/TR/html4/loose.dtd">
    <html>
        <head>
            <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
            <title>文件上传</title>
        </head>
        <body>
            <form method="post"
                  action="./part" enctype="multipart/form-data">
                <input type="file" name="file" value="请选择上传的文件"/>
                <input type="submit" value="提交"/>
            </form>
        </body>
    </html>

### controller ###

@Controller
    @RequestMapping("/file")
    public class FileController { 
        /** * 打开文件上传请求页面 * @return 指向JSP的字符串 */
        @GetMapping("/upload/page")
        public String uploadPage() { 
            return "/file/upload";
        }
        
        // 使用HttpServletRequest作为参数
        //在调用控制器之前，DispatcherServlet 会 将其装换为 MultipartHTTPServletRequest 对象
        @PostMapping("/upload/request")
        @ResponseBody
        public Map<String, Object> uploadRequest(HttpServletRequest request) { 
            boolean flag = false;
            MultipartHttpServletRequest mreq = null;
            // 强制转换为MultipartHttpServletRequest接口对象
            if (request instanceof MultipartHttpServletRequest) { 
                mreq = (MultipartHttpServletRequest) request;
            } else { 
                return dealResultMap(false, "上传失败");
            }
            // 获取MultipartFile文件信息
            MultipartFile mf = mreq.getFile("file");
            // 获取源文件名称
            String fileName = mf.getOriginalFilename();
            File file = new File(fileName);
            try { 
                // 保存文件
                mf.transferTo(file);
            } catch (Exception e) { 
                e.printStackTrace();
                return dealResultMap(false, "上传失败");
            } 
            return dealResultMap(true, "上传成功");
        }
        
        // 使用Spring MVC的MultipartFile类作为参数
        @PostMapping("/upload/multipart")
        @ResponseBody
        public Map<String, Object> uploadMultipartFile(MultipartFile file) { 
            String fileName = file.getOriginalFilename();
            File dest = new File(fileName);
            try { 
                file.transferTo(dest);
            } catch (Exception e) { 
                e.printStackTrace();
                return dealResultMap(false, "上传失败");
            } 
            return dealResultMap(true, "上传成功");
        }
        
        //推荐
        @PostMapping("/upload/part")
        @ResponseBody
        public Map<String, Object> uploadPart(Part file) { 
            // 获取提交文件名称
            String fileName = file.getSubmittedFileName();
            try { 
                // 写入文件
                file.write(fileName);
            } catch (Exception e) { 
                e.printStackTrace();
                return dealResultMap(false, "上传失败");
            } 
            return dealResultMap(true, "上传成功");
        }
        
        // 处理上传文件结果
        private Map<String, Object> dealResultMap(boolean success, String msg) { 
            Map<String, Object> result = new HashMap<String, Object>();
            result.put("success", success);
            result.put("msg", msg);
            return result;
        }
    }

*  return “/file/upload”;
 *  跳转到：src/main/webapp/WEB-INF/jsp/file/upload.jsp
 *  action="./part"
 *  跳转到 @RequestMapping("/file") @PostMapping("/upload/part")
 *

# 拦截器 #

*  请求来到 DispatcherServlet，会根据HandlerMapping的机制 处找到处理器
 *  返回：HandlerExecutionChain （包含处理器和拦截器）
 *  拦截器会对处理器进行拦截，（通过拦截器就可以增强处理器的功能）
 *  所有的拦截器都是实现 HandlerInterceptor
    
        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 { 
        	}
        
        }
 *  preHandler方法
    
     *  返回true——处理器（包含控制器功能）——postHandle方法——视图处理——afterCompletion方法——结束
     *  返回false——结束

## 开发拦截器 ##

public class Interceptor1 implements HandlerInterceptor { 
        @Override
        public boolean preHandle(HttpServletRequest request, 
                HttpServletResponse response, Object handler)
                throws Exception { 
            System.out.println("处理器前方法");
            // 返回true，不会拦截后续的处理
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, 
                HttpServletResponse response, Object handler,
                ModelAndView modelAndView) throws Exception { 
            System.out.println("处理器后方法");
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, 
                HttpServletResponse response, Object handler, Exception ex)
                throws Exception { 
            System.out.println("处理器完成方法");
        }
    }

## 注册拦截器 ##

@SpringBootApplication(scanBasePackages = "com.springboot.chapter10")
    @MapperScan(basePackages = "com.springboot.chapter10", annotationClass = Mapper.class)
    public class Chapter10Application implements WebMvcConfigurer { 
    
    	public static void main(String[] args) { 
    		SpringApplication.run(Chapter10Application.class, args);
    	}
    
    	@Override
    	public void addInterceptors(InterceptorRegistry registry) { 
    	 // 注册拦截器到Spring MVC机制，然后它会返回一个拦截器注册
    	InterceptorRegistration ir = registry.addInterceptor(new Interceptor1());
    	// 指定拦截匹配模式，限制拦截器拦截请求
    	ir.addPathPatterns("/interceptor/*");
    	}
    }

## 测试 ##

@Controller
    @RequestMapping("/interceptor")
    public class InterceptorController { 
    	@GetMapping("/start")
    	public String start() { 
    		System.out.println("执行处理器逻辑");
    		return "/welcome";
    	}
    }

<%@ page language="java" contentType="text/html; charset=UTF-8"
     pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
    "http://www.w3.org/TR/html4/loose.dtd">
    <html>
        <head>
            <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
            <title>深入Spring MVC</title>
        </head>
        <body>
            <h1>
                <%
                System.out.println("视图渲染");
                out.print("欢迎学习Spring Boot MVC章节\n");
                %>
            </h1>
        </body>
    </html>

启动的时候，会注册 拦截器（执行这里的代码）
    访问：http://localhost:8080/interceptor/start
    
    处理器前方法 ——————————拦截器的 preHandle
    执行处理器逻辑 ——————————action的逻辑
    处理器后方法 ————————————拦截器的 postHandle
    视图渲染(JSP)中java代码 ——————————jsp第一行代码
    视图渲染22 (JSP)中java代码  ——————————jsp第二行代码
    处理器完成方法 ————————————————————afterCompletion 处理器完成方法
    
    afterCompletion 执行完毕后，才执行out.print
    此时所有后台打印完毕，前端会展示out.print 的输出 欢迎学习Spring Boot MVC章节

preHandle return false;
    则直接接触，不执行action方法
    如果preHandle 出错，也是如此

## 多个拦截器的执行顺序 ##

public class MulitiInterceptor1 implements HandlerInterceptor { 
    	@Override
        public boolean preHandle(HttpServletRequest request, 
                HttpServletResponse response, Object handler)
                throws Exception { 
            System.out.println("【" + this.getClass().getSimpleName()
                +"】处理器前方法");
            // 返回true，不会拦截后续的处理
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, 
                HttpServletResponse response, Object handler,
                ModelAndView modelAndView) throws Exception { 
            System.out.println("【" + this.getClass().getSimpleName()
                +"】处理器后方法");
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, 
                HttpServletResponse response, Object handler, Exception ex)
                throws Exception { 
            System.out.println("【" + this.getClass().getSimpleName()
                +"】处理器完成方法");
        }
    }

处理器前方法
    处理器前方法2
    
    执行处理器逻辑
    
    处理器后方法2
    处理器后方法
    
    视图渲染(JSP)中java代码
    视图渲染22 (JSP)中java代码
    
    处理器完成方法2
    处理器完成方法

*  这是 责任链 模式的规则
 *  先注册 先执行，
 *  而 处理器后 方法 和 完成方法 ，则是 先注册 后执行
 *  把 第二个拦截器 执行前方法返回false
    
     *      处理器前方法
            处理器前方法2
            处理器完成方法
     *  则后续的拦截器，处理器 和 所有拦截器的处理器后 postHandler 方法都不执行
     *  完成方法 只会执行已经返回true的拦截器 的 完成方法，而顺序是 先注册 后执行

# 国际化 #

*  国际化消息源机制，MessageSource接口体系
 *  大部分情况使用JDK的 ResourceBundle处理国际化消息，主要使用 ResourceBundleMessageSource
 *

### 配置 ###

# 指定国际化区域，可以覆盖"Accept-Language" 头信息
    #spring.mvc.locale= 
    #国际化解析器，可以选择：fixed、accept-header
    #fixed代表固定的国际化，accept-header代表读取浏览器的"Accept-Language"头信息
    #spring.mvc.locale-resolver=accept-header
    
    # 文件编码
    spring.messages.encoding=UTF-8
    # 国际化文件基础名称
    spring.messages.basename=international
    # 国际化消息缓存有效时间（单位秒），超时将重新载入
    spring.messages.cache-duration=3600

# Spring MVC 拾遗 #

## @ResponseBody转为 JSON ##

*  当执行完控制器 返回，处理器会 启用结果 解析器（Result Resolver )
 *  去轮询 注册给Spring MVC 的 HttpMessageConverter接口的实现类
 *  因为：MappingJackson2HttpMessageConverter这个实现类 已经被Spring MVC 所注册
 *  Spring MVC将控制器的结果类型 标明为 JSON
 *  标注@ResponseBody——执行控制器返回——轮询注册的HttpMessageConverter （通过MappingJackson2HttpMessageConverter的canWriter方法确定是否转换结果）
 *  是
    
     *  转换为JSON数据集 结束
 *  否
    
     *  后续视图流程

## 重定向 ##

*  redirect
 *

<insert id="insertUser" parameterType="user" useGeneratedKeys="true" keyProperty="id">
    	    insert into t_user(user_name, note) values(#{userName}, #{note})
    	</insert>

// 显示用户
    	@GetMapping("/show")
    	public String showUser(Long id, Model model) { 
    	    User user = userService.getUser(id);
    	    model.addAttribute("user", user);
    	    return "data/user";
    	}
    
    	// 使用字符串指定跳转
    	@GetMapping("/redirect1")
    	public String redirect1(String userName, String note) { 
    	    User user = new User();
    	    user.setNote(note);
    	    user.setUserName(userName);
    	    // 插入数据库后，回填user的id
    	    userService.insertUser(user);
    	    return "redirect:/user/show?id=" + user.getId();
    	}
    
    	// 使用模型和视图指定跳转
    	@GetMapping("/redirect2")
    	public ModelAndView redirect2(String userName, String note) { 
    	    User user = new User();
    	    user.setNote(note);
    	    user.setUserName(userName);
    	    userService.insertUser(user);
    	    ModelAndView mv = new ModelAndView();
    	    mv.setViewName("redirect:/user/show?id=" + user.getId());
    	    return mv;
    	}

<body>
        <table>
            <tr>
                <td>编号</td>
                <td>${user.id}</td>
            </tr>
            <tr>
                <td>用户名</td>
                <td>${user.userName}</td>
            </tr>
            <tr>
                <td>备注</td>
                <td>${user.note}</td>
            </tr>
        </table>
    </body>

http://localhost:8080/user/redirect1?userName=zhangsan&note=%E5%A4%87%E6%B3%A82
    会调到第一个action,ID 为插入返回的ID
    http://localhost:8080/user/show?id=3

### 重定向优化 ###

// 显示用户
    	// 参数user直接从数据模型RedirectAttributes对象中取出
    	@RequestMapping("/showUser")
    	public String showUser(User user, Model model) { 
    	    System.out.println(user.getId());
    	    return "data/user";
    	}
    
    	// 使用字符串指定跳转
    	@RequestMapping("/redirect1")
    	public String redirect1(String userName, String note, RedirectAttributes ra) { 
    	    User user = new User();
    	    user.setNote(note);
    	    user.setUserName(userName);
    	    userService.insertUser(user);
    	    // 保存需要传递给重定向的对象
    	    ra.addFlashAttribute("user", user);
    	    return "redirect:/user/showUser";
    	}
    
    	// 使用模型和视图指定跳转
    	@RequestMapping("/redirect2")
    	public ModelAndView redirect2(String userName, String note,
    	        RedirectAttributes ra) { 
    	    User user = new User();
    	    user.setNote(note);
    	    user.setUserName(userName);
    	    userService.insertUser(user);
    	    // 保存需要传递给重定向的对象
    	    ra.addFlashAttribute("user", user);
    	    ModelAndView mv = new ModelAndView();
    	    mv.setViewName("redirect:/user/showUser");
    	    return mv;
    	}

*  第一次在 showUser方法 ，要重新查一次
 *  第二次 使用 RedirectAttributes ra ； ra.addFlashAttribute(“user”, user);
 *  /showUser 无需查询放入model了

## 操作会话对象 ##

*  操作 httpSession 十分普遍
 *  @SessionAttribute 用于参数，将httpSession属性读出，赋予控制器
 *  @SessionAttributes 用于类，数据模型的属性保存到session中
 *  
 *  setjsp 和test.jsp

<%@ page pageEncoding="UTF-8"%>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
    <html>
    <head>
        <title>用户详情</title>
    </head>
        <body>
            <%
                session.setAttribute("id",1L);
                response.sendRedirect("./test");
            %>
        </body>
    </html>
    
    查看的页面
    <%@ page import="com.hua.testj.pojo.User" %>
    <%@ page pageEncoding="UTF-8"%>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
    <html>
    <head>
        <title>用户详情</title>
    </head>
    <body>
    <%
        User user = (User) session.getAttribute("user");
        Long id_new = (Long)session.getAttribute("id_new");
        out.print(user.getUserName());
        out.println(id_new);
    %>
    </body>
    </html>

//指定数据模型名称 或 属性类型，保存到 session中
    @SessionAttributes(names = { "user"},types = Long.class)
    @Controller
    @RequestMapping("/session")
    public class SessionController { 
        @Autowired
        private UserService userService=null;
    
        //先访问这个跳转
        @GetMapping("/setjsp")
        public ModelAndView myTest(){ 
            ModelAndView mv = new ModelAndView();
            // 定义模型视图
            mv.setViewName("session/setjsp");
            // 返回模型和视图
            return mv;
        }
    
        @GetMapping("/test")
        public String test(@SessionAttribute("id") Long id, Model model){ 
            model.addAttribute("id_new",id);
            User user=userService.getUser(id);
            model.addAttribute("user",user);
            return "session/test";
        }
    }

## 给控制器增加通知 ##

*  在控制器方法的前后 和 异常 发生时 去执行不同的处理
 *  @ControllerAdvice：控制器的通知类，增强控制器的各类通知，和限定增强哪些控制器 功能
 *  @InitBinder：控制器参数绑定规则，转换规则，格式化，会在参数转换之前执行
 *  @ExceptionHandler：发生异常后的操作。如跳转到指定的页面
 *  @ModelAttribute：在控制器方法执行之前，对数据模型进行操作
 *  
 *  一个工具包

<dependency>
    			<groupId>org.apache.ant</groupId>
    			<artifactId>ant</artifactId>
    			<version>1.9.4</version>
    		</dependency>

### 通知 ###

@ControllerAdvice(
            // 指定拦截的包
            basePackages = {  "com.springboot.chapter10.controller.advice.test.*" }, 
            // 限定被标注为@Controller的类才被拦截 
            annotations = Controller.class)
    public class MyControllerAdvice { 
    
        // 绑定格式化、参数转换规则和增加验证器等 2
        @InitBinder
        public void initDataBinder(WebDataBinder binder) { 
            // 自定义日期编辑器，限定格式为yyyy-MM-dd，且参数不允许为空
            CustomDateEditor dateEditor = 
                new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), false);
            // 注册自定义日期编辑器
            binder.registerCustomEditor(Date.class, dateEditor);
        }
    
        // 在执行控制器之前先执行，可以初始化数据模型。 1
        @ModelAttribute
        public void projectModel(Model model) { 
            model.addAttribute("project_name", "chapter10");
        }
    	//抛出了异常，就执行下面代码
        // 异常处理，使得被拦截的控制器方法发生异常时，都能用相同的视图响应
        @ExceptionHandler(value = Exception.class)
        public String exception(Model model, Exception ex) {  
            // 给数据模型增加异常消息
            model.addAttribute("exception_message", ex.getMessage());
            // 返回异常视图
            return "exception";
        }
    }

### controller ###

@Controller
    @RequestMapping("/advice")
    public class AdviceController { 
    
        @GetMapping("/test")
        // 因为日期格式被控制器通知限定，所以无法再给出
        public String test(Date date, ModelMap modelMap) { 
            // 从数据模型中获取数据
            System.out.println(modelMap.get("project_name"));
            // 打印日期参数
            System.out.println(DateUtils.format(date, "yyyy-MM-dd"));
            // 抛出异常，这样流转到控制器异常通知
            throw new RuntimeException("异常了，跳转到控制器通知的异常信息里");
        }
    }

exception.jsp
      
      http://localhost:8080/advice/test
      <h3><td>${exception_message}</td></h3>

# 获取请求头 #

*  利用请求头的数据 进行身份的验证
 *  @RequestHeader
 *      <%@ page pageEncoding="UTF-8"%>
        <!DOCTYPE html>
        <html>
        <head>
            <meta charset="UTF-8">
            
            <title>获取请求头参数</title>
            
            
            <script src="https://code.jquery.com/jquery-3.2.0.js">
            </script>
            
            <script type="text/javascript">
            $.post({
                url : "./user",
                // 设置请求头参数
                headers : {id : '1'},
                // 成功后的方法
                success : function(user) {
                    if (user == null || user.id == null) {
                        alert("获取失败");
                        return;
                    }
                    // 弹出请求返回的用户信息
                    alert("id=" + user.id +", user_name="
                            +user.userName+", note="+ user.note);
                }
            });
            </script>
        </head>
        <body>
        </body>
 *      @GetMapping("/header/page")
        	public String headerPage() { 
        	    return "header";
        	}
        
        	@PostMapping("/header/user")
        	@ResponseBody
        	// 通过@RequestHeader接收请求头参数
        	public User headerUser(@RequestHeader("id") Long id) { 
        	    User user = userService.getUser(id);
        	    return user;
        	}
 *  http://localhost:8080/user/header/page