java调用redis的多种方式与心得
阅读原文时间:2023年07月08日阅读:1

心得:

/**
* 心得:
* 1.连接方式主要有:直连同步,直连事务,直连管道,直连管道事务,分布式直连同步,分布式直连管道,
* 分布式连接池同步,分布式连接池管道;普通连接池同步,普通连接池管道;
* 2.同步方式会返回数据库执行结果,管道则不会返回数据库执行结果;
* 3。管道分两种执行方式:有返回命令执行结果,无返回命令执行结果;
* 4.返回数据库执行结果 与 返回命令执行结果 不是一个东西; * 5一般管道的无返回命令执行结果 的执行方式会比 有返回结果的方式快一点点,,但是在分布式连接池的测试里则得出相反的结果, * 因此,这两种管道方式的速度差距不大,按使用需求即可。 */

_ 测试源码 _

* redis几种调用方法
*/

/\*\*  
 \* 普通直连同步写入操作,于myRedis方法一样,都是单实例方法  
 \* \* 同步执行,会返回执行结果  
 \* 写入10万行字符串  
 \*/

@org.junit.Test  
public void r1() {  
    Jedis jedis = new Jedis("127.0.0.1", 6379);  
    //密码,如果服务器没有密码,则会报错,因此,要对用使用  
    //jedis.auth("admin");

    long start = System.currentTimeMillis();  
    for (int i = 0; i < 100000; i++) {  
        //返回的是个字符串  
        String res = jedis.set("n" + i, "n" + i);  
        System.out.println("返回的结果:" + res);  
        //返回的结果:OK  
    }  
    long end = System.currentTimeMillis();  
    System.out.println("普通同步写入:" + ((end - start) / 1000.0) + "秒");  
    jedis.close();  
}  

//结果:
//普通同步写入:5.792秒

/\*\*  
 \* 普通批量事物提交,, REDIS事物不支持回滚  
 \* 同步执行,会返回执行结果  
 \* 写入10万行字符串  
 \*/

1 @org.junit.Test
2 public void r2() {
3 Jedis jedis = null;
4 try {
5 jedis = new Jedis("127.0.0.1", 6379);
6 long start = System.currentTimeMillis();
7 //事务类型的参数 , REDIS事物不支持回滚
8 Transaction transaction = jedis.multi();
9 for (int i = 0; i < 100000; i++) { 10 //没有返回值 11 transaction.set("n" + i, "n" + i); 12 } 13 //执行事务,返回执行的命令结果 14 List res = transaction.exec();
15 // System.out.println("操作成功条数:" + res.size());
16 long end = System.currentTimeMillis();
17 System.out.println("普通批量事物写入:" + ((end - start) / 1000.0) + "秒");
18 //断开连接
19 jedis.disconnect();
20 } catch (Exception e) {
21 e.printStackTrace();
22 } finally {
23 if (jedis != null) {
24 System.out.println("未关闭");
25 jedis.close();
26 System.out.println("关闭成功");
27 } else {
28 System.out.println("已关闭");
29 }
30 }
31 // 操作成功条数:100000
32 // 普通批量事物写入:0.443秒
33 // 未关闭
34 // 关闭成功
35 }

/\*\*  
 \* 普通异步管道提交,不需要等待执行完成后的结果  
 \*/

1 @org.junit.Test
2 public void r3() {
3 Jedis jedis = null;
4 try {
5 jedis = new Jedis("127.0.0.1", 6379);
6 long start = System.currentTimeMillis();
7 Pipeline pipeline = jedis.pipelined();
8 for (int i = 0; i < 100000; i++) { 9 //没有返回值 10 pipeline.set("n" + i, "n" + i); 11 } 12 // //跟批量事务提交速度一样,syncAndReturnAll()会返回结果,花费0.406秒 13 // List res = pipeline.syncAndReturnAll();
14 // System.out.println("返回的结果条数:"+res.size());
15 //无结果返回,速度更快一点点,0.334秒左右即可
16 pipeline.sync();
17 long end = System.currentTimeMillis();
18 System.out.println("普通异步管道提交:" + ((end - start) / 1000.0) + "秒");
19 //断开连接
20 jedis.disconnect();
21 } catch (Exception e) {
22 e.printStackTrace();
23 } finally {
24 if (jedis != null) {
25 System.out.println("未关闭");
26 jedis.close();
27 System.out.println("关闭成功");
28 } else {
29 System.out.println("已关闭");
30 }
31 }
32 }

/\*\*  
 \* 在异步管道中使用事务  
 \* 效率和单独使用事务差不多  
 \*/

@org.junit.Test
public void r4() {
Jedis jedis = null;
try {
jedis = new Jedis("127.0.0.1", 6379);
long start = System.currentTimeMillis();
Pipeline pipeline = jedis.pipelined();
//管道开启事务
pipeline.multi();
for (int i = 0; i < 100000; i++) { //没有返回值 pipeline.set("n" + i, "n" + i); } //执行事务 pipeline.exec(); // //执行管道,返回执行的命令结果,,花费时间0.413秒 // List res = pipeline.syncAndReturnAll();
//// for (Object ob:res){
//// System.out.println(ob);
//// }
//// System.out.println("返回的结果条数:" + res.size());
//无返回值,花费的时间0.366秒
pipeline.sync();
long end = System.currentTimeMillis();
System.out.println("普通异步管道提交:" + ((end - start) / 1000.0) + "秒");
//断开连接
jedis.disconnect();
// 普通异步管道提交:0.334秒
} catch (Exception e) {
e.printStackTrace();
} finally {
if (jedis != null) {
System.out.println("未关闭");
jedis.close();
System.out.println("关闭成功");
} else {
System.out.println("已关闭");
}
}
}

/\*\*  
 \* 分布式直连,普通同步操作  
 \* 与普通的单例连接速度一样  
 \*/

1 @org.junit.Test
2 public void r5() {
3 long start = System.currentTimeMillis();
4 //生产环境下,这里一般换成不同的ip,也就是说,使用从机
5 List shardInfos = Arrays.asList(
6 new JedisShardInfo("127.0.0.1", 6379),
7 new JedisShardInfo("127.0.0.1", 6379));
8 ShardedJedis shardedJedis = new ShardedJedis(shardInfos);
9 for (int i = 0; i < 100000; i++) {
10 //返回的是个字符串
11 String res = shardedJedis.set("n" + i, "n" + i);
12 // System.out.println("返回的结果:" + res);
13 //返回的结果:OK
14 }
15 long end = System.currentTimeMillis();
16 System.out.println("分布式直连:" + ((end - start) / 1000.0) + "秒");
17 //断开连接
18 shardedJedis.disconnect();
19 //关闭连接
20 shardedJedis.close();
21 // 分布式直连:5.254秒
22 }

/\*\*  
 \* 分布式直连,使用管道  
 \* <p>  
 \* 十万条数据花费0.457秒  
 \*/

1 @org.junit.Test
2 public void r6() {
3 long start = System.currentTimeMillis();
4 //生产环境下,这里一般换成不同的ip,也就是说,使用从机
5 List shardInfos = Arrays.asList(
6 new JedisShardInfo("127.0.0.1", 6379),
7 new JedisShardInfo("127.0.0.1", 6379));
8 ShardedJedis shardedJedis = new ShardedJedis(shardInfos);
9 //开启异步管道
10 ShardedJedisPipeline shardedJedisPipeline = shardedJedis.pipelined();
11 for (int i = 0; i < 100000; i++) { 12 shardedJedisPipeline.set("n" + i, "n" + i); 13 } 14 //有返回结果的执行方式,其实是个以队列的形式发送命令,然后返回执行命令结果 15 List list = shardedJedisPipeline.syncAndReturnAll();
16 long end = System.currentTimeMillis();
17 System.out.println("分布式管道:" + ((end - start) / 1000.0) + "秒");
18 shardedJedis.disconnect();
19 shardedJedis.close();
20 // 分布式管道:0.457秒
21 }

/\*\*  
 \* 分布式连接池,适合多线程  
 \* <p>  
 \* 同步调用  
 \*/

1 @org.junit.Test
2 public void r7() {
3 long start = System.currentTimeMillis();
4 //生产环境下,这里一般换成不同的ip,也就是说,使用从机
5 List shardInfos = Arrays.asList(
6 new JedisShardInfo("127.0.0.1", 6379),
7 new JedisShardInfo("127.0.0.1", 6379));
8 //new JedisPoolConfig() 表示默认设置,可以自定义设置属性参数,这里不展示
9 ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shardInfos);
10 ShardedJedis shardedJedis = pool.getResource();
11 for (int i = 0; i < 100000; i++) {
12 //返回的是个字符串
13 String res = shardedJedis.set("n" + i, "n" + i);
14 // System.out.println("返回的结果:" + res);
15 //返回的结果:OK
16 }
17 pool.returnResource(shardedJedis);
18 long end = System.currentTimeMillis();
19 System.out.println("分布式连接池,同步调用:" + ((end - start) / 1000.0) + "秒");
20 //销毁连接池
21 pool.destroy();
22 //断开连接,这个可写可不写
23 shardedJedis.disconnect();
24 //关闭连接
25 //不可以在这里使用shardedJedis.close();
26 //否则会报错redis.clients.jedis.exceptions.JedisException: Could not return the resource to the pool
27 ////
28 //分布式连接池,同步调用:5.419秒
29 }

/\*\*  
 \* 分布式连接池,异步管道调用  
 \*/

1 @org.junit.Test
2 public void r8(){
3 long start = System.currentTimeMillis();
4 //生产环境下,这里一般换成不同的ip,也就是说,使用从机
5 List shardInfos = Arrays.asList(
6 new JedisShardInfo("127.0.0.1", 6379),
7 new JedisShardInfo("127.0.0.1", 6379));
8 //new JedisPoolConfig() 表示默认设置,可以自定义设置属性参数,这里不展示
9 ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shardInfos);
10 ShardedJedis shardedJedis = pool.getResource();
11 //开启管道
12 ShardedJedisPipeline pipeline = shardedJedis.pipelined();
13 for (int i = 0; i < 100000; i++) { 14 pipeline.set("n" + i, "n" + i); 15 } 16 // //有返回结果的执行方式,其实是个以队列的形式发送命令,然后返回执行命令结果 17 // List list = pipeline.syncAndReturnAll();
18 //无结果返回
19 pipeline.sync();
20 pool.returnResource(shardedJedis);
21 long end = System.currentTimeMillis();
22 System.out.println("分布式连接池,异步管道调用:" + ((end - start) / 1000.0) + "秒");
23 //销毁连接池
24 pool.destroy();
25 //断开连接,这个可写可不写
26 shardedJedis.disconnect();
27 //关闭连接
28 //不可以在这里使用shardedJedis.close();
29 //否则会报错redis.clients.jedis.exceptions.JedisException: Could not return the resource to the pool
30 ////
31 //有返回结果的执行方式
32 //分布式连接池,异步管道调用:0.49秒
33 //
34 //无结果返回执行方式
35 //分布式连接池,异步管道调用:0.517秒
36
37 }

/\*\*  
 \* 普通连接池同步  
 \*/

@org.junit.Test  
public void r9() {  
    long start = System.currentTimeMillis();  
    JedisPoolConfig config = new JedisPoolConfig();  

// //最大连接数
// config.setMaxTotal(30);
// //最大连接空闲数
// config.setMaxIdle(2);
JedisPool jedisPool = new JedisPool(config, "127.0.0.1", 6379);
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
for (int i = 0; i < 100000; i++) {
jedis.set("n" + i, "n" + i);
}
//如果加入这一句,则不能使用jedis.close();
// jedisPool.returnResource(jedis);
long end = System.currentTimeMillis();
System.out.println("普通连接池同步:" + ((end - start) / 1000.0) + "秒");
//销毁连接池
jedisPool.destroy();
//断开连接,这个可写可不写
jedis.disconnect();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (jedis != null) {
jedis.close();
}
}

}  

// 普通连接池同步:5.166秒

/\*\*  
 \* 普通连接池管道  
 \*/

1 @org.junit.Test
2 public void r10() {
3 long start = System.currentTimeMillis();
4 JedisPoolConfig config = new JedisPoolConfig();
5 // //最大连接数
6 // config.setMaxTotal(30);
7 // //最大连接空闲数
8 // config.setMaxIdle(2);
9 JedisPool jedisPool = new JedisPool(config, "127.0.0.1", 6379);
10 Jedis jedis = null;
11 try {
12 jedis = jedisPool.getResource();
13 Pipeline pipeline = jedis.pipelined();
14 for (int i = 0; i < 100000; i++) {
15 pipeline.set("n" + i, "n" + i);
16 }
17 pipeline.syncAndReturnAll();
18 //如果加入这一句,则不能使用jedis.close();
19 // jedisPool.returnResource(jedis);
20 long end = System.currentTimeMillis();
21 System.out.println("普通连接池管道:" + ((end - start) / 1000.0) + "秒");
22 //销毁连接池
23 jedisPool.destroy();
24 //断开连接,这个可写可不写
25 jedis.disconnect();
26 } catch (Exception e) {
27 e.printStackTrace();
28 } finally {
29 if (jedis != null) {
30 jedis.close();
31 }
32 }
33 // 普通连接池管道:0.457秒
34 }

手机扫一扫

移动阅读更方便

阿里云服务器
腾讯云服务器
七牛云服务器

你可能感兴趣的文章