使用Jedis查询数据,使用接口默认方法完成缓存命中以及未命中的操作

首先是Jedis的Bean工厂

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisBeanFactory {

    private static final String HOST = "localhost";
    private static final int PORT = 6379;
    private static final String PASSWORD = "devroot";
    private static final int SELECT_DB = 0;

    public static Jedis JEDIS;

    public static JedisPool JEDIS_POOL;

    static {
        Jedis jedis = new Jedis(HOST, PORT);
        jedis.auth(PASSWORD);
        jedis.select(SELECT_DB);

        JEDIS = jedis;
        JEDIS_POOL = new JedisPool(new JedisPoolConfig(), HOST, PORT, 10000, PASSWORD);
    }

    /**
     * 获取默认 jedis
     *
     * @return jedis
     */
    public static Jedis get() {
        return JEDIS;
    }

    /**
     * 获取自定义jedis
     *
     * @param host     服务地址
     * @param port     服务端口
     * @param password 密钥
     * @param selectDB 选择数据页
     * @return jdis
     */
    public static Jedis get(String host, int port, String password, int selectDB) {
        Jedis jedis = new Jedis(
                host,
                port
        );
        jedis.auth(password);
        jedis.select(selectDB);
        return jedis;
    }

    /**
     * 从连接池获取Jedis
     *
     * @return jedis
     */
    public static Jedis getByConnectionPool() {
        Jedis jedis = JEDIS_POOL.getResource();
        jedis.select(SELECT_DB);
        return jedis;
    }

}

缓存尝试接口

public interface TryToGetFromCache <T>{

    // 命中缓存的抽象方法
    T hit(String key);

    // 缓存未命中以后重新获取源数据的抽象方法
    T miss(String key);

    /**
     * 执行查询
     * @param key key
     * @param seconds 过期时间  -1为永久
     * @return
     */
    default T query(String key,int seconds ){
        // 调用用户指定的查询缓存方法
        T hit = this.hit(key);
        // 如果缓存命中则返回,未命中调用用户指定的回源方法
        if ( hit instanceof String && StringUtils.isNotBlank((String)hit)) {
            return hit;
        }
        // 回源查询,如果命中则保存至缓存
        T miss = miss(key);
        if ( miss instanceof String && StringUtils.isNotBlank((String)miss)) {
            Jedis jedis = JedisBeanFactory.get();
            jedis.set(key, JSONObject.toJSONString(miss));
            jedis.expire(key,seconds);
            return miss;
        }
        return miss;
    }
}

使用

public class CacheServiceImpl {

    public static void main(String[] args) {
        CacheServiceImpl cacheService = new CacheServiceImpl();
        String query = cacheService.query();
        System.out.println(query);
    }

    /**
     * 查询
     * @return
     */
    public String query(){
        TryToGetFromCache<String> getFromCache = new TryToGetFromCache<String>() {
        	// 查询缓存的逻辑
            @Override
            public String hit(String key) {
                return JedisBeanFactory.get().get(key);
            }
			// 回源逻辑
            @Override
            public String miss(String key) {
                return "张三！"; // 这里临时模仿一下数据库
            }
        };
        String result = getFromCache.query("AName", 20);
        System.out.println(result);
        // 这里是获取到资源后的一系列操作
        // ........................
        return result;
    }
}

Json转map使用这个方法可以赋予泛型

改为Lambda写法

@FunctionalInterface
public interface LambdaGetFromCache<T>{

    // 缓存未命中以后重新获取源数据的抽象方法
    T miss();

    /**
     * 执行查询
     * @param key key
     * @param resultClass 结果类型
     * @param seconds 缓存时间
     * @return
     */
    default T query(String key,Class<T> resultClass,int seconds){
        Jedis jedis = JedisBeanFactory.get();
        String redisJson = jedis.get(key);

        if (StringUtils.isNotBlank(redisJson)) {
            try {
              return JSONObject.parseObject(redisJson,resultClass);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        // 回源查询,如果命中则保存至缓存
        T miss = miss();
        if (ObjectUtil.isNotEmpty(miss)) {
            jedis.set(key, JSONObject.toJSONString(miss));
            jedis.expire(key,seconds);
            return miss;
        }
        return miss;
    }
}

Lambda写法的使用

public class CacheServiceImpl {

    public static void main(String[] args) {
        CacheServiceImpl cacheService = new CacheServiceImpl();
        Weapon weapon = cacheService.query();
        System.out.println(weapon);
    }

    /**
     * 查询
     *
     * @return
     */
    public Weapon query() {
        // 写缓存未命中之后的回源逻辑,这里只是一个示范，实际中应该是查询数据库
        LambdaGetFromCache<Weapon> getFromCache = () -> Weapon.builder()
                .name("AR-15")
                .code("ar15rDIAS")
                .price(998)
                .build();
        // 执行查询
        Weapon result = getFromCache.query("Weapon",Weapon.class, 30);

        // 这里是获取到资源后的一系列操作
        // ........................
        return result;
    }
}