Redis在Java中基本实现

Maven必须配置

<dependencies>
    <!-- Redis Java 客户端 -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <!-- 单元测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <!--不会加入打包-->
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.testng</groupId>
        <artifactId>testng</artifactId>
        <version>6.14.3</version>
        <scope>test</scope>
    </dependency>
</dependencies>
<build>
    <plugins>
        <!-- JDK配置1.8 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.0</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
                <!--    <verbal>true</verbal>-->
            </configuration>
        </plugin>
    </plugins>
</build>

Java实现（直连Redis版）

package cn.itcast.redis.api_test;

import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.util.List;
import java.util.Set;

public class RedisTest {

    // redis连接池
    private JedisPool jedisPool;

    /**
     * 初始化
     */
    @BeforeTest
    public void beforeTest(){
        // 创建Redis池配置对象JedisPoolConfig
        JedisPoolConfig config = new JedisPoolConfig();
        // 设置最大空闲连接数
        config.setMaxIdle(10);
        // 设置最小空闲连接
        config.setMinIdle(5);
        // 设置最大等待时间(毫秒)
        config.setMaxWaitMillis(3000);
        // 设置最大连接数
        config.setMaxTotal(50);
        
        // 创建Redis池对象JedisPool
        jedisPool = new JedisPool(config, "node1");

    }

   
    /**
     * 操作String数据类型
     */
    @Test
    public void stringTest(){
        // 获取一个redis连接
        Jedis jedis = jedisPool.getResource();

        // 添加一个String数据类型，key为pv,值为0
        jedis.set("pv", "0");
        // 查询改key对应的数据
        System.out.println("pv: " + jedis.get("pv"));
        // 修改pv为1000
        jedis.set("pv", "1000");
        // 实现整型数据原子自增操作+1
        jedis.incr("pv");
        // 实现整型数据原子自增操作+1000
        jedis.incrBy("pv", 1000);

        System.out.println(jedis.get("pv"));

        // 归还连接池中
        jedis.close();
    }

    /**
     * 操作Hash数据类型
     */
    @Test
    public void hashTest(){
        // 获取redis连接
        Jedis jedis = jedisPool.getResource();

        // 用Hash类型创建商品和库存数据
        jedis.hset("goods", "iphone", "10000");
        jedis.hset("goods", "redmi", "20000");
        // 获取Hash中所有商品
        Set<String> goodsSet = jedis.hkeys("goods");
        for (String goods : goodsSet) System.out.println(goods);
        // 新增3000个redmi库存
        jedis.hincrBy("goods", "redmi", 3000);
        // 删除整个Hash
        jedis.del("goods");
        
        // 归还链接
        jedis.close();
    }

    /**
     * 操作List数据类型
     */
    @Test
    public void listTest(){
        // 获取redis连接
        Jedis jedis = jedisPool.getResource();

        // 向List中插入三个手机号
        jedis.lpush("phone", "11111111111", "22222222222", "33333333333");
        // 从右边移除一个手机号
        jedis.rpop("phone");
        // 获取所有的值
        List<String> phoneList = jedis.lrange("phone", 0, -1);
        for (String phone : phoneList) {
            System.out.println(phone);
        }

        // 归还连接
        jedis.close();
    }

    /**
     * 操作Set数据类型
     */
    @Test
    public void setTest(){
        // 获取连接
        Jedis jedis = jedisPool.getResource();

        // 往set中添加页面page1的uv(独立用户不重复)，用户user1访问一次该页面
        jedis.sadd("uv", "user1");
        // user2 访问了一次
        jedis.sadd("uv", "user2");
        // user1 再次访问
        jedis.sadd("uv", "user1");
        // 获取page1的pv值
        System.out.println("uv:" + jedis.scard("uv"));

        // 归还连接
        jedis.close();
    }

    /**
     * 结束后
     */
    @AfterTest
    public void afterTest(){
        // 关闭连接池
        jedisPool.close();
    }
}

Java实现（通过哨兵连接Redis版）

package cn.itcast.redis.api_test;

import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisSentinelPool;

import java.util.HashSet;
import java.util.Set;

public class RedisSentinelTest {

    // redis哨兵连接池
    private JedisSentinelPool jedisSentinelPool;

    @BeforeTest
    public void beforeTest(){
        // 创建Redis池配置对象JedisPoolConfig
        JedisPoolConfig config = new JedisPoolConfig();
        // 设置最大空闲连接数
        config.setMaxIdle(10);
        // 设置最小空闲连接
        config.setMinIdle(5);
        // 设置最大等待时间(毫秒)
        config.setMaxWaitMillis(3000);
        // 设置最大连接数
        config.setMaxTotal(50);

        // 创建一个HashSet用来保存哨兵节点信息（端口号必填）
        HashSet<String> sentinelSet = new HashSet<>();
        sentinelSet.add("node1:26379");
        sentinelSet.add("node2:26379");
        sentinelSet.add("node3:26379");

        // 创建Redis哨兵池对象JedisSentinelPool
        jedisSentinelPool = new JedisSentinelPool("mymaster", sentinelSet, config);
    }

    /**
     * 获取所有键值（测试哨兵连接是否正常）
     */
    @Test
    public void keysOpTest(){
        // 通过哨兵池获取redis连接
        Jedis jedis = jedisSentinelPool.getResource();

        // 获取所有键值
        Set<String> keys = jedis.keys("*");
        for (String key : keys) {
            System.out.println(key);
        }

        // 归还连接
        jedis.close();
    }

    @AfterTest
    public void afterTest(){
        jedisSentinelPool.close();
    }
}

Java实现（通过RedisCluster集群连接Redis版）

package cn.itcast.redis.api_test;

import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

import java.io.IOException;
import java.util.HashSet;

public class RedisClusterTest {

    // redisCluster集群
    private JedisCluster jedisCluster;


    @BeforeTest
    public void beforeTest(){
        // 创建Redis池配置对象JedisPoolConfig
        JedisPoolConfig config = new JedisPoolConfig();
        // 设置最大空闲连接数
        config.setMaxIdle(10);
        // 设置最小空闲连接
        config.setMinIdle(5);
        // 设置最大等待时间(毫秒)
        config.setMaxWaitMillis(3000);
        // 设置最大连接数
        config.setMaxTotal(50);

        // 创建一个HashSet用来保存所有节点信息
        HashSet<HostAndPort> hostAndPortSet = new HashSet<>();
        hostAndPortSet.add(new HostAndPort("node1", 7001));
        hostAndPortSet.add(new HostAndPort("node1", 7002));
        hostAndPortSet.add(new HostAndPort("node2", 7001));
        hostAndPortSet.add(new HostAndPort("node2", 7002));
        hostAndPortSet.add(new HostAndPort("node3", 7001));
        hostAndPortSet.add(new HostAndPort("node3", 7002));

        // 创建Redis集群对象JedisCluster
        jedisCluster = new JedisCluster(hostAndPortSet, config);
    }

    /**
     * 简单测试集群是否能正常使用
     */
    @Test
    public void setTest(){
        jedisCluster.set("test1", "value1");
        System.out.println(jedisCluster.get("test1"));
    }

    @AfterTest
    public void afterTest() throws IOException {
        jedisCluster.close();
    }
}