Spring Boot + Mybatis + Redis二級快取開發指南

背景

Spring-Boot因其提供了各種開箱即用的外掛，使得它成為了當今最為主流的Java Web開發框架之一。Mybatis是一個十分輕量好用的ORM框架。Redis是當今十分主流的分散式key-value型資料庫，在web開發中，我們常用它來快取資料庫的查詢結果。

本篇部落格將介紹如何使用Spring-Boot快速搭建一個Web應用，並且採用Mybatis作為我們的ORM框架。為了提升效能，我們將Redis作為Mybatis的二級快取。為了測試我們的程式碼，我們編寫了單元測試，並且用H2記憶體資料庫來生成我們的測試資料。通過該專案，我們希望讀者可以快速掌握現代化Java Web開發的技巧以及最佳實踐。

本文的示例程式碼可在Github中下載：https://github.com/Lovelcp/spring-boot-mybatis-with-redis/tree/master

環境

• 開發環境：mac 10.11
• ide：Intellij 2017.1
• jdk：1.8
• Spring-Boot：1.5.3.RELEASE
• Redis：3.2.9
• Mysql：5.7

Spring-Boot

新建專案

首先，我們需要初始化我們的Spring-Boot工程。通過Intellij的Spring Initializer，新建一個Spring-Boot工程變得十分簡單。首先我們在Intellij中選擇New一個Project：

然後在選擇依賴的介面，勾選Web、Mybatis、Redis、Mysql、H2：

新建工程成功之後，我們可以看到專案的初始結構如下圖所示：

Spring Initializer已經幫我們自動生成了一個啟動類——SpringBootMybatisWithRedisApplication。該類的程式碼十分簡單：

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

@SpringBootApplication註解表示啟用Spring Boot的自動配置特性。好了，至此我們的專案骨架已經搭建成功，感興趣的讀者可以通過Intellij啟動看看效果。

新建API介面

接下來，我們要編寫Web API。假設我們的Web工程負責處理商家的產品（Product）。我們需要提供根據product id返回product資訊的get介面和更新product資訊的put介面。首先我們定義Product類，該類包括產品id，產品名稱name以及價格price：

public class Product implements Serializable {
    private static final long serialVersionUID = 1435515995276255188L;
    private long id;
    private String name;
    private long price;
    // getters setters
}

然後我們需要定義Controller類。由於Spring Boot內部使用Spring MVC作為它的Web元件，所以我們可以通過註解的方式快速開發我們的介面類：

@RestController
@RequestMapping("/product")
public class ProductController {
    @GetMapping("/{id}")
    public Product getProductInfo(
            @PathVariable("id")
                    Long productId) {
        // TODO
        return null;
    }
    @PutMapping("/{id}")
    public Product updateProductInfo(
            @PathVariable("id")
                    Long productId,
            @RequestBody
                    Product newProduct) {
        // TODO
        return null;
    }
}

我們簡單介紹一下上述程式碼中所用到的註解的作用：

• @RestController：表示該類為Controller，並且提供Rest介面，即所有介面的值以Json格式返回。該註解其實是@Controller和@ResponseBody的組合註解，便於我們開發REST API。
• @RequestMapping、@GetMapping、@PutMapping：表示介面的URL地址。標註在類上的@RequestMapping註解表示該類下的所有介面的URL都以/product開頭。@GetMapping表示這是一個Get HTTP介面，@PutMapping表示這是一個Put HTTP介面。
• @PathVariable、@RequestBody：表示引數的對映關係。假設有個Get請求訪問的是/product/123，那麼該請求會由getProductInfo方法處理，其中URL裡的123會被對映到productId中。同理，如果是Put請求的話，請求的body會被對映到newProduct物件中。

這裡我們只定義了介面，實際的處理邏輯還未完成，因為product的資訊都存在資料庫中。接下來我們將在專案中整合mybatis，並且與資料庫做互動。

整合Mybatis

配置資料來源

首先我們需要在配置檔案中配置我們的資料來源。我們採用mysql作為我們的資料庫。這裡我們採用yaml作為我們配置檔案的格式。我們在resources目錄下新建application.yml檔案：

spring:
  # 資料庫配置
  datasource:
    url: jdbc:mysql://{your_host}/{your_db}
    username: {your_username}
    password: {your_password}
    driver-class-name: org.gjt.mm.mysql.Driver

由於Spring Boot擁有自動配置的特性，我們不用新建一個DataSource的配置類，Sping Boot會自動載入配置檔案並且根據配置檔案的資訊建立資料庫的連線池，十分便捷。

筆者推薦大家採用yaml作為配置檔案的格式。xml顯得冗長，properties沒有層級結構，yaml剛好彌補了這兩者的缺點。這也是Spring Boot預設就支援yaml格式的原因。

配置Mybatis

我們已經通過Spring Initializer在pom.xml中引入了mybatis-spring-boot-starte庫，該庫會自動幫我們初始化mybatis。首先我們在application.yml中指定mybatis的配置檔案：

# mybatis配置
mybatis:
  config-location: classpath:mybatis-config.xml

然後我們在resources目錄下新建mybatis-config.xml檔案。在配置檔案中，我們需要指定Product類以及mapper檔案的路徑：

<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <package name="com.wooyoo.learning.dao.domain"/>
    </typeAliases>
    <mappers>
        <mapper resource="mappers/ProductMapper.xml"/>
    </mappers>
</configuration>

接下來，我們再在resourses目錄下新建mappers目錄，並且新建ProductMapper.xml檔案，編寫操作products表的SQL語句（該檔案的內容請參考筆者在前文貼的Github倉庫地址）。最後，再在程式碼中定義ProductMapper類：

@Mapper
public interface ProductMapper {
    Product select(
            @Param("id")
                    long id);
    void update(Product product);
}

Spring Boot之所以這麼流行，最大的原因是它自動配置的特性。開發者只需要關注元件的配置（比如資料庫的連線資訊），而無需關心如何初始化各個元件，這使得我們可以集中精力專注於業務的實現，簡化開發流程。

訪問資料庫

完成了Mybatis的配置之後，我們就可以在我們的介面中訪問資料庫了。我們在ProductController下通過@Autowired引入mapper類，並且呼叫對應的方法實現對product的查詢和更新操作，這裡我們以查詢介面為例：

@RestController
@RequestMapping("/product")
public class ProductController {
    @Autowired
    private ProductMapper productMapper;
    @GetMapping("/{id}")
    public Product getProductInfo(
            @PathVariable("id")
                    Long productId) {
        return productMapper.select(productId);
    }
    // 避免篇幅過長，省略updateProductInfo的程式碼
}

然後在你的mysql中插入幾條product的資訊，就可以執行該專案看看是否能夠查詢成功了。

至此，我們已經成功地在專案中整合了Mybatis，增添了與資料庫互動的能力。但是這還不夠，一個現代化的Web專案，肯定會上快取加速我們的資料庫查詢。接下來，將介紹如何科學地將Redis整合到Mybatis的二級快取中，實現資料庫查詢的自動快取。

整合Redis

配置Redis

同訪問資料庫一樣，我們需要配置Redis的連線資訊。在application.yml檔案中增加如下配置：

spring:
  redis:
    # redis資料庫索引（預設為0），我們使用索引為3的資料庫，避免和其他資料庫衝突
    database: 3
    # redis伺服器地址（預設為localhost）
    host: localhost
    # redis埠（預設為6379）
    port: 6379
    # redis訪問密碼（預設為空）
    password:
    # redis連線超時時間（單位為毫秒）
    timeout: 0
    # redis連線池配置
    pool:
      # 最大可用連線數（預設為8，負數表示無限）
      max-active: 8
      # 最大空閒連線數（預設為8，負數表示無限）
      max-idle: 8
      # 最小空閒連線數（預設為0，該值只有為正數才有作用）
      min-idle: 0
      # 從連線池中獲取連線最大等待時間（預設為-1，單位為毫秒，負數表示無限）
      max-wait: -1

上述列出的都為常用配置，讀者可以通過註釋資訊瞭解每個配置項的具體作用。由於我們在pom.xml中已經引入了spring-boot-starter-data-redis庫，所以Spring Boot會幫我們自動載入Redis的連線，具體的配置類org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration。通過該配置類，我們可以發現底層預設使用Jedis庫，並且提供了開箱即用的redisTemplate和stringTemplate。

將Redis作為二級快取

Mybatis的二級快取原理本文不再贅述，讀者只要知道，Mybatis的二級快取可以自動地對資料庫的查詢做快取，並且可以在更新資料時同時自動地更新快取。

實現Mybatis的二級快取很簡單，只需要新建一個類實現org.apache.ibatis.cache.Cache介面即可。

該介面共有以下五個方法：

• String getId()：mybatis快取操作物件的識別符號。一個mapper對應一個mybatis的快取操作物件。
• void putObject(Object key, Object value)：將查詢結果塞入快取。
• Object getObject(Object key)：從快取中獲取被快取的查詢結果。
• Object removeObject(Object key)：從快取中刪除對應的key、value。只有在回滾時觸發。一般我們也可以不用實現，具體使用方式請參考：org.apache.ibatis.cache.decorators.TransactionalCache。
• void clear()：發生更新時，清除快取。
• int getSize()：可選實現。返回快取的數量。
• ReadWriteLock getReadWriteLock()：可選實現。用於實現原子性的快取操作。

接下來，我們新建RedisCache類，實現Cache介面：

public class RedisCache implements Cache {
    private static final Logger logger = LoggerFactory.getLogger(RedisCache.class);
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private final String id; // cache instance id
    private RedisTemplate redisTemplate;
    private static final long EXPIRE_TIME_IN_MINUTES = 30; // redis過期時間
    public RedisCache(String id) {
        if (id == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        }
        this.id = id;
    }
    @Override
    public String getId() {
        return id;
    }
    /**
     * Put query result to redis
     *
     * @param key
     * @param value
     */
    @Override
    @SuppressWarnings("unchecked")
    public void putObject(Object key, Object value) {
        RedisTemplate redisTemplate = getRedisTemplate();
        ValueOperations opsForValue = redisTemplate.opsForValue();
        opsForValue.set(key, value, EXPIRE_TIME_IN_MINUTES, TimeUnit.MINUTES);
        logger.debug("Put query result to redis");
    }
    /**
     * Get cached query result from redis
     *
     * @param key
     * @return
     */
    @Override
    public Object getObject(Object key) {
        RedisTemplate redisTemplate = getRedisTemplate();
        ValueOperations opsForValue = redisTemplate.opsForValue();
        logger.debug("Get cached query result from redis");
        return opsForValue.get(key);
    }
    /**
     * Remove cached query result from redis
     *
     * @param key
     * @return
     */
    @Override
    @SuppressWarnings("unchecked")
    public Object removeObject(Object key) {
        RedisTemplate redisTemplate = getRedisTemplate();
        redisTemplate.delete(key);
        logger.debug("Remove cached query result from redis");
        return null;
    }
    /**
     * Clears this cache instance
     */
    @Override
    public void clear() {
        RedisTemplate redisTemplate = getRedisTemplate();
        redisTemplate.execute((RedisCallback) connection -> {
            connection.flushDb();
            return null;
        });
        logger.debug("Clear all the cached query result from redis");
    }
    @Override
    public int getSize() {
        return 0;
    }
    @Override
    public ReadWriteLock getReadWriteLock() {
        return readWriteLock;
    }
    private RedisTemplate getRedisTemplate() {
        if (redisTemplate == null) {
            redisTemplate = ApplicationContextHolder.getBean("redisTemplate");
        }
        return redisTemplate;
    }
}

講解一下上述程式碼中一些關鍵點：

1. 自己實現的二級快取，必須要有一個帶id的建構函式，否則會報錯。
2. 我們使用Spring封裝的redisTemplate來操作Redis。網上所有介紹redis做二級快取的文章都是直接用jedis庫，但是筆者認為這樣不夠Spring Style，而且，redisTemplate封裝了底層的實現，未來如果我們不用jedis了，我們可以直接更換底層的庫，而不用修改上層的程式碼。更方便的是，使用redisTemplate，我們不用關心redis連線的釋放問題，否則新手很容易忘記釋放連線而導致應用卡死。
3. 需要注意的是，這裡不能通過autowire的方式引用redisTemplate，因為RedisCache並不是Spring容器裡的bean。所以我們需要手動地去呼叫容器的getBean方法來拿到這個bean，具體的實現方式請參考Github中的程式碼。
4. 我們採用的redis序列化方式是預設的jdk序列化。所以資料庫的查詢物件（比如Product類）需要實現Serializable介面。

這樣，我們就實現了一個優雅的、科學的並且具有Spring Style的Redis快取類。

開啟二級快取

接下來，我們需要在ProductMapper.xml中開啟二級快取：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wooyoo.learning.dao.mapper.ProductMapper">
    <!-- 開啟基於redis的二級快取 -->
    <cache type="com.wooyoo.learning.util.RedisCache"/>
    <select id="select" resultType="Product">
        SELECT * FROM products WHERE id = #{id} LIMIT 1
    </select>
    <update id="update" parameterType="Product" flushCache="true">
        UPDATE products SET name = #{name}, price = #{price} WHERE id = #{id} LIMIT 1
    </update>
</mapper>

<cache type="com.wooyoo.learning.util.RedisCache"/>表示開啟基於redis的二級快取，並且在update語句中，我們設定flushCache為true，這樣在更新product資訊時，能夠自動失效快取（本質上呼叫的是clear方法）。

測試

配置H2記憶體資料庫

至此我們已經完成了所有程式碼的開發，接下來我們需要書寫單元測試程式碼來測試我們程式碼的質量。我們剛才開發的過程中採用的是mysql資料庫，而一般我們在測試時經常採用的是記憶體資料庫。這裡我們使用H2作為我們測試場景中使用的資料庫。

要使用H2也很簡單，只需要跟使用mysql時配置一下即可。在application.yml檔案中：

---
spring:
  profiles: test
  # 資料庫配置
  datasource:
    url: jdbc:h2:mem:test
    username: root
    password: 123456
    driver-class-name: org.h2.Driver
    schema: classpath:schema.sql
    data: classpath:data.sql

為了避免和預設的配置衝突，我們用---另起一段，並且用profiles: test表明這是test環境下的配置。然後只要在我們的測試類中加上@ActiveProfiles(profiles = "test")註解來啟用test環境下的配置，這樣就能一鍵從mysql資料庫切換到h2資料庫。

在上述配置中，schema.sql用於存放我們的建表語句，data.sql用於存放insert的資料。這樣當我們測試時，h2就會讀取這兩個檔案，初始化我們所需要的表結構以及資料，然後在測試結束時銷燬，不會對我們的mysql資料庫產生任何影響。這就是記憶體資料庫的好處。另外，別忘了在pom.xml中將h2的依賴的scope設定為test。

使用Spring Boot就是這麼簡單，無需修改任何程式碼，輕鬆完成資料庫在不同環境下的切換。

編寫測試程式碼

因為我們是通過Spring Initializer初始化的專案，所以已經有了一個測試類——SpringBootMybatisWithRedisApplicationTests。

Spring Boot提供了一些方便我們進行Web介面測試的工具類，比如TestRestTemplate。然後在配置檔案中我們將log等級調成DEBUG，方便觀察除錯日誌。具體的測試程式碼如下：

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ActiveProfiles(profiles = "test")
public class SpringBootMybatisWithRedisApplicationTests {
    @LocalServerPort
    private int port;
    @Autowired
    private TestRestTemplate restTemplate;
    @Test
    public void test() {
        long productId = 1;
        Product product = restTemplate.getForObject("http://localhost:" + port + "/product/" + productId, Product.class);
        assertThat(product.getPrice()).isEqualTo(200);
        Product newProduct = new Product();
        long newPrice = new Random().nextLong();
        newProduct.setName("new name");
        newProduct.setPrice(newPrice);
        restTemplate.put("http://localhost:" + port + "/product/" + productId, newProduct);
        Product testProduct = restTemplate.getForObject("http://localhost:" + port + "/product/" + productId, Product.class);
        assertThat(testProduct.getPrice()).isEqualTo(newPrice);
    }
}

在上述測試程式碼中：

1. 我們首先呼叫get介面，通過assert語句判斷是否得到了預期的物件。此時該product物件會存入redis中。
2. 然後我們呼叫put介面更新該product物件，此時redis快取會失效。
3. 最後我們再次呼叫get介面，判斷是否獲取到了新的product物件。如果獲取到老的物件，說明快取失效的程式碼執行失敗，程式碼存在錯誤，反之則說明我們程式碼是OK的。

書寫單元測試是一個良好的程式設計習慣。雖然會佔用你一定的時間，但是當你日後需要做一些重構工作時，你就會感激過去寫過單元測試的自己。

檢視測試結果

我們在Intellij中點選執行測試用例，測試結果如下：

真棒，顯示的是綠色，說明測試用例執行成功了。

總結

本篇文章介紹瞭如何通過Spring Boot、Mybatis以及Redis快速搭建一個現代化的Web專案，並且同時介紹瞭如何在Spring Boot下優雅地書寫單元測試來保證我們的程式碼質量。當然這個專案還存在一個問題，那就是mybatis的二級快取只能通過flush整個DB來實現快取失效，這個時候可能會把一些不需要失效的快取也給失效了，所以具有一定的侷限性。

希望通過本篇文章，能夠給讀者帶來一些收穫和啟發。有任何的意見或者建議請在本文下方評論。

參考資料

1. http://www.baeldung.com/spring-data-redis-tutorial
2. http://chrisbaileydeveloper.com/projects/spring-boot-redis-heroku-demo/
3. http://docs.spring.io/spring-data/redis/docs/1.6.2.RELEASE/reference/html/
4. http://blog.didispace.com/springbootredis/