基于spring的redisTemplate的缓存工具类

1、spring相关配置如下：

     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
     <property name="maxIdle" value="${redis.pool.maxIdle}" />
     <property name="maxTotal" value="${redis.pool.maxTotal}" />
     <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
 bean>


     <bean id="jedisConnFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
         <property name="hostName" value="${redis.host}" />
         <property name="port" value="${redis.port}" />
         <property name="timeout" value="${redis.timeout}" />
         <property name="password" value="${redis.password}" />
         <property name="poolConfig" ref="jedisPoolConfig" />
     bean>

 <bean id="stringRedisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer" />

 <bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate"
     p:connectionFactory-ref="jedisConnFactory" />
 <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
     p:connectionFactory-ref="jedisConnFactory"
     p:keySerializer-ref="stringRedisSerializer"
     p:hashKeySerializer-ref="stringRedisSerializer" />

    <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
        <property name="caches">
            <set>
             <bean class="com.rd.ifaes.common.jedis.RdRedisCache" p:redis-template-ref="redisTemplate" p:name="sysCache"/>
            set>
        property>
    bean>


 <cache:annotation-driven cache-manager="cacheManager" proxy-target-class="true" />

 

2、缓存工具类CacheUtils

 package com.lh.core.core.util;

 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;

 import org.springframework.data.redis.core.BoundHashOperations;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.util.CollectionUtils;

 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONObject;
 import com.rd.ifaes.common.dict.ExpireTime;
 import com.lh.common.util.JsonMapper;
 import com.rd.ifaes.common.util.SpringContextHolder;
 import com.rd.ifaes.common.util.StringUtils;

 /**
  * 通用缓存工具类
  * @author lh
  * @version 3.0
  * @since 2016-6-22
  *
  */
 public class CacheUtils {

     private static StringRedisTemplate stringRedisTemplate = SpringContextHolder.getBean("stringRedisTemplate");
     private static RedisTemplate redisTemplate = SpringContextHolder.getBean("redisTemplate");

     /**
      * 删除缓存
      * 根据key精确匹配删除
      * @param key
      */
     @SuppressWarnings("unchecked")
     public static void del(String... key){
         if(key!=null && key.length > 0){
             if(key.length == 1){
                 redisTemplate.delete(key[0]);
             }else{
                 redisTemplate.delete(CollectionUtils.arrayToList(key));
             }
         }
     }

     /**
      * 批量删除
      * （该操作会执行模糊查询，请尽量不要使用，以免影响性能或误删）
      * @param pattern
      */
     public static void batchDel(String... pattern){
         for (String kp : pattern) {
             redisTemplate.delete(redisTemplate.keys(kp + "*"));
         }
     }

     /**
      * 取得缓存（int型）
      * @param key
      * @return
      */
     public static Integer getInt(String key){
         String value = stringRedisTemplate.boundValueOps(key).get();
         if(StringUtils.isNotBlank(value)){
             return Integer.valueOf(value);
         }
         return null;
     }

     /**
      * 取得缓存（字符串类型）
      * @param key
      * @return
      */
     public static String getStr(String key){
         return stringRedisTemplate.boundValueOps(key).get();
     }

     /**
      * 取得缓存（字符串类型）
      * @param key
      * @return
      */
     public static String getStr(String key, boolean retain){
         String value = stringRedisTemplate.boundValueOps(key).get();
         if(!retain){
             redisTemplate.delete(key);
         }
         return value;
     }

     /**
      * 获取缓存
      * 注：基本数据类型(Character除外)，请直接使用get(String key, Class clazz)取值
      * @param key
      * @return
      */
     public static Object getObj(String key){
         return redisTemplate.boundValueOps(key).get();
     }

     /**
      * 获取缓存
      * 注：java 8种基本类型的数据请直接使用get(String key, Class clazz)取值
      * @param key
      * @param retain    是否保留
      * @return
      */
     public static Object getObj(String key, boolean retain){
         Object obj = redisTemplate.boundValueOps(key).get();
         if(!retain){
             redisTemplate.delete(key);
         }
         return obj;
     }

     /**
      * 获取缓存
      * 注：该方法暂不支持Character数据类型
      * @param key   key
      * @param clazz 类型
      * @return
      */
     @SuppressWarnings("unchecked")
     public static  T get(String key, Class clazz) {
         return (T)redisTemplate.boundValueOps(key).get();
     }

     /**
      * 获取缓存json对象
      * @param key   key
      * @param clazz 类型
      * @return
      */
     public static  T getJson(String key, Class clazz) {
         return JsonMapper.fromJsonString(stringRedisTemplate.boundValueOps(key).get(), clazz);
     }

     /**
      * 将value对象写入缓存
      * @param key
      * @param value
      * @param time 失效时间(秒)
      */
     public static void set(String key,Object value,ExpireTime time){
         if(value.getClass().equals(String.class)){
             stringRedisTemplate.opsForValue().set(key, value.toString());
         }else if(value.getClass().equals(Integer.class)){
             stringRedisTemplate.opsForValue().set(key, value.toString());
         }else if(value.getClass().equals(Double.class)){
             stringRedisTemplate.opsForValue().set(key, value.toString());
         }else if(value.getClass().equals(Float.class)){
             stringRedisTemplate.opsForValue().set(key, value.toString());
         }else if(value.getClass().equals(Short.class)){
             stringRedisTemplate.opsForValue().set(key, value.toString());
         }else if(value.getClass().equals(Long.class)){
             stringRedisTemplate.opsForValue().set(key, value.toString());
         }else if(value.getClass().equals(Boolean.class)){
             stringRedisTemplate.opsForValue().set(key, value.toString());
         }else{
             redisTemplate.opsForValue().set(key, value);
         }
         if(time.getTime() > 0){
             redisTemplate.expire(key, time.getTime(), TimeUnit.SECONDS);
         }
     }

     /**
      * 将value对象以JSON格式写入缓存
      * @param key
      * @param value
      * @param time 失效时间(秒)
      */
     public static void setJson(String key,Object value,ExpireTime time){
         stringRedisTemplate.opsForValue().set(key, JsonMapper.toJsonString(value));
         if(time.getTime() > 0){
             stringRedisTemplate.expire(key, time.getTime(), TimeUnit.SECONDS);
         }
     }

     /**
      * 更新key对象field的值
      * @param key   缓存key
      * @param field 缓存对象field
      * @param value 缓存对象field值
      */
     public static void setJsonField(String key, String field, String value){
         JSONObject obj = JSON.parseObject(stringRedisTemplate.boundValueOps(key).get());
         obj.put(field, value);
         stringRedisTemplate.opsForValue().set(key, obj.toJSONString());
     }


     /**
      * 递减操作
      * @param key
      * @param by
      * @return
      */
     public static double decr(String key, double by){
         return redisTemplate.opsForValue().increment(key, -by);
     }

     /**
      * 递增操作
      * @param key
      * @param by
      * @return
      */
     public static double incr(String key, double by){
         return redisTemplate.opsForValue().increment(key, by);
     }

     /**
      * 获取double类型值
      * @param key
      * @return
      */
     public static double getDouble(String key) {
         String value = stringRedisTemplate.boundValueOps(key).get();
         if(StringUtils.isNotBlank(value)){
             return Double.valueOf(value);
         }
         return 0d;
     }

     /**
      * 设置double类型值
      * @param key
      * @param value
      * @param time 失效时间(秒)
      */
     public static void setDouble(String key, double value, ExpireTime time) {
         stringRedisTemplate.opsForValue().set(key, String.valueOf(value));
         if(time.getTime() > 0){
             stringRedisTemplate.expire(key, time.getTime(), TimeUnit.SECONDS);
         }
     }

     /**
      * 设置double类型值
      * @param key
      * @param value
      * @param time 失效时间(秒)
      */
     public static void setInt(String key, int value, ExpireTime time) {
         stringRedisTemplate.opsForValue().set(key, String.valueOf(value));
         if(time.getTime() > 0){
             stringRedisTemplate.expire(key, time.getTime(), TimeUnit.SECONDS);
         }
     }

     /**
      * 将map写入缓存
      * @param key
      * @param map
      * @param time 失效时间(秒)
      */
     public static  void setMap(String key, Map map, ExpireTime time){
         redisTemplate.opsForHash().putAll(key, map);
     }

     /**
      * 将map写入缓存
      * @param key
      * @param map
      * @param time 失效时间(秒)
      */
     @SuppressWarnings("unchecked")
     public static  void setMap(String key, T obj, ExpireTime time){
         Map map = (Map)JsonMapper.parseObject(obj, Map.class);
         redisTemplate.opsForHash().putAll(key, map);
     }



     /**
      * 向key对应的map中添加缓存对象
      * @param key
      * @param map
      */
     public static  void addMap(String key, Map map){
         redisTemplate.opsForHash().putAll(key, map);
     }

     /**
      * 向key对应的map中添加缓存对象
      * @param key   cache对象key
      * @param field map对应的key
      * @param value     值
      */
     public static void addMap(String key, String field, String value){
         redisTemplate.opsForHash().put(key, field, value);
     }

     /**
      * 向key对应的map中添加缓存对象
      * @param key   cache对象key
      * @param field map对应的key
      * @param obj   对象
      */
     public static  void addMap(String key, String field, T obj){
         redisTemplate.opsForHash().put(key, field, obj);
     }

     /**
      * 获取map缓存
      * @param key
      * @param clazz
      * @return
      */
     public static  Map mget(String key, Class clazz){
         BoundHashOperations boundHashOperations = redisTemplate.boundHashOps(key);
         return boundHashOperations.entries();
     }

     /**
      * 获取map缓存
      * @param key
      * @param clazz
      * @return
      */
     public static  T getMap(String key, Class clazz){
         BoundHashOperations boundHashOperations = redisTemplate.boundHashOps(key);
         Map map = boundHashOperations.entries();
         return JsonMapper.parseObject(map, clazz);
     }

     /**
      * 获取map缓存中的某个对象
      * @param key
      * @param field
      * @param clazz
      * @return
      */
     @SuppressWarnings("unchecked")
     public static  T getMapField(String key, String field, Class clazz){
         return (T)redisTemplate.boundHashOps(key).get(field);
     }

     /**
      * 删除map中的某个对象
      * @author lh
      * @date 2016年8月10日
      * @param key   map对应的key
      * @param field map中该对象的key
      */
     public void delMapField(String key, String... field){
         BoundHashOperations boundHashOperations = redisTemplate.boundHashOps(key);
         boundHashOperations.delete(field);
     }

     /**
      * 指定缓存的失效时间
      *
      * @author FangJun
      * @date 2016年8月14日
      * @param key 缓存KEY
      * @param time 失效时间(秒)
      */
     public static void expire(String key, ExpireTime time) {
         if(time.getTime() > 0){
             redisTemplate.expire(key, time.getTime(), TimeUnit.SECONDS);
         }
     }

     /**
      * 添加set
      * @param key
      * @param value
      */
     public static void sadd(String key, String... value) {
         redisTemplate.boundSetOps(key).add(value);
     }

     /**
      * 删除set集合中的对象
      * @param key
      * @param value
      */
     public static void srem(String key, String... value) {
         redisTemplate.boundSetOps(key).remove(value);
     }

     /**
      * set重命名
      * @param oldkey
      * @param newkey
      */
     public static void srename(String oldkey, String newkey){
         redisTemplate.boundSetOps(oldkey).rename(newkey);
     }

     /**
      * 短信缓存
      * @author fxl
      * @date 2016年9月11日
      * @param key
      * @param value
      * @param time
      */
     public static void setIntForPhone(String key,Object value,int time){
         stringRedisTemplate.opsForValue().set(key, JsonMapper.toJsonString(value));
         if(time > 0){
             stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
         }
     }

     /**
      * 模糊查询keys
      * @param pattern
      * @return
      */
     public static Set keys(String pattern){
         return redisTemplate.keys(pattern);
     }

 }

 3、JsonMaper

 package com.lh.common.util;

 import java.io.IOException;
 import java.util.TimeZone;

 import org.apache.commons.lang3.StringEscapeUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import com.alibaba.fastjson.JSON;
 import com.fasterxml.jackson.annotation.JsonInclude.Include;
 import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.core.JsonParser.Feature;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.JsonSerializer;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import com.fasterxml.jackson.databind.SerializerProvider;
 import com.fasterxml.jackson.databind.module.SimpleModule;
 import com.fasterxml.jackson.databind.util.JSONPObject;
 import com.fasterxml.jackson.module.jaxb.JaxbAnnotationModule;


 /**
  * 简单封装Jackson，实现JSON String<->Java Object的Mapper.
  *
  */
 public class JsonMapper extends ObjectMapper {

         private static final long serialVersionUID = 1L;

         private final static Logger LOGGER = LoggerFactory.getLogger(JsonMapper.class);

         private static JsonMapper mapper;

         public JsonMapper() {
             this(Include.NON_EMPTY);
         }

         public JsonMapper(Include include) {
             // 设置输出时包含属性的风格
             if (include != null) {
                 this.setSerializationInclusion(include);
             }
             // 设置输入时忽略在JSON字符串中存在但Java对象实际没有的属性
             this.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
             // 空值处理为空串
             this.getSerializerProvider().setNullValueSerializer(new JsonSerializer(){   
                     @Override   
                     public void serialize(Object value, JsonGenerator jgen,   
                             SerializerProvider provider) throws IOException,   
                             JsonProcessingException {   
                         jgen.writeString("");   
                     }   
                 });   
                 // 进行HTML解码。   
                 this.registerModule(new SimpleModule().addSerializer(String.class, new JsonSerializer(){   
                     @Override   
                     public void serialize(String value, JsonGenerator jgen,   
                             SerializerProvider provider) throws IOException,   
                             JsonProcessingException {   
                         jgen.writeString(StringEscapeUtils.unescapeHtml4(value));   
                     }   
                 }));   
                 // 设置时区   
                 this.setTimeZone(TimeZone.getDefault());//getTimeZone("GMT+8:00")   
             }   
        
             /**  
              * 创建只输出非Null且非Empty(如List.isEmpty)的属性到Json字符串的Mapper,建议在外部接口中使用.  
              */   
             public static JsonMapper getInstance() {   
                 if (mapper == null){   
                     mapper = new JsonMapper().enableSimple();   
                 }   
                 return mapper;   
             }   
        
             /**  
              * 创建只输出初始值被改变的属性到Json字符串的Mapper, 最节约的存储方式，建议在内部接口中使用。  
              */   
             public static JsonMapper nonDefaultMapper() {   
                 if (mapper == null){   
                     mapper = new JsonMapper(Include.NON_DEFAULT);   
                 }   
                 return mapper;   
             }   
                
             /**  
              * Object可以是POJO，也可以是Collection或数组。  
              * 如果对象为Null, 返回"null".  
              * 如果集合为空集合, 返回"[]".  
              */   
             public String toJson(Object object) {   
                 try {   
                     return this.writeValueAsString(object);   
                 } catch (IOException e) {   
                     if(LOGGER.isWarnEnabled()){   
                         LOGGER.warn("write to json string error:" + object, e);   
                     }   
                     return null;   
                 }   
             }   
        
             /**  
              * 反序列化POJO或简单Collection如List.  
              *   
              * 如果JSON字符串为Null或"null"字符串, 返回Null.  
              * 如果JSON字符串为"[]", 返回空集合.  
              *   
              * 如需反序列化复杂Collection如List, 请使用fromJson(String,JavaType)  
              * @see #fromJson(String, JavaType)  
              */   
             public  T fromJson(String jsonString, Class clazz) {   
                 if (StringUtils.isEmpty(jsonString)) {   
                     return null;   
                 }   
                 try {   
                     return this.readValue(jsonString, clazz);   
                 } catch (IOException e) {   
                     if(LOGGER.isWarnEnabled()){   
                         LOGGER.warn("parse json string error:" + jsonString, e);   
                     }   
                     return null;   
                 }   
             }   
        
             /**  
              * 反序列化复杂Collection如List, 先使用函數createCollectionType构造类型,然后调用本函数.  
              * @see #createCollectionType(Class, Class...)  
              */   
             @SuppressWarnings("unchecked")   
             public  T fromJson(String jsonString, JavaType javaType) {   
                 if (StringUtils.isEmpty(jsonString)) {   
                     return null;   
                 }   
                 try {   
                     return (T) this.readValue(jsonString, javaType);   
                 } catch (IOException e) {   
                     if(LOGGER.isWarnEnabled()){   
                         LOGGER.warn("parse json string error:" + jsonString, e);   
                     }   
                     return null;   
                 }   
             }   
        
             /**  
              * 構造泛型的Collection Type如:  
              * ArrayList, 则调用constructCollectionType(ArrayList.class,MyBean.class)  
              * HashMap, 则调用(HashMap.class,String.class, MyBean.class)  
              */   
             public JavaType createCollectionType(Class collectionClass, Class... elementClasses) {   
                 return this.getTypeFactory().constructParametricType(collectionClass, elementClasses);   
             }   
        
             /**  
              * 當JSON裡只含有Bean的部分屬性時，更新一個已存在Bean，只覆蓋該部分的屬性.  
              */   
             @SuppressWarnings("unchecked")   
             public  T update(String jsonString, T object) {   
                 try {   
                     return (T) this.readerForUpdating(object).readValue(jsonString);   
                 } catch (JsonProcessingException e) {   
                     if(LOGGER.isWarnEnabled()){   
                         LOGGER.warn("update json string:" + jsonString + " to object:" + object + " error.", e);   
                     }   
                 } catch (IOException e) {   
                     if(LOGGER.isWarnEnabled()){   
                         LOGGER.warn("update json string:" + jsonString + " to object:" + object + " error.", e);   
                     }   
                 }   
                 return null;   
             }   
        
             /**  
              * 輸出JSONP格式數據.  
              */   
             public String toJsonP(String functionName, Object object) {   
                 return toJson(new JSONPObject(functionName, object));   
             }   
        
             /**  
              * 設定是否使用Enum的toString函數來讀寫Enum,  
              * 為False時時使用Enum的name()函數來讀寫Enum, 默認為False.  
              * 注意本函數一定要在Mapper創建後, 所有的讀寫動作之前調用.  
              */   
             public JsonMapper enableEnumUseToString() {   
                 this.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);   
                 this.enable(DeserializationFeature.READ_ENUMS_USING_TO_STRING);   
                 return this;   
             }   
        
             /**  
              * 支持使用Jaxb的Annotation，使得POJO上的annotation不用与Jackson耦合。  
              * 默认会先查找jaxb的annotation，如果找不到再找jackson的。  
              */   
             public JsonMapper enableJaxbAnnotation() {   
                 JaxbAnnotationModule module = new JaxbAnnotationModule();   
                 this.registerModule(module);   
                 return this;   
             }   
        
             /**  
              * 允许单引号  
              * 允许不带引号的字段名称  
              */   
             public JsonMapper enableSimple() {   
                 this.configure(Feature.ALLOW_SINGLE_QUOTES, true);   
                 this.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);   
                 return this;   
             }   
                
             /**  
              * 取出Mapper做进一步的设置或使用其他序列化API.  
              */   
             public ObjectMapper getMapper() {   
                 return this;   
             }   
        
             /**  
              * 对象转换为JSON字符串  
              * @param object  
              * @return  
              */   
             public static String toJsonString(Object object){   
                 return JsonMapper.getInstance().toJson(object);   
             }   
                
             /**  
              * JSON字符串转换为对象  
              * @param jsonString  
              * @param clazz  
              * @return  
              */   
             public static  T fromJsonString(String jsonString, Class clazz){   
                 return JsonMapper.getInstance().fromJson(jsonString, clazz);   
             }   
                
                
             /**  
              * 将obj对象转换成 class类型的对象  
              * @param obj  
              * @param clazz  
              * @return  
              */   
             public static  T parseObject(Object obj, Class clazz){   
                 return JSON.parseObject(JSON.toJSONString(obj), clazz);   
             }   
                
     }   
     地址:http://hbxflihua.iteye.com/blog/2328156 
    
   
  

                            
                        
                    
                    
                    
                    
                    
                    
                
                
                    
                        
                        
                             
                        
                        
                        
                            
                        
                        
                        
                            
                        
                    
                
            
        
    
    
        你可能感兴趣的:(redis&缓存)
        
            
                
                    guava loadingCache代码示例
                        IM 胡鹏飞
Java工具类介绍
                        publicclassTest2{publicstaticvoidmain(String[]args)throwsException{LoadingCachecache=CacheBuilder.newBuilder()//设置并发级别为8，并发级别是指可以同时写缓存的线程数.concurrencyLevel(8)//设置缓存容器的初始容量为10.initialCapacity(10)//设置缓存
                    
                    Guava LoadingCache
                        sqyaa.
java并发编程Java知识jvm缓存guava
                        LoadingCache是GoogleGuava库提供的一个高级缓存实现，它通过自动加载机制简化了缓存使用模式。核心特性自动加载机制当缓存未命中时，自动调用指定的CacheLoader加载数据线程安全：并发请求下，相同key只会加载一次灵活的过期策略支持基于写入时间(expireAfterWrite)和访问时间(expireAfterAccess)的过期可设置最大缓存大小，基于LRU策略淘汰丰富的
                    
                    vue keep-alive标签的运用
                        

                        keep-alive，想必大家都不会很陌生，在一些选项卡中会使用到。其实，它的作用大概就是把组件的数据给缓存起来。比如果我有一个选项卡，标签一，标签二，标签三。现在，我需要实现，当我在标签一的表单中输入内容后，点击标签二，再回到标签一，表单的内容依然存在。如果按以往的做法，不使用keep-alive，那是不能实现的。然而，我们只需要在选项卡的内容最外层包一个keep-alive标签即可。但这儿有一
                    
                    php SPOF
                        贵哥的编程之路(热爱分享 为后来者)
PHP语言经典程序100题php开发语言
                        1.什么是单点故障（SPOF）？单点故障指的是系统中某个组件一旦失效，整个系统或服务就会不可用。常见的单点有：数据库、缓存、Web服务器、负载均衡、网络设备等。2.常见单点故障场景只有一台数据库服务器，宕机后所有业务不可用只有一台Redis缓存，挂掉后缓存全部失效只有一台Web服务器，挂掉后网站无法访问只有一个负载均衡节点，挂掉后流量无法分发只有一条网络链路，断开后所有服务失联3.消除单点故障的主
                    
                    OKHttp3源码分析——学习笔记
                        Sincerity_
源码相关Okhttp源码解析读书笔记httpclientcache
                        文章目录1.HttpClient与HttpUrlConnection的区别2.OKHttp源码分析使用步骤:dispatcher任务调度器,（后面有详细说明）Request请求RealCallAsyncCall3.OKHttp架构分析1.异步请求线程池,Dispather2.连接池清理线程池-ConnectionPool3.缓存整理线程池DisLruCache4.Http2异步事务线程池,http
                    
                    Python技能手册 - 模块module
                        金色牛神
Pythonpythonwindows开发语言
                        系列Python常用技能手册-基础语法Python常用技能手册-模块modulePython常用技能手册-包package目录module模块指什么typing数据类型int整数float浮点数str字符串bool布尔值TypeVar类型变量functools高阶函数工具functools.partial()函数偏置functools.lru_cache()函数缓存sorted排序列表排序元组排序
                    
                    如何发现 Redis 中的 BigKey？
                        sevevty-seven
redisbootstrap数据库
                        如何发现Redis中的BigKey？Redis因其出色的性能，常被用作缓存、消息队列和会话存储。然而，在Redis的使用过程中，BigKey是一个不容忽视的问题。BigKey指的是存储了大量数据或包含大量成员的键。它们不仅会占用大量内存，还可能导致网络延迟、主从同步延迟，甚至在极端情况下引发Redis服务崩溃。因此，有效地发现和处理BigKey对于维护Redis服务的稳定性和性能至关重要。本文将深
                    
                    项目开发日记
                        

                        框架整理学习UIMgr：一、数据结构与算法1.1关键数据结构成员变量类型说明m_CtrlsList当前正在显示的所有UI页面m_CachesList已打开过、但现在不显示的页面（缓存池）1.2算法逻辑查找缓存页面：从m_Caches中倒序查找是否已有对应ePageType页面，找到则重用。页面加载：从资源管理器ResMgr加载prefab并绑定控制器/视图组件。页面关闭：从m_Ctrls移除，添加
                    
                    C#集合：从基础到进阶的全面解析
                        阿蒙Armon
C#继续学习c#windowslinux
                        C#集合：从基础到进阶的全面解析在C#编程中，集合是处理数据集合的核心工具。无论是存储一组对象、实现缓存机制，还是处理复杂的数据结构，都离不开集合的灵活运用。本文将全面深入地探讨C#集合体系，从基础概念到高级技巧，帮助开发者掌握集合的精髓，写出更高效、更优雅的代码。一、集合概述与分类C#集合框架是.NET类库的重要组成部分，它提供了一系列用于存储和操作数据的类和接口。与数组相比，集合具有动态扩容、
                    
                    Redis简介之它是啥
                        财神爷首席大弟子
Redisredis数据库缓存
                        什么是RedisRedis是一个基于BSD协议的开源数据库,是一个以键值对形式的存储系统Redis常用于消息队列,缓存,会话存储等场景Redis是使用C语言编写使用许可证：BSD许可证是一个开源的宽松的软件许可协议Redis优点性能极高Redis是以高性能著称,可全天24小时达到每秒十万次的读写操作数据类型丰富哈希字符串集合列表有序集合原子性操作原子性操作是指,程序要么不执行,要嘛执行完毕,这种对
                    
                    短剧小程序开发全攻略：从0到1打造爆款内容平台
                        weixin_lynhgworld
小程序短剧
                        核心内容：行业趋势分析：短剧市场年增长率超300%，用户规模突破5亿，抖音、快手等平台加速布局。小程序成为短剧分发核心渠道：轻量化、低成本、社交裂变优势显著。开发核心功能模块：内容管理：支持多格式上传、分集管理、标签分类。播放体验优化：弹幕互动、倍速播放、清晰度切换、离线缓存。付费系统：单集付费、会员订阅、广告解锁等多元化盈利模式。社交裂变：分享奖励、邀请排行榜、拼团观影功能。技术实现难点：视频流
                    
                    【鸿蒙实战开发】HarmoneyOS如何添加首选项功能
                        「已注销」
鸿蒙安卓前端harmonyosjava华为android鸿蒙前端
                        什么是用户首选项？用户首选项为应用提供Key-Value键值型的数据处理能力，支持应用持久化轻量级数据，并对其修改和查询。当用户希望有一个全局唯一存储的地方，可以采用用户首选项来进行存储。Preferences会将该数据缓存在内存中，当用户读取的时候，能够快速从内存中获取数据，当需要持久化时可以使用flush接口将内存中的数据写入持久化文件中。用户首选项运作机制用户首选项的使用场景Preferen
                    
                    Spring Boot使用Redis常用场景
                        蹦跑的蜗牛
springbootredis后端
                        SpringBoot使用Redis常用场景一、概述：Redis是什么？为什么要用它？Redis（RemoteDictionaryServer）是一个内存中的数据存储系统（类似一个“超级大字典”），它能存各种类型的数据（字符串、列表、哈希等），而且读写速度极快（因为数据存在内存里）。简单说，Redis就像电脑的“缓存抽屉”：当你的程序需要频繁读取或修改某些数据时（比如用户登录信息、商品销量），直接从
                    
                    云原生技术与应用-Docker高级管理--Dockerfile镜像制作
                        慕桉 ~
云原生docker容器
                        目录一.Docker镜像管理1.Docker镜像结构2.Dockerfile介绍二.Dockerfile实施1.构建nginx容器2.构建Tomcat容器3.构建mysql容器三.Dockerfile语法注意事项1.指令书写范围2.基础镜像选择3.文件操作注意4.执行命令要点5.环境变量和参数设置6.缓存利用与清理一.Docker镜像管理Docker镜像除了是Docker的核心技术之外，也是应用发
                    
                    Android OkHttp使用与底层机制详解
                        你过来啊你
androidokhttp
                        OkHttp是Square公司开发的一个高效、功能强大的HTTP客户端库，因其简洁的API、灵活的拦截器链、内置连接池、透明GZIP压缩、响应缓存以及对HTTP/2和WebSocket的支持，已成为Android和Java应用开发中事实上的标准网络库。一、OkHttp的核心使用1.基本请求流程//1.创建OkHttpClient实例(通常全局共享一个实例)OkHttpClientclient=ne
                    
                    Redis 性能优化实战：管道、事务、缓存与连接管理全解析
                        佑瞻
数据库与知识图谱缓存redis性能优化
                        在日常开发中，我们常常会遇到Redis操作的性能瓶颈：频繁的命令交互导致网络开销激增，并发更新时的数据一致性难以保证，海量数据遍历引发的阻塞问题……其实，Redis早已为这些场景准备了“利器”。今天我们就深入探讨Redis的管道、事务、扫描迭代、客户端缓存以及连接管理技巧，用实战代码带你玩转性能优化。一、管道（Pipelines）：批量执行命令，减少网络往返当我们需要连续执行多个Redis命令时，
                    
                    九、MyBatis的缓存
                        ModelBulider
#mybatismybatis后端开发语言
                        文章目录1.MyBatis的一级缓存2.MyBatis的二级缓存3.二级缓存的相关配置4.MyBatis缓存查询的顺序5.整合第三方缓存EHCache（了解）1.MyBatis的一级缓存一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问使一级缓存失效的四种情况：不同的SqlSession对应不同的一
                    
                    docker-基于dockerfile自动构建镜像
                        liux3528
dockerdockerlinux运维
                        Dockerfile是自动化构建Docker镜像的配置文件，相比手动构建具有显著优势：更小的存储空间和带宽占用、高效的缓存利用、便捷的修改流程。其核心指令包括FROM（基础镜像）、RUN（执行命令）、COPY/ADD（文件复制）、ENV（环境变量）等，通过分层技术实现高效构建。实践案例展示了如何构建Nginx游戏镜像，包括多阶段构建技巧（分离编译和运行环境），显著减小镜像体积。通过编写Docker
                    
                    学会Python缓存妙用，你的程序更出色更快速！
                        码农必胜客
Pythonpython缓存装饰器模块
                        前言在Python应用程序中，使用缓存能够显著提高性能并降低资源消耗。本文将详细介绍如何在Python中实现缓存机制，包括内置functools模块提供的lru_cache装饰器以及自定义缓存机制。使用functools模块的lru_cachefunctools模块提供了lru_cache装饰器，可以轻松添加缓存到函数中。fromfunctoolsimportlru_cache@lru_cache
                    
                    Python性能加速器：掌握functools.lru_cache装饰器
                        清水白石008
Python题库python论文python开发语言
                        Python性能加速器：掌握functools.lru_cache装饰器一、引言在Python中，很多函数会根据输入参数计算出相应的结果。对于某些计算密集型或I/O密集型的函数，如果它们的输入参数在多次调用中保持不变或变化不大，那么每次调用都重新计算结果将是非常低效的。functools.lru_cache装饰器正是为了解决这一问题而设计的，它能够自动缓存函数的返回值，当再次以相同的参数调用函数时
                    
                    Linux-DNS域名解析服务
                        

                        系列文章目录`提示：仅用于个人学习，进行查漏补缺使用。1.Linux网络设置2.LinuxDHCP服务提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录系列文章目录前言`提示：以下是本篇文章正文内容，下面案例可供参考`一.概述二.DNS的定义三.域名结构四、DNS域名解析方式五.DNS域名解析的流程：六.Linux中的DNS配置：_DNS缓存：_七.DNS查找顺序八.DNS服
                    
                    Python深度解析：functools.lru_cache装饰器
                        

                        引言在Python中，functools.lru_cache是一个强大的装饰器，用于缓存函数的调用结果。本文将深入探讨lru_cache的用法、使用场景、解决的问题、高级用法和选项、性能，以及一些注意事项。1.介绍1.1什么是functools.lru_cache？functools.lru_cache是Python标准库中的一个装饰器，用于添加缓存功能。LRU代表最近最少使用，这意味着该缓存会保
                    
                    深入Redis：核心的缓存
                        

                        Redis最主要的用途，主要有三个方面：存储数据、缓存、消息队列。其中，缓存是Redis最常用的场景。Redis使用内存作为硬盘的缓存。把用户集中访问的20%数据放到缓存中去，可以应对80%的请求。数据库是非常重要的组件，但是mysql的速度又比较慢，所以我们用Redis来作为mysql的缓存。为什么说关系型数据库性能不高?数据库把数据存储在硬盘上，硬盘的IO速度并不快。尤其是随机访问。如果查询不
                    
                    Python进阶｜实现缓存
                        

                        在Python编程中，缓存是一种用于存储计算结果的机制，以便在需要相同结果时能够快速访问，而无需重新进行计算。缓存可以显著提高程序的性能，特别是在处理昂贵或耗时的操作时。以下是几种在Python中实现缓存的方法：1.使用简单的字典作为缓存这是最基本的缓存实现方式。你可以使用一个字典来存储已经计算过的结果，其中键是输入参数（通常是可哈希的），值是计算结果。python复制代码cache={}defe
                    
                    掌握 Spring Data Redis，提升后端开发效率
                        

                        掌握SpringDataRedis，提升后端开发效率关键词：SpringDataRedis、后端开发、缓存、数据持久化、效率提升摘要：本文旨在深入探讨SpringDataRedis这一强大的工具，帮助后端开发者更好地掌握它以提升开发效率。首先介绍SpringDataRedis的背景知识，包括其目的、适用读者等。接着详细阐述核心概念与联系，分析核心算法原理并给出具体操作步骤，通过数学模型和公式加深理
                    
                    Redis核心用法与通用命令全解析
                        Pota-to成长日记
Redisredis数据库缓存
                        Redis核心用法与通用命令全解析——从基础操作到高效实践一、Redis基础知识速览Redis是一款高性能的键值存储系统，支持String、Hash、List、Set、SortedSet五种核心数据结构，以及Bitmaps、HyperLogLog、Streams等扩展类型。其单线程模型和内存存储特性使其在缓存、计数器、消息队列等场景中表现出色。二、核心命令详解（附实用示例）1.通用键操作命令（1）
                    
                    Python-FAQ-单例模式
                        

                        1需求2接口3示例4参考资料单例模式（SingletonPattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。在Python中，实现单例模式有多种方式，下面介绍几种常见的实现方法及其优缺点。1.使用模块（Pythonic方式）Python的模块天然就是单例的，因为模块在第一次导入时会被创建并缓存，后续导入会直接使用缓存的实例。实现示例：#singleto
                    
                    【线上故障排查】缓存穿透攻击的识别与布隆过滤器（面试题 + 3 步追问应对 + 案例分析）
                        程序员岳彬
从项目到面试：Java高频面试题场景化通关指南缓存java后端springbootlinuxredis
                        一、高频面试题问题1：什么是缓存穿透？它对系统的核心危害是什么？参考答案：缓存穿透指的是用户请求的数据在缓存和数据库中都不存在，导致请求直接绕过缓存打到数据库。核心危害是大量无效请求会耗尽数据库资源，比如CPU、内存或连接数，严重时可能引发数据库宕机，进而导致整个系统崩溃，影响服务可用性。第一步追问：缓存穿透和缓存雪崩有什么本质区别？参考答案：两者本质不同。缓存穿透是请求不存在的数据，攻击或逻辑漏
                    
                    Redis 分布式锁实现与实践
                        佑瞻
数据库与知识图谱redis分布式数据库
                        在分布式系统架构中，多个独立进程对共享资源的并发访问控制是常见需求，分布式锁作为解决这一问题的关键技术，在缓存更新、任务调度、库存管理等场景中发挥着重要作用。本文将从基础原理出发，详细阐述基于Redis的分布式锁实现方案，包括单实例模式与Redlock算法，并探讨其在实际应用中的关键考量。分布式锁核心概念分布式锁是一种跨进程、跨机器的同步机制，用于保证多个分布式节点对共享资源的互斥访问。一个可靠的
                    
                    布隆过滤器详解及使用：解决缓存穿透问题
                        豪宇刘
缓存哈希算法散列表
                        在现代应用开发中，缓存技术被广泛应用于提升系统性能和响应速度。然而，缓存系统也带来了一些新的挑战，如缓存穿透、缓存击穿和缓存雪崩等问题。一、什么是布隆过滤器？布隆过滤器是一种空间效率很高的概率型数据结构，用于判断一个元素是否在一个集合中。它的优点是高效且占用内存少，但有一定的误判率（即可能会错误地认为某个不在集合中的元素存在于集合中），不过它不会漏报（即如果一个元素确实不在集合中，布隆过滤器一定能
                    
                                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其他
        
    


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