使用Java代码实现Redis和数据库数据同步

@configuration
public class redisconfig {
    @autowired
    redisconnectionfactory redisconnectionfactory;
 
    @autowired
    @qualifier("carservicedb")
    private carservice carservice;//操作数据库
    @bean
    public redismessagelistenercontainer listenercontainer(){
        //创建一个redis消息监听器容器对象
        redismessagelistenercontainer listenercontainer = new redismessagelistenercontainer();
         //设置redis连接工厂对象
        listenercontainer.setconnectionfactory(redisconnectionfactory);
 
        //向监听器容器中添加一个监听器，该监听器的主题为inserted
        listenercontainer.addmessagelistener(new messagelistener() {
            @override
            public void onmessage(message message, byte[] pattern) {
                system.out.println("*************insert*************");
 
                string carjsonstr = new string(message.getbody());
                car car = jsonobject.parseobject(carjsonstr, car.class);
 
                carservice.addcar(car);
 
 
 
                system.out.println(new string(message.getbody()));
                system.out.println(new string(pattern));
                system.out.println("*************insert*************");
            }
        }, new channeltopic(channelenum.inserted.name()));
 
        //向监听器容器中添加一个监听器，该监听器的主题为updated
        listenercontainer.addmessagelistener(new messagelistener() {
            @override
            public void onmessage(message message, byte[] pattern) {
                system.out.println("*************updated*************");
                string carjsonstr = new string(message.getbody());
                car car = jsonobject.parseobject(carjsonstr, car.class);
                carservice.updatacount(car.getbookid(),car.getnumber(),car.getuserid());
 
                system.out.println(new string(message.getbody()));
                system.out.println(new string(pattern));
                system.out.println("*************updated*************");
            }
        }, new channeltopic(channelenum.updated.name()));
 
        //向监听器容器中添加一个监听器，该监听器的主题为deleted
        listenercontainer.addmessagelistener(new messagelistener() {
            @override
            public void onmessage(message message, byte[] pattern) {
                system.out.println("*************deleted*************");
                system.out.println(new string(message.getbody()));
                system.out.println(new string(pattern));
 
                list<string[]> strings = jsonarray.parsearray(new string(message.getbody()), string[].class);
                string[] bookids = strings.get(0);
                string userid = strings.get(1)[0];
                carservice.delcar(bookids,userid);
                system.out.println("----------------------");
                system.out.println(arrays.tostring(bookids));
                system.out.println(userid);
                system.out.println("--------delete--------");
                system.out.println("*************deleted*************");
            }
        }, new channeltopic(channelenum.deleted.name()));
        return listenercontainer;
    }
}

@service("carservice")
@slf4j
public class carserviceimpl extends serviceimpl<carmapper, car> implements carservice {
    //购物车hash的key
    public static final string car_key = "carkey";
    //hash购物车中field的前缀
    public static final string user_car_hash_field_prefix = "car::";
    @resource
    private stringredistemplate stringredistemplate;
 
    /**
     * 这里存储的时候采用redis当中的hash存储
     *
     * @param car
     */
    @override
    @synchronized
    public void addcar(car car) {
        //这里存储的时候采用redis当中的hash存储
        hashoperations<string, string, string> opsforhash = stringredistemplate.opsforhash();
 
        //这里field为car_hash_field
        string usercarkey = user_car_hash_field_prefix + car.getuserid();
 
        //map<string,car>  键(存储bookid)  值存储购物车某一个商品的信息
        map<string, car> carmap = null;
        boolean flag = true;
        //获得redis中以存储的当前用户的购物车信息
        if (opsforhash.haskey(car_key, usercarkey)) {
            //存在当前用户的购物车信息，那么获取原有的数据
            string carmapjson = opsforhash.get(car_key, usercarkey);
 
            carmap = jsonobject.parseobject(carmapjson, new typereference<map<string, car>>() {
            });
 
            //检测当前购物车信息中是否包含新添加上的商品，如果包含则更新数量，如果不包含才新增
            if (carmap.containskey(car.getbookid())) {
                //获取原先商品的数量
                integer beforenumber = carmap.get(car.getbookid()).getnumber();
                log.info("beforenumber==============>{}", beforenumber);
                integer nownumber = car.getnumber(); //前端传过来现在的
                log.info("nownumber==============>{}", nownumber);
                carmap.get(car.getbookid()).setnumber(beforenumber + nownumber);
 
                flag = false; //存在商品
                //修改
 
                //包含才新增 图书的数量 在原有的基础上新增图书的数量
            } else {
                //新增
                //如果不包含当前商品信息 那么直接将商品添加到购物车信息当中
                carmap.put(car.getbookid(), car);
            }
        } else {
            /*   新增
             *
             * 当前的用户的购物车信息不存在
             *       首先把其添加的商品首先存储到carmap中
             * */
            carmap = new hashmap<>();
            carmap.put(car.getbookid(), car);
        }
 
        //最后将其存入redis当中
        opsforhash.put(car_key, usercarkey, jsonobject.tojsonstring(carmap));
 
        if (flag){
            //新增
            stringredistemplate.convertandsend(channelenum.inserted.name(), jsonobject.tojsonstring(carmap.get(car.getbookid())));
        }else {
            //修改
            stringredistemplate.convertandsend(channelenum.updated.name(), jsonobject.tojsonstring(carmap.get(car.getbookid())));
        }
    }
 
    @override
    public collection<car> getcarlist(string userid) {
        //这里存储的时候采用redis当中的hash存储
        hashoperations<string, string, string> opsforhash = stringredistemplate.opsforhash();
        string usercarkey = user_car_hash_field_prefix + userid;
        string jsonstr = opsforhash.get(car_key, usercarkey);
        map<string,car> carmap = jsonobject.parseobject(jsonstr, map.class);
        return carmap.values();
    }
 
    @override
    public void updatacount(string bookid, int number, string userid) {
        //这里存储的时候采用redis当中的hash存储
        hashoperations<string, string, string> opsforhash = stringredistemplate.opsforhash();
        string usercarkey = user_car_hash_field_prefix + userid;
 
        string jsonstr = opsforhash.get(car_key, usercarkey);
        map<string,car> carmap = jsonobject.parseobject(jsonstr, new typereference<map<string, car>>() {
        });
        if (!carmap.containskey(bookid)){ //不包含
            return;
        }
 
        car car = carmap.get(bookid);
        car.setnumber(number);
 
        //最后将其存入redis当中
        opsforhash.put(car_key, usercarkey, jsonobject.tojsonstring(carmap));
        stringredistemplate.convertandsend(channelenum.updated.name(), jsonobject.tojsonstring(carmap.get(car.getbookid())));
 
    }
 
    @override
    public void delcar(string[] bookids, string userid) {
        //获得操作redishash的对象
        hashoperations<string, string, string> forhash = stringredistemplate.opsforhash();
        string usercarkey = user_car_hash_field_prefix+userid;
        list<string[]> list = new arraylist<>();
        //从redis中获取用户对应的购物车数据
        string carjsonstr = forhash.get(car_key, usercarkey);
        //修改指定商品的数量
        map<string,car> carmap = jsonobject.parseobject(carjsonstr, new typereference<map<string,car>>() {
        });
        for(string bookid : bookids){
            carmap.remove(bookid);
        }
 
        //将修改后的数据重新添加到redis中
        forhash.put(car_key,usercarkey,jsonobject.tojsonstring(carmap));
        list.add(bookids);
        list.add(new string[]{userid});
 
        stringredistemplate.convertandsend(channelenum.deleted.name(), jsonobject.tojsonstring(list));
    }
}

listenercontainer.addmessagelistener(new messagelistener() {
            @override
            public void onmessage(message message, byte[] pattern) {
                
            }
        }, new channeltopic(channelenum.inserted.name()));