前言：最近公司需要对系统进行重构，基于以前微服务系统架构上的不足，我在此总结了一些问题以及优化思路、方案等，适用于Springboot单体项目，希望能对眼前的你提供一些帮助。

问题与思路：

1. Controller层的【try catch】处理

问题描述：在系统中充斥着大量的try catch的代码，当接口出现问题时，由于你的粗心少写一个方法的try catch，给前端返回了一串Exception的异常错误信息。

@GetMapping("/get/user")
 public Re<User> auth(){
     try {
         return servie.getUser();
     } catch (Exception e) {
         e.printStackTrace();
     }
     return Re.failed();
 }

解决思路 ：全局异常处理

解决方案：核心为 @RestControllerAdvice、@ExceptionHandler 注解。

@RestControllerAdvice
public class UnityExceptionAdvice {
    @ExceptionHandler(value =Exception.class)
    public final Re<?> exceptionHandler(Exception e){
        log.error("系统异常错误:",e);
        return Re.failed();
    }
}

2. Service业务逻辑的中断处理

问题描述：在开发过程中，难免需要业务逻辑判断，直接返回Result结果集确实是一种方案，不过在service层之间调用时还需要处理Result是否成功，代码量剧增。在基于全局异常处理的架构下，抛出异常也是一种常用方案，不过却是在代码中写满了new RuntimeException() 且存在不能返回特定code码的Result结果集的问题。

示例1：
public Re<User> getUser(String name){
    User user = userMapper.selectUser(name);
    if (user == null) {
        return Re.failed(ReCode.USER_NOT_FOUND);
    }
    return Re.success(user);
}

示例2：
public User getUser(String name){
    User user = userMapper.selectUser(name);
    if (user == null) {
        throw new RuntimeException("用户不存在");
    }
    return user;
}

解决思路 ：断言处理

解决方案：核心为Spring提供的工具类 org.springframework.util.Assert ，进行二次封装。此处需要避坑，默认的Assert工具类中的expression逻辑判断都是反着来的，且抛出的异常为new IllegalStateException()，以下代码的Asserts工具类中改为正向的处理，为自定义异常，具体可查看Assert源码。

public class Asserts extends Assert {

    /**
     * 抛出指定类型状态码
     * @param reCode 状态码
     * @throws AnywayException -
     */
    public static void state(ReCode reCode) throws AnywayException{
        throw new AnywayException(reCode);
    }

    /**
     * 验证 - 抛出指定类型状态码
     * @param expression 描述业务正确的逻辑判断
     * @param reCode 自定义返回码与消息
     * @throws AnywayException -
     */
    public static void state(boolean expression, ReCode reCode) throws AnywayException{
        if (expression) {
            throw new AnywayException(reCode);
        }
    }

    /**
     * 抛出指定类型Code 与 错误消息
     * @param expression 描述业务正确的逻辑判断
     * @param reCode 自定义返回码与消息
     * @param errorMsgTemplate 错误消息模板
     * @param params 参数 替换模板中 {} 符号
     * @throws AnywayException -
     */
    public static void state(boolean expression, ReCode reCode, String errorMsgTemplate, Object... params) throws AnywayException{
        if (expression) {
            throw new AnywayException(reCode, StrUtil.format(errorMsgTemplate, params));
        }
    }
}

自定义异常类：

@Data
@EqualsAndHashCode(callSuper = true)
public class AnywayException extends RuntimeException {

    /** 结果集状态码 */
    private final ReCode reCode;

    /** 异常 */
    public AnywayException(ReCode reCode) {
        super(reCode.getMsg());
        this.reCode = reCode;
    }

    /** 异常 */
    public AnywayException(ReCode reCode, String msg) {
        super(msg);
        this.reCode = reCode;
    }
}

示例：

public User getUser(String name){
     User user = userMapper.selectUser(name);
     Asserts.state(user == null, ReCode.USER_NOT_FOUND);
     return user;
 }

3. Controller层数据响应处理

问题描述：在数据响应的时候，我们都会进行一层包装，一成不变的返回Result结果集数据，此响应可能会在Service层就会包装，也可能在Controller层进行包装处理。对于一些新手玩家规范不到位，如果在Re结果集上不加泛型的话，会增加代码阅读的复杂度。

// 示例1:
@GetMapping("/get/user")
public Re<User> auth(){        
    return servie.getUser();
}

// 示例2：
@GetMapping("/get/user")
public Re<User> auth(){        
    return Re.success(servie.getUser());
}

解决思路 ：全局统一响应处理

解决方案：与全局异常处理一样，其核心为 @RestControllerAdvice 注解与 ResponseBodyAdvice 接口 。

@RestControllerAdvice
public class UnityResponseAdvice implements ResponseBodyAdvice<Object> {

    /**
     * 统一响应处理注解
     */
    public static final Class<? extends Annotation> UNITY_RESPONSE = RestController.class;
    
    /**
     * Whether this component supports the given controller method return type
     * and the selected {@code HttpMessageConverter} type.
     *
     * @param returnType    the return type
     * @param converterType the selected converter type
     * @return {@code true} if {@link #beforeBodyWrite} should be invoked;
     * {@code false} otherwise
     */
    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        // 当前类或方法是否有统一响应注解
        return AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), UNITY_RESPONSE) || returnType.hasMethodAnnotation(UNITY_RESPONSE);
    }

    /**
     * Invoked after an {@code HttpMessageConverter} is selected and just before
     * its write method is invoked.
     *
     * @param body                  the body to be written
     * @param returnType            the return type of the controller method
     * @param selectedContentType   the content type selected through content negotiation
     * @param selectedConverterType the converter type selected to write to the response
     * @param request               the current request
     * @param response              the current response
     * @return the body that was passed in or a modified (possibly new) instance
     */
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
        // 防止重复包裹 Re
        if (body instanceof Re) {
            return body;
        }

        return Re.success(body);
    }
}

示例：

@GetMapping("/get/user")
public User auth(){        
    return servie.getUser();
}

4. 微服务Feign接口冗余重复代码与类

问题描述：服务之间的调用都是通过Feign实现的，在使用Feign的过程中，我们会在调用方定义一套Feign接口，与提供方的Controller接口一模一样，就好比service与serviceImpl的关系，且返回的DTO或者VO在两方服务都分别创建，在修改Collection接口的时候需要同步将调用方的Feign接口进行修改，如果调用方是n，那需要修改n个服务。

// 服务调用方
@FeignClient("base-user")
public interface BaseUserFeign {
    @GetMapping("t1")
    Re<String> test1(@RequestParam("t") String t);

    @PostMapping("t2")
    Re<DemoVO> test2(@RequestBody DemoDTO demoDTO);
}

// 服务提供方
@RestController
public class DemoController {

    @GetMapping("t1")
    public Re<String> test1(@RequestParam("t") String t) {
        return Re.success("success");
    }

    @PostMapping("t2")
    public Re<DemoVO> test2(@RequestBody DemoDTO demoDTO) {
        System.out.println(demoDTO);
        return Re.success(new DemoVO("success"));
    }
}

解决思路 ：服务调用方与提供方共用Fiegn模块

解决方案：服务在划分模块的时候将Feign接口单独创建子模块，将Feign接口从服务调用方的代码转变为服务提供方的代码，除了包含Feign接口之后，还包含对应DTO与VO，服务调用方继承了此模块，即可开箱即用所有的Feign接口，而服务提供方在Controller中实现对应的Feign接口。如果需要对外服务提供接口的，都写在Feign接口中，不需要对外提供接口服务的，按照正常实现即可。

// 服务调用方（无需手写Feign接口，直接引入服务提供方的Feign模块）
<dependency>
    <groupId>cn.code72</groupId>
    <artifactId>base-user-feign</artifactId>
    <version>1.0.0</version>
</dependency>

// 需要将引入包的Fiegn进行导入，此处提供feign包路径
@EnableFeignClients("cn.code72.base")
@SpringBootApplication
public class AuthApplication {
	public static void main(String[] args) {
        SpringApplication.run(AuthApplication.class,args);
    }
}

// 服务提供方
base-user (父模块)
	base-user-feign (子模块 - feign接口)
	base-user-ms (子模块 - 业务)

@FeignClient("base-user")
public interface BaseUserFeign {
    @GetMapping("t1")
    String test1(@RequestParam("t") String t);

    @PostMapping("t2")
    DemoVO test2(@RequestBody DemoDTO demoDTO);
}

	
@RestController
public class DemoController implements BaseUserFeign {

	// 对外提供服务的接口
    @Override
    public String test1(@RequestParam String t) {
        return "success";
    }

    @Override
    public DemoVO test2(@RequestBody DemoDTO demoDTO) {
        System.out.println(demoDTO);
        return new DemoVO("success");
    }

	// 不对外提供服务的接口
    @GetMapping("t3")
    public Integer test3(String t) {
        System.out.println(t);
        return 333333333;
    }
}

5. 基于全局统一响应处理与共用Feign模块后的服务调用

问题描述：对于刚才的架构优化提供了全局统一响应处理（第3条）与Feign模块共用（第4条）的思路，单独任意一处优化都减少了一些重复造轮子的过程。不过当一起使用的时候，不知道聪明的你有没有发现问题呢？是的，当一起使用时，Feign调用的返回数据类型居然跟Controller响应的类型匹配不上？你敢信？其实是因为统一响应处理对返回类型进行了一次包装，看到的接口返回类型是个String，Feign的类型也是String，实际却是个Result结果集类型，String只是结果集中的data数据而已。

解决思路 ：改造Feign接口调用的实现

解决方案：我能想到的有两种解决方案，第一种是将所有Feign接口的返回类型都处理为Re结果集类型，不对外提供的接口还是正常的数据类型作为返回类型即可，这样保证了Feign接口调用时返回的类型匹配的上。第二种就是我将要提供的解决方案， 改造Feign接口的调用实现，在结果集取出对应的数据映射到返回类型上。

@Configuration
public class FeignConfiguration {

    @Autowired
    ObjectFactory<HttpMessageConverters> messageConverters;

    /**
     * Feign 响应解码
     *
     * @see FeignClientsConfiguration#feignDecoder()
     * @return Decoder
     */
    @Bean
    public Decoder feignDecoder() {
        return new OptionalDecoder(new ResponseEntityDecoder(new FeignResponseDecoder(this.messageConverters)));
    }
}

@AllArgsConstructor
public class FeignResponseDecoder implements Decoder {

    /**
     * Http消息转换器（从 ObjectFactory Bean中获取）
     */
    ObjectFactory<HttpMessageConverters> messageConverters;

    /**
     * Decodes an http response into an object corresponding to its
     * {@link Method#getGenericReturnType() generic return type}. If you need to
     * wrap exceptions, please do so via {@link DecodeException}.
     *
     * @param response the response to decode
     * @param type     {@link Method#getGenericReturnType() generic return type} of the
     *                 method corresponding to this {@code response}.
     * @return instance of {@code type}
     * @throws IOException     will be propagated safely to the caller.
     * @throws DecodeException when decoding failed due to a checked exception besides IOException.
     * @throws FeignException  when decoding succeeds, but conveys the operation failed.
     */
    @SneakyThrows
    @Override
    public Object decode(Response response, Type type) throws DecodeException, FeignException {
        // 校验类型是否能转换为正常类
        Asserts.state(!(type instanceof Class || type instanceof ParameterizedType || type instanceof WildcardType), Re.failed());

        // 响应类型
        Class<?> responseClass;
        // 校验类型是否带泛型处理
        if (type instanceof ParameterizedTypeImpl) {
            // 泛型类型
            responseClass = ((ParameterizedTypeImpl) type).getRawType();
        }else {
            // 默认类型
            responseClass = Class.forName(type.getTypeName());
        }

        // 设置消息转换器的响应类型
        if (!responseClass.isAssignableFrom(String.class)) {
            type = Re.class;
        }

        // Http消息转换器提取器
        @SuppressWarnings({"unchecked", "rawtypes"})
        HttpMessageConverterExtractor<?> extractor = new HttpMessageConverterExtractor(type, this.messageConverters.getObject().getConverters());

        // 获取 Feign 中响应的数据
        Object extractData = extractor.extractData(new FeignResponseAdapter(response));
        log.info("接口：{}，请求体：{}，结果集：{}", response.request().url(), response.request().body() == null ? "" : new String(response.request().body()), extractData);

        // 响应数据为空校验
        Asserts.state(extractData == null, Re.failed(), response.request().url());

        // 结果集
        Re<?> result = JSONObject.parseObject(extractData.toString(), Re.class);
        // 数据转换校验
        Asserts.state(JSONObject.parseObject(extractData.toString(), Re.class) == null, Re.failed(), response.request().url());

        // 校验返回结果集是否成功 不成功则直接返回 省略代码中逻辑校验
        Asserts.state(!FeignDefine.NON_INTERCEPT_CODE.contains(result.getCode()), result, response.request().url());

        // 解析出 result data 数据，判断如果是 基本类型 or 引用类型 则直接返回
        if (ClassUtils.isPrimitiveOrWrapper(responseClass) || responseClass.isAssignableFrom(String.class)) {
            return typeAdapter(result.getData(), responseClass);
        }

        // 处理 data 数据为空的情况
        if (ObjectUtils.isEmpty(result.getData())) {
            return result.getData();
        }

        // 解析出 result data 数据，转换成对象
        return JSONObject.parseObject(result.getData().toString(), responseClass);
    }

    /**
     * 类型适配器
     *
     * @param o 适配数据
     * @param tClass 返回类型
     * @return 适配类型的数据
     */
    public Object typeAdapter(Object o, Class<?> tClass) {
        // 类型适配
        if (Long.class.equals(tClass)) {
            return Long.valueOf(o.toString());

        } else if (Short.class.equals(tClass)) {
            return Short.valueOf(o.toString());

        } else if (Byte.class.equals(tClass)) {
            return Byte.valueOf(o.toString());

        } else if (Float.class.equals(tClass)) {
            return Float.valueOf(o.toString());

        } else if (Double.class.equals(tClass)) {
            return Double.valueOf(o.toString());
        }
        return o;
    }
}

public class FeignResponseAdapter implements ClientHttpResponse {

    private final Response response;

    public FeignResponseAdapter(Response response) {
        this.response = response;
    }

    @Override
    public HttpStatus getStatusCode() throws IOException {
        return HttpStatus.valueOf(this.response.status());
    }

    @Override
    public int getRawStatusCode() throws IOException {
        return this.response.status();
    }

    @Override
    public String getStatusText() throws IOException {
        return this.response.reason();
    }

    @Override
    public void close() {
        try {
            this.response.body().close();
        }
        catch (IOException ex) {
            // Ignore exception on close...
        }
    }

    @Override
    public InputStream getBody() throws IOException {
        return this.response.body().asInputStream();
    }

    @Override
    public HttpHeaders getHeaders() {
        return getHttpHeaders(this.response.headers());
    }

    HttpHeaders getHttpHeaders(Map<String, Collection<String>> headers) {
        HttpHeaders httpHeaders = new HttpHeaders();
        for (Map.Entry<String, Collection<String>> entry : headers.entrySet()) {
            httpHeaders.put(entry.getKey(), new ArrayList<>(entry.getValue()));
        }
        return httpHeaders;
    }
}

public class Asserts extends Assert {

    /**
     * 抛出指定类型状态码
     * @param reCode 状态码
     * @throws AnywayException -
     */
    public static void state(ReCode reCode) throws AnywayException{
        throw new AnywayException(reCode);
    }

    /**
     * 验证 - 抛出指定类型状态码
     * @param expression 描述业务正确的逻辑判断
     * @param reCode 自定义返回码与消息
     * @throws AnywayException -
     */
    public static void state(boolean expression, ReCode reCode) throws AnywayException{
        if (expression) {
            throw new AnywayException(reCode);
        }
    }

    /**
     * 验证 - 抛出指定类型状态码
     * @param expression 描述业务正确的逻辑判断
     * @param re 结果集
     * @throws FeignDecoderException -
     */
    public static void state(boolean expression, Re<?> re) throws FeignDecoderException {
        if (expression) {
            throw new FeignDecoderException(re);
        }
    }

    /**
     * 验证 - 抛出指定类型状态码
     * @param expression 描述业务正确的逻辑判断
     * @param re 结果集
     * @param url Feign 异常的接口地址
     * @throws FeignDecoderException -
     */
    public static void state(boolean expression, Re<?> re, String url) throws FeignDecoderException {
        if (expression) {
            throw new FeignDecoderException(re, url);
        }
    }

    /**
     * 抛出指定类型Code 与 错误消息
     * @param expression 描述业务正确的逻辑判断
     * @param reCode 自定义返回码与消息
     * @param errorMsgTemplate 错误消息模板
     * @param params 参数 替换模板中 {} 符号
     * @throws AnywayException -
     */
    public static void state(boolean expression, ReCode reCode, String errorMsgTemplate, Object... params) throws AnywayException{
        if (expression) {
            throw new AnywayException(reCode, StrUtil.format(errorMsgTemplate, params));
        }
    }
}

@Getter
@EqualsAndHashCode(callSuper = true)
public class FeignDecoderException extends EncodeException {

    /**
     * 结果集
     */
    private final Re<?> re;

    /**
     * Feign 异常的接口地址
     */
    private String url;

    /**
     * 抛结果集异常
     *
     * @param re 结果集
     */
    public FeignDecoderException(Re<?> re) {
        super(re.getMessage());
        this.re = re;
    }

    /**
     * 抛结果集异常
     *
     * @param re 结果集
     * @param url Feign 异常的接口地址
     */
    public FeignDecoderException(Re<?> re, String url) {
        super(re.getMessage());
        this.re = re;
        this.url = url;
    }
}

public class FeignDefine {
    /**
     * Feign 返回无需拦截的 code 集
     */
    public static List<Integer> NON_INTERCEPT_CODE = new ArrayList<Integer>(){{
        add(DefaultReCode.SUCCESS.getCode());
    }};
}

总结：此处代码的核心处理思路就是找到Feign接口调用的切入点，获取返回的数据结果集，校验结果集返回的是否成功，不成功则直接抛出异常（对于Feign接口调用的时候，你是否为每个Feign接口的结果集判断是否是成功而苦恼过？此处即可解决这个问题，省略业务上调用Feign接口之后的判断），成功则从结果集中获取到data数据，将data数据的类型需要转为返回类型，否则会抛出类型转换的异常。将数据转为返回类型之后return。

以上就是我在重构系统中的一些优化思路，欢迎各位小伙伴们一起来探讨！