2022年6月26日 14:16 周日使用命令 crontab -e 创建一个定时任务
*/1 * * * * ls -l /etc/ > /tmp/to.txt
特殊符号
，代表不连续
-破折号 表示连续
其他
定时调用脚本
编辑脚本 my.sh
date >> /home/mycal
date >> /home/mycal
给脚本赋予x权限
chmod u+x my.sh
crontab -e
*/1 * * * * my.sh
数据库备份
crontab -r 删除
crontab -l 列出
crontab -e 编辑任务
atd 是否在运行 yum install -y atd systemctl start atd
job队列
2022年6月25日 17:56 周六
rwxrwxrwx 第一列有十位，第0位确认文件类型 -普通文件，l是链接；d是目录；c是字符设备文件、鼠标、键盘；b块设备 1-3表示文件所有者拥有的权限；4-6是文件所在组所拥有的权限，7-9 其他组所拥有的权限
警察和土匪的游戏
...
2022年6月15日 21:13 周三架构篇
索引及调优篇
01
02-03
04-05
06
事务篇
日志与备份篇
查找当前系统已经装了哪些
rpm -qa |grep mysql
查找mysql服务运行状态
systemctl status mysql
停止mysql服务
systemctl stop mysql
删除
yum remove mysql-community-client-plugins-8.0.29-1.el7.x86_64
yum remove mysql-community-common-8.0.29-1.el7.x86_64
查找带mysql名字的文件夹
find / -name mysql
2022年6月12日 22:09 周日使用每个结点含有两个链接（链表中每个结点只含有一个链接）的二叉查找树来高效地实现符号表
该数据结构由结点组成，结点包含的链接可以为空(null)或者指向其他结点
一棵二叉查找树（BST）是一棵二叉树，其中每个结点都含有一个Comparable 的键（以 及相关联的值）且每个结点的键都大于其左子树中的任意结点的键而小于右子树的任意结点的键。
数据表示
多棵二叉查找树表示同一组有序的键来实现构建和使用二叉查找树的高校算法
查找
基于二叉查找树的符号表
public class BST<Key extends Comparable<Key>, Value>
{
private Node root;
// 二叉查找树的根结点
private class Node
{
private Key key;
// 键
private Value val;
// 值
private Node left, right;
// 指向子树的链接
private int N;
// 以该结点为根的子树中的结点总数
public Node(Key key, Value val, int N)
{
this.key = key;
this.val = val;
this.N = N;
}
}
public int size()
{
return size(root);
}
private int size(Node x)
{
if (x == null) return 0; else return x.N;
}
public Value get(Key key)
// 请见算法3.3（续1）
public void put(Key key, Value val)
// 请见算法3.3（续1）
// max()、min()、floor()、ceiling()方法请见算法3.3（续2）
// select()、rank()方法请见算法3.3（续3）
// delete()、deleteMin()、deleteMax()方法请见算法3.3（续4）
// keys()方法请见算法3.3（续5）
}
二叉查找树的查找和排序方法的实现
...
2022年6月4日 11:49 周六LambdaQueryWrapper主要是为了防止字段名写错
@Test
public void test11(){
String username="abc";
Integer ageBegin=null;
Integer ageEnd=30;
LambdaQueryWrapper<User> queryWrapper=new LambdaQueryWrapper<>();
queryWrapper.like(StringUtils.isNotBlank(username),User::getUserName,username)
.ge(ageBegin!=null,User::getAge,ageBegin);
userMapper.selectList(queryWrapper);
}
sql日志打印
==> Preparing: SELECT uid AS id,name AS userName,age,email,is_deleted_ly FROM t_user WHERE is_deleted_ly=0 AND (name LIKE ?)
==> Parameters: %abc%(String)
<== Total: 0
LambdaUpdateWrapper
@Test
public void test12() {
//(age>23且用户名包含a) 或 (邮箱为null)
LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.like(User::getUserName, "a")
.and(userUpdateWrapper ->
userUpdateWrapper.gt(User::getAge, 23).or().isNotNull(User::getEmail));
updateWrapper.set(User::getUserName, "小黑").set(User::getEmail, "abc@ly.com");
userMapper.update(null, updateWrapper);
}
sql日志打印
...
2022年6月3日 11:54 周五这里会出现 publicKey is now allowed ，在数据库连接语句后面加上这句话即可 allowPublicKeyRetrieval=true
spring:
#配置数据源
datasource:
#配置数据源类型
type: com.zaxxer.hikari.HikariDataSource
#配置数据源各个信息
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8&&useSSL=false&&allowPublicKeyRetrieval=true
username: root
password: 123456
查询
@Test
public void testList(){
//List<User> list = userService.list();
long count = userService.count();
System.out.println("总条数："+count);
}
SQL执行语句
==> Preparing: SELECT COUNT( * ) FROM user
==> Parameters:
<== Columns: COUNT( * )
<== Row: 5
<== Total: 1
批量添加
@Test
public void batchInsert(){
List<User> users=new ArrayList<>();
for(int i=0;i<10;i++){
User user=new User();
user.setName("name"+i);
user.setEmail("email"+i);
users.add(user);
}
boolean b = userService.saveBatch(users);
System.out.println("result:"+b);
}
sql日志输出
...
2022年6月3日 08:15 周五注：使用 mvn dependency:resolve -Dclassifier=sources 来获得mapper源码
一些接口介绍
/**
* 插入一条记录
*
* @param entity 实体对象
*/
int insert(T entity);
/**
* 根据 ID 删除
*
* @param id 主键ID
*/
int deleteById(Serializable id);
/**
* 根据实体(ID)删除
*
* @param entity 实体对象
* @since 3.4.4
*/
int deleteById(T entity);
/**
* 根据 columnMap 条件，删除记录
*
* @param columnMap 表字段 map 对象
*/
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
/**
* 根据 entity 条件，删除记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
*/
int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 删除（根据ID或实体 批量删除）
*
* @param idList 主键ID列表或实体列表(不能为 null 以及 empty)
*/
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<?> idList);
/**
* 根据 ID 修改
*
* @param entity 实体对象
*/
int updateById(@Param(Constants.ENTITY) T entity);
/**
* 根据 whereEntity 条件，更新记录
*
* @param entity 实体对象 (set 条件值,可以为 null)
* @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
*/
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
/**
* 根据 ID 查询
*
* @param id 主键ID
*/
T selectById(Serializable id);
/**
* 查询（根据ID 批量查询）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
/**
* 查询（根据 columnMap 条件）
*
* @param columnMap 表字段 map 对象
*/
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
/**
* 根据 entity 条件，查询一条记录
* <p>查询一条记录，例如 qw.last("limit 1") 限制取一条记录, 注意：多条数据会报异常</p>
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
default T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper) {
List<T> ts = this.selectList(queryWrapper);
if (CollectionUtils.isNotEmpty(ts)) {
if (ts.size() != 1) {
throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records");
}
return ts.get(0);
}
return null;
}
/**
* 根据 Wrapper 条件，判断是否存在记录
*
* @param queryWrapper 实体对象封装操作类
* @return
*/
default boolean exists(Wrapper<T> queryWrapper) {
Long count = this.selectCount(queryWrapper);
return null != count && count > 0;
}
/**
* 根据 Wrapper 条件，查询总记录数
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
Long selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 entity 条件，查询全部记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询全部记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询全部记录
* <p>注意： 只返回第一个字段的值</p>
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 entity 条件，查询全部记录（并翻页）
*
* @param page 分页查询条件（可以为 RowBounds.DEFAULT）
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
<P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询全部记录（并翻页）
*
* @param page 分页查询条件
* @param queryWrapper 实体对象封装操作类
*/
<P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
BaseMapper测试
...
2022年6月3日 06:47 周五
这里创建数据库mybatis_plus
然后创建表user
DROP TABLE IF EXISTS user;
CREATE TABLE user
(
id BIGINT(20) NOT NULL COMMENT '主键ID',
name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
age INT(11) NULL DEFAULT NULL COMMENT '年龄',
email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (id)
);
插入默认数据
DELETE FROM user;
INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');
添加依赖，并install Lombok 插件
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.0</version>
<relativePath/>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.29</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
<scope>provided</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/com.baomidou/mybatis-plus-generator -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.5.2</version>
</dependency>
</dependencies>
创建spring boot启动类
...
2022年5月31日 23:52 周二经典查找算法
用符号表这个词来描述抽象的表格，将信息（值）存储在其中，然后按照指定的键来获取这些信息
符号表也被称为字典
下面学习三种经典的数据类型：二叉查找树、红黑树和散列表
符号表最主要的目的是将键和值联系起来
用例能够将一个键值对插入符号表并希望在之后能够从符号表的所有键值对中按照键直接找到相对应的值
符号表是一种存储键值对的数据结构，支持两种操作：插入(put)，即将一组新的键值对存入表中；查找(get)，即根据给定的键得到相应的值
典型的符号表应用
符号表是一种典型的数据类型 ：代表着一组定义清晰的值及相应的操作。使用应用程序编程接口（API）来精确地定义这些操作
一种简单的泛型符号表API ST(Symbol Table)
泛型 对于符号表，我们通过明确地指定查找时键和值的类型来区分它们的不同角色【key和value】
重复的键
键不能为空
值不能为空（因为规定当键不存在时get()返回空） 当值为空表示删除
删除操作
延时删除，先将键对应的值置空，之后在某个时刻删除所有值为空的键
即时删除，立即从表中删除指定的键 put实现的开头：
if(val == null){
delete(key);
return;
}
便捷方法
迭代
在API第一行加上implements Iterable<Key> ，所有实现都包含iterator()方法来实现hasNext()和next()方法的迭代器；这里采用另一种方式：定义keys返回一个Iterable<Key>对象以方便便利所有的键，且允许遍历一部分
键的等价性 自定义的键需要重写equals()方法；且最好使用不可变数据类型作为键
如何使用
...
2022年5月29日 22:20 周日Java的约定使得我们能够利用Java的回调机制将任意实现Comparable接口的数据类型排序
交易事务 商业数据的处理，设想一家互联网商业公司为每笔交易记录都保存了所有的相关信息
public int compareTo(Transaction that)
{
return this.when.compareTo(that.when);
}
指针排序 我们使用的方法在经典教材中被称为指针排序，因为我们只处理元素的引用而不移动数据本身
不可变的键 用不可变的数据类型作为键，比如String、Integer、Double和File等
廉价的交换
使用引用的另一个好处是不必移动整个元素对于几乎任意大小的元素，使用引用使得在一般情况下交换的成本和比较的成本几乎相同（代价是需要额外的空间存储这些引用）
研究将数字排序的算法性能的一种方法就是观察其所需的比较和交换总数，因为这里隐式地假设了比较和交换的成本是相同的
多种排序方法
多键数组
一个元素的多种属性都可能被用作排序的键
使用Comparator的插入排序
public static void sort(Object[] a, Comparator c)
{
int N = a.length;
for (int i = 1; i < N; i++)
for (int j = i; j > 0 && less(Comparator, a[j], a[j-1]); j--)
exch(a, j, j-1);
}
private static Boolean less(Comparator c, Object v, Object w)
{
return c.compare(v, w) < 0;
}
private static void exch(Object[] a, int i, int j)
{
Object t = a[i];
a[i] = a[j];
a[j] = t;
}
使用比较器实现优先队列
...