爱我所爱0505
爱我所爱0505

多级缓存框架＜一＞

目录

一、概览

二、缓存封装

1. 依赖jar包

2. 定义配置

3. 自定义Cache实现类

4. 自定义redis缓存实现类

5. CacheManager管理Cache

6. 加载Redisson和Ehcache配置文件

三、缓存实战

1. 依赖cache-core包

2. 添加配置

3. Redisson和Ehcache配置文件

4. cacheName过期时间配置

5. 创建CacheManager的bean

6. @Cacheable使用

7. 测试

一、概览

        缓存是高并发下的必备技术之一。本章节使用ehcache作为一级缓存、redis集群作为二级缓存。如下图所示，获取缓存数据流程图。自己封装缓存jar包cache-core，redisson访问redis集群。

多级缓存框架＜一＞_第1张图片

        ehcache缓存是应用内存级别缓存，也是本地缓存。而redis集群为内存缓存，也是分布式缓存。DB数据存入磁盘，其查询速率远不及ehcache、redis，但DB是数据的源头。所以缓存中数据同步，即：及时更新缓存数据尤为重要。上图绿色部分”同步到redis“是为了降低数据延时同步。

         redis缓存中会出现"雪崩"、"穿透"、"击穿"。本章节也对此做了相应考虑，3种具体处理方式不在本节详细介绍。

        如下图所示是封装缓存的类图。

多级缓存框架＜一＞_第2张图片

二、缓存封装

1. 依赖jar包



    org.redisson
    redisson-spring-boot-starter
    3.11.6
    provided



    net.sf.ehcache
    ehcache
    2.9.1
    provided

2. 定义配置

cache-core:
  global:
    redisEnable: true        # redis缓存是否可用
    expiration: 120          # 全局过期时间(单位s)
    random-expiration: 60    # 全局过期随机时间(单位s)，防止redis大量key同一时间过期
    null-expiration:
      enable: true           # null值缓存过期时间是否开启
      expiration: 5          # null值缓存过期时间，防止redis穿透
  redis:
    config-path: classpath:config\redisson-cluster-config.yml # redisson集群配置文件路径
  ehcache:
    config-path: config/ehcache.xml # ehcache配置文件路径

3. 自定义Cache实现类

RedisAndEhcacheCache类实现Cache接口，该类主要完成put、get、evict等具体方法。需注意：

a. 自定义MyRedisCache类：实现redis具体的put方法，尤其是设置过期随机时间设置

b. 获取缓存数据get方法：先获取ehcache、再获取redis集群

c. null缓存：put时，ehcache不缓存null，只有redis缓存null，防止缓存穿透

package com.common.cache.core.config;

import com.log.util.LogUtil;
import org.springframework.cache.Cache;
import org.springframework.cache.ehcache.EhCacheCache;
import org.springframework.data.redis.cache.RedisCache;

import java.util.concurrent.Callable;

/**
 * @description redis + ehcache的Cache - 核心方法
 * @author TCM
 * @version 1.0
 * @date 2021/7/10 14:01
 **/
public class RedisAndEhcacheCache implements Cache {

    // redis缓存
    private MyRedisCache myRedisCache;
    // ehcache缓存
    private EhCacheCache ehCacheCache;
    // redis缓存可用
    private boolean redisEnable;

    // 构造函数
    public RedisAndEhcacheCache(RedisCache redisCache, EhCacheCache ehCacheCache, boolean redisEnable){
        this.myRedisCache = (MyRedisCache) redisCache;
        this.ehCacheCache = ehCacheCache;
        this.redisEnable = redisEnable;
    }

    // redis是否可用
    private boolean checkRedisEnable() {
        return this.redisEnable;
    }

    @Override
    public String getName() {
        return this.myRedisCache.getName();
    }

    @Override
    public Object getNativeCache() {
        return null;
    }

    // 先获取ehcache缓存、再获取redis缓存
    @Override
    public ValueWrapper get(Object key) {
        // 获取ehcache缓存
        ValueWrapper value = this.ehCacheCache.get(key);
        if (value != null) {
            return value;
        }

        try {
            // redis是否可用
            if (checkRedisEnable()) {
                // 获取redis缓存
                value = this.myRedisCache.get(key);
                // redis数据缓存到ehcache
                if (null != value) {
                    this.ehCacheCache.put(key, value.get());
                }
            }
        } catch (Exception e) {
            LogUtil.error("cache error key: " + key, "RedisAndEhcacheCache");
        }
        return value;
    }

    @Override
    public  T get(Object key, Class type) {
        // 获取ehcache缓存
        Object value = this.ehCacheCache.get(key.toString());
        if (null != value) {
            return (T) value;
        }

        // redis是否可用
        if (checkRedisEnable()) {
            // 获取redis缓存
            value = this.myRedisCache.get(key.toString(), type);
            // redis数据缓存到ehcache
            if (null != value) {
                this.ehCacheCache.put(key, value);
                return (T) value;
            }
        }
        return null;
    }

    @Override
    public  T get(Object key, Callable valueLoader) {
        return (T) this.get(key.toString());
    }

    @Override
    public void put(Object key, Object value) {
        // 如果@Cacheable中null也缓存，则ehcache也会缓存null
        // 此处定义：null值缓存，只在redis中缓存
        // 缓存到ehcache
        if (value != null) {
            this.ehCacheCache.put(key, value);
        }

        // redis可用，则缓存到redis
        if (checkRedisEnable()) {
            this.myRedisCache.put(key, value);
        }
    }

    @Override
    public ValueWrapper putIfAbsent(Object key, Object value) {
        return null;
    }

    @Override
    public void evict(Object key) {
        // 缓存到ehcache
        this.ehCacheCache.evict(key);

        // redis可用，则缓存到redis
        if (checkRedisEnable()) {
            this.myRedisCache.evict(key);
        }
    }

    @Override
    public void clear() {
        this.ehCacheCache.clear();
    }

}

4. 自定义redis缓存实现类

MyRedisCache类处理具体的put方法，其他方法继承父类RedisCache，需注意：

a. 防止"穿透"：过期时间为全局null过期时间配置

b. 防止"雪崩"：cacheName下缓存时，加上随机过期时间，避免雪崩

d. CacheNameRandomExpirationConfig：存放cacheName与随机过期时间的映射关系

package com.common.cache.core.config;

import org.springframework.data.redis.cache.RedisCache;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheWriter;

import java.time.Duration;

/**
 * @description 处理构造函数 + 过期时间
 * @author TCM
 * @version 1.0
 * @date 2021/7/11 9:16
 **/
public class MyRedisCache extends RedisCache {

    private final String name;
    private final RedisCacheWriter cacheWriter;
    private final RedisCacheConfiguration cacheConfig;

    // null值缓存过期时间是否开启
    private final Boolean enableExpiration;
    // null值缓存过期时间，防止redis穿透
    private final Long nullExpiration;

    public MyRedisCache(String name, RedisCacheWriter cacheWriter, RedisCacheConfiguration cacheConfig,
                        Boolean enableExpiration, Long nullExpiration) {
        super(name, cacheWriter, cacheConfig);
        this.name = name;
        this.cacheWriter = cacheWriter;
        this.cacheConfig = cacheConfig;
        this.enableExpiration = enableExpiration;
        this.nullExpiration = nullExpiration;
    }

    /**
     * 覆写RedisCache中的put
     * 目的：可以在redis的cacheName下所有key添加随机过期时间，防止cacheName下大批量key同一时间失效
     */
    @Override
    public void put(Object key, Object value) {
        Object cacheValue = this.preProcessCacheValue(value);
        if (!this.isAllowNullValues() && cacheValue == null) {
            throw new IllegalArgumentException(String.format("Cache '%s' does not allow 'null' values. Avoid storing null via '@Cacheable(unless=\"#result == null\")' or configure RedisCache to allow 'null' via RedisCacheConfiguration.", this.name));
        } else {
            // 总过期时间
            long totalExpiration;

            // null过期时间开启
            if (enableExpiration && value == null) {
                totalExpiration = nullExpiration;
            } else {
                // 获取cacheName对应的随机过期时间配置
                long randomExpiration = CacheNameRandomExpirationConfig.getInstance().getConcurrentHashMap().get(this.name);
                // 总过期时间 = 过期时间 + 随机过期时间
                totalExpiration = this.cacheConfig.getTtl().getSeconds() + (int) (Math.random() * (randomExpiration + 1));
            }

            // 保存key
            this.cacheWriter.put(this.name, this.createAndConvertCacheKey(key), this.serializeCacheValue(cacheValue), Duration.ofSeconds(totalExpiration));
        }
    }

    // 参考父类RedisCache的方法
    private byte[] createAndConvertCacheKey(Object key) {
        return this.serializeCacheKey(this.createCacheKey(key));
    }

}

package com.common.cache.core.config;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @description redis的key的随机过期时间 —— 防止大量key同一时间失效
 * @author TCM
 * @version 1.0
 * @date 2021/8/4 21:57
 **/
public class CacheNameRandomExpirationConfig {

    // 存放redis的cacheName的随机过期时间
    private Map concurrentHashMap;
    // 单例
    private static CacheNameRandomExpirationConfig cacheNameRandomExpirationConfig;

    public CacheNameRandomExpirationConfig(){
        this.concurrentHashMap = new ConcurrentHashMap<>();
    }

    public static synchronized CacheNameRandomExpirationConfig getInstance() {
        if (cacheNameRandomExpirationConfig == null) {
            cacheNameRandomExpirationConfig = new CacheNameRandomExpirationConfig();
        }
        return cacheNameRandomExpirationConfig;
    }

    public Map getConcurrentHashMap() {
        return concurrentHashMap;
    }

}

5. CacheManager管理Cache

SimpleCacheManagerConfig类，创建CacheManagerBean来管理不同的cache对象

package com.common.cache.core.config;

import com.common.cache.core.redisson.FastJson2JsonRedisSerializer;
import net.sf.ehcache.CacheManager;
import org.redisson.spring.data.connection.RedissonConnectionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.ehcache.EhCacheCache;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCache;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.serializer.RedisSerializationContext;

import javax.annotation.Resource;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Collection;

/**
 * @description SimpleCacheManager配置
 * @author tcm
 * @version 1.0.0
 * @date 2021/7/8 17:43
 **/
@Configuration
public class SimpleCacheManagerConfig {

    @Resource(name = "cacheRedissonConnectionFactory")
    private RedissonConnectionFactory redissonConnectionFactory;

    private final String redisKeyPrefix = "cache:";

    @Value("${cache-core.global.redisEnable}")
    private boolean redisEnable;
    @Value("${cache-core.global.expiration}")
    private Long expiration;
    @Value("${cache-core.global.random-expiration}")
    private Long randomExpiration;
    @Value("${cache-core.global.null-expiration.enable}")
    private Boolean enableExpiration;
    @Value("${cache-core.global.null-expiration.expiration}")
    private Long nullExpiration;
    @Value("${cache-core.ehcache.config-path:ehcache.xml}")
    private String configPath;

    /**
     * 设置过期时间创建SimpleCacheManager
     * @param cacheName ehcache名称
     * @param expiration redis过期时间
     * @return
     */
    protected SimpleCacheManager create(String cacheName, Long expiration, Long randomExpiration) {
        return createCacheManager(cacheName, expiration, randomExpiration);
    }

    /**
     * 默认过期时间创建SimpleCacheManager
     * @param cacheName ehcache名称
     * @return
     */
    protected SimpleCacheManager create(String cacheName) {
        return createCacheManager(cacheName, expiration, randomExpiration);
    }

    // 创建CacheManager
    private SimpleCacheManager createCacheManager(String cacheName, Long expiration, Long randomExpiration) {
        // 收集配置的cacheName对应的随机过期时间
        CacheNameRandomExpirationConfig.getInstance().getConcurrentHashMap().put(cacheName, randomExpiration);

        // 获取redis + ehcache对象
        RedisAndEhcacheCache redisAndEhcacheCache = getRedisAndEhcacheCache(cacheName, expiration);

        // cache集合
        Collection caches = new ArrayList<>();
        caches.add(redisAndEhcacheCache);

        // redis + ehcache缓存管理器
        SimpleCacheManager simpleCacheManager = new SimpleCacheManager();
        simpleCacheManager.setCaches(caches);

        return simpleCacheManager;
    }

    // 返回redis + ehcache对象
    private RedisAndEhcacheCache getRedisAndEhcacheCache(String cacheName, Long expiration){
        // redis缓存配置
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                // 设置过期时间 = 过期时间 + 随机时间[0,randomExpiration]，防止redis大量key同一时间过期
                .entryTtl(Duration.ofSeconds(expiration))
                // 序列化
                .serializeValuesWith(jackson2JsonRedisSerializer())
                // key前缀
                .prefixKeysWith(redisKeyPrefix);

        // 创建redisCache
        RedisCache redisCache = new MyRedisCache(cacheName, RedisCacheWriter.nonLockingRedisCacheWriter(redissonConnectionFactory), redisCacheConfiguration,
                enableExpiration, nullExpiration);

        // 创建ehCacheCache
        CacheManager ehcacheCacheManger = CacheEhcacheConfig.getInstance(configPath).getCacheManager();
        EhCacheCache ehCacheCache = new EhCacheCache(ehcacheCacheManger.getCache(cacheName));

        // 创建redis + ehcache
        return new RedisAndEhcacheCache(redisCache, ehCacheCache, redisEnable);
    }

    // 缓存时序列化value
    private RedisSerializationContext.SerializationPair jackson2JsonRedisSerializer(){
        FastJson2JsonRedisSerializer jackson2JsonRedisSerializer = new FastJson2JsonRedisSerializer<>(Object.class);
        return RedisSerializationContext
                .SerializationPair
                .fromSerializer(jackson2JsonRedisSerializer);
    }

}
 
  
6. 加载Redisson和Ehcache配置文件
 
  
注意：a. RedissonClusterConfig：加载redisson集群配置文件
 
  
           b. CacheEhcacheConfig：加载ehcache配置文件
 
  
           c. FastJson2JsonRedisSerializer：redis保存value时对象序列化
 
  
package com.common.cache.core.redisson;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.spring.data.connection.RedissonConnectionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;

import java.io.IOException;

/**
 * @description Redisson集群配置
 * @author tcm
 * @version 1.0.0
 * @date 2021/8/2 17:00
 **/
@Configuration
public class RedissonClusterConfig {

    @Value("${cache-core.redis.config-path:classpath:\\redisson-cluster-config.yml}")
    private Resource configFile;

    @Bean("cacheRedissonConnectionFactory")
    public RedissonConnectionFactory cacheRedissonConnectionFactory() throws IOException {
        // 加载配置文件
        Config config = Config.fromYAML(configFile.getInputStream());
        // 创建RedissonClient
        RedissonClient redissonClient = Redisson.create(config);
        // 创建RedissonConnectionFactory
        return new RedissonConnectionFactory(redissonClient);
    }

}

 
  
package com.common.cache.core.config;

import net.sf.ehcache.CacheManager;

import java.net.URL;

/**
 * @description Ehcache配置 - 单例模式
 * @author TCM
 * @version 1.0
 * @date 2021/7/11 10:16
 **/
public class CacheEhcacheConfig {

    // 获取ehcache配置文件路径
    public static String configPath2;

    // Ehcache缓存管理器
    private CacheManager cacheManager;
    private static CacheEhcacheConfig cacheEhcacheConfig;

    private CacheEhcacheConfig() {
        final String configPath = configPath2;
        URL url = CacheEhcacheConfig.class.getClassLoader().getResource(configPath);
        // 创建CacheManager
        this.cacheManager = CacheManager.create(url);
    }

    public static synchronized CacheEhcacheConfig getInstance(String configPath) {
        if (cacheEhcacheConfig == null) {
            configPath2 = configPath;
            cacheEhcacheConfig = new CacheEhcacheConfig();
        }
        return cacheEhcacheConfig;
    }

    public CacheManager getCacheManager() {
        return cacheManager;
    }

    public void setCacheManager(CacheManager cacheManager) {
        this.cacheManager = cacheManager;
    }

}

 
  
package com.common.cache.core.redisson;

import com.alibaba.fastjson.JSON;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;

import java.nio.charset.Charset;

/**
 * @description 自定义redis对象序列化
 * @author tcm
 * @version 1.0.0
 * @date 2021/5/26 17:59
 **/
public class FastJson2JsonRedisSerializer implements RedisSerializer {

    private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private Class clazz;

    public FastJson2JsonRedisSerializer(Class clazz) {
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return new byte[0];
        }
        return JSON.toJSONString(t).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);
        return (T) JSON.parseObject(str, clazz);
    }

}

 
  
三、缓存实战
 
  
1. 依赖cache-core包
 
  


     com.common
     cache-core
     1.0.0-RELEASE

 
  
2. 添加配置
 
  
cache-core:
  global:
    redisEnable: true        # redis缓存是否可用
    expiration: 120          # 全局过期时间(单位s)
    random-expiration: 60    # 全局过期随机时间(单位s)，防止redis大量key同一时间过期
    null-expiration:
      enable: true           # null值缓存过期时间是否开启
      expiration: 10         # null值缓存过期时间，防止redis穿透
  redis:
    config-path: classpath:config\redisson-cluster-config.yml # redisson集群配置文件路径
  ehcache:
    config-path: config/ehcache.xml # ehcache配置文件路径
 
  
3. Redisson和Ehcache配置文件
 
  
Redis集群配置Redisson：config/redisson-cluster-config.yml
 
  
# Redisson集群配置
clusterServersConfig:
  idleConnectionTimeout: 10000
  pingTimeout: 1000
  connectTimeout: 10000
  timeout: 3000
  retryAttempts: 3
  retryInterval: 1500
  reconnectionTimeout: 3000
  failedAttempts: 3
  subscriptionsPerConnection: 5
  clientName: null
  loadBalancer: ! {}
  slaveSubscriptionConnectionMinimumIdleSize: 1
  slaveSubscriptionConnectionPoolSize: 50
  slaveConnectionMinimumIdleSize: 32
  slaveConnectionPoolSize: 64
  masterConnectionMinimumIdleSize: 32
  masterConnectionPoolSize: 64
  readMode: "SLAVE"
  password: "abcdef"
  nodeAddresses:
    - "redis://192.168.153.94:6382"
    - "redis://192.168.153.94:6383"
    - "redis://192.168.153.94:6384"
    - "redis://192.168.153.94:6385"
    - "redis://192.168.153.94:6386"
    - "redis://192.168.153.94:6387"
  scanInterval: 1000
threads: 0
nettyThreads: 0
codec: ! {}
"transportMode": "NIO"
 
  
Ehcache配置文件：config/ehcache.xml
 
  


    
    
    
    

    
    

    
    




 
  
4. cacheName过期时间配置
 
  
配置文件为：config/ehredis.properties
 
  
# cacheName配置
tabCache.cache.name=tabCache
# cacheName下key的过期时间配置
tabCache.redis.expiration=60
# cacheName下key的随机过期时间配置
tabCache.redis.random-expiration=120

tabCacheDao.cache.name=tabCacheDao
tabCacheDao.redis.expiration=600
tabCacheDao.redis.random-expiration=120
 
  
5. 创建CacheManager的bean
 
  
package com.common.instance.demo.config.cache;

import com.common.cache.core.config.SimpleCacheManagerConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.PropertySource;

/**
 * @description SimpleCacheManager的bean管理
 * @author tcm
 * @version 1.0.0
 * @date 2021/7/9 15:14
 **/
@Configuration
@PropertySource({"classpath:/config/ehredis.properties"})
public class SimpleCacheManagerBean extends SimpleCacheManagerConfig {

    @Bean("tabCacheManager")
    @Primary
    public SimpleCacheManager tabCacheManagerBean(@Value("${tabCache.cache.name}") String cacheName,
                                     @Value("${tabCache.redis.expiration}") Long expiration,
                                     @Value("${tabCache.redis.random-expiration}") Long randomExpiration) {
        return super.create(cacheName, expiration, randomExpiration);
    }

    @Bean("tabCacheDaoManager")
    public SimpleCacheManager tabCacheDaoManagerBean(@Value("${tabCacheDao.cache.name}") String cacheName,
                                     @Value("${tabCacheDao.redis.expiration}") Long expiration,
                                     @Value("${tabCacheDao.redis.random-expiration}") Long randomExpiration) {
        return super.create(cacheName, expiration, randomExpiration);
    }

}

 
  
6. @Cacheable使用
 
  
注意：a. value：对应ehredis.properties下的xxx.cache.name的配置，见缓存实战第三步
 
  
           b. cacheManager：对应CacheManager的bean名，见缓存实战第四步
 
  
           c. unless = "#result eq null"：值为null时，根本没有走put方法
 
  
@Cacheable(value = {"tabCache"}, key = "'tabCache:' + #tabId", cacheManager = "tabCacheManager", unless = "#result eq null")
public List testRedisCacheAble(String tabId) {
    // 组装查询参数
    WcPendantTab tab = new WcPendantTab();
    tab.setTabId(tabId);

    // 查询
    List tabs = wcPendantTabDao.queryAll(tab);

    return tabs;
}
 
  
7. 测试
 
  
注意：a. 前缀"cache"：是所有key的前缀，见缓存封装第5步
 
  
多级缓存框架＜一＞_第3张图片
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(系统框架,redis,缓存,redis,ehcache)

        

            

                
    
                    
  • Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    
                    
    • 
                    
  • Android应用性能优化
                        轻口味
Android
                        
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
    
                    
    • 
                    
  • 华为云分布式缓存服务DCS 8月新特性发布
                        华为云PaaS服务小智
华为云分布式缓存
                        
    分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
    
                    
    • 
                    
  • Redis Key的过期策略
                        ArchManual
分布式架构分布式Java后端微服务架构redis
                        
    Redis的过期策略主要是指管理和删除那些设定了过期时间的键，以确保内存的有效使用和数据的及时清理。具体来说，Redis有三种主要的过期策略：定期删除（ScheduledDeletion）、惰性删除（LazyDeletion）和内存淘汰策略（EvictionPolicies）。1.定期删除Redis的定期删除策略（ScheduledDeletion）的步骤如下：设置定期任务：Redis会在后台线程
    
                    
    • 
                    
  • 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的运
    
                    
    • 
                    
  • Redis 有哪些危险命令？如何防范？
                        花小疯
redis缓存数据库危险命令大数据
                        
    Redis有哪些危险命令？Redis的危险命令主要有以下几个：1.keys客户端可查询出所有存在的键。2.flushdb删除Redis中当前所在数据库中的所有记录，并且此命令从不会执行失败。3.flushall删除Redis中所有数据库中的所有记录，不止是当前所在数据库，并且此命令从不会执行失败。4.config客户端可修改Redis配置。怎么禁用和重命名危险命令？看下redis.conf默认配置
    
                    
    • 
                    
  • 非关系型数据库
                        天秤-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.向已关闭
    
                    
    • 
                    
  • Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理
                        朱杰jjj
缓存分布式
                        
    分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
    
                    
    • 
                    
  • 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高速查
    
                    
    • 
                    
  • 关于Redis集群同步/持久化/淘汰机制的详解
                        尾巴尖上的阳光
大数据redis数据库
                        
    Redis是非常常用的KV数据库,使用内存以及HashMap进行存储的特点带来了高效的查询.本文将围绕Redis的常见开发使用场景,阐述在Redis集群中各个节点是如何进行数据同步,每个节点如何进行持久化以及在长期使用中如何对数据进行更新和淘汰.如果对Redis有更多的兴趣,可以查看我的技术博客:https://dingyuqi.com下面是Redis在开发过程中常用的几种使用场景.集群Redis
    
                    
    • 
                    
  • 主流行架构
                        rainbowcheng
架构架构
                        
    nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
    
                    
    • 
                    
  • 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.论软件需求获取
    
                    
    • 
                    
  • 网上商城项目总结 续
                        猫只i
javaweb电子商城结构
                        
    前台1.用户登录注册邮箱验证校验用户名是否存在验证码自动登录2.导航条自定义标签库采用异步读取数据（使用gson将集合转换json数据）Redis服务器3.首页热门商品查询展示4.分类列表分页查询5.商品详情用cookie实现浏览记录6.购物车实现商品添加到购物车商品的查询，添加，修改，删除清空购物车7.提交订单添加订单（订单详情）确认订单（易宝支付）8.我的订单9.Fliter定义权限拦截（提交
    
                    
    • 
                    
  • 常用类库 Guava 简介
                        豆瑞瑞
java
                        
    简介GoogleGuava是一个由Google开发的Java开源函数库。前身是GoogleCollectionsLibrary，提供了许多简化工具，如缓存、连接器、过滤器、关联数组等仓库代码GitCode-全球开发者的开源社区,开源代码托管平台参考https://github.com/google/guavahttps://github.com/google/guava/wikiRedisStre
    
                    
    • 
                                
  • 异常的核心类Throwable
                                    无量
java源码异常处理exception
                                    
    java异常的核心是Throwable，其他的如Error和Exception都是继承的这个类 里面有个核心参数是detailMessage，记录异常信息，getMessage核心方法，获取这个参数的值，我们可以自己定义自己的异常类，去继承这个Exception就可以了，方法基本上，用父类的构造方法就OK，所以这么看异常是不是很easy 
 
 
 
package com.natsu;



    
                                
    • 
                                
  • mongoDB 游标（cursor） 实现分页 迭代
                                    开窍的石头
mongodb
                                    
    上篇中我们讲了mongoDB 中的查询函数，现在我们讲mongo中如何做分页查询 
 
     如何声明一个游标 
       var mycursor = db.user.find({_id:{$lte:5}}); 
      迭代显示游标数
    
                                
    • 
                                
  • MySQL数据库INNODB 表损坏修复处理过程
                                    0624chenhong
tomcatmysql
                                    
    最近mysql数据库经常死掉，用命令net stop mysql命令也无法停掉，关闭Tomcat的时候，出现Waiting for N instance(s) to be deallocated 信息。查了下，大概就是程序没有对数据库连接释放，导致Connection泄露了。因为用的是开元集成的平台，内部程序也不可能一下子给改掉的，就验证一下咯。启动Tomcat,用户登录系统，用netstat -
    
                                
    • 
                                
  • 剖析如何与设计人员沟通
                                    不懂事的小屁孩
工作
                                    
    最近做图烦死了，不停的改图，改图……。烦，倒不是因为改，而是反反复复的改，人都会死。很多需求人员不知该如何与设计人员沟通，不明白如何使设计人员知道他所要的效果，结果只能是沟通变成了扯淡，改图变成了应付。 
 
那应该如何与设计人员沟通呢？ 
 
我认为设计人员与需求人员先天就存在语言障碍。对一个合格的设计人员来说，整天玩的都是点、线、面、配色，哪种构图看起来协调；哪种配色看起来合理心里跟明镜似的，
    
                                
    • 
                                
  • qq空间刷评论工具
                                    换个号韩国红果果
JavaScript
                                    
    

var a=document.getElementsByClassName('textinput');
					var b=[];
					for(var m=0;m<a.length;m++){
						if(a[m].getAttribute('placeholder')!=null)
							b.push(a[m])
					}
					var l
    
                                
    • 
                                
  • S2SH整合之session
                                    灵静志远
springAOPstrutssession
                                    
    错误信息： 
Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'cartService': Scope 'session' is not active for the current thread; consider defining a scoped
    
                                
    • 
                                
  • xmp标签
                                    a-john
标签
                                    
    今天在处理数据的显示上遇到一个问题： 
var html = '<li><div class="pl-nr"><span class="user-name">' + user
           + '</span>' + text + '</div></li>';
ulComme
    
                                
    • 
                                
  • Ajax的常用技巧（2）---实现Web页面中的级联菜单
                                    aijuans
Ajax
                                    
    在网络上显示数据，往往只显示数据中的一部分信息，如文章标题，产品名称等。如果浏览器要查看所有信息，只需点击相关链接即可。在web技术中，可以采用级联菜单完成上述操作。根据用户的选择，动态展开，并显示出对应选项子菜单的内容。 在传统的web实现方式中，一般是在页面初始化时动态获取到服务端数据库中对应的所有子菜单中的信息，放置到页面中对应的位置，然后再结合CSS层叠样式表动态控制对应子菜单的显示或者隐
    
                                
    • 
                                
  • 天-安-门，好高
                                    atongyeye
情感
                                    
        我是85后，北漂一族，之前房租1100，因为租房合同到期，再续，房租就要涨150。最近网上新闻，地铁也要涨价。算了一下，涨价之后，每次坐地铁由原来2块变成6块。仅坐地铁费用，一个月就要涨200。内心苦痛。 
 
    晚上躺在床上一个人想了很久，很久。 
   
    我生在农
    
                                
    • 
                                
  • android 动画
                                    百合不是茶
android透明度平移缩放旋转
                                    
    android的动画有两种  tween动画和Frame动画 
  
tween动画;,透明度,缩放,旋转,平移效果 
  
Animation   动画 
AlphaAnimation 渐变透明度 
RotateAnimation 画面旋转 
ScaleAnimation 渐变尺寸缩放 
TranslateAnimation 位置移动 
Animation
    
                                
    • 
                                
  • 查看本机网络信息的cmd脚本
                                    bijian1013
cmd
                                    
    @echo 您的用户名是：%USERDOMAIN%\%username%>"%userprofile%\网络参数.txt"
@echo 您的机器名是：%COMPUTERNAME%>>"%userprofile%\网络参数.txt"
@echo ___________________>>"%userprofile%\
    
                                
    • 
                                
  • plsql 清除登录过的用户
                                    征客丶
plsql
                                    
    tools---preferences----logon history---history  把你想要删除的删除 
 
 
-------------------------------------------------------------------- 
若有其他凝问或文中有错误，请及时向我指出， 
我好及时改正，同时也让我们一起进步。 
email ： binary_spac
    
                                
    • 
                                
  • 【Pig一】Pig入门
                                    bit1129
pig
                                    
    Pig安装 
1.下载pig 
  
wget http://mirror.bit.edu.cn/apache/pig/pig-0.14.0/pig-0.14.0.tar.gz 
  
2. 解压配置环境变量 
  
   如果Pig使用Map/Reduce模式，那么需要在环境变量中，配置HADOOP_HOME环境变量 
  
expor
    
                                
    • 
                                
  • Java 线程同步几种方式
                                    BlueSkator
volatilesynchronizedThredLocalReenTranLockConcurrent
                                    
    为何要使用同步？       java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），        将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，        从而保证了该变量的唯一性和准确性。    1.同步方法&
    
                                
    • 
                                
  • StringUtils判断字符串是否为空的方法（转帖）
                                    BreakingBad
nullStringUtils“”
                                    
    转帖地址：http://www.cnblogs.com/shangxiaofei/p/4313111.html 
  
public static boolean isEmpty(String str)      
　　判断某字符串是否为空，为空的标准是 str== 
null  
或 str.length()== 
0    
    
                                
    • 
                                
  • 编程之美-分层遍历二叉树
                                    bylijinnan
java数据结构算法编程之美
                                    
    

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LevelTraverseBinaryTree {

    /**
     * 编程之美 分层遍历二叉树
     * 之前已经用队列实现过二叉树的层次遍历，但这次要求输出换行，因此要
    
                                
    • 
                                
  • jquery取值和ajax提交复习记录
                                    chengxuyuancsdn
jquery取值ajax提交
                                    
    
// 取值
	// alert($("input[name='username']").val());
	// alert($("input[name='password']").val());
	// alert($("input[name='sex']:checked").val());
	// alert($("
    
                                
    • 
                                
  • 推荐国产工作流引擎嵌入式公式语法解析器-IK Expression
                                    comsci
java应用服务器工作Excel嵌入式
                                    
    这个开源软件包是国内的一位高手自行研制开发的，正如他所说的一样，我觉得它可以使一个工作流引擎上一个台阶。。。。。。欢迎大家使用，并提出意见和建议。。。 
----------转帖--------------------------------------------------- 
 IK Expression是一个开源的（OpenSource），可扩展的（Extensible），基于java语言
    
                                
    • 
                                
  • 关于系统中使用多个PropertyPlaceholderConfigurer的配置及PropertyOverrideConfigurer
                                    daizj
spring
                                    
    1、PropertyPlaceholderConfigurer 
Spring中PropertyPlaceholderConfigurer这个类，它是用来解析Java Properties属性文件值，并提供在spring配置期间替换使用属性值。接下来让我们逐渐的深入其配置。 
 
基本的使用方法是：(1) 
 
<bean id="propertyConfigurerForWZ&q
    
                                
    • 
                                
  • 二叉树:二叉搜索树
                                    dieslrae
二叉树
                                    
        所谓二叉树,就是一个节点最多只能有两个子节点,而二叉搜索树就是一个经典并简单的二叉树.规则是一个节点的左子节点一定比自己小,右子节点一定大于等于自己(当然也可以反过来).在树基本平衡的时候插入,搜索和删除速度都很快,时间复杂度为O(logN).但是,如果插入的是有序的数据,那效率就会变成O(N),在这个时候,树其实变成了一个链表. 
 
tree代码: 
 

    
                                
    • 
                                
  • C语言字符串函数大全
                                    dcj3sjt126com
cfunction
                                    
    C语言字符串函数大全 
  
  
函数名: stpcpy 
功 能: 拷贝一个字符串到另一个 
用 法: char *stpcpy(char *destin, char *source); 
程序例: 
  
#include <stdio.h> 
#include <string.h> 
  
int main
    
                                
    • 
                                
  • 友盟统计页面技巧
                                    dcj3sjt126com
技巧
                                    
    在基类调用就可以了, 基类ViewController示例代码 
-(void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];
    [MobClick beginLogPageView:[NSString stringWithFormat:@"%@",self.class]];

    
                                
    • 
                                
  • window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法
                                    flyvszhb
javajdk
                                    
    window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法 
 
本机已经安装了jdk1.7，而比较早期的项目需要依赖jdk1.6，于是同时在本机安装了jdk1.6和jdk1.7. 
 安装jdk1.6前，执行java -version得到 
C:\Users\liuxiang2>java -version 
java version "1.7.0_21&quo
    
                                
    • 
                                
  • Java在创建子类对象的同时会不会创建父类对象
                                    happyqing
java创建子类对象父类对象
                                    
      
1.在thingking in java 的第四版第六章中明确的说了，子类对象中封装了父类对象， 
  
2."When you create an object of the derived class, it contains within it a subobject of the base class. This subobject is the sam
    
                                
    • 
                                
  • 跟我学spring3 目录贴及电子书下载
                                    jinnianshilongnian
spring
                                    
      
  一、《跟我学spring3》电子书下载地址： 
《跟我学spring3》  （1-7 和 8-13） http://jinnianshilongnian.iteye.com/blog/pdf   
  
跟我学spring3系列 word原版 下载 
  
  二、
源代码下载  
最新依
    
                                
    • 
                                
  • 第12章 Ajax（上）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • BI and EIM 4.0 at a glance
                                    blueoxygen
BO
                                    
    http://www.sap.com/corporate-en/press.epx?PressID=14787 
  
有机会研究下EIM家族的两个新产品~~~~ 
  
New features of the 4.0 releases of BI and EIM solutions include:  
 
  Real-time in-memory computing – 
    
                                
    • 
                                
  • Java线程中yield与join方法的区别
                                    tomcat_oracle
java
                                    
    长期以来，多线程问题颇为受到面试官的青睐。虽然我个人认为我们当中很少有人能真正获得机会开发复杂的多线程应用(在过去的七年中，我得到了一个机会)，但是理解多线程对增加你的信心很有用。之前，我讨论了一个wait()和sleep()方法区别的问题，这一次，我将会讨论join()和yield()方法的区别。坦白的说，实际上我并没有用过其中任何一个方法，所以，如果你感觉有不恰当的地方，请提出讨论。 
&nb
    
                                
    • 
                                
  • android Manifest.xml选项
                                    阿尔萨斯
Manifest
                                    
    结构 
继承关系 
public final class Manifest extends Objectjava.lang.Objectandroid.Manifest 
内部类 
 
 
 class Manifest.permission权限 
 class Manifest.permission_group权限组 
 构造函数 
 
public Manifest () 详细  androi
    
                                
    • 
                                
  • Oracle实现类split函数的方
                                    zhaoshijie
oracle
                                    
    关键字：Oracle实现类split函数的方 
项目里需要保存结构数据，批量传到后他进行保存，为了减小数据量，子集拼装的格式，使用存储过程进行保存。保存的过程中需要对数据解析。但是oracle没有Java中split类似的函数。从网上找了一个，也补全了一下。 
 
CREATE OR REPLACE TYPE t_split_100 IS TABLE OF VARCHAR2(100); 
 
cr
    
                                
    •