java连接redis 以及连接池的使用和缓存的使用

最新推荐文章于 2024-05-22 19:00:00 发布

苏兮墨

最新推荐文章于 2024-05-22 19:00:00 发布

阅读量1.2k

点赞数

文章标签： java redis 缓存

本文链接：https://blog.csdn.net/m0_53830864/article/details/130358390

版权

1.idea连接redis的三种方式

第一种:jedis---传统的项目--ssm

第二种:lettuce:---->刚出现没有多久就被springboot整合进来。

第三种:springboot连接redis

1.1 jedis操作redis服务器

1）引入依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.3.1</version>
</dependency>

2）编写相关代码

@SpringBootTest
class SpringBootRedisApplicationTests {
    @Autowired
//因为springboot整合redis时会把StringRedisTemplate创建并交于spring容器管理
    private StringRedisTemplate redisTemplate;

    @Test
    void contextLoads() {

     //关于key的操作
        //获取所有的key
        Set<String> keys = redisTemplate.keys("*");
        System.out.println(keys);
        //判断指定的key是否存在
        Boolean k1 = redisTemplate.hasKey("k1");
        System.out.println("判断指定的key是否存在"+k1);
        //删除指定key
        Boolean k11 = redisTemplate.delete("k1");
        System.out.println("判断是否删除成功"+k11);
        redisTemplate.closs()

        //操作字符串StringRedisTemplate会把对每一种数据的操作单独封装成一个类。
        //string操作
        ValueOperations<String, String> forValue = redisTemplate.opsForValue();//valoperations专门操作字符
        //存值
      forValue.set("k1", "vq");
        //取值
        String k12 = forValue.get("k1");
        System.out.println(k12);
        Boolean aBoolean = forValue.setIfAbsent("k999", "v3");//判断是否存在相同的key 如果没有则写入
        System.out.println("是否存入成功" + aBoolean);
        //存储多个值
        Map<String, String> map = new HashMap<>();
        map.put("k2", "www");
        map.put("k3", "12");
        forValue.multiSet(map);
        //获取多个值
        List list = new ArrayList();
        list.add("k2");
        list.add("k3");
        List s = forValue.multiGet(list);
        System.out.println(s);
        //删除
        redisTemplate.delete("k1");
        //自增
        //incr
        forValue.set("k4", "12");
        Long k3 = forValue.increment("k4", 20);
        System.out.println("k3======" + k3);
        //自减
        //decr
        forValue.set("k5","10");
        Long k5 = forValue.decrement("k5", 1);
        System.out.println(k5);

每次使用jedis对象时都需要自己创建，当使用完后，需要关闭该对象。===>jedis中也存在连接池.

1.2 jedis连接池的使用

 @Test
    void contextLoads() {

        //连接池的配置信息
        JedisPoolConfig config=new JedisPoolConfig();
        config.setMaxTotal(10);//最多的连接个数
        config.setMaxIdle(10); //最多空闲的连接个数
        config.setMinIdle(2); //最小的空闲个数
        config.setTestOnBorrow(true);//在获取连接对象时是否验证该连接对象的连通性
        //创建连接池对象
        JedisPool jedisPool=new JedisPool(config,"192.168.26.129",6379);


        Jedis jedis = jedisPool.getResource();
        //清空当前库
        jedis.flushDB();

        String set = jedis.set("k1", "v1");
        String k1 = jedis.get("k1");
        System.out.println(k1);

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

1.3 测试jedis使用和不使用连接池的效率

   @Test
    public void test(){
        //连接池的配置信息
        JedisPoolConfig config=new JedisPoolConfig();
        config.setMaxTotal(100);//最多的连接个数
        config.setMaxIdle(10); //最多空闲的连接个数
        config.setMinIdle(2); //最小的空闲个数
        config.setTestOnBorrow(true);//在获取连接对象时是否验证该连接对象的连通性
        //创建连接池对象
        JedisPool jedisPool=new JedisPool(config,"192.168.26.129",6379);
        long start = System.currentTimeMillis();
        for(int i=0;i<10000;i++){
            Jedis jedis = jedisPool.getResource();
            String ping = jedis.ping();
            jedis.close();
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时:"+(end-start));
    }
   @Test
    public void test2(){
       long start = System.currentTimeMillis();
       //Jedis(String host, int port)
       for(int i=0;i<10000;i++){
           Jedis jedis=new Jedis("192.168.26.129",6379);
           String ping = jedis.ping();
           jedis.close();
       }
       long end = System.currentTimeMillis();
       System.out.println("耗时:"+(end-start));
   }

2.springboot整合redis

springboot在整合redis时提高两个模板类,StringRedisTemplate和RedisTemplate.以后对redis的操作都在该模板类中。StringRedisTemplate是RedisTemplate的子类。

2.1引入相关依赖

<!--redis相关的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

2.2修改配置文件

#redis的配置信息
spring.redis.host=192.168.26.129
spring.redis.port=6379
#最多获取数
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0

2.3测试相关redis常用命令及常用类型命令

    @Autowired
//因为springboot整合redis时会把StringRedisTemplate创建并交于spring容器管理
    private StringRedisTemplate redisTemplate;

    @Test
    void contextLoads() {

     //关于key的操作
        //获取所有的key
       /* Set<String> keys = redisTemplate.keys("*");
        System.out.println(keys);
        //判断指定的key是否存在
        Boolean k1 = redisTemplate.hasKey("k1");
        System.out.println("判断指定的key是否存在"+k1);
        //删除指定key
        Boolean k11 = redisTemplate.delete("k1");
        System.out.println("判断是否删除成功"+k11);
redisTemplate.closs();
        */

        //操作字符串StringRedisTemplate会把对每一种数据的操作单独封装成一个类。
        //string操作
        ValueOperations<String, String> forValue = redisTemplate.opsForValue();//valoperations专门操作字符
     /*   //存值
      forValue.set("k1", "vq");
        //取值
        String k12 = forValue.get("k1");
        System.out.println(k12);
        Boolean aBoolean = forValue.setIfAbsent("k999", "v3");//判断是否存在相同的key 如果没有则写入
        System.out.println("是否存入成功" + aBoolean);
        //存储多个值
        Map<String, String> map = new HashMap<>();
        map.put("k2", "www");
        map.put("k3", "12");
        forValue.multiSet(map);
        //获取多个值
        List list = new ArrayList();
        list.add("k2");
        list.add("k3");
        List s = forValue.multiGet(list);
        System.out.println(s);
        //删除
        redisTemplate.delete("k1");
        //自增
        //incr
        forValue.set("k4", "12");
        Long k3 = forValue.increment("k4", 20);
        System.out.println("k3======" + k3);
        //自减
        //decr
        forValue.set("k5","10");
        Long k5 = forValue.decrement("k5", 1);
        System.out.println(k5);
        */

        //hash操作
        HashOperations<String, Object, Object> forHash = redisTemplate.opsForHash();
        //增加
/*  forHash.put("k6","name","www");
        forHash.put("k6","age","16");
        //获取key
        Set<Object> k13 = forHash.keys("k6");
       // System.out.println(k13);
        Map<String,String> map=new HashMap<>();
        map.put("name","mmm");
        map.put("age","16");
        forHash.putAll("k7",map);
          //获取K6的所有数据
        Map<Object, Object> k1 = forHash.entries("k6");
        System.out.println("entries"+k1);
        //获取key
        Set<Object> k7 = forHash.keys("k7");
        System.out.println(k7);
        //获取值
        List<Object> k71 = forHash.values("k7");
        System.out.println(k71);
        //删除
       redisTemplate.delete("k6");
        // 获取存储在哈希表中指定字段的值
        Object o = forHash.get("k7", "name");
        System.out.println(o);*/


        //list操作
        ListOperations<String, String> forList = redisTemplate.opsForList();
   //增加
     /*    forList.leftPushAll("k1", "ww", "dd", "ff", "sss", "ww");
         //获取
        List<String> k1 = forList.range("k1", 0, -1);
        System.out.println(k1);
        //移出并获取列表的元素
        System.out.println(forList.leftPop("k1"));*/

        //set操作
        SetOperations<String, String> forSet = redisTemplate.opsForSet();
      /*  //增加
        forSet.add("k1","www","ff","cc","vv","sssssdfaf");
        forSet.add("k2","www","ss","ffff","qqq");
        //取值
        System.out.println(forSet.members("k1"));
        //随机获取一个值
        System.out.println(forSet.distinctRandomMembers("k1", 1));
        //读取两个集合的交集
        System.out.println(forSet.intersect("k1", "k2"));
   */


        //sort set 操作
        ZSetOperations<String, String> forZSet = redisTemplate.opsForZSet();
/*
        //增加
        forZSet.add("k1", "mach", 22);

        //取值
        Set<String> k1 = forZSet.range("k1", 0, -1);
       System.out.println(k1);
*/


    }

2.4RedisTemplate

它是StringRedisTemplate的父类，它类可以存储任意数据类型，但是任意类型必须序列化，默认采用的是jdk的序列化方式。jdk序列化方式阅读能力差，而且占用空间大. 我们在使用是一般需要人为指定序列化方式。

@Configuration
public class RedisConfig {
    //比如验证码
    @Bean //该方法的返回对象交于spring容器管理
    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);
        //field序列化
        template.setHashValueSerializer(redisSerializer);
        return template;
    }
}

如果每次使用都人为指定序列化方式，统一设置redisTemplate的序列化

3.连接集群

#最多获取数
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0


# 设置redis重定向的次数---根据主节点的个数
spring.redis.cluster.max-redirects=3

# chuang jian ji qun
spring.redis.cluster.nodes=192.168.26.129:7001,192.168.26.129:7002,192.168.26.129:7003,192.168.26.129:7004,192.168.26.129:7005,192.168.26.129:7006

4.redis的应用场景

4.1 redis可以作为缓存

4.1.2缓存的作用

1）减少访问数据库的频率。--提高系统的性能。

4.1.3什么样的数据适合放入缓存？

查询频率高的
修改频率低的
数据安全性要求低的。

4.2如何使用缓存

1）引入依赖

<?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 https://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.3.12.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.xal</groupId>
    <artifactId>springboot-redis-yingyong2</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-redis-yingyong2</name>
    <description>springboot-redis-yingyong2</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </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>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

2）编写配置文件


server.port=8081
spring.datasource.url=jdbc:mysql:///db6
spring.datasource.username=root
spring.datasource.password=chuxin0920
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
#redis?????
spring.redis.host=192.168.26.129
spring.redis.port=6379
#?????
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0

4.3 编写serviceImpl层

    @Autowired
    private StudentMapper studentMapper;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    public Student findById(Integer sid) {
        ValueOperations<String, Object> forValue = redisTemplate.opsForValue();
        //1.先查询缓存
        Object o = forValue.get("student::" + sid);
        if (o != null) {//缓存命中
            return (Student) o;
        }
        Student student = studentMapper.selectById(sid);
//2.查询到之后应该放入缓存
        if (student != null) {
            forValue.set("student::" + sid, student);
        }
        return student;
    }
}

然后编写controller运行

第一次查询

清空控制台刷新页面

会直接进入缓存中读取提高了查询效率减低了数据库的压力

苏兮墨

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java连接redis 以及连接池的使用和缓存的使用

springboot在整合redis时提高两个模板类,StringRedisTemplate和RedisTemplate.以后对redis的操作都在该模板类中。每次使用jedis对象时都需要自己创建，当使用完后，需要关闭该对象。第二种:lettuce:---->刚出现没有多久就被springboot整合进来。会直接进入缓存中读取提高了查询效率减低了数据库的压力。第一种:jedis---传统的项目--ssm。1）减少访问数据库的频率。--提高系统的性能。清空控制台刷新页面。数据安全性要求低的。
复制链接

扫一扫