Redis 客户端
概述
Redis 是一种C/S 架构的分布式缓存数据库,它有自带的命令行客户端,也有对应的Java或其它语言客户端,可以在这些客户端中通过一些API对redis进行读写操作。
准备工作
第一步:创建工程。
创建maven父工程,例如redis,并在此工程下创建两个子工程,一个为redis-jedis,一个为redis-template,例如:
第二步:添加父工程依赖
修改父工程pom.xml文件,添加编译配置
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>8</source>
<target>8</target>
</configuration>
</plugin>
</plugins>
</build>
Jedis的基本应用
简介
Jedis是Java中操作redis的一个客户端,类似通过jdbc访问mysql数据库。
准备工作
在redis-jedis 工程添加如下依赖
<dependencies>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.5.2</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.6</version>
</dependency>
</dependencies>
Jeids基本应用实践
在Jedis工程中的src/test/java目录创建单元测类,例如:
package com.jt;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import java.util.concurrent.TimeUnit;
public class JedisTests {
/**
* 测试是否可以连通redis。
*/
@Test
public void testGetConnection(){
Jedis jedis=new Jedis("192.168.126.129",6379);
String result = jedis.ping();
System.out.println(result);
}
/**
* 测试字符串操作
*/
@Test
public void testStringOper01(){
//1.建立连接
Jedis jedis=new Jedis("192.168.126.129",6379);
//2.执行redis数据操作(增删改查)
//2.1新增数据
jedis.set("id", "100");
jedis.set("name", "tony");
//2.2修改数据
jedis.incr("id");
jedis.incrBy("id", 100);//201
jedis.set("name", "Mike");//Mike
//2.3查询数据
String id = jedis.get("id");
String name = jedis.get("name");
System.out.println("id="+id+";name="+name);
//2.4删除数据
jedis.del("name");
//3.释放资源
jedis.close();
}
/**
* 测试字符串操作
*/
@Test
public void testStringOper02(){
//1.建立连接
Jedis jedis=new Jedis("192.168.126.129",6379);
//2.数据操作(将一个map对象转换为json字符串,然后写入到redis)
//2.1构建map对象
Map<String,String> map=new HashMap<>();
map.put("id", "100");
map.put("name", "Mike");
//2.2将map转换为字符串
Gson gson=new Gson();
String jsonStr = gson.toJson(map);
//2.3将字符串写入到redis
String key= UUID.randomUUID().toString();
jedis.set(key, jsonStr);
//3.释放资源
jedis.close();
}
/**
* 课堂练习:
* 基于hash类型将testStringOper02中对象写入到redis,
* 并且尝试进行查询,修改,删除等操作。
*/
@Test
public void testHash01(){
//1.建立连接
Jedis jedis=new Jedis("192.168.126.129",6379);
//2.执行hash数据操作
//2.1新增数据
String key= UUID.randomUUID().toString();
jedis.hset(key, "id", "500");
jedis.hset(key, "name", "Jack");
//2.2修改数据数据
jedis.hset(key, "name", "Jim");
//2.3查询数据
Map<String, String> map = jedis.hgetAll(key);
System.out.println(map);
//2.4删除数据
//jedis.del(key);
jedis.expire(key, 10);
//3.释放资源
jedis.close();
}
/**
* 测试:redis中list结构的应用
* 基于FIFO(First In First Out)算法,借助redis实现一个队列
*/
@Test
public void testListOper01(){
//1.建立连接
Jedis jedis=new Jedis("192.168.126.130",6379);
//2.存储数据
jedis.lpush("lst1","A","B","C","C");
//3.更新数据
Long pos=jedis.lpos("lst1","A");//获取A元素的位置
jedis.lset("lst1",pos,"D");//将A元素位置的内容修改为D
//4.获取数据
int len=jedis.llen("lst1").intValue();//获取lst1列表中元素个数
List<String> rpop = jedis.rpop("lst1",len);//获取lst1列表中所有元素
System.out.println(rpop);
//5.释放资源
jedis.close();
}
//list类型练习:实现一个阻塞式队列
@Test
public void testListOper02(){
//1.连接redis
Jedis jedis=new Jedis("192.168.126.128",6379);
//2.向队列存数据
//jedis.lpush("list1","A","B","C");
//3.按先进先出的顺序从队列取数据
List<String> list= jedis.brpop(40,"list1");
System.out.println(list);
jedis.brpop(40,"list1");
jedis.brpop(40,"list1");
jedis.brpop(40,"list1");
//4.释放资源
jedis.close();
}
//set类型练习
@Test
public void testSetOper01() {
//1.连接redis
Jedis jedis = new Jedis("192.168.126.128", 6379);
//2.朋友圈点赞
jedis.sadd("count", "1", "1", "2");
//3.取出点赞数
Set<String> set = jedis.smembers("count");
System.out.println(set);
//4.释放资源
jedis.close();
}
}
连接池JedisPool连接池应用
我们直接基于Jedis访问redis时,每次获取连接,释放连接会带来很大的性能开销,可以借助Jedis连接池,重用创建好的连接,来提高其性能,简易应用方式如下:
package com.jt;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class JedisPoolTests {
@Test
public void testJedisPool(){
//定义连接池的配置
JedisPoolConfig config=new JedisPoolConfig();
config.setMaxTotal(1000);//最大连接数
config.setMaxIdle(60);//最大空闲数
//创建连接池
JedisPool jedisPool=
new JedisPool(config,"192.168.126.130",6379);
//从池中获取一个连接
Jedis resource = jedisPool.getResource();
resource.auth("123456");
//通过jedis连接存取数据
resource.set("class","cgb2004");
String clazz=resource.get("class");
System.out.println(clazz);
//将链接返回池中
resource.close();
//关闭连接池
jedisPool.close();
}
}
我们可以基于池对象,设计一个数据源,将来在业务中通过一个数据源对象,从池中获取连接,不用每次获取连接都要创建池对象,例如:
package com.jt.redis;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class JedisDataSource {
private static final String IP="192.168.126.128";
private static final int PORT=6379;//redis.conf 默认端口
/**
* volatile 关键通常用于修饰属性:
* 1)保证线程其可见性(一个线程改了,其它CPU线程立刻可见)
* 2)禁止指令重排序
* 3)不能保证其原子性(不保证线程安全)
*/
private static volatile JedisPool jedisPool;
//方案1:饿汉式池对象的创建
/*static{
JedisPoolConfig config=new JedisPoolConfig();
config.setMaxTotal(16);
config.setMaxIdle(8);
jedisPool=new JedisPool(config,IP,PORT);
}
public static Jedis getConnection(){
return jedisPool.getResource();
}*/
//方案2:懒汉式池对象的创建
public static Jedis getConnection(){
if(jedisPool==null) {
synchronized (JedisDataSource.class) {
if (jedisPool == null) {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(16);
config.setMaxIdle(8);
jedisPool = new JedisPool(config, IP, PORT);
//创建对象分析
//1.开辟内存空间
//2.执行属性的默认初始化
//3.执行构造方法
//4.将创建的对象的内存地址赋值给jedisPool变量
//假如使用了volatile修饰jedisPool变量,可以保证如上几个步骤是顺序执行的
}
}
}
return jedisPool.getResource();
}
public static void close(){
jedisPool.close();
}
}
RedisTemplate基本应用
简介
RedisTemplate为SpringBoot工程中操作redis数据库的一个Java对象,此对象封装了对redis的一些基本操作。
准备工作
第一步:添加在redis-template工程添加依赖
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spr