Redis穿透问题解决方案详解编程语言

package com.toov5.service; 
 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.cache.ehcache.EhCacheCacheManager; 
import org.springframework.stereotype.Component; 
 
import net.sf.ehcache.Cache; 
import net.sf.ehcache.Element; 
 
 
@Component 
public class EhCacheUtils { 
 
    // @Autowired 
    // private CacheManager cacheManager; 
    @Autowired 
    private EhCacheCacheManager ehCacheCacheManager; 
 
    // 添加本地缓存 (相同的key 会直接覆盖) 
    public void put(String cacheName, String key, Object value) { 
        Cache cache = ehCacheCacheManager.getCacheManager().getCache(cacheName); 
        Element element = new Element(key, value); 
        cache.put(element); 
    } 
 
    // 获取本地缓存 
    public Object get(String cacheName, String key) { 
        Cache cache = ehCacheCacheManager.getCacheManager().getCache(cacheName); 
        Element element = cache.get(key); 
        return element == null ? null : element.getObjectValue(); 
    } 
 
    public void remove(String cacheName, String key) { 
        Cache cache = ehCacheCacheManager.getCacheManager().getCache(cacheName); 
        cache.remove(key); 
    } 
 
}

package com.toov5.service; 
 
import java.util.Set; 
import java.util.concurrent.TimeUnit; 
 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.data.redis.core.StringRedisTemplate; 
import org.springframework.stereotype.Component; 
 
@Component 
public class RedisService { 
 
    @Autowired 
    private StringRedisTemplate stringRedisTemplate; 
    //这样该方法支持多种数据类型  
    public void set(String key , Object object, Long time){ 
        //开启事务权限 
        stringRedisTemplate.setEnableTransactionSupport(true); 
        try { 
            //开启事务 
            stringRedisTemplate.multi(); 
             
            String argString =(String)object;  //强转下 
            stringRedisTemplate.opsForValue().set(key, argString); 
             
            //成功就提交 
            stringRedisTemplate.exec(); 
        } catch (Exception e) { 
            //失败了就回滚 
            stringRedisTemplate.discard(); 
             
        } 
        if (object instanceof String ) {  //判断下是String类型不 
            String argString =(String)object;  //强转下 
            //存放String类型的 
            stringRedisTemplate.opsForValue().set(key, argString); 
        } 
        //如果存放Set类型 
        if (object instanceof Set) { 
            Set<String> valueSet =(Set<String>)object; 
            for(String string:valueSet){ 
                stringRedisTemplate.opsForSet().add(key, string);  //此处点击下源码看下 第二个参数可以放好多 
            } 
        } 
        //设置有效期 
        if (time != null) { 
            stringRedisTemplate.expire(key, time, TimeUnit.SECONDS); 
        } 
         
    } 
    //做个封装 
    public void setString(String key, Object object){ 
        String argString =(String)object;  //强转下 
        //存放String类型的 
        stringRedisTemplate.opsForValue().set(key, argString); 
    } 
    public void setSet(String key, Object object){ 
        Set<String> valueSet =(Set<String>)object; 
        for(String string:valueSet){ 
            stringRedisTemplate.opsForSet().add(key, string);  //此处点击下源码看下 第二个参数可以放好多 
        } 
    } 
     
    public String getString(String key){ 
     return    stringRedisTemplate.opsForValue().get(key); 
    } 
     
     
}

package com.toov5.service; 
 
import java.util.concurrent.locks.Lock; 
import java.util.concurrent.locks.ReentrantLock; 
 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Service; 
import org.springframework.web.bind.annotation.RequestMapping; 
 
import com.toov5.entity.Users; 
import com.toov5.mapper.UserMapper; 
 
import io.netty.util.internal.StringUtil; 
 
@Service 
public class SnowslideService { 
    @Autowired 
    private UserMapper userMapper;  
    @Autowired 
    private RedisService redisService; 
     
    private Lock lock = new ReentrantLock(); 
     
    public String getUser01(Long id){ 
    //定义key， key以当前的类名+方法名+id+参数值 
    String key = this.getClass().getName() + "-" + Thread.currentThread().getStackTrace()[1].getMethodName() 
                        + "-id:" + id;     
          //1查询redis 
    String username = redisService.getString(key); 
    if (!StringUtil.isNullOrEmpty(username)) { 
        return username; 
    } 
    String resultUsaerName = null; 
    try { 
        //开启锁 
        lock.lock(); 
        Users user = userMapper.getUser(id); 
        if (username == null) { 
            return null; 
        } 
        resultUsaerName =user.getName(); 
        redisService.setString(key, resultUsaerName); 
    } catch (Exception e) { 
        // TODO: handle exception 
    }finally { 
        //释放锁 
        lock.unlock(); 
    } 
          //3直接返回 
    return resultUsaerName; 
    } 
     
     
     
//穿透解决方案     
    public String getUser02(Long id){ 
    //定义key， key以当前的类名+方法名+id+参数值 
    String key = this.getClass().getName() + "-" + Thread.currentThread().getStackTrace()[1].getMethodName() 
                        + "-id:" + id;     
          //1查询redis 
    System.out.println("查询redis缓存"+"key"+key+".resultUserName"); 
    String username = redisService.getString(key); 
    if (!StringUtil.isNullOrEmpty(username)) { 
        return username; 
    } 
    String resultUsaerName = null; 
    //如果数据库中，没有对应的数据信息的时候 
       System.out.println("查询数据库：id"+id); 
        Users user = userMapper.getUser(id); 
        if (user == null) { 
            resultUsaerName="${null}";  //做个标记  客户端识别到后 提示下吧 
             
        }else { 
            resultUsaerName=user.getName(); 
        } 
        System.out.println("写入redis缓存"+"key"+key+".resultUserName"+resultUsaerName); 
        redisService.setString(key, resultUsaerName); 
 
          //3直接返回 
    return resultUsaerName; 
    } 
     
     
}

package com.toov5.service; 
 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Component; 
 
import com.alibaba.fastjson.JSONObject; 
import com.toov5.entity.Users; 
import com.toov5.mapper.UserMapper; 
 
 
import io.netty.util.internal.StringUtil; 
 
@Component 
public class UserService { 
    @Autowired 
    private EhCacheUtils ehCacheUtils; 
    @Autowired 
    private RedisService redisService; 
    @Autowired 
    private UserMapper userMapper; 
    //定义个全局的cache名字 
    private String cachename ="userCache"; 
     
    public Users getUser(Long id){ 
        //先查询一级缓存  key以当前的类名+方法名+id+参数值 
        String key = this.getClass().getName() + "-" + Thread.currentThread().getStackTrace()[1].getMethodName() 
                + "-id:" + id; 
        //查询一级缓存数据有对应值的存在 如果有 返回 
        Users user = (Users)ehCacheUtils.get(cachename, key); 
        if (user != null) { 
            System.out.println("key"+key+",直接从一级缓存获取数据"+user.toString()); 
            return user; 
        } 
        //一级缓存没有对应的值存在,接着查询二级缓存     
        // redis存对象的方式  json格式 然后反序列号 
        String userJson = redisService.getString(key); 
        //如果rdis缓存中有这个对应的值，修改一级缓存    最下面的会有的 相同会覆盖的     
        if (!StringUtil.isNullOrEmpty(userJson)) {  //有 转成json 
            JSONObject jsonObject = new JSONObject();//用的fastjson 
            Users resultUser = jsonObject.parseObject(userJson,Users.class); 
            ehCacheUtils.put(cachename, key, resultUser); 
            return resultUser; 
        } 
        //都没有 查询DB  
        Users user1 = userMapper.getUser(id); 
        if (user1 == null) { 
            return null; 
        } 
        //保证两级缓存有效期相同！？   一级缓存时间-二级缓存执行的时间 
        //一级缓存时间 等于 二级缓存剩下的时间    
        //存放到二级缓存 redis中 
        redisService.setString(key, new JSONObject().toJSONString(user1)); 
        //存放到一级缓存 Ehchache 
        ehCacheUtils.put(cachename, key, user1); 
        return user1; 
    } 
     
     
     
}

package com.toov5.mapper; 
 
import java.util.List; 
 
import org.apache.ibatis.annotations.Param; 
import org.apache.ibatis.annotations.Select; 
import org.springframework.cache.annotation.CacheConfig; 
import org.springframework.cache.annotation.Cacheable; 
 
import com.toov5.entity.Users; 
//引入的jar包后就有了这个注解了 非常好用 （配置缓存的基本信息） 
@CacheConfig(cacheNames={"userCache"})  //缓存的名字  整个类的 
public interface UserMapper { 
    @Select("SELECT ID ,NAME,AGE FROM users where id=#{id}") 
    @Cacheable //让这个方法实现缓存 查询完毕后 存入到缓存中  不是每个方法都需要缓存呀！save()就不用了吧 
    Users getUser(@Param("id") Long id); 
}

package com.toov5.entity; 
 
import java.io.Serializable; 
 
import lombok.Data; 
 
@Data 
public class Users implements Serializable{ 
  private String name; 
  private Integer age; 
}

package com.toov5.controller; 
 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.RestController; 
 
import com.toov5.service.SnowslideService; 
 
@RestController 
public class UserRedisController { 
   @Autowired 
   private SnowslideService snowslideService; 
    
   @RequestMapping("/getUser02") 
   public String getUser02(Long id){ 
       return snowslideService.getUser02(id);  
   } 
    
}

package com.toov5.controller; 
 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.RestController; 
 
import com.toov5.entity.Users; 
import com.toov5.service.UserService; 
 
@RestController 
public class IndexController { 
    @Autowired 
    private UserService userService; 
     
    @RequestMapping("/userId") 
    public Users getUserId(Long id){ 
        return userService.getUser(id);   
    } 
     
    
}

package com.toov5.app; 
 
import org.mybatis.spring.annotation.MapperScan; 
import org.springframework.boot.SpringApplication; 
import org.springframework.boot.autoconfigure.SpringBootApplication; 
import org.springframework.cache.annotation.EnableCaching; 
 
@EnableCaching //开启缓存 
@MapperScan(basePackages={"com.toov5.mapper"}) 
@SpringBootApplication(scanBasePackages={"com.toov5.*"}) 
public class app { 
   public static void main(String[] args) { 
    SpringApplication.run(app.class, args); 
} 
     
}