java中复杂业务情况下的集合操作（增减集合同步数据）

大家好，我是雄雄，欢迎关注微信公众号：雄雄的小课堂

现在是：2022年7月5日16:14:28

前言

今天分享个案例，需求是这样的：一个团组中是可以包含多个会员，在给团组创建训练方案时，本质上是给每个会员分别制定了一套训练方案。那么会有个问题，比如创建一个团组A，里面有会员1，会员2，会员3，然后给团组A创建了个方案，那么对应的三个会员都有训练方案，此时，将会员4拉到团组A中，此时会员4是没有任何方案的，所以我们现在要做的就是将会员4也同步上团组A的方案。

思路

在给团组新建完方案之后，通过团组管理是可以对该团组中的成员增加或者减少的，就像微信群聊一样，既可以重新邀人，也可以踢人出去。只是我们的业务里面加入了方案的概念。

新加的人就需要同步训练方案，删除的人就需要删掉他的方案，这个地方我是这样处理的：

1. 通过java中集合的方法，找出哪些是新加的人，哪些是减去的人。
2. 将团组和两个集合（新加的人的集合和减少的人的集合）传入到处理方案的方法中去操作
3. 涉及到两个系统，一个是我方系统，一个是训练方案系统，并且都是我写的，所以接口操作起来就比较方便。

具体代码

团组管理

		/**
	 * 修改团组 团组里面编辑成员时，更新对应的训练方案
	 */
	@PostMapping("/updateGroup")
	@ApiOperationSupport(order = 2)
	@ApiOperation(value = "app-新增团组", notes = "传入teamGroup")
	public R updateGroup(@RequestBody TeamGroup teamGroup) {
		//1.先把原来的人放在一个集合中
		List<Long> userListOld = new ArrayList<>();
		LambdaQueryWrapper<GroupUser> groupUserLambdaQueryWrapper = new LambdaQueryWrapper<>();
		groupUserLambdaQueryWrapper.eq(GroupUser::getGroupId, teamGroup.getId());
		//集合去重
		List<GroupUser> groupUserList =
			groupUserService
				.list(groupUserLambdaQueryWrapper)
				.stream()
				.distinct()
				.collect(Collectors.toList());
		for (GroupUser groupUser : groupUserList) {
			//将原来的用户添加到这个集合中
			userListOld.add(groupUser.getUserId());
		}
		//拿到人员集合，把关联表中的数据，根据团组id把之前的数据都删掉，
		//然后再重新添加新获得的人员集合.
		groupUserService.remove(groupUserLambdaQueryWrapper);
		//2.将新更新过来的人放在一个集合中
		List<Long> userListNew = new ArrayList<>();
		if (teamGroup.getUserIds() != null && !"".equals(teamGroup.getUserIds())) {
			userListNew = CommonUtil.transLongList(teamGroup.getUserIds());
			//设置团组人数
			teamGroup.setNumPeople(userListNew.size());
			//把人员和团组在关联表中维护起来.
			for (int i = 0; i < userListNew.size(); i++) {
				GroupUser groupUser = new GroupUser();
				groupUser.setGroupId(teamGroup.getId());
				User user = userService.getUserById(userListNew.get(i));
				groupUser.setUserId(user.getId());
				groupUser.setUserName(user.getName());
				groupUser.setIsDeleted(0);
				groupUserService.save(groupUser);
			}
		}
		//3.两个集合比较哪些是新增的，哪些是删除的
		//新增的会员
		List<Long> userListAdd = new ArrayList<>(userListNew);
		userListAdd.removeAll(userListOld);
		//输出集合中的元素
		System.out.println("新增了的会员：");
		userListAdd.forEach(System.out::println);
		//删除了的会员
		List<Long> userListDel = new ArrayList<>(userListOld);
		userListDel.removeAll(userListNew);
		//输出集合中的元素
		System.out.println("删除了的会员：");
		userListDel.forEach(System.out::println);
		//传给训练方案系统，团组id,要删除的会员集合，要新增的会员集合--2022年7月5日13:56:15 updateer:穆雄雄
		R r = trainingSchemeUrlService.updateProgrammeByGroupIdAndOldUserIdAndNewUserId(teamGroup.getId(),userListAdd,userListDel);
		if(r.getCode()!=200){
			return R.fail("同步团组训练方案失败");
		}
		//更新团组的基础信息
		return R.status(teamGroupService.updateById(teamGroup));
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

代码中基本都有注释，下面我来分析一下关键的代码，比较两个集合中哪些是新增的，哪些是删除的？

	//新增的会员
		List<Long> userListAdd = new ArrayList<>(userListNew);
		userListAdd.removeAll(userListOld);
		//输出集合中的元素
		System.out.println("新增了的会员：");
		userListAdd.forEach(System.out::println);
		//删除了的会员
		List<Long> userListDel = new ArrayList<>(userListOld);
		userListDel.removeAll(userListNew);
		//输出集合中的元素
		System.out.println("删除了的会员：");
		userListDel.forEach(System.out::println);
1
2
3
4
5
6
7
8
9
10
11
12

接下来就是在本系统中调用训练方案系统的同步方案接口了，具体代码如下：

Service接口层：

		/**
	 * 团组更新成员时，方案也跟着同步
	 * @param
	 * @param
	 * @param
	 * @return
	 */
	R  updateProgrammeByGroupIdAndOldUserIdAndNewUserId(Long groupId, List<Long> userListAdd, List<Long>userListDel);

1
2
3
4
5
6
7
8
9

ServiceImpl实现类：

	@Override
	public R updateProgrammeByGroupIdAndOldUserIdAndNewUserId(Long groupId, List<Long> userListAdd, List<Long> userListDel) {
		//请求接口地址
		String url = TrainingSchemeConstant.updateProgrammeByGroupIdAndOldUserIdAndNewUserId;
		JSONObject jsonObject = new JSONObject();
		jsonObject.putOpt("groupId", groupId);
		jsonObject.putOpt("userListAdd", userListAdd);
		jsonObject.putOpt("userListDel", userListDel);
		try {
			String body = HttpRequest.post(url)
				.header("Content-Type", "application/json")
				.body(jsonObject.toString())
				.execute().body();
			if (StringUtils.isBlank(body)) {
				return R.fail("操作失败");
			}
			JSONObject obj = JSONUtil.parseObj(body);
			if (obj == null) {
				return R.fail("操作失败");
			}
			String code = obj.get("code").toString();
			if ("200".equals(code)) {
				return R.success("操作成功");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

接口地址工具类：

	/**
		 * 根据会员Id 状态 时间,查询所有动作
		 */
		public String updateProgrammeByGroupIdAndOldUserIdAndNewUserId = TRAINING_PROGRAMME+"/api/trainingprogramev3/updateProgrammeByGroupIdAndOldUserIdAndNewUserId";

1
2
3
4
5

训练方案系统中同步团组方案

	/**
	 * 根据团组id，新老用户的id编辑方案
	 * 2022年5月31日22:16:01
	 * 穆雄雄
	 *
	 * @return
	 */
	@PostMapping(value = "/updateProgrammeByGroupIdAndOldUserIdAndNewUserId")
	public String updateProgrammeByGroupIdAndOldUserIdAndNewUserId(@RequestBody GroupUpdateUser groupUpdateUser) {
		JSONObject jsonObject = new JSONObject();
		if (groupUpdateUser.getGroupId() == null) {
			jsonObject.put("code", 500);
			jsonObject.put("success", false);
			jsonObject.put("msg", "团组id不能为空");
		}
		//先从redis里面取一下，如果redis里面没有的话，就执行下面的内容
		Map<String, Object> programmeMap = bladeRedis.get("createGroupProgramme:" + groupUpdateUser.getGroupId());
		System.out.println("团组在编辑会员的时候，redis中的数据是：" + programmeMap);
		Programme programme = null;
		TeamGroup teamGroup = null;
		//方案的集合
		List<Programme> programmeList = new ArrayList<>();
		//时间戳
		Long timechuo = null;
		//缓存里面没有
		QueryWrapper<TeamGroup> teamGroupQueryWrapper = new QueryWrapper<>();
		teamGroupQueryWrapper.eq("group_id", groupUpdateUser.getGroupId()).orderByDesc("id").last("limit 1");
		teamGroup = teamGroupService.getOne(teamGroupQueryWrapper);
		//判断如果缓存里面没有的话，查询一下实际的
		if (programmeMap == null) {
			//没有方案的话
			if (teamGroup == null) {
				jsonObject.put("code", 200);
				jsonObject.put("success", true);
				jsonObject.put("msg", "操作成功");
				return jsonObject.toJSONString();
			}
			//将peibeizhu的值修改一下
			//根据方案的id查询出来方案信息
			programme = programmeService.getById(teamGroup.getProgrammeId());
			timechuo = programme.getTimechuo();
			System.out.println("编辑方案时，redis缓存里面没有数据");
		}else{
			//获取缓存中的时间戳
			timechuo = (Long) programmeMap.get("timechuo");
			System.out.println("编辑方案时，redis缓存里面有数据");
		}


		//aid的集合，最后放在pbeizhu里面去
		List<Long> pBeiZhuAidList = new ArrayList<>();
		//根据时间戳查询出所有方案
		LambdaQueryWrapper<Programme> programmeLambdaQueryWrapper = new LambdaQueryWrapper<>();
		programmeLambdaQueryWrapper.eq(Programme::getTimechuo, timechuo);
		List<Programme> programmeListByTimeChuo = programmeService.list(programmeLambdaQueryWrapper);
		programmeListByTimeChuo.forEach(pro -> {
			//重新赋值pbeizhu的值
			pBeiZhuAidList.add(pro.getPaid());
			programmeList.add(pro);
		});

		//运动员主键id集合
		List<Long> aidList = new ArrayList<>();
		//同步一下新加的用户信息
		if (groupUpdateUser.getUserListAdd().size() > 0) {
			for (Long aid : groupUpdateUser.getUserListAdd()) {
				Athletes athletes = new Athletes();
				LambdaQueryWrapper<Athletes> athletesLambdaQueryWrapper = new LambdaQueryWrapper<>();
				athletesLambdaQueryWrapper.eq(Athletes::getWorkcode, aid);
				List<Athletes> athleteList = athletesService.list(athletesLambdaQueryWrapper);
				if (athleteList.size() > 0) {
					//找到了
					athletes = athleteList.get(0);
				} else {
					//没有找到
					athletes.setAname(aid.toString());
					athletes.setWorkcode(aid.toString());
					athletesService.save(athletes);
				}
				aidList.add(athletes.getId());
			}

		}
		//加上了的成员
		for (Long aid : aidList) {
			//根据时间戳和用户id查询方案，有则添加，无则不用
			LambdaQueryWrapper<Programme> programmeWrapper = new LambdaQueryWrapper<>();
			programmeWrapper
				.eq(Programme::getPaid, aid)
				.eq(Programme::getTimechuo, timechuo)
				.last("limit 1");
			List<Programme> programmeQueryList = programmeService.list(programmeWrapper);
			if (programmeQueryList.size() == 0) {
				if(programme==null){
					programme = programmeList.get(0);
				}
				//远动员主键
				programme.setPaid(aid);
				//是否是团组方案 0是 1 不是
				programme.setIsGroupProgramme(0);
				//给用户保存方案
				programmeService.save(programme);
			}
		}

		//将运动员的主键拿到放在集合里面（删除方案）--暂时先不删除了。因为怕误删掉个人的方案 2022年7月4日21:23:19
		if (groupUpdateUser.getUserListDel().size() > 0) {
			//删除了的成员
			for (Long uid : groupUpdateUser.getUserListDel()) {
				//去运动员表卡里面查询这个人的编号
				LambdaQueryWrapper<Athletes> athletesLambdaQueryWrapper = new LambdaQueryWrapper<>();
				athletesLambdaQueryWrapper.select(Athletes::getId)
					.eq(Athletes::getWorkcode, uid)
					.last("limit 1");
				Athletes athletes = athletesService.getOne(athletesLambdaQueryWrapper);
				if (athletes != null) {
					//（遗留了bug，如果这个人正好是这个团组的最后一个方案的话，删掉之后，会导致团组和方案关联表中的方案id在方案里面找不到）
					//将方案表中的paid是这个人的都删掉
					Map<String, Object> map = new HashMap<>();
					map.put("paid", athletes.getId());
					map.put("timechuo", programme.getTimechuo());
					//map.put("is_group_programme",0);
					//物理删除
					programmeService.delProgrammeByAid(map);
				}
			}
		}


		//把集合中的
		String pbeizhu = StringUtils.join(pBeiZhuAidList, ",");
		programmeListByTimeChuo.forEach(pro -> {
			//重新赋值pbeizhu的值
			pro.setPbeizhu(pbeizhu);
			//修改pbiezhu的信息
			programmeService.updateById(pro);
		});
		//重新修改团组和方案关联表的方案id
		if (programmeList.size() > 0) {
			//将最后一个方案的Id修改到
			teamGroup.setProgrammeId(programmeList.get(programmeList.size() - 1).getId().longValue());
			teamGroupService.updateById(teamGroup);
		}
		jsonObject.put("code", 200);
		jsonObject.put("success", true);
		jsonObject.put("msg", "操作成功");
		return jsonObject.toJSONString();
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

代码中使用了redis，刚开始将方案的信息放在了redis中，在操作方案的时候先从redis中取，如果缓存中没有，则从库里面查询，如果有，则直接使用。