redis&&Jedis实测记录

最新推荐文章于 2022-11-23 15:27:05 发布
最新推荐文章于 2022-11-23 15:27:05 发布
阅读量90 收藏
点赞数
分类专栏： 数据库知识 文章标签： java redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44873668/article/details/108573933
版权

准备工具redis.exe,RedisDesktopManager

链接：https://pan.baidu.com/s/1szSoEiGFbyNA2Zmm9gBKVA 
提取码：43qt

pom

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

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.37</version>
        </dependency>
        <!--解析json数组对象字符串与将map转对象-->
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>
        <!--map转对象-->
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.9.2</version>
            <scope>compile</scope>
        </dependency>
        <!-- redis连接池 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

配置文件

spring:
  redis:
    # Redis数据库索引（默认为 0）
    database: 0
    # Redis服务器地址
    host: 127.0.0.1
    # Redis服务器连接端口
    port: 6379
    # Redis 密码
    password:  
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 8
        # 连接池中的最大空闲连接
        max-idle: 500
        # 连接池最大连接数（使用负值表示没有限制）
        max-active: 2000
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: 10000
    # 连接超时时间（毫秒）
    timeout: 5000

redis配置类

package com.springboot.redis.common.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
 
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
 
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;
import java.text.SimpleDateFormat;

/**
 * Redis缓存配置类
 * @author
 *
 */
@Configuration
@EnableCaching//开启注解
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * 自定义key
     * @return
     */
    @Override
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object o, Method method, Object... objects) {
                //格式化
                StringBuilder sb = new StringBuilder();
                sb.append(o.getClass().getName());
                sb.append(method.getName());
                for (Object obj : objects) {
                    sb.append(obj.toString());
                }
                System.out.println("调用redis缓存key：" + sb.toString());
                return sb.toString();
            }
        };
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheManager cacheManager = RedisCacheManager.create(factory);
        return cacheManager;
    }


    @Bean
    @ConditionalOnClass(RedisOperations.class)
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(mapper.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用 String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的 key也采用 String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用 jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的 value序列化方式采用 jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

redis服务层

package com.springboot.redis.common.service;/**
 * @author Mr伍
 * @date 2020/9/9 17:39
 */

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

/**
 * Created with IntelliJ IDEA.
 * @ClassName: IRedisService
 * @Auther: Mr伍
 * @Date: 2020/09/09/17:39
 */
public interface IRedisService {
    Boolean expire(String key, Long time);
    Long getExpire(String key);
    Boolean hasKey(String key);
    void   del(String... key);
    Object get(String key);
    Boolean set(String key, Object value);
    Boolean set(String key, Object value, Long time);
    Long incr(String key, Long delta);
    Long decr(String key, Long delta);
    Object hget(String key, String item);
    Map<Object, Object> hmget(String key);
    Boolean hmset(String key, Map<String, Object> map);
    Boolean hmset(String key, Map<String, Object> map, Long time);
    Boolean hset(String key, String item, Object value);
    Boolean hset(String key, String item, Object value, Long time);
    void hdel(String key, Object... item);
    Boolean hHasKey(String key, String item);
    Double hincr(String key, String item, Double by);
    Double hdecr(String key, String item, Double by);
    Set<Object> sGet(String key);
    Boolean sHasKey(String key, Object value);
    Long sSet(String key, Object... values);
    Long sSetAndTime(String key, Long time, Object... values);
    Long sGetSetSize(String key);
    Long setRemove(String key, Object... values);
    List<Object> lGet(String key, Long start, Long end);
    Long lGetListSize(String key);
    Object lGetIndex(String key, Long index);
    Boolean lSetO(String key, Object value);
    Boolean lSetO(String key, Object value, Long time);
    Boolean lSet(String key, List<Object> value);
    Boolean lSet(String key, List<Object> value, Long time);
    Boolean lUpdateIndex(String key, Long index, Object value);
    Long lRemove(String key, Long count, Object value);

}


package com.springboot.redis.common.service.impl;

import com.springboot.redis.common.service.IRedisService;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

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

/**
 * 定义常用的 Redis操作
 *
 */
@Service
public class RedisServiceImpl implements IRedisService {

    @Resource
    private  RedisTemplate<String, Object> redisTemplate;

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return Boolean
     */
    @Override
    public Boolean expire(String key, Long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key获取过期时间
     *
     * @param key 键 不能为 null
     * @return 时间(秒) 返回 0代表为永久有效
     */
    @Override
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断 key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    @Override
    public Boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @Override
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(Arrays.asList(key));
            }
        }
    }

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    @Override
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    @Override
    public Boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    @Override
    public Boolean set(String key, Object value, Long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return Long
     */
    @Override
    public Long incr(String key, Long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几
     * @return Long
     */
    @Override
    public Long decr(String key, Long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    /**
     * HashGet
     *
     * @param key  键 不能为 null
     * @param item 项 不能为 null
     * @return 值
     */
    @Override
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取 hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    @Override
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    @Override
    public Boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    @Override
    public Boolean hmset(String key, Map<String, Object> map, Long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    @Override
    public Boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    @Override
    public Boolean hset(String key, String item, Object value, Long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为 null
     * @param item 项 可以使多个不能为 null
     */
    @Override
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为 null
     * @param item 项 不能为 null
     * @return true 存在 false不存在
     */
    @Override
    public Boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return Double
     */
    @Override
    public Double hincr(String key, String item, Double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return Double
     */
    @Override
    public Double hdecr(String key, String item, Double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    /**
     * 根据 key获取 Set中的所有值
     *
     * @param key 键
     * @return Set
     */
    @Override
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    @Override
    public Boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    @Override
    public Long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    @Override
    public Long sSetAndTime(String key, Long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return Long
     */
    @Override
    public Long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    @Override
    public Long setRemove(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().remove(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     * @return List
     */
    @Override
    public List<Object> lGet(String key, Long start, Long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     *
     * @param key 键
     * @return Long
     */
    @Override
    public Long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；
     *              index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return Object
     */
    @Override
    public Object lGetIndex(String key, Long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return Boolean
     */
    @Override
    public Boolean lSetO(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return Boolean
     */
    @Override
    public Boolean lSetO(String key, Object value, Long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return Boolean
     */
    @Override
    public Boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return Boolean
     */
    @Override
    public Boolean lSet(String key, List<Object> value, Long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return Boolean
     */
    @Override
    public Boolean lUpdateIndex(String key, Long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    @Override
    public Long lRemove(String key, Long count, Object value) {
        try {
            return redisTemplate.opsForList().remove(key, count, value);
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        }
    }
}

测试类

package com.springboot.redis;/**
 * @author Mr伍
 * @date 2020/9/11 11:07
 */
import com.springboot.redis.common.service.IRedisService;
import com.springboot.redis.model.Swagger2;
import com.springboot.redis.utils.JsonStringToObjectUtil;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.commons.beanutils.BeanUtils;

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.test.context.junit4.SpringRunner;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;

/**
 * Created with IntelliJ IDEA.
 * @ClassName: RedisListSetGetTest
 * @Auther: Mr伍
 * @Date: 2020/09/11/11:07
 */

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



    @Autowired
    private IRedisService iRedisService;

    @Test
    public  void listSetValue() {
        Swagger2 swagger2=new Swagger2();
        swagger2.setName("测试");
        List<Swagger2> list=new ArrayList<>();
        list.add(swagger2);
        Boolean b= iRedisService.lSet("entity", Collections.singletonList(list));
        System.err.println(b);
    }
/**
 * @Author Mr伍
 * @Description //TODO 获取当前key值下的所有的list集合对象Map 再将map转换成对象。
 * @Date  2020/9/11
 * @Param []
 * @return void
 **/
    @Test
    public void getListValue() throws InvocationTargetException, IllegalAccessException {
        List<Map> user2 =(ArrayList)iRedisService.lGet("entity",0L,-1L);
        if(user2==null||user2.size()==0){
            Swagger2 swagger2=new Swagger2();
            swagger2.setAge(23);
            swagger2.setName("伍柳");
            List<Swagger2> list1=new ArrayList<>();
            list1.add(swagger2);
            Boolean b=  iRedisService.lSet("entity", Collections.singletonList(list1));//   .opsForValue().set("user1", swagger2);
            System.out.println(b+"__redis中没有值:");
            if(b){
                System.err.println("成功存入缓存对象："+swagger2);
            }
        }else {
            for (int i = 0; i < user2.size(); i++) {
                System.err.println(user2.get(i));
                JSONArray jsonArray = JSONArray.fromObject(user2.get(i));
                for (int j = 0; j < jsonArray.size(); j++) {
                    JSONObject jsonObject = JSONObject.fromObject(jsonArray.get(j));
                    Map map = (Map) JSONObject.toBean(jsonObject, Map.class);
                    Swagger2 swagger2=new Swagger2();
                    BeanUtils.populate(swagger2,map);
                    System.err.println(swagger2);
                }
            }
            System.err.println("成功获取到值");
        }
    }
    /**
     * @Author Mr伍
     * @Description //TODO 若返回的全是Map类型
     * @Date  2020/9/14
     * @Param []
     * @return void
     **/
    public void tesOne() throws InvocationTargetException, IllegalAccessException {
        List<List<Map>> list =(ArrayList)iRedisService.lGet("entity",0L,-1L);
        List<Map<String,Object>> mapList= JsonStringToObjectUtil.getObject(list,new Swagger2());
        System.err.println(mapList);
        mapList.forEach(i->{
            try {
                Swagger2 swagger2=new Swagger2();
                //Map转对象
                BeanUtils.populate(swagger2,i);
                System.err.println(swagger2);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        });

    }


/**
 * @Author Mr伍
 * @Description //TODO 最终版（config配置为返回类型）
 * @Date  2020/9/11
 * @Param []
 * @return void
 **/
    @Test
    public void getUtils(){
        List<List<Swagger2>> list =(ArrayList)iRedisService.lGet("entity",0L,-1L);
        list.forEach(i->{
            i.forEach(j->{
            System.err.println(j);

            });
        });


    }







}

测试k,v

package com.springboot.redis;/**
 * @author Mr伍
 * @date 2020/9/11 11:05
 */

import com.springboot.redis.common.service.IRedisService;
import com.springboot.redis.model.Swagger2;
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.test.context.junit4.SpringRunner;

/**
 * Created with IntelliJ IDEA.
 * @ClassName: RedisSetTest
 * @Auther: Mr伍
 * @Date: 2020/09/11/11:05
 */


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

    @Autowired
    private IRedisService iRedisService;
    @Test
    public void setObjectValue(){
        Swagger2 swagger2 =new Swagger2();
        swagger2.setName("设置单一值对象5");
      boolean b=  iRedisService.set("obj",swagger2);
        if(b){
            System.err.println("存入成功");
            Swagger2 swagger21=(Swagger2) iRedisService.get("obj");
            System.err.println(swagger21);
        }


    }




}

Jedis自定义配置文件

#redis
wl.redis.host=127.0.0.1
wl.redis.port=6379
wl.redis.password= 
wl.redis.timeout=5000
wl.redis.poolMaxTotal=10
wl.redis.poolMaxIdle=3
wl.reids.poolMaxWait=5000
wl.redis.db=1

配置类

package com.springboot.redis.common.properties;/**
 * @author Mr伍
 * @date 2020/9/11 17:23
 */

import lombok.Data;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
 
@Data
@SpringBootConfiguration
@PropertySource(value = {"classpath:wl.properties"})
@ConfigurationProperties(prefix = "wl")
public class WlProperties {
  private RedisProperties redis=new RedisProperties();


}


package com.springboot.redis.common.properties;/**
 * @author Mr伍
 * @date 2020/9/11 17:42
 */

import lombok.Data;

/**
 * Created with IntelliJ IDEA.
 * @ClassName: RedisProperties
 * @Auther: Mr伍
 * @Date: 2020/09/11/17:42
 */
@Data
public class RedisProperties {

    private String host;
    private int port;
    private String password;
    private int timeout;
    private int poolMaxTotal;
    private int poolMaxIdle;
    private int poolMaxWait;
    private int db;

}


package com.springboot.redis.common.config;/**
 * @author Mr伍
 * @date 2020/9/11 16:19
 */

import com.springboot.redis.common.properties.WlProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * Created with IntelliJ IDEA.
 * @ClassName: JedisPoolFactory
 * @Auther: Mr伍
 * @Date: 2020/09/11/16:19
 */
/**
 *创建RedisPool对象
 */
@Component
public class JedisPoolFactory {

        @Autowired
        private WlProperties wlProperties;

        @Bean
        public JedisPool getJedisPool(){
            JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
            jedisPoolConfig.setMaxIdle(wlProperties.getRedis().getPoolMaxIdle());
            jedisPoolConfig.setMaxWaitMillis(wlProperties.getRedis().getPoolMaxWait());
            jedisPoolConfig.setMaxTotal(wlProperties.getRedis().getPoolMaxTotal());
            JedisPool jp=new JedisPool(jedisPoolConfig,wlProperties.getRedis().getHost(),wlProperties.getRedis().getPort(),
                    wlProperties.getRedis().getTimeout(),wlProperties.getRedis().getPassword(),wlProperties.getRedis().getDb());
            return jp;
        }

}

服务层

package com.springboot.redis.common.service.impl;/**
 * @author Mr伍
 * @date 2020/9/11 17:46
 */
import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

/**
 * Created with IntelliJ IDEA.
 * @ClassName: JedisServiceImpl
 * @Auther: Mr伍
 * @Date: 2020/09/11/17:46
 */
@Service
public class JedisServiceImpl {


    /**
     * 通过Jedis操作Redis
     */
        @Autowired
        JedisPool jedisPool;

        /**
         * 获取对象
         * @param key
         * @param clazz
         * @param <T>
         * @return
         */
        public <T> T get(String key, Class<T> clazz) {
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                String str = jedis.get(key);
                T t = stringToBean(str, clazz);
                return t;
            }finally {
                closeJedis(jedis);
            }
        }

        /**
         * 设置对象
         * @param key
         * @param value
         * @param <T>
         * @return
         */
        public <T> boolean set(String key,T value){
            Jedis jedis=null;
            try {
                jedis=jedisPool.getResource();
                String str=beanToString(value);
                if (str==null||str.length()<=0){
                    return false;
                }
                jedis.set(key,str);
                return true;
            }finally {
                closeJedis(jedis);
            }
        }

        /**
         * 删除
         * @param key
         * @return
         */
        public boolean delete(String key){
            Jedis jedis=null;
            try{
                jedis=jedisPool.getResource();
                long ret=jedis.del(key);
                return ret>0;
            }finally {
                closeJedis(jedis);
            }
        }

        /**
         * 判断key是否存在
         * @param key
         * @param <T>
         * @return
         */
        public <T> boolean exists(String key){
            Jedis jedis=null;
            try{
                jedis=jedisPool.getResource();
                return jedis.exists(key);
            }finally {
                closeJedis(jedis);
            }
        }

        /**
         * 增加值
         * @param key
         * @param <T>
         * @return
         */
        public<T> Long incr(String key){
            Jedis jedis=null;
            try{
                jedis=jedisPool.getResource();
                return jedis.incr(key);
            }finally {
                closeJedis(jedis);
            }
        }

        /**
         * 减少值
         * @param key
         * @param <T>
         * @return
         */
        public<T> Long decr(String key){
            Jedis jedis=null;
            try{
                jedis=jedisPool.getResource();
                return jedis.decr(key);
            }finally {
                closeJedis(jedis);
            }
        }

        /**
         * 关闭jedis
         * @param jedis
         */
        private void closeJedis(Jedis jedis) {//用完记得要关闭
            if (jedis != null) {
                jedis.close();
            }
        }

        /**
         * 将String转换为其他对象
         *
         * @param str
         * @param clazz
         * @param <T>
         * @return
         */
        private <T> T stringToBean(String str, Class<T> clazz) {
            if (str == null || str.length() <= 0 || clazz == null) {
                return null;
            }
            if (clazz == int.class || clazz == Integer.class) {
                return (T) Integer.valueOf(str);
            } else if (clazz == String.class) {
                return (T) str;
            } else if (clazz == long.class || clazz == Long.class) {
                return (T) Long.valueOf(str);
            } else {
                return JSON.toJavaObject(JSON.parseObject(str), clazz);
            }
        }

        /**
         * 将其他对象转换为String
         * @param value
         * @param <T>
         * @return
         */
        private <T> String beanToString(T value) {
            if (value == null) {
                return null;
            }
            Class<?> clazz = value.getClass();
            if (clazz == int.class || clazz == Integer.class) {
                return "" + value;
            } else if (clazz == String.class) {
                return (String) value;
            } else if (clazz == long.class || clazz == Long.class) {
                return "" + value;
            } else {
                return JSON.toJSONString(value);
            }
        }
    }

Jedis测试类

package com.springboot.redis.Jedis;/**
 * @author Mr伍
 * @date 2020/9/11 17:49
 */

import com.alibaba.fastjson.JSONObject;
import com.springboot.redis.common.service.impl.JedisServiceImpl;
import com.springboot.redis.model.Swagger2;
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.test.context.junit4.SpringRunner;
import redis.clients.jedis.JedisPool;

import java.util.ArrayList;
import java.util.List;

/**
 * Created with IntelliJ IDEA.
 * @ClassName: JedisSetGetTest
 * @Auther: Mr伍
 * @Date: 2020/09/11/17:49
 */


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

    @Autowired
    private JedisServiceImpl jedisService;

    @Test
    public  void  JedisSet(){
        ArrayList<Swagger2> list=new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            Swagger2 swagger2 =new Swagger2();
            swagger2.setAge(20+i);
            swagger2.setName("Jedis"+i);
            swagger2.setId(i+"");
            list.add(swagger2);

        }
        boolean b = jedisService.set("swagger2",new Swagger2() );
        if(b){
            System.err.println("数据缓存成功");
        }else {
            System.err.println("缓存失败");
        }


    }

    @Autowired
    JedisPool jedisPool;
    @Test
    public void getJedisValue(){

     String getJedis= jedisService.get("jedis",String.class);
        List<Swagger2> list = JSONObject.parseArray(getJedis,Swagger2.class);
        System.err.println(list);

       Swagger2 s=jedisService.get("swagger2",Swagger2.class);

        System.err.println(s);

        }


}
cqwuliu
关注
专栏目录
Redis&Jedis
辰伏的博客
01-29 185
Redis 1. NoSQL简介 问题：海量用户，高并发 罪魁祸首：关系型数据库 性能瓶颈：磁盘IO性能低下 扩展瓶颈：数据关系复杂，扩展性差，不便于大规模集群 解决思路 降低磁盘IO次数，越低越好---------内存存储 去除数据间的关系，越简单越好—不存储关系，仅储存数据 NoSQL(Not-Only SQL)：泛指非关系型的数据库 作为关系型数据库的补充 作用 应对基于海量用户和海量数据前提下的数据处理问题 特征 可扩容，可伸缩 大数据量下高性能 灵活的数据模型 高可用
【Redis】Jedis
flora
01-06 95
Jedisidea 连接redis连接本地redis连接远程redis常用api基本Stringlistset添加移除集合运算hash事务 idea 连接redis 连接本地redis 连接本地redis， 则打开本地redis-server 打开后界面如下 public class TestPing { public static void main(String[] args) { //1. new 一个jedis 对象 Jedis jedis = new J
Redis使用opsFor系列 get读取报错InvocationTargetException
sgambler的博客
01-06 1234
Redis使用opsFor系列get读取报错InvocationTargetException说明报错信息原因解决方案 说明 昨天还好好的redis取值突然报错，抛出的异常是风马牛不相及的 InvocationTargetException ，找了好久的原因，打了好久的断点，查了好久的百度，依然一无所获。。。 最后自己都不知道是哪个关键词找到的这篇文章： RedisTemplate先在事务中使用，然后在非事务中使用，导致读操作不能立即读出数据 正好是我的问题所在，但是大神码文的时候这个关键词定的实在是。。我
使用jedis连接单机和集群redis的两种方式
weixin_34072857的博客
12-02 806
2019独角兽企业重金招聘Python工程师标准>>> ...
关于java中redis操作直接使用jedis和使用springboot封装的RedisTemplate效率对比和主要区别
wh445306
01-19 1703
个人使用总结： 我知道jedis，lettuce是目前用的最多的两个java端的redis客户端，而RedisTemplate则是SpringBoot提供的一个封装模板，为的是可以方便更换redis客户端和支持Spring Cache，SpringBoot2.0以前默认为jedis，2.x以上则换成了lettuce,经过多次的使用和对比，得出如下结论： 个人认为直接使用JedisPool比使用SpringBoot封装的RedisTemplate好用，而且效率高很多（相同的数据量至少5倍以上的差距，本机.
redis jedis jar包
10-18
Redis是世界上最受欢迎的开源内存数据结构存储系统，它可以用作数据库、缓存和消息代理。Jedis是Java语言中用于...2.7.0版本的Jedis经过实测，意味着它在稳定性、兼容性和性能方面都得到了验证，是一个可靠的版本选择。
redis实现轮询算法_Redis集群方案应该怎么做？
weixin_29207439的博客
12-31 325
为什么集群？通常，为了提高网站响应速度，总是把热点数据保存在内存中而不是直接从后端数据库中读取。Redis是一个很好的Cache工具。大型网站应用，热点数据量往往巨大，几十G上百G是很正常的事儿，在这种情况下，如何正确架构Redis呢？首先，无论我们是使用自己的物理主机，还是使用云服务主机，内存资源往往是有限制的，scale up不是一个好办法，我们需要scale out横向可伸缩扩展，这需要由多...
Java的Redis客户端，Jedis和Redisson客户端的使用详细说明；Jedis的基本使用；Redisson作为消息中间件​、​布隆过滤器​、限流器、分布式锁、分布式集合、分布式远程服务；
一个学习Java开发的老头
11-23 2447
jedis 是直连 redis server，如果在多线程环境下是非线程安全的，这个时候只有使用连接池，为每个jedis实例增加物理连接 ； Redisson 实现了分布式 和 可扩展的Java数据结构，和 Jedis 相比，功能较为简单，不支持字符串操作，不支持排序、事务、管道、分区等Redis特性。Redisson 的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上。
Redis 运维实战 第07期：Hotkey
likecolumn的博客
11-11 359
上一节，我们聊到了 Redis 的 Bigkey，这节内容我们聊聊同样需要引起重视的 Hotkey。 1 背景 Hotkey 指某个时间段访问频率比较高的键值，对应的业务比如热点话题或者热点商品。 Hotkey 可能会导致集群流量不均衡，或者某一个节点 QPS、网卡流量被打满。 因此需要考虑一些措施来降低 Hotkey 出现的概率，比如在编码阶段避免产生 Hotkey，或者提前准备出现 Hotkey 时的应对方案。 2 Hotkey 产生原因 日常生活中，可能很多热点事件的背后，都会产生一个鲜为人知的 H.
存储过程基本写法
weixin_44873668的博客
06-27 3694
存储过程 2020年6月19日 15:24 --说明 create or replace package wl_system is TYPE tp_ref_cursor is ref cursor; TYPE type_varchar2_table is table of varchar2(200); type type_list_bizholder is table of type_object_bizholder; function GetUserName(puserid a
服务器崩了只剩下数据文件恢复oracle数据库
weixin_44873668的博客
11-10 1598
一、必须安装相同版本号的数据库。 二、最好app的路径也为相同的盘符。 三、安装完毕以后命令停止数据库，shutdown immediate 并查看服务里面是否也是停止状态，将服务里面oracle开头的服务全部停止。 四、将崩之前的app下的数据文件直接覆盖替换新安装的文件。 五、启动服务，看是否能登陆进入用户并查询是否有以前的用户(如果能登陆成功)。 六、如果不能正常启动，用自己服务器的init.ora配置文件启动，路径app\Administrator\admin\orcl\pfile 教程如下； 如还
oracle获取多少个工作日后的下一个工作日
weixin_44873668的博客
08-13 1107
依赖表 -- Create table create table TIMERECORD ( jjr_id VARCHAR2(36) not null, jjr_time DATE not null, jjr_state NUMBER(2) default 0, jjr_remark VARCHAR2(200), jjr_creattime TIMESTAMP(6) default sysdate not null, jjr_creatu
oracle数据库获取多少天后的下一个工作日（工作日维护）
weixin_44873668的博客
08-13 727
话不多说直接上代码 -- Create table create table TIMERECORD ( jjr_id VARCHAR2(36) not null, jjr_time DATE not null, jjr_state NUMBER(2) default 0, jjr_remark VARCHAR2(200), jjr_creattime TIMESTAMP(6) default sysdate not null, jjr_
Oracle 自定义函数实现列转行效果
weixin_44873668的博客
03-09 503
oracle 列转行 CREATE OR REPLACE FUNCTION columns_to_string( p_str_tab IN type_table_string, p_separator IN VARCHAR2 DEFAULT ',' ) RETURN VARCHAR2 IS v_ret_str VARCHAR2(4000); BEGIN FOR i IN 1..p_str_tab.COUNT LOOP v_ret_str:=v_ret_str||p_separa
SQL查询修改通用处理工具
weixin_44873668的博客
12-09 402
/** * 得到总和的数量 * @param sqlNeedDeal sql 是否需要处理 * @param sql * @param params * @return */ public int getCount(boolean sqlNeedDeal,String sql, Object... params) { int result = 0; if(sqlNeedDeal){ sql = "select count(0) from ("+sql+")"; }
解决sql server 2012 评估期已过数据备份与还原
weixin_44873668的博客
01-06 380
还原数据库 使用T-SQL脚本备份数据库 本分数据库语法：backup database 数据库名 to disk=路径； 示例：backup database testss to disk='D:\SqlTest\backup\testss.bak'; 使用T-SQL脚本还原数据库 还原数据库语法： restore database 数据库名 from disk=完整路径; 示例：restore database testss from disk='D:\SqlTes...
mybatis逆向工程全部配置
weixin_44873668的博客
08-08 276
https://www.jianshu.com/p/74ab984b4fee 这一篇不错和自己写的差不多不过我用的oracle数据库
Oracle概要文件与触发器
weixin_44873668的博客
01-03 107
--创建概要文件 CREATE PROFILE "SY_UNLIMITED" LIMIT COMPOSITE_LIMIT UNLIMITED SESSIONS_PER_USER UNLIMITED CPU_PER_SESSION UNLIMITED CPU_PER_CALL UNLIMITED LOGICAL_READS_PER_SESSION UNLIMITED LOG...
redis.clients.jedis.Jedis
最新发布
08-02
引用[1]和[2]提供了关于使用Jedis连接Redis的示例代码和说明。根据这些代码，可以看出redis.clients.jedis.Jedis是Jedis客户端的一个类。在示例代码中，通过创建Jedis对象，指定Redis服务器的IP地址和端口号，然后使用auth方法设置连接密码，使用set方法存储键值对，使用get方法获取键对应的值。最后，通过调用close方法关闭Jedis连接。所以，redis.clients.jedis.Jedis是用于与Redis服务器建立连接并进行数据操作的类。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值