Mybatis-Flex之QueryWrapper
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函数
/**
* 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);
}
Mybatis-Flex之QueryWrapper的更多相关文章
- MyBatis：条件构造器QueryWrapper方法详解
QueryWrapper 说明: 继承自 AbstractWrapper ,自身的内部属性 entity 也用于生成 where 条件及 LambdaQueryWrapper, 可以通过 n ...
- 整合spring roo，maven,mybatis,spring-flex,blazeds,mysql
1. 下载spring roo,设置环境变量ROO_HOME,和path,classpath. 使用CMD命令行找到工作区间,新建工程目录转到工程目录:mkdir ten-minutes $ ...
- spring整合flex
在常规的开发中只是用flex二不和后台交互是不可能的,为此flex也提供了和后台交互的2种解决方案一种是Data Services另一种是BlazeDs,本篇博客是用的是后一种,我的开发步骤如下: 1 ...
- Flex入门(三)——微架构之Cairngorm
大家都知道我们在开发后台的时候,都会使用MVC,三层等分层架构,使后台代码达到职责更为分明单一,高内聚低耦合,比如,Dao层仅仅是进行和数据库打交道,负责处理数据:Service(B层)仅仅是进行逻辑 ...
- Java和Flex整合报错（四）
1.错误描述 usage: java org.apache.catalina.startup.Catalina [ -config {pathname} ] [ -nonaming ] { -help ...
- Java和Flex整合报错（三）
1.错误描述 信息: Initializing Spring FrameworkServlet 'mvc' 11-13 23:43:42 INFO [localhost-startStop-1] or ...
- Java和Flex整合报错（二）
1.错误原因 usage: java org.apache.catalina.startup.Catalina [ -config {pathname} ] [ -nonaming ] { -help ...
- Vue+SpringBoot+Mybatis的简单员工管理项目
本文项目参考自:https://github.com/boylegu/SpringBoot-vue 为了完成此项目你需要会springBoot,mybatis的一些基本操作 运行界面 第一步:搭建前端 ...
- 使用mybatis plus 操作数据库
mybatis plus 是基于mybatis 的一个增强包,比 mybatis 更加容易使用. 特点: 1.分页支持 2.支持自定义查询. 3.简单的情况下,不需要写map.xml 文件 4.支持租 ...
- Spring security + oauth2.0 + redis + mybatis plus 搭建微服务
上个星期一个朋友请求帮忙,让我搭建一个分布式授权中心的微服务,之前我也没搭建过,在网上撸了几天前辈们写的技术博客,搞出个模型,分享给大家: 前辈们博客地址: OAuth2.0 原理:https://b ...
随机推荐
- LeetCode 周赛上分之旅 #42 当 LeetCode 考树上倍增，出题的趋势在变化吗
️ 本文已收录到 AndroidFamily,技术和职场问题,请关注公众号 [彭旭锐] 和 BaguTree Pro 知识星球提问. 学习数据结构与算法的关键在于掌握问题背后的算法思维框架,你的思考越 ...
- Nomad 系列-快速上手
系列文章 Nomad 系列文章 Nomad 重要术语 Nomad 安装设置相关术语 agent - 代理.Agent 是在 Server(服务器) 或 Client(客户端) 模式下运行的 Nomad ...
- 数据库安装postgresql
数据库安装postgresql 目录 数据库安装postgresql 1.数据库源替换下载 2.初始化数据库并启动安装 3.登录数据库设置密码 4.常用命令 一.常用命令 二.用户 三.权限 四.模式 ...
- Redis持久化 (RDB和AOF) 梳理
Redis有两种持久化方案: RDB持久化 AOF持久化 RDB持久化 RDB全称Redis Database Backup file(Redis数据备份文件),也被叫做Redis数据快照.简单来说就 ...
- 在线问诊 Python、FastAPI、Neo4j — 构建问题分类器
目录 构建字典数据 构建 Trie 字典树 按实体组装字典 问题分析 将问题进行分析,和系统已有的分类进行关联 构建字典数据 将构建的知识图片字典化, 用于后面对问题的解析,下图为症状的字典,其它字典 ...
- Dubbo源码浅析（一）—RPC框架与Dubbo
一.什么是RPC 1.1 RPC概念 RPC,Remote Procedure Call 即远程过程调用,与之相对的是本地服务调用,即LPC(Local Procedure Call).本地服务调用比 ...
- 聊聊基于Alink库的主成分分析(PCA)
概述 主成分分析(Principal Component Analysis,PCA)是一种常用的数据降维和特征提取技术,用于将高维数据转换为低维的特征空间.其目标是通过线性变换将原始特征转化为一组新的 ...
- Installing Gradle
Chapter 4. Installing Gradle 4.1. Prerequisites Gradle requires a Java JDK or JRE to be installed, v ...
- 教育法学第九章单元测试MOOC
第九章单元测试 返回 本次得分为:100.00/100.00, 本次测试的提交时间为:2020-09-06, 如果你认为本次测试成绩不理想,你可以选择 再做一次 . 1 单选(5分) 作为教师最基本的 ...
- jmeter生成随机英文的几种方法
第一种:用BeanShell后置处理程序 1.写脚本 import java.util.Random; String random(int s_length) { strings= &qu ...