java推送缓存Redis

一、redis基本配置：/project/src/main/resources/beans.redis : redis.xml

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 
 3 <beans
 4     xmlns="http://www.springframework.org/schema/beans"
 5     xmlns:tx="http://www.springframework.org/schema/tx"
 6     xmlns:aop="http://www.springframework.org/schema/aop"
 7     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 8     xmlns:context="http://www.springframework.org/schema/context"
 9     xsi:schemaLocation="
10         http://www.springframework.org/schema/beans 
11         http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
12         http://www.springframework.org/schema/context
13         http://www.springframework.org/schema/context/spring-context-4.0.xsd
14         http://www.springframework.org/schema/aop
15         http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
16         http://www.springframework.org/schema/tx
17         http://www.springframework.org/schema/tx/spring-tx-4.0.xsd"
18     default-lazy-init="false">
19     
20     <!-- redis连接池的配置 -->
21     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
22         <!-- 最大连接数 -->
23         <property name="maxTotal" value="${redis.maxTotal}" />
24         <!-- 最大空闲连接数 -->
25         <property name="maxIdle" value="${redis.maxIdle}" />
26         <!-- 最小空闲连接数 -->
27         <property name="minIdle" value="${redis.minIdle}" />
28         <!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
29         <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
30         <!-- 在获取连接的时候检查有效性, 默认false -->
31         <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
32         <!--  -->
33         <!-- <property name="testOnReturn" value="${redis.testOnReturn}"/> -->
34     </bean>
35     
36     <!-- redis连接工厂 -->
37      <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
38         <!-- <property name="password" value="${redis.password}"/> -->
39         <property name="usePool" value="true"/>
40         <property name="hostName" value="${redis.host}" />
41         <property name="port" value="${redis.port}" />
42         <property name="poolConfig" ref="jedisPoolConfig" />
43     </bean> 
44     
45     <!-- redis 操作模板 -->
46      <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
47         <property name="connectionFactory" ref="jedisConnectionFactory" />
48         <property name="keySerializer">
49             <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
50         </property>
51         <property name="valueSerializer">
52             <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
53         </property>
54     </bean> 
55     
56     
57 </beans>

二、资源文件（redis参数值配置）：/project/src/main/resources/configs : redisServerConfig.properties

 1 #可用连接实例的最大数目，默认值为8
 2 redis.maxTotal=512
 3 #控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8
 4 redis.maxIdle=50
 5 redis.minIdle=0
 6 #等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
 7 redis.maxWaitMillis=10000
 8 #在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
 9 redis.testOnBorrow=true
10 
11 redis.host=192.168.17.246
12 redis.port=6379

三、redis封装工具类：/yst_sit/src/main/java/utils ： RedisUtils.java

  1 /**
  2  * 
  3  */
  4 package kklazy.utils;
  5 
  6 import java.util.List;
  7 import java.util.Map;
  8 import java.util.concurrent.TimeUnit;
  9 
 10 import javax.annotation.Resource;
 11 
 12 import org.springframework.data.redis.core.HashOperations;
 13 import org.springframework.data.redis.core.StringRedisTemplate;
 14 import org.springframework.data.redis.serializer.GenericToStringSerializer;
 15 
 16 import com.alibaba.fastjson.JSON;
 17 
 18 /**
 19  * @author 20  * 缓存工具类
 21  */
 22 @org.springframework.stereotype.Component
 23 public class RedisUtils {
 24     
 25     @Resource(name="redisTemplate")
 26     private StringRedisTemplate redisTemplate;
 27     
 28     public void test(){
 29         System.out.println("111");
 30     }
 31     public <T> T get(String key, String hashKey, Class<T> cls) {
 32         Object obj = redisTemplate.opsForHash().get(key, hashKey);
 33         if (obj == null) {
 34             return null;
 35         }
 36         
 37         return JSON.parseObject(obj.toString(), cls);
 38     }
 39     
 40     public <T> List<T> getList(String key, String hashKey, Class<T> cls) {
 41         Object obj = redisTemplate.opsForHash().get(key, hashKey);
 42         if (obj == null) {
 43             return null;
 44         }
 45         
 46         return JSON.parseArray(obj.toString(), cls);
 47     }
 48 
 49     public String get(String key) {
 50         redisTemplate.setValueSerializer(new GenericToStringSerializer<String>(String.class));
 51         Object obj = redisTemplate.opsForValue().get(key);
 52         if (obj == null) {
 53             return null;
 54         } else {
 55             return String.valueOf(obj);
 56         }
 57     }
 58     
 59     public void set(String key,String value){
 60         redisTemplate.opsForValue().set(key, value);
 61     }
 62     
 63     public void set(String key,String value,int timeout){
 64         redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.DAYS);
 65     }
 66     
 67     public void set(String key,String hashKey,Object value){
 68         HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
 69         hash.put(key, hashKey, value);
 70     }
 71     public void setMap(String key,Map<String,Object> map ){
 72          //添加 一个 hash集合
 73         HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
 74         hash.putAll(key, map);
 75     }
 76     
 77     public String getMap(String key,String mapKey ){
 78         Object obj = redisTemplate.opsForHash().get(key, mapKey);
 79         if (obj == null) {
 80             return null;
 81         } else {
 82             return String.valueOf(obj);
 83         }
 84     }
 85     public Map<Object, Object>  getAllMap(String key){
 86         Map<Object, Object> obj = (Map<Object, Object>)redisTemplate.opsForHash().entries(key);
 87         return obj;
 88         
 89     }
 90     
 91     //
 92     public void delMap(String key,String mapKey){
 93         redisTemplate.opsForHash().delete(key, mapKey);
 94     }
 95     
 96     
 97     public boolean isExists(String key){
 98         return redisTemplate.hasKey(key);
 99         
100     }
101     public boolean isExists(String key,String hashKey){
102         return redisTemplate.opsForHash().hasKey(key, hashKey);
103         
104     }
105     
106     public void del(String key){
107         redisTemplate.delete(key);
108     }
109     
110     
111 }

四、java代码实现缓存更新（推送缓存、删除缓存）

1.service：BaseBankPoscontrastService.java 

  1 /**
  2  * 
  3  */
  4 package kklazy.acqinstmanagement.service;
  5 
  6 import java.util.HashMap;
  7 import java.util.List;
  8 import java.util.Map;
  9 
 10 import org.apache.commons.collections.CollectionUtils;
 11 import org.apache.commons.lang3.StringUtils;
 12 import org.hibernate.criterion.DetachedCriteria;
 13 import org.hibernate.criterion.Restrictions;
 14 import org.springframework.beans.factory.annotation.Autowired;
 15 import org.springframework.stereotype.Service;
 16 import org.springframework.transaction.annotation.Transactional;
 17 
 18 import com.alibaba.fastjson.JSON;
 19 
 20 import kklazy.acqinstmanagement.model.BaseBankPoscontrastConfig;
 21 import kklazy.acqinstmanagement.model.BaseChannelParam;
 22 import kklazy.acqinstmanagement.model.RoutePayforminfoConfig;
 23 import kklazy.acqinstmanagement.model.BaseBankPoscontrast;
 24 import kklazy.api.model.Merchant;
 25 import kklazy.api.service.MerchantService;
 26 import kklazy.persistence.callback.AssembleCriteriaParamsCallBack;
 27 import kklazy.persistence.support.CommonResponse;
 28 import kklazy.quas.service.DefaultQuasService;
 29 import kklazy.utils.RedisUtils;
 30 
 31 /**
 32  * @author 33  *
 34  */
 35 @Service
 36 @Transactional(rollbackFor=Exception.class)
 37 public class BaseBankPoscontrastService extends DefaultQuasService<BaseBankPoscontrast,String> {
 38 
 39     
 40     @Autowired
 41     private MerchantService merchantService;
 42     @Autowired
 43     private RoutePayforminfoConfigService routePayforminfoConfigService;
 44     @Autowired
 45     private BaseChannelParamService baseChannelParamService;
 46     @Autowired
 47     private RedisUtils redisUtils;
 48        //更新缓存
 49         public CommonResponse getPushCaching(BaseBankPoscontrast pos,String type,CommonResponse retval){
 50             String key="fmtct_"+pos.getFormid()+"_"+pos.getMerchantcodeIn()+"_"+pos.getTermnoIn()+"_"+pos.getChannelid()+"_"+pos.getTranstype();
 51             BaseBankPoscontrastConfig psc=new BaseBankPoscontrastConfig();
 52             Map<String,Object> map = new HashMap<String,Object>();
 53             RoutePayforminfoConfig rpc=new RoutePayforminfoConfig();
 54             rpc.setFormId(pos.getFormid());
 55             rpc.setMerchNo(pos.getMerchantcodeIn());
 56             rpc.setStatus("00");
 57             List<RoutePayforminfoConfig> rpclist=routePayforminfoConfigService.getRoutePayforminfoConfigs(rpc);
 58             if(rpclist.size()!=1){
 59                 retval.setResult(false);
 60                 retval.setMessage("平台编码为："+pos.getFormid()+"，商户号为："+pos.getMerchantcodeIn()+"时，查询平台商户交易信息表（ROUTE_PAYFORMINFO_CONFIG）数据不是一条，请查询");
 61                 return retval;
 62             }
 63             Merchant merch=new Merchant();
 64             merch.setOrgCode(rpclist.get(0).getOrgCode());
 65             merch.setMerchNo(pos.getMerchantcodeIn());
 66             merch.setStatus("00");
 67             List<Merchant> merchant = merchantService.getMerchantsByCondition(merch);
 68             if(merchant.size()!=1){
 69                 retval.setResult(false);
 70                 retval.setMessage("该记录对应的受理商户数据不是一条，请查询。机构号："+rpclist.get(0).getOrgCode()+"，商户号："+pos.getMerchantcodeIn());
 71                 return retval;
 72             }
 73             psc.setChannelid(StringUtils.isNotBlank(pos.getChannelid()) ? pos.getChannelid():"");
 74             psc.setFormid(StringUtils.isNotBlank(pos.getFormid()) ? pos.getFormid():"");
 75             psc.setFormtype(StringUtils.isNotBlank(pos.getFormtype()) ? pos.getFormtype():"");
 76             BaseChannelParam bcp=new BaseChannelParam();
 77             bcp.setChannelId(pos.getChannelid());
 78             List<BaseChannelParam> bcplist=baseChannelParamService.getBaseChannelParams(bcp);
 79             psc.setFlag((CollectionUtils.isEmpty(bcplist)||StringUtils.isBlank(bcplist.get(0).getCode())) ? "" : bcplist.get(0).getCode());
 80             psc.setMerabbr((CollectionUtils.isEmpty(merchant)||StringUtils.isBlank(merchant.get(0).getSname())) ?"": merchant.get(0).getSname());
 81             psc.setMername((CollectionUtils.isEmpty(merchant)||StringUtils.isBlank(merchant.get(0).getCname())) ? "": merchant.get(0).getCname());
 82             psc.setMercatcode((CollectionUtils.isEmpty(rpclist)||StringUtils.isBlank(rpclist.get(0).getMccCode())) ? "": rpclist.get(0).getMccCode());
 83             psc.setMerchantcode_in((null == pos||StringUtils.isBlank(pos.getMerchantcodeIn())) ?"": pos.getMerchantcodeIn());
 84             psc.setMerchantcode_out((null == pos||StringUtils.isBlank(pos.getMerchantcodeOut())) ?"": pos.getMerchantcodeOut());
 85             psc.setTermno_in((null == pos||StringUtils.isBlank(pos.getTermnoIn())) ? "": pos.getTermnoIn());
 86             psc.setTermno_out((null == pos||StringUtils.isBlank(pos.getTermnoOut())) ? "": pos.getTermnoOut());
 87             psc.setTranstype((null == pos||StringUtils.isBlank(pos.getTranstype())) ?  "": pos.getTranstype());
 88             
 89             if(type.equals("00")){
 90                 //推缓存
 91                 System.out.println("原:key："+key+",value:"+redisUtils.getMap("route_bank_poscontrast", key));
 92                 redisUtils.set("route_bank_poscontrast", key, JSON.toJSONString(psc));    
 93                 System.out.println("Now:key："+key+",value:"+redisUtils.getMap("route_bank_poscontrast", key));
 94             }else{
 95                 //删缓存
 96                 redisUtils.delMap("route_bank_poscontrast",key);    
 97                 //判断商户路由数据结构key是否存在
 98                 if(redisUtils.isExists("route_bank_poscontrast",key)){
 99                     retval.setResult(false);
100                     retval.setMessage("删除该缓存失败,key为:route_bank_poscontrast+"+key+"!!!");
101                     return retval;
102                 }
103                 System.out.println("删除缓存成功：key为：route_bank_poscontrast+"+key);
104                 retval.setMessage("更新缓存成功");
105             }
106             return retval;
107         }
108         
109 }

2.controller:BaseBankPoscontrastController.java 

  1 /**
  2  * 
  3  */
  4 package kklazy.acqinstmanagement.controller;
  5 
  6 import java.util.List;
  7 
  8 import javax.annotation.Resource;
  9 import javax.servlet.http.HttpServletRequest;
 10 import javax.servlet.http.HttpServletResponse;
 11 
 12 import org.apache.commons.collections.CollectionUtils;
 13 import org.apache.commons.lang3.StringUtils;
 14 import org.hibernate.criterion.DetachedCriteria;
 15 import org.hibernate.criterion.MatchMode;
 16 import org.hibernate.criterion.Restrictions;
 17 import org.springframework.beans.factory.annotation.Autowired;
 18 import org.springframework.data.domain.Page;
 19 import org.springframework.data.domain.PageRequest;
 20 import org.springframework.data.domain.Sort;
 21 import org.springframework.data.domain.Sort.Direction;
 22 import org.springframework.stereotype.Controller;
 23 import org.springframework.ui.ModelMap;
 24 import org.springframework.web.bind.annotation.PathVariable;
 25 import org.springframework.web.bind.annotation.RequestMapping;
 26 import org.springframework.web.bind.annotation.ResponseBody;
 27 
 28 import kklazy.acqinstmanagement.model.RoutePayforminfoConfig;
 29 import kklazy.acqinstmanagement.model.BaseBankPoscontrast;
 30 import kklazy.acqinstmanagement.model.BaseBankPoscontrastParam;
 31 import kklazy.acqinstmanagement.service.RoutePayforminfoConfigService;
 32 import kklazy.acqinstmanagement.service.BaseBankPoscontrastService;
 33 import kklazy.api.model.BaseChannelMerchant;
 34 import kklazy.api.model.BaseOrg;
 35 import kklazy.api.model.BaseTransType;
 36 import kklazy.api.model.Merchant;
 37 import kklazy.api.service.BaseChannelMerchantService;
 38 import kklazy.api.service.BaseOrgService;
 39 import kklazy.api.service.BaseTransTypeService;
 40 import kklazy.api.service.MerchantService;
 41 import kklazy.common.constants.ContextConstants;
 42 import kklazy.common.controller.BasePageController;
 43 import kklazy.merchentry.channel.institution.model.BaseChannelEntity;
 44 import kklazy.merchentry.channel.institution.service.BaseChannelService;
 45 import kklazy.persistence.callback.AssembleCriteriaParamsCallBack;
 46 import kklazy.persistence.model.DefaultPageQueryModel;
 47 import kklazy.persistence.service.PageService;
 48 import kklazy.persistence.support.CommonResponse;
 49 import kklazy.persistence.utils.DateUtils;
 50 import kklazy.security.context.SecurityApplicationContext;
 51 import kklazy.security.service.DictionaryService;
 52 import kklazy.terminalinfo.modle.AcceptanceTerminalEntity;
 53 import kklazy.terminalinfo.modle.AcceptanceTerminalPk;
 54 import kklazy.terminalinfo.modle.TerminalChannelEntity;
 55 import kklazy.terminalinfo.modle.TerminalChannelPk;
 56 import kklazy.terminalinfo.service.AcceptanceTerminalService;
 57 import kklazy.terminalinfo.service.TerminalChannelService;
 58 
 59 /**
 60  * @author 61  *
 62  */
 63 @Controller
 64 @RequestMapping("baseBankPoscontrast")
 65 public class BaseBankPoscontrastController extends BasePageController<BaseBankPoscontrast,String> {
 66 
 67     private static final String OPERATION_TYPE = "operationType";
 68     private static final String OPERATION_CREATE = "create";
 69     private static final String OPERATION_MODIFY = "modify";
 70     private static final String OPERATION_COPY_AND_CREATE = "copy_and_create";
 71     private static final String PAGE_TRANSTYPE = "transtypes";
 72     private static final String PAGE_FORMTYPE = "formtypes";
 73     private static final String PAGE_CHANNEL = "channels";
 74     private static final String PAGE_BASEORG = "baseorg";
 75     private static final String PAGE_CHANNEL_MERCHANT = "channelmerchant";
 76     private static final String PAGE_MERCHANT = "merchant";
 77     private static final String PAGE_BASE_TERMINAL= "baseTerminalList";
 78     private static final String PAGE_TERMINAL_CHANNEL= "terminalChannelList";
 79     @Autowired
 80     public BaseBankPoscontrastService baseBankPoscontrastSerivce;
 81     @Autowired
 82     private BaseTransTypeService baseTransTypeService;
 83     
 84     
 85     @Resource(name = "defaultBaseChannelService")
 86     private BaseChannelService baseChannelService;
 87     
 88     @Autowired
 89     private BaseOrgService baseOrgService;
 90     
 91     @Autowired
 92     private BaseChannelMerchantService baseChannelMerchantService;
 93     
 94     @Autowired
 95     private MerchantService merchantService;
 96     
 97     @Autowired
 98     private RoutePayforminfoConfigService routePayforminfoConfigService;
 99     
100     @Autowired
101     private DictionaryService dictionaryService;
102 
103     @Resource(name="acceptanceTerminalService")
104     private AcceptanceTerminalService acceptanceTerminalService;
105     
106     @Resource(name="terminalChannelService")
107     private TerminalChannelService terminalChannelService;
108     
109     @Override
110     public PageService<BaseBankPoscontrast, String> pageservice() {
111         return baseBankPoscontrastSerivce;
112     }
113     
114     @Override
115     public String path() {
116         return "/webpages/acqinstmanagement/baseBankPoscontrast";
117     }
118     
119     
120     /**
121      * 保存（修改功能暂时去掉，不可修改。目前只可新增数据和删除数据（缓存同步））
122      * @param request
123      * @param response
124      * @param modelMap
125      * @param entity
126      * @return
127      */
128     @Override
129     protected CommonResponse commithandler(HttpServletRequest request, HttpServletResponse response, ModelMap modelMap,
130             BaseBankPoscontrast entity) {
131         retval = CommonResponse.SUCCESS();
132         // 新增
133         if (OPERATION_CREATE.equals(request.getParameter(OPERATION_TYPE))) {
134             // 生成Id
135 //            String id=DateUtils.format("yyMMdd")+baseBankPoscontrastSerivce.getSeqBaseBankPoscontrastId();
136 //            entity.setId(id);
137             // 状态赋值为00（正常）
138             entity.setStatus("00");
139             entity.setFormtype("0001");
140             // 增加创建时间
141             entity.setEntdate(DateUtils.currentDate());
142 
143         } 

155         // 增加操作人
156         entity.setOperaname(SecurityApplicationContext.getEmployee().getName());
157         try {
158             baseBankPoscontrastSerivce.merge(entity);//保存数据
159         } catch (Exception e) {
160             e.printStackTrace();
161             retval.setMessage("保存数据失败");
162             retval.setResult(false);
163             return retval;
164         }
165         retval.setMessage("保存数据成功");
166         try {
167             retval = baseBankPoscontrastSerivce.getPushCaching(entity,"00",retval);
168         } catch (Exception e) {
169             e.printStackTrace();
170             retval.setMessage("保存数据成功，推送缓存失败");
171             retval.setResult(false);
172             return retval;
173         }//更新缓存
174         if(retval.isResult()){
175             retval.setMessage("保存数据/推送缓存成功");
176         }
177         
178         return retval;
179 //        return super.commithandler(request, response, modelMap, entity);
180     }
181     @Override
182     @ResponseBody
183     @RequestMapping({ "/delete/{id}" })
184     public CommonResponse delete(HttpServletRequest request, HttpServletResponse response, ModelMap modelMap,@PathVariable String id) throws Exception {
185         //baseBankPoscontrastCheck pos= new baseBankPoscontrastCheck();
186         retval = CommonResponse.SUCCESS();
187         BaseBankPoscontrast pos= new BaseBankPoscontrast();
188         try {
189             if(StringUtils.isNotBlank(id)){
190                 pos = service().findBy(id);            
191             }
192             if(StringUtils.isNotBlank(pos.getStatus())){
193                 if ("00".equals(pos.getStatus())) {
194                     pos.setStatus("01");
195                 } else {
196                     pos.setStatus("00");
197                 }
198             }
199         
200             pos.setUpddate(DateUtils.currentDate());
201             pos.setOperaname(SecurityApplicationContext.getUsername());
202             try {
203                 baseBankPoscontrastSerivce.merge(pos);
204             } catch (Exception e) {
205                 e.printStackTrace();
206                 retval.setMessage("更新数据库失败");
207                 retval.setResult(false);
208                 return retval;
209             }
210             retval.setMessage("更新数据库成功");
211             //更新缓存
212             try {
213                 retval = baseBankPoscontrastSerivce.getPushCaching(pos,pos.getStatus(),retval);
214             } catch (Exception e) {
215                 e.printStackTrace();
216                 retval.setMessage("推送缓存失败");
217                 retval.setResult(false);
218                 return retval;
219             }
220             
221         } catch (Exception e) {
222             logger.error(e.getMessage());
223             return CommonResponse.FAILURE();
224         }
225         if(retval.isResult()){
226             retval.setMessage("更新数据库/推送缓存成功");
227         }
228         return retval;
229     }
230     
231 
232 }

五、更新缓存后，去缓存服务器去查看是否更新

1.通过安装redis-desktop-manager.exe查看是否更新缓存

2.secureCRT:登录进服务器：输入linux命令，根据key查询是否更新缓存：redis ------->cli------------>hget 大key  小key