spring boot + mybatis + druid + redis

接上篇，使用redis做缓存

新建spring boot 工程，添加pom引用

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.2.4</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

User类

public class User {
    private Integer id;
    private String name;
    private Integer sex;
    private Integer age;

    public User(String name, Integer sex, Integer age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public User(Integer id, String name, Integer sex, Integer age) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public User() {
    }

    public Integer getId() {

        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getSex() {
        return sex;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

UserRepository接口

import org.apache.ibatis.annotations.*;

@Mapper
public interface UserRepository {
    @Select("select * from person where id=#{id}")
    User findById(@Param("id") Integer id);
    @Options(useGeneratedKeys = true,keyProperty = "id")
    @Insert("INSERT INTO person(name,sex,age) VALUES (#{name},#{sex},#{age})")
    int save(User user);
    @Update("UPDATE person SET name=#{name},sex=#{sex},age=#{age} WHERE id=#{id}")
    void update(User user);
    @Delete("DELETE FROM person WHERE id=#{id}")
    void delete(Integer id);
}

这里需要注意加上@Options(useGeneratedKeys = true,keyProperty = "id") 才能返回id

UserRedis

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.concurrent.TimeUnit;

@Repository
public class UserRedis {
    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    public void add(String key,Long time,User user){
        Gson gson=new Gson();
        redisTemplate.opsForValue().set(key,gson.toJson(user),time, TimeUnit.MINUTES);
    }

    public void add(String key, Long time, List<User> users){
        Gson gson=new Gson();
        redisTemplate.opsForValue().set(key,gson.toJson(users),time, TimeUnit.MINUTES);
    }

    public User get(String key){
        Gson gson=new Gson();
        User user=null;
        String userJson=redisTemplate.opsForValue().get(key);
        if(!StringUtils.isEmpty(userJson)){
            user=gson.fromJson(userJson,User.class);
        }
        return user;
    }

    public List<User> getList(String key){
        Gson gson=new Gson();
        List<User> users=null;
        String listJson=redisTemplate.opsForValue().get(key);
        if(!StringUtils.isEmpty(listJson)){
            users=gson.fromJson(listJson,new TypeToken<List<User>>(){}.getType());
        }
        return users;
    }

    public void delete(String key){
        redisTemplate.opsForValue().getOperations().delete(key);
    }
}

UserService

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private UserRedis userRedis;
    private static final String keyHead="mysql:get:user:";

    public User findById(Integer id){
        User user=userRedis.get(keyHead+id);
        if(user==null){
            user= userRepository.findById(id);
            if(user!=null){
                userRedis.add(keyHead+id,30L,user);
            }
        }
        return user;
    }

    public User create(User user){
        userRepository.save(user);
        if(user!=null){
            userRedis.add(keyHead+user.getId(),30L,user);
        }
        return user;
    }

    public User update(User user){
        if(user!=null){
            userRedis.delete(keyHead+user.getId());
            userRedis.add(keyHead+user.getId(),30L,user);
        }
        userRepository.update(user);
        return user;
    }

    public void delete(Integer id){
        userRedis.delete(keyHead+id);
        userRepository.delete(id);
    }
}

RedisConfig

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.core.RedisTemplate;

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    public CacheManager cacheManager(@SuppressWarnings("rawtypes")RedisTemplate redisTemplate) {
        RedisCacheManager manager=new RedisCacheManager(redisTemplate);
        manager.setDefaultExpiration(43200);
        return manager;
    }
}

UserController

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @Autowired
    private UserService userService;
    @RequestMapping(value = "/user/{id}")
    public String show(@PathVariable Integer id){
        User user=userService.findById(id);
        return user.getName();
    }
}

application.propeties配置

spring.datasource.url= jdbc:mysql://192.168.31.146:3306/mydb
spring.datasource.username= root
spring.datasource.password= pass

spring.redis.host=192.168.31.146
spring.redis.port=6379


spring.datasource.druid.url= jdbc:mysql://192.168.31.146:3306/mydb
spring.datasource.druid.username= root
spring.datasource.druid.password= pass

spring.datasource.druid.initial-size=5
spring.datasource.druid.max-active=20
spring.datasource.druid.min-idle=5
spring.datasource.druid.max-wait=60000
spring.datasource.druid.pool-prepared-statements=true
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20
#spring.datasource.druid.max-open-prepared-statements=
spring.datasource.druid.validation-query=select 1 from dual
#spring.datasource.druid.validation-query-timeout=
spring.datasource.druid.test-on-borrow=false
spring.datasource.druid.test-on-return=false
spring.datasource.druid.test-while-idle=true
spring.datasource.druid.time-between-eviction-runs-millis=60000
spring.datasource.druid.min-evictable-idle-time-millis=300000
#spring.datasource.druid.max-evictable-idle-time-millis=
#配置多个英文逗号分隔
spring.datasource.druid.filters=stat,wall,log4j

打开druid监控sql：http://localhost:8080/druid/sql.html

启动docker redis 镜像 ，配置6379端口映射

docker run -d -p 6379:6379 redis

打开RedisDesktopManager客户端查看数据

打开页面：http://localhost:8080/user/1

可以看到druid有了查询

redis中也有数据

 多次刷新页面，可以看到没有再去查数据库，druid监控中只有一条sql