Mybatis-Flex之QueryWrapper_mybatis-flex querywrapper-程序员宅基地

技术标签： java  MybatisFlex  mybatis  

1、完整DQL语句

/**
     * 使用QueryWrapper构建超复杂SQL语句
     */
    @Test
    public void testQueryWrapper1() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(SYS_USER_ENTITY.ALL_COLUMNS, SYS_ROLE_ENTITY.ALL_COLUMNS, SYS_MENU_ENTITY.ALL_COLUMNS)
                .from(SYS_USER_ENTITY)
                .leftJoin(SYS_USER_ROLE_ENTITY).on(SYS_USER_ENTITY.ID.eq(SYS_USER_ROLE_ENTITY.USER_ID))
                .leftJoin(SYS_ROLE_ENTITY).on(SYS_ROLE_ENTITY.ID.eq(SYS_USER_ROLE_ENTITY.ROLE_ID))
                .leftJoin(SYS_ROLE_MENU_ENTITY).on(SYS_ROLE_ENTITY.ID.eq(SYS_ROLE_MENU_ENTITY.ROLE_ID))
                .leftJoin(SYS_MENU_ENTITY).on(SYS_ROLE_MENU_ENTITY.MENU_ID.eq(SYS_MENU_ENTITY.ID))
                .where(SYS_USER_ENTITY.ID.gt(0))
                .groupBy(SYS_USER_ENTITY.USERNAME)
                .having(SYS_USER_ENTITY.USERNAME.like("a"))
                .orderBy(SYS_USER_ENTITY.PASSWORD.desc())
                .union(QueryWrapper.create().from(ACCOUNT))
                .limit(3);
        printSql(wrapper);
    }

结果

SELECT
    ` sys_user `.*,
    ` sys_role `.*,
    ` sys_menu `.*
  FROM
    ` sys_user `
    LEFT JOIN ` sys_user_role ` ON ` sys_user `.` id ` = ` sys_user_role `.` user_id `
    LEFT JOIN ` sys_role ` ON ` sys_role `.` id ` = ` sys_user_role `.` role_id `
    LEFT JOIN ` sys_role_menu ` ON ` sys_role `.` id ` = ` sys_role_menu `.` role_id `
    LEFT JOIN ` sys_menu ` ON ` sys_role_menu `.` menu_id ` = ` sys_menu `.` id `
  WHERE
    ` sys_user `.` id ` > 0
  GROUP BY
    ` sys_user `.` username `
  HAVING
    ` sys_user `.` username ` LIKE '%a%'
  ORDER BY
    ` sys_user `.` password ` DESC

2、动态条件

/**
     * 动态条件
     */
    @Test
    public void testDynamic() {
    
        // 例如；
        QueryWrapper wrapper = QueryWrapper.create().select(SYS_USER_ENTITY.ALL_COLUMNS).from(SYS_USER_ENTITY);

        String name = "";
        boolean flag = name != null && !name.trim().isEmpty();

        // 方式一：为null或""不拼接条件
        wrapper.where(flag ? SYS_USER_ENTITY.NAME.eq(name) : QueryMethods.noCondition());
        // 方式二
        wrapper.and(qw -> {
    
            qw.or(SYS_USER_ENTITY.NAME.eq(name).when(flag)).or(SYS_USER_ENTITY.USERNAME.eq(name).when(StringUtil.isNotBlank(name)));
        });
        // 方式三
        wrapper.where(SYS_USER_ENTITY.NAME.eq(name).when(If::hasText));
        wrapper.and(SYS_USER_ENTITY.NAME.eq(name).when(StringUtil.isNotBlank(name)));
        // 方式四
        wrapper.where(SYS_USER_ENTITY.NAME.eq(name, If::hasText));

        printSql(wrapper);
    }

结果

SELECT
  *
FROM
  ` sys_user `
WHERE
  ` name ` = 'zs'
  AND ` name ` = 'zs'
  AND ` name ` = 'zs'
  AND (
    ` name ` = 'zs'
    OR ` username ` = 'zs'
  )
  AND ` name ` = 'zs'

3、SQL函数

官方说明select function

/**
     * sql函数
     */
    @Test
    public void testSqlFunction1() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.ID, ACCOUNT.USER_NAME,
                        QueryMethods.max(ACCOUNT.BIRTHDAY),
                        QueryMethods.avg(ACCOUNT.AGE).as("avgAge"))
                .from(ACCOUNT);
        printSql(wrapper);
        /**
         * SELECT
         *   ` id `,
         *   ` user_name `,
         *   MAX(` birthday `),
         *   AVG(` age `) AS ` avgAge `
         * FROM
         *   ` tb_account `
         */
    }

    @Test
    public void testSqlFunction2() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(concat(ACCOUNT.USER_NAME, string("ly")))
                .from(ACCOUNT)
                .where(not(ACCOUNT.AGE.eq(3)));
        printSql(wrapper);
        /**
         * SELECT
         *   CONCAT(` user_name `, 'ly')
         * FROM
         *   ` tb_account `
         * WHERE
         *   NOT (` age ` = 3)
         */
    }

4、Lambda 扩展

@Test
    public void testLambda() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .from(Account.class)
                .select(Account::getId, Account::getUserName)
                .where(Account::getAge).gt(20)
                .or(Account::getUserName).like("ly")
                .or(Account::getBirthday).between(DateUtil.parseDate("2023-08-10"), DateUtil.parseDate("2023-08-16"));
        printSql(wrapper);
    }

结果

SELECT
  ` id `,
  ` user_name `
FROM
  ` tb_account `
WHERE
  ` age ` > 20
  OR ` user_name ` LIKE '%ly%'
  OR ` birthday ` BETWEEN '2023-08-10 00:00:00' AND '2023-08-16 00:00:00'

5、字符串扩展

前面的所有操作都可以使用字符串的形式进行拼接,当然混着用也是可以的

/**
     * 字符串扩展
     */
    @Test
    public void testString() {
    
        long id = 1L;
        QueryWrapper wrapper = QueryWrapper.create()
                .select("id", "user_name", "age")
                .from("tb_account")
                .where("id = ?", id);
        printSql(wrapper);
    }

结果

SELECT
  id,
  user_name,
  age
FROM
  ` tb_account `
WHERE
  id = 1

6、CPI工具

用于设置修改QueryWrapper相关属性信息

@Test
    public void testCPI() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.ALL_COLUMNS)
                .from(ACCOUNT)
                .where(ACCOUNT.AGE.gt(10))
                .limit(10);
        CPI.setLimitRows(wrapper, 1L);

        printSql(wrapper);
    }

7、QueryWrapper方法全解

(1) select *

查询所有列

  • SQL
SELECT * FROM ` tb_account `
  • MF
/**
     * select *
     */
    @Test
    public void testSelectAll() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.ALL_COLUMNS)
                .from(ACCOUNT);
        printSql(wrapper);
    }
(2) select as

给某些列取别名

  • SQL
SELECT ` user_name ` AS ` user_name ` FROM ` tb_account `
  • MF
/**
     * select as
     */
    @Test
    public void testSelectAs() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.USER_NAME.as(Account::getUserName))
                .from(ACCOUNT);
        printSql(wrapper);
    }
(3) select multi table

查询多张表

  • SQL
SELECT
  ` T1 `.*,
  ` T2 `.*
FROM
  ` tb_user ` AS ` T1 `,
  ` tb_card ` AS ` T2 `
WHERE ` T1 `.` id ` = ` T2 `.` user_id `
  • MF
/**
     * select multi-table
     */
    @Test
    public void testSelectMultiTableColumn() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(USER.ALL_COLUMNS, CARD.ALL_COLUMNS)
                .from(USER.as("T1"), CARD.as("T2"))
                .where(USER.ID.eq(CARD.USER_ID));
        printSql(wrapper);
    }
(4) select function

查询时使用函数

  • SQL
SELECT
   MAX(` age `),
   AVG(` age `),
   MIN(` age `) AS ` age_avg `
 FROM
   ` tb_user `
  • MF
/**
     * select function
     */
    @Test
    public void testSelectFunction() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(max(USER.AGE), avg(USER.AGE), min(USER.AGE).as("age_avg"))
                .from(USER);
        printSql(wrapper);
    }

所有函数参考官网AllFunction

(5) 列计算

在列上做一些计算操作

  • SQL
SELECT
  (` age ` + 10) AS ` age `,
  SUM(` id ` * ` age `) AS ` total `
FROM
  ` tb_account `
  • MF
/**
     * select 列计算
     */
    @Test
    public void testColumnCalculation() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.AGE.add(10).as("age"),
                        sum(ACCOUNT.ID.multiply(ACCOUNT.AGE)).as("total"))
                .from(ACCOUNT);
        printSql(wrapper);
    }
(6) select case…when

case … when条件语句

  • SQL
 SELECT
   ` user_name `,
   (
     CASE
       WHEN ` age ` >= 18 THEN '青年'
       WHEN ` age ` >= 30 THEN '中年'
       WHEN ` age ` >= 60 THEN '老年'
       ELSE '其他'
     END
   ) AS ` desc `
 FROM
   ` tb_account `
  • MF
/**
     * select case...when
     */
    @Test
    public void selectCaseWhen() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .from(ACCOUNT)
                .select(ACCOUNT.USER_NAME,
                        case_().when(ACCOUNT.AGE.ge(18))
                                .then("青年")
                                .when(ACCOUNT.AGE.ge(30))
                                .then("中年")
                                .when(ACCOUNT.AGE.ge(60))
                                .then("老年")
                                .else_("其他")
                                .end().as("desc")
                );
        printSql(wrapper);
    }
(7) where 条件

查询条件

  • SQL
SELECT
  ` id `,
  ` age `,
  ` birthday `,
  ` user_name `
FROM
  ` tb_account `
WHERE
  (
    ` id ` <= 3
    OR ` age ` >= 10
  )
  AND ` user_name ` LIKE '张%'
  • MF
/**
     * where 条件
     */
    @Test
    public void testWhere() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.DEFAULT_COLUMNS)
                .from(ACCOUNT)
                .where(ACCOUNT.ID.le(3).or(ACCOUNT.AGE.ge(10)))
                .and(ACCOUNT.USER_NAME.likeLeft("张"));
        printSql(wrapper);
    }
(8) dynamic where 条件

动态查询条件

  • SQL
SELECT
  ` id `,
  ` age `,
  ` birthday `,
  ` user_name `
FROM
  ` tb_account `
WHERE
  ` user_name ` LIKE 'zhang%'
  • MF
/**
     * dynamic where 条件
     */
    @Test
    public void testDynamicWhere1() {
    
        boolean flag = false;
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.DEFAULT_COLUMNS)
                .from(ACCOUNT)
                .where(flag ? ACCOUNT.AGE.gt(10) : noCondition())
                .and(ACCOUNT.USER_NAME.likeLeft("zhang"));
        printSql(wrapper);
    }

 @Test
    public void testDynamicWhere2() {
    
        String name = "";
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.ALL_COLUMNS)
                .from(ACCOUNT)
                .where(ACCOUNT.USER_NAME.like(name).when(StringUtil.isNotBlank(name)));
        printSql(wrapper);
    }

@Test
    public void testDynamicWhere3() {
    
        String name = "aaa";
        QueryWrapper wrapper = QueryWrapper.create()
                .from(ACCOUNT)
                .where(ACCOUNT.USER_NAME.like(name).when(If.hasText(name)))
                .and(ACCOUNT.AGE.ge(10));
        /**
         *SELECT
         *   *
         * FROM
         *   ` tb_account `
         * WHERE
         *   ` user_name ` LIKE '%aaa%'
         *   AND ` age ` >= 10
         */
        printSql(wrapper);
    }

@Test
    public void testDynamicWhere4() {
    
        String name = "aaa";
        QueryWrapper wrapper = QueryWrapper.create()
                .select()
                .from(ACCOUNT)
                .where(ACCOUNT.ID.ge(2))
                .or(ACCOUNT.USER_NAME.like(name, StringUtil.isNotBlank(name)));
        /**
         *SELECT
         *   *
         * FROM
         *   ` tb_account `
         * WHERE
         *   ` id ` >= 2
         *   OR ` user_name ` LIKE '%aaa%'
         */
        printSql(wrapper);
    }
(9) where select 子查询

子查询

  • SQL
SELECT
  *
FROM
  ` tb_account `
WHERE
  ` id ` >= (
    SELECT
      ` id `
    FROM
      ` tb_account `
    WHERE
      ` birthday ` >= '2023-08-29 15:29:15'
  )
  • MF
/**
     * where select 类似子查询
     */
    @Test
    public void testWhereSelect() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.ALL_COLUMNS)
                .from(ACCOUNT)
                .where(ACCOUNT.ID.ge(
                        select(ACCOUNT.ID).from(ACCOUNT).where(ACCOUNT.BIRTHDAY.ge(new Date()))
                ));
        printSql(wrapper);
    }
(10) where exists, not exists 条件

存在|不存在

  • SQL
SELECT
  *
FROM
  ` tb_account `
WHERE
  ` id ` >= 100
  AND EXISTS (
    SELECT
      1
    FROM
      ` tb_account `
    WHERE
      ` id ` = 1
  )
  • MF
/**
     * where exists, not exists
     */
    @Test
    public void testWhereExistsAndNotExists() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .from(ACCOUNT)
                .where(ACCOUNT.ID.ge(100))
                .and(exists( // notExists
                        selectOne().from(ACCOUNT).where(ACCOUNT.ID.eq(1))
                ));
        printSql(wrapper);
    }
(11) and (…) or (…)

条件连接and|or

  • SQL
SELECT
   *
 FROM
   ` tb_account `
 WHERE
   ` id ` >= 1
   AND (
     ` age ` >= 18
     OR ` user_name ` LIKE '%zs%'
   )
   OR (
     ` age ` IN (20, 21, 22)
     AND ` user_name ` LIKE '%a'
   )
  • MF
/**
     * and (...) or (...)
     */
    @Test
    public void testAndOr() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.ALL_COLUMNS)
                .from(ACCOUNT)
                .where(ACCOUNT.ID.ge(1))
                .and(ACCOUNT.AGE.ge(18).or(ACCOUNT.USER_NAME.like("zs")))
                .or(ACCOUNT.AGE.in(20, 21, 22).and(ACCOUNT.USER_NAME.likeRight("a")));
        printSql(wrapper);
    }
(12) group by

分组

  • SQL
SELECT
   *
 FROM
   ` tb_account `
 GROUP BY
   ` user_name `
  • MF
/**
     * group by
     */
    @Test
    public void testGroupBy() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.ALL_COLUMNS)
                .from(ACCOUNT)
                .groupBy(ACCOUNT.USER_NAME);
        printSql(wrapper);
    }
(13) having

分组后筛选

  • SQL
SELECT
   *
 FROM
   ` tb_account `
 GROUP BY
   ` age `
 HAVING
   ` age ` > 18
  • MF
/**
     * having
     */
    @Test
    public void testHaving() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.ALL_COLUMNS)
                .from(ACCOUNT)
                .groupBy(ACCOUNT.AGE)
                .having(ACCOUNT.AGE.gt(18));
        printSql(wrapper);
    }
(14) join (inner join、left join、right join、full join)

连接查询

  • SQL
SELECT
   ` T1 `.` id `,
   ` T1 `.` age `,
   ` T1 `.` email `,
   ` T1 `.` dept_id `,
   ` T1 `.` user_name `,
   ` T1 `.` gmt_create `,
   ` T1 `.` gmt_modified `,
   ` T2 `.` id ` AS ` tb_card $ id `,
   ` T2 `.` card_no `,
   ` T2 `.` user_id `,
   ` T2 `.` content `
 FROM
   ` tb_user ` AS ` T1 `
 INNER JOIN ` tb_card ` AS ` T2 ` ON ` T1 `.` id ` = ` T2 `.` user_id `
 LEFT JOIN ` tb_card ` ON ` T1 `.` id ` = ` T2 `.` user_id `
 RIGHT JOIN ` tb_card ` ON ` T2 `.` user_id ` = ` T1 `.` id `
 FULL JOIN ` tb_card ` ON ` T1 `.` id ` = ` T2 `.` user_id `
WHERE
  ` T1 `.` age ` > 18
  • MF
/**
     * test join (inner join、left join、right join、full join)
     */
    @Test
    public void testJoin() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(USER.DEFAULT_COLUMNS, CARD.DEFAULT_COLUMNS)
                .from(USER).as("T1")
                // inner join
                .innerJoin(CARD).as("T2")
                .on(USER.ID.eq(CARD.USER_ID))
                // left join
                .leftJoin(CARD)
                .on(USER.ID.eq(CARD.USER_ID))
                // right join
                .rightJoin(CARD)
                .on(CARD.USER_ID.eq(USER.ID))
                // full join
                .fullJoin(CARD)
                .on(USER.ID.eq(CARD.USER_ID))
                .where(USER.AGE.gt(18));
        printSql(wrapper);
    }
(15) join on 多个条件

链表查询on多个条件

  • SQL
SELECT
   ` tb_user `.` id `,
   ` tb_user `.` age `,
   ` tb_user `.` email `,
   ` tb_user `.` dept_id `,
   ` tb_user `.` user_name `,
   ` tb_user `.` gmt_create `,
   ` tb_user `.` gmt_modified `
 FROM
   ` tb_user `
   LEFT JOIN ` tb_card ` ON ` tb_user `.` id ` = ` tb_card `.` user_id `
   AND ` tb_user `.` id ` >= 3
 WHERE
   ` tb_card `.` id ` > 5
  • MF
/**
     * join on 多个条件
     */
    @Test
    public void testJoinOn() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(USER.DEFAULT_COLUMNS)
                .from(USER)
                .leftJoin(CARD)
                .on(
                        USER.ID.eq(CARD.USER_ID)
                                .and(USER.ID.ge(3))
                ).where(CARD.ID.gt(5));
        printSql(wrapper);
    }
(16) join select

join中嵌套子查询，类似产生一张中间表

  • SQL

SELECT
  ` tb_user `.` id `,
  ` tb_user `.` age `,
  ` tb_user `.` email `,
  ` tb_user `.` dept_id `,
  ` tb_user `.` user_name `,
  ` tb_user `.` gmt_create `,
  ` tb_user `.` gmt_modified `
FROM
  ` tb_user `
  LEFT JOIN (
    SELECT
      ` user_id `
    FROM
      ` tb_card ` AS ` temp `
    WHERE
      ` id ` > 3
  ) ON ` tb_user `.` id ` = 'temp.user_id'
 WHERE
   ` tb_user `.` age ` > 18
 GROUP BY
   ` tb_user `.` user_name `
 HAVING
   ` tb_user `.` user_name ` LIKE '%Z'
  • MF
/**
     * join select
     */
    @Test
    public void testJoinSelect() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(USER.DEFAULT_COLUMNS)
                .from(USER)
                .leftJoin(
                        select(CARD.USER_ID).from(CARD).where(CARD.ID.gt(3)).as("temp")
                ).on(USER.ID.eq("temp.user_id"))
                .where(USER.AGE.gt(18))
                .groupBy(USER.USER_NAME)
                .having(USER.USER_NAME.likeRight("Z"));
        printSql(wrapper);
    }
(17) limit… offset

分页

limit… offset MyBatis-Flex 能够自动识别当前数据库，并根据数据库的类型生成不同的 SQL，用户也可以很轻易的通过 DialectFactory 注册（新增或改写）自己的实现方言。

  • SQL
SELECT
   ` id `,
   ` age `,
   ` birthday `,
   ` user_name `
 FROM
   ` tb_account `
 WHERE
   ` id ` > 1
 ORDER BY
   ` id ` DESC,
   ` age ` ASC
 LIMIT
   0, 10
  • MF
/**
     * limit... offset MyBatis-Flex 能够自动识别当前数据库，
     * 并根据数据库的类型生成不同的 SQL，用户也可以很轻易的通过 DialectFactory 注册（新增或改写）自己的实现方言。
     */
    @Test
    public void testLimitOffset() {
    
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.DEFAULT_COLUMNS)
                .from(ACCOUNT)
                .where(ACCOUNT.ID.gt(1))
                .orderBy(ACCOUNT.ID.desc(), ACCOUNT.AGE.asc())
                .limit(10)
                .offset(0);
        printSql(wrapper);
    }
(18) Entity 转化为 QueryWrapper

让实体属性值直接作为查询条件

  • SQL
 SELECT
   ` id `,
   ` user_name `,
   ` age `,
   ` birthday `
 FROM
   ` tb_account `
 WHERE
   ` user_name ` = 'ly'
   AND ` age ` = 18
  • MF
/**
     * Entity 转化为 QueryWrapper
     * 这种方式，默认通过"and"进行连接
     */
    @Test
    public void testEntityToQueryWrapper() {
    
        Account account = new Account();
        account.setAge(18);
        account.setUserName("ly");

        QueryWrapper wrapper = QueryWrapper.create(account)
                .from(ACCOUNT);
        printSql(wrapper);
    }
(19) 自定义操作符

自定义操作符，让实体属性值通过and|or…进行连接

  • SQL
SELECT
  ` id `,
  ` user_name `,
  ` age `,
  ` birthday `
FROM
  ` tb_account `
WHERE
  ` user_name ` LIKE '%ly%'
  AND ` age ` >= 18
  • MF
/**
     * 自定义操作符
     */
    @Test
    public void testEntityToQueryWrapper2() {
    
        Account account = new Account();
        account.setAge(18);
        account.setUserName("ly");
        SqlOperators operators = SqlOperators.of()
                .set(Account::getUserName, SqlOperator.LIKE)
                .set(Account::getAge, SqlOperator.GE);
        QueryWrapper wrapper = QueryWrapper.create(account,operators)
                .from(ACCOUNT);
        printSql(wrapper);
    }
(20) 注意点

在 QueryWrapper 的条件构建中，如果传入 null 值，则自动忽略该条件，
这有许多的好处，不需要额外的通过 when() 方法判断。
但是也带来一些额外的知识记忆点， 因此，正对这一点需要特别注意一下

  • SQL
SELECT
  *
FROM
  ` tb_account `
WHERE
  ` id ` > 1
  • MF
/**
     * 在 QueryWrapper 的条件构建中，如果传入 null 值，则自动忽略该条件，
     * 这有许多的好处，不需要额外的通过 when() 方法判断。
     * 但是也带来一些额外的知识记忆点， 因此，正对这一点需要特别注意一下
     */
    @Test
    public void testQeuryWrapperIgnoreNull() {
    
        String name = null;
        Integer age = null;
        QueryWrapper wrapper = QueryWrapper.create()
                .from(ACCOUNT)
                .where(ACCOUNT.AGE.eq(age))
                .and(ACCOUNT.USER_NAME.like(name))
                .and(ACCOUNT.ID.gt(1));
        printSql(wrapper);
    }
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45529338/article/details/132630225

智能推荐

线程安全和可重入函数的区别与联系-程序员宅基地

文章浏览阅读75次。一、线程安全线程安全：如果一个函数在同一时刻可以被多个线程安全的调用，就称该函数是线程安全的。不需要共享时，请为每个线程提供一个专用的数据副本。如果共享非常重要，则提供显式同步，以确保程序以确定的方式操作。通过将过程包含在语句中来锁定和解除锁定互斥，可以使不安全过程变成线程安全过程，而且可以进行串行化。很多函数并不是线程安全的，因为他们返回的数据是存放在静态的内存缓冲区中的。..._可重入函数与线程安全的区别与联系

两款免费好用的OPCUA服务端模拟器_opcua模拟器-程序员宅基地

文章浏览阅读3k次。启动Softing OPC Client输入连接信息后可以看到已经连接到OPC服务器。打开文件目录下的.config，修改IP和端口号即可。Softing OPC Client显示已经连接。_opcua模拟器

【漏洞复现】宏景ehr-hcm-templates-文件读取-程序员宅基地

文章浏览阅读186次，点赞3次，收藏3次。宏景HCM系统是一款由宏景软件研发的系统，主要功能包括人员、组织机构、档案、合同、薪资、保险、绩效、考勤、招聘、培训、干部任免和人事流程等业务的管理，以及人事、绩效、培训、招聘、考勤等业务自助，还具备了报表功能和灵活的表格工具，支持集团管控、目标管理、领导决策等应用。宏景HCM系统templates接口存在文件读取漏洞。攻击者可以通过发送特定的POST请求，利用该漏洞获取系统敏感文件。

Oracle数据库入门笔记（上）-程序员宅基地

文章浏览阅读987次，点赞15次，收藏14次。语法：DROP TABLE 表名。

文件包含漏洞全面详解-程序员宅基地

文章浏览阅读5.4w次，点赞148次，收藏888次。1.文件包含漏洞概述和SQL注入等攻击方式一样，文件包含漏洞也是一种注入型漏洞，其本质就是输入一段用户能够控制的脚本或者代码，并让服务端执行。什么叫包含呢？以PHP为例，我们常常把可重复使用的函数写入到单个文件中，在使用该函数时，直接调用此文件，而无需再次编写函数，这一过程叫做包含。有时候由于网站功能需求，会让前端用户选择要包含的文件，而开发人员又没有对要包含的文件进行安全考虑，就导致攻击者可以通过修改文件的位置来让后台执行任意文件，从而导致文件包含漏洞。以PHP为例,常用的文件包含函数有以下四种。..._文件包含漏洞

LeetCode | Path Sum-程序员宅基地

文章浏览阅读1.1k次。题目：Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.For example:Given the below binary tree

随便推点

Android中Editext响应回车键事件_android edittext 回车事件-程序员宅基地

文章浏览阅读182次。Editext 按键响应回车事件事件。_android edittext 回车事件

iSCSI存储系统知识详解_iscsi目前发展状况-程序员宅基地

文章浏览阅读1.1w次，点赞4次，收藏25次。原文：https://community.emc.com/docs/DOC-33815SCSI 即 小型计算机系统接口 。小型计算机系统接口（英语：Small Computer System Interface; 简写：SCSI），一种用于计算机和智能设备之间（硬盘、软驱、光驱、打印机、扫描仪等）系统级接口的独立处理器标准。SCSI是一种智能的通用接口标准。它是各种计算机与外部_iscsi目前发展状况

C# 不能引用命名空间_hybridclr 引用不了c#的命名空间-程序员宅基地

文章浏览阅读701次。C# 不能引用命名空间_hybridclr 引用不了c#的命名空间

win修改时间格式-程序员宅基地

文章浏览阅读346次，点赞8次，收藏6次。根据大佬操作未能实现，在最后一步，还需要什么操作吗？

Android 获取视频某一帧，并且设置为封面-程序员宅基地

文章浏览阅读6.8k次。最近要做一个为视频设置封面的功能，这里展示一下简单的demo。demo效果这里直接将选取的视频某一时间的bitmap显示在视频下方。上面是视频，下面是所获取那一帧的截图。具体代码这里的话主要是靠videoView来显示视频内容，seekBar来控制视频的进度,使用MediaMetadataRetriever来获取所选中进度的时间的视频画面。布局代码&lt;LinearLayoutx..._android 仿剪映app 视频封面设置功能demo

vmoptions idea 多个参数-程序员宅基地

文章浏览阅读7.1k次。 多个参数用空格隔开就行。 如：-Dspring.property.path=/Users/germmy/gitall/nono-properties/nono-all/nono-app/nono-web/stb -Dlog.dir=/Users/germmy/gitall/nono-all/nono-app/nono-web 对于这种参数，可以在..._idea vm options 多个参数

推荐文章

热门文章

相关标签