eblly
eblly

redis基本使用、java 工具类

描述

本文将涉及三部分：

  • redis的安装部署。
  • java操作redis(java redis util)。
  • 基于redis下的分布式锁。

安装单机redis

由于是简单操作，不考虑集群模式。

下载redis

wget http://download.redis.io/releases/redis-4.0.14.tar.gz

解压 并安装

tar -zxvf  redis-4.0.14.tar.gz
cd redis-4.0.14
make && make install

安装完成后运行redis，先修改配置文件
vim ./redis.conf

port 7779                        # 端口随意
daemonize yes
requirepass xxxxxxxxx   # 设置密码

启动服务端

./src/redis-server ./redis.conf # 指定配置文件启动redis

ps -ef | grep redis一下确认redis启动成功。

image.png

docker安装redis

可能上述的方式会比较麻烦，可以使用docker代替。

启动服务端

docker run --restart=always -v /etc/localtime:/etc/localtime:ro --name redis01 -p 7779:6379 -d redis:4.0 --requirepass "xxxxxxxxxxxx"

requirepass参数是设置密码。
使用docker客户端连接

redis-4.0.14]# docker run -it --link redis01:redis-cli --rm redis:3.2 redis-cli -h redis01 -p 6379 -a 'xxxxxxxxxxxx'
image.png

java-redis 工具类

maven.xml

 
        
            redis.clients
            jedis
            2.9.0
        

        
            de.ruedigermoeller
            fst
            2.56
        

 
        
            org.projectlombok
            lombok
            1.18.4

RedisClient.java


import lombok.extern.log4j.Log4j2;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.util.*;

/**
 * 参考jfinal redis plugin
 *
 * @author eblly
 * @since 2019/7/27
 */
@Log4j2
public class RedisClient {

    private String     host       = null;
    private Integer    port       = null;
    private Integer    timeout    = null;
    private String     password   = null;
    private Integer    database   = null;
    private JedisPool  jedisPool  = null;
    private Properties properties = null;

    private RedisSerializer serializer = null;

    private RedisClient() {

    }

    /*************************************   redis操作  start ************************************/

    /**
     * 存放 key value 对到 redis
     * 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。
     * 对于某个原本带有生存时间（TTL）的键来说， 当 SET 命令成功在这个键上执行时， 这个键原有的 TTL 将被清除。
     */
    public String set(Object key, Object value) {
        Jedis jedis = getJedis();
        try {
            return jedis.set(keyToBytes(key), valueToBytes(value));
        } finally {close(jedis);}
    }

    /**
     * 存放 key value 对到 redis，并将 key 的生存时间设为 seconds (以秒为单位)。
     * 如果 key 已经存在， SETEX 命令将覆写旧值。
     */
    public String setex(Object key, int seconds, Object value) {
        Jedis jedis = getJedis();
        try {
            return jedis.setex(keyToBytes(key), seconds, valueToBytes(value));
        } finally {close(jedis);}
    }

    /**
     * 存放 key value 对到 redis，并将 key 的生存时间设为 seconds (以秒为单位)。
     * 如果 key 已经存在， SETNX将不操作
     *  1 if the key was set 0 if the key was not set
     */
    public Long setnx(Object key, Object value) {
        Jedis jedis = getJedis();
        try {
            return jedis.setnx(keyToBytes(key), valueToBytes(value));
        } finally {close(jedis);}
    }

    /**
     * 返回 key 所关联的 value 值
     * 如果 key 不存在那么返回特殊值 nil 。
     */
    @SuppressWarnings("unchecked")
    public  T get(Object key) {
        Jedis jedis = getJedis();
        try {
            return (T) valueFromBytes(jedis.get(keyToBytes(key)));
        } finally {close(jedis);}
    }

    /**
     * 删除给定的一个 key
     * 不存在的 key 会被忽略。
     */
    public Long del(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.del(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 删除给定的多个 key
     * 不存在的 key 会被忽略。
     */
    public Long del(Object... keys) {
        Jedis jedis = getJedis();
        try {
            return jedis.del(keysToBytesArray(keys));
        } finally {close(jedis);}
    }

    /**
     * 查找所有符合给定模式 pattern 的 key 。
     * KEYS * 匹配数据库中所有 key 。
     * KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
     * KEYS h*llo 匹配 hllo 和 heeeeello 等。
     * KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。
     * 特殊符号用 \ 隔开
     */
    public Set keys(String pattern) {
        Jedis jedis = getJedis();
        try {
            return jedis.keys(pattern);
        } finally {close(jedis);}
    }

    /**
     * 同时设置一个或多个 key-value 对。
     * 如果某个给定 key 已经存在，那么 MSET 会用新值覆盖原来的旧值，如果这不是你所希望的效果，请考虑使用 MSETNX 命令：它只会在所有给定 key 都不存在的情况下进行设置操作。
     * MSET 是一个原子性(atomic)操作，所有给定 key 都会在同一时间内被设置，某些给定 key 被更新而另一些给定 key 没有改变的情况，不可能发生。
     * 
     * 例子：
     * Cache cache = RedisKit.use();            // 使用 Redis 的 cache
     * cache.mset("k1", "v1", "k2", "v2");      // 放入多个 key value 键值对
     * List list = cache.mget("k1", "k2");      // 利用多个键值得到上面代码放入的值
     * 

     */
    public String mset(Object... keysValues) {
        if (keysValues.length % 2 != 0)
            throw new IllegalArgumentException("wrong number of arguments for met, keysValues length can not be odd");
        Jedis jedis = getJedis();
        try {
            byte[][] kv = new byte[keysValues.length][];
            for (int i = 0; i < keysValues.length; i++) {
                if (i % 2 == 0)
                    kv[i] = keyToBytes(keysValues[i]);
                else
                    kv[i] = valueToBytes(keysValues[i]);
            }
            return jedis.mset(kv);
        } finally {close(jedis);}
    }

    /**
     * 返回所有(一个或多个)给定 key 的值。
     * 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil 。因此，该命令永不失败。
     */
    @SuppressWarnings("rawtypes")
    public List mget(Object... keys) {
        Jedis jedis = getJedis();
        try {
            byte[][]     keysBytesArray = keysToBytesArray(keys);
            List data           = jedis.mget(keysBytesArray);
            return valueListFromBytesList(data);
        } finally {close(jedis);}
    }

    /**
     * 将 key 中储存的数字值减一。
     * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
     * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
     * 本操作的值限制在 64 位(bit)有符号数字表示之内。
     * 关于递增(increment) / 递减(decrement)操作的更多信息，请参见 INCR 命令。
     */
    public Long decr(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.decr(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 将 key 所储存的值减去减量 decrement 。
     * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECRBY 操作。
     * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
     * 本操作的值限制在 64 位(bit)有符号数字表示之内。
     * 关于更多递增(increment) / 递减(decrement)操作的更多信息，请参见 INCR 命令。
     */
    public Long decrBy(Object key, long longValue) {
        Jedis jedis = getJedis();
        try {
            return jedis.decrBy(keyToBytes(key), longValue);
        } finally {close(jedis);}
    }

    /**
     * 将 key 中储存的数字值增一。
     * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
     * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
     * 本操作的值限制在 64 位(bit)有符号数字表示之内。
     */
    public Long incr(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.incr(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 将 key 所储存的值加上增量 increment 。
     * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCRBY 命令。
     * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
     * 本操作的值限制在 64 位(bit)有符号数字表示之内。
     * 关于递增(increment) / 递减(decrement)操作的更多信息，参见 INCR 命令。
     */
    public Long incrBy(Object key, long longValue) {
        Jedis jedis = getJedis();
        try {
            return jedis.incrBy(keyToBytes(key), longValue);
        } finally {close(jedis);}
    }

    /**
     * 检查给定 key 是否存在。
     */
    public boolean exists(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.exists(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 从当前数据库中随机返回(不删除)一个 key 。
     */
    public String randomKey() {
        Jedis jedis = getJedis();
        try {
            return jedis.randomKey();
        } finally {close(jedis);}
    }

    /**
     * 将 key 改名为 newkey 。
     * 当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。
     * 当 newkey 已经存在时， RENAME 命令将覆盖旧值。
     */
    public String rename(Object oldkey, Object newkey) {
        Jedis jedis = getJedis();
        try {
            return jedis.rename(keyToBytes(oldkey), keyToBytes(newkey));
        } finally {close(jedis);}
    }

    /**
     * 将当前数据库的 key 移动到给定的数据库 db 当中。
     * 如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。
     * 因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)。
     */
    public Long move(Object key, int dbIndex) {
        Jedis jedis = getJedis();
        try {
            return jedis.move(keyToBytes(key), dbIndex);
        } finally {close(jedis);}
    }

    /**
     * 将 key 原子性地从当前实例传送到目标实例的指定数据库上，一旦传送成功， key 保证会出现在目标实例上，而当前实例上的 key 会被删除。
     */
    public String migrate(String host, int port, Object key, int destinationDb, int timeout) {
        Jedis jedis = getJedis();
        try {
            return jedis.migrate(valueToBytes(host), port, keyToBytes(key), destinationDb, timeout);
        } finally {close(jedis);}
    }

    /**
     * 切换到指定的数据库，数据库索引号 index 用数字值指定，以 0 作为起始索引值。
     * 默认使用 0 号数据库。
     * 注意：在 Jedis 对象被关闭时，数据库又会重新被设置为初始值，所以本方法 select(...)
     * 正常工作需要使用如下方式之一：
     * 1：使用 RedisInterceptor，在本线程内共享同一个 Jedis 对象
     * 2：使用 Redis.call(ICallback) 进行操作
     * 3：自行获取 Jedis 对象进行操作
     */
    public String select(int databaseIndex) {
        Jedis jedis = getJedis();
        try {
            return jedis.select(databaseIndex);
        } finally {close(jedis);}
    }

    /**
     * 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
     * 在 Redis 中，带有生存时间的 key 被称为『易失的』(volatile)。
     */
    public Long expire(Object key, int seconds) {
        Jedis jedis = getJedis();
        try {
            return jedis.expire(keyToBytes(key), seconds);
        } finally {close(jedis);}
    }

    /**
     * EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。
     */
    public Long expireAt(Object key, long unixTime) {
        Jedis jedis = getJedis();
        try {
            return jedis.expireAt(keyToBytes(key), unixTime);
        } finally {close(jedis);}
    }

    /**
     * 这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令那样，以秒为单位。
     */
    public Long pexpire(Object key, long milliseconds) {
        Jedis jedis = getJedis();
        try {
            return jedis.pexpire(keyToBytes(key), milliseconds);
        } finally {close(jedis);}
    }

    /**
     * 这个命令和 EXPIREAT 命令类似，但它以毫秒为单位设置 key 的过期 unix 时间戳，而不是像 EXPIREAT 那样，以秒为单位。
     */
    public Long pexpireAt(Object key, long millisecondsTimestamp) {
        Jedis jedis = getJedis();
        try {
            return jedis.pexpireAt(keyToBytes(key), millisecondsTimestamp);
        } finally {close(jedis);}
    }

    /**
     * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
     * 当 key 存在但不是字符串类型时，返回一个错误。
     */
    @SuppressWarnings("unchecked")
    public  T getSet(Object key, Object value) {
        Jedis jedis = getJedis();
        try {
            return (T) valueFromBytes(jedis.getSet(keyToBytes(key), valueToBytes(value)));
        } finally {close(jedis);}
    }

    /**
     * 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。
     */
    public Long persist(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.persist(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 返回 key 所储存的值的类型。
     */
    public String type(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.type(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
     */
    public Long ttl(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.ttl(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间，而不是像 TTL 命令那样，以秒为单位。
     */
    public Long pttl(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.pttl(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 对象被引用的数量
     */
    public Long objectRefcount(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.objectRefcount(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 对象没有被访问的空闲时间
     */
    public Long objectIdletime(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.objectIdletime(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 将哈希表 key 中的域 field 的值设为 value 。
     * 如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。
     * 如果域 field 已经存在于哈希表中，旧值将被覆盖。
     */
    public Long hset(Object key, Object field, Object value) {
        Jedis jedis = getJedis();
        try {
            return jedis.hset(keyToBytes(key), fieldToBytes(field), valueToBytes(value));
        } finally {close(jedis);}
    }

    /**
     * 同时将多个 field-value (域-值)对设置到哈希表 key 中。
     * 此命令会覆盖哈希表中已存在的域。
     * 如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。
     */
    public String hmset(Object key, Map hash) {
        Jedis jedis = getJedis();
        try {
            Map para = new HashMap();
            for (Map.Entry e : hash.entrySet())
                para.put(fieldToBytes(e.getKey()), valueToBytes(e.getValue()));
            return jedis.hmset(keyToBytes(key), para);
        } finally {close(jedis);}
    }

    /**
     * 返回哈希表 key 中给定域 field 的值。
     */
    @SuppressWarnings("unchecked")
    public  T hget(Object key, Object field) {
        Jedis jedis = getJedis();
        try {
            return (T) valueFromBytes(jedis.hget(keyToBytes(key), fieldToBytes(field)));
        } finally {close(jedis);}
    }

    /**
     * 返回哈希表 key 中，一个或多个给定域的值。
     * 如果给定的域不存在于哈希表，那么返回一个 nil 值。
     * 因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。
     */
    @SuppressWarnings("rawtypes")
    public List hmget(Object key, Object... fields) {
        Jedis jedis = getJedis();
        try {
            List data = jedis.hmget(keyToBytes(key), fieldsToBytesArray(fields));
            return valueListFromBytesList(data);
        } finally {close(jedis);}
    }

    /**
     * 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
     */
    public Long hdel(Object key, Object... fields) {
        Jedis jedis = getJedis();
        try {
            return jedis.hdel(keyToBytes(key), fieldsToBytesArray(fields));
        } finally {close(jedis);}
    }

    /**
     * 查看哈希表 key 中，给定域 field 是否存在。
     */
    public boolean hexists(Object key, Object field) {
        Jedis jedis = getJedis();
        try {
            return jedis.hexists(keyToBytes(key), fieldToBytes(field));
        } finally {close(jedis);}
    }

    /**
     * 返回哈希表 key 中，所有的域和值。
     * 在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。
     */
    @SuppressWarnings("rawtypes")
    public Map hgetAll(Object key) {
        Jedis jedis = getJedis();
        try {
            Map data   = jedis.hgetAll(keyToBytes(key));
            Map result = new HashMap();
            for (Map.Entry e : data.entrySet())
                result.put(fieldFromBytes(e.getKey()), valueFromBytes(e.getValue()));
            return result;
        } finally {close(jedis);}
    }

    /**
     * 返回哈希表 key 中所有域的值。
     */
    @SuppressWarnings("rawtypes")
    public List hvals(Object key) {
        Jedis jedis = getJedis();
        try {
            List data = jedis.hvals(keyToBytes(key));
            return valueListFromBytesList(data);
        } finally {close(jedis);}
    }

    /**
     * 返回哈希表 key 中的所有域。
     * 底层实现此方法取名为 hfields 更为合适，在此仅为与底层保持一致
     */
    public Set hkeys(Object key) {
        Jedis jedis = getJedis();
        try {
            Set fieldSet = jedis.hkeys(keyToBytes(key));
            Set result   = new HashSet();
            fieldSetFromBytesSet(fieldSet, result);
            return result;
        } finally {close(jedis);}
    }

    /**
     * 返回哈希表 key 中域的数量。
     */
    public Long hlen(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.hlen(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 为哈希表 key 中的域 field 的值加上增量 increment 。
     * 增量也可以为负数，相当于对给定域进行减法操作。
     * 如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。
     * 如果域 field 不存在，那么在执行命令前，域的值被初始化为 0 。
     * 对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。
     * 本操作的值被限制在 64 位(bit)有符号数字表示之内。
     */
    public Long hincrBy(Object key, Object field, long value) {
        Jedis jedis = getJedis();
        try {
            return jedis.hincrBy(keyToBytes(key), fieldToBytes(field), value);
        } finally {close(jedis);}
    }

    /**
     * 为哈希表 key 中的域 field 加上浮点数增量 increment 。
     * 如果哈希表中没有域 field ，那么 HINCRBYFLOAT 会先将域 field 的值设为 0 ，然后再执行加法操作。
     * 如果键 key 不存在，那么 HINCRBYFLOAT 会先创建一个哈希表，再创建域 field ，最后再执行加法操作。
     * 当以下任意一个条件发生时，返回一个错误：
     * 1:域 field 的值不是字符串类型(因为 redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型）
     * 2:域 field 当前的值或给定的增量 increment 不能解释(parse)为双精度浮点数(double precision floating point number)
     * HINCRBYFLOAT 命令的详细功能和 INCRBYFLOAT 命令类似，请查看 INCRBYFLOAT 命令获取更多相关信息。
     */
    public Double hincrByFloat(Object key, Object field, double value) {
        Jedis jedis = getJedis();
        try {
            return jedis.hincrByFloat(keyToBytes(key), fieldToBytes(field), value);
        } finally {close(jedis);}
    }

    /**
     * 返回列表 key 中，下标为 index 的元素。
     * 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
     * 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
     * 如果 key 不是列表类型，返回一个错误。
     */
    @SuppressWarnings("unchecked")

    /**
     * 返回列表 key 中，下标为 index 的元素。
     * 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，
     * 以 1 表示列表的第二个元素，以此类推。
     * 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
     * 如果 key 不是列表类型，返回一个错误。
     */
    public  T lindex(Object key, long index) {
        Jedis jedis = getJedis();
        try {
            return (T) valueFromBytes(jedis.lindex(keyToBytes(key), index));
        } finally {close(jedis);}
    }

    /**
     * 获取记数器的值
     */
    public Long getCounter(String key) {
        Jedis jedis = getJedis();
        try {
            String ret = jedis.get(key);
            return ret != null ? Long.parseLong(ret) : null;
        } finally {close(jedis);}
    }

    /**
     * 返回列表 key 的长度。
     * 如果 key 不存在，则 key 被解释为一个空列表，返回 0 .
     * 如果 key 不是列表类型，返回一个错误。
     */
    public Long llen(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.llen(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 移除并返回列表 key 的头元素。
     */
    @SuppressWarnings("unchecked")
    public  T lpop(Object key) {
        Jedis jedis = getJedis();
        try {
            return (T) valueFromBytes(jedis.lpop(keyToBytes(key)));
        } finally {close(jedis);}
    }

    /**
     * 将一个或多个值 value 插入到列表 key 的表头
     * 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头： 比如说，
     * 对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a ，
     * 这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。
     * 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。
     * 当 key 存在但不是列表类型时，返回一个错误。
     */
    public Long lpush(Object key, Object... values) {
        Jedis jedis = getJedis();
        try {
            return jedis.lpush(keyToBytes(key), valuesToBytesArray(values));
        } finally {close(jedis);}
    }

    /**
     * 将列表 key 下标为 index 的元素的值设置为 value 。
     * 当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。
     * 关于列表下标的更多信息，请参考 LINDEX 命令。
     */
    public String lset(Object key, long index, Object value) {
        Jedis jedis = getJedis();
        try {
            return jedis.lset(keyToBytes(key), index, valueToBytes(value));
        } finally {close(jedis);}
    }

    /**
     * 根据参数 count 的值，移除列表中与参数 value 相等的元素。
     * count 的值可以是以下几种：
     * count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
     * count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
     * count = 0 : 移除表中所有与 value 相等的值。
     */
    public Long lrem(Object key, long count, Object value) {
        Jedis jedis = getJedis();
        try {
            return jedis.lrem(keyToBytes(key), count, valueToBytes(value));
        } finally {close(jedis);}
    }

    /**
     * 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
     * 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
     * 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
     * 
     * 例子：
     * 获取 list 中所有数据：cache.lrange(listKey, 0, -1);
     * 获取 list 中下标 1 到 3 的数据： cache.lrange(listKey, 1, 3);
     * 

     */
    @SuppressWarnings("rawtypes")
    public List lrange(Object key, long start, long end) {
        Jedis jedis = getJedis();
        try {
            List data = jedis.lrange(keyToBytes(key), start, end);
            if (data != null) {
                return valueListFromBytesList(data);
            } else {
                return new ArrayList(0);
            }
        } finally {close(jedis);}
    }

    /**
     * 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
     * 举个例子，执行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。
     * 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
     * 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
     * 当 key 不是列表类型时，返回一个错误。
     */
    public String ltrim(Object key, long start, long end) {
        Jedis jedis = getJedis();
        try {
            return jedis.ltrim(keyToBytes(key), start, end);
        } finally {close(jedis);}
    }

    /**
     * 移除并返回列表 key 的尾元素。
     */
    @SuppressWarnings("unchecked")
    public  T rpop(Object key) {
        Jedis jedis = getJedis();
        try {
            return (T) valueFromBytes(jedis.rpop(keyToBytes(key)));
        } finally {close(jedis);}
    }

    /**
     * 命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作：
     * 将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。
     * 将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。
     */
    @SuppressWarnings("unchecked")
    public  T rpoplpush(Object srcKey, Object dstKey) {
        Jedis jedis = getJedis();
        try {
            return (T) valueFromBytes(jedis.rpoplpush(keyToBytes(srcKey), keyToBytes(dstKey)));
        } finally {close(jedis);}
    }

    /**
     * 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
     * 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾：比如
     * 对一个空列表 mylist 执行 RPUSH mylist a b c ，得出的结果列表为 a b c ，
     * 等同于执行命令 RPUSH mylist a 、 RPUSH mylist b 、 RPUSH mylist c 。
     * 如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。
     * 当 key 存在但不是列表类型时，返回一个错误。
     */
    public Long rpush(Object key, Object... values) {
        Jedis jedis = getJedis();
        try {
            return jedis.rpush(keyToBytes(key), valuesToBytesArray(values));
        } finally {close(jedis);}
    }

    /**
     * BLPOP 是列表的阻塞式(blocking)弹出原语。
     * 它是 LPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
     * 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。
     * 

     * 参考：http://redisdoc.com/list/blpop.html
     * 命令行：BLPOP key [key ...] timeout
     */
    @SuppressWarnings("rawtypes")
    public List blpop(int timeout, Object... keys) {
        Jedis jedis = getJedis();
        try {
            List data = jedis.blpop(timeout, keysToBytesArray(keys));
            return keyValueListFromBytesList(data);
        } finally {close(jedis);}
    }

    /**
     * BRPOP 是列表的阻塞式(blocking)弹出原语。
     * 它是 RPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BRPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
     * 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的尾部元素。
     * 关于阻塞操作的更多信息，请查看 BLPOP 命令， BRPOP 除了弹出元素的位置和 BLPOP 不同之外，其他表现一致。
     * 

     * 参考：http://redisdoc.com/list/brpop.html
     * 命令行：BRPOP key [key ...] timeout
     */
    @SuppressWarnings("rawtypes")
    public List brpop(int timeout, Object... keys) {
        Jedis jedis = getJedis();
        try {
            List data = jedis.brpop(timeout, keysToBytesArray(keys));
            return keyValueListFromBytesList(data);
        } finally {close(jedis);}
    }

    /**
     * 使用客户端向 Redis 服务器发送一个 PING ，如果服务器运作正常的话，会返回一个 PONG 。
     * 通常用于测试与服务器的连接是否仍然生效，或者用于测量延迟值。
     */
    public String ping() {
        Jedis jedis = getJedis();
        try {
            return jedis.ping();
        } finally {close(jedis);}
    }

    /**
     * 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
     * 假如 key 不存在，则创建一个只包含 member 元素作成员的集合。
     * 当 key 不是集合类型时，返回一个错误。
     */
    public Long sadd(Object key, Object... members) {
        Jedis jedis = getJedis();
        try {
            return jedis.sadd(keyToBytes(key), valuesToBytesArray(members));
        } finally {close(jedis);}
    }

    /**
     * 返回集合 key 的基数(集合中元素的数量)。
     */
    public Long scard(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.scard(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 移除并返回集合中的一个随机元素。
     * 如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER 命令。
     */
    @SuppressWarnings("unchecked")
    public  T spop(Object key) {
        Jedis jedis = getJedis();
        try {
            return (T) valueFromBytes(jedis.spop(keyToBytes(key)));
        } finally {close(jedis);}
    }

    /**
     * 返回集合 key 中的所有成员。
     * 不存在的 key 被视为空集合。
     */
    @SuppressWarnings("rawtypes")
    public Set smembers(Object key) {
        Jedis jedis = getJedis();
        try {
            Set data   = jedis.smembers(keyToBytes(key));
            Set result = new HashSet();
            valueSetFromBytesSet(data, result);
            return result;
        } finally {close(jedis);}
    }

    /**
     * 判断 member 元素是否集合 key 的成员。
     */
    public boolean sismember(Object key, Object member) {
        Jedis jedis = getJedis();
        try {
            return jedis.sismember(keyToBytes(key), valueToBytes(member));
        } finally {close(jedis);}
    }

    /**
     * 返回多个集合的交集，多个集合由 keys 指定
     */
    @SuppressWarnings("rawtypes")
    public Set sinter(Object... keys) {
        Jedis jedis = getJedis();
        try {
            Set data   = jedis.sinter(keysToBytesArray(keys));
            Set result = new HashSet();
            valueSetFromBytesSet(data, result);
            return result;
        } finally {close(jedis);}
    }

    /**
     * 返回集合中的一个随机元素。
     */
    @SuppressWarnings("unchecked")
    public  T srandmember(Object key) {
        Jedis jedis = getJedis();
        try {
            return (T) valueFromBytes(jedis.srandmember(keyToBytes(key)));
        } finally {close(jedis);}
    }

    /**
     * 返回集合中的 count 个随机元素。
     * 从 Redis 2.6 版本开始， SRANDMEMBER 命令接受可选的 count 参数：
     * 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。
     * 如果 count 大于等于集合基数，那么返回整个集合。
     * 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。
     * 该操作和 SPOP 相似，但 SPOP 将随机元素从集合中移除并返回，而 SRANDMEMBER 则仅仅返回随机元素，而不对集合进行任何改动。
     */
    @SuppressWarnings("rawtypes")
    public List srandmember(Object key, int count) {
        Jedis jedis = getJedis();
        try {
            List data = jedis.srandmember(keyToBytes(key), count);
            return valueListFromBytesList(data);
        } finally {close(jedis);}
    }

    /**
     * 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
     */
    public Long srem(Object key, Object... members) {
        Jedis jedis = getJedis();
        try {
            return jedis.srem(keyToBytes(key), valuesToBytesArray(members));
        } finally {close(jedis);}
    }

    /**
     * 返回多个集合的并集，多个集合由 keys 指定
     * 不存在的 key 被视为空集。
     */
    @SuppressWarnings("rawtypes")
    public Set sunion(Object... keys) {
        Jedis jedis = getJedis();
        try {
            Set data   = jedis.sunion(keysToBytesArray(keys));
            Set result = new HashSet();
            valueSetFromBytesSet(data, result);
            return result;
        } finally {close(jedis);}
    }

    /**
     * 返回一个集合的全部成员，该集合是所有给定集合之间的差集。
     * 不存在的 key 被视为空集。
     */
    @SuppressWarnings("rawtypes")
    public Set sdiff(Object... keys) {
        Jedis jedis = getJedis();
        try {
            Set data   = jedis.sdiff(keysToBytesArray(keys));
            Set result = new HashSet();
            valueSetFromBytesSet(data, result);
            return result;
        } finally {close(jedis);}
    }

    /**
     * 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
     * 如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，
     * 并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
     */
    public Long zadd(Object key, double score, Object member) {
        Jedis jedis = getJedis();
        try {
            return jedis.zadd(keyToBytes(key), score, valueToBytes(member));
        } finally {close(jedis);}
    }

    public Long zadd(Object key, Map scoreMembers) {
        Jedis jedis = getJedis();
        try {
            Map para = new HashMap();
            for (Map.Entry e : scoreMembers.entrySet())
                para.put(valueToBytes(e.getKey()), e.getValue());    // valueToBytes is important
            return jedis.zadd(keyToBytes(key), para);
        } finally {close(jedis);}
    }

    /**
     * 返回有序集 key 的基数。
     */
    public Long zcard(Object key) {
        Jedis jedis = getJedis();
        try {
            return jedis.zcard(keyToBytes(key));
        } finally {close(jedis);}
    }

    /**
     * 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
     * 关于参数 min 和 max 的详细使用方法，请参考 ZRANGEBYSCORE 命令。
     */
    public Long zcount(Object key, double min, double max) {
        Jedis jedis = getJedis();
        try {
            return jedis.zcount(keyToBytes(key), min, max);
        } finally {close(jedis);}
    }

    /**
     * 为有序集 key 的成员 member 的 score 值加上增量 increment 。
     */
    public Double zincrby(Object key, double score, Object member) {
        Jedis jedis = getJedis();
        try {
            return jedis.zincrby(keyToBytes(key), score, valueToBytes(member));
        } finally {close(jedis);}
    }

    /**
     * 返回有序集 key 中，指定区间内的成员。
     * 其中成员的位置按 score 值递增(从小到大)来排序。
     * 具有相同 score 值的成员按字典序(lexicographical order )来排列。
     * 如果你需要成员按 score 值递减(从大到小)来排列，请使用 ZREVRANGE 命令。
     */
    @SuppressWarnings("rawtypes")
    public Set zrange(Object key, long start, long end) {
        Jedis jedis = getJedis();
        try {
            Set data   = jedis.zrange(keyToBytes(key), start, end);
            Set result = new LinkedHashSet();    // 有序集合必须 LinkedHashSet
            valueSetFromBytesSet(data, result);
            return result;
        } finally {close(jedis);}
    }

    /**
     * 返回有序集 key 中，指定区间内的成员。
     * 其中成员的位置按 score 值递减(从大到小)来排列。
     * 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)排列。
     * 除了成员按 score 值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE 命令一样。
     */
    @SuppressWarnings("rawtypes")
    public Set zrevrange(Object key, long start, long end) {
        Jedis jedis = getJedis();
        try {
            Set data   = jedis.zrevrange(keyToBytes(key), start, end);
            Set result = new LinkedHashSet();    // 有序集合必须 LinkedHashSet
            valueSetFromBytesSet(data, result);
            return result;
        } finally {close(jedis);}
    }

    /**
     * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
     * 有序集成员按 score 值递增(从小到大)次序排列。
     */
    @SuppressWarnings("rawtypes")
    public Set zrangeByScore(Object key, double min, double max) {
        Jedis jedis = getJedis();
        try {
            Set data   = jedis.zrangeByScore(keyToBytes(key), min, max);
            Set result = new LinkedHashSet();    // 有序集合必须 LinkedHashSet
            valueSetFromBytesSet(data, result);
            return result;
        } finally {close(jedis);}
    }

    /**
     * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
     * 排名以 0 为底，也就是说， score 值最小的成员排名为 0 。
     * 使用 ZREVRANK 命令可以获得成员按 score 值递减(从大到小)排列的排名。
     */
    public Long zrank(Object key, Object member) {
        Jedis jedis = getJedis();
        try {
            return jedis.zrank(keyToBytes(key), valueToBytes(member));
        } finally {close(jedis);}
    }

    /**
     * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。
     * 排名以 0 为底，也就是说， score 值最大的成员排名为 0 。
     * 使用 ZRANK 命令可以获得成员按 score 值递增(从小到大)排列的排名。
     */
    public Long zrevrank(Object key, Object member) {
        Jedis jedis = getJedis();
        try {
            return jedis.zrevrank(keyToBytes(key), valueToBytes(member));
        } finally {close(jedis);}
    }

    /**
     * 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
     * 当 key 存在但不是有序集类型时，返回一个错误。
     */
    public Long zrem(Object key, Object... members) {
        Jedis jedis = getJedis();
        try {
            return jedis.zrem(keyToBytes(key), valuesToBytesArray(members));
        } finally {close(jedis);}
    }

    /**
     * 返回有序集 key 中，成员 member 的 score 值。
     * 如果 member 元素不是有序集 key 的成员，或 key 不存在，返回 nil 。
     */
    public Double zscore(Object key, Object member) {
        Jedis jedis = getJedis();
        try {
            return jedis.zscore(keyToBytes(key), valueToBytes(member));
        } finally {close(jedis);}
    }

    // ---------

    protected byte[] keyToBytes(Object key) {
        return serializer.keyToBytes(key);
    }

    protected Object keyFromBytes(byte[] bytes) {
        return serializer.keyFromBytes(bytes);
    }

    protected byte[][] keysToBytesArray(Object... keys) {
        byte[][] result = new byte[keys.length][];
        for (int i = 0; i < result.length; i++)
            result[i] = keyToBytes(keys[i]);
        return result;
    }

    protected byte[] fieldToBytes(Object field) {
        return serializer.fieldToBytes(field);
    }

    protected Object fieldFromBytes(byte[] bytes) {
        return serializer.fieldFromBytes(bytes);
    }

    protected byte[][] fieldsToBytesArray(Object... fieldsArray) {
        byte[][] data = new byte[fieldsArray.length][];
        for (int i = 0; i < data.length; i++)
            data[i] = fieldToBytes(fieldsArray[i]);
        return data;
    }

    protected void fieldSetFromBytesSet(Set data, Set result) {
        for (byte[] fieldBytes : data) {
            result.add(fieldFromBytes(fieldBytes));
        }
    }

    protected byte[] valueToBytes(Object value) {
        return serializer.valueToBytes(value);
    }

    protected Object valueFromBytes(byte[] bytes) {
        return serializer.valueFromBytes(bytes);
    }

    protected byte[][] valuesToBytesArray(Object... valuesArray) {
        byte[][] data = new byte[valuesArray.length][];
        for (int i = 0; i < data.length; i++)
            data[i] = valueToBytes(valuesArray[i]);
        return data;
    }

    protected void valueSetFromBytesSet(Set data, Set result) {
        for (byte[] valueBytes : data) {
            result.add(valueFromBytes(valueBytes));
        }
    }

    @SuppressWarnings("rawtypes")
    protected List valueListFromBytesList(List data) {
        List result = new ArrayList();
        for (byte[] d : data)
            result.add(valueFromBytes(d));
        return result;
    }

    @SuppressWarnings("rawtypes")
    protected List keyValueListFromBytesList(List data) {
        List result = new ArrayList();
        result.add(keyFromBytes(data.get(0)));
        result.add(valueFromBytes(data.get(1)));
        return result;
    }

    /*************************************   redis操作 end ************************************/
    private Jedis getJedis() {
        return jedisPool.getResource();
    }

    private void close(Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }


    /***************  builder start ********************/
    public static class Builder {
        private   String          host            = null;
        private   Integer         port            = null;
        private   Integer         timeout         = null;
        private   String          password        = null;
        private   Integer         database        = null;
        private   Properties      properties      = null;
        protected RedisSerializer serializer      = null;
        private   JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

        public RedisClient build() {
            RedisClient client = new RedisClient();

            client.host = host;
            client.port = port;
            client.timeout = timeout;
            client.password = password;
            client.database = database;
            client.properties = properties;
            client.serializer = serializer;

            if (serializer == null) {
                client.serializer = new FstSerializer();
            }

            if (port != null && timeout != null && password != null && database != null) {
                client.jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password, database);
            } else if (port != null && timeout != null && password != null) {
                client.jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);
            } else if (port != null && timeout != null) {
                client.jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout);
            } else if (port != null) {
                client.jedisPool = new JedisPool(jedisPoolConfig, host, port);
            } else {
                client.jedisPool = new JedisPool(jedisPoolConfig, host);
            }

            return client;
        }

        public Builder setHost(String host) {
            this.host = host;
            return this;
        }

        public Builder setPort(Integer port) {
            this.port = port;
            return this;
        }

        public Builder setTimeout(Integer timeout) {
            this.timeout = timeout;
            return this;
        }

        public Builder setPassword(String password) {
            this.password = password;
            return this;
        }

        public Builder setDatabase(Integer database) {
            this.database = database;
            return this;
        }

        public Builder setProperties(Properties properties) {
            this.properties = properties;
            return this;
        }

        public Builder setSerializer(RedisSerializer serializer) {
            this.serializer = serializer;
            return this;
        }

        public Builder setTestWhileIdle(boolean testWhileIdle) {
            jedisPoolConfig.setTestWhileIdle(testWhileIdle);
            return this;
        }

        public Builder setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis) {
            jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
            return this;
        }

        public Builder setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis) {
            jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
            return this;
        }

        public Builder setNumTestsPerEvictionRun(int numTestsPerEvictionRun) {
            jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
            return this;
        }

        public Builder setMaxTotal(int maxTotal) {
            jedisPoolConfig.setMaxTotal(maxTotal);
            return this;
        }
    }

    public static Builder builder() {
        return new Builder();
    }

    /***************  builder end ********************/

    @Override
    public String toString() {
        return "RedisClient{" +
                "host='" + host + '\'' +
                ", port=" + port +
                ", timeout=" + timeout +
                ", password='" + password + '\'' +
                ", database=" + database +
                '}';
    }
}

 
 
RedisSerializer.java
 
 

/**
 * @author eblly
 * @since 2019/7/28
 */
public interface RedisSerializer {
    byte[] keyToBytes(Object key);

    Object keyFromBytes(byte[] bytes);

    byte[] fieldToBytes(Object field);

    Object fieldFromBytes(byte[] bytes);

    byte[] valueToBytes(Object value);

    Object valueFromBytes(byte[] bytes);
}


 
 
FstSerializer.java
 
 

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

import lombok.extern.log4j.Log4j2;
import org.nustaq.serialization.FSTObjectInput;
import org.nustaq.serialization.FSTObjectOutput;
import redis.clients.util.SafeEncoder;

/**
 * @author eblly
 * @since 2019/7/28
 */
@Log4j2
public class FstSerializer implements RedisSerializer {

    public static final RedisSerializer me = new FstSerializer();

    public byte[] keyToBytes(Object key) {
        return SafeEncoder.encode(String.valueOf(key));
    }

    public String keyFromBytes(byte[] bytes) {
        return SafeEncoder.encode(bytes);
    }

    public byte[] fieldToBytes(Object field) {
        return valueToBytes(field);
    }

    public Object fieldFromBytes(byte[] bytes) {
        return valueFromBytes(bytes);
    }

    public byte[] valueToBytes(Object value) {
        FSTObjectOutput fstOut = null;
        try {
            ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
            fstOut = new FSTObjectOutput(bytesOut);
            fstOut.writeObject(value);
            fstOut.flush();
            return bytesOut.toByteArray();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            if (fstOut != null)
                try {fstOut.close();} catch (IOException e) {log.error(e.getMessage(), e);}
        }
    }

    public Object valueFromBytes(byte[] bytes) {
        if (bytes == null || bytes.length == 0)
            return null;

        FSTObjectInput fstInput = null;
        try {
            fstInput = new FSTObjectInput(new ByteArrayInputStream(bytes));
            return fstInput.readObject();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            if (fstInput != null)
                try {fstInput.close();} catch (IOException e) {log.error(e.getMessage(), e);}
        }
    }
}

 
 
测试类
 
 
import lombok.extern.log4j.Log4j2;
import org.junit.Test;
import org.junit.Before;
import org.junit.After;

/**
 * RedisUtil Tester.
 *
 * @author eblly
 * @version 1.0
 * @since 
七月 27, 2019

 */
@Log4j2
public class RedisUtilTest {

    private String host = "127.0.0.1";
    private int    port = 6379;
    private String auth;

    RedisClient redisUtil = null;

    @Before
    public void before() throws Exception {

        redisUtil = RedisClient.builder()
                               .setHost(host)
                               .setPort(port)
                               .build();
    }

    @After
    public void after() throws Exception {
    }

    @Test
    public void test() {
        redisUtil.set("aaa", "aaa");

        String value = redisUtil.get("aaa");
        log.info("value: {}", value);

    }
} 

 
 
最新redisUtil代码在
 https://gist.github.com/eblly/2b11f05d027ecb678d6d410bf7138daa
 
 
redis分布式锁
 
 
redis分布式锁
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(redis基本使用、java 工具类)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • linux中sdl的使用教程,sdl使用入门
                        Melissa Corvinus
linux中sdl的使用教程
                        
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
    
                    
    • 
                    
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）
                        编程经验分享
开发工具服务器sshlinux
                        
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • 阅读《别说你懂思维导图》21～23章day27
                        Ling宝尔

                        
    合理期待——思维导图的应用效果很多人问我，思维导图真的有用么？我常常回答，如果你觉得是它“没用”，一定是因为你没“用”，有“用”才“有用”。实际上，学习思维导图和学习木工、驾驶等技能型学习一样，都要经历从了解到应用、从应用到受益的过程。在使用前，我们很多人的思维处于“无意识的低效”状态，经过一段时间的学习，虽然掌握了思维导图的基本使用方法，但可能并没有太好的效果，这个阶段可称为“有意识的低效”状态
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                                
  • mysql主从数据同步
                                    林鹤霄
mysql主从数据同步
                                    
    配置mysql5.5主从服务器(转)   
教程开始：一、安装MySQL 
说明：在两台MySQL服务器192.168.21.169和192.168.21.168上分别进行如下操作，安装MySQL 5.5.22 
 二、配置MySQL主服务器（192.168.21.169）mysql  -uroot  -p   &nb
    
                                
    • 
                                
  • oracle学习笔记
                                    caoyong
oracle
                                    
    1、ORACLE的安装 
   a>、ORACLE的版本 
   8i,9i :   i是internet 
   10g,11g : grid (网格) 
   12c : cloud (云计算) 
   
   b>、10g不支持win7 
&
    
                                
    • 
                                
  • 数据库，SQL零基础入门
                                    天子之骄
sql数据库入门基本术语
                                    
    数据库，SQL零基础入门 
       做网站肯定离不开数据库，本人之前没怎么具体接触SQL，这几天起早贪黑得各种入门，恶补脑洞。一些具体的知识点，可以让小白不再迷茫的术语，拿来与大家分享。 
  
       数据库，永久数据的一个或多个大型结构化集合，通常与更新和查询数据的软件相关
    
                                
    • 
                                
  • pom.xml
                                    一炮送你回车库
pom.xml
                                    
    1、一级元素dependencies是可以被子项目继承的 
2、一级元素dependencyManagement是定义该项目群里jar包版本号的，通常和一级元素properties一起使用，既然有继承，也肯定有一级元素modules来定义子元素 
3、父项目里的一级元素<modules> 
<module>lcas-admin-war</module> 
<
    
                                
    • 
                                
  • sql查地区省市县
                                    3213213333332132
sqlmysql
                                    
    
-- db_yhm_city   
SELECT * FROM db_yhm_city WHERE class_parent_id = 1 -- 海南 class_id = 9 港、奥、台 class_id = 33、34、35   
  
SELECT * FROM db_yhm_city WHERE class_parent_id =169   
  
SELECT d1.cla
    
                                
    • 
                                
  • 关于监听器那些让人头疼的事
                                    宝剑锋梅花香
画图板监听器鼠标监听器
                                    
           本人初学JAVA，对于界面开发我只能说有点蛋疼，用JAVA来做界面的话确实需要一定的耐心（不使用插件，就算使用插件的话也没好多少）既然Java提供了界面开发，老师又要求做，只能硬着头皮上啦。但是监听器还真是个难懂的地方，我是上了几次课才略微搞懂了些。 
      
    
                                
    • 
                                
  • JAVA的遍历MAP
                                    darkranger
map
                                    
    Java Map遍历方式的选择 
1. 阐述 
　　对于Java中Map的遍历方式，很多文章都推荐使用entrySet，认为其比keySet的效率高很多。理由是：entrySet方法一次拿到所有key和value的集合；而keySet拿到的只是key的集合，针对每个key，都要去Map中额外查找一次value，从而降低了总体效率。那么实际情况如何呢？ 
　　为了解遍历性能的真实差距，包括在遍历ke
    
                                
    • 
                                
  • POJ 2312 Battle City 优先多列+bfs
                                    aijuans
搜索
                                    
    来源：http://poj.org/problem?id=2312 
题意：题目背景就是小时候玩的坦克大战，求从起点到终点最少需要多少步。已知S和R是不能走得，E是空的，可以走，B是砖，只有打掉后才可以通过。 
思路：很容易看出来这是一道广搜的题目，但是因为走E和走B所需要的时间不一样，因此不能用普通的队列存点。因为对于走B来说，要先打掉砖才能通过，所以我们可以理解为走B需要两步，而走E是指需要1
    
                                
    • 
                                
  • Hibernate与Jpa的关系，终于弄懂
                                    avords
javaHibernate数据库jpa
                                    
    我知道Jpa是一种规范，而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的toplink)，OpenJPA等可供选择，所以使用Jpa的一个好处是，可以更换实现而不必改动太多代码。 
在play中定义Model时，使用的是jpa的annotations，比如javax.persistence.Entity, Table, Column, OneToMany
    
                                
    • 
                                
  • 酸爽的console.log
                                    bee1314
console
                                    
    在前端的开发中，console.log那是开发必备啊，简直直观。通过写小函数，组合大功能。更容易测试。但是在打版本时，就要删除console.log，打完版本进入开发状态又要添加，真不够爽。重复劳动太多。所以可以做些简单地封装，方便开发和上线。 
/**
 * log.js hufeng
 * The safe wrapper for `console.xxx` functions
 *  
    
                                
    • 
                                
  • 哈佛教授：穷人和过于忙碌的人有一个共同思维特质
                                    bijian1013
时间管理励志人生穷人过于忙碌
                                    
            一个跨学科团队今年完成了一项对资源稀缺状况下人的思维方式的研究，结论是：穷人和过于忙碌的人有一个共同思维特质，即注意力被稀缺资源过分占据，引起认知和判断力的全面下降。这项研究是心理学、行为经济学和政策研究学者协作的典范。 
　　这个研究源于穆来纳森对自己拖延症的憎恨。他7岁从印度移民美国，很快就如鱼得水，哈佛毕业
    
                                
    • 
                                
  • other operate
                                    征客丶
OSosx
                                    
    一、Mac Finder 设置排序方式，预览栏 在显示－》查看显示选项中 
二、有时预览显示时，卡死在那，有可能是一些临时文件夹被删除了，如：/private/tmp[有待验证] 
 
-------------------------------------------------------------------- 
若有其他凝问或文中有错误，请及时向我指出， 
我好及时改正，同时也让我们一
    
                                
    • 
                                
  • 【Scala五】分析Spark源代码总结的Scala语法三
                                    bit1129
scala
                                    
    1. If语句作为表达式 
    val properties = if (jobIdToActiveJob.contains(jobId)) {
      jobIdToActiveJob(stage.jobId).properties
    } else {
      // this stage will be assigned to "default" po
    
                                
    • 
                                
  • ZooKeeper 入门
                                    BlueSkator
中间件zk
                                    
    ZooKeeper是一个高可用的分布式数据管理与系统协调框架。基于对Paxos算法的实现，使该框架保证了分布式环境中数据的强一致性，也正是基于这样的特性，使得ZooKeeper解决很多分布式问题。网上对ZK的应用场景也有不少介绍，本文将结合作者身边的项目例子，系统地对ZK的应用场景进行一个分门归类的介绍。 
值得注意的是，ZK并非天生就是为这些应用场景设计的，都是后来众多开发者根据其框架的特性，利
    
                                
    • 
                                
  • MySQL取得当前时间的函数是什么 格式化日期的函数是什么
                                    BreakingBad
mysqlDate
                                    
    取得当前时间用 now() 就行。
在数据库中格式化时间 用DATE_FORMA T(date, format) .
根据格式串format 格式化日期或日期和时间值date，返回结果串。

  可用DATE_FORMAT( ) 来格式化DATE 或DATETIME 值，以便得到所希望的格式。根据format字符串格式化date值:

  %S, %s 两位数字形式的秒（ 00,01,
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-组合模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.util.ArrayList;
import java.util.List;

abstract class Component {
	
	public abstract void printStruct(Str
    
                                
    • 
                                
  • 4_JAVA+Oracle面试题(有答案)
                                    chenke
oracle
                                    
    基础测试题 
 卷面上不能出现任何的涂写文字，所有的答案要求写在答题纸上，考卷不得带走。 
选择题 
1、 What will happen when you attempt to compile and run the following code? （3） 
public class Static { 
 static { 
 int x = 5; // 在static内有效 
 } 
 st
    
                                
    • 
                                
  • 新一代工作流系统设计目标
                                    comsci
工作算法脚本
                                    
     
  用户只需要给工作流系统制定若干个需求，流程系统根据需求，并结合事先输入的组织机构和权限结构，调用若干算法，在流程展示版面上面显示出系统自动生成的流程图，然后由用户根据实际情况对该流程图进行微调，直到满意为止，流程在运行过程中，系统和用户可以根据情况对流程进行实时的调整，包括拓扑结构的调整，权限的调整，内置脚本的调整。。。。。 
 
 在这个设计中，最难的地方是系统根据什么来生成流
    
                                
    • 
                                
  • oracle 行链接与行迁移
                                    daizj
oracle行迁移
                                    
    表里的一行对于一个数据块太大的情况有二种(一行在一个数据块里放不下) 
 
第一种情况: 
INSERT的时候，INSERT时候行的大小就超一个块的大小。Oracle把这行的数据存储在一连串的数据块里(Oracle Stores the data for the row in a chain of data blocks)，这种情况称为行链接(Row Chain)，一般不可避免(除非使用更大的数据
    
                                
    • 
                                
  • [JShop]开源电子商务系统jshop的系统缓存实现
                                    dinguangx
jshop电子商务
                                    
    前言 
jeeshop中通过SystemManager管理了大量的缓存数据，来提升系统的性能，但这些缓存数据全部都是存放于内存中的，无法满足特定场景的数据更新（如集群环境）。JShop对jeeshop的缓存机制进行了扩展，提供CacheProvider来辅助SystemManager管理这些缓存数据，通过CacheProvider,可以把缓存存放在内存,ehcache,redis，memcache
    
                                
    • 
                                
  • 初三全学年难记忆单词
                                    dcj3sjt126com
englishword
                                    
    several 儿子；若干 
shelf 架子 
knowledge 知识；学问 
librarian 图书管理员 
abroad 到国外，在国外 
surf 冲浪 
wave 浪；波浪 
twice 两次；两倍 
describe 描写；叙述 
especially 特别；尤其 
attract 吸引 
prize 奖品；奖赏 
competition 比赛；竞争 
event 大事；事件 
O
    
                                
    • 
                                
  • sphinx实践
                                    dcj3sjt126com
sphinx
                                    
      
安装参考地址:http://briansnelson.com/How_to_install_Sphinx_on_Centos_Server 
  
yum install sphinx 
如果失败的话使用下面的方式安装 
wget http://sphinxsearch.com/files/sphinx-2.2.9-1.rhel6.x86_64.rpm 
yum loca
    
                                
    • 
                                
  • JPA之JPQL（三）
                                    frank1234
ormjpaJPQL
                                    
    1 什么是JPQL 
JPQL是Java Persistence Query Language的简称，可以看成是JPA中的HQL， JPQL支持各种复杂查询。 
 
2 检索单个对象 
@Test 
public  void querySingleObject1() { 
    Query query = em.createQuery("sele
    
                                
    • 
                                
  • Remove Duplicates from Sorted Array II
                                    hcx2013
remove
                                    
    Follow up for "Remove Duplicates":What if duplicates are allowed at most twice? 
For example,Given sorted array nums = [1,1,1,2,2,3], 
Your function should return length 
    
                                
    • 
                                
  • Spring4新特性——Groovy Bean定义DSL
                                    jinnianshilongnian
spring 4
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • CentOS安装Mysql5.5
                                    liuxingguome
centos
                                    
    CentOS下以RPM方式安装MySQL5.5 
 
首先卸载系统自带Mysql： 
yum remove mysql mysql-server mysql-libs compat-mysql51 
rm -rf /var/lib/mysql 
rm /etc/my.cnf 
查看是否还有mysql软件： 
rpm -qa|grep mysql 
 
 
 
去http://dev.mysql.c
    
                                
    • 
                                
  • 第14章 工具函数（下）
                                    onestopweb
函数
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • POJ 1050
                                    SaraWon
二维数组子矩阵最大和
                                    
    POJ ACM第1050题的详细描述，请参照 
http://acm.pku.edu.cn/JudgeOnline/problem?id=1050 
 
题目意思： 
给定包含有正负整型的二维数组，找出所有子矩阵的和的最大值。 
如二维数组 
0 -2 -7 0 
9 2 -6 2 
-4 1 -4 1 
-1 8 0 -2 
中和最大的子矩阵是 
9 2 
-4 1 
-1 8 
且最大和是15
    
                                
    • 
                                
  • [5]设计模式——单例模式
                                    tsface
java单例设计模式虚拟机
                                    
    单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点 
  
安全的单例模式： 
  
  
/*
 * @(#)Singleton.java  2014-8-1
 *
 * Copyright 2014 XXXX, Inc. All rights reserved.
 */
package com.fiberhome.singleton;


    
                                
    • 
                                
  • Java8全新打造，英语学习supertool
                                    yangshangchuan
javasuperword闭包java8函数式编程
                                    
    superword是一个Java实现的英文单词分析软件，主要研究英语单词音近形似转化规律、前缀后缀规律、词之间的相似性规律等等。Clean code、Fluent style、Java8 feature: Lambdas, Streams and Functional-style Programming。 
  
升学考试、工作求职、充电提高，都少不了英语的身影，英语对我们来说实在太重要
    
                                
    •