1、配置文件
1.1、Units单位
1k => 1000 bytes
1kb => 1024 bytes
1m => 1000000 bytes
1mb => 1024*1024 bytes
1g => 1000000000 bytes
1gb => 1024*1024*1024 bytes1.2、INCLUDES包含
- 将公用的配置文件进行包含。
# include /path/to/local.conf
# include /path/to/other.conf1.3、网络相关配置
# 默认情况bind=127.0.0.1只能接受本机的访问请求。不写的情况下，无限制接受任何ip地址的访问
bind 127.0.0.1 -::1
# 生产环境肯定要写你应用服务器的地址；服务器是需要远程访问的，所以需要将其注释掉。
protected-mode no # 将本机访问保护模式设置no
# 端口号，默认 6379
port 6379
# 设置tcp的backlog，backlog其实是一个连接队列，backlog队列总和=未完成三次握手队列 + 已经完成三次握手队列
tcp-backlog 511
# 一个空闲的客户端维持多少秒会关闭，0表示关闭该功能。即永不关闭。
timeout 0
# tcp-keepalive：就是对访问客户端每隔一定的时间就进行一次检测，如果检测在访问那么就会继续保持连接，如果没有处于连接状态，就会释放连接
tcp-keepalive 300
1.4、GENERAL通用
# 是否为后台进程，设置为yes。守护进程，后台启动
daemonize yes
# 存放pid文件的位置，每个实例会产生一个不同的pid文件
pidfile /var/run/redis_6379.pid
# 指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为notice
# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)
# warning (only very important / critical messages are logged)
loglevel notice
# 日志文件名称
logfile ""
# 设定库的数量 默认16，默认数据库为0，可以使用SELECT dbid命令在连接上指定数据库id
databases 16
1.5、SECURITY安全
# 访问密码的查看、设置和取消。默认情况下是没有密码
requirepass foobared
# 也可以通过以下方法进行临时设置密码，要永久改变密码，需要在配置文件中进行设置
config get requirepass
config set requirepass "123456"
auth 123456
1.6、LIMITS限制
# 设置redis同时可以与多少个客户端进行连接。默认情况下为10000个客户端。如果达到了此限制，redis则会拒绝新的连接请求，并且向这些连接请求方发出“max number of clients reached”以作回应。
maxclients 10000
# 建议必须设置，否则，将内存占满，造成服务器宕机。设置redis可以使用的内存量。一旦到达内存使用上限，redis将会试图移除内部数据，移除规则可以通过maxmemory-policy来指定。
maxmemory <bytes>
# volatile-lru：使用LRU算法移除key，只对设置了过期时间的键；（最近最少使用）
# allkeys-lru：在所有集合key中，使用LRU算法移除key
# volatile-random：在过期集合中移除随机的key，只对设置了过期时间的键
# allkeys-random：在所有集合key中，移除随机的key
# volatile-ttl：移除那些TTL值最小的key，即那些最近要过期的key
# noeviction：不进行移除。针对写操作，只是返回错误信息
maxmemory-policy noeviction # 默认情况
# 设置样本数量，LRU算法和最小TTL算法都并非是精确的算法，而是估算值，所以你可以设置样本的大小，redis默认会检查这么多个key并选择其中LRU的那个。一般设置3到7的数字，数值越小样本越不准确，但性能消耗越小。
maxmemory-samples 5
2、发布和订阅
2.1、什么是发布和订阅？
Redis发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。- Redis 客户端可以订阅任意数量的频道。
2.2、图解发布和订阅
- 客户端可以订阅频道如下图
- 当给这个频道发布消息后，消息就会发送给订阅的客户端
2.3、发布订阅命令实现
第一个redis客户端订阅一个频道
127.0.0.1:6379> subscribe channel1
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "channel1"
3) (integer) 1第二个客户端在其频道上发布消息
127.0.0.1:6379> publish channel1 hello
(integer) 1查看第一个客户端的变化
127.0.0.1:6379> subscribe channel1
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "channel1"
3) (integer) 1
1) "message"
2) "channel1"
3) "hello"3、Jedis测试
3.1、Jedis所需要的jar包
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.2.0</version>
</dependency>3.2、连接时的注意事项
- 禁用Linux的防火墙：Linux(CentOS7)里执行命令
systemctl stop/disable firewalld.service - redis.conf中注释掉
bind 127.0.0.1,然后protected-mode no
3.3、测试
- 创建相应的maven工程
- 测试代码如下
import redis.clients.jedis.Jedis;
public class JedisTest {
public static void main(String[] args) {
Jedis jedis = new Jedis("192.168.123.129");
String ping = jedis.ping();
System.out.println(ping);
jedis.close();
}
}输出结果：PONG
// 说明已经联通了3.4、测试相关的数据类型
3.4.1、Key
import redis.clients.jedis.Jedis;
import java.util.Set;
public class JedisTest {
public static void main(String[] args) {
Jedis jedis = new Jedis("192.168.123.129");
jedis.set("k1","v1");
jedis.set("k2","v2");
jedis.set("k3","v3");
Set<String> keys = jedis.keys("*");
System.out.println(keys.size());
for(String key : keys){
System.out.println(key);
}
Boolean k1 = jedis.exists("k1");
System.out.println(k1);
Long k2 = jedis.ttl("k2");
System.out.println(k2);
String k3 = jedis.get("k3");
System.out.println(k3);
jedis.close();
}
}
测试结果
3
k3
k1
k2
true
-1
v33.4.2、String
import redis.clients.jedis.Jedis;
import java.util.List;
public class JedisTest {
public static void main(String[] args) {
Jedis jedis = new Jedis("192.168.123.129");
List<String> mget = jedis.mget("k1", "k2", "k3");
for(String key : mget){
System.out.println(key);
}
jedis.close();
}
}
测试结果
v1
v2
v33.4.3、List
import redis.clients.jedis.Jedis;
import java.util.List;
public class JedisTest {
public static void main(String[] args) {
Jedis jedis = new Jedis("192.168.123.129");
List<String> k41 = jedis.lrange("k4", 0, -1);
System.out.println(k41);
jedis.close();
}
}测试结果
[v1, v2, v3, v4, v1, v2, v3, v4]3.4.4、set
import redis.clients.jedis.Jedis;
import java.util.Set;
public class JedisTest {
public static void main(String[] args) {
Jedis jedis = new Jedis("192.168.123.129");
Long sadd = jedis.sadd("k5", "a1", "a2", "a3", "a1");
System.out.println(sadd);
Set<String> k5 = jedis.smembers("k5");
for(String key : k5){
System.out.println(key);
}
jedis.close();
}
}测试结果
3
a3
a1
a23.4.5、hash
import redis.clients.jedis.Jedis;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class JedisTest {
public static void main(String[] args) {
Jedis jedis = new Jedis("192.168.123.129");
Map<String,String> map = new HashMap<>();
map.put("name","jack");
map.put("age","29");
map.put("birthday","4.1");
String k6 = jedis.hmset("k6", map);
System.out.println(k6);
List<String> mget = jedis.hmget("k6", "name", "age");
for(String key : mget){
System.out.println(key);
}
jedis.close();
}
}
测试结果
OK
jack
293.4.6、zset
import redis.clients.jedis.Jedis;
import java.util.Set;
public class JedisTest {
public static void main(String[] args) {
Jedis jedis = new Jedis("192.168.123.129");
jedis.zadd("z1",100d,"java");
jedis.zadd("z1",90d,"redis");
jedis.zadd("z1",80d,"jedis");
Set<String> z1 = jedis.zrange("z1", 0, -1);
for(String key : z1){
System.out.println(key);
}
jedis.close();
}
}
测试结果
jedis
redis
java4、SpringBoot整合redis
- 在pom.xml文件中引入redis相关依赖
<!-- redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- spring2.X集成redis所需common-pool2-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.6.0</version>
</dependency>- application.properties配置redis配置
#Redis服务器地址
spring.redis.host=192.168.123.129
#Redis服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0）
spring.redis.database= 0
#连接超时时间（毫秒）
spring.redis.timeout=1800000
#连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=20
#最大阻塞等待时间(负数表示没限制)
spring.redis.lettuce.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=5
#连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=0- 添加redis配置类
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.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.RedisConnectionFactory;
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 java.time.Duration;
@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
RedisSerializer<String> redisSerializer = new StringRedisSerializer();
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
template.setConnectionFactory(factory);
//key序列化方式
template.setKeySerializer(redisSerializer);
//value序列化
template.setValueSerializer(jackson2JsonRedisSerializer);
//value hashmap序列化
template.setHashValueSerializer(jackson2JsonRedisSerializer);
return template;
}
@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
RedisSerializer<String> redisSerializer = new StringRedisSerializer();
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
//解决查询缓存转换异常的问题
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置序列化（解决乱码的问题）,过期时间600秒
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofSeconds(600))
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
.disableCachingNullValues();
RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
.cacheDefaults(config)
.build();
return cacheManager;
}
}
- 测试一下：RedisTestController中添加测试方法
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class RedisTestController {
@Autowired
private RedisTemplate redisTemplate;
@GetMapping("/test")
public String test(){
redisTemplate.opsForValue().set("k1","v1");
String k1 = (String) redisTemplate.opsForValue().get("k1");
return k1;
}
}- 测试结果
