Spring Boot 集成 RedisTemplate

原创转载请注明出处：https://www.cnblogs.com/agilestyle/p/13199558.html

前置条件

Spring Boot 集成 TkMyBatis  整合完毕

Project Directory

Maven Dependency

...    
    <!--redis-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
...

application.properties

...    
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.database=0
spring.redis.password=
spring.redis.timeout=2000
spring.redis.pool.max-active=10
spring.redis.pool.max-wait=1000
spring.redis.pool.max-idle=10
spring.redis.pool.min-idle=5
spring.redis.pool.num-tests-per-eviction-run=1024
spring.redis.pool.time-between-eviction-runs-millis=30000
spring.redis.pool.min-evictable-idle-time-millis=60000
spring.redis.pool.soft-min-evictable-idle-time-millis=10000
spring.redis.pool.test-on-borrow=true
spring.redis.pool.test-while-idle=true
spring.redis.pool.block-when-exhausted=false
...

RedisTemplate CRUD

RedisConfiguration.java

package org.fool.redis.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfiguration {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

UserService.java

package org.fool.redis.service;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.fool.redis.mapper.UserMapper;
import org.fool.redis.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import tk.mybatis.mapper.entity.Example;

import java.util.Arrays;
import java.util.List;

@Service
@Slf4j
public class UserService {
    public static final String CACHE_KEY_USER = "user:";

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private RedisTemplate redisTemplate;

    public void createUser(User user) {
        userMapper.insertSelective(user);

        String key = CACHE_KEY_USER + user.getId();
        user = this.userMapper.selectByPrimaryKey(user.getId());
        redisTemplate.opsForValue().set(key, user);
    }

    public void updateUser(User user) {
        userMapper.updateByPrimaryKeySelective(user);

        String key = CACHE_KEY_USER + user.getId();
        user = this.userMapper.selectByPrimaryKey(user.getId());
        redisTemplate.opsForValue().set(key, user);
    }

    public User findUserById(Integer id) {
        ValueOperations<String, User> operations = redisTemplate.opsForValue();
        String key = CACHE_KEY_USER + id;
        User user = operations.get(key);

        if (user == null) {
            user = userMapper.selectByPrimaryKey(id);
            operations.set(key, user);
        }

        return user;
    }

    public void deleteUser(int id) {
        userMapper.deleteByPrimaryKey(id);
        String key = CACHE_KEY_USER + id;
        redisTemplate.delete(key);
    }

    public void findUser() {
        log.info("select by primary key: where id = 100");
        User result = userMapper.selectByPrimaryKey(100);
        log.info(result.toString());

        log.info("select by: where sex = 1");
        User user1 = new User();
        user1.setSex((byte) 1);
        List<User> resultList = userMapper.select(user1);
        log.info("sex=1 nums: {}", resultList.size());

        log.info("select by: where username = ? and password = ?");
        User user2 = new User();
        user2.setUsername("update100");
        user2.setPassword("update100");
        User user = userMapper.selectOne(user2);
        log.info("user: {}", user);
    }

    public void selectByExample() {
        log.info("select by example: where username = ? and password = ?");
        Example example = new Example(User.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("username", "update100");
        criteria.andEqualTo("password", "update100");
        List<User> resultList = userMapper.selectByExample(example);
        log.info("result list: {}", resultList);
    }

    public void selectByExampleAndLike() {
        log.info("select by example with andLike: where username like = ?");
        Example example = new Example(User.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andLike("username", "%update%");
        List<User> resultList = userMapper.selectByExample(example);
        log.info("result list: {}", resultList);
    }

    public void selectByExampleOrderBy() {
        log.info("select by example with order by: where username like = ? order by id desc");
        Example example = new Example(User.class);
        example.setOrderByClause("username desc");
        Example.Criteria criteria = example.createCriteria();
        criteria.andLike("username", "%user%");
        List<User> resultList = userMapper.selectByExample(example);
        log.info("result list: {}", resultList);
    }

    public void selectByExampleIn() {
        log.info("select by example with in: where id in (100, 101)");
        Example example = new Example(User.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andIn("id", Arrays.asList(100, 101));
        List<User> resultList = userMapper.selectByExample(example);
        log.info("result list: {}", resultList);
    }

    public void selectByPageInfo(int pageNo, int pageSize) {
        log.info("select by PageInfo: limit ?, ?");
        PageHelper.startPage(pageNo, pageSize);
        List<User> userList = userMapper.selectAll();
        PageInfo<User> pageInfo = new PageInfo<>(userList);
        long totalPage = pageInfo.getPages();
        long totalSize = pageInfo.getTotal();
        log.info("total page: {}, total size: {}, result list: {}", totalPage, totalSize, userList);
    }
}

Test

package org.fool.redis.test;

import org.fool.redis.Application;
import org.fool.redis.model.User;
import org.fool.redis.service.UserService;
import org.junit.Assert;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Random;

@SpringBootTest(classes = Application.class)
public class RedisTemplateTest {
    @Autowired
    private UserService userService;

    @Test
    public void testCreate() {
        User user = new User();
        user.setId(1001);
        user.setUsername("hello");
        user.setPassword("world");
        user.setSex((byte) new Random().nextInt(2));
        userService.createUser(user);
    }

    @Test
    public void testUpdate() {
        User user = new User();
        user.setId(1001);
        user.setPassword("helloworld");
        userService.updateUser(user);
    }

    @Test
    public void testSelect() {
        User result = userService.findUserById(1001);
        Assert.assertEquals("hello", result.getUsername());
    }

    @Test
    public void testDelete() {
        userService.deleteUser(1001);
    }
}