基於SpringBoot搭建應用開發框架(一) —— 基礎架構

Spring的簡史

第一階段：XML配置，在Spring1.x時代，使用Spring開發滿眼都是xml配置的Bean，隨着項目的擴大，我們需要把xml配置文件分放到不同的配置文件里，那時候需要頻繁的在開發的類和配置文件之間切換。

第二階段：注解配置，在Spring2.x時代，Spring提供聲明Bean的注解，大大減少了配置量。應用的基本配置用xml，業務配置用注解。

第三階段：Java配置，從Spring3.x到現在，Spring提供了Java配置，使用Java配置可以讓你更理解你所配置的Bean。

Spring Boot：使用“習慣優於配置”的理念讓你的項目快速運行起來。使用Spring Boot很容易創建一個獨立運行、准生產級別的基於Spring框架的項目，使用Spring Boot你可以不用或者只需要很少的Spring配置。

下面就來使用Spring Boot一步步搭建一個前后端分離的應用開發框架，並且以后不斷的去完善這個框架，往里面添加功能。后面以實戰為主，不會介紹太多概念，取而代之的是詳細的操作。

 

零、開發技術簡介

開發平台：windows

開發工具：Intellij IDEA 2017.1

JDK：Java 8

Maven：maven-3.3.9

服務器：tomcat 8.0

數據庫：MySQL 5.7

數據源：Druid1.1.6

緩存：Redis 3.2

日志框架：SLF4J+Logback

Spring Boot：1.5.9.RELEASE

ORM框架：MyBatis+通用Mapper

Spring Boot官方文檔：Spring Boot Reference Guide

 

一、創建項目

這一節創建項目的基礎結構，按照spring boot的思想，將各個不同的功能按照starter的形式拆分開來，做到靈活組合，並簡單介紹下Spring Boot相關的東西。

1、創建工程

① 通過File > New > Project，新建工程，選擇Spring Initializr，然后Next。

② 盡量為自己的框架想個好點的名字，可以去申請個自己的域名。我這里項目名稱為Sunny，項目路徑為com.lyyzoo.sunny。

③ 這里先什么都不選，后面再去集成。注意我的Spring Boot版本為1.5.9。Next

④ 定義好工程的目錄，用一個專用目錄吧，不要在一個目錄下和其它東西雜在一起。之后點擊Finish。

上面說的這么詳細，只有一個目的，從一個開始就做好規范。

⑤ 生成的項目結構如下，可以自己去看下pom.xml里的內容。

2、創建Starter

先創建一個core核心、cache緩存、security授權認證，其它的后面再集成進去。

跟上面一樣的方式，在Sunny下創建sunny-starter-core、sunny-starter-cache、sunny-starter-security子模塊。

這樣分模塊后，我們以后需要哪個模塊就引入哪個模塊即可，如果哪個模塊不滿足需求，還可以重寫該模塊。

最終的項目結構如下：

3、啟動項目

首先在core模塊下來啟動並了解SpringBoot項目。

① 在com.lyyzoo.core根目錄下，有一個SunnyStarterCoreApplication，這是SpringBoot的入口類，通常是*Application的命名。

入口類里有一個main方法，其實就是一個標准的Java應用的入口方法。在main方法中使用SpringApplication.run啟動Spring Boot項目。

然后看看@SpringBootApplication注解，@SpringBootApplication是Spring Boot的核心注解，是一個組合注解。

@EnableAutoConfiguration讓Spring Boot根據類路徑中的jar包依賴為當前項目進行自動配置。

Spring Boot會自動掃描@SpringBootApplication所在類的同級包以及下級包里的Bean。

② 先啟動項目，這里可以看到有一個Spring Boot的啟動程序，點擊右邊的按鈕啟動項目。看到控制台Spring的標志，就算是啟動成功了。

③ 替換默認的banner

可以到http://patorjk.com/software/taag/這個網站生成一個自己項目的banner。創建banner.txt並放到resources根目錄下。

4、Spring Boot 配置

① 配置文件

Spring Boot使用一個全局的配置文件application.properties或application.yaml，放置在src/main/resources目錄下。我們可以在這個全局配置文件中對一些默認的配置值進行修改。

具體有哪些配置可到官網查找，有非常多的配置，不過大部分使用默認即可。Common application properties

然后，需要為不同的環境配置不同的配置文件，全局使用application-{profile}.properties指定不同環境配置文件。

我這里增加了開發環境(dev)和生產環境(prod)的配置文件，並通過在application.properties中設置spring.profiles.active=dev來指定當前環境。

② starter pom

Spring Boot為我們提供了簡化開發絕大多數場景的starter pom，只要使用了應用場景所需的starter pom，無需繁雜的配置，就可以得到Spring Boot為我們提供的自動配置的Bean。

后面我們將會通過加入這些starter來一步步集成我們想要的功能。具體有哪些starter，可以到官網查看：Starters

③ 自動配置

Spring Boot關於自動配置的源碼在spring-boot-autoconfigure中如下：

我們可以在application.properties中加入debug=true，查看當前項目中已啟用和未啟用的自動配置。

我們在application.properties中的配置其實就是覆蓋spring-boot-autoconfigure里的默認配置，比如web相關配置在web包下。

常見的如HttpEncodingProperties配置http編碼，里面自動配置的編碼為UTF-8。

MultipartProperties，上傳文件的屬性，設置了上傳最大文件1M。

ServerProperties，配置內嵌Servlet容器，配置端口、contextPath等等。

之前說@SpringBootApplication是Spring Boot的核心注解，但他的核心功能是由@EnableAutoConfiguration注解提供的。

@EnableAutoConfiguration注解通過@Import導入配置功能，在AutoConfigurationImportSelector中，通過SpringFactoriesLoader.loadFactoryNames掃描META-INF/spring.factories文件。

在spring.factories中，配置了需要自動配置的類，我們也可以通過這種方式添加自己的自動配置。

在spring-boot-autoconfigure下就有一個spring.factories，如下：

說了這么多，只為說明一點，Spring Boot為我們做了很多自動化的配置，搭建快速方便。

但是，正因為它為我們做了很多事情，就有很多坑，有時候，出了問題，我們可能很難找出問題所在，這時候，我們可能就要考慮下是否是自動配置導致的，有可能配置沖突了，或者沒有使用上自定義的配置等等。

5、項目結構划分

core是項目的核心模塊，結構初步規划如下：

　base是項目的基礎核心，定義一些基礎類，如BaseController、BaseService等；

    cache是緩存相關；

    config是配置中心，模塊所有的配置放到config里統一管理；

    constants里定義系統的常量。

    exception里封裝一些基礎的異常類；

　system是系統模塊；

    util里則是一些通用工具類；

 

二、基礎結構功能

1、web支持

只需在pom.xml中加入spring-boot-starter-web的依賴即可。

之后，查看POM的依賴樹(插件：Maven Helper)，可以看到引入了starter、tomcat、web支持等。可以看出，Sping Boot內嵌了servlet容器，默認tomcat。

自動配置在WebMvcAutoConfiguration和WebMvcProperties里，可自行查看源碼，一般我們不需添加其他配置就可以啟動這個web項目了。

2、基礎功能

在core中添加一些基礎的功能支持。

① 首先引入一些常用的依賴庫，主要是一些常用工具類，方便以后的開發。

<!-- ******************************* 常用依賴庫 ********************************** -->
<!-- 針對開發IO流功能的工具類庫 -->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>${commons.io.version}</version>
</dependency>
<!-- 文件上傳 -->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>${commons.fileupload.version}</version>
    <exclusions>
        <exclusion>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!-- 常用的集合操作，豐富的工具類 -->
<dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>${commons.collections.version}</version>
</dependency>
<!-- 操作javabean的工具包 -->
<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>${commons.beanutils.version}</version>
    <exclusions>
        <exclusion>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!-- 包含一些通用的編碼解碼算法. 如：MD5、SHA1、Base64等 -->
<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>${commons.codec.version}</version>
</dependency>
<!-- 包含豐富的工具類如 StringUtils -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>${commons.lang3.version}</version>
</dependency>
<!--
    Guava工程包含了若干被Google的Java項目廣泛依賴的核心庫. 集合[collections] 、緩存[caching] 、原生類型支持[primitives support] 、
    並發庫[concurrency libraries] 、通用注解[common annotations] 、字符串處理[string processing] 、I/O 等等。
-->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>${guava.version}</version>
</dependency>

版本號如下：

② 在base添加一個Result類，作為前端的返回對象，Controller的直接返回對象都是Result。

package com.lyyzoo.core.base;

import com.fasterxml.jackson.annotation.JsonInclude;

import java.io.Serializable;

/**
 * 前端返回對象
 *
 * @version 1.0
 * @author bojiangzhou 2017-12-28
 */
public class Result implements Serializable {
    private static final long serialVersionUID = 1430633339880116031L;

    /**
     * 成功與否標志
     */
    private boolean success = true;
    /**
     * 返回狀態碼，為空則默認200.前端需要攔截一些常見的狀態碼如403、404、500等
     */
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private Integer status;
    /**
     * 編碼，可用於前端處理多語言，不需要則不用返回編碼
     */
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String code;
    /**
     * 相關消息
     */
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String msg;
    /**
     * 相關數據
     */
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private Object data;


    public Result() {}

    public Result(boolean success) {
        this.success = success;
    }

    public Result(boolean success, Integer status) {
        this.success = success;
        this.status = status;
    }

    public Result(boolean success, String code, String msg){
        this(success);
        this.code = code;
        this.msg = msg;
    }

    public Result(boolean success, Integer status, String code, String msg) {
        this.success = success;
        this.status = status;
        this.code = code;
        this.msg = msg;
    }

    public Result(boolean success, String code, String msg, Object data){
        this(success);
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

    public boolean isSuccess() {
        return success;
    }

    public void setSuccess(boolean success) {
        this.success = success;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }
}

之后在util添加生成Result的工具類Results，用於快速方便的創建Result對象。

package com.lyyzoo.core.util;

import com.lyyzoo.core.base.Result;

/**
 * Result生成工具類
 *
 * @version 1.0
 * @author bojiangzhou 2017-12-28
 */
public class Results {

    protected Results() {}

    public static Result newResult() {
        return new Result();

    }

    public static Result newResult(boolean success) {
        return new Result(success);
    }

    //
    // 業務調用成功
    // ----------------------------------------------------------------------------------------------------
    public static Result success() {
        return new Result();
    }

    public static Result success(String msg) {
        return new Result(true, null, msg);
    }

    public static Result success(String code, String msg) {
        return new Result(true, code, msg);
    }

    public static Result successWithStatus(Integer status) {
        return new Result(true, status);
    }

    public static Result successWithStatus(Integer status, String msg) {
        return new Result(true, status, null, msg);
    }

    public static Result successWithData(Object data) {
        return new Result(true, null, null, data);
    }

    public static Result successWithData(Object data, String msg) {
        return new Result(true, null, msg, data);
    }

    public static Result successWithData(Object data, String code, String msg) {
        return new Result(true, code, msg, data);
    }

    //
    // 業務調用失敗
    // ----------------------------------------------------------------------------------------------------
    public static Result failure() {
        return new Result(false);
    }

    public static Result failure(String msg) {
        return new Result(false, null, msg);
    }

    public static Result failure(String code, String msg) {
        return new Result(false, code, msg);
    }

    public static Result failureWithStatus(Integer status) {
        return new Result(false, status);
    }

    public static Result failureWithStatus(Integer status, String msg) {
        return new Result(false, status, null, msg);
    }

    public static Result failureWithData(Object data) {
        return new Result(false, null, null, data);
    }

    public static Result failureWithData(Object data, String msg) {
        return new Result(false, null, msg, data);
    }

    public static Result failureWithData(Object data, String code, String msg) {
        return new Result(false, code, msg, data);
    }

}

③ 在base添加BaseEnum<K, V>枚舉接口，定義了獲取值和描述的接口。

package com.lyyzoo.core.base;

/**
 * 基礎枚舉接口
 *
 * @version 1.0
 * @author bojiangzhou 2017-12-31
 */
public interface BaseEnum<K, V> {

    /**
     * 獲取編碼
     *
     * @return 編碼
     */
    K code();

    /**
     * 獲取描述
     * 
     * @return 描述
     */
    V desc();

}

然后在constants下定義一個基礎枚舉常量類，我們把一些描述信息維護到枚舉里面，盡量不要在代碼中直接出現魔法值(如一些編碼、中文等)，以后的枚舉常量類也可以按照這種模式來寫。

package com.lyyzoo.core.constants;

import com.lyyzoo.core.base.BaseEnum;

import java.util.HashMap;
import java.util.Map;

/**
 * 基礎枚舉值
 *
 * @version 1.0
 * @author bojiangzhou 2018-01-01
 */
public enum BaseEnums implements BaseEnum<String, String> {

    SUCCESS("request.success", "請求成功"),

    FAILURE("request.failure", "請求失敗"),

    OPERATION_SUCCESS("operation.success", "操作成功"),

    OPERATION_FAILURE("operation.failure", "操作失敗"),

    ERROR("system.error", "系統異常"),

    NOT_FOUND("not_found", "請求資源不存在"),

    FORBIDDEN("forbidden", "無權限訪問"),

    VERSION_NOT_MATCH("record_not_exists_or_version_not_match", "記錄版本不存在或不匹配"),

    PARAMETER_NOT_NULL("parameter_not_be_null", "參數不能為空");

    private String code;

    private String desc;

    private static Map<String, String> allMap = new HashMap<>();

    BaseEnums(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    static {
        for(BaseEnums enums : BaseEnums.values()){
            allMap.put(enums.code, enums.desc);
        }
    }

    @Override
    public String code() {
        return code;
    }

    @Override
    public String desc() {
        return desc;
    }

    public String desc(String code) {
        return allMap.get(code);
    }

}

④ 再添加一個常用的日期工具類對象，主要包含一些常用的日期時間格式化，后續可再繼續往里面添加一些公共方法。

package com.lyyzoo.core.util;


import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 日期時間工具類
 *
 * @version 1.0
 * @author bojiangzhou 2017-12-28
 */
public class Dates {

    /**
     * 日期時間匹配格式
     */
    public interface Pattern {
        //
        // 常規模式
        // ----------------------------------------------------------------------------------------------------
        /**
         * yyyy-MM-dd
         */
        String DATE = "yyyy-MM-dd";
        /**
         * yyyy-MM-dd HH:mm:ss
         */
        String DATETIME = "yyyy-MM-dd HH:mm:ss";
        /**
         * yyyy-MM-dd HH:mm
         */
        String DATETIME_MM = "yyyy-MM-dd HH:mm";
        /**
         * yyyy-MM-dd HH:mm:ss.SSS
         */
        String DATETIME_SSS = "yyyy-MM-dd HH:mm:ss.SSS";
        /**
         * HH:mm
         */
        String TIME = "HH:mm";
        /**
         * HH:mm:ss
         */
        String TIME_SS = "HH:mm:ss";

        //
        // 系統時間格式
        // ----------------------------------------------------------------------------------------------------
        /**
         * yyyy/MM/dd
         */
        String SYS_DATE = "yyyy/MM/dd";
        /**
         * yyyy/MM/dd HH:mm:ss
         */
        String SYS_DATETIME = "yyyy/MM/dd HH:mm:ss";
        /**
         * yyyy/MM/dd HH:mm
         */
        String SYS_DATETIME_MM = "yyyy/MM/dd HH:mm";
        /**
         * yyyy/MM/dd HH:mm:ss.SSS
         */
        String SYS_DATETIME_SSS = "yyyy/MM/dd HH:mm:ss.SSS";

        //
        // 無連接符模式
        // ----------------------------------------------------------------------------------------------------
        /**
         * yyyyMMdd
         */
        String NONE_DATE = "yyyyMMdd";
        /**
         * yyyyMMddHHmmss
         */
        String NONE_DATETIME = "yyyyMMddHHmmss";
        /**
         * yyyyMMddHHmm
         */
        String NONE_DATETIME_MM = "yyyyMMddHHmm";
        /**
         * yyyyMMddHHmmssSSS
         */
        String NONE_DATETIME_SSS = "yyyyMMddHHmmssSSS";
    }

    public static final String DEFAULT_PATTERN = Pattern.DATETIME;

    public static final String[] PARSE_PATTERNS = new String[]{
            Pattern.DATE,
            Pattern.DATETIME,
            Pattern.DATETIME_MM,
            Pattern.DATETIME_SSS,
            Pattern.SYS_DATE,
            Pattern.SYS_DATETIME,
            Pattern.SYS_DATETIME_MM,
            Pattern.SYS_DATETIME_SSS
    };

    /**
     * 格式化日期時間
     * 
     * @param date 日期時間
     *
     * @return yyyy-MM-dd HH:mm:ss
     */
    public static String format(Date date) {
        return format(date, DEFAULT_PATTERN);
    }

    /**
     * 格式化日期
     * 
     * @param date 日期(時間)
     *
     * @param pattern 匹配模式 參考：{@link Dates.Pattern}
     *
     * @return 格式化后的字符串
     */
    public static String format(Date date, String pattern) {
        if (date == null) {
            return null;
        }
        pattern = StringUtils.isNotBlank(pattern) ? pattern : DEFAULT_PATTERN;
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        return sdf.format(date);
    }

    /**
     * 解析日期
     *
     * @param date 日期字符串
     *
     * @return 解析后的日期 默認格式：yyyy-MM-dd HH:mm:ss
     */
    public static Date parseDate(String date) {
        if (StringUtils.isBlank(date)) {
            return null;
        }
        try {
            return DateUtils.parseDate(date, PARSE_PATTERNS);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 解析日期
     *
     * @param date 日期
     *
     * @param pattern 格式 參考：{@link Dates.Pattern}
     *
     * @return 解析后的日期，默認格式：yyyy-MM-dd HH:mm:ss
     */
    public static Date parseDate(String date, String pattern) {
        if (StringUtils.isBlank(date)) {
            return null;
        }
        String[] parsePatterns;
        parsePatterns = StringUtils.isNotBlank(pattern) ? new String[]{pattern} : PARSE_PATTERNS;
        try {
            return DateUtils.parseDate(date, parsePatterns);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }



}

⑤ Constants定義系統級的通用常量。

package com.lyyzoo.core.constants;

import com.google.common.base.Charsets;

import java.nio.charset.Charset;

/**
 * 系統級常量類
 *
 * @version 1.0
 * @author bojiangzhou 2017-12-28
 */
public class Constants {

    public static final String APP_NAME = "sunny";

    /**
     * 系統編碼
     */
    public static final Charset CHARSET = Charsets.UTF_8;

    /**
     * 標識：是/否、啟用/禁用等
     */
    public interface Flag {

        Integer YES = 1;

        Integer NO = 0;
    }

    /**
     * 操作類型
     */
    public interface Operation {
        /**
         * 添加
         */
        String ADD = "add";
        /**
         * 更新
         */
        String UPDATE = "update";
        /**
         * 刪除
         */
        String DELETE = "delete";
    }

    /**
     * 性別
     */
    public interface Sex {
        /**
         * 男
         */
        Integer MALE = 1;
        /**
         * 女
         */
        Integer FEMALE = 0;
    }

}

⑥ 在base添加空的BaseController、BaseDTO、Service、Mapper，先定義好基礎結構，后面再添加功能。

BaseDTO：標准的who字段、版本號、及10個擴展字段。

因為這里用到了@Transient注解，先引入java持久化包：

package com.lyyzoo.core.base;

import com.fasterxml.jackson.annotation.*;
import com.lyyzoo.core.Constants;
import com.lyyzoo.core.util.Dates;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;

import javax.persistence.Transient;
import java.io.Serializable;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * 基礎實體類
 *
 * @version 1.0
 * @author bojiangzhou 2017-12-29
 */
public class BaseDTO implements Serializable {
    private static final long serialVersionUID = -4287607489867805101L;

    public static final String FIELD_OPERATE = "operate";
    public static final String FIELD_OBJECT_VERSION_NUMBER = "versionNumber";
    public static final String FIELD_CREATE_BY = "createBy";
    public static final String FIELD_CREATOR = "creator";
    public static final String FIELD_CREATE_DATE = "createDate";
    public static final String FIELD_UPDATE_BY = "updateBy";
    public static final String FIELD_UPDATER = "updater";
    public static final String FIELD_UPDATE_DATE = "updateDate";


    /**
     * 操作類型，add/update/delete 參考：{@link Constants.Operation}
     */
    @Transient
    private String _operate;

    /**
     * 數據版本號,每發生update則自增,用於實現樂觀鎖.
     */
    private Long versionNumber;

    //
    // 下面是標准 WHO 字段
    // ----------------------------------------------------------------------------------------------------
    /**
     * 創建人用戶名
     */
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private Long createBy;
    /**
     * 創建人名稱
     */
    @JsonInclude(JsonInclude.Include.NON_NULL)
    @Transient
    private String creator;
    /**
     * 創建時間
     */
    @JsonInclude(JsonInclude.Include.NON_NULL)
    @JsonFormat(pattern = Dates.DEFAULT_PATTERN)
    private Date createDate;

    /**
     * 更新人用戶名
     */
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private Long updateBy;
    /**
     * 更新人名稱
     */
    @JsonInclude(JsonInclude.Include.NON_NULL)
    @Transient
    private String updater;
    /**
     * 更新時間
     */
    @JsonInclude(JsonInclude.Include.NON_NULL)
    @JsonFormat(pattern = Dates.DEFAULT_PATTERN)
    private Date updateDate;

    /**
     * 其它屬性
     */
    @JsonIgnore
    @Transient
    protected Map<String, Object> innerMap = new HashMap<>();

    //
    // 下面是擴展屬性字段
    // ----------------------------------------------------------------------------------------------------

    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String attribute1;

    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String attribute2;

    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String attribute3;

    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String attribute4;

    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String attribute5;

    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String attribute6;

    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String attribute7;

    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String attribute8;

    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String attribute9;

    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String attribute10;

    public String get_operate() {
        return _operate;
    }

    public void set_operate(String _operate) {
        this._operate = _operate;
    }

    @Override
    public String toString() {
        return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE);
    }

    public String toJSONString() {
        return ToStringBuilder.reflectionToString(this, ToStringStyle.JSON_STYLE);
    }

    public Long getVersionNumber() {
        return versionNumber;
    }

    public void setVersionNumber(Long versionNumber) {
        this.versionNumber = versionNumber;
    }

    public Long getCreateBy() {
        return createBy;
    }

    public void setCreateBy(Long createBy) {
        this.createBy = createBy;
    }

    public String getCreator() {
        return creator;
    }

    public void setCreator(String creator) {
        this.creator = creator;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public Long getUpdateBy() {
        return updateBy;
    }

    public void setUpdateBy(Long updateBy) {
        this.updateBy = updateBy;
    }

    public String getUpdater() {
        return updater;
    }

    public void setUpdater(String updater) {
        this.updater = updater;
    }

    public Date getUpdateDate() {
        return updateDate;
    }

    public void setUpdateDate(Date updateDate) {
        this.updateDate = updateDate;
    }

    @JsonAnyGetter
    public Object getAttribute(String key) {
        return innerMap.get(key);
    }

    @JsonAnySetter
    public void setAttribute(String key, Object obj) {
        innerMap.put(key, obj);
    }

    public String getAttribute1() {
        return attribute1;
    }

    public void setAttribute1(String attribute1) {
        this.attribute1 = attribute1;
    }

    public String getAttribute2() {
        return attribute2;
    }

    public void setAttribute2(String attribute2) {
        this.attribute2 = attribute2;
    }

    public String getAttribute3() {
        return attribute3;
    }

    public void setAttribute3(String attribute3) {
        this.attribute3 = attribute3;
    }

    public String getAttribute4() {
        return attribute4;
    }

    public void setAttribute4(String attribute4) {
        this.attribute4 = attribute4;
    }

    public String getAttribute5() {
        return attribute5;
    }

    public void setAttribute5(String attribute5) {
        this.attribute5 = attribute5;
    }

    public String getAttribute6() {
        return attribute6;
    }

    public void setAttribute6(String attribute6) {
        this.attribute6 = attribute6;
    }

    public String getAttribute7() {
        return attribute7;
    }

    public void setAttribute7(String attribute7) {
        this.attribute7 = attribute7;
    }

    public String getAttribute8() {
        return attribute8;
    }

    public void setAttribute8(String attribute8) {
        this.attribute8 = attribute8;
    }

    public String getAttribute9() {
        return attribute9;
    }

    public void setAttribute9(String attribute9) {
        this.attribute9 = attribute9;
    }

    public String getAttribute10() {
        return attribute10;
    }

    public void setAttribute10(String attribute10) {
        this.attribute10 = attribute10;
    }

}

同時，重寫了toString方法，增加了toJsonString方法，使得可以格式化輸出DTO的數據：

直接打印DTO，輸出的格式大概就是這個樣子：

⑦ 在exception添加BaseException，定義一些基礎異常類

基礎異常類都繼承自運行時異常類(RunntimeException)，盡可能把受檢異常轉化為非受檢異常，更好的面向接口編程，提高代碼的擴展性、穩定性。

BaseException：添加了一個錯誤編碼，其它自定義的異常應當繼承該類。

package com.lyyzoo.core.exception;

/**
 * 基礎異常類
 *
 * @version 1.0
 * @author bojiangzhou 2017-12-31
 */
public class BaseException extends RuntimeException {
    private static final long serialVersionUID = -997101946070796354L;

    /**
     * 錯誤編碼
     */
    protected String code;

    public BaseException() {}

    public BaseException(String message) {
        super(message);
    }

    public BaseException(String code, String message) {
        super(message);
        this.code = code;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

ServiceException：繼承BaseException，Service層往Controller拋出的異常。

package com.lyyzoo.core.exception;

/**
 * Service層異常
 *
 * @version 1.0
 * @author bojiangzhou 2017-12-31
 */
public class ServiceException extends BaseException {
    private static final long serialVersionUID = 6058294324031642376L;

    public ServiceException() {}

    public ServiceException(String message) {
        super(message);
    }

    public ServiceException(String code, String message) {
        super(code, message);
    }

}

3、添加系統用戶功能，使用Postman測試接口

① 在system模塊下，再分成dto、controller、service、mapper、constants子包，以后一個模塊功能開發就是這樣一個基礎結構。

User：系統用戶

package com.lyyzoo.core.system.dto;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.lyyzoo.core.base.BaseDTO;
import com.lyyzoo.core.util.Dates;

import java.util.Date;

/**
 * 系統用戶
 *
 * @version 1.0
 * @author bojiangzhou 2017-12-31
 */
@JsonInclude(JsonInclude.Include.NON_NULL)
public class User extends BaseDTO {
    private static final long serialVersionUID = -7395431342743009038L;

    /**
     * 用戶ID
     */
    private Long userId;
    /**
     * 用戶名
     */
    private String username;
    /**
     * 密碼
     */
    private String password;
    /**
     * 昵稱
     */
    private String nickname;
    /**
     * 生日
     */
    @JsonFormat(pattern = Dates.Pattern.DATE)
    private Date birthday;
    /**
     * 性別：1-男/0-女
     */
    private Integer sex;
    /**
     * 是否啟用：1/0
     */
    private Integer enabled;

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Integer getSex() {
        return sex;
    }

    public void setSex(Integer sex) {
        this.sex = sex;
    }

    public Integer getEnabled() {
        return enabled;
    }

    public void setEnabled(Integer enabled) {
        this.enabled = enabled;
    }

}

UserController：用戶控制層；用@RestController注解，前后端分離，因為無需返回視圖，采用Restful風格，直接返回數據。

package com.lyyzoo.core.system.controller;

import com.lyyzoo.core.Constants;
import com.lyyzoo.core.base.BaseController;
import com.lyyzoo.core.base.BaseEnums;
import com.lyyzoo.core.base.Result;
import com.lyyzoo.core.system.dto.User;
import com.lyyzoo.core.util.Dates;
import com.lyyzoo.core.util.Results;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

/**
 * 用戶Controller
 *
 * @version 1.0
 * @author bojiangzhou 2017-12-31
 */
@RequestMapping("/sys/user")
@RestController
public class UserController extends BaseController {

    private static List<User> userList = new ArrayList<>();

    // 先靜態模擬數據
    static {
        User user1 = new User();
        user1.setUserId(1L);
        user1.setUsername("lufei");
        user1.setNickname("蒙奇D路飛");
        user1.setBirthday(Dates.parseDate("2000-05-05"));
        user1.setSex(Constants.Sex.MALE);
        user1.setEnabled(Constants.Flag.YES);
        userList.add(user1);

        User user2 = new User();
        user2.setUserId(2L);
        user2.setUsername("nami");
        user2.setNickname("娜美");
        user2.setBirthday(Dates.parseDate("2000/7/3"));
        user2.setSex(Constants.Sex.FEMALE);
        user2.setEnabled(Constants.Flag.YES);
        userList.add(user2);
    }

    @RequestMapping("/queryAll")
    public Result queryAll(){
        return Results.successWithData(userList, BaseEnums.SUCCESS.code(), BaseEnums.SUCCESS.description());
    }

    @RequestMapping("/queryOne/{userId}")
    public Result queryOne(@PathVariable Long userId){
        User user = null;
        for(User u : userList){
            if(u.getUserId().longValue() == userId){
                user = u;
            }
        }
        return Results.successWithData(user);
    }
}

② Postman請求：請求成功，基礎的HTTP服務已經實現了。

 

三、集成MyBatis，實現基礎Mapper和Service

1、添加JDBC、配置數據源

添加spring-boot-starter-jdbc以支持JDBC訪問數據庫，然后添加MySql的JDBC驅動mysql-connector-java；

在application.properties里配置mysql的數據庫驅動

之后在application-dev.properties里配置開發環境數據庫的連接信息，添加之后，Springboot就會自動配置數據源了。

2、集成MyBatis

MyBatis官方為了方便Springboot集成MyBatis，專門提供了一個符合Springboot規范的starter項目，即mybatis-spring-boot-starter。

在application.properties里添加mybatis映射配置：

3、添加MyBatis通用Mapper

通用Mapper可以極大的簡化開發，極其方便的進行單表的增刪改查。

關於通用Mapper，參考網站地址：

　　MyBatis通用Mapper

　　MyBatis 相關工具

之后，在core.base下創建自定義的Mapper，按需選擇接口。

具體可參考：根據需要自定義接口

package com.lyyzoo.core.base;  2 
import tk.mybatis.mapper.common.BaseMapper;  4 import tk.mybatis.mapper.common.ConditionMapper;  5 import tk.mybatis.mapper.common.IdsMapper;  6 import tk.mybatis.mapper.common.special.InsertListMapper;  7 
/**
 * 10  * BaseMapper 11  * 12  * @name BaseMapper 13  * @version 1.0 14  * @author bojiangzhou 2017-12-31 15  */
public interface Mapper<T> extends BaseMapper<T>, ConditionMapper<T>, IdsMapper<T>, InsertListMapper<T> { 17 
}

定義好基礎Mapper后，就具有下圖中的基本通用方法了。每個實體類對應的*Mapper繼承Mapper<T>來獲得基本的增刪改查的通用方法。

在application.properties里配置自定義的基礎Mapper

4、添加分頁插件PageHelper

參考地址：

　　MyBatis 分頁插件 - PageHelper

　　分頁插件使用方法

分頁插件配置，一般情況下，不需要做任何配置。

之后，我們就可以在代碼中使用 PageHelper.startPage(1, 10) 對緊隨其后的一個查詢進行分頁查詢，非常方便。

5、配置自動掃描Mapper

在config下創建MyBatisConfig配置文件，通過mapperScannerConfigurer方法配置自動掃描Mapper文件。

package com.lyyzoo.core.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import tk.mybatis.spring.mapper.MapperScannerConfigurer;

/**
 * MyBatis相關配置.
 *
 * @version 1.0
 * @author bojiangzhou 2018-01-07
 */
@Configuration
public class MyBatisConfig {

    /**
     * Mapper掃描配置. 自動掃描將Mapper接口生成代理注入到Spring.
     */
    @Bean
    public static MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        // 注意這里的掃描路徑: 1.不要掃描到自定義的Mapper; 2.定義的路徑不要掃描到tk.mybatis.mapper(如定義**.mapper).
        // 兩個做法都會導致掃描到tk.mybatis的Mapper，就會產生重復定義的報錯.
        mapperScannerConfigurer.setBasePackage("**.lyyzoo.**.mapper");
        return mapperScannerConfigurer;
    }

}

注意這里的 MapperScannerConfigurer 是tk.mybatis.spring.mapper.MapperScannerConfigurer，而不是org.mybatis，否則使用通用Mapper的方法時會報類似下面的這種錯誤

6、定義基礎Service

一般來說，我們不能在Controller中直接訪問Mapper，因此我們需要加上Service，通過Service訪問Mapper。

首先定義基礎Service<T>接口，根據Mapper定義基本的增刪改查接口方法。

package com.lyyzoo.core.base;  2 
import java.util.List;  4 
/**
 * Service 基礎通用接口  7  *  8  * @name BaseService  9  * @version 1.0  10  * @author bojiangzhou 2017-12-31  11  */
public interface Service<T> {  13 
    //
    // insert  16     // ----------------------------------------------------------------------------------------------------
    /**
 * 保存一個實體，null的屬性也會保存，不會使用數據庫默認值  19  *  20  * @param record  21  * @return
     */
 T insert(T record);  24 
    /**
 * 批量插入，null的屬性也會保存，不會使用數據庫默認值  27  *  28  * @param recordList  29  * @return
     */
    List<T> insert(List<T> recordList);  32 
    /**
 * 保存一個實體，null的屬性不會保存，會使用數據庫默認值  35  *  36  * @param record  37  * @return
     */
 T insertSelective(T record);  40 
    /**
 * 批量插入，null的屬性不會保存，會使用數據庫默認值  43  *  44  * @param recordList  45  * @return
     */
    List<T> insertSelective(List<T> recordList);  48 
    //
    // update  51     // ----------------------------------------------------------------------------------------------------
    /**
 * 根據主鍵更新實體全部字段，null值會被更新  54  *  55  * @param record  56  * @return
     */
 T update(T record);  59 
    /**
 * 批量更新，根據主鍵更新實體全部字段，null值會被更新  62  *  63  * @param recordList  64  * @return
     */
    List<T> update(List<T> recordList);  67 
    /**
 * 根據主鍵更新屬性不為null的值  70  *  71  * @param record  72  * @return
     */
 T updateSelective(T record);  75 
    /**
 * 批量更新，根據主鍵更新屬性不為null的值  78  *  79  * @param recordList  80  * @return
     */
    List<T> updateSelective(List<T> recordList);  83 
    //
    // delete  86     // ----------------------------------------------------------------------------------------------------
    /**
 * 根據主鍵刪除  89  *  90  * @param id id不能為空  91  * @return
     */
    int delete(Long id);  94 
    /**
 * 根據主鍵字符串進行刪除，類中只有存在一個帶有@Id注解的字段  97  *  98  * @param ids 類似1,2,3  99      */
    int delete(String ids); 101 
    /**
 * 根據主鍵刪除多個實體，ID數組 104  * 105  * @param ids 類似[1,2,3]，不能為空 106      */
    int delete(Long[] ids); 108 
    /**
 * 根據實體屬性作為條件進行刪除 111  * 112  * @param record 113  * @return
     */
    int delete(T record); 116 
    /**
 * 根據主鍵刪除多個實體 119  * 120  * @param recordList 121  * @return
     */
    int delete(List<T> recordList); 124 
    //
    // insert or update or delete 127     // ----------------------------------------------------------------------------------------------------
    /**
 * 根據實體的operate決定哪種操作. null的屬性也會保存，不會使用數據庫默認值 130  * 131  * @param record 132  * @return
     */
 T persist(T record); 135 
    /**
 * 批量操作.根據實體的operate決定哪種操作. null的屬性也會保存，不會使用數據庫默認值 138  * 139  * @param recordList 140  * @return
     */
    List<T> persist(List<T> recordList); 143 
    /**
 * 根據實體的operate決定哪種操作. 根據主鍵更新屬性不為null的值 146  * 147  * @param record 148  * @return
     */
 T persistSelective(T record); 151 
    /**
 * 批量操作.根據實體的operate決定哪種操作. 根據主鍵更新屬性不為null的值 154  * 155  * @param recordList 156  * @return
     */
    List<T> persistSelective(List<T> recordList); 159 

    //
    // select 163     // ----------------------------------------------------------------------------------------------------
    /**
 * 根據主鍵查詢 166  * 167  * @param id 不能為空 168  * @return
     */
 T get(Long id); 171 
    /**
 * 根據實體中的屬性進行查詢，只能有一個返回值，有多個結果是拋出異常 174  * 175  * @param record 176  * @return
     */
 T get(T record); 179 
    /**
 * 根據字段和值查詢 返回一個 182  * @param key 不能為空 183  * @param value 不能為空 184  * @return
     */
 T get(String key, Object value); 187 

    /**
 * 根據主鍵字符串進行查詢 191  * 192  * @param ids 如 "1,2,3,4" 193  * @return
     */
    List<T> select(String ids); 196 
    /**
 * 根據實體中的屬性值進行查詢 199  * 200  * @param record 201  * @return
     */
    List<T> select(T record); 204 
    /**
 * 根據屬性和值查詢 207  * 208  * @param key 209  * @param value 210  * @return
     */
    List<T> select(String key, Object value); 213 
    /**
 * 根據實體中的屬性值進行分頁查詢 216  * 217  * @param record 218  * @param pageNum 219  * @param pageSize 220  * @return
     */
    List<T> select(T record, int pageNum, int pageSize); 223 
    /**
 * 查詢全部結果 226  * 227  * @return
     */
    List<T> selectAll(); 230 
    /**
 * 根據實體中的屬性查詢總數 233  * 234  * @param record 235  * @return
     */
    int count(T record); 238 
}

然后是實現類BaseService，以后的開發中，Service接口實現Service<T>，Service實現類繼承BaseService<T>。

package com.lyyzoo.core.base;

import com.github.pagehelper.PageHelper;
import com.lyyzoo.core.constants.Constants;
import com.lyyzoo.core.exception.UpdateFailedException;
import com.lyyzoo.core.util.Reflections;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import javax.annotation.PostConstruct;
import javax.persistence.Id;
import java.lang.reflect.Field;
import java.util.List;

/**
 * 基礎Service實現類
 *
 * @version 1.0
 * @author bojiangzhou 2018-01-04
 */
public abstract class BaseService<T> implements Service<T> {

    @Autowired
    private Mapper<T> mapper;

    private Class<T> entityClass;

    @SuppressWarnings("unchecked")
    @PostConstruct
    public void init() {
        this.entityClass = Reflections.getClassGenericType(getClass());
    }

    //
    // insert
    // ----------------------------------------------------------------------------------------------------
    @Transactional(rollbackFor = Exception.class)
    public T insert(T record) {
        mapper.insert(record);
        return record;
    }

    @Transactional(rollbackFor = Exception.class)
    public List<T> insert(List<T> recordList) {
        mapper.insertList(recordList);
        return recordList;
    }

    @Transactional(rollbackFor = Exception.class)
    public T insertSelective(T record) {
        mapper.insertSelective(record);
        return record;
    }

    @Transactional(rollbackFor = Exception.class)
    public List<T> insertSelective(List<T> recordList) {
        // 由於Mapper暫未提供Selective的批量插入，此處循環查詢. 當然也可參考InsertListMapper自己實現.
        for(T record : recordList){
            mapper.insertSelective(record);
        }
        return recordList;
    }

    //
    // update
    // ----------------------------------------------------------------------------------------------------
    @Transactional(rollbackFor = Exception.class)
    public T update(T record) {
        int count = mapper.updateByPrimaryKey(record);
        checkUpdate(count, record);
        return record;
    }

    @Transactional(rollbackFor = Exception.class)
    public List<T> update(List<T> recordList) {
        // Mapper暫未提供批量更新，此處循實現
        for(T record : recordList){
            int count = mapper.updateByPrimaryKey(record);
            checkUpdate(count, record);
        }
        return recordList;
    }

    @Transactional(rollbackFor = Exception.class)
    public T updateSelective(T record) {
        int count = mapper.updateByPrimaryKeySelective(record);
        checkUpdate(count, record);
        return record;
    }

    @Transactional(rollbackFor = Exception.class)
    public List<T> updateSelective(List<T> recordList) {
        // Mapper暫未提供批量更新，此處循實現
        for(T record : recordList){
            int count = mapper.updateByPrimaryKeySelective(record);
            checkUpdate(count, record);
        }
        return recordList;
    }

    //
    // delete
    // ----------------------------------------------------------------------------------------------------
    @Transactional(rollbackFor = Exception.class)
    public int delete(Long id) {
        return mapper.deleteByPrimaryKey(id);
    }

    @Transactional(rollbackFor = Exception.class)
    public int delete(Long[] ids) {
        int count = 0;
        for(Long id : ids){
            mapper.deleteByPrimaryKey(id);
            count++;
        }
        return count;
    }

    @Transactional(rollbackFor = Exception.class)
    public int delete(T record) {
        return mapper.delete(record);
    }

    @Transactional(rollbackFor = Exception.class)
    public int delete(List<T> recordList) {
        int count = 0;
        for(T record : recordList){
            mapper.delete(record);
            count++;
        }
        return count;
    }

    //
    // all operate. insert or update or delete
    // ----------------------------------------------------------------------------------------------------
    @Transactional(rollbackFor = Exception.class)
    public T persist(T record) {
        BaseDTO dto = (BaseDTO) record;
        Assert.notNull(dto.get_operate(), "_operate not be null.");
        switch (dto.get_operate()) {
            case Constants.Operation.ADD:
                insert(record);
                break;
            case Constants.Operation.UPDATE:
                update(record);
                break;
            case Constants.Operation.DELETE:
                delete(record);
                break;
            default:
                break;
        }
        dto.set_operate(null);
        return record;
    }

    @Transactional(rollbackFor = Exception.class)
    public List<T> persist(List<T> recordList) {
        for(T record : recordList){
            BaseDTO dto = (BaseDTO) record;
            Assert.notNull(dto.get_operate(), "_operate not be null.");
            switch (dto.get_operate()) {
                case Constants.Operation.ADD:
                    insert(record);
                    break;
                case Constants.Operation.UPDATE:
                    update(record);
                    break;
                case Constants.Operation.DELETE:
                    delete(record);
                    break;
                default:
                    break;
            }
            dto.set_operate(null);
        }
        return recordList;
    }

    @Transactional(rollbackFor = Exception.class)
    public T persistSelective(T record) {
        BaseDTO dto = (BaseDTO) record;
        Assert.notNull(dto.get_operate(), "_operate not be null.");
        switch (dto.get_operate()) {
            case Constants.Operation.ADD:
                insertSelective(record);
                break;
            case Constants.Operation.UPDATE:
                updateSelective(record);
                break;
            case Constants.Operation.DELETE:
                delete(record);
                break;
            default:
                break;
        }
        return record;
    }

    @Transactional(rollbackFor = Exception.class)
    public List<T> persistSelective(List<T> recordList) {
        for(T record : recordList){
            BaseDTO dto = (BaseDTO) record;
            Assert.notNull(dto.get_operate(), "_operate not be null.");
            switch (dto.get_operate()) {
                case Constants.Operation.ADD:
                    insertSelective(record);
                    break;
                case Constants.Operation.UPDATE:
                    updateSelective(record);
                    break;
                case Constants.Operation.DELETE:
                    delete(record);
                    break;
                default:
                    break;
            }
        }
        return recordList;
    }

    //
    // select
    // ----------------------------------------------------------------------------------------------------
    public T get(Long id) {
        T entity = null;
        try {
            entity = entityClass.newInstance();
            Field idField = Reflections.getFieldByAnnotation(entityClass, Id.class);
            idField.set(entity, id);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return mapper.selectByPrimaryKey(entity);
    }

    public T get(T record) {
        return mapper.selectOne(record);
    }

    public T get(String key, Object value) {
        T entity = null;
        try {
            entity = entityClass.newInstance();
            Field field = Reflections.getField(entityClass, key);
            field.set(entity, value);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return mapper.selectOne(entity);
    }

    public List<T> select(String ids) {
        return mapper.selectByIds(ids);
    }

    public List<T> select(T record) {

        return mapper.select(record);
    }

    public List<T> select(String key, Object value) {
        T entity = null;
        try {
            entity = entityClass.newInstance();
            Field field = Reflections.getField(entityClass, key);
            field.set(entity, value);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return mapper.select(entity);
    }

    public List<T> select(T record, int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        return mapper.select(record);
    }

    public List<T> selectAll() {
        return mapper.selectAll();
    }

    public int count(T record) {
        return mapper.selectCount(record);
    }

    /**
     * 檢查樂觀鎖<br>
     * 更新失敗時，拋出 UpdateFailedException 異常
     *
     * @param updateCount update,delete 操作返回的值
     * @param record 操作參數
     */
    protected void checkUpdate(int updateCount, Object record) {
        if (updateCount == 0 && record instanceof BaseDTO) {
            BaseDTO baseDTO = (BaseDTO) record;
            if (baseDTO.getVersion() != null) {
                throw new UpdateFailedException();
            }
        }
    }

}

BaseService的實現用到了反射工具類Reflections：

package com.lyyzoo.core.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * 反射工具類.
 *
 * @version 1.0
 * @author bojiangzhou 2018-01-06
 */

public abstract class Reflections {

    private static Logger logger = LoggerFactory.getLogger(Reflections.class);

    /**
     * 通過反射, 獲得Class定義中聲明的泛型參數的類型, 注意泛型必須定義在父類處. 如無法找到, 返回Object.class.
     *
     * @param clazz class類
     *
     * @return the 返回第一個聲明的泛型類型. 如果沒有,則返回Object.class
     */
    @SuppressWarnings("unchecked")
    public static Class getClassGenericType(final Class clazz) {
        return getClassGenericType(clazz, 0);
    }

    /**
     * 通過反射, 獲得Class定義中聲明的父類的泛型參數的類型. 如無法找到, 返回Object.class.
     *
     * @param clazz class類
     *
     * @param index 獲取第幾個泛型參數的類型,默認從0開始,即第一個
     *
     * @return 返回第index個泛型參數類型.
     */
    public static Class getClassGenericType(final Class clazz, final int index) {
        Type genType = clazz.getGenericSuperclass();

        if (!(genType instanceof ParameterizedType)) {
            return Object.class;
        }

        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();

        if (index >= params.length || index < 0) {
            logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: " + params.length);
            return Object.class;
        }
        if (!(params[index] instanceof Class)) {
            logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
            return Object.class;
        }

        return (Class) params[index];
    }

    /**
     * 根據注解類型獲取實體的Field
     *
     * @param entityClass 實體類型
     * 
     * @param annotationClass 注解類型
     *
     * @return 返回第一個有該注解類型的Field,如果沒有則返回null.
     */
    @SuppressWarnings("unchecked")
    public static Field getFieldByAnnotation(Class entityClass, Class annotationClass) {
        Field[] fields = entityClass.getDeclaredFields();
        for (Field field : fields) {
            if (field.getAnnotation(annotationClass) != null) {
                makeAccessible(field);
                return field;
            }
        }
        return null;
    }

    /**
     * 獲取實體的字段
     *
     * @param entityClass 實體類型
     *
     * @param fieldName 字段名稱
     *
     * @return 該字段名稱對應的字段,如果沒有則返回null.
     */
    public static Field getField(Class entityClass, String fieldName){
        try {
            Field field = entityClass.getDeclaredField(fieldName);
            makeAccessible(field);
            return field;
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 改變private/protected的成員變量為public.
     */
    public static void makeAccessible(Field field) {
        if (!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers())) {
            field.setAccessible(true);
        }
    }

}

7、獲取AOP代理

Spring 只要引入aop則是默認開啟事務的，一般我們只要在需要事務管理的地方加上@Transactional注解即可支持事務，一般我們會加在Service的類或者具體的增加、刪除、更改的方法上。

我這里要說的是獲取代理的問題。Service的事務管理是AOP實現的，AOP的實現用的是JDK動態代理或CGLIB動態代理。所以，如果你想在你的代理方法中以 this 調用當前接口的另一個方法，另一個方法的事務是不會起作用的。因為事務的方法是代理對象的，而 this 是當前類對象，不是一個代理對象，自然事務就不會起作用了。這是我在不久前的開發中遇到的實際問題，我自定義了一個注解，加在方法上，使用AspectJ來攔截該注解，卻沒攔截到，原因就是這個方法是被另一個方法以 this 的方式調用的，所以AOP不能起作用。

更詳細的可參考：Spring AOP無法攔截內部方法調用

所以添加一個獲取自身代理對象的接口，以方便獲取代理對象來操作當前類方法。Service接口只需要繼承該接口，T為接口本身即可，就可以通過self()獲取自身的代理對象了。

package com.lyyzoo.core.base;

import org.springframework.aop.framework.AopContext;

/**
 * 獲取代理對象本身.
 */
public interface ProxySelf<T> {
    /**
     * 取得當前對象的代理.
     * 
     * @return 代理對象,如果未被代理,則拋出 IllegalStateException
     */
    @SuppressWarnings("unchecked")
    default T self() {
        return (T) AopContext.currentProxy();
    }
}

還需要開啟開啟 exposeProxy = true，暴露代理對象，否則 AopContext.currentProxy() 會拋出異常。

8、數據持久化測試

① 實體映射

實體類按照如下規則和數據庫表進行轉換，注解全部是JPA中的注解：

• 表名默認使用類名，駝峰轉下划線(只對大寫字母進行處理)，如UserInfo默認對應的表名為user_info

• 表名可以使@Table(name = "tableName")進行指定，對不符合第一條默認規則的可以通過這種方式指定表名。

• 字段默認和@Column一樣，都會作為表字段，表字段默認為Java對象的Field名字駝峰轉下划線形式。

• 可以使用@Column(name = "fieldName")指定不符合第3條規則的字段名。

• 使用@Transient注解可以忽略字段，添加該注解的字段不會作為表字段使用，注意，如果沒有與表關聯，一定要用@Transient標注。

• 建議一定是有一個@Id注解作為主鍵的字段,可以有多個@Id注解的字段作為聯合主鍵。

• 默認情況下，實體類中如果不存在包含@Id注解的字段,所有的字段都會作為主鍵字段進行使用(這種效率極低)。

• 由於基本類型，如int作為實體類字段時會有默認值0，而且無法消除，所以實體類中建議不要使用基本類型。

   1 package com.lyyzoo.system.dto;  2 
   3 import com.fasterxml.jackson.annotation.JsonFormat;  4 import com.fasterxml.jackson.annotation.JsonInclude;  5 import com.lyyzoo.core.base.BaseDTO;  6 import com.lyyzoo.core.util.Dates;  7 
   8 import javax.persistence.GeneratedValue;  9 import javax.persistence.GenerationType;  10 import javax.persistence.Id;  11 import javax.persistence.Table;  12 import java.util.Date;  13 
   14 /**
   15  * 系統用戶  16  *  17  * @name User  18  * @version 1.0  19  * @author bojiangzhou 2017-12-31  20  */
   21 @JsonInclude(JsonInclude.Include.NON_NULL)  22 @Table(name = "SYS_USER")  23 public class User extends BaseDTO {  24     private static final long serialVersionUID = -7395431342743009038L;  25 
   26     /**
   27  * 用戶ID  28      */
   29  @Id  30     @GeneratedValue(strategy = GenerationType.IDENTITY)  31     private Long userId;  32     /**
   33  * 用戶名  34      */
   35     private String username;  36     /**
   37  * 密碼  38      */
   39     private String password;  40     /**
   41  * 昵稱  42      */
   43     private String nickname;  44     /**
   45  * 生日  46      */
   47     @JsonFormat(pattern = Dates.Pattern.DATE)  48     private Date birthday;  49     /**
   50  * 性別：1-男/0-女  51      */
   52     private Integer sex;  53     /**
   54  * 是否啟用：1/0  55      */
   56     private Integer enabled;  57 
   58     public Long getUserId() {  59         return userId;  60  }  61 
   62     public void setUserId(Long userId) {  63         this.userId = userId;  64  }  65 
   66     public String getUsername() {  67         return username;  68  }  69 
   70     public void setUsername(String username) {  71         this.username = username;  72  }  73 
   74     public String getPassword() {  75         return password;  76  }  77 
   78     public void setPassword(String password) {  79         this.password = password;  80  }  81 
   82     public String getNickname() {  83         return nickname;  84  }  85 
   86     public void setNickname(String nickname) {  87         this.nickname = nickname;  88  }  89 
   90     public Date getBirthday() {  91         return birthday;  92  }  93 
   94     public void setBirthday(Date birthday) {  95         this.birthday = birthday;  96  }  97 
   98     public Integer getSex() {  99         return sex; 100  } 101 
  102     public void setSex(Integer sex) { 103         this.sex = sex; 104  } 105 
  106     public Integer getEnabled() { 107         return enabled; 108  } 109 
  110     public void setEnabled(Integer enabled) { 111         this.enabled = enabled; 112  } 113 }

User實體主要加了@Table注解，映射表名；然后在userId上標注主鍵注解；其它字段如果沒加@Transient注解的默認都會作為表字段。

package com.lyyzoo.core.system.dto;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.lyyzoo.core.base.BaseDTO;
import com.lyyzoo.core.util.Dates;

import javax.persistence.*;
import java.util.Date;
import java.util.List;

/**
 * 系統用戶
 *
 * @name User
 * @version 1.0
 * @author bojiangzhou 2017-12-31
 */
@JsonInclude(JsonInclude.Include.NON_NULL)
@Table(name = "SYS_USER")
public class User extends BaseDTO {
    private static final long serialVersionUID = -7395431342743009038L;

    /**
     * 用戶ID
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @OrderBy("DESC")
    private Long userId;
    /**
     * 用戶名
     */
    private String username;
    /**
     * 密碼
     */
    private String password;
    /**
     * 昵稱
     */
    private String nickname;
    /**
     * 生日
     */
    @JsonFormat(pattern = Dates.Pattern.DATE)
    private Date birthday;
    /**
     * 性別：1-男/0-女
     */
    private Integer sex;
    /**
     * 是否啟用：1/0
     */
    private Integer enabled;


    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Integer getSex() {
        return sex;
    }

    public void setSex(Integer sex) {
        this.sex = sex;
    }

    public Integer getEnabled() {
        return enabled;
    }

    public void setEnabled(Integer enabled) {
        this.enabled = enabled;
    }

}

② 創建表結構

CREATE TABLE `sys_user` (  2   `USER_ID` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '表ID，主鍵，供其他表做外鍵',  3   `USERNAME` varchar(30) NOT NULL COMMENT '用戶名',  4   `PASSWORD` varchar(100) NOT NULL COMMENT '密碼',  5   `NICKNAME` varchar(30) NOT NULL COMMENT '用戶名稱',  6   `BIRTHDAY` date DEFAULT NULL COMMENT '生日',  7   `SEX` int(1) DEFAULT NULL COMMENT '性別：1-男；0-女',  8   `ENABLED` int(1) NOT NULL DEFAULT '1' COMMENT '啟用標識：1/0',  9   `VERSION_NUMBER` int(11) NOT NULL DEFAULT '1' COMMENT '行版本號，用來處理鎖', 10   `CREATE_DATE` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '創建時間', 11   `CREATE_BY` bigint(11) NOT NULL DEFAULT '-1' COMMENT '創建人', 12   `UPDATE_BY` bigint(11) NOT NULL DEFAULT '-1' COMMENT '更新人', 13   `UPDATE_DATE` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '更新時間', 14   `ATTRIBUTE1` varchar(150) DEFAULT NULL, 15   `ATTRIBUTE2` varchar(150) DEFAULT NULL, 16   `ATTRIBUTE3` varchar(150) DEFAULT NULL, 17   `ATTRIBUTE4` varchar(150) DEFAULT NULL, 18   `ATTRIBUTE5` varchar(150) DEFAULT NULL, 19   `ATTRIBUTE6` varchar(150) DEFAULT NULL, 20   `ATTRIBUTE7` varchar(150) DEFAULT NULL, 21   `ATTRIBUTE8` varchar(150) DEFAULT NULL, 22   `ATTRIBUTE9` varchar(150) DEFAULT NULL, 23   `ATTRIBUTE10` varchar(150) DEFAULT NULL, 24   PRIMARY KEY (`USER_ID`), 25   UNIQUE KEY `USERNAME` (`USERNAME`) 26 ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COMMENT='系統用戶';

③ 創建UserMapper

在system.mapper下創建UserMapper接口，繼承Mapper<User>：

package com.lyyzoo.core.system.mapper;

import com.lyyzoo.core.base.Mapper;
import com.lyyzoo.core.system.dto.User;

/**
 *
 * @name UserMapper
 * @version 1.0
 * @author bojiangzhou 2018-01-06
 */
public interface UserMapper extends Mapper<User> {

}

④ 創建UserService

在system.service下創建UserService接口，只需繼承Service<User>接口即可。

package com.lyyzoo.core.system.service;

import com.lyyzoo.core.base.Service;
import com.lyyzoo.core.system.dto.User;

/**
 * 用戶Service接口
 *
 * @version 1.0
 * @author bojiangzhou 2018-01-06
 */
public interface UserService extends Service<User> {

}

在system.service.impl下創建UserServiceImpl實現類，繼承BaseService<User>類，實現UserService接口。同時加上@Service注解。

package com.lyyzoo.core.system.service.impl;

import org.springframework.stereotype.Service;

import com.lyyzoo.core.base.BaseService;
import com.lyyzoo.core.system.dto.User;
import com.lyyzoo.core.system.service.UserService;

/**
 * 用戶Service實現類
 *
 * @version 1.0
 * @author bojiangzhou 2018-01-06
 */
@Service
public class UserServiceImpl extends BaseService<User> implements UserService {

}

⑤ 修改UserController，注入UserService，增加一些測試API

package com.lyyzoo.core.system.controller;

import com.lyyzoo.core.base.BaseController;
import com.lyyzoo.core.base.BaseEnums;
import com.lyyzoo.core.base.Result;
import com.lyyzoo.core.system.dto.User;
import com.lyyzoo.core.system.service.UserService;
import com.lyyzoo.core.util.Results;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.List;

/**
 * 用戶Controller
 *
 * @version 1.0
 * @author bojiangzhou 2017-12-31
 */
@RequestMapping
@RestController
public class UserController extends BaseController {

    @Autowired
    private UserService userService;


    @PostMapping("/sys/user/queryAll")
    public Result queryAll(){
        List<User> list = userService.selectAll();
        return Results.successWithData(list, BaseEnums.SUCCESS.code(), BaseEnums.SUCCESS.description());
    }

    @RequestMapping("/sys/user/queryOne/{userId}")
    public Result queryOne(@PathVariable Long userId){
        User user = userService.get(userId);
        return Results.successWithData(user);
    }

    @PostMapping("/sys/user/save")
    public Result save(@Valid @RequestBody User user){
        user = userService.insertSelective(user);
        return Results.successWithData(user);
    }

    @PostMapping("/sys/user/update")
    public Result update(@Valid @RequestBody List<User> user){
        user = userService.persistSelective(user);
        return Results.successWithData(user);
    }

    @RequestMapping("/sys/user/delete")
    public Result delete(User user){
        userService.delete(user);
        return Results.success();
    }

    @RequestMapping("/sys/user/delete/{userId}")
    public Result delete(@PathVariable Long userId){
        userService.delete(userId);
        return Results.success();
    }

}

⑥ 測試結果

查詢所有：

批量保存/修改：

9、代碼生成器

使用代碼生成器來生成基礎的代碼結構，生成DTO、XML等等。

MyBatis官方提供了代碼生成器MyBatis Generator，但一般需要定制化。MyBatis Generator

我這里從網上找了一個使用起來比較方便的界面工具，可生成DTO、Mapper、Mapper.xml，生成之后還需做一些小調整。另需要自己創建對應的Service、Controller。之后有時間再重新定制化一個符合本項目的代碼生成器。

mybatis-generator界面工具

 

四、日志及全局異常處理

在前面的測試中，會發現控制台輸出的日志不怎么友好，有很多日志也沒有輸出，不便於查找排查問題。對於一個應用程序來說日志記錄是必不可少的一部分。線上問題追蹤，基於日志的業務邏輯統計分析等都離不日志。

先貼出一些參考資料：

　　logback 配置詳解

　　日志組件slf4j介紹及配置詳解

　　Java常用日志框架介紹

1、日志框架簡介

Java有很多常用的日志框架，如Log4j、Log4j 2、Commons Logging、Slf4j、Logback等。有時候你可能會感覺有點混亂，下面簡單介紹下。

• Log4j：Apache Log4j是一個基於Java的日志記錄工具，是Apache軟件基金會的一個項目。

• Log4j 2：Apache Log4j 2是apache開發的一款Log4j的升級產品。

• Commons Logging：Apache基金會所屬的項目，是一套Java日志接口。

• Slf4j：類似於Commons Logging，是一套簡易Java日志門面，本身並無日志的實現。（Simple Logging Facade for Java，縮寫Slf4j）。

• Logback：一套日志組件的實現(slf4j陣營)。

Commons Logging和Slf4j是日志門面，提供一個統一的高層接口，為各種loging API提供一個簡單統一的接口。log4j和Logback則是具體的日志實現方案。可以簡單的理解為接口與接口的實現，調用者只需要關注接口而無需關注具體的實現，做到解耦。

比較常用的組合使用方式是Slf4j與Logback組合使用，Commons Logging與Log4j組合使用。

基於下面的一些優點，選用Slf4j+Logback的日志框架：

• 更快的執行速度，Logback重寫了內部的實現，在一些關鍵執行路徑上性能提升10倍以上。而且logback不僅性能提升了，初始化內存加載也更小了

• 自動清除舊的日志歸檔文件，通過設置TimeBasedRollingPolicy 或者 SizeAndTimeBasedFNATP的 maxHistory 屬性，你就可以控制日志歸檔文件的最大數量

• Logback擁有遠比log4j更豐富的過濾能力，可以不用降低日志級別而記錄低級別中的日志。

• Logback必須配合Slf4j使用。由於Logback和Slf4j是同一個作者，其兼容性不言而喻。

• 默認情況下，Spring Boot會用Logback來記錄日志，並用INFO級別輸出到控制台。

2、配置日志

可以看到，只要集成了spring-boot-starter-web，就引入了spring-boot-starter-logging，即slf4j和logback。

其它的幾個包：jcl-over-slf4j，代碼直接調用common-logging會被橋接到slf4j；jul-to-slf4j，代碼直接調用java.util.logging會被橋接到slf4j；log4j-over-slf4j，代碼直接調用log4j會被橋接到slf4j。

還需引入janino，如果不加入這個包會報錯。

在resources下添加logback.xml配置文件，Logback默認會查找classpath下的logback.xml文件。

具體配置如下，有較詳細的注釋，很容易看懂。可以通過application.properties配置日志記錄級別、日志輸出文件目錄等。

<?xml version="1.0" encoding="UTF-8"?>

<!-- 級別從高到低 OFF 、 FATAL 、 ERROR 、 WARN 、 INFO 、 DEBUG 、 TRACE 、 ALL -->
<!-- 日志輸出規則 根據當前ROOT 級別，日志輸出時，級別高於root默認的級別時 會輸出 -->
<!-- 以下 每個配置的 filter 是過濾掉輸出文件里面，會出現高級別文件，依然出現低級別的日志信息，通過filter 過濾只記錄本級別的日志 -->
<!-- scan 當此屬性設置為true時，配置文件如果發生改變，將會被重新加載，默認值為true。 -->
<!-- scanPeriod 設置監測配置文件是否有修改的時間間隔，如果沒有給出時間單位，默認單位是毫秒。當scan為true時，此屬性生效。默認的時間間隔為1分鍾。 -->
<!-- debug 當此屬性設置為true時，將打印出logback內部日志信息，實時查看logback運行狀態。默認值為false。 -->
<configuration debug="false" scan="false" scanPeriod="5 minutes">

    <!-- 引入配置文件 -->
    <property resource="application.properties"/>
    <property resource="application-${app.env:-dev}.properties"/>

    <property name="app.name" value="${app.name:-sunny}"/>
    <property name="app.env" value="${app.env:-dev}"/>

    <!-- 日志記錄級別 -->
    <property name="logback_level" value="${logback.level:-DEBUG}"/>
    <!-- 是否輸出日志到文件 -->
    <property name="logback_rolling" value="${logback.rolling:-false}"/>
    <!-- 設置日志輸出目錄 -->
    <property name="logback_rolling_path" value="${logback.rolling.path:-/data/logs}"/>
    <!-- 日志文件最大大小 -->
    <property name="logback_max_file_size" value="${logback.max_file_size:-10MB}"/>
    <!-- 格式化輸出：%d：表示日期，%thread：表示線程名，%-5level：級別從左顯示5個字符寬度，%logger：日志輸出者的名字(通常是所在類的全名)，%L：輸出代碼中的行號，%msg：日志消息，%n：換行符 -->
    <property name="logback_pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger %L -| %msg%n"/>


    <if condition='p("logback_rolling").equals("true")'>
        <then>
            <!-- 滾動記錄文件 -->
            <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
                <file>${logback_rolling_path}/${app.name}.log</file>
                <!-- rollingPolicy：當發生滾動時，決定RollingFileAppender的行為，涉及文件移動和重命名 -->
                <!-- TimeBasedRollingPolicy：最常用的滾動策略，它根據時間來制定滾動策略 -->
                <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                    <!-- 活動文件的名字會根據fileNamePattern的值，每隔一段時間改變一次 -->
                    <fileNamePattern>${logback_rolling_path}/${app.name}.%d{yyyy-MM-dd}.%i.log</fileNamePattern>

                    <!-- 日志文件的保存期限為30天 -->
                    <maxHistory>30</maxHistory>

                    <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                        <!-- maxFileSize:這是活動文件的大小，默認值是10MB -->
                        <maxFileSize>${logback_max_file_size}</maxFileSize>
                    </timeBasedFileNamingAndTriggeringPolicy>
                </rollingPolicy>
                <encoder>
                    <pattern>${logback_pattern}</pattern>
                    <charset>UTF-8</charset>
                </encoder>
            </appender>

            <root>
                <appender-ref ref="FILE"/>
            </root>
        </then>
    </if>


    <!-- 將日志打印到控制台 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${logback_pattern}</pattern>
        </encoder>
    </appender>

    <root level="${logback_level}">
        <appender-ref ref="CONSOLE"/>
    </root>

    <contextName>${app.name}</contextName>

</configuration>

加入配置文件后，就可以看到控制台格式化后的日志輸出，還可以看到具體代碼行數等，比之前的友好多了。

同時，將日志滾動輸出到日志文件，保留歷史記錄。可通過logback.rolling=false控制是否需要輸出日志到文件。

3、使用Logger

配置好之后，就可以使用Logger來輸出日志了，使用起來也是非常方便。

* 可以看到引入的包是slf4j.Logger，代碼里並沒有引用任何一個跟 Logback 相關的類，這便是使用 Slf4j的好處，在需要將日志框架切換為其它日志框架時，無需改動已有的代碼。

* LoggerFactory 的 getLogger() 方法接收一個參數，以這個參數決定 logger 的名字，比如第二圖中的日志輸出。在為 logger 命名時，用類的全限定類名作為 logger name 是最好的策略，這樣能夠追蹤到每一條日志消息的來源

* 可以看到，可以通過提供占位符，以參數化的方式打印日志，避免字符串拼接的不必要損耗，也無需通過logger.isDebugEnabled()這種方式判斷是否需要打印。

4、全局異常處理

現在有一個問題，當日志級別設置到INFO級別后，只會輸出INFO以上的日志，如INFO、WARN、ERROR，這沒毛病，問題是，程序中拋出的異常堆棧(運行時異常)都沒有打印了，不利於排查問題。

而且，在某些情況下，我們在Service中想直接把異常往Controller拋出不做處理，但我們不能直接把異常信息輸出到客戶端，這是非常不友好的。

所以，在config下建一個GlobalExceptionConfig作為全局統一異常處理。主要處理了自定義的ServiceException、AuthorityException、BaseException，以及系統的NoHandlerFoundException和Exception異常。

package com.lyyzoo.core.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.NoHandlerFoundException;

import com.lyyzoo.core.base.Result;
import com.lyyzoo.core.constants.BaseEnums;
import com.lyyzoo.core.exception.AuthorityException;
import com.lyyzoo.core.exception.BaseException;
import com.lyyzoo.core.exception.ServiceException;
import com.lyyzoo.core.util.Results;

/**
 * 全局異常處理
 *
 * @author bojiangzhou 2018-02-06
 * @version 1.0
 */
@RestControllerAdvice
public class GlobalExceptionConfig {

    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionConfig.class);

    /**
     * 處理 ServiceException 異常
     */
    @ExceptionHandler(ServiceException.class)
    public Result handleServiceException(ServiceException e){
        Result result = Results.failure(e.getCode(), e.getMessage());
        result.setStatus(HttpStatus.BAD_REQUEST.value());
        logger.info("ServiceException[code: {}, message: {}]", e.getCode(), e.getMessage());
        return result;
    }

    /**
     * 處理 AuthorityException 異常
     */
    @ExceptionHandler(AuthorityException.class)
    public Result handleAuthorityException(AuthorityException e){
        Result result = Results.failure(BaseEnums.FORBIDDEN.code(), BaseEnums.FORBIDDEN.desc());
        result.setStatus(HttpStatus.FORBIDDEN.value());
        logger.info("AuthorityException[code: {}, message: {}]", e.getCode(), e.getMessage());
        return result;
    }

    /**
     * 處理 NoHandlerFoundException 異常. <br/>
     * 需配置 [spring.mvc.throw-exception-if-no-handler-found=true]
     * 需配置 [spring.resources.add-mappings=false]
     */
    @ExceptionHandler(NoHandlerFoundException.class)
    public Result handleNotFoundException(NoHandlerFoundException e){
        Result result = Results.failure(BaseEnums.NOT_FOUND.code(), BaseEnums.NOT_FOUND.desc());
        result.setStatus(HttpStatus.NOT_FOUND.value());
        logger.info(e.getMessage());
        return result;
    }

    /**
     * 處理 BaseException 異常
     */
    @ExceptionHandler(BaseException.class)
    public Result handleBaseException(BaseException e){
        Result result = Results.failure(e.getCode(), e.getMessage());
        result.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
        logger.error("BaseException[code: {}, message: {}]", e.getCode(), e.getMessage(), e);
        return result;
    }

    /**
     * 處理 Exception 異常
     */
    @ExceptionHandler(Exception.class)
    public Result handleException(Exception e){
        Result result = Results.failure(BaseEnums.ERROR.code(), BaseEnums.ERROR.desc());
        result.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
        logger.error(e.getMessage(), e);
        return result;
    }

}

看上面的代碼，@ControllAdvice(@RestControllerAdvice可以返回ResponseBody)，可看做Controller增強器，可以在@ControllerAdvice作用類下添加@ExceptionHandler，@InitBinder，@ModelAttribute注解的方法來增強Controller，都會作用在被 @RequestMapping 注解的方法上。

使用@ExceptionHandler 攔截異常，我們可以通過該注解實現自定義異常處理。在每個處理方法中，封裝Result，返回對應的消息及狀態碼等。

通過Logger打印對應級別的日志，也可以看到控制台及日志文件中有異常堆棧的輸出了。注意除了BaseException、Exception，其它的都只是打印了簡單信息，且為INFO級別。Exception是ERROR級別，且打印了堆棧信息。

NoHandlerFoundException 是404異常，這里注意要先關閉DispatcherServlet的NotFound默認異常處理。

測試如下：這種返回結果就比較友好了。

   

 

五、數據庫樂觀鎖

1、樂觀鎖

在並發修改同一條記錄時，為避免更新丟失，需要加鎖。要么在應用層加鎖，要么在緩存層加鎖，要么在數據庫層使用樂觀鎖，使用version作為更新依據【強制】。 —— 《阿里巴巴Java開發手冊》

樂觀鎖，基於數據版本(version)記錄機制實現，為數據庫表增加一個"version"字段。讀取出數據時，將此版本號一同讀出，之后更新時，對此版本號加一。提交數據時，提交的版本數據與數據庫表對應記錄的當前版本信息進行比對，如果提交的數據版本號大於數據庫表當前版本號，則予以更新，否則認為是過期數據。

因此，這節就來處理BaseDTO中的"version"字段，通過增加一個mybatis插件來實現更新時版本號自動+1。

2、MyBatis插件介紹

MyBatis 允許在己映射語句執行過程中的某一點進行攔截調用。默認情況下， MyBatis 允許使用插件來攔截的接口和方法包括以下幾個：

• Executor (update 、query 、flushStatements 、commit 、rollback 、getTransaction 、close 、isClosed)

• ParameterHandler (getParameterObject 、setParameters)

• ResultSetHandler (handleResul tSets 、handleCursorResultSets、handleOutputParameters)

• StatementHandler (prepare 、parameterize 、batch update 、query)
  

MyBatis 插件實現攔截器接口Interceptor，在實現類中對攔截對象和方法進行處理 。

• setProperties：傳遞插件的參數，可以通過參數來改變插件的行為。

• plugin：參數 target 就是要攔截的對象，作用就是給被攔截對象生成一個代理對象，並返回。

• intercept：會覆蓋所攔截對象的原方法，Invocation參數可以反射調度原來對象的方法，可以獲取到很多有用的東西。

除了需要實現攔截器接口外，還需要給實現類配置攔截器簽名。 使用 @Intercepts 和 @Signature 這兩個注解來配置攔截器要攔截的接口的方法，接口方法對應的簽名基本都是固定的。

@Intercepts 注解的屬性是一個 ＠Signature  數組，可以在同 一個攔截器中同時攔截不同的接口和方法。

@Signature 注解包含以下三個屬性。

• type：設置攔截的接口，可選值是前面提到的4個接口 。

• method：設置攔截接口中的方法名， 可選值是前面4個接口對應的方法，需要和接口匹配 。

• args：設置攔截方法的參數類型數組，通過方法名和參數類型可以確定唯一一個方法 。
  

3、數據版本插件

要實現版本號自動更新，我們需要在SQL被執行前修改SQL，因此我們需要攔截的就是 StatementHandler  接口的 prepare 方法，該方法會在數據庫執行前被調用，優先於當前接口的其它方法而被執行。

在 core.plugin 包下新建一個VersionPlugin插件，實現Interceptor攔截器接口。

該接口方法簽名如下：

在 interceptor 方法中對 UPDATE 類型的操作，修改原SQL，加入version，修改后的SQL類似下圖，更新時就會自動將version+1。同時帶上version條件，如果該版本號小於數據庫記錄版本號，則不會更新。

VersionInterceptor插件：

package com.lyyzoo.core.plugins;

import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.operators.arithmetic.Addition;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.statement.Statement;
import net.sf.jsqlparser.statement.update.Update;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.util.List;
import java.util.Properties;

/**
 * 樂觀鎖：數據版本插件
 *
 * @version 1.0
 * @author bojiangzhou 2018-02-10
 */
@Intercepts(
    @Signature(
        type = StatementHandler.class,
        method = "prepare",
        args = {Connection.class, Integer.class}
    )
)
public class VersionInterceptor implements Interceptor {

    private static final String VERSION_COLUMN_NAME = "version";

    private static final Logger logger = LoggerFactory.getLogger(VersionInterceptor.class);

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 獲取 StatementHandler，實際是 RoutingStatementHandler
        StatementHandler handler = (StatementHandler) processTarget(invocation.getTarget());
        // 包裝原始對象，便於獲取和設置屬性
        MetaObject metaObject = SystemMetaObject.forObject(handler);
        // MappedStatement 是對SQL更高層次的一個封裝，這個對象包含了執行SQL所需的各種配置信息
        MappedStatement ms = (MappedStatement) metaObject.getValue("delegate.mappedStatement");
        // SQL類型
        SqlCommandType sqlType = ms.getSqlCommandType();
        if(sqlType != SqlCommandType.UPDATE) {
            return invocation.proceed();
        }
        // 獲取版本號
        Object originalVersion = metaObject.getValue("delegate.boundSql.parameterObject." + VERSION_COLUMN_NAME);
        if(originalVersion == null || Long.valueOf(originalVersion.toString()) <= 0){
            return invocation.proceed();
        }
        // 獲取綁定的SQL
        BoundSql boundSql = (BoundSql) metaObject.getValue("delegate.boundSql");
        // 原始SQL
        String originalSql = boundSql.getSql();
        // 加入version的SQL
        originalSql = addVersionToSql(originalSql, originalVersion);
        // 修改 BoundSql
        metaObject.setValue("delegate.boundSql.sql", originalSql);

        // proceed() 可以執行被攔截對象真正的方法，該方法實際上執行了method.invoke(target, args)方法
        return invocation.proceed();
    }

    /**
     * Plugin.wrap 方法會自動判斷攔截器的簽名和被攔截對象的接口是否匹配，只有匹配的情況下才會使用動態代理攔截目標對象.
     *
     * @param target 被攔截的對象
     * @return 代理對象
     */
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    /**
     * 設置參數
     */
    @Override
    public void setProperties(Properties properties) {

    }

    /**
     * 獲取代理的原始對象
     *
     * @param target
     * @return
     */
    private static Object processTarget(Object target) {
        if(Proxy.isProxyClass(target.getClass())) {
            MetaObject mo = SystemMetaObject.forObject(target);
            return processTarget(mo.getValue("h.target"));
        }
        return target;
    }

    /**
     * 為原SQL添加version
     *
     * @param originalSql 原SQL
     * @param originalVersion 原版本號
     * @return 加入version的SQL
     */
    private String addVersionToSql(String originalSql, Object originalVersion){
        try{
            Statement stmt = CCJSqlParserUtil.parse(originalSql);
            if(!(stmt instanceof Update)){
                return originalSql;
            }
            Update update = (Update)stmt;
            if(!contains(update)){
                buildVersionExpression(update);
            }
            Expression where = update.getWhere();
            if(where != null){
                AndExpression and = new AndExpression(where, buildVersionEquals(originalVersion));
                update.setWhere(and);
            }else{
                update.setWhere(buildVersionEquals(originalVersion));
            }
            return stmt.toString();
        }catch(Exception e){
            logger.error(e.getMessage(), e);
            return originalSql;
        }
    }

    private boolean contains(Update update){
        List<Column> columns = update.getColumns();
        for(Column column : columns){
            if(column.getColumnName().equalsIgnoreCase(VERSION_COLUMN_NAME)){
                return true;
            }
        }
        return false;
    }

    private void buildVersionExpression(Update update){
        // 列 version
        Column versionColumn = new Column();
        versionColumn.setColumnName(VERSION_COLUMN_NAME);
        update.getColumns().add(versionColumn);

        // 值 version+1
        Addition add = new Addition();
        add.setLeftExpression(versionColumn);
        add.setRightExpression(new LongValue(1));
        update.getExpressions().add(add);
    }

    private Expression buildVersionEquals(Object originalVersion){
        Column column = new Column();
        column.setColumnName(VERSION_COLUMN_NAME);

        // 條件 version = originalVersion
        EqualsTo equal = new EqualsTo();
        equal.setLeftExpression(column);
        equal.setRightExpression(new LongValue(originalVersion.toString()));
        return equal;
    }

}

之后還需配置該插件，只需要在MyBatisConfig中加入該配置即可。

最后，如果版本不匹配，更新失敗，需要往外拋出異常提醒，所以修改BaseService的update方法，增加檢查更新是否失敗。

最后，能不用插件盡量不要用插件，因為它將修改MyBatis的底層設計。插件生成的是層層代理對象的責任鏈模式，通過反射方法運行，會有一定的性能消耗。

我們也可以修改 tk.mapper 生成SQL的方法，加入version，這里通過插件方式實現樂觀鎖主要是不為了去修改 mapper 的底層源碼，比較方便。

 

六、Druid數據庫連接池

創建數據庫連接是一個很耗時的操作，也很容易對數據庫造成安全隱患。對數據庫連接的管理能顯著影響到整個應用程序的伸縮性和健壯性，影響程序的性能指標。

數據庫連接池負責分配、管理和釋放數據庫連接，它允許應用程序重復使用一個現有的數據庫連接，而不是再重新建立一個；釋放空閑時間超過最大空閑時間的數據庫連接來避免因為沒有釋放數據庫連接而引起的數據庫連接遺漏。數據庫連接池能明顯提高對數據庫操作的性能。

參考：

　　Druid常見問題集錦

　　常用數據庫連接池 (DBCP、c3p0、Druid) 配置說明

1、Druid

Druid首先是一個數據庫連接池，但它不僅僅是一個數據庫連接池，它還包含一個ProxyDriver，一系列內置的JDBC組件庫，一個SQLParser。Druid支持所有JDBC兼容的數據庫，包括Oracle、MySql、Derby、Postgresql、SQLServer、H2等等。 Druid針對Oracle和MySql做了特別優化，比如Oracle的PSCache內存占用優化，MySql的ping檢測優化。Druid在監控、可擴展性、穩定性和性能方面都有明顯的優勢。Druid提供了Filter-Chain模式的擴展API，可以自己編寫Filter攔截JDBC中的任何方法，可以在上面做任何事情，比如說性能監控、SQL審計、用戶名密碼加密、日志等等。

2、配置

Druid配置到core模塊下，只需在application.properties中添加如下配置即可，大部分配置是默認配置，可更改。有詳細的注釋，比較容易理解。

####################################
# Druid
####################################
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

# 初始化連接大小[0]
spring.datasource.druid.initial-size=1
# 最小空閑連接數[0]
spring.datasource.druid.min-idle=1
# 最大連接數[8]
spring.datasource.druid.max-active=20

# 配置獲取連接等待超時的時間(毫秒)[-1]
spring.datasource.druid.max-wait=60000
# 查詢超時時間(秒)
spring.datasource.druid.query-timeout=90

# 用來檢測連接是否有效的sql，要求是一個查詢語句
spring.datasource.druid.validation-query=SELECT 'x'
# 申請連接時檢測連接可用性[false]
spring.datasource.druid.test-on-borrow=false
# 歸還連接檢測[false]
spring.datasource.druid.test-on-return=false
# 超時是否檢測連接可用性[true]
spring.datasource.druid.test-while-idle=true

# 配置間隔多久才進行一次檢測，檢測需要關閉的空閑連接 (毫秒)
spring.datasource.druid.time-between-eviction-runs-millis=60000
#  配置一個連接在池中最小生存的時間(毫秒，默認30分鍾)
spring.datasource.druid.min-evictable-idle-time-millis=300000
# 通過別名的方式配置擴展插件，常用的插件有：監控統計用的filter:stat；日志用的filter:log4j；防御sql注入的filter:wall
spring.datasource.druid.filters=stat,wall,slf4j
# 合並多個DruidDataSource的監控數據
spring.datasource.druid.use-global-data-source-stat=true

# 是否緩存PreparedStatement. PSCache對支持游標的數據庫性能提升巨大，比如說oracle.在mysql下建議關閉.
spring.datasource.druid.pool-prepared-statements=false
# 每個連接上PSCache的大小
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20

# StatViewServlet [https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE_StatViewServlet%E9%85%8D%E7%BD%AE]
spring.datasource.druid.stat-view-servlet.enabled=true
spring.datasource.druid.stat-view-servlet.url-pattern=/druid/*
# 監控頁面的用戶名和密碼
spring.datasource.druid.stat-view-servlet.login-username=admin
spring.datasource.druid.stat-view-servlet.login-password=admin
spring.datasource.druid.stat-view-servlet.reset-enable=false

# StatFilter [https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE_StatFilter]
spring.datasource.druid.filter.stat.db-type=mysql
#慢SQL記錄
spring.datasource.druid.filter.stat.log-slow-sql=true
spring.datasource.druid.filter.stat.slow-sql-millis=2000
# SQL合並
spring.datasource.druid.filter.stat.merge-sql=false

# WallFilter [https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE-wallfilter]
spring.datasource.druid.filter.wall.enabled=true
spring.datasource.druid.filter.wall.db-type=mysql
spring.datasource.druid.filter.wall.config.delete-allow=false
spring.datasource.druid.filter.wall.config.drop-table-allow=false

之后啟動項目在地址欄輸入/druid/index.html並登錄就可以看到Druid監控頁面：

 

七、Redis緩存

對於如今的一個中小型系統來說，至少也需要一個緩存來緩存熱點數據，加快數據的訪問數據，這里選用Redis做緩存數據庫。在以后可以使用Redis做分布式緩存、做Session共享等。

1、SpringBoot的緩存支持

Spring定義了org.springframework.cache.CacheManager和org.springframework.cache.Cache接口來統一不同的緩存技術。CacheManager是Spring提供的各種緩存技術抽象接口，Cache接口包含緩存的各種操作。

針對不同的緩存技術，需要實現不同的CacheManager，Redis緩存則提供了RedisCacheManager的實現。

我將redis緩存功能放到sunny-starter-cache模塊下，cache模塊下可以有多種緩存技術，同時，對於其它項目來說，緩存是可插拔的，想用緩存直接引入cache模塊即可。

首先引入Redis的依賴：

SpringBoot已經默認為我們自動配置了多個CacheManager的實現，在autoconfigure.cache包下。在Spring Boot 環境下，使用緩存技術只需在項目中導入相關的依賴包即可。

在 RedisCacheConfiguration 里配置了默認的 CacheManager；SpringBoot提供了默認的redis配置，RedisAutoConfiguration 是Redis的自動化配置，比如創建連接池、初始化RedisTemplate等。

2、Redis 配置及聲明式緩存支持

Redis 默認配置了 RedisTemplate 和 StringRedisTemplate ，其使用的序列化規則是 JdkSerializationRedisSerializer，緩存到redis后，數據都變成了下面這種樣式，非常不易於閱讀。

因此，重新配置RedisTemplate，使用 Jackson2JsonRedisSerializer 來序列化 Key 和 Value。同時，增加HashOperations、ValueOperations等Redis數據結構相關的操作，這樣比較方便使用。

package com.lyyzoo.cache.redis;  2 
import org.springframework.beans.factory.annotation.Autowired;  4 import org.springframework.cache.annotation.EnableCaching;  5 import org.springframework.context.annotation.Bean;  6 import org.springframework.context.annotation.Configuration;  7 import org.springframework.data.redis.cache.RedisCacheManager;  8 import org.springframework.data.redis.connection.RedisConnectionFactory;  9 import org.springframework.data.redis.core.*; 10 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer; 11 import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder; 12 
import com.fasterxml.jackson.annotation.JsonAutoDetect; 14 import com.fasterxml.jackson.annotation.PropertyAccessor; 15 import com.fasterxml.jackson.databind.ObjectMapper; 16 
/**
 * Redis配置. 19  * 20  * 使用@EnableCaching開啟聲明式緩存支持. 之后就可以使用 @Cacheable/@CachePut/@CacheEvict 注解緩存數據. 21  * 22  * @author bojiangzhou 2018-02-11 23  * @version 1.0 24  */
@Configuration 26 @EnableCaching 27 public class RedisConfig { 28  @Autowired 29     private RedisConnectionFactory redisConnectionFactory; 30  @Autowired 31     private Jackson2ObjectMapperBuilder jackson2ObjectMapperBuilder; 32 
    /**
 * 覆蓋默認配置 RedisTemplate，使用 String 類型作為key，設置key/value的序列化規則 35      */
 @Bean 37     @SuppressWarnings("unchecked") 38     public RedisTemplate<String, Object> redisTemplate() { 39         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>(); 40  redisTemplate.setConnectionFactory(redisConnectionFactory); 41 
        // 使用 Jackson2JsonRedisSerialize 替換默認序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class); 44         ObjectMapper objectMapper = jackson2ObjectMapperBuilder.createXmlMapper(false).build(); 45  objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); 46  objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); 47  jackson2JsonRedisSerializer.setObjectMapper(objectMapper); 48 
        // 設置value的序列化規則和key的序列化規則
 redisTemplate.setKeySerializer(jackson2JsonRedisSerializer); 51  redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); 52  redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer); 53  redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer); 54  redisTemplate.afterPropertiesSet(); 55 
        return redisTemplate; 57  } 58 
 @Bean 60     public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) { 61         return redisTemplate.opsForHash(); 62  } 63 
 @Bean 65     public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) { 66         return redisTemplate.opsForValue(); 67  } 68 
 @Bean 70     public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) { 71         return redisTemplate.opsForList(); 72  } 73 
 @Bean 75     public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) { 76         return redisTemplate.opsForSet(); 77  } 78 
 @Bean 80     public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) { 81         return redisTemplate.opsForZSet(); 82  } 83 
 @Bean 85     public RedisCacheManager cacheManager() { 86         RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate()); 87         cacheManager.setUsePrefix(true); 88         return cacheManager; 89  } 90 
}

同時，使用@EnableCaching開啟聲明式緩存支持，這樣就可以使用基於注解的緩存技術。注解緩存是一個對緩存使用的抽象，通過在代碼中添加下面的一些注解，達到緩存的效果。

• @Cacheable：在方法執行前Spring先查看緩存中是否有數據，如果有數據，則直接返回緩存數據；沒有則調用方法並將方法返回值放進緩存。

• @CachePut：將方法的返回值放到緩存中。

• @CacheEvict：刪除緩存中的數據。

 

Redis服務器相關的一些配置可在application.properties中進行配置：

3、Redis工具類

添加一個Redis的統一操作工具，主要是對redis的常用數據類型操作類做了一個歸集。

ValueOperations用於操作String類型，HashOperations用於操作hash數據，ListOperations操作List集合，SetOperations操作Set集合，ZSetOperations操作有序集合。

關於redis的key命令和數據類型可參考我的學習筆記：

Redis 學習(一) —— 安裝、通用key操作命令

Redis 學習(二) —— 數據類型及操作

package com.lyyzoo.cache.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.Date;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Redis 操作工具
 *
 * @version 1.0
 * @author bojiangzhou 2018-02-12
 */
@Component
public class RedisOperator {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private ValueOperations<String, String> valueOperator;
    @Autowired
    private HashOperations<String, String, Object> hashOperator;
    @Autowired
    private ListOperations<String, Object> listOperator;
    @Autowired
    private SetOperations<String, Object> setOperator;
    @Autowired
    private ZSetOperations<String, Object> zSetOperator;

    /**
     * 默認過期時長，單位：秒
     */
    public final static long DEFAULT_EXPIRE = 60 * 60 * 24;

    /** 不設置過期時長 */
    public final static long NOT_EXPIRE = -1;

    /**
     * Redis的根操作路徑
     */
    @Value("${redis.root:sunny}")
    private String category;

    public RedisOperator setCategory(String category) {
        this.category = category;
        return this;
    }

    /**
     * 獲取Key的全路徑
     * 
     * @param key key
     * @return full key
     */
    public String getFullKey(String key) {
        return this.category + ":" + key;
    }


    //
    // key
    // ------------------------------------------------------------------------------
    /**
     * 判斷key是否存在
     *
     * <p>
     * <i>exists key</i>
     *
     * @param key key
     */
    public boolean existsKey(String key) {
        return redisTemplate.hasKey(getFullKey(key));
    }

    /**
     * 判斷key存儲的值類型
     *
     * <p>
     * <i>type key</i>
     *
     * @param key key
     * @return DataType[string、list、set、zset、hash]
     */
    public DataType typeKey(String key){
        return redisTemplate.type(getFullKey(key));
    }

    /**
     * 重命名key. 如果newKey已經存在，則newKey的原值被覆蓋
     *
     * <p>
     * <i>rename oldKey newKey</i>
     *
     * @param oldKey oldKeys
     * @param newKey newKey
     */
    public void renameKey(String oldKey, String newKey){
        redisTemplate.rename(getFullKey(oldKey), getFullKey(newKey));
    }

    /**
     * newKey不存在時才重命名.
     *
     * <p>
     * <i>renamenx oldKey newKey</i>
     *
     * @param oldKey oldKey
     * @param newKey newKey
     * @return 修改成功返回true
     */
    public boolean renameKeyNx(String oldKey, String newKey){
        return redisTemplate.renameIfAbsent(getFullKey(oldKey), getFullKey(newKey));
    }

    /**
     * 刪除key
     *
     * <p>
     * <i>del key</i>
     *
     * @param key key
     */
    public void deleteKey(String key){
        redisTemplate.delete(key);
    }

    /**
     * 刪除key
     *
     * <p>
     * <i>del key1 key2 ...</i>
     *
     * @param keys 可傳入多個key
     */
    public void deleteKey(String ... keys){
        Set<String> ks = Stream.of(keys).map(k -> getFullKey(k)).collect(Collectors.toSet());
        redisTemplate.delete(ks);
    }

    /**
     * 刪除key
     *
     * <p>
     * <i>del key1 key2 ...</i>
     *
     * @param keys key集合
     */
    public void deleteKey(Collection<String> keys){
        Set<String> ks = keys.stream().map(k -> getFullKey(k)).collect(Collectors.toSet());
        redisTemplate.delete(ks);
    }

    /**
     * 設置key的生命周期，單位秒
     *
     * <p>
     * <i>expire key seconds</i><br>
     * <i>pexpire key milliseconds</i>
     *
     * @param key key
     * @param time 時間數
     * @param timeUnit TimeUnit 時間單位
     */
    public void expireKey(String key, long time, TimeUnit timeUnit){
        redisTemplate.expire(key, time, timeUnit);
    }

    /**
     * 設置key在指定的日期過期
     *
     * <p>
     * <i>expireat key timestamp</i>
     *
     * @param key key
     * @param date 指定日期
     */
    public void expireKeyAt(String key, Date date){
        redisTemplate.expireAt(key, date);
    }

    /**
     * 查詢key的生命周期
     *
     * <p>
     * <i>ttl key</i>
     *
     * @param key key
     * @param timeUnit TimeUnit 時間單位
     * @return 指定時間單位的時間數
     */
    public long getKeyExpire(String key, TimeUnit timeUnit){
        return redisTemplate.getExpire(key, timeUnit);
    }

    /**
     * 將key設置為永久有效
     *
     * <p>
     * <i>persist key</i>
     *
     * @param key key
     */
    public void persistKey(String key){
        redisTemplate.persist(key);
    }


    /**
     *
     * @return RedisTemplate
     */
    public RedisTemplate<String, Object> getRedisTemplate() {
        return redisTemplate;
    }

    /**
     *
     * @return ValueOperations
     */
    public ValueOperations<String, String> getValueOperator() {
        return valueOperator;
    }

    /**
     *
     * @return HashOperations
     */
    public HashOperations<String, String, Object> getHashOperator() {
        return hashOperator;
    }

    /**
     *
     * @return ListOperations
     */
    public ListOperations<String, Object> getListOperator() {
        return listOperator;
    }

    /**
     *
     * @return SetOperations
     */
    public SetOperations<String, Object> getSetOperator() {
        return setOperator;
    }

    /**
     *
     * @return ZSetOperations
     */
    public ZSetOperations<String, Object> getZSetOperator() {
        return zSetOperator;
    }

}

 

八、Swagger支持API文檔

1、Swagger

做前后端分離，前端和后端的唯一聯系，變成了API接口；API文檔變成了前后端開發人員聯系的紐帶，變得越來越重要，swagger就是一款讓你更好的書寫API文檔的框架。

Swagger是一個簡單又強大的能為你的Restful風格的Api生成文檔的工具。在項目中集成這個工具，根據我們自己的配置信息能夠自動為我們生成一個api文檔展示頁，可以在瀏覽器中直接訪問查看項目中的接口信息，同時也可以測試每個api接口。

2、配置

我這里直接使用別人已經整合好的swagger-spring-boot-starter，快速方便。

參考：spring-boot-starter-swagger

新建一個sunny-starter-swagger模塊，做到可插拔。

根據文檔，一般只需要做些簡單的配置即可：

但如果想要顯示swagger-ui.html文檔展示頁，還必須注入swagger資源：

package com.lyyzoo.swagger.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import com.spring4all.swagger.EnableSwagger2Doc;

/**
 * @version 1.0
 * @author bojiangzhou 2018-02-19
 */
@Configuration
@EnableSwagger2Doc
@PropertySource(value = "classpath:application-swagger.properties")
public class SunnySwaggerConfig extends WebMvcConfigurerAdapter {
    /**
     * 注入swagger資源文件
     */
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("swagger-ui.html")
                .addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**")
                .addResourceLocations("classpath:/META-INF/resources/webjars/");
    }

}

3、使用

一般只需要在Controller加上swagger的注解即可顯示對應的文檔信息，如@Api、@ApiOperation、@ApiParam等。

常用注解參考：swagger-api-annotations

package com.lyyzoo.admin.system.controller;  2 
import org.springframework.beans.factory.annotation.Autowired;  4 import org.springframework.web.bind.annotation.*;  5 
import com.lyyzoo.admin.system.dto.Menu;  7 import com.lyyzoo.admin.system.service.MenuService;  8 import com.lyyzoo.core.base.BaseController;  9 import com.lyyzoo.core.base.Result; 10 import com.lyyzoo.core.util.Results; 11 
import io.swagger.annotations.Api; 13 import io.swagger.annotations.ApiImplicitParam; 14 import io.swagger.annotations.ApiOperation; 15 import io.swagger.annotations.ApiParam; 16 
@Api(tags = "菜單管理") 18 @RequestMapping 19 @RestController 20 public class MenuController extends BaseController { 21 
 @Autowired 23     private MenuService service; 24 
    /**
 * 查找單個用戶 27  * 28  * @param menuId 菜單ID 29  * @return Result 30      */
    @ApiOperation("查找單個用戶") 32     @ApiImplicitParam(name = "menuId", value = "菜單ID", paramType = "path") 33     @GetMapping("/sys/menu/get/{menuId}") 34     public Result get(@PathVariable Long menuId){ 35         Menu menu = service.selectById(menuId); 36         return Results.successWithData(menu); 37  } 38 
    /**
 * 保存菜單 41  * 42  * @param menu 菜單 43  * @return Result 44      */
    @ApiOperation("保存菜單") 46     @PostMapping("/sys/menu/save") 47     public Result save(@ApiParam(name = "menu", value = "菜單")@RequestBody Menu menu){ 48         menu = service.save(menu); 49         return Results.successWithData(menu); 50  } 51 
    /**
 * 刪除菜單 54  * 55  * @param menuId 菜單ID 56  * @return Result 57      */
    @ApiOperation("刪除菜單") 59     @ApiImplicitParam(name = "menuId", value = "菜單ID", paramType = "path") 60     @PostMapping("/sys/menu/delete/{menuId}") 61     public Result delete(@PathVariable Long menuId){ 62  service.deleteById(menuId); 63         return Results.success(); 64  } 65 
}

之后訪問swagger-ui.html頁面就可以看到API文檔信息了。

如果不需要swagger，在配置文件中配置swagger.enabled=false，或移除sunny-starter-swagger的依賴即可。

 

九、項目優化調整

到這里，項目最基礎的一些功能就算完成了，但由於前期的一些設計不合理及未考慮周全等因素，對項目做一些調整。並參考《阿里巴巴Java開發手冊》對代碼做了一些優化。

1、項目結構

目前項目分為5個模塊：

最外層的Sunny作為聚合模塊負責管理所有子模塊，方便統一構建。並且繼承 spring-boot-starter-parent ，其它子模塊則繼承該模塊，方便統一管理 Spring Boot 及本項目的版本。這里已經把Spring Boot的版本升到 1.5.10.RELEASE。

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lyyzoo</groupId>
    <artifactId>sunny</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>

    <name>Sunny</name>
    <description>Lyyzoo Base Application development platform</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.10.RELEASE</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>

        <sunny.version>0.0.1-SNAPSHOT</sunny.version>
        <springboot.version>1.5.10.RELEASE</springboot.version>
    </properties>

    <modules>
        <module>sunny-starter</module>
        <module>sunny-starter-core</module>
        <module>sunny-starter-cache</module>
        <module>sunny-starter-security</module>
        <module>sunny-starter-admin</module>
        <module>sunny-starter-swagger</module>
    </modules>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

sunny-starter 則引入了其余幾個模塊，在開發項目時，只需要繼承或引入sunny-starter即可，而無需一個個引入各個模塊。

<?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">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.lyyzoo</groupId>
        <artifactId>sunny</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <groupId>com.lyyzoo.parent</groupId>
    <artifactId>sunny-starter</artifactId>
    <packaging>jar</packaging>

    <name>sunny-starter</name>
    <description>Sunny Parent</description>

    <dependencies>
        <!-- core -->
        <dependency>
            <groupId>com.lyyzoo.core</groupId>
            <artifactId>sunny-starter-core</artifactId>
            <version>${sunny.version}</version>
        </dependency>
        <!-- cache -->
        <dependency>
            <groupId>com.lyyzoo.cache</groupId>
            <artifactId>sunny-starter-cache</artifactId>
            <version>${sunny.version}</version>
        </dependency>
        <!-- security -->
        <dependency>
            <groupId>com.lyyzoo.security</groupId>
            <artifactId>sunny-starter-security</artifactId>
            <version>${sunny.version}</version>
        </dependency>
        <!-- admin -->
        <dependency>
            <groupId>com.lyyzoo.admin</groupId>
            <artifactId>sunny-starter-admin</artifactId>
            <version>${sunny.version}</version>
        </dependency>
        <!-- swagger -->
        <dependency>
            <groupId>com.lyyzoo.swagger</groupId>
            <artifactId>sunny-starter-swagger</artifactId>
            <version>${sunny.version}</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

對於一個Spring Boot項目，應該只有一個入口，即 @SpringBootApplication 注解的類。經測試，其它的模塊的配置文件application.properties的配置不會生效，應該是引用了入口模塊的配置文件。

所以為了讓各個模塊的配置文件都能生效，只需使用 @PropertySource 引入該配置文件即可，每個模塊都如此。在主模塊定義的配置會覆蓋其它模塊的配置。

2、開發規范

 

十、結語

到此，基礎架構篇結束！學習了很多新東西，如Spring Boot、Mapper、Druid；有些知識也深入地學習了，如MyBatis、Redis、日志框架、Maven等等。

在這期間，看完兩本書，可參考：《MyBatis從入門到精通》、《JavaEE開發的顛覆者 Spring Boot實戰》，另外，開發規范遵從《阿里巴巴Java開發手冊》，其它的參考資料都在文中有體現。

 

緊接着，后面會完成 sunny-starter-security 模塊的開發，主要使用spring-security技術，開發用戶登錄及權限控制等。

 

-----