Leven
Leven

MyBatis整合Redis实现二级缓存

MyBatis框架提供了二级缓存接口，我们只需要实现它再开启配置就可以使用了。
特别注意，我们要解决缓存穿透、缓存穿透和缓存雪崩的问题，同时也要保证缓存性能。
具体实现说明，直接看代码注释吧！

1、开启配置

SpringBoot配置

mybatis:
  configuration:
    cache-enabled: true

2、Redis配置以及服务接口

RedisConfig.java

package com.leven.mybatis.api.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis缓存配置
 * @author Leven
 * @date 2019-09-07
 */
@Configuration
public class RedisConfig {

    /**
     * 配置自定义redisTemplate
     * @return redisTemplate
     */
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        // 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);
        template.setKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}


RedisService.java


package com.leven.mybatis.core.service;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * redis基础服务接口
 * @author Leven
 * @date 2019-09-07
 */
public interface RedisService {
// =============================common============================
    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     */
    void expire(String key, long time);

    /**
     * 指定缓存失效时间
     * @param key 键
     * @param expireAt 失效时间点
     * @return 处理结果
     */
    void expireAt(String key, Date expireAt);

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    Long getExpire(String key);

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    Boolean hasKey(String key);

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    void delete(String... key);

    /**
     * 删除缓存
     * @param keys 可以传一个值 或多个
     */
    void delete(Collection keys);

    // ============================String=============================

    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    Object get(String key);

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     */
    void set(String key, Object value);

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     */
    void set(String key, Object value, long time);

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     */
    void set(String key, Object value, long time, TimeUnit timeUnit);

    /**
     * 递增
     * @param key 键
     * @param value 要增加几(大于0)
     * @return 递增后结果
     */
    Long incr(String key, long value);

    /**
     * 递减
     * @param key 键
     * @param value 要减少几(大于0)
     * @return 递减后结果
     */
    Long decr(String key, long value);

    // ================================Map=================================
    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    Object hashGet(String key, String item);

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    Map hashEntries(String key);

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     */
    void hashSet(String key, Map map);

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     */
    void hashSet(String key, Map map, long time);

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     */
    void hashSet(String key, String item, Object value);

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     */
    void hashSet(String key, String item, Object value, long time);

    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    void hashDelete(String key, Object... item);

    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param items 项 可以使多个 不能为null
     */
    void hashDelete(String key, Collection items);

    /**
     * 判断hash表中是否有该项的值
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    Boolean hashHasKey(String key, String item);

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * @param key 键
     * @param item 项
     * @param value 要增加几(大于0)
     * @return 递增后结果
     */
    Double hashIncr(String key, String item, double value);

    /**
     * hash递减
     * @param key 键
     * @param item 项
     * @param value 要减少记(小于0)
     * @return 递减后结果
     */
    Double hashDecr(String key, String item, double value);

    // ============================set=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return set集合
     */
    Set setGet(String key);

    /**
     * 根据value从一个set中查询,是否存在
     * @param key 键
     * @param value 值
     * @return true 存在 false不存在
     */
    Boolean setIsMember(String key, Object value);

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    Long setAdd(String key, Object... values);

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    Long setAdd(String key, Collection values);

    /**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    Long setAdd(String key, long time, Object... values);

    /**
     * 获取set缓存的长度
     * @param key 键
     * @return set长度
     */
    Long setSize(String key);

    /**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    Long setRemove(String key, Object... values);

    // ===============================list=================================
    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束 0 到 -1代表所有值
     * @return 缓存列表
     */
    List listRange(String key, long start, long end);

    /**
     * 获取list缓存的长度
     * @param key 键
     * @return 长度
     */
    Long listSize(String key);

    /**
     * 通过索引 获取list中的值
     * @param key 键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return 值
     */
    Object listIndex(String key, long index);

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     */
    void listRightPush(String key, Object value);

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     */
    void listRightPush(String key, Object value, long time);

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     */
    void listRightPushAll(String key, List value);

    /**
     * 将list放入缓存
     *
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     */
    void listRightPushAll(String key, List value, long time);

    /**
     * 根据索引修改list中的某条数据
     * @param key 键
     * @param index 索引
     * @param value 值
     */
    void listSet(String key, long index, Object value);

    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    Long listRemove(String key, long count, Object value);
}


RedisServiceImpl.java


package com.leven.mybatis.core.service.impl;

import com.leven.commons.model.exception.SPIException;
import com.leven.mybatis.model.constant.Constant;
import com.leven.mybatis.core.service.RedisService;
import com.leven.mybatis.model.constant.ExceptionCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * redis基础服务接口实现
 * @author Leven
 * @date 2019-09-07
 */
@Slf4j
@Service
public class RedisServiceImpl implements RedisService {

    /**
     * 
     */
    private static final String PREFIX = Constant.APPLICATION;

    @Autowired
    private RedisTemplate redisTemplate;

    // =============================common============================
    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     */
    @Override
    public void expire(String key, long time) {
        redisTemplate.expire(getKey(key), time, TimeUnit.SECONDS);
    }

    /**
     * 指定缓存失效时间
     * @param key 键
     * @param expireAt 失效时间点
     * @return 处理结果
     */
    @Override
    public void expireAt(String key, Date expireAt) {
        redisTemplate.expireAt(getKey(key), expireAt);
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    @Override
    public Long getExpire(String key) {
        return redisTemplate.getExpire(getKey(key), TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    @Override
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(getKey(key));
    }

    /**
     * 删除缓存
     * @param keys 可以传一个值 或多个
     */
    @Override
    public void delete(String... keys) {
        if (keys != null && keys.length > 0) {
            if (keys.length == 1) {
                redisTemplate.delete(getKey(keys[0]));
            } else {
                List keyList = new ArrayList<>(keys.length);
                for (String key : keys) {
                    keyList.add(getKey(key));
                }
                redisTemplate.delete(keyList);
            }
        }
    }

    /**
     * 删除缓存
     * @param keys 可以传一个值 或多个
     */
    @Override
    public void delete(Collection keys) {
        if (keys != null && !keys.isEmpty()) {
            List keyList = new ArrayList<>(keys.size());
            for (String key : keys) {
                keyList.add(getKey(key));
            }
            redisTemplate.delete(keyList);
        }
    }

    // ============================String=============================
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    @Override
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(getKey(key));
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     */
    @Override
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(getKey(key), value);
    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     */
    @Override
    public void set(String key, Object value, long time) {
        set(key, value, time, TimeUnit.SECONDS);
    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间 time要大于0 如果time小于等于0 将设置无限期
     * @param timeUnit 时间单位
     */
    @Override
    public void set(String key, Object value, long time, TimeUnit timeUnit) {
        if (time > 0) {
            redisTemplate.opsForValue().set(getKey(key), value, time, timeUnit);
        } else {
            set(getKey(key), value);
        }
    }

    /**
     * 递增
     * @param key 键
     * @param value 要增加几(大于0)
     * @return 递增后结果
     */
    @Override
    public Long incr(String key, long value) {
        if (value < 1) {
            throw new SPIException(ExceptionCode.RUNTIME_UNITE_EXP,"递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(getKey(key), value);
    }

    /**
     * 递减
     * @param key 键
     * @param value 要减少几(大于0)
     * @return 递减后结果
     */
    @Override
    public Long decr(String key, long value) {
        if (value < 1) {
            throw new SPIException(ExceptionCode.RUNTIME_UNITE_EXP,"递减因子必须大于0");
        }
        return redisTemplate.opsForValue().decrement(getKey(key), value);
    }

    // ================================Map=================================
    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    @Override
    public Object hashGet(String key, String item) {
        return redisTemplate.opsForHash().get(getKey(key), item);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    @Override
    public Map hashEntries(String key) {
        return redisTemplate.opsForHash().entries(getKey(key));
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     */
    @Override
    public void hashSet(String key, Map map) {
        redisTemplate.opsForHash().putAll(getKey(key), map);
    }

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     */
    @Override
    public void hashSet(String key, Map map, long time) {
        String k = getKey(key);
        redisTemplate.opsForHash().putAll(k, map);
        if (time > 0) {
            expire(k, time);
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     */
    @Override
    public void hashSet(String key, String item, Object value) {
        redisTemplate.opsForHash().putIfAbsent(getKey(key), item, value);
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     */
    @Override
    public void hashSet(String key, String item, Object value, long time) {
        String k = getKey(key);
        redisTemplate.opsForHash().putIfAbsent(k, item, value);
        if (time > 0) {
            expire(k, time);
        }
    }

    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    @Override
    public void hashDelete(String key, Object... item) {
        redisTemplate.opsForHash().delete(getKey(key), item);
    }

    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param items 项 可以使多个 不能为null
     */
    @Override
    public void hashDelete(String key, Collection items) {
        redisTemplate.opsForHash().delete(getKey(key), items.toArray());
    }

    /**
     * 判断hash表中是否有该项的值
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    @Override
    public Boolean hashHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(getKey(key), item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * @param key 键
     * @param item 项
     * @param value 要增加几(大于0)
     * @return 递增后结果
     */
    @Override
    public Double hashIncr(String key, String item, double value) {
        if (value < 1) {
            throw new SPIException(ExceptionCode.RUNTIME_UNITE_EXP,"递增因子必须大于0");
        }
        return redisTemplate.opsForHash().increment(getKey(key), item, value);
    }

    /**
     * hash递减
     * @param key 键
     * @param item 项
     * @param value 要减少记(小于0)
     * @return 递减后结果
     */
    @Override
    public Double hashDecr(String key, String item, double value) {
        if (value < 1) {
            throw new SPIException(ExceptionCode.RUNTIME_UNITE_EXP,"递减因子必须大于0");
        }
        return redisTemplate.opsForHash().increment(getKey(key), item, -value);
    }

    // ============================set=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return set集合
     */
    @Override
    public Set setGet(String key) {
        return redisTemplate.opsForSet().members(getKey(key));
    }

    /**
     * 根据value从一个set中查询,是否存在
     * @param key 键
     * @param value 值
     * @return true 存在 false不存在
     */
    @Override
    public Boolean setIsMember(String key, Object value) {
        return redisTemplate.opsForSet().isMember(getKey(key), value);
    }

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    @Override
    public Long setAdd(String key, Object... values) {
        return redisTemplate.opsForSet().add(getKey(key), values);
    }

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    @Override
    public Long setAdd(String key, Collection values) {
        return redisTemplate.opsForSet().add(getKey(key), values.toArray());
    }

    /**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    @Override
    public Long setAdd(String key, long time, Object... values) {
        String k = getKey(key);
        Long count = redisTemplate.opsForSet().add(k, values);
        if (time > 0){
            expire(k, time);
        }
        return count;
    }

    /**
     * 获取set缓存的长度
     * @param key 键
     * @return set长度
     */
    @Override
    public Long setSize(String key) {
        return redisTemplate.opsForSet().size(getKey(key));
    }

    /**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    @Override
    public Long setRemove(String key, Object... values) {
        return redisTemplate.opsForSet().remove(getKey(key), values);
    }

    // ===============================list=================================
    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束 0 到 -1代表所有值
     * @return 缓存列表
     */
    @Override
    public List listRange(String key, long start, long end) {
        return redisTemplate.opsForList().range(getKey(key), start, end);
    }

    /**
     * 获取list缓存的长度
     * @param key 键
     * @return 长度
     */
    @Override
    public Long listSize(String key) {
        return redisTemplate.opsForList().size(getKey(key));
    }

    /**
     * 通过索引 获取list中的值
     * @param key 键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return 值
     */
    @Override
    public Object listIndex(String key, long index) {
        return redisTemplate.opsForList().index(getKey(key), index);
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     */
    @Override
    public void listRightPush(String key, Object value) {
        redisTemplate.opsForList().rightPush(getKey(key), value);
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     */
    @Override
    public void listRightPush(String key, Object value, long time) {
        String k = getKey(key);
        redisTemplate.opsForList().rightPush(k, value);
        if (time > 0){
            expire(k, time);
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     */
    @Override
    public void listRightPushAll(String key, List value) {
        redisTemplate.opsForList().rightPushAll(getKey(key), value);
    }

    /**
     * 将list放入缓存
     *
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     */
    @Override
    public void listRightPushAll(String key, List value, long time) {
        String k = getKey(key);
        redisTemplate.opsForList().rightPushAll(k, value);
        if (time > 0) {
            expire(k, time);
        }
    }

    /**
     * 根据索引修改list中的某条数据
     * @param key 键
     * @param index 索引
     * @param value 值
     */
    @Override
    public void listSet(String key, long index, Object value) {
        redisTemplate.opsForList().set(getKey(key), index, value);
    }

    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    @Override
    public Long listRemove(String key, long count, Object value) {
        return redisTemplate.opsForList().remove(getKey(key), count, value);
    }

    private String getKey(String key) {
        return PREFIX + ":" + key;
    }
}



3、实现MyBatis的Cache接口


MybatisRedisCache.java


package com.leven.mybatis.core.cache;

import com.leven.commons.core.util.ApplicationContextUtils;
import com.leven.commons.model.exception.SPIException;
import com.leven.mybatis.core.service.RedisService;
import com.leven.mybatis.model.constant.ExceptionCode;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomUtils;
import org.apache.ibatis.cache.Cache;

import java.security.MessageDigest;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * MyBatis二级缓存Redis实现
 * 重点处理以下几个问题
 * 1、缓存穿透：存储空值解决，MyBatis框架实现
 * 2、缓存击穿：使用互斥锁，我们自己实现
 * 3、缓存雪崩：缓存有效期设置为一个随机范围，我们自己实现
 * 4、读写性能：redis key不能过长，会影响性能，这里使用SHA-256计算摘要当成key
 * @author Leven
 * @date 2019-09-07
 */
@Slf4j
public class MybatisRedisCache implements Cache {

    /**
     * 统一字符集
     */
    private static final String CHARSET = "utf-8";
    /**
     * key摘要算法
     */
    private static final String ALGORITHM = "SHA-256";
    /**
     * 统一缓存头
     */
    private static final String CACHE_NAME = "MyBatis:";
    /**
     * 读写锁：解决缓存击穿
     */
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    /**
     * 表空间ID：方便后面的缓存清理
     */
    private final String id;
    /**
     * redis服务接口：提供基本的读写和清理
     */
    private static volatile RedisService redisService;
    /**
     * 信息摘要
     */
    private volatile MessageDigest messageDigest;

    /////////////////////// 解决缓存雪崩，具体范围根据业务需要设置合理值 //////////////////////////
    /**
     * 缓存最小有效期
     */
    private static final int MIN_EXPIRE_MINUTES = 60;
    /**
     * 缓存最大有效期
     */
    private static final int MAX_EXPIRE_MINUTES = 120;

    /**
     * MyBatis给每个表空间初始化的时候要用到
     * @param id 其实就是namespace的值
     */
    public MybatisRedisCache(String id) {
        if (id == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        }
        this.id = id;
    }

    /**
     * 获取ID
     * @return 真实值
     */
    @Override
    public String getId() {
        return id;
    }

    /**
     * 创建缓存
     * @param key 其实就是sql语句
     * @param value sql语句查询结果
     */
    @Override
    public void putObject(Object key, Object value) {
        try {
            String strKey = getKey(key);
            // 有效期为1~2小时之间随机，防止雪崩
            int expireMinutes = RandomUtils.nextInt(MIN_EXPIRE_MINUTES, MAX_EXPIRE_MINUTES);
            getRedisService().set(strKey, value, expireMinutes, TimeUnit.MINUTES);
            log.debug("Put cache to redis, id={}", id);
        } catch (Exception e) {
            log.error("Redis put failed, id=" + id, e);
        }
    }

    /**
     * 读取缓存
     * @param key 其实就是sql语句
     * @return 缓存结果
     */
    @Override
    public Object getObject(Object key) {
        try {
            String strKey = getKey(key);
            log.debug("Get cache from redis, id={}", id);
            return getRedisService().get(strKey);
        } catch (Exception e) {
            log.error("Redis get failed, fail over to db", e);
            return null;
        }
    }

    /**
     * 删除缓存
     * @param key 其实就是sql语句
     * @return 结果
     */
    @Override
    public Object removeObject(Object key) {
        try {
            String strKey = getKey(key);
            getRedisService().delete(strKey);
            log.debug("Remove cache from redis, id={}", id);
        } catch (Exception e) {
            log.error("Redis remove failed", e);
        }
        return null;
    }

    /**
     * 缓存清理
     * 网上好多博客这里用了flushDb甚至是flushAll，感觉好坑鸭！
     * 应该是根据表空间进行清理
     */
    @Override
    public void clear() {
        try {
            log.debug("clear cache, id={}", id);
            String hsKey = CACHE_NAME + id;
            // 获取CacheNamespace所有缓存key
            Map idMap = getRedisService().hashEntries(hsKey);
            if (!idMap.isEmpty()) {
                Set keySet = idMap.keySet();
                Set keys = new HashSet<>(keySet.size());
                keySet.forEach(item -> keys.add(item.toString()));
                // 清空CacheNamespace所有缓存
                getRedisService().delete(keys);
                // 清空CacheNamespace
                getRedisService().delete(hsKey);
            }
        } catch (Exception e) {
            log.error("clear cache failed", e);
        }
    }

    /**
     * 获取缓存大小，暂时没用上
     * @return 长度
     */
    @Override
    public int getSize() {
        return 0;
    }

    /**
     * 获取读写锁：为了解决缓存击穿
     * @return 锁
     */
    @Override
    public ReadWriteLock getReadWriteLock() {
        return readWriteLock;
    }

    /**
     * 计算出key的摘要
     * @param cacheKey CacheKey
     * @return 字符串key
     */
    private String getKey(Object cacheKey) {
        String cacheKeyStr = cacheKey.toString();
        log.debug("count hash key, cache key origin string:{}", cacheKeyStr);
        String strKey = byte2hex(getSHADigest(cacheKeyStr));
        log.debug("hash key:{}", strKey);
        String key = CACHE_NAME + strKey;
        // 在redis额外维护CacheNamespace创建的key，clear的时候只清理当前CacheNamespace的数据
        getRedisService().hashSet(CACHE_NAME + id, key, "1");
        return key;
    }

    /**
     * 获取信息摘要
     * @param data 待计算字符串
     * @return 字节数组
     */
    private byte[] getSHADigest(String data) {
        try {
            if (messageDigest == null) {
                synchronized (MessageDigest.class) {
                    if (messageDigest == null) {
                        messageDigest = MessageDigest.getInstance(ALGORITHM);
                    }
                }
            }
            return messageDigest.digest(data.getBytes(CHARSET));
        } catch (Exception e) {
            log.error("SHA-256 digest error: ", e);
            throw new SPIException(ExceptionCode.RUNTIME_UNITE_EXP,"SHA-256 digest error, id=" + id +  ".");
        }
    }

    /**
     * 字节数组转16进制字符串
     * @param bytes 待转换数组
     * @return 16进制字符串
     */
    private String byte2hex(byte[] bytes) {
        StringBuilder sign = new StringBuilder();
        for (byte aByte : bytes) {
            String hex = Integer.toHexString(aByte & 0xFF);
            if (hex.length() == 1) {
                sign.append("0");
            }
            sign.append(hex.toUpperCase());
        }
        return sign.toString();
    }

    /**
     * 获取Redis服务接口
     * 使用双重检查保证线程安全
     * @return 服务实例
     */
    private RedisService getRedisService() {
        if (redisService == null) {
            synchronized (RedisService.class) {
                if (redisService == null) {
                    redisService = ApplicationContextUtils.getBeanByClass(RedisService.class);
                }
            }
        }
        return redisService;
    }
}



4、Mapper配置


二选一，只有一个生效。


Java代码配置


package com.leven.mybatis.core.mapper;

import com.leven.commons.core.mapper.OracleMapper;
import com.leven.mybatis.model.pojo.entity.UserDO;
import org.apache.ibatis.annotations.CacheNamespace;

/**
 * 用户查询
 *
 * @author Leven
 * @date 2019-09-18
 */
@CacheNamespace(implementation=com.leven.mybatis.core.cache.MybatisRedisCache.class)
public interface UserMapper extends OracleMapper {
}



XML配置





    


























你可能感兴趣的:(mybatis,redis)






    

  • Redis系列：Geo 类型赋能亿级地图位置计算
Ly768768
redisbootstrap数据库

    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    

    • 

  • insert into select 主键自增_mybatis拦截器实现主键自动生成
weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id

    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    

    • 

  • MyBatis 详解
阿贾克斯的黎明
javamybatis

    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
    

    • 

  • 华为云分布式缓存服务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不存在时执行，以此来实现互
    

    • 

  • Redis 有哪些危险命令？如何防范？
花小疯
redis缓存数据库危险命令大数据

    Redis有哪些危险命令？Redis的危险命令主要有以下几个：1.keys客户端可查询出所有存在的键。2.flushdb删除Redis中当前所在数据库中的所有记录，并且此命令从不会执行失败。3.flushall删除Redis中所有数据库中的所有记录，不止是当前所在数据库，并且此命令从不会执行失败。4.config客户端可修改Redis配置。怎么禁用和重命名危险命令？看下redis.conf默认配置
    

    • 

  • mybatis 二级缓存失效_Mybatis 缓存原理及失效情况解析
weixin_39844942
mybatis二级缓存失效

    这篇文章主要介绍了Mybatis缓存原理及失效情况解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、什么是缓存[Cache]存在内存中的临时数据。将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。2、为什么要使用缓存减少和数据库的交互次
    

    • 

  • 详解mybatis的一二级缓存以及缓存失效原因
仰望天花板
缓存数据库mybatisjavamysql

    数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
    

    • 

  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
这孩子叫逆
Mybatis笔记mybatis数据库

    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    

    • 

  • 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
    

    • 

  • 华为云分布式缓存服务DCS与开源服务差异对比
hcinfo_18
redis使用华为云Redis5.0分布式缓存服务Redis客户端

    分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
    

    • 

  • MyBatis批量插入大量数据
小黑屋说YYDS
MyBatisjava

    1.思路分析批量插入这个问题，我们用JDBC操作，其实就是两种思路吧：用一个for循环，把数据一条一条的插入（这种需要开启批处理）。生成一条插入sql，类似这种insertintouser(username,address)values(‘aa’,‘bb’),(‘cc’,‘dd’)…。到底哪种快呢？我们从两方面来考虑这个问题：插入SQL本身执行的效率。网络I/O。先说第一种方案，就是用for循环循
    

    • 

  • MyBatis 查询数据库_mybatis查询某个库的所有表名(2)
2401_84181942
程序员mybatisoracletomcat

    标签说明：***``标签**：需要指定namespace属性，表示命名空间，值为mapper接口的全限定名，包括全包名.类名。***``查询标签**：是用来执行数据库的查询操作的：`id`：是和Interface（接口）中定义的方法名称一样的，表示对接口的具体实现方法。`resultType`：是返回的数据类型，也就是开头我们定义的实体类。####2.4.4添加Service服务层实现代码如下：@
    

    • 

  • 5-【JavaWeb】JUnit 单元测试及JUL 日志系统
weixin_44329069
JavaWebjunit单元测试

    1.使用JUnit进行单元测试JUnit是Java中非常流行的单元测试框架，MyBatis与JUnit可以很好地结合，来测试持久层代码的正确性。1.1添加JUnit依赖在使用JUnit之前，需要在pom.xml中引入JUnit依赖。junitjunit4.13.2test1.2单元测试基本结构假设我们要测试UserMapper中的getUserById方法，测试代码如下：importorg.apa
    

    • 

  • 【免费】springboot项目申报管理系统|毕业设计|Javaweb项目
计算机学姐来啦
springbootssmjavaspringboot课程设计后端毕设毕业设计java-ee

    收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的
    

    • 

  • MyBatis系统学习（一）——项目结构及其含义
OEC小胖胖
MyBatismybatis学习web后端

    1.MyBatis简介MyBatis是一款优秀的持久层框架，它通过SQL映射的方式实现Java对数据库操作的映射，既保留了SQL语句的灵活性，也简化了代码的编写。在一个MyBatis项目中，核心部分主要有：配置文件（mybatis-config.xml）映射文件（Mapper.xml）实体类（Entity/POJO）接口类（Mapper接口）MyBatis会话工厂（SqlSessionFactor
    

    • 

  • 关于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图形数据库
    

    • 

  • MyBatis 如何将 Mapper 接口与其 XML 映射文件关联：深入原理与实现
OEC小胖胖
web后端mybatisxmljavaweb后端

    MyBatis如何将Mapper接口与其XML映射文件关联：深入原理与实现1.概述MyBatis是一个简单、灵活的持久层框架，它通过SQL语句将Java对象与数据库进行映射。MyBatis支持基于XML和注解的配置方式。在实际开发中，XML映射文件与Mapper接口的关联是MyBatis的核心功能之一。通过这种关联，开发者可以在Mapper接口中定义方法，并在XML文件中编写SQL语句，从而实现数
    

    • 

  • Mybatis实现员工管理系统
wu1113_
mybatisjavamaven

    文章目录1.案例需求2.编程思路3.案例源码4.小结1.案例需求在上次做的父子模块的maven以及Ajax实现人工管理系统的基础上使用Mybatis实现员工管理系统的增删改查，具体运行效果如下：2.编程思路Mybatis框架的一般执行流程：创建MyBatis配置文件mybatis-config.xml在里面加载数据源、事务等，管理映射文件创建需要的映射文件mapper.xml，用于映射表中列和实体
    

    • 

  • springboot+mybatisplus实现基本的增删改查以及分页查询。这里使用的是Restful风格包括简单描述Restful是什么
okchan666
springbootjava

    先实现springboot+mybatisplus的增删改查接口使用postman测试：第一步创建项目导入依赖：直接给大家了：4.0.0org.springframework.bootspring-boot-starter-parent2.6.6com.okchanspringboot_07_ssmp0.0.1-SNAPSHOT1.8org.springframework.bootspring-b
    

    • 

  • MyBatis 方法重载的陷阱及解决方案
molashaonian
mybatis方法重载异常方法名相同

    在使用MyBatis进行开发时，尤其是使用注解模式（如@Select、@Insert等）时，开发者常常会遇到这样一个问题：为什么我的方法重载不能正常工作？即使在Java中允许方法名相同但参数不同的重载，MyBatis在处理注解的SQL方法时却并不支持这种方式。这篇文章将深入探讨MyBatis的这个特性及如何规避相关的坑。问题背景在标准的Java开发中，方法重载是一种常见的设计模式。方法重载允许我们
    

    • 

  • 网上商城项目总结 续
猫只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
    

    • 

  • Spring Cloud+Spring Boot+Mybatis+Java版电子招标采购系统源码 及 功能清单
Xiaohong0716
mybatisjavaspringcloud

    一、立项管理1、招标立项申请功能点：招标类项目立项申请入口，用户可以保存为草稿，提交。2、非招标立项申请功能点：非招标立项申请入口、用户可以保存为草稿、提交。3、采购立项列表功能点：对草稿进行编辑，驳回的立项编辑，在途流程查看。二、项目管理1、采购计划管理功能点：采购计划新增、编辑、删除2、采购过程管理功能点：查询、维护基准价、组建评审小组、项目答疑澄清、文件费保证金审核、供应商报价维护、查看评审
    

    • 

  • 2024Mysql And Redis基础与进阶操作系列（8）作者——LJS[含MySQL 创建、修改、跟新、重命名、删除视图等具体详步骤；注意点及常见报错问题所对应的解决方法]
肾透侧视攻城狮
MYSQLREDISAdvanceoperationredismysql数据库linuxsqlbashadb

    目录1MySQL视图1.概念2.作用3.特点4.具体如何操作实现MYSQL视图4.1创建视图语法示例查看表和视图查看视图的结构查看视图属性信息（比如：显示数据表的存储引擎、版本、数据行数和数据大小等）查看视图的详细定义信息4.2修改视图简介格式举例4.3更新视图简介下述结构中不可更新的视图补充说明举例更新视图视图包含聚合函数不可更新视图包含distinct不可更新视图包含goupby、having
    

    • 

  • 自定义布隆过滤器解决缓存穿透
暗金烂狗
缓存

    什么是缓存穿透以及常见解决方案缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库，导致数据库压力提高，造成宕机。缓存穿透就是指用户访问那些在数据库和Redis中都不存在的数据，例如我们知道id采用自增策略，那么就不可能出现负数id，而如果不法分子使用负数id进行查询，那么这些请求都会穿过Redis直接向数据库发送请求，从而导致数据库压力骤增，导致数
    

    • 

  • Redis 为什么这么快？
小海海不怕困难
Redisredis

    决定Redis请求效率的因素主要是三个方面，分别是网络、cpu、内存。在网络层面，Redis采用多路复用的设计，提升了并发处理的连接数，不过这个阶段，Server端的所有IO操作，都是由同一个主线程处理的这个时候IO的瓶颈就会影响到Redis端的整体处理性能。所以从Redis6.0开始，在多路复用及层面增加了多线程的处理，来优化IO处理的能力不过，具体的数据操作仍然是由主线程来处理的，所以我们可以
    

    • 

  • iOS http封装
374016526
ios服务器交互http网络请求

    程序开发避免不了与服务器的交互，这里打包了一个自己写的http交互库。希望可以帮到大家。
 
内置一个basehttp，当我们创建自己的service可以继承实现。
 
KuroAppBaseHttp *baseHttp = [[KuroAppBaseHttp alloc] init];
[baseHttp setDelegate:self];
[baseHttp 
    

    • 

  • lolcat ：一个在 Linux 终端中输出彩虹特效的命令行工具
brotherlamp
linuxlinux教程linux视频linux自学linux资料

     
那些相信 Linux 命令行是单调无聊且没有任何乐趣的人们，你们错了，这里有一些有关 Linux 的文章，它们展示着 Linux 是如何的有趣和“淘气” 。
在本文中，我将讨论一个名为“lolcat”的小工具 – 它可以在终端中生成彩虹般的颜色。
何为 lolcat ?
Lolcat 是一个针对 Linux，BSD 和 OSX 平台的工具，它类似于 cat 命令，并为 cat
    

    • 

  • MongoDB索引管理（1）——[九]
eksliang
mongodbMongoDB管理索引

    转载请出自出处：http://eksliang.iteye.com/blog/2178427 一、概述
      数据库的索引与书籍的索引类似，有了索引就不需要翻转整本书。数据库的索引跟这个原理一样，首先在索引中找，在索引中找到条目以后，就可以直接跳转到目标文档的位置，从而使查询速度提高几个数据量级。
      不使用索引的查询称
    

    • 

  • Informatica参数及变量
18289753290
Informatica参数变量

    下面是本人通俗的理解，如有不对之处，希望指正 info参数的设置：在info中用到的参数都在server的专门的配置文件中（最好以parma）结尾 下面的GLOBAl就是全局的，$开头的是系统级变量，$$开头的变量是自定义变量。如果是在session中或者mapping中用到的变量就是局部变量，那就把global换成对应的session或者mapping名字。
[GLOBAL] $Par
    

    • 

  • python 解析unicode字符串为utf8编码字符串
酷的飞上天空
unicode

    php返回的json字符串如果包含中文，则会被转换成\uxx格式的unicode编码字符串返回。
在浏览器中能正常识别这种编码，但是后台程序却不能识别，直接输出显示的是\uxx的字符，并未进行转码。
 
转换方式如下
 
>>> import json
>>> q = '{"text":"\u4
    

    • 

  • Hibernate的总结
永夜-极光
Hibernate

    1.hibernate的作用,简化对数据库的编码,使开发人员不必再与复杂的sql语句打交道
 
做项目大部分都需要用JAVA来链接数据库，比如你要做一个会员注册的 页面，那么 获取到用户填写的 基本信后，你要把这些基本信息存入数据库对应的表中，不用hibernate还有mybatis之类的框架，都不用的话就得用JDBC，也就是JAVA自己的，用这个东西你要写很多的代码，比如保存注册信
    

    • 

  • SyntaxError: Non-UTF-8 code starting with '\xc4'
随便小屋
python

    刚开始看一下Python语言，传说听强大的，但我感觉还是没Java强吧！
写Hello World的时候就遇到一个问题，在Eclipse中写的，代码如下
'''
Created on 2014年10月27日
@author: Logic
'''
print("Hello World!");
 运行结果
SyntaxError: Non-UTF-8 
    

    • 

  • 学会敬酒礼仪 不做酒席菜鸟
aijuans
菜鸟

    俗话说，酒是越喝越厚，但在酒桌上也有很多学问讲究，以下总结了一些酒桌上的你不得不注意的小细节。
细节一：领导相互喝完才轮到自己敬酒。敬酒一定要站起来，双手举杯。
细节二：可以多人敬一人，决不可一人敬多人，除非你是领导。
细节三：自己敬别人，如果不碰杯，自己喝多少可视乎情况而定，比如对方酒量，对方喝酒态度，切不可比对方喝得少，要知道是自己敬人。
细节四：自己敬别人，如果碰杯，一
    

    • 

  • 《创新者的基因》读书笔记
aoyouzi
读书笔记《创新者的基因》

    创新者的基因
 
创新者的“基因”，即最具创意的企业家具备的五种“发现技能”：联想，观察，实验，发问，建立人脉。
 
第一部分破坏性创新，从你开始
第一章破坏性创新者的基因
如何获得启示：
发现以下的因素起到了催化剂的作用：(1) -个挑战现状的问题；(2)对某项技术、某个公司或顾客的观察；(3) -次尝试新鲜事物的经验或实验；(4)与某人进行了一次交谈，为他点醒
    

    • 

  • 表单验证技术
百合不是茶
JavaScriptDOM对象String对象事件

    js最主要的功能就是验证表单,下面是我对表单验证的一些理解,贴出来与大家交流交流  ,数显我们要知道表单验证需要的技术点, String对象,事件,函数
 
一:String对象;通常是对字符串的操作;
 
1,String的属性;
 
字符串.length;表示该字符串的长度;
var str= "java"
    

    • 

  • web.xml配置详解之context-param
bijian1013
javaservletweb.xmlcontext-param

    一.格式定义：
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>contextConfigLocationValue></param-value>
</context-param>
作用：该元
    

    • 

  • Web系统常见编码漏洞（开发工程师知晓）
Bill_chen
sqlPHPWebfckeditor脚本

    1.头号大敌：SQL Injection
原因：程序中对用户输入检查不严格，用户可以提交一段数据库查询代码，根据程序返回的结果，
获得某些他想得知的数据，这就是所谓的SQL Injection，即SQL注入。
本质:
对于输入检查不充分，导致SQL语句将用户提交的非法数据当作语句的一部分来执行。
示例：
String query = "SELECT id FROM users
    

    • 

  • 【MongoDB学习笔记六】MongoDB修改器
bit1129
mongodb

    本文首先介绍下MongoDB的基本的增删改查操作，然后，详细介绍MongoDB提供的修改器，以完成各种各样的文档更新操作  MongoDB的主要操作
show dbs 显示当前用户能看到哪些数据库
use foobar 将数据库切换到foobar
show collections 显示当前数据库有哪些集合
db.people.update，update不带参数，可
    

    • 

  • 提高职业素养，做好人生规划
白糖_
人生

     
培训讲师是成都著名的企业培训讲师，他在讲课中提出的一些观点很新颖，在此我收录了一些分享一下。注：讲师的观点不代表本人的观点，这些东西大家自己揣摩。
 
1、什么是职业规划：职业规划并不完全代表你到什么阶段要当什么官要拿多少钱，这些都只是梦想。职业规划是清楚的认识自己现在缺什么，这个阶段该学习什么，下个阶段缺什么，又应该怎么去规划学习，这样才算是规划。
  
    

    • 

  • 国外的网站你都到哪边看？
bozch
技术网站国外

    学习软件开发技术，如果没有什么英文基础，最好还是看国内的一些技术网站，例如：开源OSchina，csdn，iteye,51cto等等。
个人感觉如果英语基础能力不错的话，可以浏览国外的网站来进行软件技术基础的学习，例如java开发中常用的到的网站有apache.org 里面有apache的很多Projects,springframework.org是spring相关的项目网站,还有几个感觉不错的
    

    • 

  • 编程之美-光影切割问题
bylijinnan
编程之美

    
package a;
public class DisorderCount {
/**《编程之美》“光影切割问题”
* 主要是两个问题：
* 1.数学公式（设定没有三条以上的直线交于同一点）：
* 两条直线最多一个交点，将平面分成了4个区域；
* 三条直线最多三个交点，将平面分成了7个区域；
* 可以推出：N条直线 M个交点，区域数为N+M+1。

    

    • 

  • 关于Web跨站执行脚本概念
chenbowen00
Web安全跨站执行脚本

    跨站脚本攻击(XSS)是web应用程序中最危险和最常见的安全漏洞之一。安全研究人员发现这个漏洞在最受欢迎的网站,包括谷歌、Facebook、亚马逊、PayPal,和许多其他网站。如果你看看bug赏金计划,大多数报告的问题属于 XSS。为了防止跨站脚本攻击,浏览器也有自己的过滤器,但安全研究人员总是想方设法绕过这些过滤器。这个漏洞是通常用于执行cookie窃取、恶意软件传播,会话劫持,恶意重定向。在
    

    • 

  • [开源项目与投资]投资开源项目之前需要统计该项目已有的用户数
comsci
开源项目

    
        现在国内和国外,特别是美国那边,突然出现很多开源项目,但是这些项目的用户有多少,有多少忠诚的粉丝,对于投资者来讲,完全是一个未知数,那么要投资开源项目,我们投资者必须准确无误的知道该项目的全部情况,包括项目发起人的情况,项目的维持时间..项目的技术水平,项目的参与者的势力,项目投入产出的效益.....
    

    • 

  • oracle alert log file（告警日志文件）
daizj
oracle告警日志文件alert log file

    The alert log is a chronological log of messages and errors, and includes the following items:
All internal errors (ORA-00600), block corruption errors (ORA-01578), and deadlock errors (ORA-00060) 
    

    • 

  • 关于 CAS SSO 文章声明
denger
SSO

    由于几年前写了几篇 CAS 系列的文章，之后陆续有人参照文章去实现，可都遇到了各种问题，同时经常或多或少的收到不少人的求助。现在这时特此说明几点：
1.  那些文章发表于好几年前了，CAS 已经更新几个很多版本了，由于近年已经没有做该领域方面的事情，所有文章也没有持续更新。
2. 文章只是提供思路，尽管 CAS 版本已经发生变化，但原理和流程仍然一致。最重要的是明白原理，然后
    

    • 

  • 初二上学期难记单词
dcj3sjt126com
englishword

    lesson 课
traffic 交通
matter 要紧；事物
happy 快乐的，幸福的
second 第二的
idea 主意；想法；意见
mean 意味着
important 重要的，重大的
never 从来，决不
afraid 害怕 的
fifth 第五的
hometown 故乡，家乡
discuss 讨论；议论
east 东方的
agree 同意；赞成
bo
    

    • 

  • uicollectionview 纯代码布局, 添加头部视图
dcj3sjt126com
Collection

    #import <UIKit/UIKit.h>
@interface myHeadView : UICollectionReusableView
{
UILabel *TitleLable;
}
-(void)setTextTitle;
@end
#import "myHeadView.h"
@implementation m
    

    • 

  • N 位随机数字串的 JAVA 生成实现
FX夜归人
javaMath随机数Random

    /**
* 功能描述 随机数工具类<br />
* @author FengXueYeGuiRen
* 创建时间 2014-7-25<br />
*/
public class RandomUtil {
// 随机数生成器
private static java.util.Random random = new java.util.R
    

    • 

  • Ehcache（09）——缓存Web页面
234390216
ehcache页面缓存

    页面缓存
目录
1       SimplePageCachingFilter
1.1      calculateKey
1.2      可配置的初始化参数
1.2.1     cach
    

    • 

  • spring中少用的注解@primary解析
jackyrong
primary

    这次看下spring中少见的注解@primary注解，例子
@Component
public class MetalSinger implements Singer{
@Override
public String sing(String lyrics) {
return "I am singing with DIO voice
    

    • 

  • Java几款性能分析工具的对比
lbwahoo
java

    Java几款性能分析工具的对比
摘自：http://my.oschina.net/liux/blog/51800
 
在给客户的应用程序维护的过程中，我注意到在高负载下的一些性能问题。理论上，增加对应用程序的负载会使性能等比率的下降。然而，我认为性能下降的比率远远高于负载的增加。我也发现，性能可以通过改变应用程序的逻辑来提升，甚至达到极限。为了更详细的了解这一点，我们需要做一些性能
    

    • 

  • JVM参数配置大全
nickys
jvm应用服务器

    JVM参数配置大全
/usr/local/jdk/bin/java -Dresin.home=/usr/local/resin -server -Xms1800M -Xmx1800M -Xmn300M -Xss512K -XX:PermSize=300M -XX:MaxPermSize=300M -XX:SurvivorRatio=8 -XX:MaxTenuringThreshold=5 -
    

    • 

  • 搭建 CentOS 6 服务器(14) - squid、Varnish
rensanning
varnish

    （一）squid
安装
# yum install httpd-tools -y
# htpasswd -c -b /etc/squid/passwords squiduser 123456
# yum install squid -y
设置
# cp /etc/squid/squid.conf /etc/squid/squid.conf.bak
# vi /etc/
    

    • 

  • Spring缓存注解@Cache使用
tom_seed
spring

    参考资料
http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/
http://swiftlet.net/archives/774
 
缓存注解有以下三个：
@Cacheable      @CacheEvict     @CachePut
    

    • 

  • dom4j解析XML时出现"java.lang.noclassdeffounderror: org/jaxen/jaxenexception"错误
xp9802

    java.lang.NoClassDefFoundError: org/jaxen/JaxenExc
关键字: java.lang.noclassdeffounderror: org/jaxen/jaxenexception
使用dom4j解析XML时，要快速获取某个节点的数据，使用XPath是个不错的方法，dom4j的快速手册里也建议使用这种方式
执行时却抛出以下异常：
Exceptio
    

    •