配置文件发布订阅Java连接RedisRedis篇2

Posted 崇尚学技术的科班人

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了配置文件发布订阅Java连接RedisRedis篇2相关的知识,希望对你有一定的参考价值。

1、配置文件

1.1、Units单位

1k => 1000 bytes
1kb => 1024 bytes
1m => 1000000 bytes
1mb => 1024*1024 bytes
1g => 1000000000 bytes
1gb => 1024*1024*1024 bytes

1.2、INCLUDES包含

  • 将公用的配置文件进行包含。
# include /path/to/local.conf
# include /path/to/other.conf

1.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、图解发布和订阅

  1. 客户端可以订阅频道如下图

  1. 当给这个频道发布消息后,消息就会发送给订阅的客户端

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
v3

3.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
v3

3.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
a2

3.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
29

3.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
java

4、SpringBoot整合redis

  1. 在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>
  1. 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
  1. 添加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 = RedisCacheManagerRedis模拟多个redis客户端实现订阅功能

RedisRedis 发布订阅通信模式 ( 发布订阅模式 | 订阅频道 | 发布消息 | 接收消息 )

PLC利用函数块连接MQTT订阅消息

RedisRedis 的 Java 客户端(JedisSpringDataRedis)

RedisRedis 的 Java 客户端(JedisSpringDataRedis)

RedisRedis 的 Java 客户端(JedisSpringDataRedis)