MVC 框架

在 spring 框架和 Spring Boot 中，最常用的技术就是 MVC 框架，MVC 框架会处理类似如下相同技术的需求：

1、HTTP UTL 映射到 Controller 某个方法；
2、HTTP 参数映射到 Controller 方法的参数上，比如参数映射到某个Java对象，或者上传附件映射到某个File对象上；
3、参数的校验；
4、MVC 错误处理；
5、MVC 中如何调用视图；
6、MVC 中如何序列化对象成JSON；
7、拦截器高级定制；

引入依赖
Spring Boot 集成 Spring MVC 框架并实现自动配置，只需要在 pom 中添加以下依赖即可，不需要其他任何配置。

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

Web 应用目录结构
Web的模板文件位于 resources/templates 目录下，模板文件使用的静态资源文件，如 js css 图片，存放在 resources/statis 目录下。在 MVC 中，视图名自动在 templates 目录下找到对应的模板名称，模板中使用的静态资源将在 static 目录下查找。

Java 包名结构
通常会创建如下子包名：

Controller ---
Service ---
entity ---
conf ---

使用 Controller

Spring MVC 框架不像传统的 MVC 框架那样必须继承某个基础类才能处理用户的 HTTP 请求， Spring MVC 只需要在类上声明 @Controller，标注这是一个 Controller 即可。对于用户请求，使用 @RequestMapping 映射 HTTP 请求到特定的方法处理类。

@Controller
@RequestMapping("/test)
public class HelloworldController {
    @RequestMapping("/index.html")
    public String say(Model model) {
        model.addAttribute("name","hello world");
        return "/index.html";
    }
}

如以上代码所示，@Controller 作用于类上，表示这是一个 MVC 中的 Controller。
@RequestMapping 既可以作用于方法上，也可以作用在类上。如上所示，用户如果访问 /test/index.html ，则会交给 HelloworldController.say 方法来处理。

say 方法有一个参数 Model，这是 Spring MVC 可识别的一个参数类型，用来表示 MVC 中的Model。可以在这个 Model 添加多个变量，这些变量随后可以用于视图渲染。

say 方法返回的类型是字符串，默认是视图名称。Spring Boot 的视图默认保存在 resources/templates目录下，因此，渲染的视图是 /resources/templates/index.html 模板文件。

MVC 框架有时候返回的是 JSON 字符串，如果想直接返回内容而不是视图名，则需要在方法上使用 @ResponseBody:

@RequestMapping("/index.json")
public @ResponseBody String say() {
    return "hello world";
}

ResponseBody 注解直接将返回的对象输出到客户端，如果是字符串，则直接返回；如果不是，则默认使用 Jackson 序列化成 JSON 字符串后输出。

建议在 Spring Boot 应用中，如果期望返回 JSON， URL 请求后资源后缀是 json；如果期望返回视图，URL 请求资源后缀是 html

URL 映射到方法

RequestMapping

可以使用 @RequestMapping 来映射 URL，比如 /test 到某个 Controller 类，或者是某个具体的方法，通常类上的注解 @RequestMapping 用来标注请求的路径，方法上的 @RequestMapping 注解进一步映射特定的 URL 到某个具体的处理方法。

RequestMapping 有多个属性来进一步匹配 HTTP 请求到 Controller 方法，分别是：

value， 请求的 URL 路径，支持 URL 模板、正则表达式。
method，HTTP 请求方法，有 GET、POST、PUT 等。
consumes，允许的媒体类型（Media Types），如 consumes = "application/json", 对应于请求的 HTTP 的 Content-Type。
produces, 相应的媒体类型，如 produces = "application/json",对应于 HTTP 的 Accept 字段。
params,请求参数，如 params="action=update"
headers, 请求的 HTTP 头的值，如 headers = "myHeader=myValue"

URL 路径匹配

属性 value 用于匹配一个 URL 映射，value 支持简单的表达式类匹配：

@RequestMapping(value="/get/{id}.json")
public @ResponseBody User getById(@PathVariable("id") Long id) {
    return userService.getUserById(id);
}

上边访问路径是 /get/1.json, 将调用 getById 方法，且参数 id 的值是 1 。注解 PathVariable 作用在方法参数上，用来表示参数的值来自于 URL 路径。

HTTP method 匹配

@RequestMapping 提供 method 属性来映射对应 HTTP 的请求方法，通常 HTTP 请求方法有以下内容：

GET， 用来获取 URL 对应的内容
POST，用来向服务器提交信息
HEAD，同 GET，但不返回消息体，通常用于返回 URL 对应的元信息，如过期时间等。
PUT，同 POST，用来向服务器提交信息，但语义上更像一个更新操作。同一个数据，多次 PUT 操作，也不会导致数据发生改变。POST 在语义上更类似新增操作。
DELETE， 删除对应的资源信息。
PATCH 方法，类似 PUT 方法，表示信息的局部更新。

通常对于 Web 应用，GET 和 POST 是经常使用的选项，对于 REST 接口，则会使用 PUT、DELETE 等用来从语义上进一步区分操作。

Spring 提供了简化后的 @RequestMapping, 提供了新的注解来表示 HTTP 方法：

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

consumes 和 produces
属性 consumes 意味着请求的 HTTP 头的 Content-Type 媒体类型与 consumes 的值匹配，才能调用此方法。

@GetMapping(value="/consumes/test.json",consumes="application/json")
@ResponseBody
public User forjson() {
    return userService.getUserById(11);
}

这里映射指定请求的媒体类型是 application/json,因此，此方法接受一个 AJAX 请求。如果通过浏览器直接访问，则会出错，因为通过浏览器访问，通常并没有设置 Context-Type。

为了成功调用上述Controller方法，AJAX调用必须设置 Content-Type 为 application/json

$.ajax({
    type: "get",
    url: "/consumes/test.json",
    contentType: "application/json",
    ....
})

produces属性对应于 HTTP 请求的 Accept 字段，只有匹配的上的方法才能被调用。

@GetMapping(value="/user/{userid}",produces=MediaType.APPLICATION_JSON_UTF8_VALUE)
@ResponseBody
public User getUser(@PathVariable Long userId, Model model) {
    return userService.getUserById(userId);
}

通常浏览器都会将 Accept 设置为 .

params 和 header 匹配
可以从请求参数或者 HTTP 头中提取值来进一步确定调用的方法，有以下三种形式：

如果存在参数，则通过；
如果不存在参数，则通过；
如果参数等于某一个具体值，则通过。

@PostMapping(value="/update.json",params="action=save")
@ResponseBody
public void saveUser() {
    System.out.println("call save");
}

header 和 params 一样：

@PostMapping(value="/update.json",headers="action=save")
@ResponseBody
public void saveUser() {
    System.out.println("call save");
}

方法参数

Spring 的 Controller 方法可以接受多种类型参数，比如我们看到的 path 变量，还有 MVC 的 Model，除此之外，方法还能接受以下参数。

@PathVariable, 可以将URL中的值映射到方法参数中。
Model，Spring 中通用的MVC模型，也可以使用 Map 和 ModelMap 作为渲染视图的模型。
ModelAndView, 包含了模型和视图路径的对象。
JavaBean，将HTTP参数映射到 JavaBean对象。
MultipartFile,用于处理文件上传。
@ModelAttribute 使用该注解的变量将作为 Model 的一个属性。
WebRequest 或者 NativeWebRequest，类似 Servlet Requset ，但做了一定封装。

PathVariable

注解 PathVariable 用于从请求 URL 中获取参数并映射到方法参数中

@RequestMapping(value="/get/{id}.json")
public @ResponseBody User getById(@PathVariable("id") Long id) {
    return userService.getUserById(id);
}

Model & ModelAndView
任何 MVC 框架都有一个类似 Map 结构的 Model,可以向 Model 添加视图需要的变量，Spring MVC 中的 Model 就是完成此功能的。Model 对象主要有如下方法：

Model addAttribute(String attributeName, Object attributeValue)，向模型添加一个变量，attributeName 指明了变量的名称，可以在随后的视图里引用，attributeValue 代表了变量。
Model addAttribute(Object attributeValue) , 向模型添加一个变量，变量的名字就是其类名首字母小写后转为 Java 变量。

ModelAndView 对象类似 Model,但额外提供了一个视图名称。

javaBean 接受 HTTP 参数
可以通过注解 @RequestParam来进一步限定 HTTP 参数到 Controller 方法的映射关系，RequestParam 支持如下属性：

value, 指明 HTTP 参数的名称
required, boolean 类型，声明此参数是否必须有，如果 HTTP 参数里没有，则会抛出 400 错误。
defaultValue，字符类型，如果 HTTP 参数没有提供，可以指定一个默认字符串。

可以将 HTTP 参数转为 JavaBean 对象， HTTP 参数的名字对应到 POJO 的属性名：

@GetMapping(path="/update.json")
@ResponseBody
public String updateUser(User user) {
return "success";
}

通常，HTTP 提交了多个参数，Spring 支持按照前缀自动映射到不同的对象上。比如用户交了订单信息，订单信息通常包含了多个订单明细。

需要创建一个 Form 对象来接收 HTTP 提交的数据：

public class OrderPostForm {
private Order order;
private List<OrderDetail> details;
}

如上所示，以“order”为前缀的HTTP参数映射到 OrderPostForm 类的 order 属性上，以 details 属性为前缀的 HTTP 参数映射到 OrderPostForm 的 details 属性上。

<form>
订单名称 <input name="order.name"/>
订单明细一
<input name="details[0].name" />
订单明细二
<input name="details[1].name" />
</form>

则下面的 Controller 的方法可以处理这个请求

@PostMapping(path="")
@ResponseBody
public String saveOrder(OrderPostForm form) {
return "success";
}

@RequestBody 接受 JSON
Controller 方法带有 @RequestBody 注解的参数，意味着请求的 HTTP 消息体的内容是一个 JSON，需要转化为注解指定的参数类型。Spring Boot 默认使用 Jackson 来处理反序列化工作。

如果客户端发起了一个 JSON 请求，则有如下定义来接受 JSON:

@PostMapping(path="/savejsonorder.json")
@ResponseBody
public String saveOrderByJson(@ResquestBody User user) {
return user.getName();
}

这段代码能够处理客户端发起的JSON请求

>curl -XPOST 'http://127.0.0.1:8080/savejsonorder.json' -H 'Content-Type: application/json' -d '{
"name": "Hello",
"id":1
}'

MultipartFile
通过 MultipartFile来处理文件上传:

@PostMapping("/form")
@ResponseBody
public String handleFormUpload(String name, MultipartFile file) throws IOException {
if(!file.isEmpty()) {
String fileName = file.getOriginalFilename();
InputStream ins = file.getInputStream();
return "success";
}
return "failure";
}

MultipartFile 提供了一下方法来获取上传文件的信息。

1. getOriginalFilename 获取上传文件的名字。
2. getBytes 获取上传文件内容，转为字节数组。
3. getInputStream 获取一个 InputStream
4. isEmpty 上传文件内容为空，或者就没有文件上传
5. getSize 文件上传的大小
6. transferTo（File dest）保存上传文件到目标文件系统。

如果是同时上传多个文件，则使用 MultipartFile 数组来接受多个文件上传：

@PostMapping("/form")
@ResponseBody
public String handleFormUpload(String name, MultipartFile[] files) throws IOException {

}

这要求自HTTP请求中包含多个名为 "files" 的文件：

<form action="filesUpload.html" method="post" entype="multipart/form-data">
1
<input  type ="file" name="files" />
2
<input  type ="file" name="files" />
3
<input  type ="file" name="files" />
4
<input  type ="file" name="files" />

</form>

可以通过配置文件对Spring Boot 上传的文件进行限定，默认如下:

spring.servlet.multipart.enabled=true
spring.servlet.multipart.file-size-threshold=0
spring.servlet.multipart.location=
spring.servlet.multipart.max-file-size=1MB
spring.servlet.multipart.max-request-size=10MB
spring.servlet.multipart.resolve-lazily=false

参数 enabled 默认为 true，即允许附件上传。
file-size-threshold 限定了当上传的文件超过一定长度时，就先先写到临时文件里。这有助于上传文件不占用过多内存，单位时 MB 或者 KB。默认是0，不限定阈值。
location 值指的是临时文件的存放目录，如果不限定，则是 Web 服务器提供的一个临时目录。
max-file-size 属性指定了单个文件的最大长度，默认是 1 MB
max-request-size 属性说明单次 HTTP 请求上传的最大长度，默认 10 M
@ModelAttribute
注解 ModelAttribute 通常作用在 Controller 的某个方法上，此方法会首先被调用，并将方法结果作为 Model的属性，然后再调用对应的 Controller 处理方法。

@ModelAttribute
public void findUserById(@PathVariable Long id, Model model) {
mode.addAttribute("user",userService,getUserById(id));
}

@GetMapping(path="/{id}/get.json")
@ResponseBody
public String getUser(Model model) {
System.out.println(model.containsAttribute("user"));
return "success";
}

对于 HTTP 请求，modelattribute/1/get.json ，会调用 findUserById 方法，取得 user, 并添加到模型里。使用 ModelAttribute 通常可以用来向一个 Controller 中需要的公共模型添加数据。

验证框架
Spring Boot 支持 JSR-303、Bean 验证框架，默认实现使用的是 Hibernate validator。在 Spring MVC 中，只需要使用 @Valid 注解在方法参数上，Spring Boot 即可对参数对象进行校验，校验结果放在 BindingResult 对象中。

JSR-303
jsr-303 是 Java 标准的验证框架，已有的实现有 Hibernate validator。JSR-303 定义了一些列注解来验证Bean 的属性，常用的有如下几种。

空检查
1、 @Null，验证对象是否为空
2、 @NotNull，验证对象不为空
3、 @NotBlank，验证字符串不为空或者不是空字符串
4、 @NotEmpty, 验证对象不为 null，或者集合不为空

长度检查
1、 @Siz(min= , max=), 验证对象长度，可支持字符串、集合；
2、 @Length, 字符串大小
数值检测
1、 @Min，验证数字是否大于指定值
2、 @Max, 验证数字是否小于等于指定的值
3、 @Digits, 验证数字是否符合指定格式，如 @Digits(integer=9,faraction=2)
4、 @Range, 验证数字是否在指定范围内，如 @Range(min=1,max=100)
其他
1、 @Email, 验证是否为邮件格式，为 null 则不做校验
2、 @Pattern， 验证String对象是否符合正则表达式的规则

public class WorkInfoForm {
@NotNull
Long id;
@Size (min=3,max=20)
String name;
@Email
String email;
}

通常不同的业务逻辑会有不同的验证逻辑，比如对于 WorkInfoForm来说，当更新的时候， id 必须不为null，但增加的时候， id必须是null。

JSR-303 定义了group概念，每个校验注解都必须支持。校验注解作用在字段上的时候，可以指定一个或者多个group，当Spring Boot校验对象的时候，也可以指定校验的上下文属于那个group。这样，只有group匹配的时候，校验注解才能生效。上面的WorkInfoForm定义id字段校验可以更改为如下内容：

public class WorkInfoForm {

// 定义一个类，更新时校验组
public interface Update{}
//定义一个类，添加时校验组
public interface Add{}

@NotNull(groups={Update.class})
@Null(groups={Add.class})
Long id;
@Size (min=3,max=20)
String name;
@Email
String email;
}

这段代码表示，当校验上下文为 Add.class 的时候，@Null 生效，id需为空才能校验通过；当校验上下文为 Update.class 的时候，@NotNull 生效，id不能为空。

MVC 中使用 @Validated
在Controller中，只需要给方法参数添加上@Validated即可触发一次校验。

@ResponseBody
@RequestMapping("/addworkinfo.html")
public void addWorkInfo(@Validated({WorkInfoForm.Add.class}) WorkInfoForm workInfo, BindingResult result) {
if(result.hasErrors()) {
List<ObjectError> list = result.getAllErrors();
FieldError error = (FieldError) list.get(0);
System.out.println(error.getObjectName()+"," + error.getField() + "," + error.getDefaultMessage());
}
}

此方法可以接受 HTTP 参数并映射到 WorkInfoForm对象，WorkInfoForm使用了@Validated注解，将触发Spring的校验，并将验证结果存放在BindingResult对象中。这里，Validated 注解使用了校验的上下文 WorkInfoForm.Add.class 因此，整个校验将按照 Add.class 来校验。

BindingResult 包含了验证结果，提供了如下方法。

hasErrors 判断验证是否通过。
getAllError 得到所有的错误信息，通常返回的是 FieldError 列表

如果 Controller 参数未提供 BindingReult 对象，则 SpringMVC 将抛出异常。

自定义校验
JSR-303 提供的大部分校验注解已经够用，也允许定制校验注解，比如在 WorkInfoForm 类中，我们新增加一个加班时间。

@WorkOverTime(max=2)
int workTime;

属性 workTime 使用了注解 @WorkOverTime，属性值超过 max 值的时候，将会验证失败。WorkOverTime 跟其他注解差不多，但提供了 @Constraint 来说明用什么类作为验证注解实现类。

@Constraint(validatedBy= {WorkOverTimeValidator.class})
@Documented
@Target({ ElementType.ANNOTATION_TYPE, ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface WorkOverTime {
String message() default "加班时间过长，不能超过{max} 小时"；
int max() default 5;
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}

@Constraint注解声明用什么类来实现验证，我们将创建一个 WorkOverTimeValidator 来进行验证。验证注解必须要提供如下信息。

message 用于创建错误信息
groups 验证规则分组，比如新增和修改的验证规则不一样，分为两个组，验证注解必须提供
payload 定义了验证的有效负荷

WorkOverTimeValidator 必须实现 ConstraintValidator 接口 initialize 方法及验证方法 isValid;

public class WorkOverTimeValidator implements ConstraintValidator<WorkOverTime, Integer> {
WorkOverTime work;
int max;
public void initialize(WorkOverTime work) {
thie.work = work;
max = work.max();
}

public boolean isValid(Integer value, ConstraintValidatorContext context) {
if(value == null) {
return true;
}
return value<max>;
}
}

WebMvcConfigurer
WebMvcConfigurer 是用来全局制定 Spring Boot 的 mvc 特性。开发者通过实现 WebMvcConfigurer 接口来配置应用的 MVC 全局特性。

@Configuration
public class MvcConfigurer implements WebMvcConfigurer {
//拦截器
public void addInterceptors (InterceptorRegistry registry) {

}

// 跨域访问配置
public void addCorsMappings(CorsRegistry registry) {

}

//格式化
public void addFormatters (FormatterRegistry registry) {

}

// URI 到视图的映射
public void addViewControllers(ViewControllerRegistry registry) {

}

}

拦截器
通过 addInterceptors方法可以设置多个拦截器，比如对特定的 URI 设定拦截器以检查用户是否登录，打印处理用户请求耗费的时间等。

public void addInterceptors(InterceptorRegistry registry) {
// 增加一个拦截器，检查会话， URL 以 admin 开头的都适用此拦截器
registry.addInterceptor(new SessionHandlerInterceptor()).addPathPatterns("/admin/**");
}

class SessionHandlerInterceptor implements HandlerInterceptor {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
User user = (User) requset.getSession().getAttribute("user");
if(user == null) {
//没有登录，重定向到 login.html
response.sendRedirect("/login.html");
return false;
}
return true;
}

publica void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
// controller 方法处理完毕后，待用此方法
}

@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,Exception ex) throws Exception {
// 页面渲染完毕后调用此方法，通常用来接触某些资源。
}
}

上边这段代码，我们在 MvcConfigurer 总实现了 addInterceptors 方法，并对访问地址 /admin/** 添加了一个拦截器。

拦截器，有以下三个方法需要覆盖实现

preHandle，在调用 Controller 方法前会调用此方法
postHandle，在调用Controller 方法结束后、页面渲染之前调用此方法，比如可以在这里将渲染的视图名称更改为其他视图名
afterCompletion ，页面渲染完毕后调用此方法。
跨域访问
处于安全的考虑，浏览器会禁止 AJAX 访问不同域的地址。
Spring Boot 提供了对 CORS 的支持，可以实现 addCorsMappings 接口来添加特定的配置：

@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**");
}

允许所有跨域访问，或者更为精细的控制

public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/api/**")
.allowedOrigins("http://doain2.com")
.allowedMethods("POST","GET");
}

跨域原理简单理解就是发起跨域请求的时候，浏览器会对请求域返回的响应信息检查HTTP头，如果Access-Control-Allow-Origin 包含了自身域，则表示允许访问。否则报错，这就是 allowedOrigins 的作用。

注册Controller
应用有时候没有必要为一个 URL 制定一个Controller方法，可以直接将 URI 请求转到对应的模版渲染上。可以直接通过 ViewControllerRegistry 注册一个：

public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/index.html").setViewName("/index.html");
registry.addRedirectViewController("/**/*.do","/index.html");
}

视图技术
Redirect 和 Forward

Contoller 中重定向可以返回以 "redirect:" 为前缀的 URL

@RequestMapping("/order/saveorder.html")
public String saveOrder(Order order) {
Long orderId = service.addOrder(order);
return "redirect:/order/detail.html?orderId=" + orderId;
}

或者直接使用 RedirectView 类

RedirectView view = new RedirectView("/order/detail.html?orderid=" + orderId);

Spring MVC 也支持 foward前缀，用来在 Controller 执行完毕之后，再执行另外一个 Controller 的方法。

通用错误处理
在 Spring Boot 中， Controller 中抛出的异常默认交给了 /error 来处理，应用程序可以将 /error 映射到一个特定的 Controller 中处理来代替 Spring Boot 的默认实现，应用可以继承 AbstractErrorController 来统一处理系统的各种异常。

@Controller
public class ErrorController extends AbstractErrorController {
Log log = LogFactory.getLog(ErrorController.class);

@Autowired
ObjectMapper objectMapper;

public ErrorController() {
super(new DefaultErrorAttributes());
}

@RequestMapping("/error")
public ModelAndView getErrorPath(HttpServletRequest request, HttpServletResponse response) {
//处理异常

}
}

AbstractErrorController 提供了多个方法可以从 request 中获取错误信息，包含以下信息：

timestamp, 错误发生的时间
status 对应于 HTTP status 如 404
error， 错误消息，如 Bad Requset、Not Found
message， 详细错误信息
exception， 如果应用抛出异常
path，请求的 URI
errors， @Validated 校验错误的时候，校验结果信息放在这里。

考虑到异常信息直接显示给应用系统客户并不合适，尤其是 RuntimeException。同时，还要区分页面渲染和JSON 请求这两种不同的情况，前者应该返回一个错误页面，后者应该返回一个 JSON 结果。因此，为应用提供的统一错误处理代码：

@RequestMapping(ERROR_PATH)
public ModelAndView getErrorPath (HttpServletRequest request, HttpServletResponse response) {
Map<String,Object> model = Collections.unmodifiableMap(getErrorAttributes(request, false));
// 获取异常，有可能为空

Throwable cause = getCause(request);
int status = (Interger) model.get("status");

// 错误信息
String message = (String) model.get("message");

// 提示
String errorMessage = getErrorMessage(cause);
//后台打印日志信息
log.info(status+"," + message , cause);
response.setStatus(status);
if(!isJsonRequest(requst)) {
//error.html
ModelAndView view = new ModelAndView("/error.html");
view.addAllObjects(model);
view.addObject("errorMessage",errorMessage);
view.addObject("status",status)
view.addObject("cause",cause);
return view;
}else {
Map error = new HashMap();
error.put("success",false);
error.put("errorMessage",errorMessage);
error.put("message",message);
writeJson(response,error);
return null;

}

}

getErrorAttributes 方法是 AbstractErrorController 提供的用于获取错误信息的方法，返回一个 Map，包含的数据如下。

getCause 方法用于获取应用系统的异常，定义如下：

protected Throwable getCause(HttpServletRequest request) {
Throwable  error = (Throwable) request.getAttribute("javax.servlet.error.exception");
if(error != null) {
// MVC 有可能会封装异常成 ServletException 需要调用 getCause 获取真正的异常 
while( error instanceof ServletException && error.getCause() != null) {
error = ((ServletException ) error).getCause();
}
}
return error;
 }

getErrorMessage 方法返回一个友好的异常信息，而不是 Spring Boot 提供的 message 包含的信息：

protected String getErrorMessage(Throwable ex) {
return "服务器错误，请联系管理员";
}

通常这个友好信息很简单，类似上边。也可以根据应用系统自定义的异常进一步输出详细信息

protected String getErrorMessage(Throwable ex) {
if(ex instanceof YourApplicationException) {
return ((YourApplicationException) ex).getMessage();
}

return "服务器错误，请联系管理员";
}

isJsonRequest 方法用来区分客户端发起的是页面渲染请求还是 JSON 请求：

protected boolean isJsonRequest(HttpServletRequest request) {
String requestUri = (String) request.getAttribute("javax.servlet.error.requeset_uri");
if(requestUri != null && requestUri.endsWith(".json")) {
return true;
}else {
//也可以通过获取 HTTP 头，根据 Accept 字段是否包含 JSON 来进一步判断
// request.getHeader("Accept").contains("application.json");
return false;
}

}

@Service 和 @Transactional
到目前为止，Spring Boot 的 Controller 介绍完了，在 Spring Boot 中， Controller 调用业务逻辑处理交给了被 @Service 注解的类，这也是一个普通的 JavaBean，Controller 中可以自动注入这种 Bean，并调用其方法完成主要的业务逻辑。正如 Controller 注解经常和 @RequestMapping 搭配使用一样，@Service 和 @Transactional 配合使用。

声明一个 Service 类

publica interface UserService {
public User getUserById(Long id);
public void updateUser(Long id, Integer type);
}

然后实现此业务接口，不要忘记增加@Service 来引起 Spring Boot 的注意，同时搭配上 @Transactional, Spring Boot 会对这样的 Bean 进行事物增强。

@Service
@Transactional // 也可以作用于放上上
public class UserServiceImpl implements UserService {
public User getUserById(Long id){
return user
}
public void updateUser(Long id, Integer type) {

}
}

当 Controller 调用 Service 方法的时候，会开启一个事物上下文，随后的调用都将处于这个事物上下文中。如果调用这个 Service 方法抛出 RuntimeException , 事物则会自动回滚。