Redis Java客户端jedis工具类以及Redis实现的跨jvm的锁

Redis Java客户端jedis工具类以及Redis实现的跨jvm的锁

最近项目中使用redis，学习了一下，client端使用jedis-2.1.0 

首先是一个redis实现的跨jvm的lock， 
接着是一个简单封装的工具类，也对pipeline处理进行了几个常用的封装 
然后是对应Spring的相关配置 

 public class RedisLock {

     /** 加锁标志 */
     public static final String LOCKED = "TRUE";
     /** 毫秒与毫微秒的换算单位 1毫秒 = 1000000毫微秒 */
     public static final long MILLI_NANO_CONVERSION = 1000 * 1000L;
     /** 默认超时时间（毫秒） */
     public static final long DEFAULT_TIME_OUT = 1000;
     public static final Random RANDOM = new Random();
     /** 锁的超时时间（秒），过期删除 */
     public static final int EXPIRE = 3 * 60;

     private ShardedJedisPool shardedJedisPool;
     private ShardedJedis jedis;
     private String key;
     // 锁状态标志
     private boolean locked = false;

     /**
      * This creates a RedisLock
      * @param key key
      * @param shardedJedisPool 数据源
      */
     public RedisLock(String key, ShardedJedisPool shardedJedisPool) {
         this.key = key + "_lock";
         this.shardedJedisPool = shardedJedisPool;
         this.jedis = this.shardedJedisPool.getResource();
     }

     /**
      * 加锁
      * 应该以：
      * lock();
      * try {
      *      doSomething();
      * } finally {
      *      unlock()；
      * }
      * 的方式调用
      * @param timeout 超时时间
      * @return 成功或失败标志
      */
     public boolean lock(long timeout) {
         long nano = System.nanoTime();
         timeout *= MILLI_NANO_CONVERSION;
         try {
             while ((System.nanoTime() - nano) < timeout) {
                 if (this.jedis.setnx(this.key, LOCKED) == 1) {
                     this.jedis.expire(this.key, EXPIRE);
                     this.locked = true;
                     return this.locked;
                 }
                 // 短暂休眠，避免出现活锁
                 Thread.sleep(3, RANDOM.nextInt(500));
             }
         } catch (Exception e) {
             throw new RuntimeException("Locking error", e);
         }
         return false;
     }

     /**
      * 加锁
      * 应该以：
      * lock();
      * try {
      *      doSomething();
      * } finally {
      *      unlock()；
      * }
      * 的方式调用
      * @param timeout 超时时间
      * @param expire 锁的超时时间（秒），过期删除
      * @return 成功或失败标志
      */
     public boolean lock(long timeout, int expire) {
         long nano = System.nanoTime();
         timeout *= MILLI_NANO_CONVERSION;
         try {
             while ((System.nanoTime() - nano) < timeout) {
                 if (this.jedis.setnx(this.key, LOCKED) == 1) {
                     this.jedis.expire(this.key, expire);
                     this.locked = true;
                     return this.locked;
                 }
                 // 短暂休眠，避免出现活锁
                 Thread.sleep(3, RANDOM.nextInt(500));
             }
         } catch (Exception e) {
             throw new RuntimeException("Locking error", e);
         }
         return false;
     }

     /**
      * 加锁
      * 应该以：
      * lock();
      * try {
      *      doSomething();
      * } finally {
      *      unlock()；
      * }
      * 的方式调用
      * @return 成功或失败标志
      */
     public boolean lock() {
         return lock(DEFAULT_TIME_OUT);
     }

     /**
      * 解锁
      * 无论是否加锁成功，都需要调用unlock
      * 应该以：
      * lock();
      * try {
      *      doSomething();
      * } finally {
      *      unlock()；
      * }
      * 的方式调用
      */
     public void unlock() {
         try {
             if (this.locked) {
                 this.jedis.del(this.key);
             }
         } finally {
             this.shardedJedisPool.returnResource(this.jedis);
         }
     }
 }

 /**
  * 内存数据库Redis的辅助类，负责对内存数据库的所有操作
  * @version V1.0
  * @author fengjc
  */
 public class RedisUtil {

     // 数据源
     private ShardedJedisPool shardedJedisPool;

     /**
      * 执行器，{@link com.futurefleet.framework.base.redis.RedisUtil}的辅助类，
      * 它保证在执行操作之后释放数据源returnResource(jedis)
      * @version V1.0
      * @author fengjc
      * @param
      */
     abstract class Executor {

         ShardedJedis jedis;
         ShardedJedisPool shardedJedisPool;

         public Executor(ShardedJedisPool shardedJedisPool) {
             this.shardedJedisPool = shardedJedisPool;
             jedis = this.shardedJedisPool.getResource();
         }

         /**
          * 回调
          * @return 执行结果
          */
         abstract T execute();

         /**
          * 调用{@link #execute()}并返回执行结果
          * 它保证在执行{@link #execute()}之后释放数据源returnResource(jedis)
          * @return 执行结果
          */
         public T getResult() {
             T result = null;
             try {
                 result = execute();
             } catch (Throwable e) {
                 throw new RuntimeException("Redis execute exception", e);
             } finally {
                 if (jedis != null) {
                     shardedJedisPool.returnResource(jedis);
                 }
             }
             return result;
         }
     }

     /**
      * 删除模糊匹配的key
      * @param likeKey 模糊匹配的key
      * @return 删除成功的条数
      */
     public long delKeysLike(final String likeKey) {
         return new Executor(shardedJedisPool) {

             @Override
             Long execute() {
                 Collection jedisC = jedis.getAllShards();
                 Iterator iter = jedisC.iterator();
                 long count = 0;
                 while (iter.hasNext()) {
                     Jedis _jedis = iter.next();
                     Set keys = _jedis.keys(likeKey + "*");
                     count += _jedis.del(keys.toArray(new String[keys.size()]));
                 }
                 return count;
             }
         }.getResult();
     }

     /**
      * 删除
      * @param key 匹配的key
      * @return 删除成功的条数
      */
     public Long delKey(final String key) {
         return new Executor(shardedJedisPool) {

             @Override
             Long execute() {
                 return jedis.del(key);
             }
         }.getResult();
     }

     /**
      * 删除
      * @param keys 匹配的key的集合
      * @return 删除成功的条数
      */
     public Long delKeys(final String[] keys) {
         return new Executor(shardedJedisPool) {

             @Override
             Long execute() {
                 Collection jedisC = jedis.getAllShards();
                 Iterator iter = jedisC.iterator();
                 long count = 0;
                 while (iter.hasNext()) {
                     Jedis _jedis = iter.next();
                     count += _jedis.del(keys);
                 }
                 return count;
             }
         }.getResult();
     }

     /**
      * 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
      * 在 Redis 中，带有生存时间的 key 被称为『可挥发』(volatile)的。
      * @param key key
      * @param expire 生命周期，单位为秒
      * @return 1: 设置成功 0: 已经超时或key不存在
      */
     public Long expire(final String key, final int expire) {
         return new Executor(shardedJedisPool) {

             @Override
             Long execute() {
                 return jedis.expire(key, expire);
             }
         }.getResult();
     }

     /**
      * 一个跨jvm的id生成器，利用了redis原子性操作的特点
      * @param key id的key
      * @return 返回生成的Id
      */
     public long makeId(final String key) {
         return new Executor(shardedJedisPool) {

             @Override
             Long execute() {
                 long id = jedis.incr(key);
                 if ((id + 75807) >= Long.MAX_VALUE) {
                     // 避免溢出，重置，getSet命令之前允许incr插队，75807就是预留的插队空间
                     jedis.getSet(key, "0");
                 }
                 return id;
             }
         }.getResult();
     }

     /* ======================================Strings====================================== */

     /**
      * 将字符串值 value 关联到 key 。
      * 如果 key 已经持有其他值， setString 就覆写旧值，无视类型。
      * 对于某个原本带有生存时间（TTL）的键来说， 当 setString 成功在这个键上执行时， 这个键原有的 TTL 将被清除。
      * 时间复杂度：O(1)
      * @param key key
      * @param value string value
      * @return 在设置操作成功完成时，才返回 OK 。
      */
     public String setString(final String key, final String value) {
         return new Executor(shardedJedisPool) {

             @Override
             String execute() {
                 return jedis.set(key, value);
             }
         }.getResult();
     }

     /**
      * 将值 value 关联到 key ，并将 key 的生存时间设为 expire (以秒为单位)。
      * 如果 key 已经存在， 将覆写旧值。
      * 类似于以下两个命令:
      * SET key value
      * EXPIRE key expire # 设置生存时间
      * 不同之处是这个方法是一个原子性(atomic)操作，关联值和设置生存时间两个动作会在同一时间内完成，在 Redis 用作缓存时，非常实用。
      * 时间复杂度：O(1)
      * @param key key
      * @param value string value
      * @param expire 生命周期
      * @return 设置成功时返回 OK 。当 expire 参数不合法时，返回一个错误。
      */
     public String setString(final String key, final String value, final int expire) {
         return new Executor(shardedJedisPool) {

             @Override
             String execute() {
                 return jedis.setex(key, expire, value);
             }
         }.getResult();
     }

     /**
      * 将 key 的值设为 value ，当且仅当 key 不存在。若给定的 key 已经存在，则 setStringIfNotExists 不做任何动作。
      * 时间复杂度：O(1)
      * @param key key
      * @param value string value
      * @return 设置成功，返回 1 。设置失败，返回 0 。
      */
     public Long setStringIfNotExists(final String key, final String value) {
         return new Executor(shardedJedisPool) {

             @Override
             Long execute() {
                 return jedis.setnx(key, value);
             }
         }.getResult();
     }

     /**
      * 返回 key 所关联的字符串值。如果 key 不存在那么返回特殊值 nil 。
      * 假如 key 储存的值不是字符串类型，返回一个错误，因为 getString 只能用于处理字符串值。
      * 时间复杂度: O(1)
      * @param key key
      * @return 当 key 不存在时，返回 nil ，否则，返回 key 的值。如果 key 不是字符串类型，那么返回一个错误。
      */
     public String getString(final String key) {
         return new Executor(shardedJedisPool) {

             @Override
             String execute() {
                 return jedis.get(key);
             }
         }.getResult();
     }

     /**
      * 批量的 {@link #setString(String, String)}
      * @param pairs 键值对数组{数组第一个元素为key，第二个元素为value}
      * @return 操作状态的集合
      */
     public List batchSetString(final List> pairs) {   
              return new Executor>(shardedJedisPool) {   
         
                  @Override   
                  List execute() {   
                      ShardedJedisPipeline pipeline = jedis.pipelined();   
                      for (Pair pair : pairs) {   
                          pipeline.set(pair.getKey(), pair.getValue());   
                      }   
                      return pipeline.syncAndReturnAll();   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 批量的 {@link #getString(String)}  
           * @param keys key数组  
           * @return value的集合  
           */   
          public List batchGetString(final String[] keys) {   
              return new Executor>(shardedJedisPool) {   
         
                  @Override   
                  List execute() {   
                      ShardedJedisPipeline pipeline = jedis.pipelined();   
                      List result = new ArrayList(keys.length);   
                      List> responses = new ArrayList>(keys.length);   
                      for (String key : keys) {   
                          responses.add(pipeline.get(key));   
                      }   
                      pipeline.sync();   
                      for (Response resp : responses) {   
                          result.add(resp.get());   
                      }   
                      return result;   
                  }   
              }.getResult();   
          }   
         
          /* ======================================Hashes====================================== */   
         
          /**  
           * 将哈希表 key 中的域 field 的值设为 value 。  
           * 如果 key 不存在，一个新的哈希表被创建并进行 hashSet 操作。  
           * 如果域 field 已经存在于哈希表中，旧值将被覆盖。  
           * 时间复杂度: O(1)  
           * @param key key  
           * @param field 域  
           * @param value string value  
           * @return 如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1 。如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 0 。  
           */   
          public Long hashSet(final String key, final String field, final String value) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  Long execute() {   
                      return jedis.hset(key, field, value);   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 将哈希表 key 中的域 field 的值设为 value 。  
           * 如果 key 不存在，一个新的哈希表被创建并进行 hashSet 操作。  
           * 如果域 field 已经存在于哈希表中，旧值将被覆盖。  
           * @param key key  
           * @param field 域  
           * @param value string value  
           * @param expire 生命周期，单位为秒  
           * @return 如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1 。如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 0 。  
           */   
          public Long hashSet(final String key, final String field, final String value, final int expire) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  Long execute() {   
                      Pipeline pipeline = jedis.getShard(key).pipelined();   
                      Response result = pipeline.hset(key, field, value);   
                      pipeline.expire(key, expire);   
                      pipeline.sync();   
                      return result.get();   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 返回哈希表 key 中给定域 field 的值。  
           * 时间复杂度:O(1)  
           * @param key key  
           * @param field 域  
           * @return 给定域的值。当给定域不存在或是给定 key 不存在时，返回 nil 。  
           */   
          public String hashGet(final String key, final String field) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  String execute() {   
                      return jedis.hget(key, field);   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 返回哈希表 key 中给定域 field 的值。 如果哈希表 key 存在，同时设置这个 key 的生存时间  
           * @param key key  
           * @param field 域  
           * @param expire 生命周期，单位为秒  
           * @return 给定域的值。当给定域不存在或是给定 key 不存在时，返回 nil 。  
           */   
          public String hashGet(final String key, final String field, final int expire) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  String execute() {   
                      Pipeline pipeline = jedis.getShard(key).pipelined();   
                      Response result = pipeline.hget(key, field);   
                      pipeline.expire(key, expire);   
                      pipeline.sync();   
                      return result.get();   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 同时将多个 field-value (域-值)对设置到哈希表 key 中。  
           * 时间复杂度: O(N) (N为fields的数量)  
           * @param key key  
           * @param hash field-value的map  
           * @return 如果命令执行成功，返回 OK 。当 key 不是哈希表(hash)类型时，返回一个错误。  
           */   
          public String hashMultipleSet(final String key, final Map hash) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  String execute() {   
                      return jedis.hmset(key, hash);   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 同时将多个 field-value (域-值)对设置到哈希表 key 中。同时设置这个 key 的生存时间  
           * @param key key  
           * @param hash field-value的map  
           * @param expire 生命周期，单位为秒  
           * @return 如果命令执行成功，返回 OK 。当 key 不是哈希表(hash)类型时，返回一个错误。  
           */   
          public String hashMultipleSet(final String key, final Map hash, final int expire) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  String execute() {   
                      Pipeline pipeline = jedis.getShard(key).pipelined();   
                      Response result = pipeline.hmset(key, hash);   
                      pipeline.expire(key, expire);   
                      pipeline.sync();   
                      return result.get();   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 返回哈希表 key 中，一个或多个给定域的值。如果给定的域不存在于哈希表，那么返回一个 nil 值。  
           * 时间复杂度: O(N) (N为fields的数量)  
           * @param key key  
           * @param fields field的数组  
           * @return 一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。  
           */   
          public List hashMultipleGet(final String key, final String... fields) {   
              return new Executor>(shardedJedisPool) {   
         
                  @Override   
                  List execute() {   
                      return jedis.hmget(key, fields);   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 返回哈希表 key 中，一个或多个给定域的值。如果给定的域不存在于哈希表，那么返回一个 nil 值。  
           * 同时设置这个 key 的生存时间  
           * @param key key  
           * @param fields field的数组  
           * @param expire 生命周期，单位为秒  
           * @return 一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。  
           */   
          public List hashMultipleGet(final String key, final int expire, final String... fields) {   
              return new Executor>(shardedJedisPool) {   
         
                  @Override   
                  List execute() {   
                      Pipeline pipeline = jedis.getShard(key).pipelined();   
                      Response> result = pipeline.hmget(key, fields);   
                      pipeline.expire(key, expire);   
                      pipeline.sync();   
                      return result.get();   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 批量的{@link #hashMultipleSet(String, Map)}，在管道中执行  
           * @param pairs 多个hash的多个field  
           * @return 操作状态的集合  
           */   
          public List batchHashMultipleSet(final List>> pairs) {   
              return new Executor>(shardedJedisPool) {   
         
                  @Override   
                  List execute() {   
                      ShardedJedisPipeline pipeline = jedis.pipelined();   
                      for (Pair> pair : pairs) {   
                          pipeline.hmset(pair.getKey(), pair.getValue());   
                      }   
                      return pipeline.syncAndReturnAll();   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 批量的{@link #hashMultipleSet(String, Map)}，在管道中执行  
           * @param data Map>格式的数据  
           * @return 操作状态的集合  
           */   
          public List batchHashMultipleSet(final Map> data) {   
              return new Executor>(shardedJedisPool) {   
         
                  @Override   
                  List execute() {   
                      ShardedJedisPipeline pipeline = jedis.pipelined();   
                      for (Map.Entry> iter : data.entrySet()) {   
                          pipeline.hmset(iter.getKey(), iter.getValue());   
                      }   
                      return pipeline.syncAndReturnAll();   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 批量的{@link #hashMultipleGet(String, String...)}，在管道中执行  
           * @param pairs 多个hash的多个field  
           * @return 执行结果的集合  
           */   
          public List> batchHashMultipleGet(final List> pairs) {   
              return new Executor>>(shardedJedisPool) {   
         
                  @Override   
                  List> execute() {   
                      ShardedJedisPipeline pipeline = jedis.pipelined();   
                      List> result = new ArrayList>(pairs.size());   
                      List>> responses = new ArrayList>>(pairs.size());   
                      for (Pair pair : pairs) {   
                          responses.add(pipeline.hmget(pair.getKey(), pair.getValue()));   
                      }   
                      pipeline.sync();   
                      for (Response> resp : responses) {   
                          result.add(resp.get());   
                      }   
                      return result;   
                  }   
              }.getResult();   
         
          }   
         
          /**  
           * 返回哈希表 key 中，所有的域和值。在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。  
           * 时间复杂度: O(N)  
           * @param key key  
           * @return 以列表形式返回哈希表的域和域的值。若 key 不存在，返回空列表。  
           */   
          public Map hashGetAll(final String key) {   
              return new Executor>(shardedJedisPool) {   
         
                  @Override   
                  Map execute() {   
                      return jedis.hgetAll(key);   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 返回哈希表 key 中，所有的域和值。在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。  
           * 同时设置这个 key 的生存时间  
           * @param key key  
           * @param expire 生命周期，单位为秒  
           * @return 以列表形式返回哈希表的域和域的值。若 key 不存在，返回空列表。  
           */   
          public Map hashGetAll(final String key, final int expire) {   
              return new Executor>(shardedJedisPool) {   
         
                  @Override   
                  Map execute() {   
                      Pipeline pipeline = jedis.getShard(key).pipelined();   
                      Response> result = pipeline.hgetAll(key);   
                      pipeline.expire(key, expire);   
                      pipeline.sync();   
                      return result.get();   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 批量的{@link #hashGetAll(String)}  
           * @param keys key的数组  
           * @return 执行结果的集合  
           */   
          public List> batchHashGetAll(final String... keys) {   
              return new Executor>>(shardedJedisPool) {   
         
                  @Override   
                  List> execute() {   
                      ShardedJedisPipeline pipeline = jedis.pipelined();   
                      List> result = new ArrayList>(keys.length);   
                      List>> responses = new ArrayList>>(keys.length);   
                      for (String key : keys) {   
                          responses.add(pipeline.hgetAll(key));   
                      }   
                      pipeline.sync();   
                      for (Response> resp : responses) {   
                          result.add(resp.get());   
                      }   
                      return result;   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 批量的{@link #hashMultipleGet(String, String...)}，与{@link #batchHashGetAll(String...)}不同的是，返回值为Map类型  
           * @param keys key的数组  
           * @return 多个hash的所有filed和value  
           */   
          public Map> batchHashGetAllForMap(final String... keys) {   
              return new Executor>>(shardedJedisPool) {   
         
                  @Override   
                  Map> execute() {   
                      ShardedJedisPipeline pipeline = jedis.pipelined();   
         
                      // 设置map容量防止rehash   
                      int capacity = 1;   
                      while ((int) (capacity * 0.75) <= keys.length) {   
                          capacity <<= 1;   
                      }   
                      Map> result = new HashMap>(capacity);   
                      List>> responses = new ArrayList>>(keys.length);   
                      for (String key : keys) {   
                          responses.add(pipeline.hgetAll(key));   
                      }   
                      pipeline.sync();   
                      for (int i = 0; i < keys.length; ++i) {   
                          result.put(keys[i], responses.get(i).get());   
                      }   
                      return result;   
                  }   
              }.getResult();   
          }   
         
          /* ======================================List====================================== */   
         
          /**  
           * 将一个或多个值 value 插入到列表 key 的表尾(最右边)。  
           * @param key key  
           * @param values value的数组  
           * @return 执行 listPushTail 操作后，表的长度  
           */   
          public Long listPushTail(final String key, final String... values) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  Long execute() {   
                      return jedis.rpush(key, values);   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 将一个或多个值 value 插入到列表 key 的表头  
           * @param key key  
           * @param value string value  
           * @return 执行 listPushHead 命令后，列表的长度。  
           */   
          public Long listPushHead(final String key, final String value) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  Long execute() {   
                      return jedis.lpush(key, value);   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 将一个或多个值 value 插入到列表 key 的表头, 当列表大于指定长度是就对列表进行修剪(trim)  
           * @param key key  
           * @param value string value  
           * @param size 链表超过这个长度就修剪元素  
           * @return 执行 listPushHeadAndTrim 命令后，列表的长度。  
           */   
          public Long listPushHeadAndTrim(final String key, final String value, final long size) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  Long execute() {   
                      Pipeline pipeline = jedis.getShard(key).pipelined();   
                      Response result = pipeline.lpush(key, value);   
                      // 修剪列表元素, 如果 size - 1 比 end 下标还要大，Redis将 size 的值设置为 end 。   
                      pipeline.ltrim(key, 0, size - 1);   
                      pipeline.sync();   
                      return result.get();   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 批量的{@link #listPushTail(String, String...)}，以锁的方式实现  
           * @param key key  
           * @param values value的数组  
           * @param delOld 如果key存在，是否删除它。true 删除；false: 不删除，只是在行尾追加  
           */   
          public void batchListPushTail(final String key, final String[] values, final boolean delOld) {   
              new Executor(shardedJedisPool) {   
         
                  @Override   
                  Object execute() {   
                      if (delOld) {   
                          RedisLock lock = new RedisLock(key, shardedJedisPool);   
                          lock.lock();   
                          try {   
                              Pipeline pipeline = jedis.getShard(key).pipelined();   
                              pipeline.del(key);   
                              for (String value : values) {   
                                  pipeline.rpush(key, value);   
                              }   
                              pipeline.sync();   
                          } finally {   
                              lock.unlock();   
                          }   
                      } else {   
                          jedis.rpush(key, values);   
                      }   
                      return null;   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 同{@link #batchListPushTail(String, String[], boolean)},不同的是利用redis的事务特性来实现  
           * @param key key  
           * @param values value的数组  
           * @return null  
           */   
          public Object updateListInTransaction(final String key, final List values) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  Object execute() {   
                      Transaction transaction = jedis.getShard(key).multi();   
                      transaction.del(key);   
                      for (String value : values) {   
                          transaction.rpush(key, value);   
                      }   
                      transaction.exec();   
                      return null;   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 在key对应list的尾部部添加字符串元素,如果key存在，什么也不做  
           * @param key key  
           * @param values value的数组  
           * @return 执行insertListIfNotExists后，表的长度  
           */   
          public Long insertListIfNotExists(final String key, final String[] values) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  Long execute() {   
                      RedisLock lock = new RedisLock(key, shardedJedisPool);   
                      lock.lock();   
                      try {   
                          if (!jedis.exists(key)) {   
                              return jedis.rpush(key, values);   
                          }   
                      } finally {   
                          lock.unlock();   
                      }   
                      return 0L;   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 返回list所有元素，下标从0开始，负值表示从后面计算，-1表示倒数第一个元素，key不存在返回空列表  
           * @param key key  
           * @return list所有元素  
           */   
          public List listGetAll(final String key) {   
              return new Executor>(shardedJedisPool) {   
         
                  @Override   
                  List execute() {   
                      return jedis.lrange(key, 0, -1);   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 返回指定区间内的元素，下标从0开始，负值表示从后面计算，-1表示倒数第一个元素，key不存在返回空列表  
           * @param key key  
           * @param beginIndex 下标开始索引（包含）  
           * @param endIndex 下标结束索引（不包含）  
           * @return 指定区间内的元素  
           */   
          public List listRange(final String key, final long beginIndex, final long endIndex) {   
              return new Executor>(shardedJedisPool) {   
         
                  @Override   
                  List execute() {   
                      return jedis.lrange(key, beginIndex, endIndex - 1);   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 一次获得多个链表的数据  
           * @param keys key的数组  
           * @return 执行结果  
           */   
          public Map> batchGetAllList(final List keys) {   
              return new Executor>>(shardedJedisPool) {   
         
                  @Override   
                  Map> execute() {   
                      ShardedJedisPipeline pipeline = jedis.pipelined();   
                      Map> result = new HashMap>();   
                      List>> responses = new ArrayList>>(keys.size());   
                      for (String key : keys) {   
                          responses.add(pipeline.lrange(key, 0, -1));   
                      }   
                      pipeline.sync();   
                      for (int i = 0; i < keys.size(); ++i) {   
                          result.put(keys.get(i), responses.get(i).get());   
                      }   
                      return result;   
                  }   
              }.getResult();   
          }   
         
          /* ======================================Pub/Sub====================================== */   
         
          /**  
           * 将信息 message 发送到指定的频道 channel。  
           * 时间复杂度：O(N+M)，其中 N 是频道 channel 的订阅者数量，而 M 则是使用模式订阅(subscribed patterns)的客户端的数量。  
           * @param channel 频道  
           * @param message 信息  
           * @return 接收到信息 message 的订阅者数量。  
           */   
          public Long publish(final String channel, final String message) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  Long execute() {   
                      Jedis _jedis = jedis.getShard(channel);   
                      return _jedis.publish(channel, message);   
                  }   
                     
              }.getResult();   
          }   
         
          /**  
           * 订阅给定的一个频道的信息。  
           * @param jedisPubSub 监听器  
           * @param channel 频道  
           */   
          public void subscribe(final JedisPubSub jedisPubSub, final String channel) {   
              new Executor(shardedJedisPool) {   
         
                  @Override   
                  Object execute() {   
                      Jedis _jedis = jedis.getShard(channel);   
                      // 注意subscribe是一个阻塞操作，因为当前线程要轮询Redis的响应然后调用subscribe   
                      _jedis.subscribe(jedisPubSub, channel);   
                      return null;   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 取消订阅  
           * @param jedisPubSub 监听器  
           */   
          public void unSubscribe(final JedisPubSub jedisPubSub) {   
              jedisPubSub.unsubscribe();   
          }   
         
          /* ======================================Sorted set================================= */   
         
          /**  
           * 将一个 member 元素及其 score 值加入到有序集 key 当中。  
           * @param key key  
           * @param score score 值可以是整数值或双精度浮点数。  
           * @param member 有序集的成员  
           * @return 被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。  
           */   
          public Long addWithSortedSet(final String key, final double score, final String member) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  Long execute() {   
                      return jedis.zadd(key, score, member);   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 将多个 member 元素及其 score 值加入到有序集 key 当中。  
           * @param key key  
           * @param scoreMembers score、member的pair  
           * @return 被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。  
           */   
          public Long addWithSortedSet(final String key, final Map scoreMembers) {   
              return new Executor(shardedJedisPool) {   
         
                  @Override   
                  Long execute() {   
                      return jedis.zadd(key, scoreMembers);   
                  }   
              }.getResult();   
          }   
         
          /**  
           * 返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。  
           * 有序集成员按 score 值递减(从大到小)的次序排列。  
           * @param key key  
           * @param max score最大值  
           * @param min score最小值  
           * @return 指定区间内，带有 score 值(可选)的有序集成员的列表  
           */   
          public Set revrangeByScoreWithSortedSet(final String key, final double max, final double min) {   
              return new Executor>(shardedJedisPool) {   
         
                  @Override   
                  Set execute() {   
                      return jedis.zrevrangeByScore(key, max, min);   
                  }   
              }.getResult();   
          }   
         
          /* ======================================Other====================================== */   
         
          /**  
           * 设置数据源  
           * @param shardedJedisPool 数据源  
           */   
          public void setShardedJedisPool(ShardedJedisPool shardedJedisPool) {   
              this.shardedJedisPool = shardedJedisPool;   
          }   
         
          /**  
           * 构造Pair键值对  
           * @param key key  
           * @param value value  
           * @return 键值对  
           */   
          public  Pair makePair(K key, V value) {   
              return new Pair(key, value);   
          }   
         
          /**  
           * 键值对  
           * @version V1.0  
           * @author fengjc  
           * @param  key  
           * @param  value  
           */   
          public class Pair {   
         
              private K key;   
              private V value;   
         
              public Pair(K key, V value) {   
                  this.key = key;   
                  this.value = value;   
              }   
         
              public K getKey() {   
                  return key;   
              }   
         
              public void setKey(K key) {   
                  this.key = key;   
              }   
         
              public V getValue() {   
                  return value;   
              }   
         
              public void setValue(V value) {   
                  this.value = value;   
              }   
          }   
      }   
     
    
    
    Spring配置文件：  
    
    "1.0" encoding="UTF-8" ?>
 "http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
     xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context-3.0.xsd">


     "jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
         "maxActive" value="${redis.jedisPoolConfig.maxActive}" />
         "maxIdle" value="${redis.jedisPoolConfig.maxIdle}" />
         "maxWait" value="${redis.jedisPoolConfig.maxWait}" />
         "testOnBorrow" value="${redis.jedisPoolConfig.testOnBorrow}" />



     "jedis.shardInfoCache1" class="redis.clients.jedis.JedisShardInfo">
         "0" value="${redis.jedis.shardInfoCache1.host}" />
         "1"  type="int" value="${redis.jedis.shardInfoCache1.port}" />

     "jedis.shardInfoCache2" class="redis.clients.jedis.JedisShardInfo">
         "0" value="${redis.jedis.shardInfoCache2.host}" />
         "1"  type="int" value="${redis.jedis.shardInfoCache2.port}" />



     "shardedJedisPoolCache" class="redis.clients.jedis.ShardedJedisPool">
         "0" ref="jedisPoolConfig" />
         "1">

                 "jedis.shardInfoCache1" />
                 "jedis.shardInfoCache2" />




     "redisCache" class="com.**.RedisUtil">
         "shardedJedisPool" ref="shardedJedisPoolCache" />

 
   
  

                            
                        
                    
                    
                    
                    
                    
                    
                
                
                    
                        
                        
                             
                        
                        
                        
                            
                        
                        
                        
                            
                        
                    
                
            
        
    
    
        你可能感兴趣的:(JAVA_WEB)
        
            
                
                    课堂笔记
                        拾花为柴焚诗作薪

                        java_web标签超链接标签作用：跳转，访问其他资源属性：href资源路径target超链接打开的方式"_self"表示在当前标签中打开"_blank"打开一个新开标签页"_parent"在父窗口中打开"_top"在最顶层窗口打开自定义在指定name出打开该超链接锚点属性：name锚点名称，访问时通过“#锚点名”访问form标签作用：收集并提交用户的信息属性：id表单的id，用于js获取表单na
                    
                    手动打war包以及部署应用到tomcat
                        好大一只鹏

                        项目位置：E:\java\eclipse_java_ee\eclipse\java_web\helloSpring打开dos命令窗口;验证java环境：输入jar输入项目位置：cdE:\java\eclipse_java_ee\eclipse\java_web\helloSpring回车后输入jar-cvfhelloSpring.war./*即可打包成功，然后war包部署到tomcat的webap
                    
                    java_web接收前端传的excel文件读取数据
                        (｢･ω･)｢嘿 猪宝
java前端excel
                        #本次做一个将患者数据导入到某个模块的功能，前期集成的代码时不时出现异常，本次进行修改记录//controller层/***导入患者数据*/@RejectReplayRequest@PostMapping("/importData")publicResultimportData(HttpServletRequestrequest,LoginUserloginUser,@Param(value="a
                    
                    JAVA_WEB工具类---属性工具类
                        Elcker
Elcker技术教程WEB_UTILSIntector
                        小伙伴啊，小伙伴，你真是懒得动手！代码如下：importjava.io.File;importjava.io.FileInputStream;importjava.io.IOException;importjava.io.InputStream;importjava.text.SimpleDateFormat;importjava.util.Date;importjava.util.HashMap
                    
                    前端 java_WEB前端与JAVA的区别
                        洛裳
前端java
                        很多想要学习web前端和Java的人，总是比较纠结自己要学习你那个，web前端和Java要了解web前端和Java的区别，就必须搞懂他们都是什么，干什么的。1、要搞懂区别，我们首先要知道他们是什么。Web前端:就是用来作我们可以看得到的像网站页面，aap、手机界面等，我们这里所说的前端泛指Web前端，也就是在Web应用中用户可以看得见碰得着的东西。Java：更多的是与数据库进行交互以处理相应的业务
                    
                    Eclipse新建Maven Project界面select an archetype 空白
                        爱谁谁未成年
maveneclipsemaven
                        1、先用命令行新建maven项目，在电脑上新建一个文件夹，用来存放maven项目，命令行下先进入这个文件夹cdE:\maven\Java_Web\maven-demo2、开始新建mvnarchetype:generate3.接着就是下载各种架包，首先要保证网速，按照提示一步一步建立好成功之后打开eclipse就不会再有问题呢
                    
                    java_web 快速入门之第十章 富文本编辑器与web文件的上传和下载
                        渊婉
javaeclipsetomcat
                        一：富文本编辑器富文本编辑器（RichTextEditor，RTE）是一种可内嵌于浏览器，所见即所得的文本编辑器。它提供类似于OfficeWord的编辑功能，方便那些不太懂HTML用户使用，富文本编辑器的应用非常广泛，它的历史与图文网页诞生的历史几乎一样长。常用的富文本编辑器：①CKEditorCkeditor也是一款非常经典的富文本编辑器，官方下载量过千万。它是在非常著名的FCkEditor基础
                    
                    Java_web笔记: 含html、css、js、servlet、jsp
                        叶 落
javaWebHTMLcssjavawebhtmlcssjsjsp
                        第1章HTML1.1HTML基础1.1.1网页和网站和HTML1.1.1.1网页和网站网站是指在英特网上根据一定的规则，使用HTML等制作用于展示特定内容的相关网页的集合。网页是网站的一“页”，通常是HTML格式的文件，它可以通过浏览器来展示。网页是构成网站的基本元素，它通常由图片、表格、链接、文字、视频等元素组成。通常我们看到的网页是以.htm或.html为后缀的文件，它们都统称为html文件。
                    
                    java_web的框架分析
                        我是小水水啊
Java_webjava前端开发语言
                        文章目录本阶段技术体系用项目理解原理controllersClassPathXmlApplicationContextDispatcherServletFruitServiceImplFilter本阶段技术体系用项目理解原理项目的目录首先设置一个参数，这里里面用反射机制，获取方法的时候如果不设置会获取到arg[0],arg[1]…等等，设置了之后就会正常显示函数的名称项目概念的理解controll
                    
                    java_web 项目的创建
                        我是小水水啊
Java_webjava前端web
                        文章目录环境配置idea项目的搭建与依赖的配置环境配置jdbc（MySQL和Java连接的架包）mysql-connector-java-8.0.27-bin.jardruid-1.1.21.jartomcat的架包官网：https://tomcat.apache.org/Tomcat8.5.24thymeleaf（Java后端与前端代码的渲染）官网：https://www.thymeleaf.o
                    
                    java_web：基于三层架构设计一个学生信息管理系统（暂时实现了一个增加学生功能）
                        _小尘
java_webjavaservletmysql
                        应用实例：用三层架构模型实现一个增加学生功能的学生信息管理项目涉及的理论知识：三层架构设计模型项目结构图1.需要用到的数据库与数据表createdatabasetest;usetest;droptableifexistsstudent;createtablestudent(s_idintnotnullprimarykey,s_namevarchar(20),s_ageint,s_addressva
                    
                    java_web [Maven]项目
                        码字小萌新♡
javajavamaven前端tomcatintellij-idea
                        一.web项目搭建及web服务器(一)一般Java项目(二)java_web项目创建(三)web服务器Web服务器：【apacthapacthTomcatweblogic】发布项目—最终运行1.结构剖析：tomcat2.tomcatserver.xml配置文件x相关的配置场景(四)tomcat项目部署tomcat项目部署：将项目复制到tomcat里webapps目录里tomcat导进IDEA(五)
                    
                    java_web 快速入门之第四章 验证码&新闻增加
                        tanglin＿030907031026
javaeclipsetomcatjar
                        一：验证码的基本概念：验证码是一种区分用户是计算机还是人的公共全自动程序，验证码问题由计算机生成并评判，只有人类才能解答，可以防止恶意破解密码、刷票、论坛灌水等问题，分为Gif动画验证码、手机短信验证码、手机语音验证码和视频验证码。由于验证码是随机产生的，有很大几率会出现无法清楚识别的验证码图片，一般会有【看不清，换一张】的提示，直接点击当前的验证码图片可以完成验证码的更换，一般注册用户ID的地方
                    
                    java_web 快速入门之第十一章 三层架构
                        tanglin＿030907031026
eclipsejavatomcat
                        一：三层架构的概述三层架构(3-tierarchitecture)通常意义上的三层架构就是将整个业务应用划分为：表现层（UI）、业务逻辑层（BLL）、数据访问层（DAL）。区分层次的目的即为了“高内聚，低耦合”的思想。表现层（UI）主要是指与用户交互的界面,用于接收用户输入的数据和显示处理后用户需要的数据业务逻辑层（BLL）表示层和数据库访问层之间的桥梁,实现业务逻辑,具体包含：验证、计算、业务规
                    
                    JAVA_WEB框架设计模式总结集(未完结)
                        AinUser
设计模式框架设计模式JAVABean面试必备JAVA_WEB知识
                        设计模式思想：设计模式是为了：增加代码的复用性(一次编码/多处使用)，降低代码块之间的耦合度,提高代码块功能的专一性。我找了几个.pdf文件大家看一下：链接:http://pan.baidu.com/s/1miCUF48密码:r5f8IT职场的小菜经常有这样的疑问：为什么一个相似的功能，大牛一会儿就搞定，然后悠闲地品着下午茶逛淘宝；而自己加班加点搞到天亮还做不完。为什么用户提出需求变更后，大牛只需
                    
                    【JAVA】书店管理系统（附带前后端源码及资源）
                        Lin-CT
JAVAjava前端开发语言
                        【JAVA_Web】书店管理系统（附带前后端源码及资源）一、项目的目的和意义1.1目的在“互联网+”的大趋势下，线上销售以其简单、便捷、高效的特点受到人们的青睐。网上书店不受时间或者空间的限制，只要在网络覆盖的地方人们就可以浏览网页，购买想要的书籍，获知最新的书籍或者资料的信息。线下实体书店则不仅投资成本高，也受空间地点的限制，还必须考虑房租、水电、人工等诸多方面的问题，使书籍的价格不可以压得太低
                    
                    java_web开发中 遇到可坑
                        笑意

                        目前有两个坑,:一首先在启动tomcat的时候我进行的一个跳转页面的操作然后报了如下的错误:org.apache.jasper.JasperException:/jsp/frame.jsp(行.:[2],列:[0])无法在web.xml或使用此应用程序部署的jar文件中解析绝对uri：[http://java.sun.com/jsp/jstl/core]大概的意思就是说无法解析我在jsp引入的核心
                    
                    获取web项目的绝对路径的方法总结
                        超级侠哥

                        转载：http://www.cnblogs.com/duoting/p/4141044.html?utm_source=tuicool&utm_medium=referral一、用Jsp获取1、获取文件的绝对路径Stringfile="文件";（例如：data.mdb）Stringpath=application.getRealPath(file);结果：E:\java_web\workspace
                    
                    JAVA_WEB项目之Lucene实现检索结果排序和关键字在索引库中多字段查询结果进行高亮显示
                        chenchudongsg
JAVA_WEB项目
                        上一篇介绍了JAVA_WEB项目之Lucene使用中文分词器IKAnalyzer3.2.8，接下来对上一篇的代码实现排序的效果和关键字在索引库中多字段查询结果进行高亮显示。首先是排序的效果：Goods类，LuceneUtil类，ConfigureLucene类，测试类等的代码和上一篇的一样，只有HelloWordLucene里面的查询代码不一样。/***根据指定的条件查询，*@paramname指
                    
                    java_web论坛项目4
                        豪毅
myjavajava_web后端java_web后端项目小型论坛
                        java_web论坛项目4（评论点赞的功能实现）这两个功能实现花费了有一天事件吧我把我的难点分享一下吧先说评论功能评论是你点击以后可以发表你自己的话然后添加到数据里面但是我的前端页面评论和回复使用的是同一个模态框所以评论和回复的一个区别就是是否有被回复人的id，以及如何拿到被回复人的id我使用的是jquery控制的跳转直接把信息拼接到链接里面了//如果没有登录直接返回登录界面if(${user.u
                    
                    （建议收藏）Java基础知识笔记（详细）
                        五角钱的程序员
java系列java编程语言算法c++数据结构
                        1.集成开发环境IDEA是一个专门针对Java的集成开发工具(IDE)，由Java语言编写。所以，需要有JRE运行环境并配置好环境变量。它可以极大地提升我们的开发效率。可以自动编译，检查错误。2.创建项目创建项目-创建模块-创建包-创建类(1)创建一个工程(2)jdk版本我这里是1.7的(3)我命名为java_Web(4)创建一个Module我命名为day01(5)创建包和类3.编写程序Java第
                    
                    新人报到，多多关照
                        alsdiuhfeircn
IT有感
                        本人菜鸟一枚，只能说了解汇编语言、C、C++、C#、JAVA、HTML、JAVASCRIPT、PYTHON，做过MFC、ANDROID、JAVA_WEB、ASP.NET、FL、DW、PS等语言项目应用的一些技巧。。。。。。hhhh，I'mcoming!!!!
                    
                    微信小程序之与servlet进行通信（图片+文字）
                        王智涵

                        最近做一个小程序商城前端很快就解决了，各种资源抄一抄改一改就那么回事了后端真是把我折磨够呛，图书馆借了本书后端是用php写的，我之前根本没有接触过php在挣扎了很久之后，选择了更熟悉的java_web进行后端的开发，spring_mvc我也不会，，，网上的代码也看不懂，最后被逼无奈，只能选择了最简单的servlet进行小程序的通信前端代码及图片展示：index.wxml:营业执照{{imageLi
                    
                    Java poi导入word文件提取内容
                        精打细算
Javapoi
                        一、需求描述javaweb项目从前台上传word格式文件，后台接收文件并提取word内容保存至数据库。二、依赖jar包这里操作的是maven项目，所有依赖jar包均可到maven仓库进行免费下载。具体如下：三、后台代码这里的java_web项目采用SpringMVC的内置文件上传方式进行接收解析，具体如下：/***提取word文件内容*@paramfile*@paramrequest*@retur
                    
                    利用tomcat发布java_WEB项目到外网的方法
                        jasonkent27
Java
                        首先写好项目，放在没有中文的路径文件上，tomcat也是路径不能有中文路径然后在tomcat的conf文件的server.xml中添加这样访问到first就访问到了G盘下的上边的项目了然后是路由的设置：1.路由器设置：本人路由器为tp-link..其他请baidu一下了，方法都是端口映射，实现转发，其他机器访问你的外网ip就转发到你机子的ip，就可以了。进入路由的设置页面（主机上地址栏输:http
                    
                    修改http请求参数格式
                        chonghuan5167

                        最近迁移老项目（JAVA_WEB)，由于老项目本身就是做的前后端分离；将老项目整改为新微服务，我想直接使用原来的前段页面；可是有一个问题，原来的页面ajax接口封装了一层，请求信息和现在借口不一致。于是有了这一篇自定义HttpServletRequestWrapper处理参数：packagecom.example.demo;importcom.alibaba.fastjson.JSON;impor
                    
                    Java_web Mybatis
                        ccsu_deer
java_web
                        显示这个日志是没有问题的。可以运行，我还以为是错误，然后疯狂百度，不知道他们为什么说这个也是错误。。。。还有解决办法DEBUG[main]-Logginginitializedusing'classorg.apache.ibatis.logging.slf4j.Slf4jImpl'adapter.DEBUG[main]-Classnotfound:org.jboss.vfs.VFSDEBUG[ma
                    
                    JAVA_WEB项目之Service层抽取成BaseService和BaseServiceImpl
                        chenchudongsg
JAVA_WEB项目
                        在javaweb开发中使用到三大框架开发的时候会涉及到Dao层，Service层，Action层，接下来是贴出在Service层中抽取出公共业务逻辑模块的BaseService接口和BaseServiceImpl实现类。packagecom.shop.service;importjava.util.List;importcom.shop.pojo.Category;publicinterfaceB
                    
                    java_web学期总结
                        IT_tan

                        Javaweb学期总结学习Java的体系课程已经有几个月时间了，其中加入了Web元素，咋听起来让人觉得望而生畏，但是细来一想，无非几个标签而已，语法并没有多困难，核心还是在Java基础概念的掌握。一开始学习前端html+css+javascript的时候，觉得页面效果挺酷炫的，代码也算是简而易懂，其中预科了几乎一个多月的时间，所以把所有知识点也都给过了几遍，正课的时候学起来算是比较轻松，到了前端课
                    
                    JAVA_WEB SSH 开发客户关系管理系统
                        晓 5
java
                        SSH开发客户关系管理系统案例展示：登录界面：注册界面：登录成功后主界面：客户列表界面：新增客户界面：修改客户界面：联系人列表界面：新增联系人页面：联系人列表中查询中的选择客户：客户拜访列表：新增客户拜访页面：实现思路解析：客户列表分析：书写步骤：1）封装PageBean2）书写Action3）书写Service4）书写Dao5）完成struts以及spring的配置6）书写前台list.jsp页
                    
                                二分查找排序算法
                                    周凡杨
java二分查找排序算法折半
                                     一：概念 二分查找又称
折半查找（
折半搜索/
二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而 查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表 分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
                                
                                java中的BigDecimal
                                    bijian1013
javaBigDecimal
                                            在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。 
        原文地址：http://blog.csdn.net/ugg/article/de
                                
                                Shell echo命令详解
                                    daizj
echoshell
                                    Shell echo命令 
Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式： 
echo string 
您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串: 
  echo "It is a test" 
这里的双引号完全可以省略，以下命令与上面实例效果一致： 
  echo Itis a test 2.显示转义
                                
                                Oracle DBA 简单操作
                                    周凡杨
oracle dba sql
                                     --执行次数多的SQL 
 select sql_text,executions from ( 
     select sql_text,executions from v$sqlarea order by executions desc 
     ) where rownum<81; 
 &nb
                                
                                画图重绘
                                    朱辉辉33
游戏
                                      我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。 
  在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
                                
                                线程之初体验
                                    西蜀石兰
线程
                                    一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。 
之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。 
 
线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。 
你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
                                
                                linux集群互相免登陆配置
                                    林鹤霄
linux
                                    配置ssh免登陆 
1、生成秘钥和公钥    ssh-keygen -t rsa 
2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub 
   其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密    c
                                
                                mysql : Lock wait timeout exceeded; try restarting transaction
                                    aigo
mysql
                                    原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html 
  
原因是你使用的InnoDB   表类型的时候, 
默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s, 
因为有的锁等待超过了这个时间,所以抱错. 
  
你可以把这个时间加长,或者优化存储
                                
                                Socket编程 基本的聊天实现。
                                    alleni123
socket
                                    public class Server
{

	//用来存储所有连接上来的客户
	private List<ServerThread> clients;
	
	public static void main(String[] args)
	{
		Server s = new Server();
		s.startServer(9988);
	}

	publi
                                
                                多线程监听器事件模式(一个简单的例子)
                                    百合不是茶
线程监听模式
                                        
多线程的事件监听器模式 
  监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到 
  
     创建多线程的事件监听器模式 思路: 
   1, 创建线程并启动,在创建线程的位置设置一个标记 
    2,创建队
                                
                                spring InitializingBean接口
                                    bijian1013
javaspring
                                    spring的事务的TransactionTemplate，其源码如下： 
public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{
 ...
} 
TransactionTemplate继承了DefaultT
                                
                                Oracle中询表的权限被授予给了哪些用户
                                    bijian1013
oracle数据库权限
                                            Oracle查询表将权限赋给了哪些用户的SQL，以备查用。 
select t.table_name as "表名",
       t.grantee    as "被授权的属组",
       t.owner      as "对象所在的属组"
                                
                                【Struts2五】Struts2 参数传值
                                    bit1129
struts2
                                    Struts2中参数传值的3种情况 
1.请求参数绑定到Action的实例字段上 
2.Action将值传递到转发的视图上 
3.Action将值传递到重定向的视图上 
  一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上  
Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
                                
                                【Kafka十四】关于auto.offset.reset[Q/A]
                                    bit1129
kafka
                                    I got serveral questions about  auto.offset.reset. This configuration parameter governs how  consumer read the message from  Kafka when  there is no initial offset in ZooKeeper or 
                                
                                nginx gzip压缩配置
                                    ronin47
nginx gzip 压缩范例
                                    nginx gzip压缩配置   更多 
0      
 nginx      
 gzip      
 配置         
随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？ 
gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
                                
                                java-13.输入一个单向链表，输出该链表中倒数第 k 个节点
                                    bylijinnan
java
                                    two cursors. 
Make the first cursor go K steps first. 
 
 

/*
	 * 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点
	 */
	public void displayKthItemsBackWard(ListNode head,int k){
		ListNode p1=head,p2=head;

                                
                                Spring源码学习-JdbcTemplate queryForObject
                                    bylijinnan
javaspring
                                    JdbcTemplate中有两个可能会混淆的queryForObject方法： 
1. 
Object queryForObject(String sql, Object[] args, Class requiredType) 
2. 
Object queryForObject(String sql, Object[] args, RowMapper rowMapper) 
 
第1个方法是只查
                                
                                [冰川时代]在冰川时代,我们需要什么样的技术?
                                    comsci
技术
                                     
 
     看美国那边的气候情况....我有个感觉...是不是要进入小冰期了? 
 
     那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段... 
 
  &nb
                                
                                js 获取浏览器型号
                                    cuityang
js浏览器
                                    根据浏览器获取iphone和apk的下载地址 
 
<!DOCTYPE html> 
<html> 
<head> 
    <meta charset="utf-8" content="text/html"/> 
    <meta name=
                                
                                C# socks5详解 转
                                    dalan_123
socketC#
                                    http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html    这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
                                
                                运维 Centos问题汇总
                                    dcj3sjt126com
云主机
                                    一、sh 脚本不执行的原因 
sh脚本不执行的原因 只有2个 
1.权限不够 
2.sh脚本里路径没写完整。 
  
二、解决You have new mail in /var/spool/mail/root 
修改/usr/share/logwatch/default.conf/logwatch.conf配置文件 
MailTo = 
MailFrom 
  
三、查询连接数
                                
                                Yii防注入攻击笔记
                                    dcj3sjt126com
sqlWEB安全yii
                                    网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号  这里有个转义对照表： 
http://blog.csdn.net/xinzhu1990/articl
                                
                                MongoDB简介[一]
                                    eksliang
mongodbMongoDB简介
                                    MongoDB简介 
转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用 
       MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。 
       另外，不
                                
                                zookeeper windows 入门安装和测试
                                    greemranqq
zookeeper安装分布式
                                    一、序言 
      以下是我对zookeeper 的一些理解：      zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。 
      栗子1号： 
      假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
                                
                                Spring之使用事务缘由(2-注解实现)
                                    ihuning
spring
                                      
Spring事务注解实现 
  
1. 依赖包： 
    1.1 spring包： 
          spring-beans-4.0.0.RELEASE.jar 
          spring-context-4.0.0.
                                
                                iOS App Launch Option
                                    啸笑天
option
                                    iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。 
  
launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节 。 
1、若用户直接
                                
                                jdk与jre的区别（_）
                                    macroli
javajvmjdk
                                    简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。  
JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。 如果安装了JDK，会发同你
                                
                                Updates were rejected because the tip of your current branch is behind
                                    qiaolevip
学习永无止境每天进步一点点众观千象git
                                    $ git push joe prod-2295-1

To [email protected]:joe.le/dr-frontend.git
 ! [rejected]        prod-2295-1 -> prod-2295-1 (non-fast-forward)
error: failed to push some refs to '[email protected]
                                
                                [一起学Hive]之十四-Hive的元数据表结构详解
                                    superlxw1234
hivehive元数据结构
                                    关键字：Hive元数据、Hive元数据表结构 
  
之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。 
本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。 
  
文章最后面，会以一个示例来全面了解一下，
                                
                                Spring 3.2.14，4.1.7，4.2.RC2发布
                                    wiselyman
Spring 3
                                      
Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。 
  
其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。 
  
其中Spring 4.1.7主要包含这些更新内容。 
                                
                
            
        
    


    
        
            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    
        
            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.