基于 Java 的管道技术使用

为了比较管道技术与 般情况下命令使用在时间上的区别，这里设计了一个测试比较

示例。其代码实现如下：

package com.threecoolcat.pipe;
import com.threecoolcat.pipe.redis.RedisUtil;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import java.io.IOException;

public class RedisTest {
    private Jedis jedis;

    @Before               // 注解before 表示在方法前执行
    public void initJedis() throws IOException {
        jedis = RedisUtil.initPool().getResource();//调用7.4.2节连接数据库功能
    }

    @Test
    public void PipecommendTest() {
        jedis.flushDB();      //调用flushDB命令，清除指定服务器上的0号数据库数据
        long t1 = System.currentTimeMillis();
        noPipeline(jedis);                //无管道方式执行集合10000条插入命令
        long t2 = System.currentTimeMillis();
        System.out.printf("非管道方式用时:%d毫秒", t2 - t1);  //打印非管道方式所用时间
        jedis.flushDB();      //调用flushDB命令，清除指定服务器上的0号数据库数据
        t1 = System.currentTimeMillis();
        usePipeline(jedis);               //管道方式执行集合10000条插入命令
        t2 = System.currentTimeMillis();
        System.out.printf("管道方式用时:%d毫秒", t2 - t1);//打印管道方式执行所用时间
    }

    @After
    public void closeJedis() {
        jedis.close();
    }

  
}

PilecornmendTest （）部分为上述代码的核心部分，实现了对指定集合，在插入 10000

命令 的情况下，无管道方式和有管道方式所消耗的时间的比较 noPipeline(Jedis jedis ）为被

调用 的自定义无 道函数， usePipeline(Jedis jedis ）为被调用的有 道函数，这两个函数的

自定 义实现内容见下列代码：

private static void noPipeline(Jedis jedis) {
        try {
            for (int i = 0; i < 10000; i++) {  //循环一次提交一条命令
                jedis.sadd("SetAdd", i + "");//往集合SetAdd里连续加10000个数据
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void usePipeline(Jedis jedis) {
        try {
            Pipeline pl = jedis.pipelined();//启动管道
            for (int i = 0; i < 10000; i++) {
                pl.sadd("SAdd", i + ""); //往集合SetAdd里连续加10000个数据
            }
            pl.sync();        //用管道方式提交10000个命令
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

上述代码的 noPipeline(Jedis jedis ）函数在没有使用管道技术的情况下，对指定集合实现

0000 条数据的插入； usePipeline(Jedis jedis ）函数在使用管道技术的情况下，对指定集

合实 现了 10000 条数据的插入。

整合在一起的代码

package com.threecoolcat.pipe;
import com.threecoolcat.pipe.redis.RedisUtil;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import java.io.IOException;

public class RedisTest {
    private Jedis jedis;

    @Before               // 注解before 表示在方法前执行
    public void initJedis() throws IOException {
        jedis = RedisUtil.initPool().getResource();//调用7.4.2节连接数据库功能
    }

    @Test
    public void PipecommendTest() {
        jedis.flushDB();      //调用flushDB命令，清除指定服务器上的0号数据库数据
        long t1 = System.currentTimeMillis();
        noPipeline(jedis);                //无管道方式执行集合10000条插入命令
        long t2 = System.currentTimeMillis();
        System.out.printf("非管道方式用时:%d毫秒", t2 - t1);  //打印非管道方式所用时间
        jedis.flushDB();      //调用flushDB命令，清除指定服务器上的0号数据库数据
        t1 = System.currentTimeMillis();
        usePipeline(jedis);               //管道方式执行集合10000条插入命令
        t2 = System.currentTimeMillis();
        System.out.printf("管道方式用时:%d毫秒", t2 - t1);//打印管道方式执行所用时间
    }

    @After
    public void closeJedis() {
        jedis.close();
    }

    private static void noPipeline(Jedis jedis) {
        try {
            for (int i = 0; i < 10000; i++) {  //循环一次提交一条命令
                jedis.sadd("SetAdd", i + "");//往集合SetAdd里连续加10000个数据
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void usePipeline(Jedis jedis) {
        try {
            Pipeline pl = jedis.pipelined();//启动管道
            for (int i = 0; i < 10000; i++) {
                pl.sadd("SAdd", i + ""); //往集合SetAdd里连续加10000个数据
            }
            pl.sync();        //用管道方式提交10000个命令
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

我的redis密码为123456，需要根据你的代码进行修改，或者将你的代码修改成123456，如何修改redis密码

其中的RedisUtil函数为下：

package com.threecoolcat.pipe.redis;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class RedisUtil {
	public static JedisPool initPool() throws IOException {
		// 初始化redis连接池配置
		JedisPoolConfig config = new JedisPoolConfig();
		config.setMaxTotal(150);
		config.setMaxIdle(100);
		config.setTestOnBorrow(false);
		// 初始化redis连接池
		JedisPool pool = new JedisPool(config, "127.0.0.1",
				6379, 2000,"123456");
		return pool;
	}
}

pom.xml文件为下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>pipe</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>19</maven.compiler.source>
        <maven.compiler.target>19</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.1.1</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.13</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

</project>