【Redis深入】Jedis的使用

1.Jedis的基本使用

基本使用很简单，就是Redis的基本命令，首先需要导入jar包

    public void firstConnection() {
//连接redis的IP和端口号
        Jedis jedis = new Jedis("127.0.0.1",6379);
//输入密码
        jedis.auth("dream");
//设置键name的值
        System.out.println(jedis.set("name","Lee"));
//获取键name的值
        System.out.println(jedis.get("name"));
//删除键name
        System.out.println(jedis.del("name"));
//再获取键name的值
        System.out.println(jedis.get("name"));
//一次设置多个键的值
        System.out.println(jedis.mset("id","1001","username","consumer"));
//获取数据库中所有键
        System.out.println(jedis.keys("*"));
//测试客户端与服务器是否连通
        System.out.println("ping: "+jedis.ping());

    }

2.Jedispool的使用

class JedisPoolUtil
{
private static volatile JedisPool jedisPool = null;

private JedisPoolUtil(){}

public static JedisPool getJedisPoolInstance()
    {
if(null == jedisPool)
        {
            synchronized (JedisPoolUtil.class)
            {
if(null == jedisPool)
                {
                    JedisPoolConfig poolConfig = new JedisPoolConfig();
                    poolConfig.setMaxActive(1000);
                    poolConfig.setMaxIdle(32);
                    poolConfig.setMaxWait(100*1000);
                    poolConfig.setTestOnBorrow(true);

                    jedisPool = new JedisPool(poolConfig,"127.0.0.1",6379);
                }
            }
        }
return jedisPool;
    }

public static void release(JedisPool jedisPool,Jedis jedis)
    {
if(null != jedis)
        {
            jedisPool.returnResourceObject(jedis);
        }
    }

}

class TestPool {

public static void main(String[] args) {
        JedisPool jedisPool = JedisPoolUtil.getJedisPoolInstance();
        JedisPool jedisPool2 = JedisPoolUtil.getJedisPoolInstance();

        System.out.println(jedisPool == jedisPool2);

        Jedis jedis = null;
try {
            jedis = jedisPool.getResource();
            jedis.set("aa","bb");
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            JedisPoolUtil.release(jedisPool, jedis);
        }
    }
}

3.使用Jedis执行事务

    public void connection() {
        Jedis redis = new Jedis("192.168.236.142",6379);

//返回一个事务控制对象
        Transaction transaction=jedis.multi();

//预先在事务对象中装入要执行的操作
        transaction.set("k4", "v44");
        transaction.set("k5", "v55");
        transaction.set("serialNum","s002");

        Response<String> response = transaction.get("serialNum");

        transaction.lpush("list3","a");
        transaction.lpush("list3","b");
        transaction.lpush("list3","c");

//执行事务
        transaction.exec();

        System.out.println("serialNum***********"+response.get());

//取消事务
        transaction.discard();

    }

4.实现redis的序列化

public class RedisDao {
private final JedisPool jedisPool;
private final Logger logger = LoggerFactory.getLogger(this.getClass());

public RedisDao(String ip,int port) {
        jedisPool = new JedisPool(ip, port);
    }

//首先是告知protostuffIOUtil即将要序列化的对象的序列化规则。
//RuntimeSchema<T> schema = RuntimeSchema.createFrom(T.class);
private RuntimeSchema<Seckill> schema = RuntimeSchema.createFrom(Seckill.class);

public Seckill getSeckill(long seckillId) {
//redis操作逻辑
try{
            Jedis jedis = jedisPool.getResource();
try {
                String key = "seckill: "+seckillId;
//并没有实现内部序列化操作
// get‐>byte[] ‐‐>反序列化 ‐‐>Object(Seckill)
//实现自定义序列化
//protostuff ： pojo
byte[] bytes = jedis.get(key.getBytes());
//缓存重获取到
if(bytes != null) {
//schema代表序列化规则，所以通过Object object = schema.newMessage();
//可以让容器按规则生成一个空对象，在根据冲redis中拿到的序列值进行反化

                    Seckill seckill = schema.newMessage();
                    ProtostuffIOUtil.mergeFrom(bytes,seckill,schema);
//seckill 被反序列化
return seckill;
                }
            } finally {
                jedis.close();
            }
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
return null;
    }

/**
 * redis服务器以键值对来存储对象，
 * 但是值得存储方式是将对象序列化再进行存储。
 * jdk为用户提供了一套对象序列化API，
 * 此时大家想到的应该是让被序列化类去实现Serializable接口。
 * 这种方法是可行的，但是缺点在与sun提供的这套API是比较低效率的，
 * 而且压缩之后的对象还是比较占空间的。
 * 此时我们可以采用Protostuff对象提供的序列化API，
 * 测试证明了这套API的序列化效率更高切压缩空间更小。
 */

public String putSeckill (Seckill seckill){
//set Object(Seckill) ‐‐> 序列化 ‐> byte[]
try {
            Jedis jedis = jedisPool.getResource();
try {
                String key = "seckill:"+seckill.getSeckillId();
//将Object对象进行序列化，schema则是序列化规则，参数三是序列过过程中使用到的缓冲79.
//*byte[] bytes = ProtostuffIOUtil.toByteArray(Object, schema,LinkedBuffer.80.
byte[] bytes = ProtostuffIOUtil.toByteArray(seckill,schema,
                        LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
//超时缓存
int timeout = 60 * 60;
//jedis.setex(key,seconds,values);第一个参数key，第二个参数有效时间 秒 
//第三个86. String result = jedis.setex(key.getBytes(),timeout,bytes);
return result;
                } finally {
                    jedis.close();
                    }
            } catch (Exception e) {
                logger.error(e.getMessage(),e);
            }
return null;
        }
}

本人才疏学浅，若有错，请指出，谢谢！