Spring Boot 、 Mybatis 、 Redis快速搭建现代化Web项目

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

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

@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;
 }
}

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

# mybatis配置
mybatis:
 # 配置映射类所在包名
 type-aliases-package: com.wooyoo.learning.dao.domain
 # 配置mapper xml文件所在路径，这里是一个数组
 mapper-locations:
 - mappers/ProductMapper.xml

@Mapper
public interface ProductMapper {
 Product select(
   @Param("id")
     long id);
 void update(Product 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的代码
}

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

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;
 }
}

<?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>

---
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

@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);
 }
}