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

智能推荐

FTP命令字和返回码_ftp 登录返回230-程序员宅基地

文章浏览阅读3.5k次，点赞2次，收藏13次。为了从FTP服务器下载文件，需要要实现一个简单的FTP客户端。FTP（文件传输协议） 是 TCP/IP 协议组中的应用层协议。FTP协议使用字符串格式命令字，每条命令都是一行字符串，以“\r\n”结尾。客户端发送格式是：命令+空格+参数+"\r\n"的格式服务器返回格式是以：状态码+空格+提示字符串+"\r\n"的格式，代码只要解析状态码就可以了。读写文件需要登陆服务器，特殊用..._ftp 登录返回230

centos7安装rabbitmq3.6.5_centos7 安装rabbitmq3.6.5-程序员宅基地

文章浏览阅读648次。前提：systemctl stop firewalld 关闭防火墙关闭selinux查看getenforce临时关闭setenforce 0永久关闭sed-i'/SELINUX/s/enforcing/disabled/'/etc/selinux/configselinux的三种模式enforcing：强制模式，SELinux 运作中，且已经正确的开始限制..._centos7 安装rabbitmq3.6.5

idea导入android工程,idea怎样导入Android studio 项目？-程序员宅基地

文章浏览阅读5.8k次。满意答案s55f2avsx2017.09.05采纳率：46%等级：12已帮助：5646人新版Android Studio/IntelliJ IDEA可以直接导入eclipse项目,不再推荐使用eclipse导出gradle的方式2启动Android Studio/IntelliJ IDEA，选择 import project3选择eclipse 项目4选择 create project f..._android studio 项目导入idea 看不懂安卓项目

浅谈AI大模型技术：概念、发展和应用_ai大模型应用开发-程序员宅基地

文章浏览阅读860次，点赞2次，收藏6次。AI大模型技术已经在自然语言处理、计算机视觉、多模态交互等领域取得了显著的进展和成果，同时也引发了一系列新的挑战和问题，如数据质量、计算效率、知识可解释性、安全可靠性等。城市运维涉及到多个方面，如交通管理、环境监测、公共安全、社会治理等，它们需要处理和分析大量的多模态数据，如图像、视频、语音、文本等，并根据不同的场景和需求，提供合适的决策和响应。知识搜索有多种形式，如语义搜索、对话搜索、图像搜索、视频搜索等，它们可以根据用户的输入和意图，从海量的数据源中检索出最相关的信息，并以友好的方式呈现给用户。_ai大模型应用开发

非常详细的阻抗测试基础知识_阻抗实部和虚部-程序员宅基地

文章浏览阅读8.2k次，点赞12次，收藏121次。为什么要测量阻抗呢？阻抗能代表什么？阻抗测量的注意事项... ...很多人可能会带着一系列的问题来阅读本文。不管是数字电路工程师还是射频工程师，都在关注各类器件的阻抗，本文非常值得一读。全文13000多字，认真读完大概需要2小时。一、阻抗测试基本概念阻抗定义：阻抗是元器件或电路对周期的交流信号的总的反作用。AC 交流测试信号 (幅度和频率)。包括实部和虚部。​图1 阻抗的定义阻抗是评测电路、元件以及制作元件材料的重要参数。那么什么是阻抗呢？让我们先来看一下阻抗的定义。首先阻抗是一个矢量。通常，阻抗是_阻抗实部和虚部

小学生python游戏编程arcade----基本知识1_arcade语言 like-程序员宅基地

文章浏览阅读955次。前面章节分享试用了pyzero,pygame但随着想增加更丰富的游戏内容，好多还要进行自己编写类，从今天开始解绍一个新的python游戏库arcade模块。通过此次的《连连看》游戏实现，让我对swing的相关知识有了进一步的了解，对java这门语言也有了比以前更深刻的认识。java的一些基本语法，比如数据类型、运算符、程序流程控制和数组等，理解更加透彻。java最核心的核心就是面向对象思想，对于这一个概念，终于悟到了一些。_arcade语言 like

随便推点

【增强版短视频去水印源码】去水印微信小程序+去水印软件源码_去水印机要增强版-程序员宅基地

文章浏览阅读1.1k次。源码简介与安装说明：2021增强版短视频去水印源码 去水印微信小程序源码网站 去水印软件源码安装环境（需要材料）：备案域名–服务器安装宝塔-安装 Nginx 或者 Apachephp5.6 以上-安装 sg11 插件小程序已自带解析接口，支持全网主流短视频平台，搭建好了就能用注：接口是公益的，那么多人用解析慢是肯定的，前段和后端源码已经打包，上传服务器之后在配置文件修改数据库密码。然后输入自己的域名，进入后台，创建小程序，输入自己的小程序配置即可安装说明：上传源码，修改data/_去水印机要增强版

verilog进阶语法-触发器原语_fdre #(.init(1'b0) // initial value of register (1-程序员宅基地

文章浏览阅读557次。1. 触发器是FPGA存储数据的基本单元2. 触发器作为时序逻辑的基本元件，官方提供了丰富的配置方式，以适应各种可能的应用场景。_fdre #(.init(1'b0) // initial value of register (1'b0 or 1'b1) ) fdce_osc (

嵌入式面试/笔试C相关总结_嵌入式面试笔试c语言知识点-程序员宅基地

文章浏览阅读560次。本该是不同编译器结果不同，但是尝试了g++ msvc都是先计算c，再计算b，最后得到a+b+c是经过赋值以后的b和c参与计算而不是6。由上表可知，将q复制到p数组可以表示为：*p++=*q++，*优先级高，先取到对应q数组的值，然后两个++都是在后面，该行运算完后执行++。在电脑端编译完后会分为text data bss三种，其中text为可执行程序，data为初始化过的ro+rw变量，bss为未初始化或初始化为0变量。_嵌入式面试笔试c语言知识点

57 Things I've Learned Founding 3 Tech Companies_mature-程序员宅基地

文章浏览阅读2.3k次。57 Things I've Learned Founding 3 Tech CompaniesJason Goldberg, Betashop | Oct. 29, 2010, 1:29 PMI’ve been founding andhelping run techn_mature

一个脚本搞定文件合并去重，大数据处理，可以合并几个G以上的文件_python 超大文本合并-程序员宅基地

文章浏览阅读1.9k次。问题：先讲下需求，有若干个文本文件（txt或者csv文件等），每行代表一条数据，现在希望能合并成 1 个文本文件，且需要去除重复行。分析：一向奉行简单原则，如无必要，绝不复杂。如果数据量不大，那么如下两条命令就可以搞定合并：cat a.txt >> new.txtcat b.txt >> new.txt……去重：cat new...._python 超大文本合并

支付宝小程序iOS端过渡页DFLoadingPageRootController分析_类似支付宝页面过度加载页-程序员宅基地

文章浏览阅读489次。这个过渡页是第一次打开小程序展示的，点击某个小程序前把手机的开发者->network link conditioner->enable & very bad network 就会在停在此页。比如《支付宝运动》这个小程序先看这个类的.h可以看到它继承于DTViewController点击左上角返回的方法- (void)back;#import "DTViewController.h"#import "APBaseLoadingV..._类似支付宝页面过度加载页

推荐文章

热门文章

相关标签