从0开始学Redis（实战篇）

最新推荐文章于 2023-04-18 14:47:34 发布

code_jedi

最新推荐文章于 2023-04-18 14:47:34 发布

阅读量185

点赞数

分类专栏：数据库后台缓存Redis

本文链接：https://blog.csdn.net/qq_40664795/article/details/103833128

版权

后台同时被 3 个专栏收录

10 篇文章 0 订阅

订阅专栏

数据库

5 篇文章 0 订阅

订阅专栏

缓存Redis

2 篇文章 0 订阅

订阅专栏

简介：本次给大家讲解在项目中如何使用Redis

如果不清楚如何下载安装Linux版或Windows版以及一些基本操作，可以查看我的另一篇文章
从0开始学Redis（基础篇）
我使用的环境是IDEA+Maven+Springboot搭建的
Jedis是什么？
Redis官方首选的java客户端开发包（java-redis的组合）

在pom.xml文件中加入Jedis依赖

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

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

在application.properties文件里配置redis信息

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

直接连接一个Jedis资源

/*******************************************直接连接一个jedis资源start************************************/
    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("127.0.0.1",6379);
        //设置密码
        jedis.auth("123456");
        System.out.println("连接成功");
        //查看服务是否运行
        System.out.println("服务正在运行: "+jedis.ping());
        //进行操作
        jedis.set("key","value");
    }
    /*******************************************直接连接一个jedis资源end************************************/
    实际开发中一般不使用这种方式，效率太低了。一般使用连接池方式JedisPool

创建一个生成JedisPool的工厂

一般情况下创建一个包NewRedisConfig，包下创建一个类NewJedisPoolFactory
package cn.test.demo.exercise.NewRedis.NewRedisConfig;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * <p>创建一个生成JedisPool的工厂</p>
 */
@Configuration
public class NewJedisPoolFactory {
    /******************************************从连接池中获取jedis资源start**********************************/
    //获取redis服务的配置信息
    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxActive;

    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.jedis.pool.min-idle}")
    private int minIdle;

    @Value("${spring.redis.jedis.pool.max-wait}")
    private long maxWaitMillis;

	//注入信息，创建JedisPool实例
    @Bean
    public JedisPool generateJedisPoolFactory() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(maxActive);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setMaxWaitMillis(maxWaitMillis);
        JedisPool jedisPool = new JedisPool(poolConfig, host, port, timeout, password);
        return jedisPool;
    }
    /******************************************从连接池中获取jedis资源end**********************************/
    
}

创建一个RedisUtil类

package cn.test.demo.exercise.NewRedis.NewRedisUtil;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import javax.annotation.Resource;

/**
 * <p>编写工具类</p>
 * <p>这里的@Component注解不能丢，否则jedisPool为空，</p>
 */
@Component
@RestController
@RequestMapping("/newRedisUtil")
public class NewRedisUtil {
    @Qualifier("generateJedisPoolFactory")    //在Controller中需要注入service那么我的这个server有两个实现类如何区分开这两个impl呢？表明了哪个实现类才是我们所需要的
    @Autowired
    private JedisPool jedisPool;

    /**
     * 存储字符串键值对
     * @param key
     * @param value
     * @return
     */
    @RequestMapping("/set")
    public String set(String key, String value) throws Exception {
        Jedis jedis = jedisPool.getResource();  //从连接池中获取连接
        try {
            return jedis.set(key, value);       //添加数据
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        } finally {
            jedis.close();                      //使用完关闭资源
        }
    }

    /**
     * 得到对应键的字符串值
     * @param key
     * @return
     */
    @RequestMapping("/get")
    public String get(String key) throws Exception {
        Jedis jedis = jedisPool.getResource();
        try {
            return jedis.get(key);              //通过key获取相对于的值
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        } finally {
            jedis.close();
        }
    }

    /**
     * 删除字符串键值对
     * @param key
     * @return
     */
    @RequestMapping("/del")
    public Long del(String key) throws Exception {
        Jedis jedis = jedisPool.getResource();
        try {
            return jedis.del(key);
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        } finally {
            jedis.close();
        }
    }

    /**
     * 存储对象
     * @param key
     * @param value
     */
    @RequestMapping("/setObject")
    public String setObject(String key, Object value) throws Exception {
        Jedis jedis = jedisPool.getResource();
        try {
            return jedis.set(key.getBytes(), ObjectUtil.serialize(value));
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        } finally {
            jedis.close();
        }
    }

    /**
     * 得到对应键的对象
     * @param key
     * @return
     */
    @RequestMapping("/getObject")
    public Object getObject(String key) throws Exception {
        Jedis jedis = jedisPool.getResource();
        try {
            byte[] byteArr =  jedis.get(key.getBytes());
            return ObjectUtil.unSerialize(byteArr);
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        } finally {
            jedis.close();
        }
    }
}

上面如果有存入对象的话需要进行序列化（存值时）和反序列化（取值时）
在工具包创建ObjectUtil类
package cn.test.demo.exercise.NewRedis.NewRedisUtil;

import java.io.*;
import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Map;

public class ObjectUtil {
    /**
     * 判断对象是否为空
     *
     * @param o
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static boolean isEmpty(Object o) {
        if (o == null) {
            return true;
        } else if (o instanceof String) {
            String s = (String) o;
            if ("".equals(s.trim())) {
                return true;
            } else {
                return false;
            }
        } else if (o instanceof Collection) {
            return ((Collection) o).isEmpty();
        } else if (o instanceof Map) {
            return ((Map) o).isEmpty();
        } else if (o.getClass().isArray()) {
            return Array.getLength(o) == 0;
        } else {
            return false;
        }
    }

    /**
     * 将对象序列化
     *
     * @param o
     * @return
     */
    public static byte[] serialize(Object o) throws Exception {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
            oos = new ObjectOutputStream(baos);
            oos.writeObject(o);
        } catch (IOException e) {
            e.printStackTrace();
            throw new Exception(e.getMessage());
        } finally {
            closeObjectOutputStream(oos);
        }
        return baos.toByteArray();
    }

    /**
     * 将对象反序列化
     *
     * @param byteArr
     * @return
     */
    public static Object unSerialize(byte[] byteArr) throws Exception {
        ObjectInputStream ois = null;
        ByteArrayInputStream bais = new ByteArrayInputStream(byteArr);
        Object o = null;
        try {
            ois = new ObjectInputStream(bais);
            o = ois.readObject();
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        } finally {
            closeObjectIutputStream(ois);
        }
        return o;
    }

    /**
     * 关闭对象输出流
     * @param oos
     */
    private static void closeObjectOutputStream(ObjectOutputStream oos) throws Exception {
        if (oos != null) {
            try {
                oos.close();
            } catch (IOException e) {
                throw new Exception(e.getMessage());
            }
        }
        oos = null;
    }

    /**
     * 关闭对象输入流
     * @param ois
     */
    private static void closeObjectIutputStream(ObjectInputStream ois) throws Exception {
        if (ois != null) {
            try {
                ois.close();
            } catch (IOException e) {
                throw new Exception(e.getMessage());
            }
        }
        ois = null;
    }
}

上面是一个完整的例子

*下面写多一个例子，pom.xml文件和application文件的配置不变

在redis包创建config包、controller包、service包、serviceImpl包
在config包下创建RedisConfig类

package cn.test.demo.exercise.redis.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class RedisConfig {

   // private static Logger logger = LoggerFactory.getLogger(MQSender.class);

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxActive;

    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.jedis.pool.min-idle}")
    private int minIdle;

    @Value("${spring.redis.jedis.pool.max-wait}")
    private long maxWaitMillis;

    /**
     * 注入 RedisConnectionFactory
     */
    @Autowired
    RedisConnectionFactory redisConnectionFactory;

    @Bean
    public JedisPool redisPoolFactory() {
        System.out.println("JedisPool注入成功！！");
        System.out.println("redis地址：" + host + ":" + port);
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);

        JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);

        return jedisPool;
    }

    /**
     * 实例化 RedisTemplate 对象
     *
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> functionDomainRedisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
        return redisTemplate;
    }

    /**
     * 设置数据存入 redis 的序列化方式
     *
     * @param redisTemplate
     * @param factory
     */
    private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
        redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
        redisTemplate.setConnectionFactory(factory);
    }

    /**
     * 实例化 HashOperations 对象,可以使用 Hash 类型操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    /**
     * 实例化 ValueOperations 对象,可以使用 String 操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    /**
     * 实例化 ListOperations 对象,可以使用 List 操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    /**
     * 实例化 SetOperations 对象,可以使用 Set 操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    /**
     * 实例化 ZSetOperations 对象,可以使用 ZSet 操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}

3.在service包下创建RedisServer

package cn.test.demo.exercise.redis.service;

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

public interface RedisService<T> {
    /**
     * 存入redis中的key
     *
     * @return
     */
    //protected abstract String getRedisKey();

    /**
     * <p>添加：给一个集合添加某一个属性和属性值</p>
     * @param hashKey 集合key中的key(集合里的属性key)
     * @param value   hashKey对应的值
     * @param expire  过期时间(单位:秒),传入 -1 时表示不设置过期时间
     */
    public void put(String hashKey, T value, long expire);

    /**
     * <p>删除:删除map集合中一个或多个hashkey</p>
     * @param hashKeys 一个或多个map集合的key
     * @return Long
     */
    public Long delete(Object... hashKeys);

    /**
     * <p>查询哪个集合中的哪个值</p>
     * @param hashKey 查询的key
     * @return
     */
    public T get(Object hashKey);

    /**
     * <p>获取集合中所有元素的value</p>
     * @return
     */
    public List<T> getAll();

    /**
     * <p>获取集合中所有hashkey</p>
     * @return
     */
    public Set<String> getKeys();

    /**
     * <p>判断当前集合中是否已经存在hash</p>
     * @param hashKey 传入集合里的hashKey
     * @return
     */
    public boolean isKeyExists(Object hashKey);

    /**
     * <p>获取集合长度</p>
     * @return
     */
    public long count();

    /**
     * 清空redis
     */
    public void empty();

}

4.在serviceImpl包下创建RedisServiceImpl实现类

package cn.test.demo.exercise.redis.service.impl;

import cn.test.demo.exercise.redis.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

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

@Service
public class RedisServiceImpl<T> implements RedisService<T> {

    @Autowired
    protected RedisTemplate<String,Object> redisTemplate;
    @Resource
    protected HashOperations<String,String,T> hashOperations;  //HashOperations处理集合等操作
    //集合key,也就是表示哪一个集合
    private static final String LIST_KEY = "REDIS_KEY";
    /**
     * <p>添加：给一个集合添加某一个属性和属性值</p>
     * @param hashKey 集合key中的key(集合里的属性key)
     * @param value   hashKey对应的值
     * @param expire  过期时间(单位:秒),传入 -1 时表示不设置过期时间
     */
    @Override
    public void put(String hashKey, T value, long expire) {
        hashOperations.put(LIST_KEY,hashKey,value);//给key为LIST_KEY的集合添加属性key为hashKey的值
        if(expire != -1){   //如果不是-1，则设计过期时间
            redisTemplate.expire(hashKey,expire, TimeUnit.SECONDS);//TimeUnit.SECONDS意思是单位为妙
        }
    }

    /**
     * <p>删除:删除map集合中一个或多个hashkey</p>
     * @param hashKeys 一个或多个map集合的key
     * @return Long
     */
    @Override
    public Long delete(Object... hashKeys) {
        Long result = hashOperations.delete(LIST_KEY,hashKeys);//删除哪个集合的哪些hashkey
        return result;
    }

    /**
     * <p>查询哪个集合中的哪个值</p>
     * @param hashKey 查询的key
     * @return
     */
    @Override
    public T get(Object hashKey) {

        return hashOperations.get(LIST_KEY,hashKey);
    }

    /**
     * <p>获取集合中所有元素的value</p>
     * @return
     */
    @Override
    public List<T> getAll() {
        return hashOperations.values(LIST_KEY);
    }

    /**
     * <p>获取集合中所有hashkey</p>
     * @return
     */
    @Override
    public Set<String> getKeys() {
        return hashOperations.keys(LIST_KEY);
    }

    /**
     * <p>判断当前集合中是否已经存在hash</p>
     * @param hashKey 传入集合里的hashKey
     * @return
     */
    @Override
    public boolean isKeyExists(Object hashKey) {

        return hashOperations.hasKey(LIST_KEY,hashKey);
    }

    /**
     * <p>获取集合长度</p>
     * @return
     */
    @Override
    public long count() {

        return hashOperations.size(LIST_KEY);
    }

    /**
     * <p>清空redis</p>
     */
    @Override
    public void empty() {
        Set<String> set = hashOperations.keys(LIST_KEY);
        set.stream().forEach(key -> hashOperations.delete(LIST_KEY,key));
    }

}

5.在controller包下创建RedisController类

package cn.test.demo.exercise.redis.controller;

import cn.test.demo.exercise.redis.pojo.RedisModel;
import cn.test.demo.exercise.redis.service.RedisService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/redisTest")
public class RedisCtroller {

    @Resource
    private RedisService redisService;

    /**
     * <p>添加对象到集合里</p>
     */
    @RequestMapping("/add1")
    @ResponseBody
    public void add(){
        System.out.println("进来 了");
        RedisModel redis = new RedisModel();
        redis.setRedisKey("RedisModelKey");
        redis.setName("张三2");
        redis.setAddress("地球村2");
        redis.setTel("13800138000");

        redisService.put("RedisModelKey",redis,-1);

    }

    @RequestMapping("/get")
    @ResponseBody
    public List<RedisModel> getAll() {
        return redisService.getAll();
    }

    /**
     * <p>添加对象到集合里</p>
     */
    @RequestMapping("/add2")
    public String add1(){
        return "haha";
    }
}

以上就是本次的全过程，如果要查看redis下载、安装以及配置可以看我这篇文章
从0开始学Redis（基础篇）

code_jedi

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
从0开始学Redis（实战篇）

简介：本次给大家讲解在项目中如何使用Redis如果不清楚如何下载安装Linux版或Windows版以及一些基本操作，可以查看我的另一篇文章从0开始学Redis（基础篇）我使用的环境是IDEA+Maven+Springboot搭建的Jedis是什么？Redis官方首选的java客户端开发包（java-redis的组合）在pom.xml文件中加入Jedis依赖 <depende...
复制链接

扫一扫