java --关注/取消关注

业务需求：A、B两个用户的关注/取消关注接口

1.接口文档以下

2.数据库设计以下

3.数据库数据存放以下

由数据库设计文档和数据库存放关系可知，

数据 1000000004 既能够在数据库的A位置，也能够在数据库的B位置。

3.该接口的webservice思路以下

关注/取消关注 用户的思路
参数：用户A、用户B、关注/取消关注flag
A和B的关系，假设A在数据库的A位置
00 A关注B
01 B关注A
02 A、B相互关注
备注：A在数据库的B位置时，如上关系为0一、00、02
思路以下：
0.去数据库查询A、B这两个用户有没有关系(00/01/02)
1.点击关注 --说明A和B的关系：1>没有关系；2>B关注A
1-1.判断A和B的关系
1-2.若是没有关系，则添加一条数据
1-3.若是有关系，则将关系改成相互关注(这个要结合实际，若是A已经关注了B，则A不能在关注B了，即进来
的确定是B点击了关注A)
2.点击取消关注 --说明A和B的关系：1>A关注B；2>A、B相互关注
2-1.判断A和B的关系
2-2.若是是关注(结合实际，只有相互关注和关注两种关系)，则取消关注，即删除这条数据
2-3.若是是相互关注，则须要判断A和B的位置
2-3-1 若是A在数据库的A位置，则修改A和B的关系为被关注--即关系为01
2-3-2 若是A在数据库的B位置，则修改A和B的关系为被关注--即关系为00

4.该接口的java代码以下

@Service
public class UserFollowServiceImpl implements UserFollowService {

    @Autowired
    private UserFollowMapper userFollowMapper;

    /**
     * 关注(取消关注)用户
     * 
     * @param userIdB
     *            被关注者id
     * @param userId
     *            用户Id
     * @param flag
     *            0：关注 1：取消关注
     */
    @Override
    public ResultObject updateOrInsertUserFocus(UserFollowVO userFollowVO)
            throws DataAccessException {
        boolean needBreak = false;
        String userId = userFollowVO.getUserId();
        String userIdB = userFollowVO.getUserIdB();
        String flag = userFollowVO.getFlag();
        ResultObject ro = new ResultObject();
        ro.setResultCode(ResultCode.FAILED);

        if (StringUtils.isBlank(userIdB) || StringUtils.isBlank(userId)
                || StringUtils.isBlank(flag)) {
            ro.setResultCode(ResultCode.FAILED);
            ro.setResultMsg(ResultMsg.MSG_PARAM_ERROR);
            needBreak = true;
        }
        if (!needBreak) {
            // 当前时间
            String timeNow = Utils.getSysTime();
            // 查找双方关系
            UserFollow userFollow = userFollowMapper.updateOrInsertUserFocus(
                    userId, userIdB);
            // 点击须要关注
            if (flag.equals(Constant.FOLLOW)) {
                if (userFollow != null) {
                    // 已经存在关注关系，改成相互关注
                    userFollowMapper.updUserFocus(userId, userIdB,
                            Constant.A_BOTH_B, timeNow);
                    int temp = userFollowMapper.selectCount(userIdB);
                    ro.setData(temp);
                    HashMap<String, Object> map = new HashMap<>();
                    map.put("focusNums", temp);
                    ro.setData(map);
                    ro.setResultCode(ResultCode.SUCCESS);
                } else {
                    // 不存在关注关系，改成单方面关注
                    userFollowMapper.insertUserFocus(userId, userIdB,
                            Constant.A_FOLLOW_B, timeNow);
                    int temp = userFollowMapper.selectCount(userIdB);
                    ro.setData(temp);
                    HashMap<String, Object> map = new HashMap<>();
                    map.put("focusNums", temp);
                    ro.setData(map);
                    ro.setResultCode(ResultCode.SUCCESS);
                }

                ro.setResultMsg(ResultMsg.MSG_FOLLOW_SUCCESS);
            } else {
                // 取消关注
                if (userFollow != null) {
                    // 相互关注
                    if (userFollow.getFollowFlag().equals(Constant.A_BOTH_B)) {
                        // 判断操做用户是否在A位置
                        int count = userFollowMapper.getUserIdPosition(userId,
                                userIdB);
                        // 若是关注者在A位置，被关注这在B位置，改成'01'
                        if (count > 0) {
                            userFollowMapper.updUserFocus(userId, userIdB,
                                    Constant.B_FOLLOW_A, timeNow);
                            int temp = userFollowMapper.selectCount(userIdB);
                            HashMap<String, Object> map = new HashMap<>();
                            map.put("focusNums", temp);
                            ro.setData(map);
                            ro.setResultCode(ResultCode.SUCCESS);
                        } else {
                            // 若是关注者在B位置，被关注这在A位置，改成'00'
                            userFollowMapper.updUserFocus(userId, userIdB,
                                    Constant.A_FOLLOW_B, timeNow);
                            int temp = userFollowMapper.selectCount(userIdB);
                            HashMap<String, Object> map = new HashMap<>();
                            map.put("focusNums", temp);
                            ro.setData(map);
                            ro.setResultCode(ResultCode.SUCCESS);
                        }
                    } else {
                        // 单方面关注，删除关系
                        userFollowMapper.deleteUserFocus(userId, userIdB);
                        int temp = userFollowMapper.selectCount(userIdB);
                        HashMap<String, Object> map = new HashMap<>();
                        map.put("focusNums", temp);
                        ro.setData(map);
                        ro.setResultCode(ResultCode.SUCCESS);
                    }
                    ro.setResultMsg(ResultMsg.MSG_CANCLE_FOLLOW_SUCCESS);
                }
            }
        }
        return ro;
    }
}