社交系统中用户好友关系 （添加好友）设计

于 2025-05-30 12:55:58 发布
阅读量745 收藏 11
点赞数 21
文章标签： java 数据库 交友
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45472715/article/details/148335841
版权

社交系统中用户好友关系 （添加好友）设计

用户需求：
在这里插入图片描述

接口设计：
1.<添加> 好友申请
好友申请：
例如 1208 申请 添加 1209 ，保存时，先存 MemberID=1208，状态Category=“no” ,等那边同意后再存 MemberID=1209，状态Category=“yes” ，然后修改 添加人1208 的数据状态 Category=“yes”;
（后续判断谁加的谁，添加人的关系id > 被添加人的关系id）
（例如：1208 1209 ） 一条数据是 单向好友
（例如：1209 1208 ） 1209 也有 1208的好友 （两条数据 双向好友）
添加前先判断当前用户是否已添加 (添加用户需要给关系表加一条数据，对方同意后再加一条，形成双向好友)
这里判断只需要判断当前用户有没有发起过好友申请,好友关系数据的删除在 同意申请逻辑中处理。
传参：用户id,好友id
2.<同意> 好友申请
同意申请: 根据 申请数据id修改 加好友时关系表 状态 no 改成 yes，且加一条 yes的数据，形成 双向好友。
（例如：1208 1209 ） 一条数据是 单向好友
（例如：1209 1208 ） 1209 也有 1208的好友 （两条数据 双向好友）
参数：申请数据id,category = yes
<拒绝> 好友申请
拒绝申请: 根据 申请数据id修改数据状态,软删除 (修改category申请状态：通过 yes, 暂未通过 no , 拒绝 refuse)
参数：申请数据id,category = refuse
3.<删除> 好友 (双向删除)
根据 好友id,自己的用户id，清空关系表
参数： 当前好友数据id
4.查询当前用户的 <申请列表> 发送的好友申请
参数: 用户id
查询: 只展示未通过的申请。（用id查询 关系表，状态=no/refuse的数据，refuse 前台标识 : 已拒绝）
select * from 关系表 where MemberID = 1208 and (Category = “no” or Category = “refuse”) ;
5.查询当前用户的 <申请通知> 收到的好友申请
参数: 用户id
select * from 关系表 where RelevanceID = 11 and Category = “no” ;
6.查询当前用户的 <好友列表>
参数: 用户id
查询好友列表： 用自己的id查询
select * from 关系表 where MemberID = 1208 and Category = “yes” ;

用户表
用户id | 用户姓名 |
1208 | 畅想 |
1204 | 小张 |
16 | ccc |
11 | xxx |

用户关系表（下面的字段 自定义 ，代码中用的是 复用表字段）

  • 我的好友 : 好友申请 FriendsRequest
  • 发起的好友列表： 申请列表 （姓名，头像） （通过，未通过，拒绝）
  • memberid (myid) 用户id
  • relevanceid (friendid) 好友id
  • category (code) 申请状态：通过 yes, 暂未通过 no , 拒绝 refuse
  • remark 他关注的好友 500 （好友列表人数）

在这里插入图片描述

Controller层

package com.bxproject.huaqiabroad.controller;

import com.bxproject.huaqiabroad.Server.FriendsRequestService;
import com.bxwl.common.base.Result;
import com.bxwl.common.utils.JwtUtil;
import com.bxwl.memberbase.model.Member;
import com.bxwl.memberbase.model.Memberfavorite;
import com.bxwl.memberbase.service.MemberService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 我的好友 : 好友申请 FriendsRequest
 * 发起的好友列表： 申请列表 （姓名，头像） （通过，未通过，拒绝）
 * memberid     用户id
 * relevanceid  好友id
 * category     申请状态：通过 yes, 暂未通过 no , 拒绝 refuse
 * remark       他关注的好友  500 （好友列表人数）
 */

@RestController
@RequestMapping({"friendsRequest"})
public class FriendsRequestController {
    private static final Logger log = LoggerFactory.getLogger(FriendsRequestController.class);

    @Resource
    private MemberService memberService;

    @Value("${local.authorizeforetoken}")
    private String authorizetoken;

    @Resource
    FriendsRequestService friendsRequestService;

    /**
     * <添加> 好友申请
     * 好友申请：
     * 例如 1208 申请 添加 1209 ，保存时，先存 MemberID=1208，状态Category="no" ,等那边同意后再存 MemberID=1209，状态Category="yes" ，然后修改 添加人1208 的数据状态 Category="yes";
     * （后续判断谁加的谁，添加人的关系id > 被添加人的关系id）
     * （例如：1208   1209 ） 一条数据是 单向好友
     * （例如：1209   1208 ） 1209 也有 1208的好友 （两条数据 双向好友）
     * 添加前先判断当前用户是否已添加 (添加用户需要给关系表加一条数据，对方同意后再加一条，形成双向好友)
     * 这里判断只需要判断当前用户有没有发起过好友申请,好友关系数据的删除在 同意申请逻辑中处理。
     * 传参：用户id,好友id
     *
     * @return 新增结果
     */
    @ResponseBody
    @PostMapping(value = "/addFriendsRequest")
    public Result addFriendsRequest(@RequestBody Map<String, String> obj, HttpServletRequest request) {
        try {
            if (obj == null) {
                throw new IllegalArgumentException("新增请求体不能为空");
            }
            if (obj.get("memberid").isEmpty() || obj.get("relevanceid").isEmpty()) {
                throw new IllegalArgumentException("用户id or 好友id不能为空");
            }
            String msg = JwtUtil.checkUserToken(request.getHeader(authorizetoken));
            if (msg.equals("登录超时") || msg.equals("未登录")) {
                return new Result(msg, null, 401);
            }
            Member member = memberService.selectByPrimaryKey(Integer.parseInt(msg));
            if (member == null) {
                return new Result("无此用户", null, 401);
            }

            //   用户id
            int memberId = member.getId();
            //   好友id
            int relevanceid = obj.get("relevanceid") == null ? 0 : Integer.parseInt(obj.get("relevanceid"));
            // 判断当前用户是否已添加
            Integer rows = friendsRequestService.queryIsAdded(memberId, relevanceid);
            if (rows != null && rows > 0) {
                return new Result("当前用户已添加", null, 401);
            }
            Memberfavorite memberfavorite = new Memberfavorite();
            memberfavorite.setMemberid(memberId);
            memberfavorite.setRelevanceid(relevanceid);
            // 添加时间
            Date nowDate = new Date();
            memberfavorite.setAddtime(nowDate);
            // 申请状态：通过 yes/未通过 no
            memberfavorite.setCategory("no");
            // 查询 好友关注总数
            int friendRows = friendsRequestService.queryByMyFriendsCount(relevanceid);
            // 他关注的好友  500 （好友列表人数）
            memberfavorite.setRemark(String.valueOf(friendRows));
            // 插入数据
            friendsRequestService.insert(memberfavorite);
            return new Result("添加申请已发送", memberfavorite, 0);
        } catch (IllegalArgumentException e) {
            log.error("参数验证失败：", e);
            return new Result("参数错误", e, -1);
        } catch (Exception e) {
            log.info("addFriendsRequest出错，错误：" + e);
            return new Result("操作失败", null, 500);
        }
    }


    /**
     * <同意> 好友申请
     * 同意申请: 根据 申请数据id修改 加好友时关系表 状态 no 改成 yes，且加一条 yes的数据，形成 双向好友。
     * （例如：1208   1209 ） 一条数据是 单向好友
     * （例如：1209   1208 ） 1209 也有 1208的好友 （两条数据 双向好友）
     * 参数：申请数据id,category = yes
     * <拒绝> 好友申请
     * 拒绝申请: 根据 申请数据id修改数据状态,软删除 (修改category申请状态：通过 yes, 暂未通过 no , 拒绝 refuse)
     * 参数：申请数据id,category = refuse
     *
     * @return 编辑结果
     */
    @PostMapping("/agreeOrRefuseFriendsRequest")
    public Result agreeOrRefuseFriendsRequest(HttpServletRequest request, @RequestBody Map<String, String> obj) {
        try {
            String msg = JwtUtil.checkUserToken(request.getHeader(authorizetoken));
            if (msg.equals("登录超时") || msg.equals("未登录")) {
                return new Result(msg, null, 401);
            }
            Member member = memberService.selectByPrimaryKey(Integer.parseInt(msg));
            if (member == null) {
                return new Result("无此用户", null, 401);
            }
            if (obj.get("memberid").isEmpty() || obj.get("relevanceid").isEmpty() || obj.get("id").isEmpty()) {
                throw new IllegalArgumentException("id不能为空");
            }

            // 判断参数是 同意申请 还是 拒绝申请 标识
            String category = obj.get("category");
            // 参数控制 只能是 refuse/yes
            if (category.equals("refuse") || category.equals("yes")) {
                // 根据数据id查询,验证当前数据的好友状态
                Memberfavorite verify = friendsRequestService.queryById(Integer.parseInt(obj.get("id")));
                // 同意 or 拒绝, 只处理状态是no 暂未通过 的好友申请数据
                if(verify.getCategory().isEmpty() || verify.getCategory() == null || !verify.getCategory().equals("no")){
                    return new Result("数据标识不对,请联系管理员处理", null, 401);
                }
                // “数据验证”  验证当前数据: 好友状态标识 是 暂未通过  no
                if(verify.getCategory().equals("no")){
                    // 用户id
                    Integer memberId = member.getId();
//                    Integer memberId = obj.get("memberid") == null ? 0 : Integer.parseInt(obj.get("memberid"));
                    // 好友id
                    int relevanceid = verify.getRelevanceid() == null ? 0 : verify.getRelevanceid();
                    // 初始化对象
                    Memberfavorite updateMemberfavorite = new Memberfavorite();
                    updateMemberfavorite.setId(Integer.valueOf(obj.get("id")));
                    // 申请状态：通过 yes/未通过 no/拒绝 refuse
                    updateMemberfavorite.setCategory(category);
                    // 添加时间
                    Date nowDate = new Date();
                    updateMemberfavorite.setAddtime(nowDate);
                    // 查询 好友关注总数
                    int friendRows = friendsRequestService.queryByMyFriendsCount(memberId);
                    // 他关注的好友  500 （好友列表人数）
                    updateMemberfavorite.setRemark(String.valueOf(friendRows));
                    // <修改>好友关系
                    friendsRequestService.update(updateMemberfavorite);

                    // 同意申请,再加一条数据，形成双向好友 (拒绝申请/同意申请 都需要修改状态，上面的代码逻辑都需要走,下面代码是 同意后新增数据。拒绝申请不走下面的逻辑)
                    if (category.equals("yes")) {
                        Memberfavorite memberfavorite = new Memberfavorite();
                        // 反向保存数据id
                        memberfavorite.setMemberid(memberId);
                        memberfavorite.setRelevanceid(relevanceid);
                        // 申请状态：通过 yes/未通过 no
                        memberfavorite.setCategory(category);
                        // 添加时间
                        nowDate = new Date();
                        memberfavorite.setAddtime(nowDate);
                        // 查询 好友关注总数
                        friendRows = friendsRequestService.queryByMyFriendsCount(relevanceid);
                        // 他关注的好友  500 （好友列表人数）
                        memberfavorite.setRemark(String.valueOf(friendRows));
                        // <添加>好友关系
                        friendsRequestService.insert(memberfavorite);
                    }
                }
            } else {
                return new Result("参数有误", null, 401);
            }
            return new Result("操作成功", null, 0);
        } catch (Exception e) {
            log.info("agreeOrRefuseFriendsRequest出错，错误：" + e);
            return new Result("失败", null, 500);
        }
    }


    /**
     * <删除> 好友 (双向删除)
     * 根据 好友id,自己的用户id，清空关系表
     * 参数： 当前好友数据id
     * @return 删除是否成功
     */
    @PostMapping("/deleteFriendsRequest")
    public Result deleteFriendsRequest(HttpServletRequest request, @RequestBody Map<String, String> obj) {
        try {
            if (obj == null) {
                throw new IllegalArgumentException("请求体不能为空");
            }
            String msg = JwtUtil.checkUserToken(request.getHeader(authorizetoken));
            if (msg.equals("登录超时") || msg.equals("未登录")) {
                return new Result(msg, null, 401);
            }
            Member member = memberService.selectByPrimaryKey(Integer.parseInt(msg));
            if (member == null) {
                return new Result("无此用户", null, 401);
            }
            // 根据好友数据id查询到 对应的用户id
            Memberfavorite verify = friendsRequestService.queryById(Integer.parseInt(obj.get("id")));
            int memberid = verify.getMemberid();
            int relevanceid = verify.getRelevanceid();
            // 删除 好友关系(双向删除)
            boolean isok = friendsRequestService.delete(memberid,relevanceid);
            if (isok) {
                return new Result("删除成功", null, 0);
            } else {
                return new Result("删除失败", null, 300);
            }
        } catch (IllegalArgumentException e) {
            log.error("参数验证失败：", e);
            return new Result("参数错误", e, -1);
        } catch (Exception e) {
            log.error("deleteFriendsRequest出错：", e);
            return new Result("系统错误", e, -1);
        }
    }


    /**
     * 查询当前用户的 <申请列表> 发送的好友申请
     * 参数:  用户id
     * 查询: 只展示未通过的申请。（用id查询 关系表，状态=no/refuse的数据，refuse 前台标识 : 已拒绝）
     * select * from member_favorite where  MemberID = 1208 and (Category = "no" or Category = "refuse") ;
     *
     * @return 查询当前用户发布的最新动态结果
     */
    @GetMapping("/queryFriendsRequestByList")
    public Result queryFriendsRequestByList(@RequestHeader Map<String, String> headers, Memberfavorite memberfavorite) {
        try {
            String msg = JwtUtil.checkUserToken(headers.get(authorizetoken));
            if (msg.equals("登录超时") || msg.equals("未登录")) {
                return new Result(msg, null, -1);
            }
            Member member = memberService.selectByPrimaryKey(Integer.parseInt(msg));
            if (member == null) {
                return new Result("无此用户", null, -1);
            }
            if (memberfavorite.getPage() != null) {
                if (memberfavorite.getPage() == 1) {
                    memberfavorite.setPage(0);
                } else {
                    memberfavorite.setPage((memberfavorite.getPage() - 1) * memberfavorite.getLimit());
                }
            }
            // 根据 用户id 查询 申请列表
            List<Memberfavorite> friendsRequestList = friendsRequestService.queryFriendsRequestByList(memberfavorite);
            int count = friendsRequestService.queryByRequestCount(memberfavorite);
            if (count > 0) {
                return new Result("成功", friendsRequestList, 0, count, memberfavorite.getLimit());
            } else {
                return new Result("无数据", null, 1, 0, 0);
            }
        } catch (Exception e) {
            log.info("queryFriendsRequestByList出错，错误：" + e);
            return new Result("出错", e, -1);
        }
    }

    /**
     * 查询当前用户的 <申请通知> 收到的好友申请
     * 参数:  用户id
     * select * from member_favorite where RelevanceID = 11 and Category = "no" ;
     *
     * @return 查询当前用户发布的最新动态结果
     */
    @GetMapping("/queryGotFriendsRequestByList")
    public Result queryGotFriendsRequestByList(@RequestHeader Map<String, String> headers, Memberfavorite memberfavorite) {
        try {
            String msg = JwtUtil.checkUserToken(headers.get(authorizetoken));
            if (msg.equals("登录超时") || msg.equals("未登录")) {
                return new Result(msg, null, -1);
            }
            Member member = memberService.selectByPrimaryKey(Integer.parseInt(msg));
            if (member == null) {
                return new Result("无此用户", null, -1);
            }
            if (memberfavorite.getPage() != null) {
                if (memberfavorite.getPage() == 1) {
                    memberfavorite.setPage(0);
                } else {
                    memberfavorite.setPage((memberfavorite.getPage() - 1) * memberfavorite.getLimit());
                }
            }
            // 根据 用户id 查询 收到的好友申请
            List<Memberfavorite> gotFriendsRequestList = friendsRequestService.queryGotFriendsRequestByList(memberfavorite);
            int count = friendsRequestService.queryByGotFriendsRequestCount(memberfavorite);
            if (count > 0) {
                return new Result("成功", gotFriendsRequestList, 0, count, memberfavorite.getLimit());
            } else {
                return new Result("无数据", null, 1, 0, 0);
            }
        } catch (Exception e) {
            log.info("queryGotFriendsRequestByList出错，错误：" + e);
            return new Result("出错", e, -1);
        }
    }


    /**
     * 查询当前用户的 <好友列表>
     * 参数: 用户id
     * 查询好友列表： 用自己的id查询
     * select * from member_favorite where MemberID = 1208 and Category = "yes" ;
     *
     * @return 查询当前用户的结果
     */
    @GetMapping("/queryFriendsByList")
    public Result queryFriendsByList(@RequestHeader Map<String, String> headers, Memberfavorite memberfavorite) {
        try {
            String msg = JwtUtil.checkUserToken(headers.get(authorizetoken));
            if (msg.equals("登录超时") || msg.equals("未登录")) {
                return new Result(msg, null, -1);
            }
            Member member = memberService.selectByPrimaryKey(Integer.parseInt(msg));
            if (member == null) {
                return new Result("无此用户", null, -1);
            }
            if (memberfavorite.getPage() != null) {
                if (memberfavorite.getPage() == 1) {
                    memberfavorite.setPage(0);
                } else {
                    memberfavorite.setPage((memberfavorite.getPage() - 1) * memberfavorite.getLimit());
                }
            }
            // 根据 用户id 查询 好友列表
            List<Memberfavorite> friendsList = friendsRequestService.queryFriendsByList(memberfavorite);
            int count = friendsRequestService.queryByFriendsCount(memberfavorite);
            if (count > 0) {
                return new Result("成功", friendsList, 0, count, memberfavorite.getLimit());
            } else {
                return new Result("无数据", null, 1, 0, 0);
            }
        } catch (Exception e) {
            log.info("queryFriendsByList出错，错误：" + e);
            return new Result("出错", e, -1);
        }
    }
}

Mapper层

package com.bxproject.huaqiabroad.Mapper;

import com.bxwl.memberbase.model.Memberfavorite;
import java.util.List;

public interface FriendsRequestMapper {

    Memberfavorite queryById(int id);
    /**
     * 新增数据
     *
     * @param memberfavorite 实例对象
     */
    void insert(Memberfavorite memberfavorite);

    void update(Memberfavorite memberfavorite);

    Integer queryIsAdded(int memberid,int relevanceid);

    Integer queryByMyFriendsCount(int relevanceid);

    boolean delete(int memberid,int relevanceid);

    // 查询 发送的好友申请
    List<Memberfavorite> queryFriendsRequestByList(Memberfavorite memberfavorite);
    /**
     * 查询 申请列表 统计总行数
     *
     * @param memberfavorite 查询条件
     * @return 申请列表 总行数
     */
    int queryByRequestCount(Memberfavorite  memberfavorite);

    // 查询好友列表
    List<Memberfavorite> queryFriendsByList(Memberfavorite memberfavorite);
    /**
     * 查询 申请列表 统计总行数
     *
     * @param memberfavorite 查询条件
     * @return 申请列表 总行数
     */
    int queryByFriendsCount(Memberfavorite  memberfavorite);

    // 查询 收到的好友申请
    List<Memberfavorite> queryGotFriendsRequestByList(Memberfavorite memberfavorite);
    /**
     * 查询 收到的申请 统计总行数
     *
     * @param memberfavorite 查询条件
     * @return 申请列表 总行数
     */
    int queryByGotFriendsRequestCount(Memberfavorite  memberfavorite);
}

Impl

package com.bxproject.huaqiabroad.Server.Impl;


import com.bxproject.huaqiabroad.Mapper.FriendsRequestMapper;
import com.bxproject.huaqiabroad.Server.FriendsRequestService;
import com.bxwl.memberbase.model.Memberfavorite;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;

@Service("friendsRequestService")
public class FriendsRequestServiceImpl implements FriendsRequestService {
    @Resource
    private FriendsRequestMapper FriendsRequestMapper;

    @Override
    public Memberfavorite queryById(int id) {
        return FriendsRequestMapper.queryById(id);
    }
    /**
     * 新增数据
     *
     * @param memberfavorite 实例对象
     * @return 实例对象
     */
    @Override
    public Memberfavorite insert(Memberfavorite memberfavorite) {
        this.FriendsRequestMapper.insert(memberfavorite);
        return memberfavorite;
    }
    
    @Override
    public Integer queryIsAdded(int memberid,int relevanceid) {
        return FriendsRequestMapper.queryIsAdded(memberid, relevanceid);
    }

    @Override
    public Integer queryByMyFriendsCount(int relevanceid) {
        return FriendsRequestMapper.queryByMyFriendsCount(relevanceid);
    }

    /**
     * 同意 好友申请
     *
     * @param memberfavorite 实例对象
     * @return 实例对象
     */
    @Override
    public Memberfavorite update(Memberfavorite memberfavorite) {
        this.FriendsRequestMapper.update(memberfavorite);
        return memberfavorite;
    }

    // 删除
    public boolean delete(int memberid,int relevanceid) {
        return FriendsRequestMapper.delete(memberid,relevanceid);
    }

    public List<Memberfavorite> queryFriendsRequestByList(Memberfavorite memberfavorite) {
        return FriendsRequestMapper.queryFriendsRequestByList(memberfavorite);
    }
    @Override
    public int queryByRequestCount(Memberfavorite memberfavorite) {
        return FriendsRequestMapper.queryByRequestCount(memberfavorite);
    }

    public List<Memberfavorite> queryFriendsByList(Memberfavorite memberfavorite) {
        return FriendsRequestMapper.queryFriendsByList(memberfavorite);
    }
    @Override
    public int queryByFriendsCount(Memberfavorite memberfavorite) {
        return FriendsRequestMapper.queryByRequestCount(memberfavorite);
    }

    public List<Memberfavorite> queryGotFriendsRequestByList(Memberfavorite memberfavorite) {
        return FriendsRequestMapper.queryGotFriendsRequestByList(memberfavorite);
    }
    @Override
    public int queryByGotFriendsRequestCount(Memberfavorite memberfavorite) {
        return FriendsRequestMapper.queryByGotFriendsRequestCount(memberfavorite);
    }

}

Service层

package com.bxproject.huaqiabroad.Server;

import com.bxwl.memberbase.model.Memberfavorite;
import java.util.List;

public interface FriendsRequestService {
    // 查询
    Memberfavorite queryById(int id);

    // 新增数据
    Memberfavorite insert(Memberfavorite memberfavorite);

    // 同意/拒绝 好友申请
    Memberfavorite update(Memberfavorite memberfavorite);

    // 判断当前好友是否已添加
    Integer queryIsAdded(int memberid,int relevanceid);

    // 查询好友数关注数
    Integer queryByMyFriendsCount(int relevanceid);

    // 删除 （ 拒绝好友申请 ）
    boolean delete(int memberid,int relevanceid);

    // 发送的好友申请
    List<Memberfavorite> queryFriendsRequestByList(Memberfavorite memberfavorite);
    int queryByRequestCount(Memberfavorite memberfavorite);

    // 好友列表
    List<Memberfavorite> queryFriendsByList(Memberfavorite memberfavorite);
    int queryByFriendsCount(Memberfavorite memberfavorite);

    // 收到的好友申请
    List<Memberfavorite> queryGotFriendsRequestByList(Memberfavorite memberfavorite);
    int queryByGotFriendsRequestCount(Memberfavorite memberfavorite);
}

xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bxproject.huaqiabroad.Mapper.FriendsRequestMapper">

    <resultMap type="com.bxwl.memberbase.model.Memberfavorite" id="MemberfavoriteMap">
        <result property="id" column="ID" jdbcType="INTEGER"/>
        <result property="memberid" column="MemberID" jdbcType="INTEGER"/>
        <result property="category" column="Category" jdbcType="VARCHAR"/>
        <result property="relevanceid" column="RelevanceID" jdbcType="INTEGER"/>
        <result property="addtime" column="AddTime" jdbcType="TIMESTAMP"/>
        <result property="remark" column="Remark" jdbcType="VARCHAR"/>
    </resultMap>

    <!-- 根据申请数据id 查询数据详情,同意/拒绝 好友申请时, 做数据验证 -->
    <select id="queryById" resultMap="MemberfavoriteMap">
        select
            id,memberid,category,relevanceid,addtime,remark
        from member_favorite
        where id = #{id}
    </select>

    <!--新增所有列-->
    <insert id="insert" keyProperty="id" useGeneratedKeys="true">
        insert into member_favorite(MemberID, Category, RelevanceID, AddTime, Remark)
        values (#{memberid}, #{category}, #{relevanceid}, #{addtime}, #{remark})
    </insert>

    <!--通过主键修改数据-->
    <update id="update">
        update member_favorite
        <set>
            <if test="memberid != null">MemberID = #{memberid},</if>
            <if test="category != null">Category = #{category},</if>
            <if test="relevanceid != null">RelevanceID = #{relevanceid},</if>
            <if test="addtime != null">AddTime = #{addtime},</if>
            <if test="remark != null">Remark = #{remark},</if>
        </set>
        where ID = #{id}
    </update>

    <!-- 通过主键删除 双向删除好友 -->
    <!--    DELETE from member_favorite where (MemberID = 11 or RelevanceID = 1208) or (MemberID = 1208 or RelevanceID = 11) ;-->
    <delete id="delete">
        delete
        from member_favorite
        where (MemberID = #{memberid} and RelevanceID = #{relevanceid})
        or  (MemberID = #{relevanceid} and RelevanceID = #{memberid})
    </delete>

    <!--查新增好友前, 验证是否是好友 -->
    <!--    例如 自己id:1208  好友id: 1209-->
    <select id="queryIsAdded" resultMap="MemberfavoriteMap">
        select IFNULL((
            select count(1) from member_favorite
            where
                <!--    好友列表 验证查询 ： 用自己的id查询，count总数大于1，有数据证明加过好友 -->
                    (MemberID = #{memberid} and relevanceID = #{relevanceid})
                            or
                    (MemberID = #{relevanceid} and relevanceID = #{memberid})
        ), 0)
    </select>

    <!-- 查询 好友关注 总数 -->
    <!--    select count(*) from member_favorite where MemberID = 1208 and Category = "yes" ;-->
    <select id="queryByMyFriendsCount" resultType="java.lang.Integer">
        select count(*)
        from member_favorite
        where MemberID = #{id} and Category = "yes"
    </select>

    <!--查询 申请列表 指定行数据-->
    <!--    select * from member_favorite where  MemberID = 1208 and (Category = "no" or Category = "refuse") ;-->
    <select id="queryFriendsRequestByList" resultMap="MemberfavoriteMap">
        select
        ID,MemberID,Category,RelevanceID,AddTime,Remark
        from member_favorite
        where MemberID = #{id}
        and (Category = "no" or Category = "refuse")
        <if test="page != null and limit != null">
            limit #{page}, #{limit}
        </if>
    </select>

    <!-- 查询 申请列表 总数 -->
    <!--    select count(*) from member_favorite where  MemberID = 1208 and (Category = "no" or Category = "refuse") ;-->
    <select id="queryByRequestCount" resultType="java.lang.Integer">
        select count(*)
        from member_favorite
        where MemberID = #{id}
          and (Category = "no" or Category = "refuse")
    </select>

    <!--查询 好友列表 指定行数据-->
    <!--   select * from member_favorite where MemberID = 1208 and Category = "yes" ;-->
    <select id="queryFriendsByList" resultMap="MemberfavoriteMap">
        select
        ID,MemberID,Category,RelevanceID,AddTime,Remark
        from member_favorite
        where MemberID = #{id} and Category = "yes"
        <if test="page != null and limit != null">
            limit #{page}, #{limit}
        </if>
    </select>

    <!-- 查询 好友列表 总数 -->
    <!--    select count(*) from member_favorite where MemberID = 1208 and Category = "yes" ;-->
    <select id="queryByFriendsCount" resultType="java.lang.Integer">
        select count(*)
        from member_favorite
        where MemberID = #{id} and Category = "yes"
    </select>

    <!--查询 收到的好友申请 指定行数据-->
    <!--  select * from member_favorite where RelevanceID = 11 and Category = "no"  ;-->
    <select id="queryGotFriendsRequestByList" resultMap="MemberfavoriteMap">
        select
        ID,MemberID,Category,RelevanceID,AddTime,Remark
        from member_favorite
        where RelevanceID = #{id} and Category = "no"
        <if test="page != null and limit != null">
            limit #{page}, #{limit}
        </if>
    </select>

    <!-- 查询 收到的好友申请 总数 -->
    <!--  select * from member_favorite where RelevanceID = 11 and Category = "no" ;-->
    <select id="queryByGotFriendsRequestCount" resultType="java.lang.Integer">
        select count(*)
        from member_favorite
        where RelevanceID = #{id} and Category = "no"
    </select>

</mapper>

实体

package com.bxwl.memberbase.model;

import com.fasterxml.jackson.annotation.JsonFormat;

import java.io.Serializable;
import java.util.Date;

// 实体类 
public class Memberfavorite implements Serializable {
    private static final long serialVersionUID = -32569297257851674L;

    private Integer id;

    private String name;
    private String alias;

    private Integer memberid;

    private String category;

    private Integer relevanceid;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date addtime;

    private String remark;

    private Integer page;
    private Integer limit;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getMemberid() {
        return memberid;
    }

    public void setMemberid(Integer memberid) {
        this.memberid = memberid;
    }

    public String getCategory() {
        return category;
    }

    public void setCategory(String category) {
        this.category = category;
    }

    public Integer getRelevanceid() {
        return relevanceid;
    }

    public void setRelevanceid(Integer relevanceid) {
        this.relevanceid = relevanceid;
    }

    public Date getAddtime() {
        return addtime;
    }

    public void setAddtime(Date addtime) {
        this.addtime = addtime;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    public Integer getPage() {
        return page;
    }

    public void setPage(Integer page) {
        this.page = page;
    }

    public Integer getLimit() {
        return limit;
    }

    public void setLimit(Integer limit) {
        this.limit = limit;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAlias() {
        return alias;
    }

    public void setAlias(String alias) {
        this.alias = alias;
    }
}
CHANGXIANG.
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值