定制@ResponseBody

自定义注解类（annotation）：

IgnoreResult该类用于忽略不使用@ResponseBody

package com.baizhi.mall.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//元注解：描述注解的注解
@Retention(RetentionPolicy.RUNTIME)//设置当前注解保留到什么项目的什么阶段
//当前的注解类可以作用到什么位置上
@Target({ElementType.TYPE,ElementType.METHOD})
//@interface：声明为注解类
public @interface IgnoreResult {
}

?ResultBody使用该类声明使用定制的@ResponseBody

package com.baizhi.mall.api.annotation;

import org.springframework.web.bind.annotation.ResponseBody;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//元注解：描述注解的注解
@Retention(RetentionPolicy.RUNTIME) //设置当前注解保留到什么项目的什么阶段
@Target({ElementType.TYPE, ElementType.METHOD}) //当前的注解可以作用在类的什么位置上
//如果类或者方法上面有此注解，那么就代表。当前类中所有的方法都需要我们自动类型包装
public @interface ResultBody {
}

配置自定义的ResponseBodyAdvice

package com.baizhi.mall.advice;

import com.baizhi.mall.annotation.IgnoreResult;
import com.baizhi.mall.annotation.ResultBody;
import com.baizhi.mall.api.vo.Result;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.core.MethodParameter;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

//ResponseBodyAdvice springboot中自定义@ResponseBody需要的通知接口
//扫描Controller中定义的自定义注解 或 @restControllerAdvice
@ControllerAdvice                               
public class MyResponseBodyAdvice implements ResponseBodyAdvice {

    /**
     * 本方法代表我们的返回值是否需要进行自动类型保证为beforeBodyWrite中定义的转换值
     * @param returnType  方法的参数:返回值信息
     * @param converterType    转换的类型
     *                         比如：Controller中方法的返回值是String，那么converterType就会是StringHttpMessageConverter
     *                              Controller中方法的返回值不是String，那么converterType就会是MappingJackson2HttpMessageConverter
     * @return  如果返回值是true则需要包装成Result类型；如果返回值是fasle,则不需要包装成
     */
    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        System.out.println("=============supports========returnType======》"+returnType);
        //返回值本身就是Result，不需要转换
        if (returnType.getParameterType().isAssignableFrom(Result.class)){
            return  false;
        }
        //如果方法上或者类上有@IgnoreResult，不需要转换
        if (returnType.hasMethodAnnotation(IgnoreResult.class)|| AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(),IgnoreResult.class)){
            return false;
        }
        //如果方法上或者类上有@ResultBody，需要转换
        if (returnType.hasMethodAnnotation(ResultBody.class)|| AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(),ResultBody.class)){
            return true;
        }
        return false;
    }

    /**
     * 进行实际类型保证的方法
     * body:就是我们方法的返回值
     */
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        System.out.println("=============beforeBodyWrite=========body=====》"+body);
        //创建JSON转换的类对象
        ObjectMapper mapper= Jackson2ObjectMapperBuilder.json().build();
        //如果body是字符串，我们需要转换成Json格式
        if(body instanceof String){
            //以Result规范式返回值返回
            Result<Object> result=Result.ok(body);
            try {
              return   mapper.writeValueAsString(result);
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }
        return Result.ok(body); //不是String类型， 直接转换。 body就变成了Resuslt类中的data
    }
}

?Result该类为响应返回时alibaba规范式的返回值

package com.baizhi.mall.api.vo;

import com.baizhi.mall.api.ResponseStatus;
import com.baizhi.mall.api.constant.ResponseStatusEnum;
import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @param <T>  :就是参数化类型！
 *           简而言之，就是用户调用的时候，传什么，T就是什么！
 *  如果不写泛型T，那么data的数据类型必须是Object.
 *           那么每次获取data的时候，就必须做类型转换，比较繁琐。
 *           实现的效果是一样的。
 *  不同的请求，可能得到相同的状态码和状态信息。
 *           这样就会导致，代码冗余。
 *           这时候我们就需要创建一个接口，就是统一规范。
 *           只要是成功了，那么就返回我这个接口对应的值。
 *
 */
@Data
@AllArgsConstructor //省略了带参构造
public class Result<T> {
    private  int code; //状态码
    private  String message; //状态码信息
    private  T data; //返回的具体数据

    //第二步：创建构建者的调用方式
    public  static <T>Builder<T> builder(){
        return  new  Builder<>();
        //这个builder对象是空的，要给那个属性赋值，直接 点 方法名即可。
        //Result.builder().code(200).message("message");
    }

    //第2种：通过status接收ResponseStatus后续只需要添加data再build就可以：status(responseStatus).build(data
    public static <T> Builder<T> status(ResponseStatus status) {
        return Result.<T>builder().status(status);
    }

    //第3种：提供开发最常见的2种状态的简化方式ok和error
    public static <T> Result<T> ok() {
        return Result.ok((T) null);
    }

    public static <T> Result<T> ok(T data) {
        return Result.<T>status(ResponseStatusEnum.SUCCESS).data(data).build();
    }

    public static <T> Builder<T> ok(String message) {
        return Result.<T>builder().code(ResponseStatusEnum.SUCCESS.getCode()).message(message);
    }

    public static <T> Result<T> error() {
        return Result.<T>status(ResponseStatusEnum.FAILED).build();
    }

    public static <T> Result<T> error(String message){
        return Result.<T>builder().code(ResponseStatusEnum.FAILED.getCode()).message(message).build();
    }


    //第一步：创建Result类的构建者,针对Result类中的属性，进行组合
    public static  class Builder<T>{
        private  int code; //状态码
        private  String message; //状态码信息
        private  T data; //返回的具体数据
        private  Builder(){}
        public  Builder<T> status(ResponseStatus status){
            this.code=status.getCode();
            this.message=status.getMessage();
            return  this;
        }
        public  Builder<T> code(int code){
            this.code=code;
            return  this;
        }
        public  Builder<T> message(String message){
            this.message=message;
            return  this;
        }
        public  Builder<T> data(T data){
            this.data=data;
            return  this;
        }
        public  Result<T> build(){
            return  new Result(code,message,data);
        }
        public  Result<T> build(T data){
            this.data(data);
            return  build();
        }
    }

}

使用自定义注解在Controller的类和方法上?

@GetMapping("/haha")
@ResultBody //自定义注解  转换成Result对象
public String haha(){
    System.out.println("==================haha=====================");
    return "haha";
}
@GetMapping("/haha1")
@IgnoreResult //不转换成Result对象
public String haha1(){
    System.out.println("==================haha1=====================");
    return "haha1";
}
@GetMapping("/list")
@ResultBody //自定义注解  转换成Result对象
public List<Student> list(){
    System.out.println("==================list=====================");
    List<Student> students=new ArrayList<>();
    students.add(new Student(1,18,"小黑1"));
    students.add(new Student(2,14,"小黑2"));
    students.add(new Student(3,16,"小黑3"));
    return students;
}