奔跑者runner
奔跑者runner

springboot2.x 的 RedisCacheManager

redis介绍
Redis是目前业界使用最广泛的内存数据存储。相比memcached，Redis支持更丰富的数据结构，例如hashes, lists, sets等，同时支持数据持久化。除此之外，Redis还提供一些类数据库的特性，比如事务，HA，主从库。可以说Redis兼具了缓存系统和数据库的一些特性，因此有着丰富的应用场景。本文介绍Redis在Spring Boot中两个典型的应用场景。

如何使用
1、引入 spring-boot-starter-redis

org.springframework.boot spring-boot-starter-redis 2、添加配置文件 
# REDIS (RedisProperties)
# Redis数据库索引（默认为0）
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=192.168.0.58
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码（默认为空）
spring.redis.password=  
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8  
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1  
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8  

    # 连接池中的最小空闲连接

spring.redis.pool.min-idle=0  

    # 连接超时时间（毫秒）

spring.redis.timeout=0

springboot2.x 的 RedisCacheManager变化

由于最近在学着使用redis做缓存，使用的是springboot2.x来搭建的项目。
看了看网上的一些教程，但是大多数教程都是基于1.x的版本来讲解的，但是springboot2.x之后发生了一些变动，网上想找一些资料不太容易。

springboot配置缓存过期时间，网上大部分资料是使用ReidsCacheManager来进行自定义的配置
以下是大部分网上的代码（这也是基于springboot1.x的版本可以使用的）

@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate) {
    RedisCacheManager cacheManager= new RedisCacheManager(redisTemplate);
    cacheManager.setDefaultExpiration(60);
    Map expiresMap=new HashMap<>();
    expiresMap.put("Product",5L);
    cacheManager.setExpires(expiresMap);
    return cacheManager;
}

然而在springboot2.x中，RedisCacheManager已经没有了单参数的构造方法

@Configuration
@EnableCaching
public class RedisConfiguratioon extends CachingConfigurerSupport {

    @SuppressWarnings("rawtypes")
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration redisCacheConfiguration=RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(null);
        return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                .cacheDefaults(redisCacheConfiguration).build();
    }

    @Bean
    @SuppressWarnings({"rawtypes", "unchecked"})
    public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory){
        RedisTemplate redisTemplate=new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        //使用Jackson2JsonRedisSerializer替换默认的序列化规则
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper=new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);


        //设置value的序列化规则
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        //设置key的序列化规则
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

Example 1
Project: springboot_cwenao File: RedisConfig.java

@Bean(name="redisTemplate")
public RedisTemplate redisTemplate(RedisConnectionFactory factory) {

RedisTemplate template = new RedisTemplate<>();


RedisSerializer redisSerializer = new StringRedisSerializer();

Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);

template.setConnectionFactory(factory);
//key序列化方式
template.setKeySerializer(redisSerializer);
//value序列化
template.setValueSerializer(jackson2JsonRedisSerializer);
//value hashmap序列化
template.setHashValueSerializer(jackson2JsonRedisSerializer);

return template;

}

Example 2
Project: springboot_cwenao File: RedisConfig.java
@Bean(name=“redisTemplate”)
public RedisTemplate redisTemplate(RedisConnectionFactory factory) {

RedisTemplate template = new RedisTemplate<>();


RedisSerializer redisSerializer = new StringRedisSerializer();

Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);

template.setConnectionFactory(factory);
//key序列化方式
template.setKeySerializer(redisSerializer);
//value序列化
template.setValueSerializer(jackson2JsonRedisSerializer);
//value hashmap序列化
template.setHashValueSerializer(jackson2JsonRedisSerializer);

return template;

}

Example 3
Project: springboot_op File: RedisConfiguration.java

/**
 * RedisTemplate配置
 * @param factory
 * @return
 */
@Bean
@SuppressWarnings({"rawtypes", "unchecked"})
public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
    StringRedisTemplate template = new StringRedisTemplate(factory);
    //定义value的序列化方式
    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    
    template.setValueSerializer(jackson2JsonRedisSerializer);
    template.setHashValueSerializer(jackson2JsonRedisSerializer);
    template.afterPropertiesSet();
    return template;
}

Example 4
Project: JavaQuarkBBS File: RedisConfig.java

@SuppressWarnings("rawtypes")
@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate) {
    RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
    //设置缓存过期时间
    //rcm.setDefaultExpiration(60);//秒
    return rcm;
}

Example 5
Project: springboot-smart File: RedisConfiguration.java

@Bean("redisTemplate")  //新家的这个注解 10-26 12:06
@SuppressWarnings({ "rawtypes", "unchecked" })
public RedisTemplate redisTemplate(RedisConnectionFactory redisFactory){
	StringRedisTemplate template = new StringRedisTemplate(redisFactory);
	Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new 
			Jackson2JsonRedisSerializer(Object.class);
	
	ObjectMapper om = new ObjectMapper();
	om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
	om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
	jackson2JsonRedisSerializer.setObjectMapper(om);
	
	template.setValueSerializer(jackson2JsonRedisSerializer);
	template.afterPropertiesSet();
	return template;
}

Example 6
Project: action File: RedisUtil.java

@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) {
    RedisTemplate template = new RedisTemplate<>();
    template.setConnectionFactory(connectionFactory);

    //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
    Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);

    ObjectMapper mapper = new ObjectMapper();
    mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    serializer.setObjectMapper(mapper);

    template.setValueSerializer(serializer);
    //使用StringRedisSerializer来序列化和反序列化redis的key值
    template.setKeySerializer(new StringRedisSerializer());
    template.afterPropertiesSet();
    return template;
}

Example 7
Project: keti File: AttributeCacheFactory.java

private AttributeCache createAttributeCache(final String cacheType, final long maxCachedIntervalMinutes,
        final String zoneName, final RedisTemplate cacheRedisTemplate,
        final BiFunction getKey, final boolean enableAttributeCaching) {
    String[] profiles = environment.getActiveProfiles();

    if (!enableAttributeCaching) {
        LOGGER.info("Caching disabled for {} attributes.", cacheType);
        return new NonCachingAttributeCache();
    }
    if (ArrayUtils.contains(profiles, "redis") || ArrayUtils.contains(profiles, "cloud-redis")) {
        LOGGER.info("Redis caching enabled for {} attributes.", cacheType);
        return new RedisAttributeCache(maxCachedIntervalMinutes, zoneName, getKey, cacheRedisTemplate);
    }
    LOGGER.info("In-memory caching enabled for {} attributes.", cacheType);
    return new InMemoryAttributeCache(maxCachedIntervalMinutes, zoneName, getKey);
}

Example 8
Project: storm_spring_boot_demo File: RedisConfUtils.java

public static RedisTemplate buildRedisTemplate(byte[] redisProperties){
    JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(
            RedisConfUtils.getClusterConfiguration(
                    (RedisProperties) Serializer.INSTANCE.deserialize(redisProperties)));
    RedisTemplate redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(jedisConnectionFactory);
    jedisConnectionFactory.afterPropertiesSet();

    GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
    StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    redisTemplate.setKeySerializer(stringRedisSerializer);
    redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
    redisTemplate.setHashKeySerializer(stringRedisSerializer);
    redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
    redisTemplate.afterPropertiesSet();
    return redisTemplate;
}

Example 9
Project: ait-platform File: AitCacheConfigBase.java

@Bean
@Primary
RedisTemplate redisTemplate(RedisConnectionFactory rcf) {
	AitLogger.debug(logger, "Serializer overriding ");

	RedisTemplate template = new RedisTemplate<>();
	template.setConnectionFactory(rcf);

	GenericJackson2JsonRedisSerializer valSerializer = new GenericJackson2JsonRedisSerializer();

	template.setValueSerializer(valSerializer);
	template.setKeySerializer(new RedisSerializer() {

		@Override
		public byte[] serialize(Object t) throws SerializationException {
			return (t == null ? null : (":" + t.toString()).getBytes());
		}

		@Override
		public Object deserialize(byte[] bytes) throws SerializationException {
			return (bytes == null ? null : new String(bytes));
		}
	});
	template.setHashValueSerializer(valSerializer);
	return template;
}
 
  
Example 10
 Project: data-migration File: RedisConfiguration.java
 
  
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) {
    RedisTemplate template = new RedisTemplate<>();
    template.setConnectionFactory(connectionFactory);

    //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
    Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);

    ObjectMapper mapper = new ObjectMapper();
    mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    serializer.setObjectMapper(mapper);

    template.setValueSerializer(serializer);
    //使用StringRedisSerializer来序列化和反序列化redis的key值
    template.setKeySerializer(new StringRedisSerializer());
    template.afterPropertiesSet();
    return template;
}

 
  
Example 11
 Project: happylifeplat-transaction File: RedisClusterConfig.java
 
  
@Bean
public RedisTemplate getStringRedisTemplate() {
    StringRedisTemplate clusterTemplate = new StringRedisTemplate();
    clusterTemplate.setConnectionFactory(jedisConnectionFactory());
    clusterTemplate.setKeySerializer(new StringRedisSerializer());
    clusterTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    return clusterTemplate;
}

 
  
Example 12
 Project: JavaStudy File: Test.java View source code
 
  
@org.junit.Test
public void test(){
    String  user_prefix="user_";
    User user=new User(1,"aric");
    ApplicationContext atc=new AnnotationConfigApplicationContext(RedisStartConfig.class);
    RedisTemplate obj = (RedisTemplate) atc.getBean("redisTemplate");
    PrinterUtils.printILog(obj.getKeySerializer());
    obj.opsForValue().set(user_prefix+user.getId(),user);
    RedisSentinelConfiguration RedisSentinelConfiguration = (RedisSentinelConfiguration) atc.getBean("sentinelConfig");
    PrinterUtils.printILog(RedisSentinelConfiguration);
    User value=obj.opsForValue().get(user_prefix+1);
    PrinterUtils.printELog(value.getUsername());
}

 
  
Example 13
 Project: springboot-shiro-cas-mybatis File: RedisConfig.java
 
  
@SuppressWarnings({"unchecked","rawtypes"})
@Bean  
   public RedisTemplate redisTemplate(  
           RedisConnectionFactory factory) {  
       StringRedisTemplate template = new StringRedisTemplate(factory);  
	Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);  
       ObjectMapper om = new ObjectMapper();  
       om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
       om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);  
       jackson2JsonRedisSerializer.setObjectMapper(om);  
       template.setValueSerializer(jackson2JsonRedisSerializer);  
       template.afterPropertiesSet();  
       return template;  
   }

 
  
Example 14
 Project: springboot-shiro-cas-mybatis File: RedisConfig.java
 
  
@SuppressWarnings({"unchecked","rawtypes"})
@Bean  
   public RedisTemplate redisTemplate(  
           RedisConnectionFactory factory) {  
       StringRedisTemplate template = new StringRedisTemplate(factory);  
	Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);  
       ObjectMapper om = new ObjectMapper();  
       om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
       om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);  
       jackson2JsonRedisSerializer.setObjectMapper(om);  
       template.setValueSerializer(jackson2JsonRedisSerializer);  
       template.afterPropertiesSet();  
       return template;  
   }

 
  
Example 15
 Project: parrot-rest File: ApplicationTestConfiguration.java
 
  
@Bean
public RedisTemplate redisTemplate() {
    @SuppressWarnings("unchecked")
	RedisTemplate template = mock(RedisTemplate.class);
    opsHash = new HashOperationsMock();
	when(template.opsForHash()).thenReturn(opsHash);
    return template;
}

 
  
Example 16
 Project: JavaQuarkBBS File: RedisConfig.java
 
  
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
    StringRedisTemplate template = new StringRedisTemplate(factory);
    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    template.setValueSerializer(jackson2JsonRedisSerializer);
    template.afterPropertiesSet();
    return template;
}

 
  
Example 17
 Project: JavaQuarkBBS File: RedisConfig.java
 
  
@SuppressWarnings("rawtypes")
@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate) {
    RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
    //设置缓存过期时间
    //rcm.setDefaultExpiration(60);//秒
    return rcm;
}

 
  
Example 18
 Project: lemcloud File: RedisConfig.java
 
  
@SuppressWarnings({ "unchecked", "rawtypes" })
  private void setSerializer(RedisTemplate template) {
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
      ObjectMapper om = new ObjectMapper();
      om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
      om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
      jackson2JsonRedisSerializer.setObjectMapper(om);
      template.setKeySerializer(new StringRedisSerializer());
      //template.setValueSerializer(jackson2JsonRedisSerializer);		//-- 值序列化为json
      template.setValueSerializer(new RedisObjectSerializer());       //-- 默认序列化为byte[]
  }

 
  
Example 19
 Project: iBase4J-Common File: RedisHelper.java
 
  
@SuppressWarnings("unchecked")
public void setRedisTemplate(RedisTemplate redisTemplate) {
    this.redisTemplate = redisTemplate;
    this.keySerializer = (RedisSerializer)redisTemplate.getKeySerializer();
    this.valueSerializer = (RedisSerializer)redisTemplate.getValueSerializer();
    CacheUtil.setCacheManager(this);
}
 
  
Example 20
 Project: iBase4J-Common File: JedisConfig.java
 
  
@Bean
@Qualifier("redisTemplate")
public CacheManager redisCacheManager(RedisTemplate redisTemplate) {
    RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
    cacheManager.setTransactionAware(true);
    cacheManager.setDefaultExpiration(PropertiesUtil.getInt("redis.expiration", 10));
    return cacheManager;
}

 
  
Example 21
 Project: neto File: AppConfig.java View source code
 
  
private RedisTemplate jsonRedisTemplate(JedisConnectionFactory jedisConnectionFactory, Class clazz) {
    RedisTemplate template = new RedisTemplate();
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(new Jackson2JsonRedisSerializer(clazz));
    template.setHashKeySerializer(new StringRedisSerializer());
    template.setHashValueSerializer(new Jackson2JsonRedisSerializer(clazz));
    template.setConnectionFactory(jedisConnectionFactory);
    return template;
}

 
  
Example 22
 Project: tx-lcn File: JedisClusterConfig.java
 
  
@Bean
public RedisTemplate redisTemplateFactory(){
    RedisTemplate redisTemplate =new RedisTemplate();
    redisTemplate.setConnectionFactory(jedisConnectionFactory());

    //指定具体序列化方式  不过这种方式不是很好,一个系统中可能对应值的类型不一样,如果全部使用StringRedisSerializer 序列化
    //会照成其他类型报错,所以还是推荐使用第一种,直接指定泛型的类型,spring 会根据指定类型序列化。
    //redisTemplate.setKeySerializer( new StringRedisSerializer());
    //redisTemplate.setValueSerializer(new StringRedisSerializer());
    //redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    //redisTemplate.setHashValueSerializer(new StringRedisSerializer());
    return redisTemplate;
}

 
  
Example 23
 Project: xproject File: RedisCache.java
 
  
public RedisCache(String cacheName, RedisTemplate redisTemplate, boolean cacheExpire,
		int cacheExpireSeconds, String cacheKeyPrefix) {
	super();
	Assert.hasText(cacheName, "Parameter 'cacheName' can not be empty!");
	Assert.notNull(redisTemplate, "Parameter 'redisTemplate' can not be null!");
	Assert.isTrue(cacheExpireSeconds > 0, "Parameter 'cacheExpireSeconds' must be > 0!");
	this.cacheName = cacheName;
	this.redisTemplate = redisTemplate;
	this.cacheExpire = cacheExpire;
	this.cacheExpireSeconds = cacheExpireSeconds;
	this.cacheKeyPrefix = cacheKeyPrefix;
}

 
  
Example 24
 Project: automat File: RedisHelper.java
 
  
@SuppressWarnings("unchecked")
private RedisTemplate getRedis() {
    if (redisTemplate == null) {
        synchronized (RedisHelper.class) {
            if (redisTemplate == null) {
                redisTemplate = (RedisTemplate)applicationContext
                        .getBean("redisTemplate");
            }
        }
    }
    return redisTemplate;
}

 
  
Example 25
 Project: spring-data-examples File: ApplicationConfiguration.java
 
  
@Bean
RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) {

	RedisTemplate template = new RedisTemplate();
	template.setConnectionFactory(connectionFactory);

	return template;
}

 
  
Example 26
 Project: filter File: JedisClusterConfig.java
 
  
@Bean
    public RedisTemplate redisTemplateFactory(){
        RedisTemplate redisTemplate =new RedisTemplate();
        redisTemplate.setConnectionFactory(jedisConnectionFactory());

        //指定具体序列化方式  不过这种方式不是很好,一个系统中可能对应值的类型不一样,如果全部使用StringRedisSerializer 序列化
        //会照成其他类型报错,所以还是推荐使用第一种,直接指定泛型的类型,spring 会根据指定类型序列化。
//        redisTemplate.setKeySerializer( new StringRedisSerializer());
//        redisTemplate.setValueSerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }

 
  
Example 27
 Project: OutsourcedProject File: RedisConfig.java
 
  
@Bean
public  RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    RedisTemplate template = new RedisTemplate<>();
    template.setConnectionFactory(redisConnectionFactory);
    template.setKeySerializer(new StringRedisSerializer());
    template.setHashKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
    template.setEnableTransactionSupport(true);
    template.afterPropertiesSet();
    return template;
}

 
  
Example 28
 Project: MI-S File: RedisConfig.java
 
  
@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate){
    RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
    //设置缓存过期时间
    //rcm.setDefaultExpiration(60);//秒
    return rcm;
}

 
  
Example 29
 Project: boot-mon File: BootmonServerRedisConfig.java
 
  
@Bean
public RedisTemplate redisTemplate() {
    final RedisTemplate template = new RedisTemplate();
    template.setConnectionFactory(jedisConnectionFactory());
    template.setValueSerializer(new GenericToStringSerializer(Object.class));
    return template;
}
 
  
Example 30
 Project: bird-java File: RedisCacher.java V
 
  
@SuppressWarnings("unchecked")
private RedisTemplate getRedis() {
    if (redisTemplate == null) {
        synchronized (RedisCacher.class) {
            if (redisTemplate == null) {
                redisTemplate = (RedisTemplate)applicationContext
                        .getBean("redisTemplate");
            }
        }
    }
    return redisTemplate;
}`在这里插入代码片`

 
  
Example 31
 Project: shoucang File: RedisConfiguration.java
 
  
@Bean(name = "redisListTemplate")
RedisTemplate redisListTemplate() {
    RedisTemplate redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(jedisConnectionFactory());
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setValueSerializer(new GenericToStringSerializer<>(Long.class));
    return redisTemplate;
}

 
  
`
 
  

Example 32
Project: shoucang   File: RedisConfiguration.java   View source code	5 votes	vote down vote up
@Bean(name = "redisCountingTemplate")
RedisTemplate redisCountingTemplate() {
    RedisTemplate redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(jedisConnectionFactory());
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashValueSerializer(new GenericToStringSerializer<>(Integer.class));
    return redisTemplate;
}
 
Example 33
Project: raven   File: CacheService.java   View source code	5 votes	vote down vote up
/** 查询huawei accessToken */
public AccessToken getHuaweiAK()
{
    Cache redisCache1101 = commonCacheManager.getCache("redisCache1101");
    @SuppressWarnings("unchecked")
    RedisTemplate template = (RedisTemplate)redisCache1101.getNativeCache();
    Set keys = template.keys(CacheKeyPrefixConst.HW_ACCESS_TOKEN);

    if (null == keys || keys.isEmpty())
    {
        return null;
    }

    return redisCache1101.get(keys.iterator().next(), AccessToken.class);
}
 
Example 34
Project: DanmuChat   File: RedisConfig.java   View source code	5 votes	vote down vote up
@SuppressWarnings("rawtypes")
@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate){
    RedisCacheManager redisCacheManager =new RedisCacheManager(redisTemplate);
    //设置缓存过期时间
    redisCacheManager.setDefaultExpiration(60);//秒
    return redisCacheManager;
}
 
Example 35
Project: DanmuChat   File: RedisConfig.java   View source code	5 votes	vote down vote up
/**
 * 序列化设置
 */
private void initRedisTemplate(RedisTemplate redisTemplate, RedisConnectionFactory factory) {
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
    redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
    redisTemplate.setConnectionFactory(factory);
}
 
Example 36
Project: spring-boot-start-current   File: SpringCacheConfig.java   View source code	5 votes	vote down vote up
@Bean
public CacheManager cacheManager ( RedisTemplate redisTemplate ) {
	RedisCacheManager redisCacheManager = new RedisCacheManager( redisTemplate );
	// 默认30分钟
	redisCacheManager.setDefaultExpiration( defaultExpiration );
	redisCacheManager.setExpires( expires );
	redisCacheManager.setUsePrefix( usePrefix );
	return redisCacheManager;
}
 
Example 37
Project: keti   File: RedisAttributeCache.java   View source code	5 votes	vote down vote up
RedisAttributeCache(final long maxCachedIntervalMinutes, final String zoneName,
        final BiFunction getKey,
        final RedisTemplate resourceCacheRedisTemplate) {
    this.maxCachedIntervalMinutes = maxCachedIntervalMinutes;
    this.zoneName = zoneName;
    this.getKey = getKey;
    this.resourceCacheRedisTemplate = resourceCacheRedisTemplate;
}
 
Example 38
Project: keti   File: CommonRedisConfig.java   View source code	5 votes	vote down vote up
private RedisTemplate createCacheRedisTemplate(final RedisConnectionFactory redisConnectionFactory,
        final String redisTemplateType) {
    RedisTemplate redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(redisConnectionFactory);
    redisTemplate.setDefaultSerializer(new StringRedisSerializer());
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setValueSerializer(new StringRedisSerializer());
    LOGGER.info("Successfully created {} Redis template.", redisTemplateType);
    return redisTemplate;
}
 
Example 39
Project: storm_spring_boot_demo   File: RedisConfig.java   View source code	5 votes	vote down vote up
@Bean("redisTemplate")
public RedisTemplate getRedisTemplate(){
    RedisTemplate template = new StringRedisTemplate(jedisConnectionFactory);
    GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
    StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    template.setKeySerializer(stringRedisSerializer);
    template.setValueSerializer(genericJackson2JsonRedisSerializer);
    template.setHashKeySerializer(stringRedisSerializer);
    template.setHashValueSerializer(genericJackson2JsonRedisSerializer);
    return template;
}
 
Example 40
Project: xq_seckill_microservice   File: CachingConfig.java   View source code	5 votes	vote down vote up
@Bean
public RedisTemplate byteRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
    RedisTemplate redisTemplate = new RedisTemplate();
    redisTemplate.setConnectionFactory(redisConnectionFactory);
    redisTemplate.setEnableDefaultSerializer(true);
    //redisTemplate.setDefaultSerializer(new StringRedisSerializer());
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    //redisTemplate.setValueSerializer(new StringRedisSerializer());
    //redisTemplate.setEnableTransactionSupport(true);
    redisTemplate.afterPropertiesSet();
    return redisTemplate;
}
 



 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java缓存)

        

            

                
    
                    
  • java缓存管理，一级缓存和二级缓存
                        Luffyying
java
                        
    一级缓存的生命周期和SqlSession的生命周期相同二级缓存和整个应用的生命周期相同一级缓存存放的结果不是查询出的结果本身，而是一个Map【无法关闭//一级缓存中底层实现是一个Map//key：statementId和sql语句//value：查询结果//包含查询结果本身，还和sql语句statement的ID有关系增删改会刷新一级缓存执行插入会对缓存造成影响，无论是否对sqlSession进行
    
                    
    • 
                    
  • ExpiringMap：轻量级的Java缓存方式
                        programmer_山风
JAVA基础缓存java开发语言
                        
    一、ExpiringMap具有高性能、低开销、零依赖、线程安全、使用ConcurrentMap的实现过期entries等优点。其主要特点包括：过期策略、可变有效期、最大尺寸、侦听器过期、延迟输入加载、过期自省等。二、基本功能1、可设置Map中的Entry在一段时间后自动过期。2、可设置Map最大容纳值，当到达Maximumsize后，再次插入值会导致Map中的第一个值过期。3、可添加监听事件，在监
    
                    
    • 
                    
  • 性能利器Caffeine缓存全面指南
                        宋小黑
缓存java
                        
    第1章：引言大家好，我是小黑，今天咱们聊聊Caffeine缓存，小黑在网上购物，每次查看商品都要等几秒钟，那体验肯定不咋地。但如果用了缓存，常见的商品信息就像放在口袋里一样，随时取用，速度自然就快多了。这就是缓存的魔力，它通过存储临时数据，减少数据库的重复读写，提升系统的响应速度和性能。在Java里，Caffeine缓存是一个现代化的、高性能的Java缓存库，用起来既方便又快捷。相比于老牌的Gua
    
                    
    • 
                    
  • Java缓存介绍
                        xmh-sxh-1314
java
                        
    一、什么是缓存1、Cache是高速缓冲存储器一种特殊的存储器子系统，其中复制了频繁使用的数据以利于快速访问2、凡是位于速度相差较大的两种硬件/软件之间的，用于协调两者数据传输速度差异的结构，均可称之为Cache二、缓存的分类1、基于web应用的系统架构图2、在系统架构的不同层级之间，为了加快访问速度，都可以存在缓存操作系统磁盘缓存->减少磁盘机械操作数据库缓存->减少文件系统I/O应用程序缓存->
    
                    
    • 
                    
  • Java缓存优化
                        代码有点萌
java缓存开发语言
                        
    缓存优化环境配置配置yml文件中的redismaven导入redis缓存菜品数据先从redis获取数据，如果有直接返回;没有的话从数据库中找，把数据放入到redis中。更新菜品数据时(或者数据库中的数据变化时)，需要清理缓存数据。SpringCache在启动类中添加@EnableCaching注解，以开启缓存注解功能。这样可以在应用程序中使用缓存相关的注解。@Cacheable会在方法执行前先检查
    
                    
    • 
                    
  • 缓存框架Ehcache的介绍，且与Springboot的集成
                        OYMN
缓存springboot后端ehcache
                        
    文章目录一、前言二、核心特性三、架构与工作原理四、性能优化五、与Springboot集成六、xml文件的相关配置一、前言缓存技术在现代软件开发中扮演着越来越重要的角色，作为一个成熟的开源Java缓存库，Ehcache在提高应用性能、减少数据库负载、加速用户体验方面占有一席之地。本篇博客将全方位多角度地深入理解Ehcache，帮助大家把握其核心功能、实现原理及应用实例。Ehcache是一个纯Java
    
                    
    • 
                    
  • Java 缓存中间件
                        码农小旋风
后端
                        
    Java缓存中间件关键词：SpringCache、J2Cache、JetCache一、JSR107JSR107中制订了Java缓存的规范。因此，在很多缓存框架、缓存库中，其API都参考了JSR107规范。imgJavaCaching定义了5个核心接口CachingProvider-定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可以在运行期访问多个CachingProvid
    
                    
    • 
                    
  • Apache Commons JCS缓存解决方案
                        宋小黑
ApacheCommons工具实战手册apache缓存java
                        
    第1章：引言大家好，我是小黑！今天，咱们来聊聊ApacheCommonsJCS，一个Java界里的缓存大杀器。缓存技术，对于提高应用性能来说，就像是给它加了一剂兴奋剂，能让数据访问变得快如闪电。而ApacheCommonsJCS，作为一个开源的Java缓存框架，它的出现就像是给了咱们一个超级工具箱，不仅强大而且使用方便。咱们为什么要选用JCS呢？因为它不仅功能全面，而且还能跟各种应用环境无缝配合，
    
                    
    • 
                    
  • Java缓存框架Caffeine详解
                        酱学编程
java缓存spring
                        
    Java缓存框架Caffeine详解介绍缓存在现代软件开发中扮演着重要的角色，能够显著提高应用程序的性能和响应速度。Caffeine是一个高性能的Java缓存库，旨在提供快速、高效的内存缓存解决方案。1.Caffeine简介1.1Caffeine概述Caffeine是一个基于Java8+的现代化缓存库，其特点是高性能、内存友好和可扩展性强。它使用了许多优化技术来减少缓存的内存占用和提高缓存访问速度
    
                    
    • 
                    
  • Java缓存规范
                        动力节点IT教育
Java自学教程java缓存开发语言
                        
    字典服务的设计与管理方法字典服务通常是一种标准的API服务，提供了一系列的功能接口，以方便对字典数据的查询、检索和更新。下面介绍一下字典服务的设计和管理方法。定义API接口：字典服务需要定义标准的API接口，以明确数据的结构和服务的功能。其中，输入输出参数应该清晰明确，以便于客户端开发人员快速理解应用。例如，一个字典服务的API接口可能包括以下内容：queryWord：输入参数为目标单词和相关选项
    
                    
    • 
                    
  • Redis事务、Redis与Memcached的区别
                        一只IT攻城狮
#《Redis必知必会》系列redismemcached分布式缓存
                        
    文章目录一、缓存分类二、Redis与Memcached的区别1、线程模型2、数据结构3、淘汰策略4、持久化5、高可用6、集群化三、Redis虚拟内存机制四、Redis事务机制1、Redis事务机制2、redis事务命令3、事务3阶段4、redis的事务特性一、缓存分类首先了解下Java缓存分类：本地缓存：Ehcache、GuavaCache、Caffeine等分布式缓存：Redis、Memcach
    
                    
    • 
                    
  • java缓存——（一）服务器本地缓存ehcache、guava cache和Caffeine
                        weixin_30241919
java大数据
                        
    在多线程高并发场景中往往是离不开cache的，需要根据不同的应用场景来需要选择不同的cache，比如分布式缓存如redis、memcached，还有本地（进程内）缓存如ehcache、GuavaCache、Caffeine、LocalCache等。一、ehcache在Java项目广泛的使用。它是一个开源的、设计于提高在数据从RDBMS中取出来的高花费、高延迟采取的一种缓存方案。正因为Ehcache
    
                    
    • 
                    
  • 基于内存和 Redis 的两级 Java 缓存框架！
                        程序员大咖
linuxjavaredispython大数据
                        
    关注后回复“进群”，拉你进程序员交流群Java两级缓存框架，可以让应用支持两级缓存框架ehcache(Caffeine)+redis。避免完全使用独立缓存系统所带来的网络IO开销问题基于内存和Redis的两级Java缓存框架J2Cache第一级缓存使用内存(同时支持Ehcache2.x、Ehcache3.x和Caffeine)，第二级缓存使用Redis(推荐)/Memcached。由于大量的缓存读
    
                    
    • 
                    
  • SpringBoot 如何使用 Ehcache 作为缓存？
                        硬件人某某某
SpringBoot教程springboot缓存spring
                        
    SpringBoot如何使用Ehcache作为缓存？在现代的应用程序中，缓存是一个非常重要的概念。缓存可以帮助我们加速应用程序的响应时间，减少数据库或其他服务的负载，并提高系统的可扩展性和容错性。SpringFramework提供了强大的缓存抽象，使得我们可以轻松地使用各种缓存技术，包括Ehcache。Ehcache是一个流行的Java缓存库，它提供了快速、可靠的内存缓存和分布式缓存功能。在本文中
    
                    
    • 
                    
  • 在SpringBoot中使用EhCache缓存
                        Miaow.Y.Hu
#Springspringboot缓存spring
                        
    在使用EhCache缓存之前，我们需要了解的是EhCache缓存是啥？Ehcache的概述Ehcache是一个开源的Java缓存框架，用于提供高效的内存缓存解决方案，他可以用于缓存各种类型的数据，包括对象，查询结果，方法调用的结果等。Ehcache具有以下特点:内存缓存：Ehcache主要用于将数据存储在内存中，用以提供更快速的访问速度，他使用内存管理技术，可以有效的管理缓存中的对象。可拓展性：E
    
                    
    • 
                    
  • JAVA缓存规范 —— 虽迟但到的JCache API与天生不俗的Spring Cache
                        架构悟道
缓存原理与实战设计javaspring缓存架构
                        
    大家好，又见面了。本文是笔者作为掘金技术社区签约作者的身份输出的缓存专栏系列内容，将会通过系列专题，讲清楚缓存的方方面面。如果感兴趣，欢迎关注以获取后续更新。有诗云“纸上得来终觉浅，绝知此事要躬行”，在上一篇文章《手写本地缓存实战2——打造正规军，构建通用本地缓存框架》中，我们一起论证并逐步实现了一套简化版本的通用本地缓存框架，并在过程中逐步剖析了缓存设计关键要素的实现策略。本篇文章中，我们一起来
    
                    
    • 
                    
  • java架构学习——29. Redis基础与高级
                        wmq_fly
java架构学习Redis主从复制Redis哨兵机制Redis持久化Redis发布订阅
                        
    本篇博文主要包含：OsCache与EhCache区别JVM缓存的缺点NoSQL介绍Redis简介Redis应用场景Redis优势Redis主从复制（部署一主多备实例）Redis哨兵机制（含实例）Redis持久化-RDB持久化-AOF持久化-AOF与RDB区别Redis发布订阅一、概述Java缓存机制Java中要用到缓存的地方很多，首当其冲的就是持久层缓存，针对持久层谈一下：要实现java缓存有很多
    
                    
    • 
                    
  • JAVA缓存机制
                        chenqqabcdchenqqabcd
杂谈
                        
    缓存可分为二大类:一、通过文件缓存,顾名思义文件缓存是指把数据存储在磁盘上，不管你是以XML格式，序列化文件DAT格式还是其它文件格式；二、内存缓存，也就是实现一个类中静态Map,对这个Map进行常规的增删查.下面为一个简单的缓存代码Java代码packagelhm.hcy.guge.frameset.cache;importjava.util.*;/***Title:**Description:
    
                    
    • 
                    
  • 获取缓存数据修改后，缓存中的值也修改问题
                        free spark
JAVAJAVA缓存cache
                        
    获取缓存数据修改后，缓存中的值也修改问题JAVA缓存，获取数据后修改，缓存中的数值也会修改，解决方法是创建新的对象再修改值比如使用BeanUtils.copyProperties()方法。如果值是List，可以使用两种方法解决1、循环List，创建新List,使用BeanUtils.copyProperties()方法赋值2、使用newList=JSON.parseArray(JSON.toJSO
    
                    
    • 
                    
  • 获取本地缓存数据修改后，本地缓存中的值也修改问题
                        IT枫斗者
JAVA基础工作中实际总结缓存java数据库windows服务器
                        
    获取本地缓存数据修改后，本地缓存中的值也修改问题JAVA缓存，获取数据后修改，缓存中的数值也会修改，解决方法是创建新的对象再修改值比如使用BeanUtils.copyProperties()方法。如果值是List，可以使用两种方法解决循环List，创建新List,使用BeanUtils.copyProperties()方法赋值使用newList=JSON.parseArray(JSON.toJSO
    
                    
    • 
                    
  • Integer 缓存机制
                        冷风扇666
java
                        
    在Java中，Integer类型的对象有一个缓存机制，它会缓存一定范围内的整数值，以提高性能和减少内存占用。这个缓存机制是针对Integer类型的封装类而言的，对于原始的int类型没有这种缓存。以下是关于Integer缓存的一些重要信息：范围：默认情况下，Java缓存了范围为-128到127的整数对象。这意味着在这个范围内创建的Integer对象会被缓存，而不是每次都创建新的对象。这个范围可以通过
    
                    
    • 
                    
  • 【Java缓存】demo01-了解缓存Cache+实现Spring缓存实例
                        清晨敲代码
SpringCache缓存缓存springjavaspringboot
                        
    目录1.介绍1.1什么是缓存？1.2web应用的缓存分类1.2.1基于web应用的系统架构图1.2.2基于web应用的缓存分类1.2.3应用程序缓存2.Java缓存2.1基于Map实现2.1.1创建Maven项目准备父项目环境2.1.2准备子项目环境和service类2.1.3准备Test测试3.SpringCache缓存3.1基于SpringCache实现3.1.1准备子项目并添加service
    
                    
    • 
                    
  • Java本地缓存框架Caffeine介绍
                        xmh-sxh-1314
java
                        
    Caffeine是一个进程内部缓存框架，使用了Java8最新的[StampedLock]乐观锁技术，极大提高缓存并发吞吐量，一个高性能的Java缓存库，被称为最快缓存。缓存简介（一）缓存对比从横向对常用的缓存进行对比，有助于加深对缓存的理解，有助于提高技术选型的合理性。下面对比三种常用缓存：Redis、EhCache、Caffeine。1、序列化缓存序列化原因Redis必须实现序列化进程间数据传输
    
                    
    • 
                    
  • 缓存之缓存简介
                        爱穿背带裤的馫
缓存缓存redis本地缓存分布式缓存数据不一致性
                        
    目录一.缓存的作用二.缓存的使用1.适用缓存的数据场景2.读取缓存流程图三.本地缓存和分布式缓存一.缓存的作用Java缓存技术是在应用程序和数据库之间的一种中间层,用于存储暂时性数据,尤其是读取频繁但更新较少的数据。它的作用是减轻应用程序和数据库之间的负担,提高应用程序的响应速度和性能。二.缓存的使用1.适用缓存的数据场景(1)对即时性、数据一致性要求不高的。(2)访问量大并且更新频率不高的数据(
    
                    
    • 
                    
  • 本地缓存无冕之王Caffeine Cache
                        
后端缓存
                        
    本文已收录至GitHub，推荐阅读Java随想录微信公众号：Java随想录原创不易，注重版权。转载请注明原作者和原文链接在常规的软件开发流程中，缓存的重要性日益凸显。它不仅为用户带来了更迅速的反馈时间，还能在大多数情况下有效减轻系统负荷。本篇文章将详述一个本地缓存框架：「CaffeineCache」。CaffeineCache以其高性能和可扩展性赢得「本地缓存之王」的称号，它是一个Java缓存库。
    
                    
    • 
                    
  • JAVA缓存规范—JCache API与Spring Cache
                        Java_LingFeng
java缓存spring
                        
    为何需要规范构建的最简化版本的缓存框架，虽然可以使用，但是也存在一个问题，就是它对外提供的实现接口都是框架根据自己的需要而自定义的。这样一来，项目集成了此缓存框架，后续如果想要更换缓存框架的时候，业务层面的改动会比较大。——因为是自定义的框架接口，无法基于里氏替换原则来进行灵活的更换。在业界各大厂商或者开源团队都会构建并提供一些自己实现的缓存框架或者组件，提供给开发者按需选择使用。如果大家都是各自
    
                    
    • 
                    
  • Java缓存理解
                        xmh-sxh-1314
java
                        
    CPU占用：如果你有某些应用需要消耗大量的cpu去计算，比如正则表达式，如果你使用正则表达式比较频繁，而其又占用了很多CPU的话，那你就应该使用缓存将正则表达式的结果给缓存下来。数据库IO性能：如果发现有大量数据需要频繁查询使用，或者某些数据不会频繁变更时，为了提高数据库IO性能，可以使用缓存缓存定义所谓缓存，就是将程序或系统经常要调用的对象存在内存中，一遍其使用时可以快速调用，不必再去创建新的重
    
                    
    • 
                    
  • 面试题之java缓存总结，从单机缓存到分布式缓存架构
                        一只程序猿哟

                        
    1、缓存定义高速数据存储层，提高程序性能2、为什么要用缓存（读多写少，高并发）1、提高读取吞吐量2、提升应用程序性能3、降低数据库成本4、减少后端负载5、消除数据库热点6、可预测的性能3、缓存分类3.1、单机缓存（localCache）实现方案1、基于JSR107规范自研（了解即可）：1、JavaCaching定义了5个核心接口，分别是CachingProvider,CacheManager,Ca
    
                    
    • 
                    
  • Java缓存技术简介
                        福如四海

                        
    什么是缓存缓存就是数据交换的缓冲区（称作：Cache），当某一硬件要读取数据时，会首先从缓存汇总查询数据，有则直接执行，不存在时从内存中获取。由于缓存的数据比内存快的多，所以缓存的作用就是帮助硬件更快的运行。缓存的适用场景1、对于数据实时性要求不高对于一些经常访问但是很少改变的数据，读明显多于写，适用缓存就很有必要。比如一些网站配置项。2、对于性能要求高比如一些秒杀活动场景。缓存技术优点操作系统磁
    
                    
    • 
                    
  • Java缓存介绍
                        xmh-sxh-1314
java
                        
    使用场景CPU占用：如果你有某些应用需要消耗大量的cpu去计算，比如正则表达式，如果你使用正则表达式比较频繁，而其又占用了很多CPU的话，那你就应该使用缓存将正则表达式的结果给缓存下来。数据库IO性能：如果发现有大量数据需要频繁查询使用，或者某些数据不会频繁变更时，为了提高数据库IO性能，可以使用缓存缓存定义所谓缓存，就是将程序或系统经常要调用的对象存在内存中，一遍其使用时可以快速调用，不必再去创
    
                    
    • 
                                
  • 集合框架
                                    天子之骄
java数据结构集合框架
                                    
       集合框架 
集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。 
从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。 
  
简单介绍： 
  
Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
    
                                
    • 
                                
  • Table Driven（表驱动）方法实例
                                    bijian1013
javaenumTable Driven表驱动
                                    
    实例一：   
/**
 * 驾驶人年龄段
 * 保险行业，会对驾驶人的年龄做年龄段的区分判断
 * 驾驶人年龄段：01-[18,25);02-[25,30);03-[30-35);04-[35,40);05-[40,45);06-[45,50);07-[50-55);08-[55,+∞)
 */
public class AgePeriodTest {

    //if...el
    
                                
    • 
                                
  • Jquery 总结
                                    cuishikuan
javajqueryAjaxWebjquery方法
                                    
    1.$.trim方法用于移除字符串头部和尾部多余的空格。如：$.trim('   Hello   ') // Hello2.$.contains方法返回一个布尔值，表示某个DOM元素（第二个参数）是否为另一个DOM元素（第一个参数）的下级元素。如：$.contains(document.documentElement, document.body); 3.$
    
                                
    • 
                                
  • 面向对象概念的提出
                                    麦田的设计者
java面向对象面向过程
                                    
       
     面向对象中，一切都是由对象展开的，组织代码，封装数据。 
  在台湾面向对象被翻译为了面向物件编程，这充分说明了，这种编程强调实体。 
  
    下面就结合编程语言的发展史，聊一聊面向过程和面向对象。 
     c语言由贝尔实
    
                                
    • 
                                
  • linux网口绑定
                                    被触发
linux
                                    
    刚在一台IBM Xserver服务器上装了RedHat Linux Enterprise AS 4，为了提高网络的可靠性配置双网卡绑定。 
 
一、环境描述 
我的RedHat Linux Enterprise AS 4安装双口的Intel千兆网卡，通过ifconfig -a命令看到eth0和eth1两张网卡。 
 
二、双网卡绑定步骤： 
2.1 修改/etc/sysconfig/network
    
                                
    • 
                                
  • XML基础语法
                                    肆无忌惮_
xml
                                    
    一、什么是XML？ 
XML全称是Extensible Markup Language，可扩展标记语言。很类似HTML。XML的目的是传输数据而非显示数据。XML的标签没有被预定义，你需要自行定义标签。XML被设计为具有自我描述性。是W3C的推荐标准。 
  
二、为什么学习XML？ 
用来解决程序间数据传输的格式问题 
做配置文件 
充当小型数据库 
  
三、XML与HTM
    
                                
    • 
                                
  • 为网页添加自己喜欢的字体
                                    知了ing
字体 秒表 css
                                    
    @font-face {
			font-family: miaobiao;//定义字体名字
			font-style:  normal;
		    font-weight: 400;
			src: url('font/DS-DIGI-e.eot');//字体文件
		} 
使用： 
 
<label style="font-size:18px;font-famil
    
                                
    • 
                                
  • redis范围查询应用-查找IP所在城市
                                    矮蛋蛋
redis
                                    
    原文地址： 
http://www.tuicool.com/articles/BrURbqV 
需求 
 
根据IP找到对应的城市 
 
原来的解决方案 
 
oracle表（ip_country）： 
 
 
查询IP对应的城市： 
 
1.把a.b.c.d这样格式的IP转为一个数字，例如为把210.21.224.34转为3524648994 
 
2. select city from ip_
    
                                
    • 
                                
  • 输入两个整数， 计算百分比
                                    alleni123
java
                                    
    	public static String getPercent(int x, int total){
		 
		double result=(x*1.0)/(total*1.0);
		System.out.println(result);
		
		
		DecimalFormat df1=new DecimalFormat("0.0000%");
		

    
                                
    • 
                                
  • 百合——————>怎么学习计算机语言
                                    百合不是茶
java 移动开发
                                    
        对于一个从没有接触过计算机语言的人来说，一上来就学面向对象，就算是心里上面接受的了，灵魂我觉得也应该是跟不上的，学不好是很正常的现象，计算机语言老师讲的再多，你在课堂上面跟着老师听的再多，我觉得你应该还是学不会的，最主要的原因是你根本没有想过该怎么来学习计算机编程语言，记得大一的时候金山网络公司在湖大招聘我们学校一个才来大学几天的被金山网络录取，一个刚到大学的就能够去和
    
                                
    • 
                                
  • linux下tomcat开机自启动
                                    bijian1013
tomcat
                                    
    方法一： 
修改Tomcat/bin/startup.sh 为: 
export JAVA_HOME=/home/java1.6.0_27
export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:.
export PATH=$JAVA_HOME/bin:$PATH
export CATALINA_H
    
                                
    • 
                                
  • spring aop实例
                                    bijian1013
javaspringAOP
                                    
    1.AdviceMethods.java 
package com.bijian.study.spring.aop.schema;

public class AdviceMethods {

	public void preGreeting() {
		System.out.println("--how are you!--");
	}
} 
2.beans.x
    
                                
    • 
                                
  • [Gson八]GsonBuilder序列化和反序列化选项enableComplexMapKeySerialization
                                    bit1129
serialization
                                    
    enableComplexMapKeySerialization配置项的含义 
 Gson在序列化Map时，默认情况下，是调用Key的toString方法得到它的JSON字符串的Key，对于简单类型和字符串类型，这没有问题，但是对于复杂数据对象，如果对象没有覆写toString方法，那么默认的toString方法将得到这个对象的Hash地址。 
  
GsonBuilder用于
    
                                
    • 
                                
  • 【Spark九十一】Spark Streaming整合Kafka一些值得关注的问题
                                    bit1129
Stream
                                    
    包括Spark Streaming在内的实时计算数据可靠性指的是三种级别： 
1. At most once，数据最多只能接受一次，有可能接收不到 
2. At least once, 数据至少接受一次，有可能重复接收 
3. Exactly once  数据保证被处理并且只被处理一次， 
  
具体的多读几遍http://spark.apache.org/docs/lates
    
                                
    • 
                                
  • shell脚本批量检测端口是否被占用脚本
                                    ronin47

                                    
    #!/bin/bash
cat ports   |while read line
do#nc -z  -w 10  $line

nc -z -w 2 $line 58422>/dev/null2>&1if[ $?-eq 0]then
echo $line:ok
else
echo $line:fail
fi

done

这里的ports 既可以是文件
    
                                
    • 
                                
  • java-2.设计包含min函数的栈
                                    bylijinnan
java
                                    
    具体思路参见：http://zhedahht.blog.163.com/blog/static/25411174200712895228171/ 
 

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


public class MinStack {

	//maybe we can use origin array rathe
    
                                
    • 
                                
  • Netty源码学习-ChannelHandler
                                    bylijinnan
javanetty
                                    
     
一般来说，“有状态”的ChannelHandler不应该是“共享”的，“无状态”的ChannelHandler则可“共享” 
例如ObjectEncoder是“共享”的, 但 ObjectDecoder 不是 
因为每一次调用decode方法时，可能数据未接收完全（incomplete）， 
它与上一次decode时接收到的数据“累计”起来才有可能是完整的数据，是“有状态”的 
 
 

p
    
                                
    • 
                                
  • java生成随机数
                                    cngolon
java
                                    
    方法一： 
/** 
* 生成随机数 
* @author [email protected] 
* @return 
*/ 
public synchronized static String getChargeSequenceNum(String pre){ 
StringBuffer sequenceNum = new StringBuffer(); 
Date dateTime = new D
    
                                
    • 
                                
  • POI读写海量数据
                                    ctrain
海量数据
                                    
    import java.io.FileOutputStream; 
import java.io.OutputStream; 
 
import org.apache.poi.xssf.streaming.SXSSFRow; 
import org.apache.poi.xssf.streaming.SXSSFSheet; 
import org.apache.poi.xssf.streaming
    
                                
    • 
                                
  • mysql 日期格式化date_format详细使用
                                    daizj
mysqldate_format日期格式转换日期格式化
                                    
     
 日期转换函数的详细使用说明 
   DATE_FORMAT(date,format) Formats the date value according to the format string. The following specifiers may be used in the format string. The&n
    
                                
    • 
                                
  • 一个程序员分享8年的开发经验
                                    dcj3sjt126com
程序员
                                    
      
在中国有很多人都认为IT行为是吃青春饭的，如果过了30岁就很难有机会再发展下去!其实现实并不是这样子的，在下从事.NET及JAVA方面的开发的也有8年的时间了，在这里在下想凭借自己的亲身经历，与大家一起探讨一下。 
明确入行的目的 
很多人干IT这一行都冲着“收入高”这一点的，因为只要学会一点HTML, DIV+CSS，要做一个页面开发人员并不是一件难事，而且做一个页面开发人员更容
    
                                
    • 
                                
  • android欢迎界面淡入淡出效果
                                    dcj3sjt126com
android
                                    
    很多Android应用一开始都会有一个欢迎界面，淡入淡出效果也是用得非常多的，下面来实现一下。 
主要代码如下： 
package com.myaibang.activity; 
import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.os.CountDown
    
                                
    • 
                                
  • linux 复习笔记之常见压缩命令
                                    eksliang
tar解压linux系统常见压缩命令linux压缩命令tar压缩
                                    
    转载请出自出处:http://eksliang.iteye.com/blog/2109693 
linux中常见压缩文件的拓展名 
*.gz   gzip程序压缩的文件
*.bz2  bzip程序压缩的文件
*.tar  tar程序打包的数据，没有经过压缩
*.tar.gz  tar程序打包后，并经过gzip程序压缩
*.tar.bz2 tar程序打包后，并经过bzip程序压缩
*.zi
    
                                
    • 
                                
  • Android 应用程序发送shell命令
                                    gqdy365
android
                                    
    项目中需要直接在APP中通过发送shell指令来控制lcd灯，其实按理说应该是方案公司在调好lcd灯驱动之后直接通过service送接口上来给APP，APP调用就可以控制了，这是正规流程，但我们项目的方案商用的mtk方案，方案公司又没人会改，只调好了驱动，让应用程序自己实现灯的控制，这不蛋疼嘛！！！！ 
 
发就发吧！ 
 
一、关于shell指令： 
我们知道，shell指令是Linux里面带的
    
                                
    • 
                                
  • java 无损读取文本文件
                                    hw1287789687
读取文件无损读取读取文本文件charset
                                    
    java 如何无损读取文本文件呢？ 
以下是有损的 
@Deprecated
	public static String getFullContent(File file, String charset) {
		BufferedReader reader = null;
		if (!file.exists()) {
			System.out.println("getFull
    
                                
    • 
                                
  • Firebase 相关文章索引
                                    justjavac
firebase
                                    
    Awesome Firebase 
最近谷歌收购Firebase的新闻又将Firebase拉入了人们的视野，于是我做了这个 github 项目。 
Firebase 是一个数据同步的云服务，不同于 Dropbox 的「文件」，Firebase 同步的是「数据」，服务对象是网站开发者，帮助他们开发具有「实时」（Real-Time）特性的应用。 
开发者只需引用一个 API 库文件就可以使用标准 RE
    
                                
    • 
                                
  • C++学习重点
                                    lx.asymmetric
C++笔记
                                    
    1.c++面向对象的三个特性：封装性，继承性以及多态性。 
  
2.标识符的命名规则：由字母和下划线开头，同时由字母、数字或下划线组成；不能与系统关键字重名。 
  
3.c++语言常量包括整型常量、浮点型常量、布尔常量、字符型常量和字符串性常量。 
  
4.运算符按其功能开以分为六类：算术运算符、位运算符、关系运算符、逻辑运算符、赋值运算符和条件运算符。 
&n
    
                                
    • 
                                
  • java bean和xml相互转换
                                    q821424508
javabeanxmlxml和bean转换java bean和xml转换
                                    
    这几天在做微信公众号 
做的过程中想找个java bean转xml的工具，找了几个用着不知道是配置不好还是怎么回事，都会有一些问题， 
然后脑子一热谢了一个javabean和xml的转换的工具里，自己用着还行，虽然有一些约束吧 ， 
还是贴出来记录一下  
  
  
顺便你提一下下，这个转换工具支持属性为集合、数组和非基本属性的对象。 
  
packag
    
                                
    • 
                                
  • C 语言初级 位运算
                                    1140566087
位运算c
                                    
      第十章 位运算    1、位运算对象只能是整形或字符型数据，在VC6.0中int型数据占4个字节    2、位运算符：  运算符 作用  ~ 按位求反  << 左移  >> 右移  & 按位与  ^ 按位异或  | 按位或   他们的优先级从高到低；    3、位运算符的运算功能：  a、按位取反：  ~01001101 = 101
    
                                
    • 
                                
  • 14点睛Spring4.1-脚本编程
                                    wiselyman
spring4
                                    
    14.1 Scripting脚本编程 
 
 脚本语言和java这类静态的语言的主要区别是:脚本语言无需编译,源码直接可运行; 
 如果我们经常需要修改的某些代码,每一次我们至少要进行编译,打包,重新部署的操作,步骤相当麻烦; 
 如果我们的应用不允许重启,这在现实的情况中也是很常见的; 
 在spring中使用脚本编程给上述的应用场景提供了解决方案,即动态加载bean; 
 spring支持脚本
    
                                
    •