Redis（连接池）

最新推荐文章于 2024-04-07 23:18:37 发布

潇洒（sa）一点

最新推荐文章于 2024-04-07 23:18:37 发布

阅读量904

点赞数

文章标签： redis java junit

本文链接：https://blog.csdn.net/qq_60281421/article/details/130558139

版权

SpringBoor环境下使用redis连接池

依赖：

<dependencies>
        <dependency>
            <groupId>com.yugabyte</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0-yb-11</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

测试类：“

package com.pb;

public class RedisTest1 {

    @Test
    public  void  test(){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();   //创建连接池的配置对象
        jedisPoolConfig.setMaxTotal(100);    //并发量在100左右
        jedisPoolConfig.setMaxIdle(50);  //最大的等待连接
        jedisPoolConfig.setMinIdle(10);  //最小的等待连接
        jedisPoolConfig.setTestOnBorrow(false);   //其作用是设置在从连接池中获取连接时，是否检测并确保获取的连接可用。
        jedisPoolConfig.setTestOnReturn(false);   //用于设置在将连接还回连接池时是否检测连接的可用性
        jedisPoolConfig.setTestOnCreate(true);   //用于设置在创建新的连接时是否检测连接的可用性
        jedisPoolConfig.setBlockWhenExhausted(true);    //用于设置当连接池中的连接耗尽时，是阻塞等待还是立即抛出异常。

        jedisPoolConfig.setMaxWaitMillis(1000);  //等待1s

        //创建连接池
        JedisPool jedisPool=new JedisPool(jedisPoolConfig,"192.168.200.166",6380,2000,"123.com");

        Jedis jedis=null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(10);
            jedis.set("curry","库里");
            String curry = jedis.get("curry");
            System.out.println(curry);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            jedis.close();  //关闭连接
        }

    }
}

Spring—Redis（连接池）

pom

<dependencies>
        <dependency>
            <groupId>com.yugabyte</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0-yb-11</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>2.0.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
    </dependencies>

配置文件

beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean  id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="100"/>
        <property name="maxIdle" value="50"/>
        <property name="minIdle" value="10"/>
        <property name="testOnBorrow" value="false"/>
        <property name="testOnReturn" value="false"/>
        <property name="testOnCreate" value="false"/>
    </bean>

    <bean  id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          p:usePool="true" p:poolConfig-ref="jedisPoolConfig"
          p:hostName="192.168.200.166" p:port="6380" p:database="10"
          p:password="123.com" p:timeout="200000">
    </bean>

    <bean class="org.springframework.data.redis.core.RedisTemplate" p:connectionFactory-ref="connectionFactory">

       
    </bean>

</beans>

测试：

package com.pb;


@RunWith(value = SpringJUnit4ClassRunner.class )
@ContextConfiguration(locations ={"classpath:beans.xml"})
public class RedisTest1 {

    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    public  void  test(){
        //System.out.println(redisTemplate);

        //操作Spring类型
        redisTemplate.opsForValue().set("aa","aa");

        String aa = (String) redisTemplate.opsForValue().get("aa");
        System.out.println(aa);

    }
}

但是出现了一个问题就是乱码问题

需要在xml中内部Bean

<bean class="org.springframework.data.redis.core.RedisTemplate" p:connectionFactory-ref="connectionFactory">

        <!--创建一个内部Bean-->
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>

        <!--创建一个内部Bean-->
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
    </bean>

但是这样子又出现一个问题就是保存对象的额时候出现的问题可能还会出现乱码

/**
     * 存对象
     */
    @Test
    public void  test2(){

        User user = new User();
        user.setId(1);
        user.setName("curry");
        user.setSex("男");

        redisTemplate.opsForValue().set("user:1:info",user);

        User user1 = (User) redisTemplate.opsForValue().get("user:1:info");
        System.out.println(user1);

    }

上面的代码会报错纯是编码问题：

我们就需要在xml 中配置：

  <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
 </property>

还有一个和就是可能会保存hash数据

  <!--创建一个内部Bean-->
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
        </property>

        <!--创建一个内部Bean-->
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
        </property>

测试：

 /**
     * 存hash
     */
    @Test
    public  void  test3(){
        Map<String, Object> map=new HashMap<>();
        User user = new User();
        user.setId(1);
        user.setName("curry");
        user.setSex("男");
        map.put("user11",user);
        redisTemplate.opsForHash().putAll("user:1:hash",map);


        User user11 = (User) redisTemplate.opsForHash().get("user:1:hash", "user11");

        System.out.println(user11);
    }
}

Spring—Boot声明式缓存

SpringBoot_data_redis

依赖：（boot版本 2.6.13）

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</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>

配置文件 application.yml

spring:
  redis:
    host: 192.168.200.166
    port: 6380
    password: 123.com
    connect-timeout: 10000

    jedis:
      pool:
        max-active: 100
        max-idle: 50
        min-idle: 10
        max-wait: 1000
    database: 10

测试类：

package com.pb;


@SpringBootTest
class SpringBootDataRedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        System.out.println(redisTemplate);

        redisTemplate.opsForValue().set("java","opoo");
        String java = stringRedisTemplate.opsForValue().get("java");
        System.out.println(java);


        User user = new User(1001,"curry","男");

        redisTemplate.opsForValue().set("123123",user);
    }

}

不管是村对象还是存单个值都有乱码问题

我们需要写一个配置类

package com.pb.com.config;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory){

        RedisTemplate redisTemplate = new RedisTemplate();

        redisTemplate.setConnectionFactory(connectionFactory);

        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());

        redisTemplate.afterPropertiesSet();
        return  redisTemplate;
    }
}

在测试就没有乱码了

过期时间：

@Test
    void  test(){
        redisTemplate.opsForValue().set("java","hello",5000, TimeUnit.SECONDS);
        redisTemplate.opsForValue().set("spring","spring", Duration.ofSeconds(5000));
    }

List集合：

 @Test
    void  test(){
        redisTemplate.opsForList().rightPushAll("user:1:info","11","22","33","44","55");

        List range = redisTemplate.opsForList().range("user:1:info", 0, -1);
        System.out.println(range);
    }

Hash

 @Test
    void  test2(){
        Map<String,Object> map=new HashMap<>();
        map.put("id",1001);
        map.put("name","詹姆斯");
        map.put("sex","男");

       redisTemplate.opsForHash().putAll("user:info",map);

       Map<Object,Object> entries=redisTemplate.opsForHash().entries("user:info");
       Iterator<Map.Entry<Object, Object>> integer=entries.entrySet().iterator();
       while (integer.hasNext()){
           Map.Entry<Object,Object>  next= integer.next();
           System.out.println(next.getKey()+"\t"+next.getValue());
       }

        Set<Object> keys = redisTemplate.opsForHash().keys("user:info");
        for (Object key : keys) {
            Object o = redisTemplate.opsForHash().get("user:info", key);
            System.out.println(o);

        }
    }

其他的操作（匿名函数）

 @Test
    public  void test3(){
        redisTemplate.execute(new RedisCallback<Object>() {
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                connection.flushAll();
                return null;
            }
        });
    }