多对多关系通用操作组件,省时省力的神器

news2024/11/15 15:35:26

项目上有很多对多操作的场景，建对象，建mapper接口，设置查询条件，查询多对多数据等都是一项极为耗时耗力的工作。因此，搓了这款集建表-保存-查询-设置条件等操作于一体的组件。原理简单，利用$标签动态作些操作。如下xml配置。

<mapper namespace="com.xxx.future.support.dependence.mapper.ManyRelationMapper">

	<!--查找记录-->
    <select id="findRelation" resultType="com.xxx.future.support.dependence.manyrelation.Relation"
            parameterType="com.xxx.future.support.dependence.manyrelation.RelationFind">
        select ${targetKey} as targetId,${sourceKey} as sourceId from ${tableName} where 1=1
        <if test="sourceIds!=null and sourceIds.size>0">
           and ${sourceKey} in
            <foreach collection="sourceIds" separator="," item="sourceId" open="(" close=")">
                #{sourceId}
            </foreach>
        </if>
        <if test="targetIds!=null and targetIds.size>0">
          and  ${targetKey} in
            <foreach collection="targetIds" separator="," item="targetId" open="(" close=")">
                #{targetId}
            </foreach>
        </if>
    </select>

	  <!--删除记录-->
    <delete id="clearRelation" parameterType="com.xxx.future.support.dependence.manyrelation.RelationDelete">
        delete FROM ${tableName}
        <where>
            <if test="sourceIds!=null and sourceIds.size>0">
                AND ${sourceKey} IN
                <foreach collection="sourceIds" separator="," open="(" close=")" item="sId">
                    #{sId}
                </foreach>
            </if>
            <if test="targetIds!=null and targetIds.size>0">
                AND ${targetKey} IN
                <foreach collection="targetIds" separator="," open="(" close=")" item="tId">
                    #{tId}
                </foreach>
            </if>
            <if test="targetApply!=null">
                AND ${targetApply}
            </if>
            <if test="sourceApply!=null">
                AND ${sourceApply}
            </if>
        </where>
    </delete>
   
    <!--mysql批量插入-->
    <insert id="saveRelation" databaseId="mysql"
            parameterType="com.xxx.future.support.dependence.manyrelation.RelationSave">
        INSERT INTO ${tableName}
        (
        ${sourceKey},
        ${targetKey}
        )
        VALUES
        <foreach collection="relations" item="item" separator=",">
            (
            #{item.sourceId},
            #{item.targetId}
            )
        </foreach>
    </insert>
    
   <!--oracle批量插入-->
    <insert id="saveRelation" databaseId="oracle"
            parameterType="com.xxx.future.support.dependence.manyrelation.RelationSave">
        INSERT ALL
        <foreach collection="relations" item="item" separator=" ">
            INTO ${tableName}
            (
            ${sourceKey},
            ${targetKey}
            )
            VALUES
            (
            #{item.sourceId},
            #{item.targetId}
            )
        </foreach>
        SELECT 1 FROM dual
    </insert>

	<!--检查表是否存在-->
    <select id="testExistsTable" resultType="int">
        select count(*) from ${tableName}
    </select>

	<!--mysql库建表-->
    <update id="createRelationTable" databaseId="mysql"
            parameterType="com.xxx.future.support.dependence.manyrelation.RelationTable">
        CREATE TABLE ${tableName} (
            ${sourceKey} varchar(60),
            ${targetKey} varchar(60),
            CONSTRAINT pk_${tableName} PRIMARY KEY(${sourceKey},${targetKey})
        )
    </update>
	<!--oracle库建表-->
    <update id="createRelationTable" databaseId="oracle"
            parameterType="com.xxx.future.support.dependence.domain.entity.RelationTable">
        CREATE TABLE ${tableName} (
            ${sourceKey} varchar2(60),
            ${targetKey} varchar2(60),
            CONSTRAINT pk_${tableName} PRIMARY KEY(${sourceKey},${targetKey})
        )
    </update>
</mapper>

工具类：工具ZYManyHelper怎么封装的就不细看了。太多了。都是一个拼参数，都是调用xml sql里面的查询，删除，保存，建表操作。看了上面xml配置就知道了。

public interface RelationBee {
    // tableName.columnName
    String sourceTable();

    // tableName.columnName
    String targetTable();

    default String sourceTableName() {
        String sourceTable = sourceTable();
        String[] split = sourceTable.split("\\.");
        return split[0];
    }

    default String sourceColumnName() {
        String sourceTable = sourceTable();
        String[] split = sourceTable.split("\\.");
        return split[1];
    }


    default String targetColumnName() {
        String targetTable = targetTable();
        String[] split = targetTable.split("\\.");
        return split[1];
    }

    default String targetTableName() {
        String targetTable = targetTable();
        String[] split = targetTable.split("\\.");
        return split[0];
    }

    default void joinOne(String sourceId, String targetId) {
        ZYManyHelper.joinOne(this, sourceId, targetId);
    }

    default void join(String sourceId, List<String> targetIds) {
        ZYManyHelper.joinBySourceId(this, sourceId, targetIds);
    }

    default void joinByTargetId(String targetId, List<String> sourceIds) {
        ZYManyHelper.joinByTargetId(this, targetId, sourceIds);
    }


    default void onlyJoin(List<String> sourceIds, List<String> targetIds) {
        ZYManyHelper.join(this, sourceIds, targetIds);
    }

    default void onlyJoin(String sourceId, List<String> targetIds) {
        if (ZYStrUtils.isNotNull(sourceId)) {
            ZYManyHelper.join(this, Collections.singletonList(sourceId), targetIds);
        }
    }

    default void onlyJoin(List<String> sourceIds, String targetId) {
        if (ZYStrUtils.isNotNull(targetId)) {
            ZYManyHelper.join(this, sourceIds, Collections.singletonList(targetId));
        }
    }

    default void clearByTargetIdAndSourceApply(String targetId, String sourceApply) {
        ZYManyHelper.clearByTargetIdsAndSourceApply(this, Collections.singletonList(targetId), sourceApply);
    }

    default void clearBySourceIdAndTargetApply(String sourceIds, String targetApply) {
        ZYManyHelper.clearBySourceIdsAndTargetApply(this, Collections.singletonList(sourceIds), targetApply);
    }

    default void clearByTargetIdsAndSourceApply(List<String> targetIds, String sourceApply) {
        ZYManyHelper.clearByTargetIdsAndSourceApply(this, targetIds, sourceApply);
    }

    default void clearBySourceIdsAndTargetApply(List<String> sourceIds, String targetApply) {
        ZYManyHelper.clearBySourceIdsAndTargetApply(this, sourceIds, targetApply);
    }

    default void clearBySourceId(String sourceId) {
        ZYManyHelper.clearBySourceId(this, sourceId);
    }

    default void clearBySourceIds(List<String> sourceIds) {
        ZYManyHelper.clearBySourceIds(this, sourceIds);
    }

    default void clearByTargetId(String targetId) {
        ZYManyHelper.clearByTargetId(this, targetId);
    }

    default void clearByTargetIds(List<String> targetIds) {
        ZYManyHelper.clearByTargetIds(this, targetIds);
    }

    default void clearBySourceIdAndTargetIds(String sourceId, List<String> targetIds) {
        ZYManyHelper.clearBySourceIdAndTargetIds(this, sourceId, targetIds);
    }

    default void clearByTargetIdAndSourceIds(String targetId, List<String> sourceIds) {
        ZYManyHelper.clearByTargetIdAndSourceIds(this, targetId, sourceIds);
    }

    default Map<String, List<String>> findSourceTargetsMap(List<String> sourceIds) {
        return ZYManyHelper.findSourceTargetsMap(this, sourceIds);
    }

    default Map<String, List<String>> findTargetSourcesMap(List<String> targetIds) {
        return ZYManyHelper.findTargetSourcesMap(this, targetIds);
    }


    default Map<String, List<String>> findSourceTargetsMap() {
        return ZYManyHelper.findSourceTargetsMap(this);
    }

    default Map<String, List<String>> findTargetSourcesMap() {
        return ZYManyHelper.findTargetSourcesMap(this);
    }

    default List<String> findTargetIds(String sourceId) {
        return ZYManyHelper.findTargetIds(this, sourceId);
    }

    default List<String> findTargetIds(List<String> sourceIds) {
        return ZYManyHelper.findTargetIds(this, sourceIds);
    }

    default List<String> findSourceIds(String targetId) {
        return ZYManyHelper.findSourceIds(this, targetId);
    }

    default List<String> findSourceIds(List<String> targetIds) {
        return ZYManyHelper.findSourceIds(this, targetIds);
    }

    // select role where id in (select role_id from relation_role_user where user_id='1')
    default void setWrapper(LambdaQueryWrapper<?> wrapper, String targetId) {
        ZYManyHelper.applyRelation(this, wrapper, targetId);
    }

    // select role where id in (select role_id from relation_role_user where user_id='1')
    default void setWrapper(LambdaQueryWrapper<?> wrapper, String sourceColumn, String targetId) {
        ZYManyHelper.applyRelation(this, wrapper, sourceColumn, targetId, false);
    }

    // select role where id in (select role_id from relation_role_user where user_id='1')
    default void setWrapper(QueryWrapper<?> wrapper, String targetId) {
        ZYManyHelper.applyRelation(this, wrapper, targetId);
    }

    // select role where id in (select role_id from relation_role_user where user_id in ('1'))
    default void setInLambdaWrapper(LambdaQueryWrapper<?> wrapper, List<String> targetIds) {
        ZYManyHelper.applyInRelation(this, wrapper, targetIds);
    }

    // select role where id in (select role_id from relation_role_user where user_id in ('1'))
    default void setInLambdaWrapper(LambdaQueryWrapper<?> wrapper, String sourceColumn, List<String> targetIds) {
        ZYManyHelper.applyInRelation(this, wrapper, sourceColumn, targetIds, false);
    }

    // select role where id in (select role_id from relation_role_user where user_id in ('1'))
    default void setInWrapper(QueryWrapper<?> wrapper, List<String> targetIds) {
        ZYManyHelper.applyInRelation(this, wrapper, targetIds);
    }

    // select role where id in (select role_id from relation_role_user where user_id in ('1'))
    default void setInWrapper(QueryWrapper<?> wrapper, String sourceColumn, List<String> targetIds) {
        ZYManyHelper.applyInRelation(this, wrapper, sourceColumn, targetIds, false);
    }


    // select role where id in (select role_id from relation_role_user where user_id='1')
    default void setWrapper(QueryWrapper<?> wrapper, String sourceColumn, String targetId) {
        ZYManyHelper.applyRelation(this, wrapper, sourceColumn, targetId, false);
    }

    // select role where id not in (select role_id from relation_role_user where user_id='1')
    default void setExcludeWrapper(LambdaQueryWrapper<?> wrapper, String targetId) {
        ZYManyHelper.applyExcludeRelation(this, wrapper, targetId);
    }

    // select role where id not in (select role_id from relation_role_user where user_id='1')
    default void setExcludeWrapper(LambdaQueryWrapper<?> wrapper, String sourceColumn, String targetId) {
        ZYManyHelper.applyRelation(this, wrapper, sourceColumn, targetId, true);
    }

    // select role where id not in (select role_id from relation_role_user where user_id='1')
    default void setExcludeWrapper(QueryWrapper<?> wrapper, String targetId) {
        ZYManyHelper.applyExcludeRelation(this, wrapper, targetId);
    }

    // select role where id not in (select role_id from relation_role_user where user_id='1')
    default void setExcludeWrapper(QueryWrapper<?> wrapper, String sourceColumn, String targetId) {
        ZYManyHelper.applyRelation(this, wrapper, sourceColumn, targetId, true);
    }

    // select user where id not in (select user_id from relation_role_user where role_id='1')
    default void setExcludeTargetWrapper(QueryWrapper<?> wrapper, String sourceId) {
        ZYManyHelper.applyExcludeTargetRelation(this, wrapper, sourceId);
    }

    // select user where id not in (select user_id from relation_role_user where role_id='1')
    default void setExcludeTargetWrapper(LambdaQueryWrapper<?> wrapper, String sourceId) {
        ZYManyHelper.applyExcludeTargetRelation(this, wrapper, sourceId);
    }

    // select user where id  in (select user_id from relation_role_user where role_id='1')
    default void setTargetWrapper(QueryWrapper<?> wrapper, String sourceId) {
        ZYManyHelper.applyTargetRelation(this, wrapper, sourceId);
    }

    // select user where id  in (select user_id from relation_role_user where role_id='1')
    default void setTargetWrapper(LambdaQueryWrapper<?> wrapper, String sourceId) {
        ZYManyHelper.applyTargetRelation(this, wrapper, sourceId);
    }
}

调用枚举定义：

   public enum SecurityRelation implements RelationBee {
    // 角色快捷菜单关系
    RELATION_ROLE_QUICK_MENU("role.role_id", "quick_menu.quick_menu_id"),
    // 角色用户关系
    RELATION_ROLE_USER("role.role_id", "user.user_id"),
    // 角色APP菜单关系
    RELATION_ROLE_APP_MENU("role.role_id", "app_menu.app_menu_id"),
    // 角色菜单关系
    RELATION_ROLE_MENU("role.role_id", "menu.menu_id");

    private String sourceTable;

    private String targetTable;


    SecurityRelation(String sourceTable, String targetTable) {
        this.sourceTable = sourceTable;
        this.targetTable = targetTable;
    }

    @Override
    public String sourceTable() {
        return sourceTable;
    }

    @Override
    public String targetTable() {
        return targetTable;
    }
}

在数据库中的数据效果如下图：
在这里插入图片描述

在这里插入图片描述

代码中的调用还是蛮舒服的，基本一条代码搞定，项目中，使用该方法节省了大量的体力劳动和时间，代码也较清爽干净，取得了不错的效果。如下图：

   // 查找登用户有哪些角色id
  List<String> roleIds = SecurityRelation.RELATION_ROLE_USER.findSourceIds(loginUserId);
  // 查找登录用户s有哪些角色ids
  List<String> roleIds = SecurityRelation.RELATION_ROLE_USER.findSourceIds(userIds);
  // 查找登录用户s有哪些角色对应关系
  Map<String, List<String>> userRoleIds = SecurityRelation.RELATION_ROLE_USER.findTargetSourcesMap(userIds);
  // 查找角色有哪些用户
   List<String> userIds = SecurityRelation.RELATION_ROLE_USER.findTargetIds(role.getId());
   // 清理角色用户
   SecurityRelation.RELATION_ROLE_USER.clearByTargetIdAndSourceIds(userId, roleIds);
   //关连角色用户
   SecurityRelation.RELATION_ROLE_USER.onlyJoin(roleIds, userId);
   // 设置查询条件
   SecurityRelation.RELATION_ROLE_USER.setTargetWrapper(wrapper, role.getId());
   // 根据角色删除
   SecurityRelation.RELATION_ROLE_USER.clearBySourceIds(roleIds);
   // 根据用户删除
   SecurityRelation.RELATION_ROLE_USER.clearByTargetId(userId);
   // 全量关连
   SecurityRelation.RELATION_ROLE_USER.join(roleId, userIds);

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1323727.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【自动化测试】selenium元素定位方式大全！

【自动化测试】selenium元素定位方式大全！

前言 当我们在使用selenium进行自动化测试工作时&#xff0c;元素定位是非常重要的一环&#xff0c;因为我们是借助脚本模拟我们通过鼠标和键盘对元素进行点击、输入内容和滑动操作的&#xff0c;所以准确的元素定位是我们执行测试脚本的重要一环。本文就来给大家介绍一下sele…
阅读更多...
windows11 ssd掉盘（无法访问）

windows11 ssd掉盘（无法访问）

故障描述&#xff1a; 开机的时候能够正常访问SSD当使用电源的时候很容易SSD无法访问接入电源以后掉盘情况缓解 故障原因&#xff1a;win11加入了一个新的电源策略 更改高级电源设置&#xff08;默认是10/20&#xff09;&#xff0c;把这个参数调整大。 非常蠢的一个设计&…
阅读更多...
信号处理基础之噪声与降噪(二）| 时域降噪方法（平滑降噪、SVD降噪）python代码实现

信号处理基础之噪声与降噪(二）| 时域降噪方法（平滑降噪、SVD降噪）python代码实现

接上期信号处理基础之噪声与降噪(一) | 噪声分类及python代码实现&#xff0c;本期为大家介绍噪声评价指标&#xff0c;并且讲解两种降噪方法——平滑降噪、SVD降噪&#xff0c;并给出python代码。 信号处理基础之噪声与降噪(二&#xff09;| 时域降噪方法&#xff08;平滑降噪…
阅读更多...
Z Potentials | 叶生晅：生成式 AI 下不变的是需求，坚定成为客户的营销技术合伙人

Z Potentials | 叶生晅：生成式 AI 下不变的是需求，坚定成为客户的营销技术合伙人

移动互联网时代&#xff0c;视频、直播、兴趣电商、社交、新资讯等线上新平台新服务实现大发展&#xff0c;吸引用户加速融入日益不可或缺的线上生活和「线上线下」融合场景&#xff0c;铸就海量的流量红利。营销场景从来都是软件应用行业最大的市场&#xff0c;离客户的预算最…
阅读更多...
基于ssm双星小区物业管理系统的设计与实现论文

基于ssm双星小区物业管理系统的设计与实现论文

摘 要 传统办法管理双星小区物业信息首先需要花费的时间比较多&#xff0c;其次数据出错率比较高&#xff0c;而且对错误的数据进行更改也比较困难&#xff0c;最后&#xff0c;检索数据费事费力。因此&#xff0c;在计算机上安装双星小区物业管理系统软件来发挥其高效地信息处…
阅读更多...
【性能测试】登录接口性能压测+选择并发用户数总结...

【性能测试】登录接口性能压测+选择并发用户数总结...

目录&#xff1a;导读 前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结&#xff08;尾部小惊喜&#xff09; 前言 1、需要登录的接口…
阅读更多...
jvm相关命令操作

jvm相关命令操作

查看jvm使用情况 jmap -heap PID 查看线程使用情况 jstack pid 查看当前线程数 jstack 21294 |grep -E (#[0-9]) -o -c 查看系统线程数 top -H top -Hp pid #查看具体的进程中的线程信息 使用 jps 命令查看配置了JVM的服务 查看某个进程JVM的GC使用情况 jstat -gc 进程…
阅读更多...
配置 vim 默认显示行号 行数 :set number

配置 vim 默认显示行号 行数 :set number

vi ~/.vimrc 最后添加一行 :set number保存退出&#xff0c;再次 vim 打开文件&#xff0c;默认就会显示行号了
阅读更多...
ctfshow（web190-web200）

ctfshow（web190-web200）

目录 web190 web191 web192 web193 web194 web195 web196 web197 web198 web199 web200 web190 为什么要有admin呢 这也是试出来的 这个admin必须是数据库中存在的 这样才能使用布尔注入 因为这个时候登录 有两种返回结果 一种密码错误 一种就是用户名错误 admin an…
阅读更多...
自动化测试工具-Selenium：Selenium的核心三大组件详解

自动化测试工具-Selenium：Selenium的核心三大组件详解

目录 1. WebDriver 1.1 WebDriver的通信方式 1.2 WebDriver的功能 1.3 W3C推荐标准 2. Grid 3. IDE Selenium 是支持 web 浏览器自动化的一系列工具和库的综合项目。官方对Selenium认可的三大组件或API分别是&#xff1a;WebDriver、Selenium IDE、Grid。其中&#xff0c…
阅读更多...
vue-springboot大学生兼职招聘评价系统_b8t93

vue-springboot大学生兼职招聘评价系统_b8t93

线上管理大学生兼职平台设计与实现提供了良好的发展空间&#xff0c;随着人们生活质量的提高&#xff0c;人们对服务质量的要求越来越严格。人们希望拥有更好的大学生兼职平台体验。而且&#xff0c;大学生兼职平台有着使用常规电话交流比不了的便捷高效简单等优势。大学生兼职…
阅读更多...
VS+Qt 打包Python文件

VS+Qt 打包Python文件

书接上回&#xff0c;调用C调用python&#xff0c;下面来谈谈随exe文件打包。 先说下环境vs2019Qt5.12.11python3.8&#xff0c;这里需要注意如果你要适配Win7的系统&#xff0c;python最好是9以下&#xff0c;以上不兼容&#xff0c;也没时间找方法&#xff0c;找到评论说下 如…
阅读更多...
I Doc View在线文档预览任意文件读取

I Doc View在线文档预览任意文件读取

漏洞简介 I Doc View在线文档预览是一款在线文档预览系统&#xff0c;可以实现文档的预览及文档协作编辑功能。其存在任意文件读取漏洞&#xff0c;可通过该漏洞读取服务器各敏感文件 资产测绘 title“在线文档预览 - I Doc View” 漏洞利用 http://your_ip/doc/upload?t…
阅读更多...
Nginx快速入门：访问日志access.log参数详解 ｜访问日志记录自定义请求头（三）

Nginx快速入门：访问日志access.log参数详解 ｜访问日志记录自定义请求头（三）

0. 引言 在企业的生产环境中&#xff0c;我们时常需要通过nginx的访问日志来统计流量、排查调用问题等&#xff0c;而nginx默认的日志格式所包含的信息远无法满足我们使用&#xff0c;因此常常需要对日志进行自定义&#xff0c;所以今天我们就来看如何自定义nginx的访问日志格…
阅读更多...
移动端自适应

移动端自适应

1.普通html页面 一般使用px定义&#xff0c;不会进行适配 移动端项目&#xff1a;从不同的终端保持页面的一致性&#xff08;自适应&#xff09;,使用rem相对单位&#xff0c;rem是相对于根节点html的font-size的值进行动态换算的值 2.普通html页面进行适配 普通页面中&…
阅读更多...
解决方案架构师 vs 技术架构师，有何区别？

解决方案架构师 vs 技术架构师，有何区别？

Salesforce架构师角色是生态系统中常见的职业目标。架构师因其丰富的Salesforce知识以及在平台上构建可扩展解决方案的能力而广受认可。 解决方案架构师和技术架构师是Salesforce生态系统中最常见的两个架构师角色&#xff0c;这些角色有一些重叠&#xff0c;但它们完全不同&a…
阅读更多...
Seata使用详解

Seata使用详解

分布式事务介绍分布式事务的优缺点CAP理论介绍Base理论介绍CAP和BASE之间有什么区别Seata介绍Seata支持的事务模式介绍Seata的架构Seata应用场景Seata集群部署Seata集群部署的优缺点Seata在Java中的使用案例Seata在Java中的代码示例Seata与SpringBoot2.x的整合Seata与SpringBoo…
阅读更多...
winfrom大恒工业相机SDK二次开发、C#联合halcon开发

winfrom大恒工业相机SDK二次开发、C#联合halcon开发

一、开发环境 1.在大恒图像官网下载SDK安装包&#xff0c;安装SDK后&#xff0c;打开安装目录找到Samples文件夹&#xff0c;然后找到Samples\CSharp SDK\x64\DoNET\.NET4.0文件夹下找到GxIAPINET.dll&#xff0c;如图&#xff1a; 2.打开VS2019软件&#xff0c;建立winfrom项…
阅读更多...
Linux系统管理、服务器设置、安全、云数据中心

Linux系统管理、服务器设置、安全、云数据中心

前言 「作者主页」&#xff1a;雪碧有白泡泡 「个人网站」&#xff1a;雪碧的个人网站 我们来快速了解liunx命令 文章目录 前言解析命令提示符linux的文件和目录文件和目录管理文件操作 进程管理命令系统管理网络管理 书籍推荐 本文以服务器最常用的CentOS为例 解析命令提示…
阅读更多...
JDBC简单使用

JDBC简单使用

1. 首先导包&#xff0c;放在src -> lib下 打开项目结构&#xff0c;添加导入的包为库 基础语法 Statement statement conn.createStatement(); ---------------------------------------------- 1.execute(String query)方法用来执行任意的SQL语句查询&#xff0c;如果…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023