Java实现数据库表中的七种连接【Mysql】

Java实现数据库表中的七种连接【Mysql】

  • 前言
  • 版权
  • 推荐
  • Java实现数据库表中的七种连接
    • 左外连接
    • 右外连接
    • 其他连接
  • 附录
    • 七种连接
    • SQL测试
    • Java测试
      • 转换方法
      • 类 Cla1
      • 类 Cla2
      • 类Cla3
  • 最后

前言

2023-8-4 16:51:42

以下内容源自《【Mysql】》
仅供学习交流使用

版权

禁止其他平台发布时删除以下此话
本文首次发布于CSDN平台
作者是CSDN@日星月云
博客主页是https://blog.csdn.net/qq_51625007
禁止其他平台发布时删除以上此话

推荐

Java实现数据库表中的七种连接

左外连接

  /**
     * 左外连接
     * 计算
     *     SELECT cla1.`id`,cla1.`type`,cla2.`name`
     *     FROM cla1
     *     LEFT JOIN cla2
     *     ON cla1.`id`=cla2.`id`
     *     (Where cla2.id IS NULL);
     *
     * @param list1
     * @param list2
     * @param isNull 有没有括号中的IS NULL这条语句
     * @param out 输出吗?
     * @return
     */
    public static  List<Cla3> leftJoin(List<Cla3> list1, List<Cla3> list2,boolean isNull,boolean out) {
       List<Cla3> leftJoin=new ArrayList<>();

       //左表遍历
       list1.forEach(c1->{
           //在右表中有没有找到
           AtomicBoolean flag= new AtomicBoolean(false);
           list2.forEach(c2->{
               //找到了
               if(c1.id.equals(c2.id)){
                   //如果cla2.id is null,就不需要添加
                   if (!isNull) {
                       leftJoin.add(new Cla3(c1.id, c1.type, c2.name));
                   }
                   flag.set(true);
               }
           });
           //没有找到添加 右表属性 NULL
           if(!flag.get()){
               leftJoin.add(new Cla3(c1.id,c1.type,"null"));
           }
       });
       
        return leftJoin;
    }


右外连接

    /**
     * 右外连接
     * 计算
     *     SELECT cla2.`id`,cla1.`type`,cla2.`name`
     *     FROM cla1
     *     RIGHT JOIN cla2
     *     ON cla1.`id`=cla2.`id`
     *     (WHERE cla1.`id` IS NULL);
     *
     * @param list1
     * @param list2
     * @param isNull 有没有括号中的IS NULL这条语句
     * @return
     */
    public static  List<Cla3> rightJoin(List<Cla3> list1, List<Cla3> list2,boolean isNull,boolean out) {
        List<Cla3> rightJoin=new ArrayList<>();
        //右表遍历
        list2.forEach(c2->{
            //在左表中有没有找到
            AtomicBoolean flag= new AtomicBoolean(false);
            list1.forEach(c1->{
                //找到了
                if(c1.id.equals(c2.id)){
                    //如果cla1.id is null,就不需要添加
                    if (!isNull){
                        rightJoin.add(new Cla3(c2.id, c1.type,c2.name));
                    }
                    flag.set(true);
                }
            });
            //没有找到添加 左表属性 NULL
            if(!flag.get()){
                rightJoin.add(new Cla3(c2.id,"null",c2.name));
            }
        });

        return rightJoin;
    }

其他连接

外连接
 * 左外+右外
 * 右外+左外
内连接
 * 左外-左外ISNULL
 * 右外-右外ISNULL
外连接-内连接

附录

七种连接

MySQL笔记:第06章_多表查询

在这里插入图片描述

SQL测试

CREATE DATABASE cla;


USE cla;

CREATE TABLE cla1(
	`id` 	VARCHAR(10),
	`type` 	VARCHAR(10)
);

CREATE TABLE cla2(
	`id` 	VARCHAR(10),
	`name` 	VARCHAR(10)
);



INSERT INTO cla1 VALUES('22','cde');
INSERT INTO cla1 VALUES('11','abc');
INSERT INTO cla1 VALUES('44','cdef');
INSERT INTO cla1 VALUES('55','cdefg');

INSERT INTO cla2 
VALUES
('11','name1'),
('22','name2'),
('33','name3'),
('44','name4'),
('aa','nameaa');

#leftJoin 
SELECT cla1.`id`,cla1.`type`,cla2.`name`
FROM cla1
LEFT JOIN cla2
ON cla1.`id`=cla2.`id`
/*
id	type	name
22	cde	name2
11	abc	name1
44	cdef	name4
55	cdefg	\N
*/

#leftJoin isnull
SELECT cla1.`id`,cla1.`type`,cla2.`name`
FROM cla1
LEFT JOIN cla2
ON cla1.`id`=cla2.`id`
WHERE cla2.`id` IS NULL;
/*
id	type	name
55	cdefg	\N
*/


#rightJoin 
SELECT cla2.`id`,cla1.`type`,cla2.`name`
FROM cla1
RIGHT JOIN cla2
ON cla1.`id`=cla2.`id`
/*
id	type	name
11	abc	name1
22	cde	name2
33	\N	name3
44	cdef	name4
aa	\N	nameaa
*/

#rightJoin ISNULL
SELECT cla2.`id`,cla1.`type`,cla2.`name`
FROM cla1
RIGHT JOIN cla2
ON cla1.`id`=cla2.`id`
WHERE cla1.`id` IS NULL;
/*
id	type	name
33	\N	name3
aa	\N	nameaa
*/


#innerJoin leftBefore
SELECT cla1.`id`,cla1.`type`,cla2.`name`
FROM cla1
INNER JOIN cla2
ON cla1.`id`=cla2.`id`
/*
id	type	name
11	abc	name1
22	cde	name2
44	cdef	name4
*/

#innerJoin rightBefore
SELECT cla2.`id`,cla1.`type`,cla2.`name`
FROM cla2
INNER JOIN cla1
ON cla2.`id`=cla1.`id`
/*
id	type	name
11	abc	name1
22	cde	name2
44	cdef	name4
*/

#outJoin leftBefore
#左1+右2
SELECT cla1.`id`,cla1.`type`,cla2.`name`
FROM cla1
LEFT JOIN cla2
ON cla1.`id`=cla2.`id`
UNION ALL
SELECT cla2.`id`,cla1.`type`,cla2.`name`
FROM cla1
RIGHT JOIN cla2
ON cla1.`id`=cla2.`id`
WHERE cla1.`id` IS NULL;
/*
id	type	name
22	cde	name2
11	abc	name1
44	cdef	name4
55	cdefg	\N
33	\N	name3
aa	\N	nameaa
*/

#outJoin rightBefore
#右1+左2
SELECT cla2.`id`,cla1.`type`,cla2.`name`
FROM cla1
RIGHT JOIN cla2
ON cla1.`id`=cla2.`id`
UNION ALL
SELECT cla1.`id`,cla1.`type`,cla2.`name`
FROM cla1
LEFT JOIN cla2
ON cla1.`id`=cla2.`id`
WHERE cla2.`id` IS NULL;
/*
id	type	name
11	abc	name1
22	cde	name2
33	\N	name3
44	cdef	name4
aa	\N	nameaa
55	cdefg	\N
*/

Java测试

转换方法


package test.algo;


import test.algo.main2.Cla1;
import test.algo.main2.Cla2;
import test.algo.main2.Cla3;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;



public class testJoin {

    static List<Cla1> claList1 = new ArrayList<>();
    static List<Cla2> claList2 = new ArrayList<>();

    static List<Cla3> list1 = new ArrayList<>();
    static List<Cla3> list2 = new ArrayList<>();


    public static void main(String[] args) {

        test();

        init(claList1,claList2);

        leftJoin(list1, list2,false,true);
        /*
        {id: 22, type: cde, name: name2}
        {id: 11, type: abc, name: name1}
        {id: 44, type: cdef, name: name4}
        {id: 55, type: cdefg, name: null}
         */

        leftJoin(list1, list2,true,true);;
        /*
        {id: 55, type: cdefg, name: null}
         */

        rightJoin(list1, list2,false,true);
        /*
        {id: 11, type: abc, name: name1}
        {id: 22, type: cde, name: name2}
        {id: 33, type: null, name: name3}
        {id: 44, type: cdef, name: name4}
        {id: aa, type: null, name: nameaa}
         */

        rightJoin(list1, list2,true,true);
        /*
        {id: 33, type: null, name: name3}
        {id: aa, type: null, name: nameaa}
         */


        outJoin(list1, list2,true,true);
        /*
        {id: 22, type: cde, name: name2}
        {id: 11, type: abc, name: name1}
        {id: 44, type: cdef, name: name4}
        {id: 55, type: cdefg, name: null}
        {id: 33, type: null, name: name3}
        {id: aa, type: null, name: nameaa}
         */

        outJoin(list1, list2,false,true);
        /*
        {id: 11, type: abc, name: name1}
        {id: 22, type: cde, name: name2}
        {id: 33, type: null, name: name3}
        {id: 44, type: cdef, name: name4}
        {id: aa, type: null, name: nameaa}
        {id: 55, type: cdefg, name: null}
         */


        innerJoin(list1,list2,true,true);
        /*
        {id: 22, type: cde, name: name2}
        {id: 11, type: abc, name: name1}
        {id: 44, type: cdef, name: name4}
         */

        innerJoin(list1,list2,false,true);
        /*
        {id: 11, type: abc, name: name1}
        {id: 22, type: cde, name: name2}
        {id: 44, type: cdef, name: name4}
         */

        outJoin_InnerJoin(list1,list2,true,true);
        /*
        {id: 55, type: cdefg, name: null}
        {id: 33, type: null, name: name3}
        {id: aa, type: null, name: nameaa}
         */
        outJoin_InnerJoin(list1,list2,false,true);
        /*
        {id: 33, type: null, name: name3}
        {id: aa, type: null, name: nameaa}
        {id: 55, type: cdefg, name: null}
         */

    }

    /**
     * 初始两个表中的数据
     */
    public static void test(){
        claList1.add(new Cla1("22", "cde"));
        claList1.add(new Cla1("11", "abc"));
        claList1.add(new Cla1("44", "cdef"));
        claList1.add(new Cla1("55", "cdefg"));

        claList2.add(new Cla2("11", "name1"));
        claList2.add(new Cla2("22", "name2"));
        claList2.add(new Cla2("33", "name3"));
        claList2.add(new Cla2("44", "name4"));
        claList2.add(new Cla2("aa", "nameaa"));
    }


    /**
     * 初始结果表中的数据
     */
    public static void init(List<Cla1> claList1, List<Cla2> claList2){
        claList1.forEach(cla1 -> list1.add(new Cla3(cla1.getId(), cla1.getType(), "null")));
        claList2.forEach(cla2 -> list2.add(new Cla3(cla2.getId(), "null", cla2.getName())));
    }


    /**
     *外连接-内连接
     * @param list1
     * @param list2
     * @param leftBefore 左边在前
     * @param out 是否输出
     * @return
     */
    public static List<Cla3> outJoin_InnerJoin(List<Cla3> list1, List<Cla3> list2,boolean leftBefore,boolean out){
        List<Cla3> outJoin_InnerJoin=new ArrayList<>();

        outJoin_InnerJoin.addAll(outJoin(list1, list2, leftBefore, false));
        outJoin_InnerJoin.removeAll(innerJoin(list1, list2, leftBefore, false));


        if(out){
            System.out.println("--------------------outJoin_InnerJoin"+((leftBefore)?"leftBefore":"rightBefore")+"-------------------------------");
            outJoin_InnerJoin.forEach(System.out::println);
            System.out.println("--------------------outJoin_InnerJoin"+((leftBefore)?"leftBefore":"rightBefore")+"-------------------------------");
        }
        return outJoin_InnerJoin;

    }

    /**
     * 内连接
     * 左外-左外ISNULL
     * 右外-右外ISNULL
     * @param list1
     * @param list2
     * @param leftBefore 左边在前
     * @param out 是否输出
     * @return
     */
    public static List<Cla3> innerJoin(List<Cla3> list1, List<Cla3> list2,boolean leftBefore,boolean out){
        List<Cla3> innerJoin=new ArrayList<>();

        if(leftBefore){
            innerJoin.addAll(leftJoin(list1, list2, false, false));
            innerJoin.removeAll(leftJoin(list1, list2, true, false));
        }else {
            innerJoin.addAll(rightJoin(list1, list2, false, false));
            innerJoin.removeAll(rightJoin(list1, list2, true, false));
        }

        if(out){
            System.out.println("--------------------innerJoin"+((leftBefore)?"leftBefore":"rightBefore")+"-------------------------------");
            innerJoin.forEach(System.out::println);
            System.out.println("--------------------innerJoin"+((leftBefore)?"leftBefore":"rightBefore")+"-------------------------------");
        }
        return innerJoin;
    }


    /**
     * 左外连接
     * 计算
     *     SELECT cla1.`id`,cla1.`type`,cla2.`name`
     *     FROM cla1
     *     LEFT JOIN cla2
     *     ON cla1.`id`=cla2.`id`
     *     (Where cla2.id IS NULL);
     *
     * @param list1
     * @param list2
     * @param isNull 有没有括号中的IS NULL这条语句
     * @param out 输出吗?
     * @return
     */
    public static  List<Cla3> leftJoin(List<Cla3> list1, List<Cla3> list2,boolean isNull,boolean out) {
       List<Cla3> leftJoin=new ArrayList<>();

       list1.forEach(c1->{
           AtomicBoolean flag= new AtomicBoolean(false);
           list2.forEach(c2->{
               if(c1.id.equals(c2.id)){
                   if (!isNull) {
                       leftJoin.add(new Cla3(c1.id, c1.type, c2.name));
                   }
                   flag.set(true);
               }
           });
           if(!flag.get()){
               leftJoin.add(new Cla3(c1.id,c1.type,"null"));
           }
       });

       if(out){
            System.out.println("--------------------leftJoin---"+((isNull)?"isNull":"----")+"-------------------------------");
            leftJoin.forEach(System.out::println);
            System.out.println("--------------------leftJoin---"+((isNull)?"isNull":"----")+"-------------------------------");
            System.out.println();
       }

        return leftJoin;
    }

    /**
     * 右外连接
     * 计算
     *     SELECT cla2.`id`,cla1.`type`,cla2.`name`
     *     FROM cla1
     *     RIGHT JOIN cla2
     *     ON cla1.`id`=cla2.`id`
     *     (WHERE cla1.`id` IS NULL);
     *
     * @param list1
     * @param list2
     * @param isNull 有没有括号中的IS NULL这条语句
     * @return
     */
    public static  List<Cla3> rightJoin(List<Cla3> list1, List<Cla3> list2,boolean isNull,boolean out) {
        List<Cla3> rightJoin=new ArrayList<>();
        list2.forEach(c2->{
            AtomicBoolean flag= new AtomicBoolean(false);
            list1.forEach(c1->{
                if(c1.id.equals(c2.id)){
                    if (!isNull){
                        rightJoin.add(new Cla3(c2.id, c1.type,c2.name));
                    }
                    flag.set(true);
                }
            });
            if(!flag.get()){
                rightJoin.add(new Cla3(c2.id,"null",c2.name));
            }
        });
        if (out){
            System.out.println("--------------------rightJoin---"+((isNull)?"isNull":"----")+"-------------------------------");
            rightJoin.forEach(System.out::println);
            System.out.println("--------------------rightJoin---"+((isNull)?"isNull":"----")+"-------------------------------");
            System.out.println();
        }
        return rightJoin;
    }

    /**
     * 外连接
     * 左外+右外
     * 右外+左外
     *     SELECT *
     *     FROM tableA A
     *     FULL OUTER JOIN TableB B
     *     ON A.key=B.key
     *
     * @param leftBefore 结果集左表在前还是右边在前
     * @param out 输出吗
     * @return
     */
    public static List<Cla3> outJoin(List<Cla3> list1, List<Cla3> list2,boolean leftBefore,boolean out) {


        List<Cla3> outJoin=new ArrayList<>();
        List<Cla3> leftJoin = leftJoin(list1, list2,!leftBefore,false);
        List<Cla3> rightJoin = rightJoin(list1, list2,leftBefore,false);

        if (leftBefore){
            outJoin.addAll(leftJoin);
            outJoin.addAll(rightJoin);
        }else {
            outJoin.addAll(rightJoin);
            outJoin.addAll(leftJoin);
        }

        if(out){
            System.out.println("--------------------outJoin"+((leftBefore)?"leftBefore":"rightBefore")+"-------------------------------");
            outJoin.forEach(System.out::println);
            System.out.println("--------------------outJoin"+((leftBefore)?"leftBefore":"rightBefore")+"-------------------------------");
        }

        return outJoin;

    }

}

类 Cla1

package test.algo.main2;

public class Cla1 {
    public String id;
    public String type;

    public Cla1(String id, String type) {
        this.id = id;
        this.type = type;
    }

    public String getId() {
        return id;
    }

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

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public String toString() {
        return "{id: " + id + ", type: " + type + "}";
    }
}

类 Cla2

package test.algo.main2;

public class Cla2 {
    public String id;
    public String name;

    public Cla2(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "{id: " + id + ", name: " + name + "}";
    }
}

类Cla3

需要重写equals()
id==id

package test.algo.main2;

import java.util.Objects;

public class Cla3 {
    public String id;
    public String name;
    public String type;

    public Cla3(String id, String type, String name) {
        this.id = id;
        this.type = type;
        this.name = name;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Cla3 cla3 = (Cla3) o;
        return Objects.equals(id, cla3.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }

    @Override
    public String toString() {
        return "{id: " + id + ", type: " + type + ", name: " + name + "}";
    }
}

最后

2023-8-4 17:04:28

我们都有光明的未来

祝大家考研上岸
祝大家工作顺利
祝大家得偿所愿
祝大家如愿以偿
点赞收藏关注哦

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

vue 混入(mixin)的使用

在 vue 组件内&#xff0c;如果想将一些公共功能&#xff0c;如组件、方法、钩子函数等复用&#xff0c;混入是一个很好的选择。 现在开始我们的混入使用吧 1、我们可以创建一个目录mixins&#xff0c;在创建一个comment.js文件如图&#xff1a; // 在 common.js 里写你想共享…

SQL 表别名 和 列别名

列表名 列表名之后 order by 可以用别名 也可以用原名&#xff0c; where 中不能用别名的 SQL语句执行顺序&#xff1a; from–>where–>group by -->having — >select --> order 第一步&#xff1a;from语句&#xff0c;选择要操作的表。 第二步&#xff1…

matlab编程实践18、19

浅水方程 浅水方程可以建立起海啸和浴缸中波浪的数学模型。浅水方程建立了水或者其它不可压缩液体受扰动时传播的模型。隐含的假设是&#xff0c;液体的深度和波浪的长度、扰动等相比是很小的。 在这样的记号下&#xff0c;浅水方程为双曲守恒定律的一个例子。 使用拉克斯-冯特…

ssm机动车维修站车辆维护管理系统java汽车报修备案jsp源代码mysql

本项目为前几天收费帮学妹做的一个项目&#xff0c;Java EE JSP项目&#xff0c;在工作环境中基本使用不到&#xff0c;但是很多学校把这个当作编程入门的项目来做&#xff0c;故分享出本项目供初学者参考。 一、项目描述 ssm机动车维修站车辆维护管理系统 系统有2权限&#…

iOS16.0:屏幕旋转

此文写于2022年08月03日&#xff0c;距离iOS16正式版推出还有一个多月的时间&#xff0c;iOS16 beta版本有很多API的修改&#xff0c;今天讨论的是屏幕旋转&#xff0c;基于Xcode 14.0 beta4。 之前的屏幕旋转会报错&#xff1a; [Orientation] BUG IN CLIENT OF UIKIT: Settin…

MinIO

MinIO 1.MinIO安装 Minio 是个基于 Golang 编写的开源对象存储服务&#xff0c;存储非结构化数据&#xff0c;如&#xff1a;图片&#xff0c;视频&#xff0c;音乐等 官网地址&#xff1a;https://min.io/ 中文地址&#xff1a;http://minio.org.cn 官网文档&#xff08; …

Istio 安全 mTLS认证 PeerAuthentication

这里定义了访问www.ck8s.com可以使用http也可以使用https访问&#xff0c;两种方式都可以访问。 那么是否可以强制使用mtls方式去访问&#xff1f; mTLS认证 PeerAuthentication PeerAuthentication的主要作用是别人在和网格里的pod进行通信的时候&#xff0c;是否要求mTLS mTL…

SpringBoot中事务失效的原因

SpringBoot中事务失效的原因 文章目录 SpringBoot中事务失效的原因一、事务方法非public修饰二、非事务方法调用事务方法三、事务方法的异常被捕获四、事务异常类型不对五、事务传播行为不对六、没有被Spring管理6.1、暴漏代理对象6.2、使用代理对象 常见的事务失效原因包括如下…

LeetCode-26-删除有序数组中的重复项

一&#xff1a;题目描述&#xff1a; 给你一个 升序排列 的数组 nums &#xff0c;请你 原地 删除重复出现的元素&#xff0c;使每个元素 只出现一次 &#xff0c;返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。 考虑 nums 的唯…

【Linux】-进程概念之进程优先级(如何去进行调度以及进程切换),还不进来看看??

&#x1f496;作者&#xff1a;小树苗渴望变成参天大树&#x1f388; &#x1f389;作者宣言&#xff1a;认真写好每一篇博客&#x1f4a4; &#x1f38a;作者gitee:gitee✨ &#x1f49e;作者专栏&#xff1a;C语言,数据结构初阶,Linux,C 动态规划算法&#x1f384; 如 果 你 …

adb 调试oppo k11过程记录

学习使用appium工具&#xff0c;自动化测试andriod应用程序。 过程记录 背景交代 手机&#xff1a;oppo k11 系统&#xff1a; macOS 手机开启use调试 具体细节&#xff0c;可百度 安装软件 adbappiumappium-inspector adb安装 下载adb工具包platform-tools, 解压。 直…

【网络基础进阶之路】基于MGRE多点协议的实战详解

PS&#xff1a;本要求基于华为的eNSP模拟软件进行 具体要求&#xff1a; 完成步骤&#xff1a; 1、根据上述要求&#xff0c;对各路由器进行地址安排&#xff0c;如下图。 2、进入各路由器&#xff0c;对每个端口进行地址设置。 R1路由器设置&#xff1a; ISP路由器设置&…

CNN-NER论文详解

论文&#xff1a;https://arxiv.org/abs/2208.04534 代码&#xff1a;https://github.com/yhcc/CNN_Nested_NER/tree/master 文章目录 有关工作前期介绍CNN-NER模型介绍 代码讲解主类多头biaffineCNNLoss解码数据传入格式 参考资料 有关工作 前期介绍 过去一共主要有四类方式…

数据结构初阶--二叉树的顺序结构之堆

目录 一.堆的概念及结构 1.1.堆的概念 1.2.堆的存储结构 二.堆的功能实现 2.1.堆的定义 2.2.堆的初始化 2.3.堆的销毁 2.4.堆的打印 2.5.堆的插入 向上调整算法 堆的插入 2.6.堆的删除 向下调整算法 堆的删除 2.7.堆的取堆顶元素 2.8.堆的判空 2.9.堆的求堆的…

MyBatis-Plus实现分页查询

目录 MyBatis-Plus实现分页查询 代码 定义一个MyBatis-Plus拦截器 在连接数据库的配置文件中添加MyBatis-Plus日志查看MyBatis-Plus的SQL语句 测试 运行结果 MyBatis-Plus实现分页查询 代码 定义一个MyBatis-Plus拦截器 package com.dong.config;import com.baomidou.my…

webpack基础知识二:说说webpack的构建流程?

一、运行流程 webpack 的运行流程是一个串行的过程&#xff0c;它的工作流程就是将各个插件串联起来 在运行过程中会广播事件&#xff0c;插件只需要监听它所关心的事件&#xff0c;就能加入到这条webpack机制中&#xff0c;去改变webpack的运作&#xff0c;使得整个系统扩展…

【学习笔记】Java安全之反序列化

文章目录 反序列化方法的对比PHP的反序列化Java的反序列化Python反序列化 URLDNS链利用链分析触发DNS请求 CommonCollections1利用链利用TransformedMap构造POC利用LazyMap构造POCCommonsCollections6 利用链 最近在学习Phith0n师傅的知识星球的Java安全漫谈系列&#xff0c;随…

分布式限流方案及实现

优质博文&#xff1a;IT-BLOG-CN 一、限流的作用和意义 限流是对高并发访问进行限制&#xff0c;限速的过程。通过限流来限制资源&#xff0c;可以提高系统的稳定性和可靠性&#xff0c;控制系统的负载&#xff0c;削峰填谷&#xff0c;保证服务质量。 服务限流后的常见处理…

电动汽车设计、制造、研发的学科、技术和前沿科技综述

引言&#xff1a;电动汽车作为替代传统燃油汽车的一种先进交通工具&#xff0c;不仅具有环保、低噪音等优势&#xff0c;而且对于能源消耗和气候变化等全球性问题也具有重要意义。本文将综述与电动汽车设计、制造、研发相关的学科、技术和前沿科技&#xff0c;以期对电动汽车领…

MATLAB /Simulink 快速开发STM32(使用st官方工具 STM32-MAT/TARGET),以及开发过程

配置好环境以后就是开发&#xff1a; stm32cube配置芯片&#xff0c;打开matlab添加ioc文件&#xff0c;写处理逻辑&#xff0c;生成代码&#xff0c;下载到板子中去。 配置需要注意事项&#xff1a; STM32CUBEMAX6.5.0 MABLAB2022BkeilV5.2 Matlab生成的代码CTRLB 其中关键的…