package project.party.recom.internal;
|
|
import java.io.Serializable;
|
import java.util.ArrayList;
|
import java.util.LinkedList;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import kernel.exception.BusinessException;
|
import kernel.util.StringUtils;
|
import kernel.web.ApplicationUtil;
|
import project.party.PartyRedisKeys;
|
import project.party.model.UserRecom;
|
import project.party.recom.UserRecomService;
|
import project.redis.RedisHandler;
|
|
@SuppressWarnings("unchecked")
|
public class UserRecomServiceImpl implements UserRecomService {
|
|
private RedisHandler redisHandler;
|
|
private static final Logger logger=LoggerFactory.getLogger(UserRecomServiceImpl.class);
|
|
/**
|
* 存储推荐关系
|
*/
|
public void save(UserRecom entity) {
|
if(null==entity) return;
|
|
checkRecommended(entity.getPartyId(), entity.getReco_id());
|
|
if(null==entity.getId()) entity.setId(ApplicationUtil.getCurrentTimeUUID());
|
ApplicationUtil.executeInsert(entity);
|
|
redisHandler.setSync(PartyRedisKeys.USER_RECOM_PARTYID + entity.getPartyId().toString(), entity);
|
List<UserRecom> recos = (List<UserRecom>) redisHandler.get(PartyRedisKeys.USER_RECOM_RECO_ID + entity.getReco_id().toString());
|
if (recos == null) recos=new ArrayList<UserRecom>();
|
recos.add(entity);
|
|
redisHandler.setSync(PartyRedisKeys.USER_RECOM_RECO_ID + entity.getReco_id().toString(), recos);
|
}
|
|
/**
|
* 修改推荐关系
|
*/
|
public void update(Serializable partyId, Serializable reco_id) {
|
//检查是否存在推荐关系,如果存在则抛出异常
|
checkRecommended(partyId, reco_id);
|
|
//先查缓存再查询数据库
|
UserRecom entity=findByPartyId(partyId);
|
if (null==entity) {
|
List<UserRecom> list=ApplicationUtil.executeSelect(UserRecom.class,"WHERE PARTY_ID=?",new Object[] {partyId});
|
if(null!=list && list.size()>0) {
|
entity=list.get(0);
|
if(list.size()>1) logger.error("data record duplication and get first record,found multiple same PARTY_ID: {}",partyId);
|
}
|
}
|
|
//如果缓存和数据库中都没有找到该用户则创建该用户
|
if (null==entity) {
|
entity = new UserRecom();
|
entity.setPartyId(partyId);
|
entity.setId(ApplicationUtil.getCurrentTimeUUID());
|
}
|
|
//变更推荐人之前获取以前的(旧的)推荐人,方便后续从旧推荐人的推荐集合中移除他自己
|
Serializable reco_id_old = entity.getReco_id();
|
|
//绑定或变更新的推荐人
|
entity.setReco_id(reco_id);
|
|
//保存或修改推荐关系
|
ApplicationUtil.executeInsertOrUpdate(entity,"WHERE UUID=?",new Object[] {entity.getId()});
|
redisHandler.setSync(PartyRedisKeys.USER_RECOM_PARTYID + entity.getPartyId().toString(), entity);
|
|
//如果当前用户以前有推荐人,则从他以前的推荐人的推荐集合中移除他自己
|
if (null!=reco_id_old) {
|
List<UserRecom> recos_oldList = (List<UserRecom>) redisHandler.get(PartyRedisKeys.USER_RECOM_RECO_ID + reco_id_old.toString());
|
while(recos_oldList.remove(entity));
|
redisHandler.setSync(PartyRedisKeys.USER_RECOM_RECO_ID + reco_id_old.toString(), recos_oldList);
|
}
|
|
//从新推荐人的推荐集合中加入当前用户自己
|
List<UserRecom> recos = (List<UserRecom>) redisHandler.get(PartyRedisKeys.USER_RECOM_RECO_ID + reco_id.toString());
|
if (null==recos) recos = new ArrayList<UserRecom>();
|
recos.add(entity);
|
redisHandler.setSync(PartyRedisKeys.USER_RECOM_RECO_ID + reco_id.toString(), recos);
|
}
|
|
/**
|
* 根据用户ID从缓存中获取此用户的推荐关系
|
* @param partyId 用户ID
|
* @return 推荐关系实体对象
|
*/
|
public UserRecom findByPartyId(Serializable partyId) {
|
return null==partyId?null:(UserRecom) redisHandler.get(PartyRedisKeys.USER_RECOM_PARTYID+partyId);
|
}
|
|
/**
|
* 向上查找用户的推荐树
|
* @param partyId 用户ID
|
* @return 推荐树节点列表(含用户自己)
|
*/
|
public List<UserRecom> getParents(Serializable partyId) {
|
LinkedList<UserRecom> list = new LinkedList<UserRecom>();
|
if (partyId == null) return list;
|
list = findParents(partyId, list);
|
return list;
|
}
|
|
/**
|
* 向上查找用户的祖先节点推荐树(含用户自己)
|
* @param partyId 用户ID
|
* @param list 推荐树节点列表
|
* @return 推荐树节点列表(含用户自己)
|
*/
|
private LinkedList<UserRecom> findParents(Serializable partyId, LinkedList<UserRecom> list) {
|
if(null==partyId) return list;
|
UserRecom userRecom = (UserRecom) redisHandler.get(PartyRedisKeys.USER_RECOM_PARTYID + partyId);
|
if(null==userRecom) return list;
|
|
list.add(userRecom);
|
findParents(userRecom.getReco_id(), list);
|
|
return list;
|
}
|
|
/**
|
* 向下查找参数ID对应推荐人推荐的下级用户集合
|
* @param partyId 推荐人ID
|
* @return 推荐的下级用户列表(直接下级用户集合,不含孙子及后裔节点)
|
*/
|
public List<UserRecom> findRecoms(Serializable partyId) {
|
List<UserRecom> list = (List<UserRecom>) redisHandler.get(PartyRedisKeys.USER_RECOM_RECO_ID + partyId.toString());
|
return null==list?new ArrayList<UserRecom>():list;
|
}
|
|
/**
|
* 向下查找参数ID对应推荐人推荐的下级用户ID集合
|
* @param partyId 推荐人ID
|
* @return 推荐的下级用户ID列表(直接下级用户集合,不含孙子及后裔节点)
|
*/
|
public List<String> findRecomsToPartyId(Serializable partyId) {
|
List<UserRecom> recom_list = findRecoms(partyId);
|
return recom_list.stream().map(userRecom->userRecom.getPartyId().toString()).collect(Collectors.toList());
|
}
|
|
/**
|
* 检查两用户间是否存在直接或间接的推荐关系
|
* @param partyId1 第一个用户
|
* @param partyId2 第二个用户
|
*/
|
public void checkRecommended(Serializable partyId1, Serializable partyId2) {
|
String errorTip="两用户间已经存在直接或间接推荐关系,不能修改已经存在的推荐关系层级的先后顺序!";
|
List<UserRecom> recom_list1 = getParents(partyId1);
|
for (int i = 0; i < recom_list1.size(); i++) {
|
if (partyId2.toString().equals(((UserRecom) recom_list1.get(i)).getReco_id().toString())) {
|
throw new BusinessException(errorTip);
|
}
|
}
|
|
List<UserRecom> recom_list2 = getParents(partyId2);
|
for (int i = 0; i < recom_list2.size(); i++) {
|
if (partyId1.toString().equals(((UserRecom) recom_list2.get(i)).getReco_id().toString())) {
|
throw new BusinessException(errorTip);
|
}
|
}
|
}
|
|
/**
|
* 向下查找用户的后代节点推荐ID树(不含用户自己)
|
* @param partyId 用户ID
|
* @return 节点ID推荐树(不含用户自己)
|
*/
|
public List<String> findChildren(Serializable partyId) {
|
return findChildren(partyId, new ArrayList<String>());
|
}
|
|
/**
|
* 向下查找用户的后代节点推荐ID树(不含用户自己)
|
* @param partyId 用户ID
|
* @param list 节点ID推荐树
|
* @return 节点ID推荐树(不含用户自己)
|
*/
|
private ArrayList<String> findChildren(Serializable partyId, ArrayList<String> list) {
|
List<UserRecom> recom_list = findRecoms(partyId);
|
for (int i = 0; i < recom_list.size(); i++) {
|
list.add(((UserRecom) recom_list.get(i)).getPartyId().toString());
|
findChildren(((UserRecom) recom_list.get(i)).getPartyId().toString(), list);
|
}
|
return list;
|
}
|
|
/**
|
* 获取用户的后代节点推荐ID序列串(不含用户自己)
|
* @param loginPartyId 用户ID
|
* @return 后代节点推荐ID序列串(不含用户自己)
|
*/
|
public String findChildrensIds(String loginPartyId) {
|
if (StringUtils.isNullOrEmpty(loginPartyId)) return null;
|
List<String> children = findChildren(loginPartyId);
|
return children.isEmpty()?null:String.join(",",children.stream().map(id->"'"+id+"'").collect(Collectors.toSet()));
|
}
|
|
public void setRedisHandler(RedisHandler redisHandler) {
|
this.redisHandler = redisHandler;
|
}
|
}
|
