java 事务操作reids

来源：互联网发布：淘宝店铺解封需要钱吗编辑：程序博客网时间：2024/06/09 10:37

环境准备

jedis-2.2.0.jar

JedisTools类 (网上找的,可以用的)

import java.util.HashMap;
import java.util.Map;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisTools {

   /**
     * 私有构造器.
     */
    private JedisTools() {

    }
    private static Map<String,JedisPool> maps = new HashMap<String,JedisPool>();

    /**
     * 获取连接池.
     * @return 连接池实例
     */
    private static JedisPool getPool(String ip,int port ) {
        String key = ip+":" +port;
        JedisPool pool = null;
        if(!maps.containsKey(key)) {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxActive(chan_mid.chan_mid.Config.Config.REDISMAXACTIVE);
            config.setMaxIdle(chan_mid.chan_mid.Config.Config.REDISMAXIDLE);
            config.setMaxWait(chan_mid.chan_mid.Config.Config.REDISMAXWAIT);
            config.setTestOnBorrow(true);
            config.setTestOnReturn(true);
            try{
                /**
                 *如果你遇到 java.net.SocketTimeoutException: Read timed out exception的异常信息
                 *请尝试在构造JedisPool的时候设置自己的超时值. JedisPool默认的超时时间是2秒(单位毫秒)
                 */
                pool = new JedisPool(config, ip, port,chan_mid.chan_mid.Config.Config.REDISTIMEOUT);
                maps.put(key, pool);
            } catch(Exception e) {
                e.printStackTrace();
            }
        }else{
            pool = maps.get(key);
        }
        return pool;
    }

    /**
     *类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     *没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。
     */
    private static class RedisUtilHolder{
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static JedisTools instance = new JedisTools();
    }

    /**
     *当getInstance方法第一次被调用的时候，它第一次读取
     *RedisUtilHolder.instance，导致RedisUtilHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静
     *态域，从而创建RedisUtil的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。
     *这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本。
     */
    public static JedisTools getInstance() {
        return RedisUtilHolder.instance;
    }

    /**
     * 获取Redis实例.
     * @return Redis工具类实例
     */
    public Jedis getJedis(String ip,int port) {
        Jedis jedis = null;
        int count =0;
        do{
            try{
                jedis = getPool(ip,port).getResource();
                //log.info("get redis master1!");
            } catch (Exception e) {
                 // 销毁对象
                getPool(ip,port).returnBrokenResource(jedis);
            }
            count++;
        }while(jedis==null&&count<chan_mid.chan_mid.Config.Config.RETRYNUM);
        return jedis;
    }

    /**
     * 释放redis实例到连接池.
     * @param jedis redis实例
     */
    public void closeJedis(Jedis jedis,String ip,int port) {
        if(jedis != null) {
            getPool(ip,port).returnResource(jedis);
        }
    }
}

Jedis jedis = JedisTools.getInstance().getJedis(Config.Config.JedisUrl, Config.Config.JedisPort);

获取连接

Pipeline pipeline = jedis.pipelined();
pipeline.multi();

/*事务提交内容*/

pipeline.del("demo");

pipeline.zadd("demo",0, "这是值1");

pipeline.zadd("demo",1, "这是值3");

pipeline.zadd("demo",2, "这是值4");

pipeline.exec();
List<Object> results = pipeline.syncAndReturnAll();
int redisUpdateCount = results.size();
logger.info(stockId+"写入redis成功!更新"+redisUpdateCount+"记录");

0 0