基于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&缓存)
        
            
                
                    顺序表和链表的比较
                        数九天有一个秘密
链表数据结构算法
                        这两个结构各有优势，相辅相成。顺序表：优点：1.支持随机访问。2.CPU高速缓存命中率更高。(物理空间连续)缺点：1.头部和中部插入和删除时间效率低(O(n))。2.连续的物理空间，空间不够后需要增容：a.增容有一定程度的消耗。b.为了避免频繁的进行增容，我们一般都按照倍数去增容，用不完会有一定的空间浪费。链表(带头循环双链表)优点：1.任意位置插入删除效率高(O(n))。2.按需申请和释放空间。
                    
                    Redis7——进阶篇（四）
                        啥也不会的小神龙·
Redis系列redis缓存学习redis经典面试题
                        前言：此篇文章系本人学习过程中记录下来的笔记，里面难免会有不少欠缺的地方，诚心期待大家多多给予指教。基础篇：Redis（一）Redis（二）Redis（三）Redis（四）Redis（五）Redis（六）Redis（七）Redis（八）进阶篇：Redis（九）Redis（十）Redis（十一）接上期内容：上期完成了缓存双写一致性方面的学习。下面学习HyperLogLog/Geo/Bitmap实际案
                    
                    Redis 常用数据类型
                        27xixi
java技术栈redis数据库缓存
                        Redis常用数据类型的详细介绍及其典型应用场景：String（字符串）描述：最基本的数据类型，可存储文本、数字或二进制数据（最大512MB）。常用命令：SETkeyvalue：设置值GETkey：获取值INCRkey：将值自增1（原子性操作）EXPIREkeyseconds：设置过期时间应用场景：缓存简单键值对（如用户会话、配置项）。计数器（如文章阅读量、库存扣减）。分布式锁（结合SETNX命令
                    
                    DPU的架构：模块化与可扩展性
                        绿算技术
DPU架构介绍架构科技缓存算法
                        DPU的架构设计注重模块化和可扩展性，以下是其典型架构：1.网络接口模块支持高速网络接口，例如100GbE、200GbE，甚至更高带宽的接口。2.处理核心模块包括多个ARM核心和专用加速核心，用于处理控制平面和数据平面任务。3.硬件加速模块包括网络加速引擎、存储加速引擎、加密引擎等，用于加速特定任务。4.内存与缓存集成高速内存和缓存，用于存储临时数据和指令。5.PCIe接口模块提供与主机CPU的高
                    
                    TCP网络协议
                        Ccc030.
tcp/ip网络服务器
                        TCP粘包1.TCP在接收数据时，多包数据粘在了一起2.原因：1.TCP发送数据时，没有及时发走，会根据缓冲区数据的情况进行重新组包；2.TCP接收方，没有及时读走缓冲区数据，导致缓冲区大量数据缓存。3.如何解决TCP粘包：1.发指定大小字节(结构体）structdata{intid;floattmp;xxx；}；指定在相同平台上使用，注意结构体对其齐问题。2.发送具有指定分隔符的数据"hello
                    
                    Linux arp(地址解析协议) 命令使用详解
                        
linux
                        简介arp（地址解析协议）命令用于查看、添加和修改系统的ARP缓存。ARP缓存存储了IP地址和MAC地址之间的映射，有助于网络中的计算机高效通信。许多现代Linux发行版使用ipneigh（来自iproute2）而不是arp。但是，arp对于管理ARP表仍然有用。示例用法显示ARP表arp-a或ipneighshow#这将显示当前ARP缓存，显示IP地址、MAC地址和网络接口示例输出192.168
                    
                    Java架构设计亿级流量场景下的本地缓存方案选型
                        我真的不想做程序员
架构设计java架构系统架构缓存java
                        在当今的互联网时代，亿级流量的应用场景已经司空见惯。无论是大型电商平台的促销活动，还是热门社交应用的日常运营，都可能面临每秒数万甚至数十万的请求流量。在这样的高并发、高流量场景下，系统的性能和稳定性面临着巨大的挑战。本地缓存作为提升系统性能、减轻服务器压力的重要手段，其选型和设计显得尤为重要。本文将探讨在亿级流量场景下，Java架构设计中本地缓存方案的选型策略。一、亿级流量场景下的挑战1.高并发请
                    
                    浏览器中输入 URL 到显示主页的完整过程
                        27xixi
java高频java
                        在浏览器中输入URL到显示主页的完整过程涉及网络通信、资源加载、渲染引擎协作等多个环节。以下是详细步骤：URL解析输入处理：浏览器解析URL格式（协议、域名、路径、参数等），若未指定协议（如直接输入example.com），默认补全为http://或https://。安全检查：检查地址合法性（如屏蔽恶意域名）。DNS解析将域名转换为IP地址：本地缓存查询浏览器缓存→系统hosts文件→路由器缓存→
                    
                    虚幻引擎入门_光照
                        MJ-MK
虚幻引擎入门虚幻游戏引擎
                        光照静态/固定/可移动物体静态物体在任何情况都不允许移动，且允许光照烘焙，渲染速度最快，开销最小。固定物体不能在运行时运动，启用光照缓存，缓存动态阴影。可移动物体可以在运行时移动，投射动态阴影，渲染速度最慢。静态/固定/可移动光源定向光源是固定光源，是平行光，只能旋转，移动和缩放都不造成影响，常用于模拟太阳光。点光源类似白炽灯，可以移动和缩放，但旋转没有意义，常用于区域照明。聚光源可以移动、旋转、
                    
                    Nginx、LVS、HAProxy 的区别和优缺点
                        青年夏日科技
nginx运维
                        Nginx、LVS、HAProxy是目前使用最广泛的三种负载均衡软件，本人都在多个项目中实施过，通常会结合Keepalive做健康检查，实现故障转移的高可用功能。1）在四层（tcp）实现负载均衡的软件：lvs------>重量级nginx------>轻量级，带缓存功能，正则表达式较灵活haproxy------>模拟四层转发，较灵活2）在七层（http）实现反向代理的软件：haproxy----
                    
                    我与DeepSeek读《大型网站技术架构》- 大型网站架构技术一览与Web开发技术发展历程
                        诺亚凹凸曼
架构
                        文章目录大型网站架构技术一览1.前端架构2.应用层架构3.服务层架构4.存储层架构5.后台架构6.数据采集与监控7.安全架构8.数据中心机房架构Web开发技术发展历程一、静态HTML阶段二、CGI脚本模式阶段三、服务器页面模式阶段大型网站架构技术一览1.前端架构浏览器访问优化：压缩静态资源、减少HTTP请求。CDN加速：将静态资源分发至边缘节点，降低网络延迟。反向代理：缓存热点内容，提供负载均衡与
                    
                    Android第二次面试总结（项目拷打实战）
                        每次的天空
android
                        MVVM+Jetpack组件落地采用ViewModel+LiveData实现数据驱动开发，将UI逻辑与业务逻辑解耦，通过LiveData的生命周期感知能力避免内存泄漏。使用WorkManager替代传统Service处理后台任务（如数据同步），结合Room数据库实现任务持久化，确保应用被杀后仍能恢复任务。性能优化实战集成Glide加载国风插画，结合自定义三级缓存策略（内存LRU+磁盘缓存+本地资源
                    
                    32路模拟采集PCI总线带DIO用什么采集卡
                        阿尔泰1999
数据分析嵌入式硬件科技
                        北京阿尔泰科技PCI5659是一-款多功能数据采集卡，具有32路12位100K采集频率，AD带16K字FIFO缓存，保证数据的连续性，并带16路可设方向的DIO功能。产品支持阿尔泰科技最新的ART-DAQ数据管理软件，提供QT、PYTHON、LABVIEW、VC、VB、VB.NET、C#等例子程序。模拟量输入通道数32路精度12位*大采样频率100KsPs多通道采样速度各通道*大采样频率/设置的采
                    
                    Vue动态组件完全指南：原理、使用场景与最佳实践
                        北辰alk
前端vuevue.jsjavascript前端
                        文章目录一、什么是动态组件？核心特性：二、基本使用方式1.基础语法2.组件注册方式3.动态组件生命周期三、六大典型应用场景1.标签页切换系统2.多步骤表单流程3.动态仪表盘4.权限驱动视图5.插件系统集成6.服务端驱动界面四、高级使用技巧1.状态保持方案2.动态Props传递3.异步组件加载4.过渡动画支持五、性能优化策略1.缓存策略对比2.代码分割配置3.内存管理示例六、常见问题解决方案1.组件
                    
                    Spring Cache的基本使用
                        奇怪的大象
面试学习路线阿里巴巴springjava后端
                        文章目录一、概述二、SpringCache的使用2.1环境搭建2.2缓存的读模式@Cacheable2.3自定义缓存配置[email protected]@CacheEvict删除缓存2.6@Caching多个操作三、SpringCache的不足一、概述常见的缓存的框架有Redis、Memcached、Guava、Caffeine等等，各有各的优势。如果我们的程序想要使用缓存，就要与这些框架耦合。聪明
                    
                    基础知识《Redis解析》
                        Hum8le
redis数据库缓存安全web安全
                        Redis详细解析与介绍Redis（RemoteDictionaryServer）是一个开源的高性能键值对（Key-Value）数据库，支持多种数据结构（如字符串、哈希、列表、集合等），广泛应用于缓存、消息队列、实时数据分析等场景。核心特点：内存存储：数据主要存储在内存中，读写性能极高（10万+/秒QPS）。持久化支持：支持RDB（快照）和AOF（追加日志）两种持久化方式。多数据结构：支持字符串、
                    
                    高性能缓存利器：Caffeine 在 Spring Boot 中的应用
                        阿里小阿希
JAVA缓存springbootspring
                        在现代应用程序中，缓存是提高数据检索速度、减少对数据库或其他数据源访问次数的重要手段。SpringCache提供了多种缓存实现方式，而在我们的SpringBoot项目中，我们选择了Caffeine作为默认的缓存库。Caffeine简介Caffeine是一个基于Java8的高性能、近乎最佳的缓存库。它提供了多种优化技术，如写入时复制（Copy-on-Write）和分段锁（SegmentedLocki
                    
                    Redis缓存和Mysql数据一致性问题
                        每天瞎忙的农民工
缓存redismysql
                        在高并发环境下，保持Redis缓存和MySQL数据库的数据一致性是一个复杂但至关重要的任务。下面是对这一问题的详细讲解，并结合PHP代码示例来展示如何解决这些一致性问题。问题背景Redis缓存和MySQL数据库的主要挑战在于：缓存和数据库之间的延迟：在缓存更新与数据库更新之间，可能存在时间差，导致数据不一致。高并发下的缓存击穿：缓存被并发请求同时击穿，导致大量请求直接访问数据库。缓存雪崩：大量缓存
                    
                    缓存使用的具体场景有哪些？缓存的一致性问题如何解决？缓存使用常见问题有哪些？
                        蒂法就是我
缓存
                        缓存使用场景、一致性及常见问题解析一、缓存的核心使用场景1.高频读、低频写场景典型场景：商品详情页、新闻资讯、用户基本信息。特点：数据更新频率低，但访问量极高。策略：Cache-Aside（旁路缓存）：优先读缓存，未命中时查数据库并回填。TTL（过期时间）：设置合理过期时间（如5分钟），平衡数据新鲜度与缓存命中率。示例：publicProductgetProduct(Stringid){Produ
                    
                    什么是 Redis
                        yqcoder
redis数据库缓存
                        Redis（RemoteDictionaryServer）是一个开源的、基于内存的键值存储系统，常用作数据库、缓存和消息中间件。它支持多种数据结构，如字符串、哈希、列表、集合、有序集合等，并提供丰富的操作命令。主要特点高性能：数据存储在内存中，读写速度极快。持久化：支持RDB和AOF两种方式，确保数据在重启后不丢失。数据结构丰富：支持字符串、哈希、列表、集合、有序集合等多种类型。原子操作：所有操作
                    
                    java不用缓存实现token续签_JWT实现登陆认证及Token自动续期
                        deep go

                        过去这段时间主要负责了项目中的用户管理模块，用户管理模块会涉及到加密及认证流程，加密已经在前面的文章中介绍了，可以阅读：https://juejin.cn/post/6916150628955717646今天就来讲讲认证功能的技术选型及实现。技术上没啥难度当然也没啥挑战，但是对一个原先没写过认证功能的菜鸡甜来说也是一种锻炼吧技术选型要实现认证功能，很容易就会想到JWT或者session，但是两者有
                    
                    Java常用集合与映射的线程安全问题深度解析
                        扣得A艾
java安全开发语言
                        Java常用集合与映射的线程安全问题深度解析一、线程安全基础认知在并发编程环境下，当多个线程同时操作同一集合对象时，若未采取同步措施，可能导致以下典型问题：数据竞争：多个线程同时修改数据导致结果不可预测状态不一致：部分线程看到集合的中间状态内存可见性：线程本地缓存与主内存数据不同步死循环风险：特定操作引发无限循环（如JDK7的HashMap扩容）二、典型非线程安全集合问题分析1.ArrayList
                    
                    Spring Boot实战：MySQL与Redis数据一致性深度解析与代码实战
                        黑猫Teng
springbootmysqlredis
                        SpringBoot实战：MySQL与Redis数据一致性深度解析与代码实战一、数据一致性问题概述二、常见解决方案三、选择合适的解决方案四、总结在SpringBoot开发中，MySQL作为关系型数据库，提供了强大的数据存储和查询能力；而Redis作为内存数据库，以其高速读写性能成为缓存层的首选。然而，当这两者共同服务于一个系统时，如何确保它们之间的数据一致性，成为了一个不可忽视的问题。本文将深入探
                    
                    Java常用集合与映射的线程安全问题深度解析
                        jiajia651304
java安全开发语言
                        Java常用集合与映射的线程安全问题深度解析一、线程安全基础认知在并发编程环境下，当多个线程同时操作同一集合对象时，若未采取同步措施，可能导致以下典型问题：数据竞争：多个线程同时修改数据导致结果不可预测状态不一致：部分线程看到集合的中间状态内存可见性：线程本地缓存与主内存数据不同步死循环风险：特定操作引发无限循环（如JDK7的HashMap扩容）二、典型非线程安全集合问题分析1.ArrayList
                    
                    Mybatis的基本使用
                        学c真好玩
mybatis
                        MyBatis简介MyBatis用于持久层框架,持久层是对数据库操作的部分，前版本iBatis由Apache软件基金组织进行更名并维护。特点:简化数据库的操作SQL映射灵活(半ORM框架)支持高级映射易于集成维护配置动态SQL缓存机制功能：替代JDBC,JDBC是java中提供的用于操作数据库的技术及方案数据库的连接控制难。连接池SQL语句硬编码。将sql语句存放到xml配置文件中参数传递问题。提
                    
                    页面刷新时如何实现vuex数据缓存
                        拉米医生
缓存json前端javascript开发语言
                        在Vuex中，您可以使用本地存储(例如localStorage)来缓存状态数据，并在页面刷新时将其加载回状态中。首先，您需要在Vuex的store实例中定义一个方法，用于在页面刷新时从本地存储中加载数据：conststore=newVuex.Store({state:{count:0},mutations:{increment(state){state.count++}},actions:{loa
                    
                    vuex-persistedstate缓存vuex状态数据
                        abytecoder
经验分享
                        `vuex-persistedstate`是一个用于在Vuex中实现数据持久化的插件，可以将Vuexstore中的状态持久化到本地存储中（如localStorage或sessionStorage）。以下是一个简单的示例，演示如何使用`vuex-persistedstate`插件：首先，安装`vuex-persistedstate`：```bashnpminstallvuex-persistedst
                    
                    vuex-----Store进行页面数据缓存，页面回退不刷新数据。
                        猪头人的机车暴力美学
Web前端Vuexvue.jsjavascript前端vue.js
                        各位可以经常在项目当中遇见一个非常常见的需求，即用户在一页表单中点击某列详情或其他操作，跳转入另一页面，在完成操作后返回前一页，期望前一页的表单页数停留在最后操作的那一页，而不是从新以第一页开始，这样会导致用户操作频繁，系统友好度非常低。在以往的项目经验当中，keep-alive是一个很好的处理方式，但是keep-alive本身也存在一些坑，不小心就会给自己挖了慢满满的坑，在最新的项目当中，有使用
                    
                    vuex中使用vuex-persistedstate无法进行持久缓存
                        小小怪下士_---_
缓存前端javascriptvue.js
                        在vuex的mutations中发送axios请求造成响应数据无法持久缓存最近在开发一个基于vue3的后台管理系统，因为要使用到了动态路由和权限管理，所以需要请求用户所属角色的一个权限信息，并将这些信息通过vuex-persistedstate持久保存到localStorage中。起初我在配置vuex的中mutations中使用axios向服务端请求用户的权限信息，并使用vuex-persiste
                    
                    云原生周刊：基于 KubeSphere LuBan 架构打造DeepSeek 插件
                        
云计算
                        开源项目推荐KubeAIKubeAI是一个K8s上的AI推理操作器，旨在简化在生产环境中部署和管理大型语言模型（LLM）、向量嵌入和语音处理等机器学习模型。它提供与OpenAI兼容的API，支持在CPU和GPU上运行，并具备按需自动扩缩容的能力。KubeAI无需依赖Istio、Knative等其他系统，能够在几乎任何K8s集群中开箱即用。此外，它内置了模型代理，优化了键值缓存利用率，从而显著提升系
                    
                                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.