Android中的Handler, MessageQ

Android中的Handler, MessageQueu, Message, Looper

. ThreadLocal

在研究Handler的機制之前我們想明確一個知識點，ThreadLocal. ThreadLocal字面意思是線程本地變量，他保存的是一個變量的副本，并且只對當前線程可見。我們做個例子：

結果如下：

可以看到第一個和第二個打印的日志是一樣的，也可能你覺得這個不能說明啥，一會我們看看源碼也許你就明白了。

OK那我們看看他的源碼：

在set值得時候，拿到當前的線程，并拿到一個map，就這個值存放到map中。這個TheaLocalMap是什么呢？

就一句話，還是從當前的線程里面去拿的，繼續看下threadLocals：

那么這個ThreadLocalMap 是一個什么東西呢，繼續往下看：

可以看到這個ThreadLocalMap中有一個存儲結構用來存儲鍵值對，這個value其實就是我們set進去的變量，繼續看下set方法：

這個方法也不復雜，就是看看當前的數組table中是不是已經存過了，如果已經存過了那么久覆蓋掉之前的Value，沒有的話就創建一個Entry放到數組中。所以同一個ThreadLocal在一個線程中只能存放一個值，不然會被覆蓋掉。

當然拿到當前的值時候也不難，明白了這個get方法也就很簡單了。

總結下 ThreadLocal的作用當前線程是綁定一個變量，只能當前線程訪問，別的線程訪問不了也修改不了他的值。在多線程的環境中，當多個線程需要對某一個變量進行頻繁的操作，但又不需要同步的時候，可以用ThreadLocal，因為他存儲在當前的線程中的，效率恨到，其實就是空間換時間。

2. Handler Looper, MessageQueue, Message

Handler Looper MessageQueue Message他們之間關系其實不難理解，我們new一個Handler并實現里面的handMessage方法，參數是一個message，然后用Handler發送message，發送的message到了MessageQuueue這個隊列里面，Looper維持一個死循環，一直從MessageQueue里面取Message，之后調用相應的Handler里面的handMessage方法，這樣就完成了一個循環。說起來你不難，但是要理解里面的機制，還需要看源碼：

首先一個應用在啟動的時候，系統會調用ActivityThread.java中的main方法，在main方法里面會去初始化Looper。

可以看到調用了Looper.prepareMainLooper();這個方法其實就是初始化了一個Looper，這個Looper是給主線程調用，接著下面調用了Looper.loop() 這個方法是開啟一個死循環，一會再看，先看下Looper.prepareMainLooper()

在上面的源碼prepare中new了一個Looper并把它放到了ThreadLocal中，上面我們已經說了，ThreadLocal存儲的變量和線程綁定在一起，那么當前的線程其實是主線程。 sMainLooper 這變量其實就是我們常用的Looper.getMainLooper().

那么MessageQueue是什么時候創建的，其實就是new Looper的時候創建的。

我們平常用Handler的時候都是new Handler 如下：

那么Handler發送的的message是怎么到隊列里面，并且之后是怎么回調的，繼續看源碼：

所有的send方法都會掉到上面這個方法里面來，然后插進隊列：

這個時候要注意上面的那個msg.target=this;這一句，可以看到message將會綁定當前發送的Handler，這也就為以后出來message埋下了伏筆，其實說白了就是拿到這個target指向的Handler來調用handmessage方法處理message。

那你有沒有注意到那個mQueue 是從哪里冒出來的？

其實就是在new Handler的時候初始化的，可以看到上面Looper.myLooper();這句話，如果你有心的話其實上面已經有這個方法的實現了：

其實就拿的當前線程里面的Looper，因為這個是在主線程里面的new的所以其實就是拿到ActivityThread里面初始化的Looper。

既然已經拿到messageQueue并且將message放到隊列里面的那么接下來是怎么出隊列進行處理的呢，那就是我們的一開始就說的Looper.loop()了：

看上面的代碼，我刪除了一些東西，最主要的是就拿到messageQueue，并有一個死循環，不斷的從messageQueue里面拿去message，接著調用msg.target.dispatchMessage(msg); 在直接發送message的時候，我們看過這個target其實就是綁定的當前的Handler，在dispatchMessage這個方法中就會去調用handMessage這個方法，到這里，整個流程就走完了。

關于死循環的問題，可以看看https://www.zhihu.com/question/34652589/answer/90344494 可以看看這個鏈接，牽扯到了Linux系統管道的問題了。

通過上面的分析我們也就知道了在主線程中可以newHandler 而在子線程中new Hander 必須自己手動調用Looper的原因了，因為主線程已經幫我實現好了

參考文章： https://www.cnblogs.com/alex-mh/p/6761233.html； https://www.cnblogs.com/alex-mh/p/6761233.html

截器Interceptor，是SpringMVC中的核心內容，利用spring的AOP（Aspect Oriented Programming，面向切面編程）特性，可以很方便的對用戶的業務代碼進行橫向抽取，根據具體業務需求對應用功能進行增強。
在SpringBoot中使用Interceptor，同時采用全注解開發，涉及到以下接口和類：

HandlerInterceptor：處理器攔截器，handler就是處理器，在springboot web開發中，由控制器來處理web請求，因此handler具體指控制器
使用全注解開發，通過@Configuration注解，讓一個java對象主任到IOC容器，并作為配置對象，這里的JavaConfig類相當于一個xml配置文件；
在以前的xml配置中
（1）通過引入一些標簽進行配置，在JavaConfig中，通過繼承一個類或者實現一個接口來實現配置，這里所繼承的類、所實現的接口就相當于引入的標簽；
（3）通過設置所引入標簽的屬性和值，可以實現個性化配置，在JavaConfig中通過覆蓋類或者接口的方法來實現個性化配置。

下面通過一個案例來實現自定義攔截器
攔截/user/開頭的請求，不攔截/usr/login請求

1. 定義攔截器

1234567891011121314package cn.eis220.web;

import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("執行了logininterceptor的preHandle方法");
        return true;
    }
}

2. 使用JavaConfig注冊攔截器

java配置類相當于xml配置文件
xml中通過引入interceptor標簽來進行配置，java配置類通過實現WebMvcController進行配置；
xml中通過修改標簽的屬性和值來個性化配置，java配置類通過實現WebMvcController的方法進行個性化配置

123456789101112131415161718package cn.eis220.config;

import cn.eis220.web.LoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class MyAppCofnig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        LoginInterceptor loginInterceptor=new LoginInterceptor();

        String[] path={"/user/**"};
        String[] excludePath={"/user/login"};
	registry.addInterceptor(loginInterceptor).addPathPatterns(path).excludePathPatterns(excludePath);
    }
}

3. 定義控制器，測試攔截器

123456789101112131415161718192021package cn.eis220.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class BootController {
    @RequestMapping("/user/account")
    @ResponseBody
    public String userAccount(){
        return "/user/account";
    }

    @RequestMapping("/user/login")
    @ResponseBody
    public String userLogin(){
        return "/user/login";
    }
}

4. 總結

步驟：

如何定義自己的攔截器：
實現HandlerInterceptor接口的方法，來自定義攔截器
如何注冊攔截器：
JavaConfig配置類實現WebMvcConfigurer接口的addInterceptor方法來注冊攔截器

本文作者：流云的博客
本文鏈接：https://www.cnblogs.com/arminker/p/15806725.html

時開發過程中，無可避免我們需要處理各類異常，所以這里我們在公共模塊中自定義統一異常，Spring Boot 提供 @RestControllerAdvice 注解統一異常處理，我們在GitEgg_Platform中新建gitegg-platform-boot子工程，此工程主要用于Spring Boot相關功能的自定義及擴展。

1、修改gitegg-platform-boot的pom.xml，添加spring-boot-starter-web和swagger依賴，設置optional為true，讓這個包在項目之間依賴不傳遞。

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
       <optional>true</optional>
</dependency>
<dependency>
       <groupId>com.gitegg.platform</groupId>
       <artifactId>gitegg-platform-swagger</artifactId>
       <optional>true</optional>
</dependency>

2、自定義通用響應消息類，Result和PageResult，一個是普通響應消息，一個是分頁響應消息。

Result類：

package com.gitegg.platform.boot.common.base;
import com.gitegg.platform.boot.common.enums.ResultCodeEnum;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
/**
 * @ClassName: Result
 * @Description: 自定義通用響應類
 * @author GitEgg
 * @date 2020年09月19日 下午9:24:50
 */
@ApiModel(description="通用響應類")
@Getter
@ToString
public class Result<T> {
    @ApiModelProperty(value="是否成功", required=true)
    private boolean success;
    
    @ApiModelProperty(value="響應代碼", required=true)
    private int code;
    @ApiModelProperty(value="提示信息", required=true)
    private String msg;
    @ApiModelProperty(value="響應數據")
    private T data;
    
    /**
     * 
     * @param code
     * @param data
     * @param msg
     */
    private Result(int code, T data, String msg) {
        this.success=ResultCodeEnum.SUCCESS.code==code;
        this.code=code;
        this.msg=msg;
        this.data=data;
    }
    /**
     * 
     * @param resultCodeEnum
     */
    private Result(ResultCodeEnum resultCodeEnum ) {
        this(resultCodeEnum.code, null, resultCodeEnum.msg);
    }
    /**
     * 
     * @param resultCodeEnum
     * @param msg
     */
    private Result(ResultCodeEnum resultCodeEnum , String msg) {
        this(resultCodeEnum, null, msg);
    }
    /**
     * 
     * @param resultCodeEnum
     * @param data
     */
    private Result(ResultCodeEnum resultCodeEnum , T data) {
        this(resultCodeEnum, data, resultCodeEnum.msg);
    }
    /**
     * 
     * @param resultCodeEnum
     * @param data
     * @param msg
     */
    private Result(ResultCodeEnum resultCodeEnum , T data, String msg) {
        this(resultCodeEnum.code, data, msg);
    }
    /**
     * 
     *
     * @param data 數據
     * @param <T>  T 響應數據
     * @
     */
    public static <T> Result<T> data(T data) {
        return data(data, ResultCodeEnum.SUCCESS.msg);
    }
    /**
     * 
     *
     * @param data 數據
     * @param msg  消息
     * @param <T>  T 響應數據
     * @
     */
    public static <T> Result<T> data(T data, String msg) {
        return data(ResultCodeEnum.SUCCESS.code, data, msg);
    }
    /**
     * 
     *
     * @param code 狀態碼
     * @param data 數據
     * @param msg  消息
     * @param <T>  T 響應數據
     * @
     */
    public static <T> Result<T> data(int code, T data, String msg) {
        return new Result<>(code, data, msg);
    }
    /**
     * 返回Result
     *
     * @param 
     * @param <T>  T 響應數據
     * @返回Result
     */
    public static <T> Result<T> success() {
        return new Result<>(ResultCodeEnum.SUCCESS);
    }
    
    /**
     * 返回Result
     *
     * @param msg 消息
     * @param <T> T 響應數據
     * @返回Result
     */
    public static <T> Result<T> success(String msg) {
        return new Result<>(ResultCodeEnum.SUCCESS, msg);
    }
    /**
     * 返回Result
     *
     * @param 
     * @param <T>  T 響應數據
     * @返回Result
     */
    public static <T> Result<T> success(ResultCodeEnum resultCodeEnum ) {
        return new Result<>(resultCodeEnum);
    }
    /**
     * 返回Result
     *
     * @param 
     * @param msg   提示信息
     * @param <T>  T 響應數據
     * @返回Result
     */
    public static <T> Result<T> success(ResultCodeEnum resultCodeEnum , String msg) {
        return new Result<>(resultCodeEnum, msg);
    }
    
    /**
     * 返回Result
     *
     * @param <T> T 響應數據
     * @返回Result
     */
    public static <T> Result<T> error() {
        return new Result<>(ResultCodeEnum.ERROR, ResultCodeEnum.ERROR.msg);
    }
    /**
     * 返回Result
     *
     * @param msg 消息
     * @param <T> T 響應數據
     * @返回Result
     */
    public static <T> Result<T> error(String msg) {
        return new Result<>(ResultCodeEnum.ERROR, msg);
    }
    /**
     * 返回Result
     *
     * @param code 狀態碼
     * @param msg  消息
     * @param <T>  T 響應數據
     * @返回Result
     */
    public static <T> Result<T> error(int code, String msg) {
        return new Result<>(code, null, msg);
    }
    /**
     * 返回Result
     *
     * @param 
     * @param <T>  T 響應數據
     * @返回Result
     */
    public static <T> Result<T> error(ResultCodeEnum resultCodeEnum ) {
        return new Result<>(resultCodeEnum);
    }
    /**
     * 返回Result
     *
     * @param 
     * @param msg   提示信息
     * @param <T>  T 響應數據
     * @返回Result
     */
    public static <T> Result<T> error(ResultCodeEnum resultCodeEnum , String msg) {
        return new Result<>(resultCodeEnum, msg);
    }
    
    /**
     * 
     * @param <T>
     * @param flag
     * @return
     */
    public static <T> Result<T> result(boolean flag) {
        return flag ? Result.success("操作成功") : Result.error("操作失敗");
    }
}

PageResult類：

package com.gitegg.platform.boot.common.base;
import java.util.List;
import com.gitegg.platform.boot.common.enums.ResultCodeEnum;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
 * @ClassName: PageResult
 * @Description: 通用分頁返回
 * @author GitEgg
 * @date
 * @param <T>
 */
@Data
@ApiModel("通用分頁響應類")
public class PageResult<T> {
    @ApiModelProperty(value="是否成功", required=true)
    private boolean success;
    @ApiModelProperty(value="響應代碼", required=true)
    private int code;
    @ApiModelProperty(value="提示信息", required=true)
    private String msg;
    @ApiModelProperty(value="總數量", required=true)
    private long count;
    @ApiModelProperty(value="分頁數據")
    private List<T> data;
    public PageResult(long total, List<T> rows) {
        this.count=total;
        this.data=rows;
        this.code=ResultCodeEnum.SUCCESS.code;
        this.msg=ResultCodeEnum.SUCCESS.msg;
    }
}

3、自定義通用響應消息枚舉類ResultCodeEnum。

package com.gitegg.platform.boot.common.enums;
/**
 * @ClassName: ResultCodeEnum
 * @Description: 自定義返回碼枚舉
 * @author GitEgg
 * @date 2020年09月19日 下午11:49:45
 */
public enum ResultCodeEnum {
    /**
     * 成功
     */
    SUCCESS(200, "操作成功"),
    /**
     * 系統錯誤
     */
    ERROR(500, "系統錯誤"),
    /**
     * 操作失敗
     */
    FAILED(101, "操作失敗"),
    /**
     * 未登錄/登錄超時
     */
    UNAUTHORIZED(102, "登錄超時"),
    /**
     * 參數錯誤
     */
    PARAM_ERROR(103, "參數錯誤"),
    /**
     * 參數錯誤-已存在
     */
    INVALID_PARAM_EXIST(104, "請求參數已存在"),
    /**
     * 參數錯誤
     */
    INVALID_PARAM_EMPTY(105, "請求參數為空"),
    /**
     * 參數錯誤
     */
    PARAM_TYPE_MISMATCH(106, "參數類型不匹配"),
    /**
     * 參數錯誤
     */
    PARAM_VALID_ERROR(107, "參數校驗失敗"),
    /**
     * 參數錯誤
     */
    ILLEGAL_REQUEST(108, "非法請求"),
    /**
     * 驗證碼錯誤
     */
    INVALID_VCODE(204, "驗證碼錯誤"),
    /**
     * 用戶名或密碼錯誤
     */
    INVALID_USERNAME_PASSWORD(205, "賬號或密碼錯誤"),
    /**
     *
     */
    INVALID_RE_PASSWORD(206, "兩次輸入密碼不一致"),
    /**
     * 用戶名或密碼錯誤
     */
    INVALID_OLD_PASSWORD(207, "舊密碼錯誤"),
    /**
     * 用戶名重復
     */
    USERNAME_ALREADY_IN(208, "用戶名已存在"),
    /**
     * 用戶不存在
     */
    INVALID_USERNAME(209, "用戶名不存在"),
    /**
     * 角色不存在
     */
    INVALID_ROLE(210, "角色不存在"),
    /**
     * 角色不存在
     */
    ROLE_USED(211, "角色使用中，不可刪除"),
    /**
     * 沒有權限
     */
    NO_PERMISSION(403, "當前用戶無該接口權限");
    public int code;
    public String msg;
    ResultCodeEnum(int code, String msg) {
        this.code=code;
        this.msg=msg;
    }
    public int getCode() {
        return code;
    }
    public void setCode(int code) {
        this.code=code;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg=msg;
    }
}

4、自定義異常類BusinessException和SystemException

package com.gitegg.platform.boot.common.exception;
import com.gitegg.platform.boot.common.enums.ResultCodeEnum;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
/**
 * @ClassName: BusinessException
 * @Description: 業務處理異常
 * @author GitEgg
 * @date
 */
@Getter
@Setter
public class BusinessException extends RuntimeException {
    private int code;
    private String msg;
    public BusinessException() {
        this.code=ResultCodeEnum.FAILED.code;
        this.msg=ResultCodeEnum.FAILED.msg;
    }
    public BusinessException(String message) {
        this.code=ResultCodeEnum.FAILED.code;
        this.msg=message;
    }
    public BusinessException(int code, String msg) {
        this.code=code;
        this.msg=msg;
    }
    public BusinessException(Throwable cause) {
        super(cause);
    }
    public BusinessException(String message, Throwable cause) {
        super(message, cause);
    }
}

package com.gitegg.platform.boot.common.exception;
import com.gitegg.platform.boot.common.enums.ResultCodeEnum;
import lombok.Getter;
/**
 * @ClassName: SystemException
 * @Description: 系統處理異常
 * @author GitEgg
 * @date
 */
@Getter
public class SystemException extends RuntimeException {
    private int code;
    private String msg;
    public SystemException() {
        this.code=ResultCodeEnum.ERROR.code;
        this.msg=ResultCodeEnum.ERROR.msg;
    }
    public SystemException(String message) {
        this.code=ResultCodeEnum.ERROR.code;
        this.msg=message;
    }
    public SystemException(int code, String msg) {
        this.code=code;
        this.msg=msg;
    }
    public SystemException(Throwable cause) {
        super(cause);
    }
    public SystemException(String message, Throwable cause) {
        super(message, cause);
    }
}

5、自定義統一異常處理類GitEggControllerAdvice.java

package com.gitegg.platform.boot.common.advice;
import com.gitegg.platform.boot.common.base.Result;
import com.gitegg.platform.boot.common.enums.ResultCodeEnum;
import com.gitegg.platform.boot.common.exception.BusinessException;
import com.gitegg.platform.boot.common.exception.SystemException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.ui.Model;
import org.springframework.web.HttpMediaTypeNotAcceptableException;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingPathVariableException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import org.springframework.web.servlet.NoHandlerFoundException;
import javax.annotation.PostConstruct;
import javax.servlet.http.HttpServletRequest;
import javax.validation.ConstraintViolationException;
@Slf4j
@RestControllerAdvice
public class GitEggControllerAdvice {
    /**
     * 服務名
     */
    @Value("${spring.application.name}")
    private String serverName;
    /**
     * 微服務系統標識
     */
    private String errorSystem;
    @PostConstruct
    public void init() {
        this.errorSystem=new StringBuffer()
                .append(this.serverName)
                .append(": ").toString();
    }
    /**
     * 應用到所有@RequestMapping注解方法，在其執行之前初始化數據綁定器
     */
    @InitBinder
    public void initBinder(WebDataBinder binder) {
    }
    /**
     * 把值綁定到Model中，使全局@RequestMapping可以獲取到該值
     */
    @ModelAttribute
    public void addAttributes(Model model) {
    }
    /**
     * 全局異常捕捉處理
     */
    @ExceptionHandler(value={Exception.class})
    public Result handlerException(Exception exception, HttpServletRequest request) {
        log.error("請求路徑uri={},系統內部出現異常:{}", request.getRequestURI(), exception);
        Result result=Result.error(ResultCodeEnum.ERROR, errorSystem + exception.toString());
        return result;
    }
    /**
     * 非法請求異常
     */
    @ExceptionHandler(value={
            HttpMediaTypeNotAcceptableException.class,
            HttpMediaTypeNotSupportedException.class,
            HttpRequestMethodNotSupportedException.class,
            MissingServletRequestParameterException.class,
            NoHandlerFoundException.class,
            MissingPathVariableException.class,
            HttpMessageNotReadableException.class
    })
    public Result handlerSpringAOPException(Exception exception) {
        Result result=Result.error(ResultCodeEnum.ILLEGAL_REQUEST, errorSystem + exception.getMessage());
        return result;
    }
    /**
     * 非法請求異常-參數類型不匹配
     */
    @ExceptionHandler(value=MethodArgumentTypeMismatchException.class)
    public Result handlerSpringAOPException(MethodArgumentTypeMismatchException exception) {
        Result result=Result.error(ResultCodeEnum.PARAM_TYPE_MISMATCH, errorSystem + exception.getMessage());
        return result;
    }
    /**
     * 非法請求-參數校驗
     */
    @ExceptionHandler(value={MethodArgumentNotValidException.class})
    public Result handlerMethodArgumentNotValidException(MethodArgumentNotValidException methodArgumentNotValidException) {
        //獲取異常字段及對應的異常信息
        StringBuffer stringBuffer=new StringBuffer();
        methodArgumentNotValidException.getBindingResult().getFieldErrors().stream()
                .map(t -> t.getField()+"=>"+t.getDefaultMessage()+" ")
                .forEach(e -> stringBuffer.append(e));
        String errorMessage=stringBuffer.toString();
        Result result=Result.error(ResultCodeEnum.PARAM_VALID_ERROR, errorSystem + errorMessage);
        return result;
    }
    /**
     * 非法請求異常-參數校驗
     */
    @ExceptionHandler(value={ConstraintViolationException.class})
    public Result handlerConstraintViolationException(ConstraintViolationException constraintViolationException) {
        String errorMessage=constraintViolationException.getLocalizedMessage();
        Result result=Result.error(ResultCodeEnum.PARAM_VALID_ERROR, errorSystem + errorMessage);
        return result;
    }
    /**
     * 自定義業務異常-BusinessException
     */
    @ExceptionHandler(value={BusinessException.class})
    public Result handlerCustomException(BusinessException exception) {
        String errorMessage=exception.getMsg();
        Result result=Result.error(exception.getCode(), errorSystem + errorMessage);
        return result;
    }
    /**
     * 自定義系統異常-SystemException
     */
    @ExceptionHandler(value={SystemException.class})
    public Result handlerCustomException(SystemException exception) {
        String errorMessage=exception.getMsg();
        Result result=Result.error(exception.getCode(), errorSystem + errorMessage);
        return result;
    }
}

6、重新將GitEgg-Platform進行install，在GitEgg-Cloud中的gitegg-service引入gitegg-platform-boot

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>GitEgg-Cloud</artifactId>
        <groupId>com.gitegg.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>gitegg-service</artifactId>
    <packaging>pom</packaging>
    <modules>
        <module>gitegg-service-base</module>
        <module>gitegg-service-bigdata</module>
        <module>gitegg-service-system</module>
    </modules>
    <dependencies>
        <!-- gitegg Spring Boot自定義及擴展 -->
        <dependency>
            <groupId>com.gitegg.platform</groupId>
            <artifactId>gitegg-platform-boot</artifactId>
        </dependency>
        <!-- gitegg數據庫驅動及連接池 -->
        <dependency>
            <groupId>com.gitegg.platform</groupId>
            <artifactId>gitegg-platform-db</artifactId>
        </dependency>
        <!-- gitegg mybatis-plus -->
        <dependency>
            <groupId>com.gitegg.platform</groupId>
            <artifactId>gitegg-platform-mybatis</artifactId>
        </dependency>
        <!-- gitegg swagger2-knife4j -->
        <dependency>
            <groupId>com.gitegg.platform</groupId>
            <artifactId>gitegg-platform-swagger</artifactId>
        </dependency>
        <!-- spring boot web核心包 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- spring boot 健康監控 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>
</project>

7、修改SystemController.java、ISystemService.java和SystemServiceImpl.java增加異常處理的測試代碼

SystemController.java:

package com.gitegg.service.system.controller;
import com.gitegg.platform.boot.common.base.Result;
import com.gitegg.platform.boot.common.exception.BusinessException;
import com.gitegg.service.system.service.ISystemService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping(value="system")
@AllArgsConstructor
@Api(tags="gitegg-system")
public class SystemController {
    private final ISystemService systemService;
    @GetMapping(value="list")
    @ApiOperation(value="system list接口")
    public Object list() {
        return systemService.list();
    }
    @GetMapping(value="page")
    @ApiOperation(value="system page接口")
    public Object page() {
        return systemService.page();
    }
    @GetMapping(value="exception")
    @ApiOperation(value="自定義異常及返回測試接口")
    public Result<String> exception() {
        return Result.data(systemService.exception());
    }
}

ISystemService.java:

package com.gitegg.service.system.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.gitegg.service.system.entity.SystemTable;
import java.util.List;
public interface ISystemService {
    List<SystemTable> list();
    Page<SystemTable> page();
    String exception();
}

SystemServiceImpl.java:

package com.gitegg.service.system.service.impl;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.gitegg.platform.boot.common.exception.BusinessException;
import com.gitegg.service.system.entity.SystemTable;
import com.gitegg.service.system.mapper.SystemTableMapper;
import com.gitegg.service.system.service.ISystemService;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.List;
/**
 *
 */
@Service
@AllArgsConstructor
public class SystemServiceImpl implements ISystemService {
    private final SystemTableMapper systemTableMapper;
    @Override
    public List<SystemTable> list() {
        return systemTableMapper.list();
    }
    @Override
    public Page<SystemTable> page() {
        Page<SystemTable> page=new Page<>(1, 10);
        List<SystemTable> records=systemTableMapper.page(page);
        page.setRecords(records);
        return page;
    }
    @Override
    public String exception() {
        throw new BusinessException("自定義異常");
//        return "成功獲得數據";
    }
}

8、運行GitEggSystemApplication，打開瀏覽器訪問：http://127.0.0.1:8001/doc.html，然后點擊左側的異常處理接口，使用Swagger2進行測試，即可看到結果

源碼在https://gitee.com/wmz1930/GitEgg 的chapter-07分支。

在線咨詢

上一篇：Windows XP、ClearType 和微軟雅黑
下一篇：ASP（動態伺服器網頁）簡介

您的項目需求

*請認真填寫需求信息，我們會在24小時內與您取得聯系。