springboot-redis实战

最新推荐文章于 2024-05-13 14:46:59 发布
最新推荐文章于 2024-05-13 14:46:59 发布
阅读量490 收藏
点赞数
分类专栏： 后端 文章标签： redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35911118/article/details/109504526
版权

redis:
host: 127.0.0.1
password:
port: 6379
database: 0
lettuce:
pool:
max-idle: 8
min-idle: 0
max-active: 8
max-wait: -1ms
timeout: 10000ms

package com.example.springbootdemo.config;

import com.example.springbootdemo.utils.RedisObjectSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import javax.annotation.Resource;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Set;

/**
*

  • @author rstyro
  • @time 2017-07-31

*/
@Configuration
@EnableCaching // 开启缓存支持
public class RedisConfig extends CachingConfigurerSupport {

@Resource
private LettuceConnectionFactory lettuceConnectionFactory;

@Bean
public KeyGenerator keyGenerator() {
    return new KeyGenerator() {
        @Override
        public Object generate(Object target, Method method, Object... params) {
            StringBuffer sb = new StringBuffer();
            sb.append(target.getClass().getName());
            sb.append(method.getName());
            for (Object obj : params) {
                sb.append(obj.toString());
            }
            return sb.toString();
        }
    };
}

// 缓存管理器
@Bean
public CacheManager cacheManager() {
    RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager.RedisCacheManagerBuilder
            .fromConnectionFactory(lettuceConnectionFactory);
    @SuppressWarnings("serial")
    Set<String> cacheNames = new HashSet<String>() {
        {
            add("codeNameCache");
        }
    };
    builder.initialCacheNames(cacheNames);
    return builder.build();
}

/**
 * RedisTemplate配置
 */
@Bean
public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
    // 设置序列化
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
            Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    // 配置redisTemplate
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
    redisTemplate.setConnectionFactory(lettuceConnectionFactory);
    RedisSerializer<?> stringSerializer = new StringRedisSerializer();
    redisTemplate.setKeySerializer(stringSerializer);// key序列化
    redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);// value序列化
    redisTemplate.setHashKeySerializer(stringSerializer);// Hash key序列化
    redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);// Hash value序列化
    redisTemplate.afterPropertiesSet();
    return redisTemplate;
}

/**
 * RedisTemplate配置
 */
@Bean
public RedisTemplate<String, ?> redisTemplates(RedisConnectionFactory factory) {
    RedisTemplate<String, ?> template = new RedisTemplate();
    template.setConnectionFactory(factory);
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(new RedisObjectSerializer());
    return template;
}

}

package com.example.springbootdemo.config;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

/**

  • redisson 配置，下面是单节点配置：
  • 官方wiki地址：https://github.com/redisson/redisson/wiki/2.-%E9%85%8D%E7%BD%AE%E6%96%B9%E6%B3%95#26-%E5%8D%95redis%E8%8A%82%E7%82%B9%E6%A8%A1%E5%BC%8F

*/
@Configuration
public class RedissonConfig {

@Value("${spring.redis.host}")
private String host;

@Value("${spring.redis.port}")
private String port;

@Value("${spring.redis.password}")
private String password;

@Bean
public RedissonClient redissonClient(){
    Config config = new Config();
    //单节点
    config.useSingleServer().setAddress("redis://" + host + ":" + port);
    if(StringUtils.isEmpty(password)){
        config.useSingleServer().setPassword(null);
    }else{
        config.useSingleServer().setPassword(password);
    }
    //添加主从配置

// config.useMasterSlaveServers().setMasterAddress("").setPassword("").addSlaveAddress(new String[]{"",""});

    // 集群模式配置 setScanInterval()扫描间隔时间，单位是毫秒,  //可以用"rediss://"来启用SSL连接

// config.useClusterServers().setScanInterval(2000).addNodeAddress(“redis://127.0.0.1:7000”, “redis://127.0.0.1:7001”).addNodeAddress(“redis://127.0.0.1:7002”);

    return Redisson.create(config);
}

}
package com.example.springbootdemo.utils;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestHash {

@Autowired
private RedisTemplate<String,String> redisTemplate;

@Test
public void testHash(){
    //创建对象
    HashOperations<String, String, String> opsForHash = redisTemplate.opsForHash();
    //存储一条数据
    opsForHash.put("orderInfo","orderId","11");
    //获取一条数据
    String value = opsForHash.get("orderInfo", "orderId");
    System.out.println(value);

    //存储多条数据
    Map<String,String> map = new HashMap<>();
    map.put("createTime","2018-06-21");
    map.put("orderSn","888888");
    opsForHash.putAll("orderInfo",map);
    //获取多条数据
    List<String> listKey = new ArrayList<>();
    listKey.add("createTime");
    listKey.add("orderSn");
    List<String> info = opsForHash.multiGet("orderInfo", listKey);
    for (String s : info) {
        System.out.println(s);

    }

}

}

package com.example.springbootdemo.utils;

import junit.framework.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestString {

@Autowired
private RedisTemplate stringRedisTemplate;
@Autowired
private RedisTemplate<String, User> objectRedisTemplate;
@Autowired
private RedisTemplate<String, List<User>> listRedisTemplate;
@Autowired
private RedisTemplate<String, List<Map<String,Object>>> mapRedisTemplate;

@Test
public void test1(){
    //JsonObjectMapper jsonMapper = JsonObjectMapper.getInstance();
    //trSync = jsonMapper.fromJson(jsonStr, TrSync.class);
    //操作String类型的数据
    ValueOperations<String, String> valueStr = stringRedisTemplate.opsForValue();
    valueStr.set("goodsProdu","长安");
    //存储一条数据
    valueStr.set("goodsProdu","长安");
    //获取一条数据并输出
    String goodsName = valueStr.get("goodsProdu");
    System.out.println(goodsName);
    //存储多条数据
    Map<String,String> map = new HashMap<>();
    map.put("goodsName","福特汽车");
    map.put("goodsPrice","88888");
    map.put("goodsId","88");

    valueStr.multiSet(map);
    //获取多条数据
    System.out.println("========================================");
    List<String> list = new ArrayList<>();
    list.add("goodsName");
    list.add("goodsPrice");
    list.add("goodsId");
    list.add("goodsProdu");

    List<String> listKeys = valueStr.multiGet(list);
    for (String key : listKeys) {
        System.out.println(key);
    }
    String goodsNames = valueStr.get("goodsProdu");
    if(valueStr.get("goodsProdu").equals("长安test")){
        valueStr.set("goodsProdu","长安test");
    }
    System.out.println(goodsName);

}


@Test
public void test2() throws Exception {

    // 保存字符串
    stringRedisTemplate.opsForValue().set("url", "www.lrshuai.top");
    Assert.assertEquals("www.lrshuai.top", stringRedisTemplate.opsForValue().get("url"));

    // 保存对象
    User user = new User("C++", 40);
    objectRedisTemplate.opsForValue().set(user.getUsername(), user);

    user = new User("Java", 30);
    objectRedisTemplate.opsForValue().set(user.getUsername(), user);

    user = new User("Python", 20);
    objectRedisTemplate.opsForValue().set(user.getUsername(), user);

    Assert.assertEquals(20, objectRedisTemplate.opsForValue().get("Python").getAge());
    Assert.assertEquals(30, objectRedisTemplate.opsForValue().get("Java").getAge());
    Assert.assertEquals(40, objectRedisTemplate.opsForValue().get("C++").getAge());

}

@Test
public void test3() throws Exception{
    List<User> us = new ArrayList<>();
    User u1 = new User("rs1", 21);
    User u2 = new User("rs2", 22);
    User u3 = new User("rs3", 23);
    us.add(u1);
    us.add(u2);
    us.add(u3);
    listRedisTemplate.opsForValue().set("key_ul", us);
    System.out.println("放入缓存》。。。。。。。。。。。。。。。。。。。");
    System.out.println("=============================");
    List<User> redisList = listRedisTemplate.opsForValue().get("key_ul");
    System.out.println("redisList="+redisList);
}

@Test
public void test4() throws Exception{

// List<Map<String,Object>> ms = new ArrayList<>();
// Map<String,Object> map = new HashMap<>();
// map.put(“name”, “rs”);
// map.put(“age”, 20);
//
// Map<String,Object> map1 = new HashMap<>();
// map1.put(“name”, “rs1”);
// map1.put(“age”, 21);
//
// Map<String,Object> map2 = new HashMap<>();
// map2.put(“name”, “rs2”);
// map2.put(“age”, 22);
//
// ms.add(map);
// ms.add(map1);
// ms.add(map2);
// mapRedisTemplate.opsForValue().set(“key_ml”, ms);
// System.out.println(“放入缓存》。。。。。。。。。。。。。。。。。。。”);
System.out.println("=============================");
List<Map<String,Object>> mls = mapRedisTemplate.opsForValue().get(“key_ml”);
for (Map<String,Object> map3:mls) {
System.out.println(“value******”+map3.get(“name”).toString());
System.out.println(“value&&&&&&”+map3.get(“age”).toString());
}
}

}

xml文件

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


4.0.0

<groupId>top.lrshuai</groupId>
<artifactId>springboot-redis</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>springboot-redis</name>
<description>Demo project for Spring Boot</description>

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.4.7.RELEASE</version>
	<relativePath/> <!-- lookup parent from repository -->
</parent>

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

<dependencies>

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

	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
	
	
</dependencies>

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

Test.class
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootRedisApplicationTests {

@Autowired
private StringRedisTemplate stringRedisTemplate;

@Autowired
private RedisTemplate<String, User> redisTemplate;

@Autowired
private RedisTemplate<String, List<User>> rt;


@Autowired
private RedisTemplate<String, List<Map<String,Object>>> rm;

@Test
public void test() throws Exception {

	// 保存字符串
	stringRedisTemplate.opsForValue().set("url", "www.lrshuai.top");
	Assert.assertEquals("www.lrshuai.top", stringRedisTemplate.opsForValue().get("url"));

	// 保存对象
	User user = new User("C++", 40);
	redisTemplate.opsForValue().set(user.getUsername(), user);

	user = new User("Java", 30);
	redisTemplate.opsForValue().set(user.getUsername(), user);

	user = new User("Python", 20);
	redisTemplate.opsForValue().set(user.getUsername(), user);

	Assert.assertEquals(20, redisTemplate.opsForValue().get("Python").getAge());
	Assert.assertEquals(30, redisTemplate.opsForValue().get("Java").getAge());
	Assert.assertEquals(40, redisTemplate.opsForValue().get("C++").getAge());

}

@Test
public void test1() throws Exception{
	List<User> us = new ArrayList<>();
	User u1 = new User("rs1", 21);
	User u2 = new User("rs2", 22);
	User u3 = new User("rs3", 23);
	us.add(u1);
	us.add(u2);
	us.add(u3);
	rt.opsForValue().set("key_ul", us);
	System.out.println("放入缓存》。。。。。。。。。。。。。。。。。。。");
	System.out.println("=============================");
	List<User> redisList = rt.opsForValue().get("key_ul");
	System.out.println("redisList="+redisList);
}

@Test
public void test2() throws Exception{
	List<Map<String,Object>> ms = new ArrayList<>();
	Map<String,Object> map = new HashMap<>();
	map.put("name", "rs");
	map.put("age", 20);
	
	Map<String,Object> map1 = new HashMap<>();
	map1.put("name", "rs1");
	map1.put("age", 21);
	
	Map<String,Object> map2 = new HashMap<>();
	map2.put("name", "rs2");
	map2.put("age", 22);
	
	ms.add(map);
	ms.add(map1);
	ms.add(map2);
	rm.opsForValue().set("key_ml", ms);
	System.out.println("放入缓存》。。。。。。。。。。。。。。。。。。。");
	System.out.println("=============================");
	List<Map<String,Object>> mls = rm.opsForValue().get("key_ml");
	System.out.println("mls="+mls);
}

}

application.properties
#server.port=80

redis db number default number is 0

spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.timeout=0

config

RedisObjectSerializer.java
public class RedisObjectSerializer implements RedisSerializer {

private Converter<Object, byte[]> serializer = new SerializingConverter();
private Converter<byte[], Object> deserializer = new DeserializingConverter();

static final byte[] EMPTY_ARRAY = new byte[0];

public Object deserialize(byte[] bytes) {
if (isEmpty(bytes)) {
return null;
}

try {
  return deserializer.convert(bytes);
} catch (Exception ex) {
  throw new SerializationException("Cannot deserialize", ex);
}

}

public byte[] serialize(Object object) {
if (object == null) {
return EMPTY_ARRAY;
}

try {
  return serializer.convert(object);
} catch (Exception ex) {
  return EMPTY_ARRAY;
}

}

private boolean isEmpty(byte[] data) {
return (data == null || data.length == 0);
}
}

@Configuration
public class RedisConfig {

@Value("${spring.redis.database}")
private int database;

@Value("${spring.redis.host}")
private String host;

@Value("${spring.redis.port}")
private int port;

@Value("${spring.redis.timeout}")
private int timeout;

@Value("${spring.redis.pool.max-idle}")
private int maxidle;

@Value("${spring.redis.pool.min-idle}")
private int minidle;

@Value("${spring.redis.pool.max-active}")
private int maxActive;

@Value("${spring.redis.pool.max-wait}")
private long maxWait;

@Bean
JedisConnectionFactory jedisConnectionFactory() {
	JedisPoolConfig config = new JedisPoolConfig();

// 最大空闲连接数, 默认8个
config.setMaxIdle(maxidle);
// 最小空闲连接数, 默认0
config.setMinIdle(minidle);
// 最大连接数, 默认8个
config.setMaxTotal(maxActive);
// 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间, 默认-1
config.setMaxWaitMillis(maxWait);

	JedisConnectionFactory factory = new JedisConnectionFactory();
	factory.setDatabase(database);
    factory.setHostName(host);
    factory.setPort(port);
    factory.setTimeout(timeout);
    factory.setPoolConfig(config);
    return factory;
}

@SuppressWarnings({ "unchecked", "rawtypes" })
@Bean
public RedisTemplate<String, ?> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, ?> template = new RedisTemplate();
    template.setConnectionFactory(factory);
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(new RedisObjectSerializer());
    return template;
}

}

public class User implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;

private String username;
private int age;

public User() {
	super();
}
public User(String username, int age) {
	super();
	this.username = username;
	this.age = age;
}
public String getUsername() {
	return username;
}
public void setUsername(String username) {
	this.username = username;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}

@Override
public String toString() {
	return "User [username=" + username + ", age=" + age + "]";
}

}

启动类
@SpringBootApplication
public class SpringbootRedisApplication {

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

}

xml文件

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


4.0.0

<groupId>top.lrshuai</groupId>
<artifactId>springboot-redis</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>springboot-redis</name>
<description>Demo project for Spring Boot</description>

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.4.7.RELEASE</version>
	<relativePath/> <!-- lookup parent from repository -->
</parent>

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

<dependencies>

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

	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
	
	
</dependencies>

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

Test.class
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootRedisApplicationTests {

@Autowired
private StringRedisTemplate stringRedisTemplate;

@Autowired
private RedisTemplate<String, User> redisTemplate;

@Autowired
private RedisTemplate<String, List<User>> rt;


@Autowired
private RedisTemplate<String, List<Map<String,Object>>> rm;

@Test
public void test() throws Exception {

	// 保存字符串
	stringRedisTemplate.opsForValue().set("url", "www.lrshuai.top");
	Assert.assertEquals("www.lrshuai.top", stringRedisTemplate.opsForValue().get("url"));

	// 保存对象
	User user = new User("C++", 40);
	redisTemplate.opsForValue().set(user.getUsername(), user);

	user = new User("Java", 30);
	redisTemplate.opsForValue().set(user.getUsername(), user);

	user = new User("Python", 20);
	redisTemplate.opsForValue().set(user.getUsername(), user);

	Assert.assertEquals(20, redisTemplate.opsForValue().get("Python").getAge());
	Assert.assertEquals(30, redisTemplate.opsForValue().get("Java").getAge());
	Assert.assertEquals(40, redisTemplate.opsForValue().get("C++").getAge());

}

@Test
public void test1() throws Exception{
	List<User> us = new ArrayList<>();
	User u1 = new User("rs1", 21);
	User u2 = new User("rs2", 22);
	User u3 = new User("rs3", 23);
	us.add(u1);
	us.add(u2);
	us.add(u3);
	rt.opsForValue().set("key_ul", us);
	System.out.println("放入缓存》。。。。。。。。。。。。。。。。。。。");
	System.out.println("=============================");
	List<User> redisList = rt.opsForValue().get("key_ul");
	System.out.println("redisList="+redisList);
}

@Test
public void test2() throws Exception{
	List<Map<String,Object>> ms = new ArrayList<>();
	Map<String,Object> map = new HashMap<>();
	map.put("name", "rs");
	map.put("age", 20);
	
	Map<String,Object> map1 = new HashMap<>();
	map1.put("name", "rs1");
	map1.put("age", 21);
	
	Map<String,Object> map2 = new HashMap<>();
	map2.put("name", "rs2");
	map2.put("age", 22);
	
	ms.add(map);
	ms.add(map1);
	ms.add(map2);
	rm.opsForValue().set("key_ml", ms);
	System.out.println("放入缓存》。。。。。。。。。。。。。。。。。。。");
	System.out.println("=============================");
	List<Map<String,Object>> mls = rm.opsForValue().get("key_ml");
	System.out.println("mls="+mls);
}

}

application.properties
#server.port=80

redis db number default number is 0

spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.timeout=0

config

RedisObjectSerializer.java
public class RedisObjectSerializer implements RedisSerializer {

private Converter<Object, byte[]> serializer = new SerializingConverter();
private Converter<byte[], Object> deserializer = new DeserializingConverter();

static final byte[] EMPTY_ARRAY = new byte[0];

public Object deserialize(byte[] bytes) {
if (isEmpty(bytes)) {
return null;
}

try {
  return deserializer.convert(bytes);
} catch (Exception ex) {
  throw new SerializationException("Cannot deserialize", ex);
}

}

public byte[] serialize(Object object) {
if (object == null) {
return EMPTY_ARRAY;
}

try {
  return serializer.convert(object);
} catch (Exception ex) {
  return EMPTY_ARRAY;
}

}

private boolean isEmpty(byte[] data) {
return (data == null || data.length == 0);
}
}

@Configuration
public class RedisConfig {

@Value("${spring.redis.database}")
private int database;

@Value("${spring.redis.host}")
private String host;

@Value("${spring.redis.port}")
private int port;

@Value("${spring.redis.timeout}")
private int timeout;

@Value("${spring.redis.pool.max-idle}")
private int maxidle;

@Value("${spring.redis.pool.min-idle}")
private int minidle;

@Value("${spring.redis.pool.max-active}")
private int maxActive;

@Value("${spring.redis.pool.max-wait}")
private long maxWait;

@Bean
JedisConnectionFactory jedisConnectionFactory() {
	JedisPoolConfig config = new JedisPoolConfig();

// 最大空闲连接数, 默认8个
config.setMaxIdle(maxidle);
// 最小空闲连接数, 默认0
config.setMinIdle(minidle);
// 最大连接数, 默认8个
config.setMaxTotal(maxActive);
// 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间, 默认-1
config.setMaxWaitMillis(maxWait);

	JedisConnectionFactory factory = new JedisConnectionFactory();
	factory.setDatabase(database);
    factory.setHostName(host);
    factory.setPort(port);
    factory.setTimeout(timeout);
    factory.setPoolConfig(config);
    return factory;
}

@SuppressWarnings({ "unchecked", "rawtypes" })
@Bean
public RedisTemplate<String, ?> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, ?> template = new RedisTemplate();
    template.setConnectionFactory(factory);
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(new RedisObjectSerializer());
    return template;
}

}

public class User implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;

private String username;
private int age;

public User() {
	super();
}
public User(String username, int age) {
	super();
	this.username = username;
	this.age = age;
}
public String getUsername() {
	return username;
}
public void setUsername(String username) {
	this.username = username;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}

@Override
public String toString() {
	return "User [username=" + username + ", age=" + age + "]";
}

}

启动类
@SpringBootApplication
public class SpringbootRedisApplication {

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

}

或者
pom.xml

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


4.0.0

org.springframework.boot
spring-boot-starter-parent
2.1.7.RELEASE


top.lrshuai
cache
0.0.1-SNAPSHOT
cache
Demo project for Spring Boot

<properties>
    <java.version>1.8</java.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <!-- 添加mybatis 依赖 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.0.0</version>
    </dependency>
    <!-- 驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

    <!-- druid 连接池 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.19</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>log4j-over-slf4j</artifactId>
        <version>1.7.26</version>
    </dependency>

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

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>


    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.8</version>
    </dependency>
</dependencies>

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

application.yml
spring:
profiles:
active: dev
application-dev.yml
spring:
datasource:
url: jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Hongkong&autoReconnect=true&allowPublicKeyRetrieval=true
username: rstyro
password: rstyro
driver-class-name: com.mysql.cj.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource
# druid config
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
filters: ‘stat,wall,log4j’
initialSize: 5
maxActive: 20
maxPoolPreparedStatementPerConnectionSize: 20
maxWait: 60000
minEvictableIdleTimeMillis: 300000
minIdle: 5
poolPreparedStatements: true
testOnBorrow: false
testOnReturn: false
testWhileIdle: true
timeBetweenEvictionRunsMillis: 60000
validationQuery: SELECT 1 FROM DUAL

redis:
password:
database: 0
port: 6379
host: 127.0.0.1
lettuce:
pool:
max-idle: 8
min-idle: 0
max-active: 8
max-wait: -1ms
timeout: 10000ms
cache:
redis:
cache-null-values: false
use-key-prefix: true
time-to-live: 20s

mybatis:
mapper-locations:
- classpath:mapper//.xml
- classpath*:mapper///*.xml

驼峰命名

configuration:
map-underscore-to-camel-case: true

demo.sql
/*
Navicat MySQL Data Transfer

Source Server : 本地
Source Server Type : MySQL
Source Server Version : 80016
Source Host : localhost:3306
Source Schema : demo

Target Server Type : MySQL
Target Server Version : 80016
File Encoding : 65001

Date: 08/08/2019 22:58:42
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

– Table structure for act_acticle

DROP TABLE IF EXISTS act_acticle;
CREATE TABLE act_acticle (
id bigint(20) NOT NULL AUTO_INCREMENT,
title varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT ‘标题’,
content text CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT ‘内容’,
tag_id bigint(20) NULL DEFAULT 1,
create_by bigint(20) NULL DEFAULT NULL COMMENT ‘创建人ID’,
create_time datetime(0) NULL DEFAULT NULL COMMENT ‘创建时间’,
modify_by bigint(20) NULL DEFAULT NULL,
modify_time datetime(0) NULL DEFAULT NULL,
PRIMARY KEY (id) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

– Records of act_acticle

INSERT INTO act_acticle VALUES (1, ‘SpringBoot缓存Cacheable整合’, ‘SpringBoot缓存Cacheable整合’, 0, 1, ‘2019-08-08 17:03:59’, 1, ‘2019-08-08 17:04:02’);
INSERT INTO act_acticle VALUES (3, ‘测试’, ‘阿道夫士大夫ssff’, 1, 1, ‘2019-08-08 17:22:38’, 1, ‘2019-08-08 17:22:38’);
INSERT INTO act_acticle VALUES (4, ‘abc’, ‘阿道夫士大夫ssff’, 2, 1, ‘2019-08-08 17:47:13’, 1, ‘2019-08-08 17:47:13’);

SET FOREIGN_KEY_CHECKS = 1;

logback-spring.xml

%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n logs/cacheable_info.log %d{yyyy-MM-dd HH:mm:ss} [%class:%line] - %m%n INFO ACCEPT DENY logs/cacheable_info.%d{yyyy-MM-dd}.log 30 logs/cacheable_error.log %d{yyyy-MM-dd HH:mm:ss} [%class:%line] - %m%n ERROR ACCEPT DENY logs/cacheable_error.%d{yyyy-MM-dd}.log 30 
<logger name="top.lrshuai.cache" level="DEBUG" />

启动类
package top.lrshuai.cache;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan(basePackages = {“top.lrshuai.cache.*.mapper”})
@SpringBootApplication
public class CacheApplication {

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

}

config类
package top.lrshuai.cache.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;
import java.sql.SQLException;

@Configuration
public class DruidConfig {
private Logger logger = LoggerFactory.getLogger(this.getClass());

@Value("${spring.datasource.url}")
private String dbUrl;

@Value("${spring.datasource.username}")
private String username;

@Value("${spring.datasource.password}")
private String password;

@Value("${spring.datasource.driver-class-name}")
private String driverClassName;

@Value("${spring.datasource.initialSize}")
private int initialSize;

@Value("${spring.datasource.minIdle}")
private int minIdle;

@Value("${spring.datasource.maxActive}")
private int maxActive;

@Value("${spring.datasource.maxWait}")
private long maxWait;

@Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
private int timeBetweenEvictionRunsMillis;

@Value("${spring.datasource.minEvictableIdleTimeMillis}")
private int minEvictableIdleTimeMillis;

@Value("${spring.datasource.validationQuery}")
private String validationQuery;

@Value("${spring.datasource.testWhileIdle}")
private boolean testWhileIdle;

@Value("${spring.datasource.testOnBorrow}")
private boolean testOnBorrow;

@Value("${spring.datasource.testOnReturn}")
private boolean testOnReturn;

@Value("${spring.datasource.poolPreparedStatements}")
private boolean poolPreparedStatements;

@Value("${spring.datasource.maxPoolPreparedStatementPerConnectionSize}")
private int maxPoolPreparedStatementPerConnectionSize;

@Value("${spring.datasource.filters}")
private String filters;

@Value("{spring.datasource.connectionProperties}")
private String connectionProperties;

@Bean     //声明其为Bean实例
@Primary  //在同样的DataSource中，首先使用被标注的DataSource
public DataSource dataSource(){
    DruidDataSource datasource = new DruidDataSource();

    datasource.setUrl(this.dbUrl);
    datasource.setUsername(username);
    datasource.setPassword(password);
    datasource.setDriverClassName(driverClassName);

    //configuration
    datasource.setInitialSize(initialSize);
    datasource.setMinIdle(minIdle);
    datasource.setMaxActive(maxActive);
    datasource.setMaxWait(maxWait);
    datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
    datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
    datasource.setValidationQuery(validationQuery);
    datasource.setTestWhileIdle(testWhileIdle);
    datasource.setTestOnBorrow(testOnBorrow);
    datasource.setTestOnReturn(testOnReturn);
    datasource.setPoolPreparedStatements(poolPreparedStatements);
    datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
    try {
        datasource.setFilters(filters);
    } catch (SQLException e) {
        logger.error("druid configuration initialization filter", e);
    }
    datasource.setConnectionProperties(connectionProperties);

    return datasource;
}

@Bean
public ServletRegistrationBean druidServlet() {
    ServletRegistrationBean reg = new ServletRegistrationBean();
    reg.setServlet(new StatViewServlet());
    reg.addUrlMappings("/druid/*");
    reg.addInitParameter("allow", "127.0.0.1,192.168.1.83"); //白名单
    reg.addInitParameter("deny",""); //黑名单
    reg.addInitParameter("loginUsername", "admin");//查看监控的用户名
    reg.addInitParameter("loginPassword", "nimda");//密码
    return reg;
}

@Bean public FilterRegistrationBean filterRegistrationBean() {
    FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
    filterRegistrationBean.setFilter(new WebStatFilter());
    filterRegistrationBean.addUrlPatterns("/*");
    filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
    return filterRegistrationBean;
}

}

package top.lrshuai.cache.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration;
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.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import javax.annotation.Resource;
import java.time.Duration;

/**
*

  • @author rstyro
  • @time 2018-07-31

*/
@Configuration
@EnableCaching // 开启缓存支持
public class RedisConfig extends CachingConfigurerSupport {
@Resource
private LettuceConnectionFactory lettuceConnectionFactory;

/**
 * 配置CacheManager
 * @return
 */
@Bean
public CacheManager cacheManager() {
    RedisSerializer<String> redisSerializer = new StringRedisSerializer();
    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

    CacheAutoConfiguration
    //解决查询缓存转换异常的问题
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    jackson2JsonRedisSerializer.setObjectMapper(om);

    // 配置序列化（解决乱码的问题）
    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()

// .entryTtl(Duration.ZERO)
.entryTtl(Duration.ofSeconds(20)) //设置缓存失效时间
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
.disableCachingNullValues();

    RedisCacheManager cacheManager = RedisCacheManager.builder(lettuceConnectionFactory)
            .cacheDefaults(config)
            .build();
    return cacheManager;
}


/**
 * RedisTemplate配置
 */
@Bean
public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
    // 设置序列化
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
            Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    // 配置redisTemplate
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
    redisTemplate.setConnectionFactory(lettuceConnectionFactory);
    RedisSerializer<?> stringSerializer = new StringRedisSerializer();
    redisTemplate.setKeySerializer(stringSerializer);// key序列化
    redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);// value序列化
    redisTemplate.setHashKeySerializer(stringSerializer);// Hash key序列化
    redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);// Hash value序列化
    redisTemplate.afterPropertiesSet();
    return redisTemplate;
}

}

controller
package top.lrshuai.cache.act.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import top.lrshuai.cache.act.entity.Acticle;
import top.lrshuai.cache.act.service.IActicleService;

@RestController
@RequestMapping("/act")
public class ActicleController {

@Autowired
private IActicleService acticleService;

@GetMapping("/list")
public Object list() throws Exception{
    return acticleService.list();
}

@GetMapping("/add")
public Object add(Acticle acticle) throws Exception{
    return acticleService.save(acticle);
}

@GetMapping("/del/{id}")
public Object del(@PathVariable("id") Long id) throws Exception{
    return acticleService.del(id);
}

@GetMapping("/delall")
public Object delAll() throws Exception{
    return acticleService.delAll();
}

@GetMapping("/get/id/{id}")
public Object getActicleById(@PathVariable("id") Long id) throws Exception{
    return acticleService.queryById(id);
}

@GetMapping("/get/title/{title}")
public Object getActicleByTitle(@PathVariable("title") String title) throws Exception{
    return acticleService.queryByTitle(title);
}
@GetMapping("/get/tag/{tagId}")
public Object getActicleByTag(@PathVariable("tagId") Long tagId) throws Exception{
    return acticleService.queryByTag(tagId);
}

@GetMapping("/update/{id}")
public Object update(Acticle acticle) throws Exception{
    return acticleService.update(acticle);
}

}

service及serviceimpl
package top.lrshuai.cache.act.service;

import top.lrshuai.cache.act.entity.Acticle;

import java.util.List;

public interface IActicleService {
public List list() throws Exception;
public Acticle save(Acticle acticle) throws Exception;
public int del(Long id) throws Exception;
public int delAll() throws Exception;
public Acticle update(Acticle acticle) throws Exception;
public Acticle queryById(Long id) throws Exception;
public Acticle queryByTitle(String title) throws Exception;
public Acticle queryByTag(Long tagId) throws Exception;
}

package top.lrshuai.cache.act.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.*;
import org.springframework.stereotype.Service;
import top.lrshuai.cache.act.entity.Acticle;
import top.lrshuai.cache.act.mapper.ActicleMapper;
import top.lrshuai.cache.act.service.IActicleService;

import java.time.LocalDateTime;
import java.util.List;

@CacheConfig(cacheNames = “act”)
@Service
public class ActicleService implements IActicleService {

@Autowired
private ActicleMapper acticleMapper;

/**
 * @Cacheable
 * 1、先查缓存，
 * 2、若没有缓存，就执行方法
 * 3、若有缓存。则返回，不执行方法
 *
 * 所以@Cacheable 不能使用result
 *
 * @return
 * @throws Exception
 */
@Cacheable(key = "#root.methodName")
public List<Acticle> list() throws Exception {
    return acticleMapper.getActicleList();
}

/**
 * @CachePut 更新并刷新缓存
 * 1、先调用目标方法
 * 2、把结果缓存
 * @param acticle
 * @return
 * @throws Exception
 */
@CachePut(key = "#result.id" ,unless = "#result.id == null" )
public Acticle save(Acticle acticle) throws Exception {
    acticle.setCreateBy(1l);
    acticle.setCreateTime(LocalDateTime.now());
    acticle.setModifyBy(1l);
    acticle.setModifyTime(LocalDateTime.now());
    acticleMapper.save(acticle);
    System.out.println("acticle="+acticle);
    return acticle;
}

/**
 * 删除指定key 的缓存
 * beforeInvocation=false  缓存的清除是否在方法之前执行
 * 默认是在方法之后执行
 * @param id
 * @return
 * @throws Exception
 */
@CacheEvict(key = "#id",beforeInvocation = true)
public int del(Long id) throws Exception {
    int isDel = 0;
    isDel = acticleMapper.del(id);
    return isDel;
}

/**
 * 删除所有缓存
 * @return
 * @throws Exception
 */
@CacheEvict(allEntries = true)
public int delAll() throws Exception {
    return 1;
}

@CachePut(key = "#result.id" ,unless = "#result.id == null" )
public Acticle update(Acticle acticle) throws Exception {
    acticle.setModifyBy(1l);
    acticle.setModifyTime(LocalDateTime.now());
    return acticleMapper.update(acticle);
}

@Cacheable(key = "#id",condition = "#id > 0")
public Acticle queryById(Long id) throws Exception {
    return acticleMapper.queryById(id);
}

/**
 * @Caching复杂组合缓存注解
 *
 * @param title
 * @return
 * @throws Exception
 */
@Caching(cacheable = { @Cacheable(key = "#title")},
        put = {@CachePut(key = "#result.id"),

// @CachePut(key = “T(String).valueOf(#page).concat(’-’).concat(#pageSize)”)
@CachePut(key = “T(String).valueOf(‘tag’).concat(’-’).concat(#result.tagId)”)
})
public Acticle queryByTitle(String title) throws Exception {
return acticleMapper.queryByTitle(title);
}

@Cacheable(key = "T(String).valueOf('tag').concat('-').concat(#tagId)")
public Acticle queryByTag(Long tagId) throws Exception {
    return null;
}

}

mapping
package top.lrshuai.cache.act.mapper;

import org.springframework.stereotype.Component;
import top.lrshuai.cache.act.entity.Acticle;

import java.util.List;

@Component
public interface ActicleMapper {
public int save(Acticle acticle) throws Exception;
public int del(Long id) throws Exception;
public Acticle update(Acticle acticle) throws Exception;
public Acticle queryById(Long id) throws Exception;
public Acticle queryByTitle(String title) throws Exception;
public List getActicleList();
}

实体类
package top.lrshuai.cache.act.entity;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;

import java.time.LocalDateTime;

@Data
public class Acticle {

private Long id;
private String title;
private String content;

private Long tagId;

private Long createBy;

@JsonDeserialize(using = LocalDateTimeDeserializer.class)
@JsonSerialize(using = LocalDateTimeSerializer.class)
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime createTime;

private Long modifyBy;

@JsonDeserialize(using = LocalDateTimeDeserializer.class)
@JsonSerialize(using = LocalDateTimeSerializer.class)
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime modifyTime;

}

resource/mapping/act

<?xml version="1.0" encoding="UTF-8"?> 
<insert id="save" parameterType="top.lrshuai.cache.act.entity.Acticle" keyProperty="id" useGeneratedKeys="true">
    insert into act_acticle(
        title,
        content,
        create_time,
        create_by,
        modify_time,
        modify_by
    )values(
        #{title},
        #{content},
        #{createTime},
        #{createBy},
        #{modifyTime},
        #{modifyBy}
    )
</insert>

<update id="update">
    update act_acticle
    set
        title=#{title},
        content=#{content},
        modify_by=#{modifyBy},
        modify_time=#{modifyTime}
    where
        id=#{id}
</update>

<delete id="del">
    delete from act_acticle where id=#{id}
</delete>
<select id="queryById" resultType="top.lrshuai.cache.act.entity.Acticle">
    select * from act_acticle where id=#{id}
</select>

<select id="queryByTitle" resultType="top.lrshuai.cache.act.entity.Acticle">
    select * from act_acticle where title like concat('%',#{title},'%')
</select>

<select id="getActicleList" resultType="top.lrshuai.cache.act.entity.Acticle">
    select * from act_acticle
</select>
qiuJun998
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redisson 的高级功能
洪晓鸿
04-07 807
Redisson 提供了对 Redis 集群的支持，但它的主要优势在于它的高级功能，如分布式锁、分布式对象、分布式集合等。这些功能需要对 Redis 集群中的多个节点进行操作，并且需要保证数据的一致性和可靠性。为了实现这些功能，Redisson 使用了多个 Redis 节点之间的协调和通信机制，并提供了丰富的配置选项，以便根据实际需求进行配置
Redis之分布式锁的实现
程铭程铭你快成名的博客
07-01 1万+
分布式锁在分布式系统中比较常见，常见的分布式锁解决方案有： zookeeper，创建顺序临时节点来实现 redis实现（setnx / setnx命令） 数据库唯一主键 这篇文章主要介绍下redis分布式锁怎么实现。在了解分布式锁的实现之前，我们需要了解下分布式锁应该注意些什么： 互斥性，即任何时刻都是一个客户端持有锁 避免死锁，一个客户端挂掉之后不能释放锁，导致后面的客户端不能加锁 保证加锁和解锁是同一个客户端 只要大部分的Redis节点正常运行，客户端就可以进行加锁和解锁操作 废话不多说，直接上
最全springboot使用redis(从配置到实战)，java后端面试
最新发布
2401_84557821的博客
05-13 866
面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取本文已被。
reids cluster模式的两种配置方式
yuhui666666的博客
12-01 984
/redisson版本是3.5，集群的ip前面要加上“redis://”，不然会报错，3.2版本可不加。redis不同的服务模式，客户端要用对应的模式连接，否则出错。1，redisson集成。
Springboot2.x集成lettuce连接redis集群报超时异常Command timed out after 6 second(s)
朱季谦
11-13 1669
Springboot2.x集成lettuce连接redis集群报超时异常Command timed out after 6 second(s)
springboot整合redisson分布式锁(集群模式)
CNZYYH的博客
10-18 2157
1.maven引入redisson &lt;dependency&gt; &lt;groupId&gt;org.redisson&lt;/groupId&gt; &lt;artifactId&gt;redisson&lt;/artifactId&gt; &lt;version&gt;3.5.0&lt;/ve...
docker-compose启动springboot项目-springboot+redis实战案例.zip
08-30
docker-compose启动springboot项目-springboot+redis实战案例。可以参考文章：https://blog.csdn.net/Ber_Bai/article/details/119995240
springboot-mybatis-redis.rar
08-05
《SpringBoot、MyBatis与Redis的整合应用详解》 在现代Web开发中，SpringBoot以其简洁的配置、快速的启动以及丰富的生态成为了许多开发者首选的框架。而MyBatis作为轻量级的持久层框架，以其灵活的SQL操作和优秀的...
Redission分布式锁-本地单机Redis实战-springboot-redis-lock.zip
01-31
本项目“Redission分布式锁-本地单机Redis实战-springboot-redis-lock”旨在教你如何在SpringBoot项目中集成Redisson库，实现基于Redis的分布式锁功能。下面我们将深入探讨相关的知识点。 1. **Redisson**：...
springboot_redis
04-03
标题 "springboot_redis" 涉及的是Spring Boot与Redis集成的应用。Spring Boot是Spring框架的一个简化版，它旨在简化创建独立的、生产级别的基于Spring的应用程序。而Redis是一款高性能的键值对数据库，常被用作缓存...
10分钟掌握redis实战（redis安装, springboot+redis实战，附完整源码）
06-16
10分钟掌握redis实战（centos7安装redis, springboot+redis实战，附完整源码）。 快速掌握centos7安装redis的方法，展示springboot +redis的配置方法，以及redis序列化，附完整实例及源码。 无废话，无长篇大论。 ...
redis在springboot中的使用，redissonClient
进化的深山猿
04-10 3024
创建spring-boot项目，创建的时候同时勾选web，如果不知道怎么创建springboot项目可以参考 https://blog.csdn.net/forezp/article/details/70341651。 1、pom引入，增加如下内容 <dependency> <groupId>org.springframew...
分布式锁：redission使用案例以及报错解决方式
赚钱养家
04-18 1008
原因：config.useClusterServers().addNodeAddress("redis://192.168.55.77:6379").addNodeAddress("redis://192.168.55.77:6378");这里的key不能用redis中已经存在的key，更不要直接用业务用的key，例如库存id。单机和集群的赋端口方式不同。
Java自学资料！docker集群springcloud
m0_56835488的博客
07-09 145
1.为什么要使用分布式锁 使用分布式锁的目的，无外乎就是保证同一时间只有一个客户端可以对共享资源进行操作。 1.1举一个很长的例子 系统 A 是一个电商系统，目前是一台机器部署，系统中有一个用户下订单的接口，但是用户下订单之前一定要去检查一下库存，确保库存足够了才会给用户下单。由于系统有一定的并发，所以会预先将商品的库存保存在 Redis 中，用户下单的时候会更新 Redis 的库存。此时系统架构如下： 但是这样一来会产生一个问题：假如某个时刻，Redis 里面的某个商品库存为 1。 此时两个请求同时到来
springboot整合Redis的Lettuce连接池连接超时：io.lettuce.core.RedisCommandTimeoutException: Command timed out
热门推荐
是我的温柔啊
03-06 2万+
一、可能最大连接数/超时时间设置过小 如图，检查最大连接数和超时时间，将其调大。
Redis实现分布式锁
08-17 762
在之前并发系列的文章中，我们介绍了JVM中的锁。但是无论是synchronized还是Lock，都运行在线程级别上，必须运行在同一个JVM中。如果竞争资源的进程不在同一个JVM中时，这样线程锁就无法起到作用，必须使用分布式锁来控制多个进程对资源的访问。 分布式锁的实现一般有三种方式，使用MySql数据库行锁，基于Redis的分布式锁，以及基于Zookeeper的分布式锁。本文中我们重点看一下Redis如何实现分布式锁。 首先，看一下用于实现分布式锁的两个Redis基础命令： setnx key va
记录redis连接被打满的踩坑之路
奔跑的路路
01-11 2240
记录redis连接被打满的踩坑之路
Redisson 三种集群部署模式使用
skystep的博客
09-22 4972
Redis 常见四种部署模式：单机部署、主从模式部署、sentinel 部署模式、分片模式，针对不同场景一般选择不同的集群部署模式。而 redisson 单机部署针对不同的部署模式分别提供了不同的 API 以统一操作。
spring boot 缓存redis设置定时过期时间
郑小白的博客
07-08 9114
本篇文章分享的就是spring boot中的一个轮子，spring cache注解的方式实现接口数据缓存。默认的配置想非常简单，但是有一个弊端是缓存数据为永久缓存，本次将介绍如何设置接口缓存数据的过期时间......
springboot中redis实战
08-18
- *2* [【Redis】之 SpringBoot 项目整合 Redis 实战](https://blog.csdn.net/aiwangtingyun/article/details/109170525)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值