Java項目中使用Redis緩存案例

   緩存的目的是為了提高系統的性能，緩存中的數據主要有兩種： 

                1.熱點數據。我們將經常訪問到的數據放在緩存中，降低數據庫I/O,同時因為緩存的數據的高速查詢，加快整個系統的響應速度，也在一定程度上提高並發量。

                2.查詢耗時的數據。如果有一些數據查詢十分耗時，那么每次請求這些數據時，都去數據庫查詢的話，會使得系統響應速度特別低，數據庫cpu 100%。將這些數據放緩存，會極大提高系統響應速度，但同時數據實時性較差。

  最近工作中有碰到需要使用緩存的情況，場景如下：app端看板統計數據匯總，在打開app時加載看板數據，匯總數據來源於不同的庫，各個數據的生成接口已經寫好，只需要去調用接口整合數據返回即可。

  具體我們來看看是怎么實現的吧。

 

 第一步，取mysql中查詢各個接口的信息：

 getPanelInfo.java

/* service代碼略*/
List<PanelDto> panels = panelService.getAllPanels();   //得到接口的名稱，接口的url

 

第二步，根據拿到的信息生成請求參數：

 getPanelInfo.java

  WrapResponseModel resonseModel = new WrapResponseModel();
  Map<String, String> headers = new HashMap<>();
  headers.put("username", username);
  headers.put("token",token);
  List<String> content = new ArrayList<String>();
  for(PanelDto panelDto:panel){
  //發送http請求
       content.add(HttpRequestUtils.get(panelDto.getUrl(), headers));
}
// 返回格式
  responseModel.setCode(SUCCESS_CODE);
  responseModel.setData(content);

第三步，發送http請求調用接口：

HttpRequestUtils.java

public static String get(String url, Map<String, String> headers) {
        RequestConfig config = RequestConfig.custom().setConnectTimeout(TIME_OUT).setConnectionRequestTimeout(TIME_OUT).setSocketTimeout(TIME_OUT).build();
        String ret = null;
        //創建HttpClient對象
        CloseableHttpClient closeHttpClient = HttpClients.createDefault();
        CloseableHttpResponse httpResponse = null;
        //發送get請求
        HttpGet httpGet = new HttpGet(url);
        try {
            // add header
            if (Objects.nonNull(headers)) {
                Set<String> keys = headers.keySet();
                for (Iterator<String> i = keys.iterator(); i.hasNext(); ) {
                    String key = i.next();
                    httpGet.addHeader(key, headers.get(key));
                }
            }

            httpGet.setConfig(config);
            //執行Get請求 得到Response對象
            httpResponse = closeHttpClient.execute(httpGet);
            //httpResponse.getStatusLine() 響應頭信息
            int httpResponseCode = httpResponse.getStatusLine().getStatusCode();

            if (200 != httpResponseCode) {
                logger.error("http返回值異常， httpResponseCode = " + httpResponseCode);
            }

            //返回對象
            HttpEntity httpEntity = httpResponse.getEntity();
            ret = EntityUtils.toString(httpEntity, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            logger.error(e.getMessage(), e);
        } catch (ClientProtocolException e) {
            logger.error(e.getMessage(), e);
        } catch (IOException e) {
            //logger.error(e.getMessage(), e);
        } finally {
            if (httpResponse != null) {
                try {
                    httpResponse.close();
                } catch (IOException e) {
                    logger.error(e.getMessage(), e);
                }
            }
            if (closeHttpClient != null) {
                try {
                    closeHttpClient.close();
                } catch (IOException e) {
                    logger.error(e.getMessage(), e);
                }
            }
        }
        return ret;
    }

第四步，查詢數據set進redis，之后返回查詢的數據:

 getPanelInfo.java

 if (!Objects.equals(redisCache, "false")) {
2                 //redisttl過期時間 3                 redisProxyHandler.set(redisKey, JSON.toJSONString(responseModel), REDIS_TTL);
4                 logger.error("set succeed!!!!!!!!!!!!!!!!");
5             }

 redisHandler.java

  public void set(String key, String value, int seconds) {
            redisCacheProvider.set(key, value, seconds);
    }

 redisProvider.java

    @Autowired
    private JedisPool jedisPool;

    public Jedis getJedis() {
        Jedis jedis = this.jedisPool.getResource();
        //　使用index為2的database
        jedis.select(2);
        return jedis;
    }

    public void set(String key, String value, int seconds) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.setex(key, seconds, value);
            Long exp = jedis.ttl(key);
            if (exp < 0) {
                throw new RuntimeException("data time out！");19             }
        } catch (Throwable e) {
            logger.error(e.getMessage(), e);
            throw new TokenException(e.getMessage());
        } finally {
            if(jedis != null){jedis.close;}
        }
    }

第五步，請求接口的時候，先請求redis緩存,如果命中則返回命中數據，否則，將執行上面的發送http請求在拼湊數據返回的代碼：

getPanelInfo.java

                String panelInfo = redisProxyHandler.get(redisKey);
                Long expire = redisProxyHandler.getExpire(redisKey);
               //命中才返回，否則會去發http請求
                if (Objects.nonNull(panelInfo) && (expire > 0) && expire <REDIS_TTL) {
                 responseModel = JSON.parseObject(panelInfo, WrapResponseModel.class);
6                  return responseModel; 
7                  }

redisHandler.java

   public String get(String key) 
            return redisCacheProvider.get(key);
   }

redisProvider.java

      public String get(String key) {
        String value = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            value = jedis.get(key);
        } catch (Throwable e) {
            logger.error(e.getMessage(), e);
            throw new TokenException(e.getMessage());
        } finally {
            if(jedis != null){
                jedis.close();
           }
        }
        return value;
    }

 redis相關配置文件如下

applicationContext.xml

 <!-- 讀取配置文件信息 -->
    <context:property-placeholder location="classpath:redis.properties" file-encoding="UTF-8" ignore-unresolvable="true"/>

    <!-- Jedis 連接池配置 -->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="${redis.pool.maxTotal}"/>
        <property name="maxIdle" value="${redis.pool.maxIdle}"/>
        <property name="maxWaitMillis" value="${redis.pool.maxWaitMillis}"/>
        <property name="testOnBorrow" value="${redis.pool.testOnBorrow}"/>
    </bean>

    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
        <constructor-arg ref="jedisPoolConfig"/>
        <constructor-arg value="${jedis.host}" type="java.lang.String"/>
        <constructor-arg type="int" value="${jedis.port}"/>
    </bean>

redis.properties

# 控制一個pool可分配多少個jedis實例
redis.pool.maxTotal=1000
# 控制一個pool最多有多少個狀態為idle(空閑)的jedis實例
redis.pool.maxIdle=200
# 表示當borrow一個jedis實例時，最大的等待時間，如果超過等待時間，則直接拋出JedisConnectionException
redis.pool.maxWaitMillis=2000
#在borrow一個jedis實例時，是否提前進行validate操作；如果為true，則得到的jedis實例均是可用的
redis.pool.testOnBorrow=true
# redis 單機
# 單機 host
jedis.host=127.0.0.1
# 單機 port
jedis.port=6379

看了上面的代碼，我們知道一般的緩存是怎么使用的，在這個案例中，每個redisKey是根據請求的用戶名拼接特定的字符串生成的，每個請求用戶對應的key只在redis中保存一定的時間，過了指定的過期時間REDIS_TTL，數據將會被清除掉。