Java连接Redis

Java连接Redis

创建springboot项目

Redis依赖

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

data-redis默认集成的是lettuce客户端

lettuce客户端：是基于netty框架来管理连接，天然是非阻塞和线程安全的，支持同步和异步响应式操作，可以共享同一个连接实例

jedis客户端：直接连接到redis服务器，在多个线程之间是共享一个jedis实例，线程是不安全的

使用jedis客户端

jedis依赖

<!--redis依赖-->        
        ​​​​​​​<dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

pom.xml 依赖配置

<dependencies>
        <!--redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <!--
                1.x版本默认采用的连接池技术是Jedis
                2.0以上默认连接池是lettuce，
                如果采用Jedis，需要排除lettuce的依赖
            -->
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>letture-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--jedis依赖-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <!--web组件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
         <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

application.yml配置

spring:
  redis:
    #Redis服务器地址
    host: 192.168.211.128
    #Redis默认服务器端口
    port: 6379
    #Redis密码
    password: root
    #选择哪个库，默认为0库
    database: 1
    #连接超时时间
    timeout: 100000ms
    jedis:
      pool:
        #最大连接数，默认值为8
        max-active: 100
        #最大连接阻塞等待时间，默认-1ms
        max-wait: 10000ms
        #最大空闲连接，默认8
        max-idle: 200
        #最小空闲连接，默认为0
        min-idle: 5
​

测试连接

jedis连接redis

@SpringBootTest
class RedisApplicationTests {
    @Test
    //测试连接
    public void initConnect() {
        Jedis jedis = new Jedis("192.168.211.128",6379);//创建jedis对象
        jedis.auth("root");//设置密码
        jedis.select(2);//指定数据库，第个2库
        String result = jedis.ping();//ping命令测试连接
        System.out.println(result);
        if (jedis !=null){   //关闭连接,释放资源
            jedis.close();
        }
    }
}

使用jedis连接池操作redis

 //使用连接池连接redis
    @Test
    public void initConnect1(){
        //创建连接池对象
        JedisPool jedisPool = new JedisPool(new JedisPoolConfig(), "192.168.211.128", 6379, 10000, "root");
        //从连接池中获取jedis对象
        Jedis jedis = jedisPool.getResource();
        jedis.select(3);//指定数据库，第个3库
        String result = jedis.ping();//ping命令测试连接
        System.out.println(result);
        if (jedis!=null){   //关闭连接,释放资源
            jedis.close();
        }
    }

封装JedisUtil对外提供连接对像的获取方法

创建配置类---RedisConfig

@Configuration
public class RedisConfig {
​
    @Value("${spring.redis.host}") //获取yml中配置的服务器地址
    private String host;
    @Value("${spring.redis.port}") //获取yml中配置的端口
    private int port;
    @Value("${spring.redis.password}") //获取yml中配置的密码
    private String password;
    @Value("${spring.redis.timeout}") //获取yml中配置的
    private String timeout;
    @Value("${spring.redis.jedis.pool.max-active}") //获取yml中配置的最大超时时间
    private int maxActive;
    @Value("${spring.redis.jedis.pool.max-wait}") //获取yml中配置的最大连接阻塞等待时间
    private String  maxWait;
    @Value("${spring.redis.jedis.pool.max-idle}") //获取yml中配置的最大空闲连接
    private int maxIdle;
    @Value("${spring.redis.jedis.pool.min-idle}") //获取yml中配置的最小空闲连接
    private int minIdle;
​
    @Bean
    public JedisPool getJedisPool(){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(maxActive);//最大超时时间
        Duration duration = Duration.ofDays(Long.valueOf(maxWait.substring(0, maxWait.length() - 2)));
        jedisPoolConfig.setMaxWait(duration);//最大空闲连接
        jedisPoolConfig.setMaxIdle(maxIdle);//最大空闲连接
        jedisPoolConfig.setMinIdle(minIdle);//最小空闲连接
        JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port,Integer.valueOf(timeout.substring(0,timeout.length()-2)),password);
        return jedisPool;
    }
}
​

封装

每次运行都会从线程池获取一个实例对象，运行结束后，对不是空的对象进行资源释放

@SpringBootTest
@RunWith(SpringRunner.class)
class RedisApplicationTests {
    @Autowired
    private JedisPool jedisPool;
    private Jedis jedis=null;
    //初始化jedis实例对象
    @Before
    public void initConnect2(){
        jedis = jedisPool.getResource();
    }
    //释放资源
    @After
    public void closeConnect2(){
        if (jedis!=null){
            jedis.close();
        }
    }
}

Jedis操作五种基本数据类型

String

@SpringBootTest
@RunWith(SpringRunner.class)
public class RedisApplicationTests {
    @Autowired
    private JedisPool jedisPool;
    private Jedis jedis=null;
    //初始化jedis实例对象
    @Before
    public void initConnect(){
        jedis = jedisPool.getResource();
    }
​
    /**
     * 操作String
     */
    @Test
    public void exampleString(){
        jedis.set("name","小明");  //添加一条数据
        String name = jedis.get("name");//获取添加的数据  小明 
        System.out.println(name);
        jedis.mset("sex","男","age","18");//添加多条数据
        List<String> list = jedis.mget("name", "sex", "age");//获取多条数据 
        list.forEach(System.out::println);
        jedis.del("age");  //通用删除
    }
    //释放资源
    @After
    public void closeConnect(){
        if (jedis!=null){
            jedis.close();
        }
    }
}
​

Hash

 public void exampleHash(){
        jedis.hset("user","name","小白");
        String name = jedis.hget("user", "name");
        System.out.println(name);//小白
        //添加多条数据
        HashMap<String, String> map = new HashMap<>();
        map.put("sex","男");
        map.put("age","21");
        jedis.hmset("user",map);
        //获取多条数据
        List<String> list = jedis.hmget("user", "name", "sex", "age");
        list.forEach(System.out::println);  //小白 男 21
        //获取整个hash的数据
        Map<String, String> user = jedis.hgetAll("user");
        user.entrySet().forEach(e->{
            System.out.println(e.getKey()+"-"+e.getValue());
        });  //name-小白  sex-男  age-21
        //删除
        jedis.hdel("user","sex","name");
    }

List

public void exampleList(){
       //左添加
       jedis.lpush("userName","小明","小白");
       //右添加
       jedis.rpush("userName","王五","张三");
       //获取数据   ---结果：小白 小明  王五  张三
       List<String> userName = jedis.lrange("userName", 0, 3);
       userName.forEach(System.out::println);
       //获取总条数
       Long llen = jedis.llen("userName");
       System.out.println(llen);  // 结果：4
       //删除数据
       jedis.lrem("userName",1,"王五");
       //左弹出  ---弹出最左边的一条数据，同时删除了这条数据
       String left = jedis.lpop("userName");
       System.out.println(left);  //小白
       //右弹出  ---弹出最右边的一条数据，同时删除了这条数据
       String right = jedis.rpop("userName");
       System.out.println(right); //张三
   }

Set

public void exampleSet(){
        //添加数据
        jedis.sadd("users","aa","bb","cc","dd");
        //获取数据  结果是无序的
        Set<String> members = jedis.smembers("users");
        members.forEach(System.out::println);
        //获取总条数
        Long total = jedis.scard("users");
        System.out.println(total);
        //删除
        jedis.srem("users","aa","cc");
    }

Sorted Set

public void exampleSortedSet(){
        Map<String, Double> map = new HashMap<>();
        map.put("张三",3D);
        map.put("李四",4D);
        map.put("小明",1D);
        map.put("王五",5D);
        map.put("小白",2D);
        //添加数据
        jedis.zadd("sorted",map);
        //获取数据
        Set<String> sorted = jedis.zrange("sorted", 0, 4);
        sorted.forEach(System.out::println);//结果:小明 小白 张三 赵四 王五
        //获取总条数
        Long zcard = jedis.zcard("sorted");
        System.out.println(zcard);  //5
        //删除数据
        jedis.zrem("sorted","小明","小白");
    }

根据层级关系目录形式存储数据

public void exampleDir(){
        jedis.set("data:data01:item01","123");
        //获取层级目录下的数据
        System.out.println(jedis.get("data:data01:item01"));
    }

设置key的失效时间

 public void exampleExpire(){
        jedis.set("code","test");
        //设置失效时间，单位为秒
        jedis.expire("code",20L);
        //设置失效时间，单位为ms
        jedis.pexpire("code",30000);
        //查看失效时间，-1为不失效，-2为已失效
        Long code = jedis.ttl("code");
        //添加key时，设置失效时间
        jedis.setex("code",20L,"test");
        //NX XX 的用法
        SetParams setParams = new SetParams();
        setParams.nx(); //不存在时设置成功  
        setParams.xx();//存在时设置成功
        setParams.ex(30L); //设置失效时间
        jedis.set("code","test",setParams);
    }

常用查询命令

public void findAllKey(){
        //查询当前数据库的所有key
        Set<String> set = jedis.keys("*");
        set.forEach(System.out::println);
        //查询当前数据库key的数量
        Long size = jedis.dbSize();
        System.out.println(size);
    }

事务相关命令

public void testMulti(){
        //开启事务 
        Transaction multi = jedis.multi();
        //提交事务
        multi.set("test","测试");
        //回滚事务
        multi.discard();
    }

jedis操作

序列化工具类 SerializeUtil

public class SerializeUtil {
    public static byte[] serialize(Object object){
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try{
            //序列化
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);//对象转换为字节数组
            byte[] bytes = baos.toByteArray();
            return bytes;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 将byte数组转换为java对象，反序列化
     */
    public static Object unserialize(byte[] bytes){
        if (bytes==null){
            return null;
        }
        ByteArrayInputStream bais = null;
        try{
            //反序列化
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();//字节数组转换为对象
        }catch (Exception e){
            e.getStackTrace();
        }
        return null;
    }
}

新建实体类User

@Data
public class User implements Serializable {
    private Integer id;
    private String username;
    private String password;
}

操作数组

 public void exampleByte(){
        User user = new User();
        user.setId(1);
        user.setUsername("admin");
        user.setPassword("123456");
        //序列化为byte数组
        byte[] userKey = SerializeUtil.serialize("user:" + user.getId());
        byte[] userValue = SerializeUtil.serialize(user);
        //存入Redis
        jedis.set(userKey,userValue);
        //取出数据
        byte[] bytes = jedis.get(userKey);
        //反序列化
        User user1 = (User) SerializeUtil.unserialize(bytes);
        System.out.println(user1);
    }