Spring中的@ControllerAdvice和ResponseBodyAdvice详解

/**
* @param returnType 可以得到方法和参数的相关信息（注解呀，类型呀）
* @param converterType HttpMessageConverter的实现类
* @return 是否对某个接口（被@ResponseBody修饰）的返回值进行修改。如果为true就会调用
*         beforeBodyWrite方法
*/
boolean supports(MethodParameter returnType, 
                Class<? extends HttpMessageConverter<?>> converterType);
/**
* @param body 被@ResponseBody修饰方法的返回值（区别于returnType）
* @param returnType 可以得到方法和参数的相关信息（注解呀，类型呀）
* @param selectedContentType 选中的媒体类型，即以什么格式写出数据（json、xml、text...）
* @param selectedConverterType HttpMessageConverter的实现类的具体类型
* @param request 请求对象
* @param response 响应对象
* @return
*/
T beforeBodyWrite(@Nullable T body, MethodParameter returnType, MediaType selectedContentType,
			Class<? extends HttpMessageConverter<?>> selectedConverterType,
			ServerHttpRequest request, ServerHttpResponse response);

Allows customizing the response after the execution of an 
@ResponseBody or a ResponseEntity controller method but
 before the body is written with an HttpMessageConverter.

public class Result {
    private int code;
    private String data;
    // getter and seter
}

@ControllerAdvice
public class Advice implements ResponseBodyAdvice {
    //因为这里也加了@ResponseBody注解，所以它的返回值也会被ResponseBodyAdvice 处理一遍
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public Result he(Exception e) {
        Result res = new Result();
        res.setCode(500);
        res.setData(e.getMessage());
        return res;
    }

    @Override
    public boolean supports(MethodParameter returnType, Class converterType) {
        //返回任意类型都要封装
        return true;
    }

    ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType,
                                  MediaType selectedContentType, Class selectedConverterType,
                                  ServerHttpRequest request, ServerHttpResponse response) {

        Result res = new Result();
        res.setCode(200);
        //如果返回值是String，直接放到Result里
        if (body instanceof String) {
            res.setData((String) body);
            return res;
        }
        //如果返回值是标准返回格式，就不需要再次封装了
        //如果不加这个判断，异常的结果会被封装两次
        else if (body instanceof Result) {
            return body;
        }
        String dataStr = null;
        try {
            dataStr = objectMapper.writeValueAsString(body);
            res.setData(dataStr);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return res;
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@Controller
public class Demo1Application {

    public static void main(String[] args) {
        SpringApplication.run(Demo1Application.class, args);
    }

    @GetMapping("ex")
    @ResponseBody
    public String ex() throws Exception {
        throw new Exception("异常信息");
    }

    @GetMapping("stu")
    @ResponseBody
    public Stu s() {
        final Stu stu = new Stu();
        stu.setName("zcx");
        stu.setAge(22);
        return stu;
    }
}


class Stu {
    private String name;
    private int age;
    //getter and setter
}