大数据技术进阶
大数据技术进阶

RedisPool操作Redis，工具类实例

redis.properties
配置文件内容
redis.pool.maxActive=100
redis.pool.maxIdle=20
redis.pool.maxWait=3000
redis.pool.testOnBorrow=false
redis.pool.testOnReturn=false

redis.ip=127.0.0.1
redis.port=6379
redis.port1=6380
redis.password=****

package com.szreach.rcrp.redis;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Set;

import org.apache.log4j.Logger;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

public class RedisUtil {

   private static final Logger log = Logger.getLogger(RedisUtil.class);
   private static JedisPool jedisPool = null;
   private static ShardedJedisPool shardedJedisPool = null;
   /**
    * 初始化Redis连接池
    */
   static {
       try {
           // 加载redis配置文件
           ResourceBundle bundle = ResourceBundle.getBundle("redis");
           if (bundle == null) {
               throw new IllegalArgumentException(
                       "[redis.properties] is not found!");
           }
           int maxActivity = Integer.valueOf(bundle
                   .getString("redis.pool.maxActive"));
           int maxIdle = Integer.valueOf(bundle
                   .getString("redis.pool.maxIdle"));
           long maxWait = Long.valueOf(bundle.getString("redis.pool.maxWait"));
           boolean testOnBorrow = Boolean.valueOf(bundle
                   .getString("redis.pool.testOnBorrow"));
           boolean onreturn = Boolean.valueOf(bundle
                   .getString("redis.pool.testOnReturn"));
           // 创建jedis池配置实例
           JedisPoolConfig config = new JedisPoolConfig();
           // 设置池配置项值
           config.setMaxActive(maxActivity);
           config.setMaxIdle(maxIdle);  //最大空闲连接数
           config.setMaxWait(maxWait);
           config.setTestOnBorrow(testOnBorrow);
           config.setTestOnReturn(onreturn);
           jedisPool = new JedisPool(config, bundle.getString("redis.ip"),
                   Integer.valueOf(bundle.getString("redis.port")), 10000,
                   bundle.getString("redis.password"));
           // slave链接
           List shards = new ArrayList();
           shards.add(new JedisShardInfo(bundle.getString("redis.ip"), Integer
                   .valueOf(bundle.getString("redis.port1"))));
           shardedJedisPool = new ShardedJedisPool(config, shards);
           log.info("初始化Redis连接池success");
       } catch (Exception e) {
           log.error("初始化Redis连接池 出错！", e);
       }
   }

   /**
    * 获取Jedis实例
    * 
    * @return
    */
   public synchronized static Jedis getJedis() {
       try {
           if (jedisPool != null) {
               Jedis resource = jedisPool.getResource();
               return resource;
           } else {
               return null;
           }
       } catch (Exception e) {
           log.error("Redis缓存获取Jedis实例 出错！", e);
           return null;
       }
   }

   /**
    * 获取shardedJedis实例
    * 
    * @return
    */
   public static ShardedJedis getShardedJedis() {
       try {
           if (shardedJedisPool != null) {
               ShardedJedis resource = shardedJedisPool.getResource();
               return resource;
           } else {
               return null;
           }
       } catch (Exception e) {
           log.error("Redis缓存获取shardedJedis实例 出错！", e);
           return null;
       }
   }

   /**
    * 释放jedis资源
    * 
    * @param jedis
    */
   public static void returnResource(final Jedis jedis) {
       if (jedis != null) {
           jedisPool.returnResource(jedis);
       }
   }

   /**
    * 释放shardedJedis资源
    * 
    * @param jedis
    */
   public static void returnResource(final ShardedJedis shardedJedis) {
       if (shardedJedis != null) {
           shardedJedisPool.returnResource(shardedJedis);
       }
   }

   /**
    * 向缓存中设置字符串内容
    * 
    * @param key
    *            key
    * @param value
    *            value
    * @return
    * @throws Exception
    */
   public static boolean set(String key, String value) {
       Jedis jedis = null;
       try {
           jedis = getJedis();
           if(jedis != null){
               jedis.set(key, value);
           }
           return true;
       } catch (Exception e) {
           log.error("Redis缓存设置key值 出错！", e);
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   /**
    * 判断key是否存在
    */
   public static boolean exists(String key){
       ShardedJedis jedis = null;
       try {
           jedis = getShardedJedis();
           if (jedis == null) {
               return false;
           } else {
               return jedis.exists(key);
           }
       } catch (Exception e) {
           log.error("Redis缓存判断key是否存在 出错！", e);
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   /**
    * 删除缓存中的对象，根据key
    * @param key
    * @return
    */
   public static boolean del(String key) {
       Jedis jedis = null;
       try {
           jedis = getJedis();
           jedis.del(key);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   
   //*******************key-value****************start
   
   /**
    * 向缓存中设置对象
    * 
    * @param key
    * @param value
    * @return
    */
   public static boolean set(String key, Object value) {
       Jedis jedis = null;
       try {
           String objectJson = JSONObject.fromObject(value).toString();
           jedis = getJedis();
           if (jedis != null) {
               jedis.set(key, objectJson);
           }
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }

   /**
    * 根据key 获取内容
    * 
    * @param key
    * @return
    */
   public static Object get(String key) {
       ShardedJedis jedis = null;
       try {
           jedis = shardedJedisPool.getResource();
           Object value = jedis.get(key);
           return value;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           shardedJedisPool.returnResource(jedis);
       }
   }
   
   /**
    * 根据key 获取对象
    * 
    * @param key
    * @return
    */
   @SuppressWarnings("unchecked")
   public static  T get(String key, Class clazz) {
       ShardedJedis jedis = null;
       try {
           jedis = getShardedJedis();
           if (jedis != null) {
               return (T) JSONObject.toBean(JSONObject.fromObject(jedis.get(key)), clazz);
           } else {
               return null;
           }
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       } finally {
           returnResource(jedis);
       }
   }
   //*******************key-value****************end
   
   //*************** 操作list****************start
   /**
    * 向缓存中设置对象 
    * @param key
    * @param list
    * T string calss
    * @return
    */
   public static  boolean setList(String key,List list){
       Jedis jedis = null;
       try {
           jedis = getJedis();
           if (jedis != null) {
               for (T vz : list) {
                   if (vz instanceof String) {
                       jedis.lpush(key, (String) vz);
                   } else {
                       String objectJson = JSONObject.fromObject(vz).toString();
                       jedis.lpush(key, objectJson);
                   }
               }
               return true;
           } else {
               return false;
           }
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   
   @SuppressWarnings("unchecked")
   public static  List getListEntity(String key,Class entityClass){
       ShardedJedis jedis = null;
       try {
           jedis = getShardedJedis();
           if (jedis != null) {
               List valueJson = jedis.lrange(key, 0, -1);
               JSONArray json = new JSONArray();
               json.addAll(valueJson);
               JSONArray jsonArray = JSONArray.fromObject(json.toString());
               return (List) JSONArray.toCollection(jsonArray, entityClass);
           } else {
               return null;
           }
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       } finally {
           returnResource(jedis);
       }
   }
   
   public static List getListString(String key){
       ShardedJedis jedis = null;
       try {
           jedis = getShardedJedis();
           if (jedis != null) {
               return jedis.lrange(key, 0, -1);
           } else {
               return null;
           }
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       } finally {
           returnResource(jedis);
       }
   }
   //*************** 操作list****************end
   
   //*************** 操作map****************start
   public static  boolean setMap(String key,Map map){
       Jedis jedis = null;
       try {
           jedis = getJedis();
           if (jedis != null) {
               Set> entry = map.entrySet();
               for (Iterator> ite = entry.iterator(); ite.hasNext();) {
                   Map.Entry kv = ite.next();
                   if (kv.getValue() instanceof String) {
                       jedis.hset(key, kv.getKey(), (String) kv.getValue());
                   }else if (kv.getValue() instanceof List) {
                       jedis.hset(key, kv.getKey(), JSONArray.fromObject(kv.getValue()).toString());
                   } else {
                       jedis.hset(key, kv.getKey(), JSONObject.fromObject(kv.getValue()).toString());
                   }
               }
               return true;
           } else {
               return false;
           }
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   public static boolean setMapKey(String key,String mapKey,Object value){
       Jedis jedis = null;
       try {
           jedis = getJedis();
           if (jedis != null) {
               if (value instanceof String) {
                   jedis.hset(key, mapKey, String.valueOf(value));
               } else if (value instanceof List) {
                   jedis.hset(key, mapKey, JSONArray.fromObject(value).toString());
               } else {
                   jedis.hset(key, mapKey, JSONObject.fromObject(value).toString());
               }
               return true;
           } else {
               return false;
           }
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   /**
    * seconds key和value 保存的有效时间（单位：秒）
    * @return
    */
   public static boolean setMapKeyExpire(String key,String mapKey,Object value, int seconds){
       Jedis jedis = null;
       try {
           jedis = getJedis();
           if (jedis != null) {
               if (value instanceof String) {
                   jedis.hset(key, mapKey, String.valueOf(value));
               } else if (value instanceof List) {
                   jedis.hset(key, mapKey, JSONArray.fromObject(value).toString());
               } else {
                   jedis.hset(key, mapKey, JSONObject.fromObject(value).toString());
               }
               jedis.expire(key, seconds);
               return true;
           } else {
               return false;
           }
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   @SuppressWarnings("unchecked")
   public static  Map getMap(String key){
       ShardedJedis jedis = null;
       try {
           jedis = getShardedJedis();
           if (jedis != null) {
               Map map = (Map) jedis.hgetAll(key);
               return map;
           } else {
               return null;
           }
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       } finally {
           returnResource(jedis);
       }
   }
   
   @SuppressWarnings("unchecked")
   public static  Map getMapEntityClass(String key,Class clazz){
       ShardedJedis jedis = null;
       try {
           jedis = getShardedJedis();
           if (jedis != null) {
               Map map = (Map) jedis.hgetAll(key);
               Set> entry = map.entrySet();
               for (Iterator> ite = entry.iterator(); ite.hasNext();) {
                   Map.Entry kv = ite.next();
                   map.put(kv.getKey(), (V) JSONObject.toBean(JSONObject.fromObject(kv.getValue()), clazz));
               }
               return map;
           } else {
               return null;
           }
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       } finally {
           returnResource(jedis);
       }
   }
   
   @SuppressWarnings("unchecked")
   public static  Map> getMapList(String key,Class clazz){
       ShardedJedis jedis = null;
       try {
           jedis = getShardedJedis();
           if (jedis != null) {
               Map map = (Map) jedis.hgetAll(key);
               Set> entry = map.entrySet();
               for (Iterator> ite = entry.iterator(); ite.hasNext();) {
                   Map.Entry kv = ite.next();
                   JSONArray jsonArray = JSONArray.fromObject(kv.getValue());
                   map.put(kv.getKey(), (V) JSONArray.toCollection(jsonArray, clazz));
               }
               return (Map>) map;
           } else {
               return null;
           }
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       } finally {
           returnResource(jedis);
       }
   }
   
   @SuppressWarnings("unchecked")
   public static  List getMapKeyListEntity(String key,String mapKey,
           Class entityClass){
       ShardedJedis jedis = null;
       try {
           jedis = getShardedJedis();
           if (jedis != null) {
               String valueJson = jedis.hget(key, mapKey);
               JSONArray jsonArray = JSONArray.fromObject(valueJson);
               return (List) JSONArray.toCollection(jsonArray, entityClass);
           } else {
               return null;
           }
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       } finally {
           returnResource(jedis);
       }
   }
   
   @SuppressWarnings("unchecked")
   public static  T getMapKeyEntity(String key,String mapKey,
           Class entityClass){
       ShardedJedis jedis = null;
       try {
           jedis = getShardedJedis();
           if(jedis != null){
           String valueJson=jedis.hget(key, mapKey);
           return (T) JSONObject.toBean(JSONObject.fromObject(valueJson), entityClass);
           }else{return null;}
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       } finally {
           returnResource(jedis);
       }
   }
   
   public static Object getMapKey(String key,String mapKey){
       ShardedJedis jedis = null;
       try {
           jedis = getShardedJedis();
           if(jedis != null){
           return jedis.hget(key, mapKey);
           }else{return null;}
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       } finally {
           returnResource(jedis);
       }
   }
   
   public static boolean delMapKey(String key,String mapKey){
       Jedis jedis = null;
       try {
           jedis = getJedis();
           jedis.hdel(key, mapKey);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   public static boolean hexists(String key,String mapKey){
       ShardedJedis jedis = null;
       try {
           jedis = shardedJedisPool.getResource();
           return jedis.hexists(key,mapKey);
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           shardedJedisPool.returnResource(jedis);
       }
   }
   //*************** 操作map****************end
   
   //***************计数器应用INCR,DECR****************begin
   //Redis的命令都是原子性的，你可以轻松地利用INCR，DECR命令来构建计数器系统
   
   /**
    * incr(key)：名称为key的string增1操作
    */
   public static boolean incr(String key){
       Jedis jedis = null;
       try {
           jedis = getJedis();
           jedis.incr(key);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   /**
    * incrby(key, integer)：名称为key的string增加integer
    */
   public static boolean incrBy(String key, int value){
       Jedis jedis = null;
       try {
           jedis = getJedis();
           jedis.incrBy(key, value);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   /**
    * decr(key)：名称为key的string减1操作
    */
   public static boolean decr(String key){
       Jedis jedis = null;
       try {
           jedis = getJedis();
           jedis.decr(key);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   /**
    * decrby(key, integer)：名称为key的string减少integer
    */
   public static boolean decrBy(String key, int value){
       Jedis jedis = null;
       try {
           jedis = getJedis();
           jedis.decrBy(key, value);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   //***************计数器应用INCR,DECR****************end
   
   //***************使用sorted set(zset)甚至可以构建有优先级的队列系统***************begin
   /**
    * 向名称为key的zset中添加元素member，score用于排序。
    * 如果该元素已经存在，则根据score更新该元素的顺序
    */
   public static boolean zadd(String key, double score, String member){
       Jedis jedis = null;
       try {
           jedis = getJedis();
           jedis.zadd(key, score, member);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   /**
    * 删除名称为key的zset中的元素member
    */
   public static boolean zrem(String key, String... members){
       Jedis jedis = null;
       try {
           jedis = getJedis();
           jedis.zrem(key, members);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   /**
    * 返回集合中score在给定区间的元素
    */
   public static Set zrangeByScore(String key, double min, double max){
       ShardedJedis jedis = null;
       try {
           jedis = shardedJedisPool.getResource();
           return jedis.zrangeByScore(key, min, max);
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       } finally {
           returnResource(jedis);
       }
   }
   //***************使用sorted set(zset)甚至可以构建有优先级的队列系统***************end
   
   //***************sorted set 处理***************************************begin
   //zset 处理
   public static boolean zaddObject(String key, double score, Object value){
       Jedis jedis = null;
       try {
           jedis = getJedis();
           String objectJson = JSONObject.fromObject(value).toString();
           jedis.zadd(key, score, objectJson);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   /**
    * score值递减(从大到小)次序排列。
    * @param key
    * @param max score
    * @param min score
    * @param entityClass
    * @return
    */
   @SuppressWarnings("unchecked")
   public static   List zrevrangeByScore(String key,double max,double min, 
           Class entityClass){
       ShardedJedis jedis = null;
       try {
           jedis =shardedJedisPool.getResource();
           Set set=jedis.zrevrangeByScore(key, max, min);
           List list=new ArrayList();
           for (String str : set) {  
               list.add((T) JSONObject.toBean(JSONObject.fromObject(str), entityClass));
           } 
           return list;
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       } finally {
           returnResource(jedis);
       }
   }
   
   /**
    * score值递减(从大到小)次序排列。
    * @param key
    * @param max score
    * @param min score
    * @param offset count (类似mysql的 LIMIT)
    * @param entityClass
    * @return
    */
   @SuppressWarnings("unchecked")
   public static   List zrevrangeByScore(String key,double max,double min,
           int offset, int count,Class entityClass){
       ShardedJedis jedis = null;
       try {
           jedis =shardedJedisPool.getResource();
           Set set=jedis.zrevrangeByScore(key, max, min,offset,count);
           List list=new ArrayList();
           for (String str : set) {  
               list.add((T) JSONObject.toBean(JSONObject.fromObject(str), entityClass));
           } 
           return list;
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       } finally {
           returnResource(jedis);
       }
   }
   
   
   //得到总记录数
   public static long zcard(String key){
       ShardedJedis jedis = null;
       try {
           jedis =shardedJedisPool.getResource();
           return jedis.zcard(key);
       } catch (Exception e) {
           e.printStackTrace();
           return 0;
       } finally {
           returnResource(jedis);
       }
   }
   
   //删除 元素
   public static  boolean zremObject(String key, Object value){
       Jedis jedis = null;
       try {
           jedis = getJedis();
           String objectJson = JSONObject.fromObject(value).toString();
           jedis.zrem(key, objectJson);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }
   
   //统计zset集合中score某个范围内（1-5），元素的个数
   public static long zcount(String key,double min, double max){
       ShardedJedis jedis = null;
       try {
           jedis =shardedJedisPool.getResource();
           return jedis.zcount(key,min,max);
       } catch (Exception e) {
           e.printStackTrace();
           return 0;
       } finally {
           returnResource(jedis);
       }
   }
   
   //查看zset集合中元素的score
   public static double zscore(String key,Object value){
       ShardedJedis jedis = null;
       try {
           jedis =shardedJedisPool.getResource();
           String objectJson = JSONObject.fromObject(value).toString();
           return jedis.zscore(key,objectJson);
       } catch (Exception e) {
           e.printStackTrace();
           return 0;
       } finally {
           returnResource(jedis);
       }
   }
   //**************sorted set******************************************end
   
   //***********************Redis Set集合操作**************************begin
   /**
    * sadd:向名称为Key的set中添加元素,同一集合中不能出现相同的元素值。（用法：sadd set集合名称 元素值）
    * @param key
    * @param value
    * @return
    */
   public static boolean sadd(String key, String value) {
       Jedis jedis = null;
       try {
           jedis = getJedis();
           jedis.sadd(key, value);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }

   /**
    * srem:删除名称为key的set中的元素。（用法：srem set集合名称 要删除的元素值）
    * 
    * @param key
    * @param value
    * @return
    */
   public static boolean srem(String key, String value) {
       Jedis jedis = null;
       try {
           jedis = getJedis();
           jedis.srem(key, value);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }

   /**
    * sdiff:返回所有给定key与第一个key的差集。（用法：sdiff set集合1 set集合2）
    * 
    * @param key1
    * @param key2
    * @return
    */
   public static Set sdiff(String key1, String key2) {
       Jedis jedis = null;
       Set diffList = null;
       try {
           jedis = getJedis();
           diffList = jedis.sdiff(key1, key2);
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           returnResource(jedis);
       }
       return diffList;
   }

   /**
    * sismember:判断某个值是否是集合的元素。（用法：sismember 集合1 指定的元素值）
    * 
    * @param key
    * @param value
    * @return
    */
   public static boolean sismember(String key, String value) {
       ShardedJedis jedis = null;
       try {
           jedis = shardedJedisPool.getResource();
           return jedis.sismember(key, value);
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       } finally {
           returnResource(jedis);
       }
   }

   /**
    * smembers(key) ：返回名称为key的set的所有元素
    * 
    * @param key
    * @return
    */
   public static Set smembers(String key) {
       Jedis jedis = null;
       Set list = null;
       try {
           jedis = getJedis();
           list = jedis.smembers(key);
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           returnResource(jedis);
       }
       return list;
   }
   
   //***********************Redis Set集合操作****************************end
}

你可能感兴趣的:(RedisPool操作Redis，工具类实例)

  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • git常用命令笔记 咩酱-小羊 git笔记
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
  • 将cmd中命令输出保存为txt文本文件 落难Coder Windowscmdwindow
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • 关于城市旅游的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：做与用户的交互行为文章目录前端学习路线
  • MongoDB Oplog 窗口 喝醉酒的小白 MongoDB运维
    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • 【PG】常见数据库、表属性设置 江无羡 数据库
    PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python开发语言
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
  • EIO国际确定性的交易（3/10）资管 ， 资金委托安全吗？ 古城鹏哥
    大家可能都知道资金托管，账户是自己开，钱在自己的账户上，密码是由自己掌控，别人提不走你账户的资金，每天可以看下到自己的账户，也可以看到交易流水。现金只能提到自己的银行卡中。账户由技术人员或操作人员，或者是机构团队帮你操作账户，产生盈利和收入，以获得的利润来分配盈利，技术强硬和做的时间久了过硬技术团队，会保证你的资金本金，不会让你的本金亏损的按照一定比例分配收入。所以在这个过程当中一定要看清楚技术的
  • ES聚合分析原理与代码实例讲解 光剑书架上的书 大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
  • Shell、Bash、Zsh这都是啥啊 小白码上飞 bashlinux开发语言
    Zsh和Bash都是我们常用的Shell，那先搞明白啥是shell吧。Shell作为一个单词，他是“壳”的意思，蛋壳坚果壳。之所以叫壳，是为了和计算机的“核”来区分，用它表示“为使用者提供的操作界面”。所以这个命名其实很形象，翻译成中文，直译过来叫“壳层”。个人认为这个叫法很奇怪，意译貌似也没有什么好的词汇来匹配。就还是叫shell吧。维基百科给的定义是：Incomputing,ashellisa
  • ios GCD _Waiting_
    1.GCD任务和队列学习GCD之前，先来了解GCD中两个核心概念：任务和队列。任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等
  • 关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解 秋刀prince mysqlmysql数据库
    提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
  • 一文掌握python面向对象魔术方法（二） 程序员neil pythonpython开发语言
    接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
  • 一文掌握python常用的list（列表）操作 程序员neil pythonpython开发语言
    目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • 【从浅识到熟知Linux】Linux发展史 Jammingpro 从浅学到熟知Linuxlinux运维服务器
    归属专栏：从浅学到熟知Linux个人主页：Jammingpro每日努力一点点，技术变化看得见文章前言：本篇文章记录Linux发展的历史，因在介绍Linux过程中涉及的其他操作系统及人物，本文对相关内容也有所介绍。文章目录Unix发展史Linux发展史开源Linux官网企业应用情况发行版本在学习Linux前，我们可能都会问Linux从哪里来？它是如何发展的。但在介绍Linux之前，需要先介绍一下Un
  • linux 发展史 种树的猴子 内核java操作系统linux大数据
    linux发展史说明此前对linux认识模糊一知半解，近期通过学习将自己对于linux的发展总结一下方便大家日后的学习。那Linux是目前一款非常火热的开源操作系统，可是linux是什么时候出现的，又是因为什么样的原因被开发出来的呢。以下将对linux的发展历程进行详细的讲解。目录一、Linux发展背景二、UINIX的诞生三、UNIX的重要分支-BSD的诞生四、Minix的诞生五、GNU与Free
  • 用Python实现读取统计单词个数 程序媛了了 python游戏java
    完整实例代码：fromcollectionsimportCounterdefpythonit():danci={}withopen("pythonit.txt","r",encoding="utf-8")asf:foriinf:words=i.strip().split()forwordinwords:ifwordnotindanci:danci[word]=1else:danci[word]+=
  • 2024.9.6 Python，华为笔试题总结，字符串格式化，字符串操作，广度优先搜索解决公司组织绩效互评问题，无向图 RaidenQ python华为leetcode算法力扣广度优先无向图
    1.字符串格式化name="Alice"age=30formatted_string="Name:{},Age:{}".format(name,age)print(formatted_string)或者name="Alice"age=30formatted_string=f"Name:{name},Age:{age}"print(formatted_string)2.网络健康检查第一行有两个整数m
  • java工厂模式 3213213333332132 java抽象工厂
    工厂模式有 1、工厂方法 2、抽象工厂方法。 下面我的实现是抽象工厂方法, 给所有具体的产品类定一个通用的接口。 package 工厂模式; /** * 航天飞行接口 * * @Description * @author FuJianyong * 2015-7-14下午02:42:05 */ public interface SpaceF
  • nginx频率限制+python测试 ronin47 nginx 频率 python
           部分内容参考：http://www.abc3210.com/2013/web_04/82.shtml 首先说一下遇到这个问题是因为网站被攻击，阿里云报警，想到要限制一下访问频率，而不是限制ip（限制ip的方案稍后给出）。nginx连接资源被吃空返回状态码是502，添加本方案限制后返回599，与正常状态码区别开。步骤如下：
  • java线程和线程池的使用 dyy_gusi ThreadPoolthreadRunnabletimer
    java线程和线程池 一、创建多线程的方式     java多线程很常见，如何使用多线程，如何创建线程，java中有两种方式，第一种是让自己的类实现Runnable接口，第二种是让自己的类继承Thread类。其实Thread类自己也是实现了Runnable接口。具体使用实例如下： 1、通过实现Runnable接口方式 1 2
  • Linux 171815164 linux
    ubuntu kernel http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.1.2-unstable/ 安卓sdk代理 mirrors.neusoft.edu.cn        80 输入法和jdk sudo apt-get install fcitx su
  • Tomcat JDBC Connection Pool g21121 Connection
           Tomcat7 抛弃了以往的DBCP 采用了新的Tomcat Jdbc Pool 作为数据库连接组件，事实上DBCP已经被Hibernate 所抛弃，因为他存在很多问题，诸如：更新缓慢，bug较多，编译问题，代码复杂等等。        Tomcat Jdbc P
  • 敲代码的一点想法 永夜-极光 java随笔感想
                  入门学习java编程已经半年了,一路敲代码下来,现在也才1w+行代码量,也就菜鸟水准吧,但是在整个学习过程中,我一直在想,为什么很多培训老师,网上的文章都是要我们背一些代码?比如学习Arraylist的时候,教师就让我们先参考源代码写一遍,然
  • jvm指令集 程序员是怎么炼成的 jvm 指令集
    转自：http://blog.csdn.net/hudashi/article/details/7062675#comments       将值推送至栈顶时 const ldc  push   load指令 const系列 该系列命令主要负责把简单的数值类型送到栈顶。(从常量池或者局部变量push到栈顶时均使用) 0x02 &nbs
  • Oracle字符集的查看查询和Oracle字符集的设置修改 aijuans oracle
    本文主要讨论以下几个部分：如何查看查询oracle字符集、 修改设置字符集以及常见的oracle utf8字符集和oracle exp 字符集问题。 一、什么是Oracle字符集 Oracle字符集是一个字节数据的解释的符号集合,有大小之分,有相互的包容关系。ORACLE 支持国家语言的体系结构允许你使用本地化语言来存储，处理，检索数据。它使数据库工具，错误消息，排序次序，日期，时间，货
  • png在Ie6下透明度处理方法 antonyup_2006 css浏览器FirebugIE
    由于之前到深圳现场支撑上线，当时为了解决个控件下载，我机器上的IE8老报个错，不得以把ie8卸载掉，换个Ie6,问题解决了，今天出差回来，用ie6登入另一个正在开发的系统，遇到了Png图片的问题，当然升级到ie8(ie8自带的开发人员工具调试前端页面JS之类的还是比较方便的，和FireBug一样，呵呵)，这个问题就解决了，但稍微做了下这个问题的处理。 我们知道PNG是图像文件存储格式，查询资
  • 表查询常用命令高级查询方法(二) 百合不是茶 oracle分页查询分组查询联合查询
    ----------------------------------------------------分组查询 group by    having   --平均工资和最高工资   select avg(sal)平均工资,max(sal)  from emp ;  --每个部门的平均工资和最高工资
  • uploadify3.1版本参数使用详解 bijian1013 JavaScriptuploadify3.1
    使用：     绑定的界面元素<input id='gallery'type='file'/>$("#gallery").uploadify({设置参数，参数如下}); 设置的属性： id: jQuery(this).attr('id'),//绑定的input的ID langFile: 'http://ww
  • 精通Oracle10编程SQL(17)使用ORACLE系统包 bijian1013 oracle数据库plsql
    /* *使用ORACLE系统包 */ --1.DBMS_OUTPUT --ENABLE:用于激活过程PUT,PUT_LINE,NEW_LINE,GET_LINE和GET_LINES的调用 --语法：DBMS_OUTPUT.enable(buffer_size in integer default 20000); --DISABLE:用于禁止对过程PUT,PUT_LINE,NEW
  • 【JVM一】JVM垃圾回收日志 bit1129 垃圾回收
    将JVM垃圾回收的日志记录下来，对于分析垃圾回收的运行状态，进而调整内存分配(年轻代，老年代，永久代的内存分配)等是很有意义的。JVM与垃圾回收日志相关的参数包括： -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -Xloggc -XX:+PrintGC 通
  • Toast使用 白糖_ toast
    Android中的Toast是一种简易的消息提示框，toast提示框不能被用户点击，toast会根据用户设置的显示时间后自动消失。     创建Toast 两个方法创建Toast makeText(Context context, int resId, int duration)     参数：context是toast显示在
  • angular.identity boyitech AngularJSAngularJS API
    angular.identiy 描述: 返回它第一参数的函数. 此函数多用于函数是编程. 使用方法: angular.identity(value); 参数详解: Param Type Details value * to be returned. 返回值: 传入的value 实例代码: <!DOCTYPE HTML>
  • java-两整数相除，求循环节 bylijinnan java
    import java.util.ArrayList; import java.util.List; public class CircleDigitsInDivision { /** * 题目：求循环节，若整除则返回NULL，否则返回char*指向循环节。先写思路。函数原型：char*get_circle_digits(unsigned k,unsigned j)
  • Java 日期 周 年 Chen.H javaC++cC#
    /** * java日期操作(月末、周末等的日期操作) * * @author * */ public class DateUtil { /** */ /** * 取得某天相加(减)後的那一天 * * @param date * @param num *
  • [高考与专业]欢迎广大高中毕业生加入自动控制与计算机应用专业 comsci 计算机
          不知道现在的高校还设置这个宽口径专业没有,自动控制与计算机应用专业,我就是这个专业毕业的,这个专业的课程非常多,既要学习自动控制方面的课程,也要学习计算机专业的课程,对数学也要求比较高.....如果有这个专业,欢迎大家报考...毕业出来之后,就业的途径非常广.....      以后
  • 分层查询（Hierarchical Queries） daizj oracle递归查询层次查询
    Hierarchical Queries If a table contains hierarchical data, then you can select rows in a hierarchical order using the hierarchical query clause: hierarchical_query_clause::= start with condi
  • 数据迁移 daysinsun 数据迁移
    最近公司在重构一个医疗系统，原来的系统是两个.Net系统，现需要重构到java中。数据库分别为SQL Server和Mysql，现需要将数据库统一为Hana数据库，发现了几个问题，但最后通过努力都解决了。 1、原本通过Hana的数据迁移工具把数据是可以迁移过去的，在MySQl里面的字段为TEXT类型的到Hana里面就存储不了了，最后不得不更改为clob。 2、在数据插入的时候有些字段特别长
  • C语言学习二进制的表示示例 dcj3sjt126com cbasic
    进制的表示示例 # include <stdio.h> int main(void) { int i = 0x32C; printf("i = %d\n", i); /* printf的用法 %d表示以十进制输出 %x或%X表示以十六进制的输出 %o表示以八进制输出 */ return 0; }
  • NsTimer 和 UITableViewCell 之间的控制 dcj3sjt126com ios
    情况是这样的: 一个UITableView, 每个Cell的内容是我自定义的 viewA viewA上面有很多的动画, 我需要添加NSTimer来做动画, 由于TableView的复用机制, 我添加的动画会不断开启, 没有停止, 动画会执行越来越多.   解决办法: 在配置cell的时候开始动画, 然后在cell结束显示的时候停止动画   查找cell结束显示的代理
  • MySql中case when then 的使用 fanxiaolong casewhenthenend
    select "主键", "项目编号", "项目名称","项目创建时间", "项目状态","部门名称","创建人" union (select pp.id as "主键", pp.project_number as &
  • Ehcache（01）——简介、基本操作 234390216 cacheehcache简介CacheManagercrud
    Ehcache简介 目录 1       CacheManager 1.1      构造方法构建 1.2      静态方法构建 2       Cache 2.1&
  • 最容易懂的javascript闭包学习入门 jackyrong JavaScript
    http://www.ruanyifeng.com/blog/2009/08/learning_javascript_closures.html 闭包（closure）是Javascript语言的一个难点，也是它的特色，很多高级应用都要依靠闭包实现。 下面就是我的学习笔记，对于Javascript初学者应该是很有用的。 一、变量的作用域 要理解闭包，首先必须理解Javascript特殊
  • 提升网站转化率的四步优化方案 php教程分享 数据结构PHP数据挖掘Google活动
    网站开发完成后,我们在进行网站优化最关键的问题就是如何提高整体的转化率，这也是营销策略里最最重要的方面之一，并且也是网站综合运营实例的结果。文中分享了四大优化策略：调查、研究、优化、评估，这四大策略可以很好地帮助用户设计出高效的优化方案。 PHP开发的网站优化一个网站最关键和棘手的是，如何提高整体的转化率，这是任何营销策略里最重要的方面之一，而提升网站转化率是网站综合运营实力的结果。今天，我就分
  • web开发里什么是HTML5的WebSocket？ naruto1990 Webhtml5浏览器socket
    当前火起来的HTML5语言里面，很多学者们都还没有完全了解这语言的效果情况，我最喜欢的Web开发技术就是正迅速变得流行的 WebSocket API。WebSocket 提供了一个受欢迎的技术，以替代我们过去几年一直在用的Ajax技术。这个新的API提供了一个方法，从客户端使用简单的语法有效地推动消息到服务器。让我们看一看6个HTML5教程介绍里 的 WebSocket API：它可用于客户端、服
  • Socket初步编程——简单实现群聊 Everyday都不同 socket网络编程初步认识
    初次接触到socket网络编程，也参考了网络上众前辈的文章。尝试自己也写了一下，记录下过程吧：   服务端：（接收客户端消息并把它们打印出来）   public class SocketServer { private List<Socket> socketList = new ArrayList<Socket>(); public s
  • 面试：Hashtable与HashMap的区别（结合线程） toknowme
    昨天去了某钱公司面试，面试过程中被问道 Hashtable与HashMap的区别？当时就是回答了一点，Hashtable是线程安全的，HashMap是线程不安全的，说白了，就是Hashtable是的同步的，HashMap不是同步的，需要额外的处理一下。   今天就动手写了一个例子，直接看代码吧 package com.learn.lesson001; import java
  • MVC设计模式的总结 xp9802 设计模式mvc框架IOC
    随着Web应用的商业逻辑包含逐渐复杂的公式分析计算、决策支持等，使客户机越 来越不堪重负，因此将系统的商业分离出来。单独形成一部分，这样三层结构产生了。 其中‘层’是逻辑上的划分。 三层体系结构是将整个系统划分为如图2.1所示的结构[3] （1）表现层（Presentation layer）：包含表示代码、用户交互GUI、数据验证。 该层用于向客户端用户提供GUI交互，它允许用户
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他