四.Redis极简入门-Java操作Redis

转x33g5p2x  于2021-12-19 转载在 其他  
字(11.3k)|赞(0)|评价(0)|浏览(652)

1.Java集成Jedis

开始在 Java 中使用 Redis 前， 我们需要确保已经安装并启动 redis 服务及 Java redis 驱动，且你的机器上能正常使用 Java。可以取Maven仓库下载驱动包 下载 jedis.jar，。

1.1.搭建工程
  • 搭建普通java项目，项目名：jedis-demo
1.2.导入Jedis依赖
  • 把Jedis和连接池包一起导入进来
  1. commons-pool2-2.2.jar		#连接池
  2. jedis-2.5.2.jar			    #Jedis核心包
1.3.编写测试类
  • 通过Jedis客户端对象连接Redis，调用API进行Redis
  1. @Test
  2. public void testJedis()throws Exception{
  3.     //创建连接
  4.     String host ="127.0.0.1";
  5.     //端口
  6.     int port = 6379;
  7. 	//超时时间,1秒超时
  8.     int timeout = 1000;
  9.     //jedis客户端
  10.     Jedis jedis = new Jedis(host,port,timeout);
  11.     //认证
  12.     jedis.auth("123456");
  13.     //执行操作,保存值
  14.     jedis.set("username","wang da cui");
  15.     //获取值
  16.     String result = jedis.get("username");
  17.     System.out.print(result);
  18.     //关闭连接
  19.     jedis.close();
  20. }
1.4.连接池的使用

如果直接使用 Jedis链接Redis会造成频繁的Jedis对象创建和销毁，对性能会有很大的影响，所以我们会选择使用连接池来链接性能。原理同Mysql连接池

  • 编写测试方法，使用JedisPool连接池对象
  1. @Test
  2. public void test()throws Exception{
  3.     //1 创建jedispool配置对象
  4.     JedisPoolConfig config = new JedisPoolConfig();
  5.     //2 做配置
  6.     //最大空闲连接数
  7.     config.setMaxIdle(2);
  8.     //最大链接对象数
  9.     config.setMaxTotal(10);
  10.     //链接超时时间
  11.     config.setMaxWaitMillis(1*1000);
  12.     //获取连接是测试连接是否畅通
  13.     config.setTestOnBorrow(true);
  14.     //3 创建jedispool连接池对戏
  15.     //参数：配置对象，redis主机地址 ，超时时间，密码
  16.     JedisPool pool = new JedisPool(config,"127.0.0.1",6379,1*1000,"123456");
  17.     //4 通过jedispool获取连接
  18.     Jedis jedis = pool.getResource();
  19.     //5 执行操作
  20.     jedis.set("age",10);
  21.     String result = jedis.get("age");
  22.     System.out.println(result);
  23.     // 6 释放连接 , 底层做了兼容,如果是连接池操作就是释放,如果是连接操作就是关闭
  24.     jedis.close(); 
  25.     // 7 摧毁连接池-如果是真正项目中它应该是一个受spring管理的单例
  26.     pool.destroy();
  27. }
  • 工具类封装：JedisPool应该是单例的(想想你的Mybatis的DataSource也只是创建了一个)，为了方便使用，将JedisPool封装成工具。

redis.properties

  1. redis.host=127.0.0.1
  2. redis.port=6379
  3. redis.password=123456
  4. redis.timeout=5000

RedisUtils

  1. package org.example;
  3. import redis.clients.jedis.Jedis;
  4. import redis.clients.jedis.JedisPool;
  5. import redis.clients.jedis.JedisPoolConfig;
  7. import java.io.IOException;
  8. import java.util.List;
  9. import java.util.Map;
  10. import java.util.Properties;
  11. import java.util.Set;
  13. /** * 获取连接池对象 */
  14. public enum RedisUtils {
  16.     INSTANCE;
  18.     //连接池
  19.     static JedisPool jedisPool = null;
  21.     static {
  22.         //1 创建连接池配置对象
  23.         JedisPoolConfig config = new JedisPoolConfig();
  24.         //2 进行配置-四个配置
  25.         config.setMaxIdle(1);//最小连接数
  26.         config.setMaxTotal(11);//最大连接数
  27.         config.setMaxWaitMillis(10 * 1000L);//最长等待时间
  28.         config.setTestOnBorrow(true);//测试连接时是否畅通
  29.         //3 通过配置对象创建连接池对象
  30.         Properties properties = null;
  31.         try {
  32.             properties = new Properties();
  33.             properties.load(RedisUtils.class.getClassLoader().getResourceAsStream("redis.properties"));
  34.         } catch (IOException e) {
  35.             e.printStackTrace();
  36.         }
  37.         String host = properties.getProperty("redis.host");
  38.         String port = properties.getProperty("redis.port");
  39.         String password = properties.getProperty("redis.password");
  40.         String timeout = properties.getProperty("redis.timeout");
  42.         jedisPool = new JedisPool(config, host, Integer.valueOf(port),Integer.valueOf(timeout), password);
  43.     }
  45.     //获取连接
  46.     public Jedis getSource() {
  47.         return jedisPool.getResource();
  48.     }
  50.     //关闭资源
  51.     public void closeSource(Jedis jedis) {
  52.         if (jedis != null) {
  53.             jedis.close();
  54.         }
  56.     }
  58.     /** * hash操作字符串============================================== */
  59.     public List<String> hvals(String key) {
  60.         Jedis jedis = getSource();
  61.         List<String> hvals = jedis.hvals(key);
  62.         closeSource(jedis);
  63.         return hvals;
  64.     }
  65.     public Set<String> hkeys(String key) {
  66.         Jedis jedis = getSource();
  67.         Set<String> hkeys = jedis.hkeys(key);
  68.         closeSource(jedis);
  69.         return hkeys;
  70.     }
  72.     public Long hset(String key,String field,String value) {
  73.         Jedis jedis = getSource();
  74.         Long result = jedis.hset(key,field,value);
  75.         closeSource(jedis);
  76.         return result;
  77.     }
  78.     public String hmset(String key, Map<String,String> data) {
  79.         Jedis jedis = getSource();
  80.         String result = jedis.hmset(key,data);
  81.         closeSource(jedis);
  82.         return result;
  83.     }
  84.     public String hget(String key,String field) {
  85.         Jedis jedis = getSource();
  86.         String value = jedis.hget(key, field);
  87.         closeSource(jedis);
  88.         return value;
  89.     }
  90.     /** * hash操作byte[]============================================== */
  91.     public List<byte[]> hvals(byte[] key) {
  92.         Jedis jedis = getSource();
  93.         List<byte[]> hvals = jedis.hvals(key);
  94.         closeSource(jedis);
  95.         return hvals;
  96.     }
  97.     public Set<byte[]> hkeys(byte[] key) {
  98.         Jedis jedis = getSource();
  99.         Set<byte[]> hkeys = jedis.hkeys(key);
  100.         closeSource(jedis);
  101.         return hkeys;
  102.     }
  104.     public Long hset(byte[] key,byte[] field,byte[] value) {
  105.         Jedis jedis = getSource();
  106.         Long result = jedis.hset(key,field,value);
  107.         closeSource(jedis);
  108.         return result;
  109.     }
  110.     public String hmset(byte[] key, Map<byte[],byte[]> data) {
  111.         Jedis jedis = getSource();
  112.         String result = jedis.hmset(key,data);
  113.         closeSource(jedis);
  114.         return result;
  115.     }
  116.     public byte[] hget(byte[] key,byte[] field) {
  117.         Jedis jedis = getSource();
  118.         byte[] value = jedis.hget(key, field);
  119.         closeSource(jedis);
  120.         return value;
  121.     }
  123.     /** * 删除key */
  124.     public boolean del(String key) {
  125.         Jedis jedis = getSource();
  126.         long result  = jedis.del(key);
  127.         closeSource(jedis);
  128.         return result > 0;
  129.     }
  131.     /** * 设置字符值 * * @param key * @param value :value是字符串，如果要存储对象，转成JSON字符串在存储 */
  132.     public void set(String key, String value) {
  133.         Jedis jedis = getSource();
  134.         jedis.set(key, value);
  135.         closeSource(jedis);
  136.     }
  138.     /** * 设置 * @param key * @param value */
  139.     public void set(byte[] key, byte[] value) {
  140.         Jedis jedis = getSource();
  141.         jedis.set(key, value);
  142.         closeSource(jedis);
  143.     }
  145.     /** * * @param key * @return */
  146.     public byte[]  get(byte[] key) {
  147.         Jedis jedis = getSource();
  148.         try {
  149.             return jedis.get(key);
  150.         } catch (Exception e) {
  151.             e.printStackTrace();
  152.         } finally {
  153.             closeSource(jedis);
  154.         }
  155.         return null;
  157.     }
  159.     /** * 设置字符值 * * @param key * @return ：返回的是JSON格式的字符串 ，考虑转对象 */
  160.     public String get(String key) {
  161.         Jedis jedis = getSource();
  162.         try {
  163.             return jedis.get(key);
  164.         } catch (Exception e) {
  165.             e.printStackTrace();
  166.         } finally {
  167.             closeSource(jedis);
  168.         }
  170.         return null;
  171.     }
  172. }

2.Jedis的API操作

使用jedis来操作redis的key和value，而value有很多种类型，和命令操作一样。

2.1.key的操作
  1. System.out.println(jedis.keys("*"));
2.2.String的操作
  1. System.out.println(jedis.set("name","zhangsan"));//新增
  2. System.out.println(jedis.get("name"));//获取
  3. System.out.println(jedis.set("name","zhangsan1"));//修改
  4. System.out.println(jedis.get("name"));//获取
  5. System.out.println(jedis.del("name"));//删除
  6. System.out.println(jedis.keys("*"));//查看所有的key
2.3.List的操作
  1. jedis.lpush("students1","1","2","3","5","6");	//添加数据
  2. System.out.println(jedis.lrange("students1", 0, 3));	//获取数据
  • 排序操作，对于数字元素排序不需要加SortingParams，对于字符串需要指定SortingParams，并且指定使用assii值排序
  1. //对数字排序
  2. jedis.flushDB();
  3. //添加数据
  4. jedis.lpush("nums","1","2","3","4","8","5","3","1");
  5. //排序
  6. System.out.println(jedis.sort("nums"));
  7. //指定排序方式
  8. SortingParams sortingParams1 = new SortingParams();
  9. sortingParams1.desc();
  10. System.out.println(jedis.sort("nums", sortingParams1));
  12. //对字母排序
  13. jedis.lpush("langues","java","php","c++","test","ui");
  14. SortingParams sortingParams = new SortingParams();
  15. sortingParams.alpha();
  16. sortingParams.desc();
  18. System.out.println(jedis.sort("langues",sortingParams));
2.4.Set的操作
  1. jedis.sadd("students2","a1","b1","c1","b1");		//添加数据
  2. System.out.println(jedis.smembers("students2"));	//获取成员
2.5.Hash操作
  1. jedis.hset("students3","student","zhangsan");			//添加数据
  2. System.out.println(jedis.hget("students3", "student"));	 //获取数据
2.6.Hash存储对象

序列化SerializeUtil.java

  1. import java.io.ByteArrayInputStream;
  2. import java.io.ByteArrayOutputStream;
  3. import java.io.ObjectInputStream;
  4. import java.io.ObjectOutputStream;
  6. public class SerializeUtil {
  7.     /** * 序列化 * * @param object * @return */
  8.     public static byte[] serialize(Object object) {
  9.         ObjectOutputStream oos = null;
  10.         ByteArrayOutputStream baos = null;
  11.         try {
  12.             // 序列化
  13.             baos = new ByteArrayOutputStream();
  14.             oos = new ObjectOutputStream(baos);
  15.             oos.writeObject(object);
  16.             byte[] bytes = baos.toByteArray();
  17.             return bytes;
  18.         } catch (Exception e) {
  20.         }
  21.         return null;
  22.     }
  24.     /** * 反序列化 * * @param bytes * @return */
  25.     public static Object unserialize(byte[] bytes) {
  26.         ByteArrayInputStream bais = null;
  27.         try {
  28.             // 反序列化
  29.             bais = new ByteArrayInputStream(bytes);
  30.             ObjectInputStream ois = new ObjectInputStream(bais);
  31.             return ois.readObject();
  32.         } catch (Exception e) {
  34.         }
  35.         return null;
  36.     }
  37. }

实体类User.java

  1. import java.io.Serializable;
  3. public class User implements Serializable {
  5.     @Override
  6.     public String toString() {
  7.         return "User{" +
  8.                 "username='" + username + '\'' +
  9.                 ", id=" + id +
  10.                 '}';
  11.     }
  13.     private String username;
  14.     private Long id;
  16.     public String getUsername() {
  17.         return username;
  18.     }
  20.     public void setUsername(String username) {
  21.         this.username = username;
  22.     }
  24.     public Long getId() {
  25.         return id;
  26.     }
  28.     public void setId(Long id) {
  29.         this.id = id;
  30.     }
  32.     public User() {
  33.     }
  35.     public User(String username, Long id) {
  36.         this.username = username;
  37.         this.id = id;
  38.     }
  39. }

测试代码

  1. import com.alibaba.fastjson.JSON;
  2. import org.junit.Test;
  4. import java.util.*;
  6. public class RedisTest {
  8.     private User createUser(){
  9.         return new User("zs",1L);
  10.     }
  12.     private List<User> createUsers(){
  13.         return Arrays.asList(
  14.                 new User("zs",1L),
  15.                 new User("zs",2L),
  16.                 new User("zs",3L),
  17.                 new User("zs",4L),
  18.                 new User("zs",5L),
  19.                 new User("zs",6L));
  20.     }
  22.     //查询所有的用户
  23.     //根据id查询某个用户
  24.     @Test
  25.     public void test(){
  27.         //存放====================================================================
  28.         List<User> users = createUsers();
  30.         Map<String,String> data = new HashMap<>(users.size());
  32.         users.forEach(user -> {
  33.             data.put(user.getId().toString(),JSON.toJSONString(user));
  34.         });
  36.         String hmsetResult = RedisUtils.INSTANCE.hmset("users", data);
  37.         System.out.println(hmsetResult);
  38.         RedisUtils.INSTANCE.hset("users","7",JSON.toJSONString(new User("zs",7L)));
  40.         //取所有值==================================================================
  41.         List<String> values = RedisUtils.INSTANCE.hvals("users");
  42.         List<User> result  = new ArrayList<>(values.size());
  43.         values.forEach(value ->{
  44.             result.add(JSON.parseObject(value,User.class));
  45.         });
  46.         System.out.println(values);
  48.         //根据ID取User==============================================================
  50.         String user = RedisUtils.INSTANCE.hget("users","1");
  51.         System.out.println(user);
  52.     }
  54.     //查询所有的用户
  55.     //根据id查询某个用户
  56.     @Test
  57.     public void test2(){
  59.         //存放====================================================================
  60.         List<User> users = createUsers();
  62.         Map<byte[],byte[]> data = new HashMap<>(users.size());
  64.         users.forEach(user -> {
  65.             data.put(user.getId().toString().getBytes(),SerializeUtil.serialize(user));
  66.         });
  68.         String hmsetResult = RedisUtils.INSTANCE.hmset("users".getBytes(), data);
  69.         System.out.println(hmsetResult);
  70.         RedisUtils.INSTANCE.hset("users".getBytes(),"7".getBytes(),SerializeUtil.serialize(new User("zs",7L)));
  72.         //取所有值==================================================================
  73.         List<byte[]> values = RedisUtils.INSTANCE.hvals("users".getBytes());
  74.         List<User> result  = new ArrayList<>(values.size());
  75.         values.forEach(value ->{
  76.             result.add(((User)SerializeUtil.unserialize(value)));
  77.         });
  78.         System.out.println(result);
  80.         //根据ID取User==============================================================
  82.         byte[] user = RedisUtils.INSTANCE.hget("users".getBytes(),"7".getBytes());
  83.         System.out.println(SerializeUtil.unserialize(user));
  84.     }
  86.     //查询所有的用户
  87.     //根据id查询某个用户
  88.     @Test
  89.     public void test3(){
  91.         //存放====================================================================
  92.         RedisUtils.INSTANCE.hset("users".getBytes(),"7".getBytes(),SerializeUtil.serialize(new User("zs",7L)));
  94.         //根据ID取User==============================================================
  96.         byte[] user = RedisUtils.INSTANCE.hget("users".getBytes(),"7".getBytes());
  97.         System.out.println(SerializeUtil.unserialize(user));
  98.     }
  99. }
2.7.事务操作
  1. jedis.set("name","zs");
  2. jedis.set("age",18);
  4. //开启事务
  5. Transaction multi = jedis.multi();
  6. multi.incr("name");
  7. multi.incr("age");
  8. //提交事务
  9. List<Object> result = multi.exec();
  10. System.out.println(result);
  12. //关闭连接
  13. jedis.close();
  15. //关闭连接池
  16. pool.destory();

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/u014494148/article/details/108222756

内容来源于网络，如有侵权，请联系作者删除！

redisnosql缓存数据库

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com