01-16 maven基础_动力节点

2022年7月2日 18:58 周六

学习

Maven_基础动力节点

课程介绍#

maven 自动化构建–>开发–编译–运行-测试–打包–部署（m ei ’ ven）

maven的作用#

软件是一个工程
软件中重复的操作（开发阶段）
- 需求分析
- 设计阶段
- 开发阶段（编码），编译，测试
- 测试阶段（专业测试），测试报告
- 项目打包，发布，给客户安装项目
maven
- 项目自动构建，清理、编译、测试、打包、安装、部署
- 管理依赖：项目中需要使用的其他资源

Maven中的概念#

没有使用maven，管理jar，手动处理jar，以及jar之间的依赖
maven是apache 【əˈpætʃi】基金会的开源项目，使用java语法开发
maven是项目的自动化构建工具，管理项目依赖
maven中的概念
- POM
- 约定的目录
- 坐标
- 依赖管理
- 仓库管理
- 生命周期
- 插件和目标
- 继承（高级内容）
- 聚合（高级内容）

Maven资源的获取与安装，测试#

https://maven.apache.org/index.html
- 各种内容
- 要求
- 视频用的3.6.3 ，这里下载3.8.6 （最新的，不要和电脑原配置冲突，方便学习，后续改回3.8.4）
  - 检查java home
    - 如果没有需要进行配置
  - 将maven的bin目录配置到path环境变量下（这里使用的是下一节的方法，视频中没有用MAVEN_HOME，而是直接将maven的bin目录路径加到path中）
maven解压后的目录结构

另一种安装方式#

确定JAVA_HOME是否有效
创建M2_HOME(MAVEN_HOME)，值为maven的安装目录
在path环境中，加入%M2_HOME%\bin
测试maven安装 mvn -v

约定的目录结构#

大多数人遵守的目录结构

一个maven项目对应一个文件夹，比如Hello

Hello
	\src
		\main			叫做主程序目录（完成项目功能的代码和配置文件）
			\java		源代码（包和相关的类定义）
			\resources  配置文件
		\test			放置测试程序代码（开发人员自己写的测试代码）
			\java		测试代码（junit）
			\resources  测试程序的配置文件
	\pom.xml			maven的配置文件

Hello的Maven项目#

maven可以独立使用：创建项目、编译代码、测试程序、打包、部署等

52-X

2022年6月26日 14:16 周日

学习

Linux_韩老师

crond快速入门#

使用命令 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队列
at选项
at指定时间
添加任务

linux_韩老师_40-51

2022年6月25日 17:56 周六

学习

Linux_韩老师

组介绍#

每个用户必定属于某个组
每个文件有几个概念：所有者、所在组、其他组 tom创建了hello.txt，则所有者为tom，默认所在组为tom组除了所在组，就是其他组
ls -ahl （h更友好，a隐藏，l列表）

所有者#

使用chown root helo.java 修改，效果如下

所在组修改#

组的创建 groupadd monster
创建一个用户并让他属于该组 useradd -g monster fox
注意逻辑，此时使用fox创建文件 passwd fox 给fox创建密码
如图，创建一个文件
使用chgrp fruit orange.txt 修改文件的所在组
改变某个用户所在组 usermod -g fruit fox
使用 cat /etc/group 查看所有的组
当一个用户属于多个组的时候，groups会出现多个组名

rwx权限#

rwxrwxrwx 第一列有十位，第0位确认文件类型 -普通文件，l是链接；d是目录；c是字符设备文件、鼠标、键盘；b块设备 1-3表示文件所有者拥有的权限；4-6是文件所在组所拥有的权限，7-9 其他组所拥有的权限

rwx作用到文件，r代表可读可查看，w代表可修改（如果是删除权限，则必须在该文件所在的目录有写权限，才能删除），x代表可执行
rwx作用到目录，r表示可以读取(ls可查看目录内容)，w表示可写（可以在目录内创建、删除、重命名目录），x表示可以进入该目录
rwx分别用数字表示，4，2，1。当拥有所有权限，则为7
- 最后面的数字，代表连接数（或者子目录数）
- 1213 文件大小（字节），如果是文件夹则显示4096
- 最后abc表示文件名，蓝色表示是目录

修改权限#

chmod 修改权限，u：所有者，g：所有组，o：其他人，a 所有（ugo总和）
chmod u=rwx,g=rw,o=x 文件/目录名这里等号表示直接给权限
chmod o+w 文件/目录名这里加表示+权限
chmod a-x 文件/目录名
chmod u=rwx,g=rx,o=rx abc 给文件添加执行权限（会变成绿色的）
使用数字
- 将abc.txt文件权限修改成rwxr-xr-x使用数字实现 chmod 755 abc

修改所有者和所在组#

chown tom abc #修改文件所有者为tom
chown -R tom abc #修改文件夹及其所有子目录所有者为tom
chgrp -R fruit kkk #修改文件夹所在组为fruit

权限管理应用实例#

警察和土匪的游戏

mysql高阶_sgg 96-00

2022年6月15日 21:13 周三

学习

Mysql高级篇-尚硅谷

章节概述#

架构篇
- 1-3
- 4
- 5
- 6
索引及调优篇
- 01
- 02-03
- 04-05
- 06
事务篇
- 01-02
- 03
- 04
日志与备份篇
- 01
- 02
- 03

CentOS环境准备#

这里主要是做了克隆，并没有讲到CentOS的安装，所以笔记不记录了

MySQL的卸载#

查找当前系统已经装了哪些 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

进行删除

rm -rf /usr/lib64/mysql
rm -rf /usr/share/mysql
rm -rf /etc/selinux/targeted/active/modules/100/mysql
rm -rf /etc/my.cnf

Linux下安装MySQL8.0与5.7版本#

版本介绍

算法红皮书 3.2.1

2022年6月12日 22:09 周日

学习

算法红皮书(第四版)

二叉查找树#

使用每个结点含有两个链接（链表中每个结点只含有一个链接）的二叉查找树来高效地实现符号表
该数据结构由结点组成，结点包含的链接可以为空(null)或者指向其他结点
一棵二叉查找树（BST）是一棵二叉树，其中每个结点都含有一个Comparable 的键（以及相关联的值）且每个结点的键都大于其左子树中的任意结点的键而小于右子树的任意结点的键。

基本实现#

数据表示
- 每个结点都含有一个键、一个值、一条左链接、一条右链接和一个结点计数器左链接指向一棵由小于该结点的所有键组成的二叉查找树，右链接指向一棵由大于该节点的所有键组成的二叉查找树，变量N给出了以该结点为根的子树的结点总数
- 对于任意节点总是成立 size(x)=size(x.left)+size(x.right)+1
多棵二叉查找树表示同一组有序的键来实现构建和使用二叉查找树的高校算法
查找
- 在符号表中查找一个键可能得到两种结果：如果含有该键的结点存在表中，我们的查找就命中了，然后返回值；否则查找未命中（返回null)
- 递归：如果树是空的，则查找未命中；如果被查找的键和根节点的键相等，查找命中，否则在适当的子树中查找：如果被查找的键较小就选择左子树，否则选择右子树
- 下面的get()方法，第一个参数是一个结点（子树根节点），第二个参数是被查找的键，代码会保证只有该结点所表示的子树才会含有和被查找的键相等的结点
- 从根结点开始，在每个结点中查找的进程都会递归地在它的一个子结点上展开，因此一次查找也就定义了树的一条路径。对于命中的查找，路径在含有被查找的键的结点处结束。对于未命中的查找，路径的终点是一个空链接

基于二叉查找树的符号表

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）
}

每个Node 对象都是一棵含有N 个结点的子树的根结点，它的左链接指向一棵由小于该结点的所有键组成的二叉查找树，右链接指向一棵由大于该结点的所有键组成的二叉查找树。root 变量指向二叉查找树的根结点Node 对象（这棵树包含了符号表中的所有键值对）

二叉查找树的查找和排序方法的实现

mybatis-plus-sgg-40-57

2022年6月4日 11:49 周六

学习

Mybatis-Plus 尚硅谷

LambdaXxxWrapper#

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日志打印

mybatis-plus-sgg-19-39

2022年6月3日 11:54 周五

学习

Mybatis-Plus 尚硅谷

通用Service应用#

这里会出现 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日志输出

mybatis-plus-sgg-12-18

2022年6月3日 08:15 周五

学习

Mybatis-Plus 尚硅谷

BaseMapper#

注：使用 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测试

mybatis-plus-sgg-01-11

2022年6月3日 06:47 周五

学习

Mybatis-Plus 尚硅谷

简介#

MyBatis-Plus是一个MyBatis的增强工具，在MyBatis的基础上只做增强不做改变，为简化开发、提高效率而生
这里以MySQL数据库为案例，以Idea作为IDE，使用Maven作为构建工具，使用SpringBoot完成各种功能
课程主要内容
特性润物无声、效率至上、丰富功能
支持的数据库
框架结构
- 左边：扫描实体，从实体抽取属性猜测数据库字段
- 通过默认提供的方法使用sql语句，然后注入mybatis容器

开发环境#

ly-20241212142150006

测试数据库和表#

这里创建数据库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');

Spring Boot工程#

添加依赖，并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启动类

算法红皮书 3.1.1-3.1.7

2022年5月31日 23:52 周二

学习

算法红皮书(第四版)

查找#

经典查找算法
用符号表这个词来描述抽象的表格，将信息（值）存储在其中，然后按照指定的键来获取这些信息
符号表也被称为字典
- 在英语字典里，键就是单词，值就是单词对应的定义、发音和词源
- 符号表有时又叫索引
- 在一本书的索引中，键就是术语，而值就是书中该术语出现的所有页码
下面学习三种经典的数据类型：二叉查找树、红黑树和散列表

符号表#

符号表最主要的目的是将键和值联系起来
用例能够将一个键值对插入符号表并希望在之后能够从符号表的所有键值对中按照键直接找到相对应的值
符号表是一种存储键值对的数据结构，支持两种操作：插入(put)，即将一组新的键值对存入表中；查找(get)，即根据给定的键得到相应的值
典型的符号表应用

API#

符号表是一种典型的数据类型 ：代表着一组定义清晰的值及相应的操作。使用应用程序编程接口（API）来精确地定义这些操作一种简单的泛型符号表API ST(Symbol Table)
泛型对于符号表，我们通过明确地指定查找时键和值的类型来区分它们的不同角色【key和value】
重复的键
- 这里假设每个键只对应着一个值（表中不允许重复值）
- 当用例代码向表中存入的键值对和表中已有的键（及关联的值）冲突时，新的值会替代旧的值
- 上述定义了关联数组的抽象形式，可以将符号表想象成数组，键即索引，值即数组中的值
- 在一个关联数组中，键可以是任意类型，但我们仍然可以用它来快速访问数组的值
- 非Java使用st[key]来替代st.get(key)，用st[key]=val来替代st.put(key,val)
键不能为空
值不能为空（因为规定当键不存在时get()返回空）当值为空表示删除
删除操作
- 延时删除，先将键对应的值置空，之后在某个时刻删除所有值为空的键
- 即时删除，立即从表中删除指定的键 put实现的开头：
```
if(val == null){
 delete(key);
 return;
}
```
- 便捷方法
- 迭代在API第一行加上implements Iterable<Key> ，所有实现都包含iterator()方法来实现hasNext()和next()方法的迭代器；这里采用另一种方式：定义keys返回一个Iterable<Key>对象以方便便利所有的键，且允许遍历一部分
- 键的等价性自定义的键需要重写equals()方法；且最好使用不可变数据类型作为键

有序符号表#

一种有序的泛型符号表的API
最大值和最小值、向下取整和向上取整、排名和选择
对于0到size()-1的所有i都有i==rank(select(i))，且所有的键都满足key == select(rank(key))
范围查找
例外情况当一个方法需要返回一个键但表中没有合适的键可以返回时，我们约定抛出一个异常
有序符号表中冗余有序性方法的默认实现
所有Comparable类型中compareTo()方法和equals()方法的一致性
★★成本模型在学习符号表的实现时，我们会统计比较的次数（等价性测试或是键的相互比较），在内循环**不进行比较（极少）**的情况下，我们会统计数组的访问次数

用例举例#

如何使用

行为测试用例简单的符号表测试用例