基于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&缓存)
        
            
                
                    Android应用性能优化
                        轻口味
Android
                        Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
                    
                    华为云分布式缓存服务DCS 8月新特性发布
                        华为云PaaS服务小智
华为云分布式缓存
                        分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
                    
                    Redis:缓存击穿
                        我的程序快快跑啊
缓存redisjava
                        缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
                    
                    L1 L2 L3 缓存
                        京天不下雨
windows缓存windows
                        L1L2L3缓存L1Cache(一级bai缓存)是CPU第一层高速缓存，分为数据缓存和指令缓存。du内置的zhiL1高速缓存的容量和结构对daoCPU的性能影响较大，不过高速缓冲存储器均由静态RAM组成，结构较复杂，在CPU管芯面积不能太大的情况下，L1级高速缓存的容量不可能做得太大。一般服务器CPU的L1缓存的容量通常在32—4096KB。L2由于L1级高速缓存容量的限制，为了再次提高CPU的运
                    
                    非关系型数据库
                        天秤-white
nosql
                        一、为什么要用Nosql1.单机MySQL的时代。一个基本的网站访问量一般不会太大，单个数据库完全足够。那时候更多使用的静态网页html，服务器根本没有太大压力。这时候网站的瓶颈是什么？-数据量如果太大，一个机器放不下。-数据量太大需要建立数据的索引（B+Tree），一个服务器内存放不下。-访问量读写混合，一个服务器承受不了。2.memcached缓存+MySQL+垂直拆分（读写分离）。网站80%
                    
                    mybatis 二级缓存失效_Mybatis 缓存原理及失效情况解析
                        weixin_39844942
mybatis二级缓存失效
                        这篇文章主要介绍了Mybatis缓存原理及失效情况解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、什么是缓存[Cache]存在内存中的临时数据。将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。2、为什么要使用缓存减少和数据库的交互次
                    
                    详解mybatis的一二级缓存以及缓存失效原因
                        仰望天花板
缓存数据库mybatisjavamysql
                        数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
                    
                    Golang channel 死锁
                        羊城程序猿
golanggolang
                        死锁是指两个或两个以上的协程的执行过程中，由于竞争资源或由于彼此通信而造成的一种阻塞的现象，若无外力作用，他们将无法推进下去,以下是总结出来的几种死锁情况。1.死锁1：一个通道在一个主go程里同时进行读和写2.死锁2：go程开启之前使用通道3.死锁3：通道1中调用了通道2，通道2中调用通道14.死锁4：直接读取空channel的死锁5.死锁5：超过channel缓存继续写入数据导致死锁6.向已关闭
                    
                    Cloud Native Weekly | 华为云抢先发布Redis5.0，红帽宣布收购混合云提供商
                        weixin_34302561
数据库devops大数据
                        1——华为云抢先发布Redis5.02——DigitalOceanK8s服务正式上线3——红帽宣布收购混合云提供商NooBaa4——微软发布多项AzureKubernetes服务更新1华为云抢先发布Redis5.012月17日，华为云在DCS2.0的基础上，快人一步，抢先推出了新的Redis5.0产品，这是一个崭新的突破。目前国内在缓存领域的发展普遍停留在Redis4.0阶段，华为云率先发布了Re
                    
                    Three.js AnimationUtils 和 AnimationObjectGroup
                        灵魂清零
three前端web3javascript
                        AnimationObjectGroup接收共享动画状态的一组对象。在使用手册的“下一步”章节中，“动画系统”一文对three.js动画系统中的不同元素作出了概述用法:将本来要作为根对象传入构造器或者动画混合器(AnimationMixer)的clipAction方法中的对象加入组中，并将这个组对象作为根对象传递。注意，这个类的实例作为混合器中的一个对象，因此，必须对组内的单个对象做缓存控制。限制
                    
                    华为云分布式缓存服务DCS与开源服务差异对比
                        hcinfo_18
redis使用华为云Redis5.0分布式缓存服务Redis客户端
                        分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
                    
                    Linux中open函数详解
                        460833359
LinuxClinuxopen函数
                        初级文件I/O函数（即不用缓存的I/O函数）：open（打开文件）相关函数read，write，fcntl，create，lseek，close，link，stat，umask，unlink，fopen头文件#include#include#include定义函数intopen(constchar*pathname,intflags);intopen(constchar*pathname,intf
                    
                    页面报错 POST 413错误 (Request Entity Too Large)
                        小黑屋说YYDS
踩坑nginxjavalinux服务器
                        一般来说是服务器使用nginx作为反向代理出现的问题，post请求长度超过了nginx默认的缓存大小和最大客户端最大请求大小。解决方式如下，更该nginx代理配置：在nginx.conf配置文件中，找到http{}代码块，添加如下配置client_max_body_size20m;重启nginx即可。
                    
                    数据库连接池
                        幻影翔

                        连接池的意义作用：连接池是将已经创建好的连接保存在池中，当有请求来时，直接使用已经创建好的连接对数据库进行访问。这样省略了创建连接和销毁连接的过程。这样性能上得到了提高。连接池放了N个Connection对象，本质上放在内存当中，在内存中划出一块缓存对象，应用程序每次从池里获得Connection对象，而不是直接从数据里获得，这样不占用服务器的内存资源。两种优秀的连接池技术都要实现接口DataSo
                    
                    【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析
                        "小夜猫&小懒虫&小财迷"的男人
鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为
                        【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
                    
                    npm install报错npm ERR! code CERT_HAS_EXPIRED
                        夏早安
npm前端node.js
                        报错如图解决办法：强制清缓存，取消ssl验证1.npmcacheclean--force2.npmconfigsetstrict-sslfalse3.重新npminstall4.依赖下载成功
                    
                    清除 Conda 缓存
                        Dmatteratall
conda缓存
                        清除Conda缓存：cssCopycodecondaclean--allcondaclean--all命令将会清除Conda缓存和临时文件，而不会删除已经安装的软件包和环境。它主要用于清理不必要的缓存和临时文件以释放磁盘空间。
                    
                    优化Conda环境：深入掌握conda clean命令的清理艺术
                        2401_85842555
conda
                        优化Conda环境：深入掌握condaclean命令的清理艺术Conda作为Anaconda发行版中的包管理器，不仅用于安装和管理包，还提供了强大的环境管理功能。随着时间的推移，Conda环境中可能会积累大量的缓存文件，这些文件不仅占用磁盘空间，还可能影响Conda的性能。本文将详细介绍如何在Conda中使用condaclean命令来清理缓存，帮助你优化Conda环境，释放宝贵的磁盘空间。Cond
                    
                    MySQL内存结构
                        san.hang
数据库数据结构与算法
                        实际上MySQL内存的组成和Oracle类似，也可以分为SGA（系统全局区）和PGA（程序缓存区）。mysql>showvariableslike"%buffer%";一、SGA1.innodb_buffer_bool用来缓存Innodb表的数据、索引、插入缓冲、数据字典等信息。2.innodb_log_buffer事务在内存中的缓冲，即redlogbuffer的大小3.querycache高速查
                    
                    Java中的服务端点响应缓存：Spring Cache抽象
                        微赚淘客机器人开发者联盟@聚娃科技
java缓存spring
                        Java中的服务端点响应缓存：SpringCache抽象大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在Java后端服务开发中，缓存是一个重要的性能优化手段。Spring框架提供了一个强大的缓存抽象，允许开发者以统一的方式使用不同的缓存技术。本文将介绍如何在Java应用中使用SpringCache抽象来实现服务端点的响应缓存。响应缓存的重要性响应缓存在服务端点中
                    
                    Certificate has expired(npm 安装strapi)
                        窥见漫天星光-莹
npmstrapi
                        报错信息解决方法1、清空缓存，有时，损坏的缓存会导致连接问题npmcacheclean--force2、切换到淘宝镜像源的npm注册表npmconfigsetregistryhttps://registry.npmmirror.com/执行这两步后就可以执行自己想要安装的东西了，我是在执行npxcreate-strapi-appschedul命令创建strapi项目时报上述错误。仅供参考。当然再安
                    
                    系统架构师软考历年论文题目（2009-2024年）及分析
                        pccai-vip
系统架构师系统架构
                        时间题目20091.论基于DSSA的软件架构设计与应用；2.论信息系统建模方法；3.论基于REST服务的Web应用系统设计；4.论软件可靠性设计与应用20101.论软件的静态演化和动态演化及其应用；2.论数据挖掘技术的应用；3.论大规模分布式系统缓存设计策略；4.论软件可靠性评价20111.论模型驱动架构在系统开发中的应用；2.论企业集成平台的架构设计；3.论企业架构管理与应用；4.论软件需求获取
                    
                    常用类库 Guava 简介
                        豆瑞瑞
java
                        简介GoogleGuava是一个由Google开发的Java开源函数库。前身是GoogleCollectionsLibrary，提供了许多简化工具，如缓存、连接器、过滤器、关联数组等仓库代码GitCode-全球开发者的开源社区,开源代码托管平台参考https://github.com/google/guavahttps://github.com/google/guava/wikiRedisStre
                    
                    手机广告
                        cccxccc

                        今天老鹰费了两天劲了，她说的最多的是“以后再也不摁了，可是不敢弄了。”她的手机，丢失了很多她宝贝的照片，还是亲手删的。最近小外孙总是用她的手机，不知是点了什么东西，屏幕上总会出现一个全屏广告。这让她苦恼极了。女儿远程帮她指导了指导，没解决问题就费了两个小时。晚上一个外甥女跟她视频，又提到这个问题，外甥女似乎懂，指挥着她把微信里的缓存都清理了。问题没解决，她一看，㖞，最喜欢的那几张照片没了！她寻了所
                    
                    自定义布隆过滤器解决缓存穿透
                        暗金烂狗
缓存
                        什么是缓存穿透以及常见解决方案缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库，导致数据库压力提高，造成宕机。缓存穿透就是指用户访问那些在数据库和Redis中都不存在的数据，例如我们知道id采用自增策略，那么就不可能出现负数id，而如果不法分子使用负数id进行查询，那么这些请求都会穿过Redis直接向数据库发送请求，从而导致数据库压力骤增，导致数
                    
                    java 线程池 队列封装_java线程池（线程池组---分离任务队列和线程池）
                        爱打怪的小魔女
java线程池队列封装
                        线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/消费者”模型。生产消费外部线程(生产者)－－－>任务消费者和生产者共享一个数据结构(缓存任务)PriorityQueue；生产者将任务添加到队列中，消费者从队列中取出数据；队列和线程池(线程池内部维护一个线程数组)，完全耦合在一起，当任务特别多，队列就不断的膨胀，增多，拥堵；就向车子过洞子另外一头走不掉，我靠，长龙(世界最长堵车世界纪录在天朝2
                    
                    【Redis】Redis缓存
                        1886i
JavaRedis缓存redis数据库
                        目录一、缓存1、概念2、作用3、缺点二、缓存模型三、缓存的更新1、更新策略2、主动更新的三种模式1.cacheasidepattern2.read/writethroughpattern3.writebehindcachingpattern3、线程安全问题1.缓存删除还是更新缓存2.先删除缓存后操作数据库3.先操作数据库后删除缓存4.如何保证缓存与数据库操作同时成功或失败4、最佳选择一、缓存1、概
                    
                    Integer 缓存
                        爱吃肉c
java面试缓存
                        在Java中，如果你通过newInteger(value)显式创建一个Integer对象，以下几点需要注意：内存中的Integer对象缓存范围：Java自动缓存的Integer对象范围是从-128到127。这些对象在类加载时被创建并存储在内存中。使用new创建对象：当你使用newInteger(value)创建一个整数对象时，无论value的值是-127、0、100还是128，都会创建一个新的In
                    
                    多级缓存架构设计
                        白鸽呀
架构缓存redis数据库
                        缓存是提升性能最直接的方法多级缓存分为：客户端，应用层，业务层，数据层1、客户端缓存：主要对浏览器的静态资源进行缓存通过在响应头设置Expires，cache-control，将文件保存在本地，减少多次请求静态资源带来的带宽损耗（解决并发手段）2、应用层缓存：浏览器只负责读取Expires，Expires在CDN内容分发网络和Nginx进行设置CDN内容分发网络是静态资源分发的主要技术手段，有效解
                    
                    实现多级缓存的六种策略方法
                        Kixuan214
缓存redisrabbitmq
                        保证多级缓存数据一致性是一个复杂的任务，尤其是在分布式和高并发环境中。以下是一些常见的方法和策略，可以帮助实现多级缓存的数据一致性1.缓存失效策略1.1主动失效在更新数据库时，主动使相关缓存失效。步骤：更新数据库删除或失效缓存publicclassCacheService{privateLocalCachelocalCache;privateRedisCacheredisCache;private
                    
                                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.