REDIS学习总结（二）Java操作redis集群

最新推荐文章于 2024-09-27 21:51:44 发布
最新推荐文章于 2024-09-27 21:51:44 发布
阅读量3.5k 收藏 18
点赞数 2
分类专栏： redis 文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Juwenzhe_HEBUT/article/details/86661670
版权

REDIS学习总结（二）Java操作redis集群
REDIS学习总结（一）单机集群搭建

一、操作方式概述
  方法一、Jedis操作
  方式二、RedisTemplate操作
  Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端，比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache
二、代码实例
  1.IDEA下创建工程的目录结构
  
  2.各配置文件及类文件
     pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.jupiter.redis.test</groupId>
    <artifactId>redis-learn</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>redis-learn</name>
    <description>Demo project for Spring Boot</description>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.54</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </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>

</project>

     RedisConfig.java

package com.jupiter.redis.commons;

import com.alibaba.fastjson.parser.ParserConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

import java.time.Duration;
import java.util.HashSet;
import java.util.Set;

/*
 * @author Jupiter
 * @date 2019/1/20-23:41
 * @description redis配置
 */
@Component
@PropertySource("classpath:redis.properties")
public class RedisConfig {

    @Value("${spring.redis.cluster.nodes}")
    private String clusterNodes;
    @Value("${redis.cache.timeout}")
    private int timeout;
    @Value("${redis.pool.max-idle}")
    private int maxIdle;
    @Value("${redis.pool.max-wait}")
    private long maxWaitMillis;
    @Value("${redis.cache.commandTimeout}")
    private int commandTimeout;

    @Bean
    public RedisSerializer fastJson2JsonRedisSerializer(){
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        return new FastJson2RedisJsonSerializer<Object>(Object.class);
    }

    @Bean
    public JedisCluster getJedisCluster() {
        String[] cNodes = clusterNodes.split(",");
        Set<HostAndPort> nodes =new HashSet<>();
        //分割出集群节点
        for(String node : cNodes) {
            String[] hp = node.split(":");
            nodes.add(new HostAndPort(hp[0], Integer.parseInt(hp[1])));
        }
        JedisPoolConfig jedisPoolConfig =new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        //创建集群对象
        return new JedisCluster(nodes,timeout,jedisPoolConfig);
    }

    @Bean
    public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<Object,Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        //使用fastjson做序列化
        FastJson2RedisJsonSerializer fastJson2RedisJsonSerializer = new FastJson2RedisJsonSerializer(Object.class);
        redisTemplate.setValueSerializer(fastJson2RedisJsonSerializer);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    public RedisConnectionFactory connectionFactory() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestOnReturn(false);
        poolConfig.setTestWhileIdle(true);
        JedisClientConfiguration clientConfig = JedisClientConfiguration.builder()
                .usePooling().poolConfig(poolConfig).and().readTimeout(Duration.ofMillis(timeout)).build();

        // 集群redis
        RedisClusterConfiguration redisConfig = new RedisClusterConfiguration();
        String[] cNodes = clusterNodes.split(",");
        Set<RedisNode> nodes =new HashSet<>();
        //分割出集群节点
        for(String node : cNodes) {
            String[] hp = node.split(":");
            nodes.add(new RedisNode(hp[0], Integer.parseInt(hp[1])));
        }
        redisConfig.setClusterNodes(nodes);
        //redisConfig.setPassword(RedisPassword.of(redisAuth));

        return new JedisConnectionFactory(redisConfig, clientConfig);
    }
}

     FastJson2RedisJsonSerializer.java

package com.jupiter.redis.commons;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;

import java.nio.charset.Charset;

/*
 * @author Jupiter
 * @date 2019/1/20-22:57
 * @description 使用FastJson序列化（redisTemplate序列化默认使用的jdkSerializeable,存储二进制字节码,导致key会出现乱码，所以自定义）
 */
public class FastJson2RedisJsonSerializer<T> implements RedisSerializer<T> {

    private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private Class<T> clazz;

    public FastJson2RedisJsonSerializer(Class<T> clazz) {
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null)
            return new byte[0];
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return  null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);
        return (T) JSON.parseObject(str, clazz);
    }
}

     RedisLearnApplication.java

package com.jupiter.redis;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

     redis.properties

# Redis服务器连接密码（默认为空）
redis.password=
# 连接池最大连接数（使用负值表示没有限制）
redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
redis.pool.max-wait=-1
# 连接池中的最大空闲连接
redis.pool.max-idle=8
# 连接池中的最小空闲连接
redis.pool.min-idle=0
# 连接超时时间（毫秒）
redis.cache.timeout=0
redis.cache.commandTimeout=5000

# redis.cluster
spring.redis.cluster.nodes=192.168.31.132:27001,192.168.31.132:27002,192.168.31.132:27003,192.168.31.132:27004,192.168.31.132:27005,192.168.31.132:27006,192.168.31.132:27007,192.168.31.132:27008

  RedisLearnApplicationTests.java测试类

package com.jupiter.redis;

import com.jupiter.redis.commons.RedisConfig;
import org.junit.Before;
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.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.SortingParams;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

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

    @Resource
    private RedisConfig redis;

    private JedisCluster jedis;

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    public StringRedisTemplate stringRedisTemplate;

    //private JedisClusterConnection jedisClusterConnection;

    @Before
    public void getJedis() {
        this.jedis =  redis.getJedisCluster();

        //拿到RedisConnectionFactory
//        RedisConnectionFactory factory = redis.connectionFactory();
//        this.redisTemplate = redis.redisTemplate();
    }


    @Test
    public void testRedisConfig(){
        jedis.setex("sex", 13, "man");
        System.out.println(jedis.get("sex"));
    }

    @Test
    public void testRedisBasicOperation(){
        JedisCluster jedis = redis.getJedisCluster();

    }

    @Test
    public void testKey() throws InterruptedException {

        jedis.del("age");
        jedis.del("username");
        jedis.del("sortedList");
        jedis.del("password");
        jedis.del("collections");
        jedis.del("name");
        System.out.println("判断某个键是否存在："+jedis.exists("username"));
        System.out.println("新增<'username','wukong'>的键值对："+jedis.set("username", "wukong"));
        System.out.println("是否存在:"+jedis.exists("name"));
        System.out.println("新增<'password','password'>的键值对："+jedis.set("password", "password"));
        Set<String> keys = redisTemplate.keys("*");//jedis单节点可以
        System.out.println("系统中所有的键如下："+keys);
        System.out.println("删除键password:"+jedis.del("password"));
        System.out.println("判断键password是否存在："+jedis.exists("password"));
        System.out.println("设置键username的过期时间为5s:"+jedis.expire("username", 5));
        TimeUnit.SECONDS.sleep(2);
        System.out.println("查看键username的剩余生存时间："+jedis.ttl("username"));
        System.out.println("移除键username的生存时间："+jedis.persist("username"));
        System.out.println("查看键username的剩余生存时间："+jedis.ttl("username"));
        System.out.println("查看键username所存储的值的类型："+jedis.type("username"));
    }

    /***
     * 字符串操作
     * memcached和redis同样有append的操作，但是memcached有prepend的操作，redis中并没有。
     */
    @Test
    public void testString() throws InterruptedException {
        System.out.println("===========增加数据===========");
        System.out.println(jedis.set("key1","value1"));
        System.out.println(jedis.set("key2","value2"));
        System.out.println(jedis.set("key3", "value3"));
        System.out.println("删除键key2:"+jedis.del("key2"));
        System.out.println("获取键key2:"+jedis.get("key2"));
        System.out.println("修改key1:"+jedis.set("key1", "value1Changed"));
        System.out.println("获取key1的值："+jedis.get("key1"));
        System.out.println("在key3后面加入值："+jedis.append("key3", "End"));
        System.out.println("key3的值："+jedis.get("key3"));
        Map<String, String> maps = new HashMap<>();
        maps.put("key01", "value01");
        maps.put("key02", "value02");
        maps.put("key03", "value03");
        redisTemplate.opsForValue().multiSet(maps);
        System.out.println("获取键值对："+jedis.get("key01"));
        System.out.println("增加多个键值对成功");
//        System.out.println("增加多个键值对："+jedis.mset("key01","value01","key02","value02","key03","value03"));
//        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));
//        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03","key04"));
//        System.out.println("删除多个键值对："+jedis.del(new String[]{"key01","key02"}));
//        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));

        System.out.println("===========新增键值对防止覆盖原先值==============");
        System.out.println(jedis.setnx("key1", "value1"));
        System.out.println(jedis.setnx("key2", "value2"));
        System.out.println(jedis.setnx("key2", "value2-new"));
        System.out.println(jedis.get("key1"));
        System.out.println(jedis.get("key2"));

        System.out.println("===========新增键值对并设置有效时间=============");
        System.out.println(jedis.setex("key3", 2, "value3"));
        System.out.println(jedis.get("key3"));
        TimeUnit.SECONDS.sleep(3);
        System.out.println(jedis.get("key3"));

        System.out.println("===========获取原值，更新为新值==========");//GETSET is an atomic set this value and return the old value command.
        System.out.println(jedis.getSet("key2", "key2GetSet"));
        System.out.println(jedis.get("key2"));

        System.out.println("获得key2的值的字串："+jedis.getrange("key2", 2, 4));
    }

    /***
     * 整数和浮点数
     */
    @Test
    public void testNumber() {
        jedis.set("key1", "1");
        jedis.set("key2", "2");
        jedis.set("key3", "2.3");
        System.out.println("key1的值："+jedis.get("key1"));
        System.out.println("key2的值："+jedis.get("key2"));
        System.out.println("key1的值加1："+jedis.incr("key1"));
        System.out.println("获取key1的值："+jedis.get("key1"));
        System.out.println("key2的值减1："+jedis.decr("key2"));
        System.out.println("获取key2的值："+jedis.get("key2"));
        System.out.println("将key1的值加上整数5："+jedis.incrBy("key1", 5));
        System.out.println("获取key1的值："+jedis.get("key1"));
        System.out.println("将key2的值减去整数5："+jedis.decrBy("key2", 5));
        System.out.println("获取key2的值："+jedis.get("key2"));
    }

    /***
     * 列表
     */
    @Test
    public void testList() {
        System.out.println("===========添加一个list===========");
        //从左到右依次先放
        jedis.lpush("collections", "ArrayList", "Vector", "Stack", "HashMap", "WeakHashMap", "LinkedHashMap");
        jedis.lpush("collections", "HashSet");
        jedis.lpush("collections", "TreeSet");
        jedis.lpush("collections", "TreeMap");
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));//-1代表倒数第一个元素，-2代表倒数第二个元素
        System.out.println("collections区间0-3的元素："+jedis.lrange("collections",0,3));
        System.out.println("===============================");
        // 删除列表指定的值 ，第二个参数为删除的个数（有重复时），后add进去的值先被删，类似于出栈
        System.out.println("删除指定元素个数："+jedis.lrem("collections", 2, "HashMap"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("删除下表0-3区间之外的元素："+jedis.ltrim("collections", 0, 3));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections列表出栈（左端）："+jedis.lpop("collections"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections添加元素，从列表右端，与lpush相对应："+jedis.rpush("collections", "EnumMap"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections列表出栈（右端）："+jedis.rpop("collections"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("修改collections指定下标1的内容："+jedis.lset("collections", 1, "LinkedArrayList"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("===============================");
        System.out.println("collections的长度："+jedis.llen("collections"));
        System.out.println("获取collections下标为2的元素："+jedis.lindex("collections", 2));
        System.out.println("===============================");
        jedis.lpush("sortedList", "3","6","2","0","7","4");
        System.out.println("sortedList排序前："+jedis.lrange("sortedList", 0, -1));
        System.out.println(jedis.sort("sortedList"));
        //排序前排序后一样，要想输出排好序的List,用jedis.sort("sortedList")即可
        System.out.println("sortedList排序后："+jedis.lrange("sortedList", 0, -1));
    }



    /***
     * set集合
     */
    @Test
    public void testSet() {
        System.out.println("============向集合中添加元素============");
        System.out.println(jedis.sadd("eleSet", "e1","e2","e4","e3","e0","e8","e7","e5"));
        System.out.println(jedis.sadd("eleSet", "e6"));
        System.out.println(jedis.sadd("eleSet", "e6"));//集合元素唯一性
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("删除一个元素e0："+jedis.srem("eleSet", "e0"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("删除两个元素e7和e6："+jedis.srem("eleSet", "e7","e6"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("随机的移除集合中的一个元素："+jedis.spop("eleSet"));
        System.out.println("随机的移除集合中的一个元素："+jedis.spop("eleSet"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("eleSet中包含元素的个数："+jedis.scard("eleSet"));
        System.out.println("e3是否在eleSet中："+jedis.sismember("eleSet", "e3"));
        System.out.println("e1是否在eleSet中："+jedis.sismember("eleSet", "e1"));
        System.out.println("e1是否在eleSet中："+jedis.sismember("eleSet", "e5"));
        System.out.println("=================================");
        System.out.println(jedis.sadd("eleSet1", "e1","e2","e4","e3","e0","e8","e7","e5"));
        System.out.println(jedis.sadd("eleSet2", "e1","e2","e4","e3","e0","e8"));
        //redisTemplate不会创建新的SET集合，而jedis操作集群有报错No way to dispatch this command to Redis Cluster because keys have different slots.
        //解决方法, redis集群下的multiCommands：https://www.cnblogs.com/Finley/p/8595506.html
//        System.out.println("将eleSet1中删除e1并存入eleSet3中："+redisTemplate.opsForSet().move("eleSet1", "e1", "eleSet3"));
//        System.out.println("将eleSet1中删除e1并存入eleSet3中："+jedis.smove("eleSet1", "eleSet3", "e1"));
//        System.out.println("将eleSet1中删除e7并存入eleSet2中："+redisTemplate.opsForSet().move("eleSet1", "e7", "eleSet2"));
//        System.out.println("将eleSet1中删除e2并存入eleSet3中："+jedis.smove("eleSet1", "eleSet3", "e2"));
//        System.out.println("eleSet1中的元素："+jedis.smembers("eleSet1"));
//        System.out.println("eleSet3中的元素："+jedis.smembers("eleSet3"));
//        System.out.println("============集合运算=================");
//        System.out.println("eleSet1中的元素："+jedis.smembers("eleSet1"));
//        System.out.println("eleSet2中的元素："+jedis.smembers("eleSet2"));
//        System.out.println("eleSet1和eleSet2的交集:"+jedis.sinter("eleSet1","eleSet2"));
//        System.out.println("eleSet1和eleSet2的并集:"+jedis.sunion("eleSet1","eleSet2"));
//        System.out.println("eleSet1和eleSet2的差集:"+jedis.sdiff("eleSet1","eleSet2"));//eleSet1中有，eleSet2中没有
    }

    @Test
    public void setMove(){
        System.out.println("eleSet1中是否含有e7元素："+stringRedisTemplate.opsForSet().members("{eleSet}1"));
        System.out.println("eleSet1中是否含有e7元素："+redisTemplate.opsForSet().members("{eleSet}1"));
        System.out.println("将eleSet1中删除e7并存入eleSet2中："+redisTemplate.opsForSet().move("{eleSet}1", "e7", "{eleSet}2"));
    }

    /***
     * 加入HashTag后的set集合（redis 集群下的相关操作）
     */
    @Test
    public void testHashTagSet() {
        System.out.println("============向集合中添加元素============");
        System.out.println(jedis.sadd("{eleSet}", "e1","e2","e4","e3","e0","e8","e7","e5"));
        System.out.println(jedis.sadd("{eleSet}", "e6"));
        System.out.println(jedis.sadd("{eleSet}", "e6"));//集合元素唯一性
        System.out.println("eleSet的所有元素为："+jedis.smembers("{eleSet}"));
        System.out.println("删除一个元素e0："+jedis.srem("{eleSet}", "e0"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("{eleSet}"));
        System.out.println("删除两个元素e7和e6："+jedis.srem("{eleSet}", "e7","e6"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("{eleSet}"));
        System.out.println("随机的移除集合中的一个元素："+jedis.spop("{eleSet}"));
        System.out.println("随机的移除集合中的一个元素："+jedis.spop("{eleSet}"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("{eleSet}"));
        System.out.println("eleSet中包含元素的个数："+jedis.scard("{eleSet}"));
        System.out.println("e3是否在eleSet中："+jedis.sismember("{eleSet}", "e3"));
        System.out.println("e1是否在eleSet中："+jedis.sismember("{eleSet}", "e1"));
        System.out.println("e1是否在eleSet中："+jedis.sismember("{eleSet}", "e5"));
        System.out.println("=================================");
        System.out.println(jedis.sadd("{eleSet}1", "e1","e2","e4","e3","e0","e8","e7","e5"));
        System.out.println(jedis.sadd("{eleSet}2", "e1","e2","e4","e3","e0","e8"));
        //jedis操作集群有报错No way to dispatch this command to Redis Cluster because keys have different slots.
        //解决方法, redis集群下的multiCommands：https://www.cnblogs.com/Finley/p/8595506.html
        System.out.println("将eleSet1中删除e1并存入eleSet3中："+redisTemplate.opsForSet().move("{eleSet}1", "e1", "{eleSet}3"));
        System.out.println("将eleSet1中删除e1并存入eleSet3中："+jedis.smove("{eleSet}1", "{eleSet}3", "e1"));
        System.out.println("将eleSet1中删除e7并存入eleSet2中："+redisTemplate.opsForSet().move("{eleSet}1", "e7", "{eleSet}2"));
        System.out.println("将eleSet1中删除e2并存入eleSet3中："+jedis.smove("{eleSet}1", "{eleSet}3", "e2"));
        System.out.println("eleSet1中的元素："+jedis.smembers("{eleSet}1"));
        System.out.println("eleSet3中的元素："+jedis.smembers("{eleSet}3"));
        System.out.println("============集合运算=================");
        System.out.println("eleSet1中的元素："+jedis.smembers("{eleSet}1"));
        System.out.println("eleSet2中的元素："+jedis.smembers("{eleSet}2"));
        System.out.println("eleSet1和eleSet2的交集:"+jedis.sinter("{eleSet}1","{eleSet}2"));
        System.out.println("eleSet1和eleSet2的并集:"+jedis.sunion("{eleSet}1","{eleSet}2"));
        System.out.println("eleSet1和eleSet2的差集:"+jedis.sdiff("{eleSet}1","{eleSet}2"));//eleSet1中有，eleSet2中没有
    }

    /***
     * 散列
     */
    @Test
    public void testHash() {
        Map<String,String> map = new HashMap<String,String>();
        map.put("key1","value1");
        map.put("key2","value2");
        map.put("key3","value3");
        map.put("key4","value4");
        jedis.hmset("hash",map);
        jedis.hset("hash", "key5", "value5");
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));//return Map<String,String>
        System.out.println("散列hash的所有键为："+jedis.hkeys("hash"));//return Set<String>
        System.out.println("散列hash的所有值为："+jedis.hvals("hash"));//return List<String>
        System.out.println("将key6保存的值加上一个整数，如果key6不存在则添加key6："+jedis.hincrBy("hash", "key6", 6));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("将key6保存的值加上一个整数，如果key6不存在则添加key6："+jedis.hincrBy("hash", "key6", 3));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("删除一个或者多个键值对："+jedis.hdel("hash", "key2"));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("散列hash中键值对的个数："+jedis.hlen("hash"));
        System.out.println("判断hash中是否存在key2："+jedis.hexists("hash","key2"));
        System.out.println("判断hash中是否存在key3："+jedis.hexists("hash","key3"));
        System.out.println("获取hash中的值："+jedis.hmget("hash","key3"));
        System.out.println("获取hash中的值："+jedis.hmget("hash","key3","key4"));
    }

    /**
     * 有序集合
     */
    @Test
    public void testSortedSet() {
        Map<String,Double> map = new HashMap<String,Double>();
        map.put("key2",1.2);
        map.put("key3",4.0);
        map.put("key4",5.0);
        map.put("key5",0.2);
        System.out.println(jedis.zadd("zset", 3,"key1"));
        System.out.println(jedis.zadd("zset",map));
        System.out.println("zset中的所有元素："+jedis.zrange("zset", 0, -1));
        System.out.println("zset中的所有元素："+jedis.zrangeWithScores("zset", 0, -1));
        System.out.println("zset中的所有元素："+jedis.zrangeByScore("zset", 0,100));
        System.out.println("zset中的所有元素："+jedis.zrangeByScoreWithScores("zset", 0,100));
        System.out.println("zset中key2的分值："+jedis.zscore("zset", "key2"));
        System.out.println("zset中key2的排名："+jedis.zrank("zset", "key2"));
        System.out.println("删除zset中的元素key3："+jedis.zrem("zset", "key3"));
        System.out.println("zset中的所有元素："+jedis.zrange("zset", 0, -1));
        System.out.println("zset中元素的个数："+jedis.zcard("zset"));
        System.out.println("zset中分值在1-4之间的元素的个数："+jedis.zcount("zset", 1, 4));
        System.out.println("key2的分值加上5："+jedis.zincrby("zset", 5, "key2"));
        System.out.println("key3的分值加上4："+jedis.zincrby("zset", 4, "key3"));
        System.out.println("zset中的所有元素："+jedis.zrange("zset", 0, -1));
    }

    /**
     * 排序
     */
    @Test
    public void testSort()
    {
        jedis.lpush("collections", "ArrayList", "Vector", "Stack", "HashMap", "WeakHashMap", "LinkedHashMap");
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        SortingParams sortedParameters = new SortingParams();
        System.out.println(jedis.sort("collections",sortedParameters.alpha()));
        System.out.println("===============================");
        jedis.lpush("sortedList", "3","6","2","0","7","4");
        System.out.println("sortedList排序前："+jedis.lrange("sortedList", 0, -1));
        System.out.println("升序："+jedis.sort("sortedList", sortedParameters.asc()));
        System.out.println("降序："+jedis.sort("sortedList", sortedParameters.desc()));
    }
}

  3.更多SpringBoot操作REDIS的文章推荐：
    链接：springboot之使用redistemplate优雅地操作redis
    链接：使用RedisTemplate访问Redis数据结构API大全
三、实践遇到的问题
  问题一：错误TypeMismatchException: Failed to convert property value of type [java.lang原因与解决
    原因：配置文件并没有被spring容器加载到,所以导致这样的错误
    解决：
      链接：TypeMismatchException: Failed to convert property value of type [java.lang解决与原因
      链接：Springboot导入自定义properties配置文件 和 SpringBoot自定义配置文件（xxx.properties）
      链接：SpringBoot四种读取properties文件的方式
  问题二：redis.clients.jedis.exceptions.JedisClusterOperationException: No way to dispatch this command to Redis Cluster because keys have different slots.
    原因：哈希槽(hash slot)是Redis Cluster的概念，哈希槽是一个key的集合，Redis集群共有16384个哈希槽，每个key通过CRC16散列然后对16384进行取模来决定该key应当被放到哪个槽中，集群中的每个节点负责一部分哈希槽。这里需要注意的是需要组成并集的各个集合的key必须是对应到redis集群中的同一个slot上，否则将会出现异常：No way to dispatch this command to Redis Cluster because keys have different slots或者CROSSSLOT Keys in request don’t hash to the same slot。所以redis提供了一种特定的标签{},这个{}内的字符串才参与计算hash slot.例如：{user}:aaa与{user}:bbb 这两个集合可以确保在同一个slot上,可以使用zunionstore求它们的并集。如果是在redis集群环境下，需要特别注意。
    解决：
      在操作redis集群之前先想好后期是否会涉及对集群中存的数据进行批操作，如果只是做缓存，单个K-V存取可以不考虑key在一个hash slot中，这样也有利于数据均匀散列到不通的槽中。
      链接：Redis集群
      链接：zunionstore异常：CROSSSLOT Keys in request don't hash to the same slot
  问题三：redisTemplate.opsForSet().members 反序列化失败
    原因：StringRedisTemplate与RedisTemplate区别点：两者的关系是StringRedisTemplate继承RedisTemplate。两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据。两者之间的区别主要在于他们使用的序列化类：RedisTemplate使用的是JdkSerializationRedisSerializer：存入数据会将数据先序列化成字节数组然后在存入Redis数据库。 StringRedisTemplate使用的是StringRedisSerializer
    解决：
　　　    当你的redis数据库里面本来存的是字符串数据或者你要存取的数据就是字符串类型数据的时候，那么你就使用StringRedisTemplate即可。
　　　    但是如果你的数据是复杂的对象类型，而取出的时候又不想做任何的数据转换，直接从Redis里面取出一个对象，那么使用RedisTemplate是更好的选择。
      链接：StringRedisTemplate操作redis数据
  问题四：Redis报错：WRONGTYPE Operation against a key holding the wrong kind of value
    原因：jedis方法与redis服务器中存储数据的类型存在冲突。例如：数据库中有一个key的数据存储的是Hash类型的，但是你使用jedis执行数据操作的时候却使用了非Hash的操作方法。
    解决：
     链接： Redis报错：WRONGTYPE Operation against a key holding the wrong kind of value 解决处理
    
四、参考文献
  1.redis学习系列(二)--spring boot整合Redis集群
  2.Spring Boot学习之旅：（六）springboot 整合 redis 以及 redis 通用工具类
  3.IntelliJ IDEA lombok插件的安装和使用
  4.Caused by: java.lang.NoClassDefFoundError: redis/clients/util/Pool
  5.JedisCluster模式尝试进行批量操作
  6.springboot配置文件代码提示
  7.Redis: Jedis和RedisTemplate有何区别？
  

小土狗一只
关注
专栏目录
【Java进阶营】Redis 集群★★★
Netty711的博客
05-01 1637
目录 1、搭建 2、故障恢复 3、jredis开发 阿K须知点： 操作集群的添加，查询（对应的插槽机），查看节点（cluseer nodes）都必须在主机上面操作。 一、搭建 1、解决两个问题 （1）容量不够，redis如何进行扩容？ （2）并发写操作， redis如何分摊？ 另外，主从模式，薪火相传模式，主机宕机，导致ip地址发生变化，应用程序中配置需要修改对应的主机地址、端口等信息。 之前通过代理主机来解决，但是redis3.0中提供了解决方案。就是无中心化集群配置 2、什么是集群 （1）Redis 集
Springboot整合redis集群相关配置详解
qq_45491757的博客
04-23 4734
springboot整合redis 官方配置 # common spring boot settings spring.redis.database= spring.redis.host= spring.redis.port= spring.redis.password= spring.redis.ssl= spring.redis.timeout= spring.redis.cluster.no...
Redis篇（Java操作Redis）
最新发布
wlcass zhengge blog
09-27 2176
在Redis官网中提供了各种语言的客户端，JedisLettuceRedissonJedis和Lettuce：这两个主要是提供了Redis命令对应的API，方便我们操作Redis，而Spring 对 Redis 客户端进行了整合，提供了 Spring Data Redis，在Spring Boot项目中还提供了对应的Starter，即 spring-Redisson：是在Redis基础上实现了分布式的可伸缩的java数据结构，例如：Map、Queue等，而且支持跨。
linux部署redis集群及java连接redis集群
virtual251的博客
02-18 553
Linux部署redis集群，java代码连接redis集群
Java实现连接redis几种方式
gaozhenyu5201314的博客
11-11 4233
2、在测试中 实现五种类型 添加到redis中。5、先运行setredis 再运行getredis。
Redis之Java操作连接操作Redis
ChatYU的博客
11-06 1963
Java是一种强大的编程语言，而Redis是一个快速且具有高可扩展性的开源键值数据存储系统。使用Java操作Redis可以提高效率和性能，并且能够满足大规模数据存储和处理的需求。在本篇文章中，我们将介绍如何使用Java连接Redis，以及如何在Java中使用Redis的API来进行数据操作。
Reactive的方式访问Redis
jay_888的博客
08-19 837
参考博客为： https://blog.csdn.net/weixin_38003389/article/details/90239641
java 连redis 集群_Redis三主三从集群环境搭建以及java操作连接
weixin_28964423的博客
02-13 1109
Redis是非关系型数据库的一种，一般用于做高速缓存，从而降低数据库的读写压力。比如在电商首页中，图片轮播，信息展示，都是基于redis进行读取，然后在有效期过后再从数据库读取最新数据。三主三从结构指三个主Master的Redis服务和从属于Master的Slave的Redis服务，主服务主要负责数据写入操作，从服务负责数据读取操作，一共需要6台服务器。结构图如下集群说明:Redis3.0 开始支...
阿里云公网redis集群搭建以及java访问redis集群
04-20
二、Java访问公网Redis集群 1. 添加依赖：在Java项目中，我们需要引入JedisCluster库，可以通过Maven或Gradle添加以下依赖： Maven: ```xml <groupId>redis.clients <artifactId>jedis <version>3.7.0 `...
redis集群模式 java操作redis
qq_55682798的博客
08-02 1059
redis单机版，出现单机故障后，导致redis无法使用，如果程序使用redis，间接导致程序出错。redis的集群模式主从复制模式哨兵模式集群化模式。
Redis高可用集群Java(jedis客户端)操作源码.zip
11-07
通过这份源码，你可以学习到如何在Java应用中实现对Redis集群的正确配置和高效使用，以及如何处理集群环境中的异常情况。同时，了解这些知识对于提升应用的稳定性和扩展性至关重要。通过实践，你将能够更好地理解和...
Java调用Redis集群代码及问题解决
08-25
主要介绍了Java调用Redis集群代码及问题解决,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
redis集群环境搭建以及java中jedis客户端集群代码实现
04-26
NULL 博文链接：https://ihenu.iteye.com/blog/2267881
redis集群批量插入
11-23
总结起来，要在Java中连接Redis集群并批量插入String类型数据，你需要： 1. 配置JedisCluster实例，包含所有集群节点的信息。 2. 创建一个Map对象，存储键值对。 3. 使用`mset`方法执行批量插入。 4. 确保所有键在...
redis-集群模式、在Java中使用redis
weixin_48112109的博客
08-01 2239
redis02集群模式—java中使用redis
java集群spring_spring redis 集群配置
weixin_39917046的博客
02-26 667
pom引入jar包redis.clientsjedis2.9.0org.springframework.dataspring-data-redis1.8.6.RELEASEspring 配置文件location="classpath:redis.properties"ignore-unresolvable="true" />配置文件redis.properties###redis集群推送任务...
Redis的集群 与 Java连接Redis集群
小白的记录
01-17 2483
主从结构添加哨兵能够解决读写分离和单点故障高可用 但是如果数据量过大，特别是写数据量过大,这个时候一个主节点是不够的,需要进行集群搭建↓ Redis集群在保证主从加哨兵的基本功能之外，还能够提升Redis存储数据的能力↓ 配置上图的集群，可以按照以下步骤配置： 停止并删除所有容器,创建docker_redis_cluster文件夹, 里面编辑docker-compose.yml文件： version: "3.1" services: redis1: image: dao
使用Jedis连接Redis3.x集群操作
胡啊呦的博客
06-12 2380
一、实验环境：1.服务器为centos6.4版本系统2.redis安装版本为3.2.93.jedis版本为jedis-2.9.03.jedis依赖commons-pool包版本为commons-pool2-2.2.jar二、Jedis操作集群java测试代码：/**        *@throwsException        *redis3.x集群下的API存储        */      ...
redis集群搭建并实现java连接
zzq的博客
05-05 6285
实验环境 ：CentOS 7 redis集群中最少要有3个节点，为了保证集群高可用，需要每个节点有一个备份机。redis集群至少需要6个节点，也就是6台服务器。 本此实验用三台服务器模拟出6个节点，所以一台服务器上要安装两个节点。服务器IP如下（为了安全我的IP是假的）： 1、47.103.221.121 2、47.103.222.122 3、47.103.223.123 一、安装re...
Redis高可用集群Java操作实践教程
本资源文件应当包含一系列Java代码示例，这些示例展示了如何使用Jedis客户端对Redis集群进行各种操作。例如，包括但不限于： - 初始化Jedis客户端连接集群。 - 进行键值对操作，如set, get, del等。 - 执行高级操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值