作者: chenyl

  • 被问懵了:MySQL 自增主键一定是连续的吗?

    测试环境:

    MySQL版本:8.0

    数据库表:T (主键id,唯一索引c,普通字段d)

    如果你的业务设计依赖于自增主键的连续性,这个设计假设自增主键是连续的。但实际上,这样的假设是错的,因为自增主键不能保证连续递增。

    一、自增值的属性特征:

    1. 自增主键值是存储在哪的?

    MySQL5.7版本

    在 MySQL 5.7 及之前的版本,自增值保存在内存里,并没有持久化。每次重启后,第一次打开表的时候,都会去找自增值的最大值 max(id),然后将 max(id)+1 作为这个表当前的自增值。

    MySQL8.0之后版本

    在 MySQL 8.0 版本,将自增值的变更记录在了 redo log 中,重启的时候依靠 redo log 恢复重启之前的值。

    可以通过看表详情查看当前自增值,以及查看表参数详情AUTO_INCREMENT值(AUTO_INCREMENT就是当前数据表的自增值)

    2. 自增主键值的修改机制?

    在表t中,我定义了主键id为自增值,在插入一行数据的时候,自增值的行为如下:

    1. 如果插入数据时 id 字段指定为 0、null 或未指定值,那么就把这个表当前的 AUTO_INCREMENT 值填到自增字段;
    2. 如果插入数据时 id 字段指定了具体的值,就直接使用语句里指定的值。

    根据要插入的值和当前自增值的大小关系,自增值的变更结果也会有所不同。假设,某次要插入的值是 X,当前的自增值是 Y。

    1. 如果 X
    2. 如果 X≥Y,就需要把当前自增值修改为新的自增值。

    二、新增语句自增主键是如何变化的:

    我们执行以下SQL语句,来观察自增主键是如何进行变化的

    insert into t values(null11); 
    

    流程图如下所示

    流程步骤:

    • AUTO_INCREMENT=1 (表示下一次插入数据时,如果需要自动生成自增值,会生成 id=1。)
    • insert into t values(null, 1, 1) (执行器调用 InnoDB 引擎接口写入一行,传入的这一行的值是 (0,1,1))
    • get AUTO_INCREMENT=1 (InnoDB 发现用户没有指定自增 id 的值,获取表 t 当前的自增值 1 )
    • AUTO_INCREMENT=2 insert into t values(1, 1, 1) (将传入的行的值改成 (1,1,1),并把自增值改为2)
    • insert (1,1,1) 执行插入操作,至此流程结束

    大家可以发现,在这个流程当中是先进行自增值的+1,在进行新增语句的执行的。大家可以发现这个操作并没有进行原子操作,如果SQL语句执行失败,那么自增是不是就不会连续了呢?

    三、自增主键值不连续情况:(唯一主键冲突)

    当我执行以下SQL语句时

    insert into t values(null11); 
    

    第一次我们可以进行新增成功,根据自增值的修改机制。如果插入数据时 id 字段指定为 0、null 或未指定值,那么就把这个表当前的 AUTO_INCREMENT 值填到自增字段;

    当我们第二次在执行以下SQL语句时,就会出现错误。因为我们表中c字段是唯一索引,会出现Duplicate key error错误导致新增失败。

    例如:

    • AUTO_INCREMENT=2 (表示下一次插入数据时,如果需要自动生成自增值,会生成 id=2。)
    • insert into t values(null, 1, 1) (执行器调用 InnoDB 引擎接口写入一行,传入的这一行的值是 (0,1,1))
    • get AUTO_INCREMENT=2 (InnoDB 发现用户没有指定自增 id 的值,获取表 t 当前的自增值 2 )
    • AUTO_INCREMENT=3 insert into t values(2, 1, 1) (将传入的行的值改成 (2,1,1),并把自增值改为3)
    • insert (2,1,1)  执行插入操作,由于已经存在 c=1 的记录,所以报 Duplicate key error,语句返回。

    可以看到,这个表的自增值改成 3,是在真正执行插入数据的操作之前。这个语句真正执行的时候,因为碰到唯一键 c 冲突,所以 id=2 这一行并没有插入成功,但也没有将自增值再改回去。所以,在这之后,再插入新的数据行时,拿到的自增 id 就是 3。也就是说,出现了自增主键不连续的情况。

    四、自增主键值不连续情况:(事务回滚)

    其实事务回滚原理也和上面一样,都是因为异常导致新增失败,但是自增值没有进行回退。

    五、自增主键值不连续情况:(批量插入)

    批量插入数据的语句,MySQL 有一个批量申请自增 id 的策略:

    1. 语句执行过程中,第一次申请自增 id,会分配 1 个;
    2. 1 个用完以后,这个语句第二次申请自增 id,会分配 2 个;
    3. 2 个用完以后,还是这个语句, 第三次申请自增 id,会分配 4 个;
    4. 依此类推,同一个语句去申请自增 id,每次申请到的自增 id 个数都是上一次的两倍。

    执行以下SQL语句(在表t中先新增了4条数据,在创建表tt把表t数据进行批量新增)

    insert into t values(null1,1);
    insert into t values(null2,2);
    insert into t values(null3,3);
    insert into t values(null4,4);
    create table tt like t;
    insert into tt(c,d) select c,d from t;
    
    insert into tt values(null5,5);
    

    第一次申请到了 id=1,第二次被分配了 id=2 和 id=3, 第三次被分配到 id=4 到 id=7。当我们再执行 insert into t2 values(null, 5,5),实际上插入的数据就是(8,5,5),出现了自增主键不连续的情况。

    六、自增主键值的优化

    1.什么是自增锁

    自增锁是一种比拟非凡的表级锁。并且在事务向蕴含了 AUTO_INCREMENT 列的表中新增数据时就会去持有自增锁,假如事务 A 正在做这个操作,如果另一个事务 B 尝试执行 INSERT语句,事务 B 会被阻塞住,直到事务 A 开释自增锁。

    2.自增锁有哪些优化

    在 MySQL 5.0 版本的时候,自增锁的范围是语句级别。也就是说,如果一个语句申请了一个表自增锁,这个锁会等语句执行结束以后才释放。显然,这样设计会影响并发度。在MySQL 5.1.22 版本引入了一个新策略,新增参数 innodb_autoinc_lock_mode,默认值是 1。

    传统模式(Traditional)

    这个参数的值被设置为 0 时,表示采用之前 MySQL 5.0 版本的策略,即语句执行结束后才释放锁;

    传统模式他可以保证数据一致性,但是如果有多个事务并发的执行 INSERT 操作,AUTO-INC的存在会使得 MySQL 的性能略有降落,因为同时只能执行一条 INSERT 语句。

    间断模式(Consecutive)

    这个参数的值被设置为 1 时:普通 insert 语句,自增锁在申请之后就马上释放;类似 insert … select 这样的批量插入数据的语句,自增锁还是要等语句结束后才被释放;

    间断模式他可以保证数据一致性,但是如果有多个事务并发的执行 INSERT 批量操作时,就会进行锁等待状态。如果我们业务插入数据量很大时,这个时候MySQL的性能就会大大下降。

    穿插模式(Interleaved)

    这个参数的值被设置为 2 时,所有的申请自增主键的动作都是申请后就释放锁。

    穿插模式他没有进行任何的上锁设置。在一定情况下是保证了MySQL的性能,但是他无法保证数据的一致性。如果我们在穿插模式下进行主从复制时,如果你的binlog格式不是row格式,主从复制就会出现不一致。

    七、MySQL8.0做了哪些优化

    在MySQL8.0之后版本,已经默认设置为 innodb_autoinc_lock_mode=2binlog_format=row.。这样更有利与我们在 insert … select 这种批量插入数据的场景时,既能提升并发性,又不会出现数据一致性问题。

    作者:又欠

    来源:blog.csdn.net/qq_48157004/article/

    details/128356734

  • 阿里为什么建议给MVC三层架构多加一层Manager层?

    我们在刚刚成为程序员的时候,就会被前辈们 “教育” 说系统的设计要遵循 MVC(Model-View-Controller)架构。它将整体的系统分成了 Model(模型),View(视图)和 Controller(控制器)三个层次,也就是将用户视图和业务处理隔离开,并且通过控制器连接起来,很好地实现了表现和逻辑的解耦,是一种标准的软件分层架构。

    MVC三层架构

    MVC分层架构是架构上最简单的一种分层方式。为了遵循这种分层架构我们在构建项目时往往会建立这样三个目录:controller、service 和 dao,它们分别对应了表现层、逻辑层还有数据访问层。关注公众号:码猿技术专栏,回复关键词:1111 获取阿里内部Java性能优化手册

    三层架构示意图

    每层的作用如下:

    • Controller层:主要是对访问控制进行转发,各类基本参数校验,或者不复用的业务简单处理。
    • Service层:主要是处理业务逻辑和事务
    • Dao层:负责与底层数据库MySQL,Oracle等进行数据交互

    可是随着我们的业务逻辑越来复杂,代码写的越来越多,这种简单的三层架构的问题也越来越明显。

    MVC架构弊端

    传统的MVC分层有以下几个很明显的问题:

    1. Service层代码臃肿
    2. Service层很容易出现大事务,事务嵌套,导致问题很多,而且极难排查
    3. dao层参杂业务逻辑
    4. dao层sql语句复杂,关联查询比较多

    为了解决这个问题,我们参考《alibaba java开发手册》,在Service层之下再独立出一个通用业务处理层(Manager层)

    Manager层

    在这个分层架构中主要增加了 Manager 层,它与 Service 层的关系是:Manager 层提供原子的服务接口,Service 层负责依据业务逻辑来编排原子接口。

    Manager层的特征

    在《alibaba java开发手册》中是这样描述Manager层的:

    Manager 层:通用业务处理层,它有如下特征:

    1. 对第三方平台封装的层,预处理返回结果及转化异常信息,适配上层接口;
    2. 对 Service 层通用能力的下沉,如缓存方案、中间件通用处理;
    3. 与 DAO 层交互,对多个 DAO 的组合复用。

    在实际开发中我们可以这样使用Manager层

    1. 复杂业务,service提供数据给Manager层,负责业务编排,然后把事务下沉到Manager层,Manager层不允许相互调用,不会出现事务嵌套。
    2. 专注于不带业务sql语言,也可以在manager层进行通用业务的dao层封装。
    3. 避免复杂的join查询,数据库压力比java大很多,所以要严格控制好sql,所以可以在manager层进行拆分,比如复杂查询。

    当然对于简单的业务,可以不使用Manager层。

    Manager层使用案例

    这里我们举个例子说明一下Manager层的使用场景:

    假设你有一个用户系统,他有一个获取用户信息的接口,它调用逻辑Service层的 getUser 方法,getUser方法又和 User DB 交互获取数据。如下图左边展示部分。

    这时,产品提出一个需求,在 APP 中展示用户信息的时候,如果用户不存在,那么要自动给用户创建一个用户。同时,要做一个 HTML5 的页面,HTML5 页面要保留之前的逻辑,也就是不需要创建用户。

    此时按照传统的三层架构,逻辑层的边界就变得不清晰,表现层也承担了一部分的业务逻辑,因为我们往往会在表现层Controller中增加业务逻辑处理,将获取用户和创建用户接口编排起来。

    而添加Manager层以后,Manager 层提供创建用户和获取用户信息的接口,而 Service 层负责将这两个接口组装起来。这样就把原先散布在表现层的业务逻辑都统一到了 Service 层,每一层的边界就非常清晰了。

    接下来我们看一段实际代码说明一下Service层与Manager层如何进行区分?

    @Transactional(rollbackFor = Throwable.class)
    public ResultStringupOrDown(Long departmentIdLong swapId) {
      // 验证 1
      DepartmentEntity departmentEntity = departmentDao.selectById(departmentId);
      if (departmentEntity == null) {
        return Result.error("部门xxx不存在");
      }
      // 验证 2
      DepartmentEntity swapEntity = departmentDao.selectById(swapId);
      if (swapEntity == null) {
        return Result.error("部门xxx不存在");
      }
      // 验证 3
      Long count = employeeDao.countByDepartmentId(departmentId);
      if (count != null && count > 0) {
        return Result.error("员工不存在");
      }
      // 操作数据库 4
      Long departmentSort = departmentEntity.getSort();
      departmentEntity.setSort(swapEntity.getSort());
      departmentDao.updateById(departmentEntity);
      swapEntity.setSort(departmentSort);
      departmentDao.updateById(swapEntity);
      return Result.OK("success");
    }
    

    上面代码在我们在我们采用三层架构时经常会遇到,那么它有什么问题呢?

    上面的代码是典型的长事务问题(类似的还有调用第三方接口),前三步都是使用 connection 进行验证操作,但是由于方法上有@Transactional 注解,所以这三个验证都是使用的同一个 connection。

    若对于复杂业务、复杂的验证逻辑,会导致整个验证过程始终占用该 connection 连接,占用时间可能会很长,直至方法结束,connection 才会交还给数据库连接池。

    对于复杂业务的不可预计的情况,长时间占用同一个 connection 连接不是好的事情,应该尽量缩短占用时间。

    说明:对于@Transactional 注解,当 spring 遇到该注解时,会自动从数据库连接池中获取 connection,并开启事务然后绑定到 ThreadLocal 上,如果业务并没有进入到最终的 操作数据库环节,那么就没有必要获取连接并开启事务,应该直接将 connection 返回给数据库连接池,供其他使用。

    所以我们在加入Manager层以后可以这样写:

    DepartmentService.java
      
    public Result upOrDown(Long departmentId, Long swapId) {
      // 验证 1
      DepartmentEntity departmentEntity = departmentDao.selectById(departmentId);
      if (departmentEntity == null) {
        return Result.error("部门xxx不存在");
      }
      // 验证 2
      DepartmentEntity swapEntity = departmentDao.selectById(swapId);
      if (swapEntity == null) {
        return Result.error("部门xxx不存在");
      }
      // 验证 3
      Long count = employeeDao.countByDepartmentId(departmentId);
      if (count != null && count > 0) {
        return Result.error("员工不存在");
      }
      
      // 操作数据库 4
      departmentManager.upOrDown(departmentSort,swapEntity);
    
      return Result.OK("success");
    }
    DepartmentManager.java
      
    @Transactional(rollbackFor = Throwable.class)
    public void upOrDown(DepartmentEntity departmentEntity ,DepartmentEntity swapEntity){
      Long departmentSort = departmentEntity.getSort();
      departmentEntity.setSort(swapEntity.getSort());
      departmentDao.updateById(departmentEntity);
      swapEntity.setSort(departmentSort);
      departmentDao.updateById(swapEntity);
    }
    

    将数据在 service 层准备好,然后传递给 manager 层,由 manager 层添加@Transactional事务注解进行数据库操作。

    好了,今天的文章就到这里了,看完对你有没有收获呢?欢迎留言评论!

    最后说一句(别白嫖,求关注)

    陈某每一篇文章都是精心输出,如果这篇文章对你有所帮助,或者有所启发的话,帮忙点赞在看转发收藏,你的支持就是我坚持下去的最大动力!

    另外陈某的知识星球开通了,公众号回复关键词:知识星球 获取限量30元优惠券加入只需89元,一顿饭钱,但是星球回馈的价值却是巨大,目前更新了Spring全家桶实战系列亿级数据分库分表实战DDD微服务实战专栏我要进大厂、Spring,Mybatis等框架源码、架构实战22讲等….每增加一个专栏价格将上涨20元

  • Spring Boot 开发环境热部署方案 !

    • 前言
    • 热部署常用实现方案
      • spring-boot-devtools
      • JRebel
    • 总结

    前言

    Spring Boot 提出了多项开箱即用的功能特性,但归根到底还是围绕简化应用的创建、开发、运行。开发环境下我们经常对项目代码进行变动,如果每次都重新启动应用会浪费我们大量时间,为此就产生了多种进行热部署的方案,可以在不重启的情况下使用新的代码。

    热部署常用实现方案

    然而,在 Java 中实现热部署并不是一件容易的事情。

    1. ClassLoader 重新加载

    Java 作为一种静态语言,类一经加载到 JVM 中,便无法修改,而且同一个类加载器对于同一个类只能加载一次,因此热部署常用的一种解决方案是创建新的 ClassLoader 加载新的 class 文件,然后替换之前创建的对象。

    2. Java Agent

    另一种解决方案是使用 Java AgentJava Agent 可以理解为 JVM 层面的 AOP,可以在类加载时将 class 文件的内容修改为自定义的内容,并且支持修改已加载到 JVM 的 class,不过对于已加载到 JVM 的 class 只能修改方法体,因此具有一定的局限性。

    spring-boot-devtools

    spring-boot-devtools 快速上手

    Spring Boot 通过 Maven 插件 spring-boot-devtools 提供对热部署的支持,只要将这个依赖添加到类路径,当类路径下的 class 发生变化时就会自动重启应用上下文,从而使用新的 class 文件中的代码。这个插件的坐标如下。

    
        org.springframework.boot
        spring-boot-devtools
        true
    
    

    引入依赖时指定 optional 避免依赖传递,同时 spring-boot-maven-plugin 打包时也会忽略 spring-boot-devtools 插件。

    spring-boot-devtools 功能特性

    spring-boot-devtools 作为一个开发环境的插件,不仅支持热部署,具体来说有以下特性。

    • 将第三方库(如 thymeleaf、freemarker)缓存相关的属性配置到 Environment,以便开发环境禁用缓存。
    • 类路径下的 class 文件发生变更时触发 ApplicationContext 重启。
    • 内嵌 LiveReload 服务器,资源发生变化时触发浏览器刷新。
    • 支持全局配置,所有的 Spring Boot 应用的 spring-boot-devtools 插件使用同一套配置,如指定检查 class 文件变化的轮训时间。
    • 支持远程触发热部署(不推荐使用)。

    spring-boot-devtools 实现原理

    虽然 spring-boot-devtools 支持添加配置用来修改自身行为,通常情况下我们使用默认配置即可,不再赘述配置相关内容。下面我们把重点放到 spring-boot-devtools 热部署的具体实现上。

    spring-boot-devtools 热部署使用了 ClassLoader 重新加载 的实现方式,具体来说使用两类 ClassLoader,一类是加载第三方库的 CladdLoader,另一类是加载应用类路径下 class 的自定义 RestartClassLoader,应用类路径下 class 变化会触发应用重新启动,由于不需要重新加载第三方库的 class,因此相比重新启动整个应用速度上会快一些。

    那具体到代码层面怎么实现的呢?spring-boot-devtools 利用 Spring Boot 应用自动装配的特性,在 spring.factories 文件中添加了很多配置。

    图片
    1. SpringApplication 启动时触发应用重启

    spring-boot-devtools 通过 RestartApplicationListener 监听 SpringApplication 的启动,监听到启动时关闭当前线程,并重启应用,重启时使用自定义的 RestartClassLoader 加载应用类路径下的 class。监听 Spring Boot 应用启动的核心代码如下。

    public class RestartApplicationListener implements ApplicationListener, Ordered {
    
     @Override
     public void onApplicationEvent(ApplicationEvent event) {
      if (event instanceof ApplicationStartingEvent) {
       onApplicationStartingEvent((ApplicationStartingEvent) event);
      }
      ... 省略部分代码
     }
     
     private void onApplicationStartingEvent(ApplicationStartingEvent event) {
      String enabled = System.getProperty(ENABLED_PROPERTY);
      if (enabled == null || Boolean.parseBoolean(enabled)) {
       String[] args = event.getArgs();
       DefaultRestartInitializer initializer = new DefaultRestartInitializer();
       boolean restartOnInitialize = !AgentReloader.isActive();
       // 初始化 Restarter
       Restarter.initialize(args, false, initializer, restartOnInitialize);
      } else {
       Restarter.disable();
      }
     }
    }
    

    RestartApplicationListener 监听到 SpringApplication 启动事件后开始对 Restarter 进行初始化,Restarter 是重启应用的核心类,Restarter 初始化过程仅仅实例化自身并调用其初始化方法,初始化的核心代码如下。

    public class Restarter {
    
     protected void initialize(boolean restartOnInitialize) {
      preInitializeLeakyClasses();
      if (this.initialUrls != null) {
       this.urls.addAll(Arrays.asList(this.initialUrls));
       if (restartOnInitialize) {
        this.logger.debug("Immediately restarting application");
        immediateRestart();
       }
      }
     }
    
     private void immediateRestart() {
      try {
       // 等待新线程执行结束
       getLeakSafeThread().callAndWait(() -> {
        start(FailureHandler.NONE);
        cleanupCaches();
        return null;
       });
      } catch (Exception ex) {
       this.logger.warn("Unable to initialize restarter", ex);
      }
      // 再通过抛出异常的方式退出主线程
      SilentExitExceptionHandler.exitCurrentThread();
     }
    
    }
    

    Restarter 首先收集类路径的 URL,然后立即调用 #immediateRestart 方法重启应用,待新线程重启应用后再通过抛出异常的方式关闭 main 线程。启动应用的核心代码如下。

    public class Restarter {
    
     private Throwable doStart() throws Exception {
      Assert.notNull(this.mainClassName, "Unable to find the main class to restart");
      URL[] urls = this.urls.toArray(new URL[0]);
      ClassLoaderFiles updatedFiles = new ClassLoaderFiles(this.classLoaderFiles);
      // 使用新的类加载器加载变化的类
      ClassLoader classLoader = new RestartClassLoader(this.applicationClassLoader, urls, updatedFiles, this.logger);
      if (this.logger.isDebugEnabled()) {
       this.logger.debug("Starting application " + this.mainClassName + " with URLs " + Arrays.asList(urls));
      }
      return relaunch(classLoader);
     }
     
    }
    

    Restarter 先根据类路径下 URL 收集文件系统中的 class 文件到 ClassLoaderFiles,然后使用新的类加载器 RestartClassLoader 对应用重启,剩下的就很简单了,直接调用 main 方法即可。

    2. 类路径 class 文件变化时触发应用重启

    除了首次应用启动时切换 ClassLoader 重启应用,对开发者而言,最重要的就是 class 文件发生变化时重启应用了。自动配置类位于 LocalDevToolsAutoConfiguration.RestartConfigurationspring-boot-devtools 提供了一个 ClassPathFileSystemWatcher bean 用于监听 class 文件的变化。

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnInitializedRestarter
    @EnableConfigurationProperties(DevToolsProperties.class)
    public class LocalDevToolsAutoConfiguration {
    
     @Lazy(false)
     @Configuration(proxyBeanMethods = false)
     @ConditionalOnProperty(prefix = "spring.devtools.restart", name = "enabled", matchIfMissing = true)
     static class RestartConfiguration {
     
      @Bean
      @ConditionalOnMissingBean
      ClassPathFileSystemWatcher classPathFileSystemWatcher(FileSystemWatcherFactory fileSystemWatcherFactory,
                     ClassPathRestartStrategy classPathRestartStrategy) {
       URL[] urls = Restarter.getInstance().getInitialUrls();
       ClassPathFileSystemWatcher watcher = new ClassPathFileSystemWatcher(fileSystemWatcherFactory,
         classPathRestartStrategy, urls);
       watcher.setStopWatcherOnRestart(true);
       return watcher;
      }
        }
    }
    

    ClassPathFileSystemWatcher 实现了 InitializingBean 接口,会在初始化时启动一个线程监听 class 文件的变化,然后发送一个 ClassPathChangedEvent 事件,因此 spring-boot-devtools 还提供了一个对应的监听器。

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnInitializedRestarter
    @EnableConfigurationProperties(DevToolsProperties.class)
    public class LocalDevToolsAutoConfiguration {
    
     @Lazy(false)
     @Configuration(proxyBeanMethods = false)
     @ConditionalOnProperty(prefix = "spring.devtools.restart", name = "enabled", matchIfMissing = true)
     static class RestartConfiguration {
     
      @Bean
      ApplicationListener restartingClassPathChangedEventListener(
        FileSystemWatcherFactory fileSystemWatcherFactory) {
       return (event) -> {
        if (event.isRestartRequired()) {
         // 类路径发生变化时重启应用上下文
         Restarter.getInstance().restart(new FileWatchingFailureHandler(fileSystemWatcherFactory));
        }
       };
      }
    }
    

    监听器监听到 class 文件变化后通过 Restarter 再次重启了应用,流程与首次重启时类似,不再赘述。

    JRebel

    除了 spring-boot-devtools,Spring 官方推荐的另一个热部署工具是 JRebel。JRebel 的核心是一个普通的 jar 包,内置了对多种框架的支持,通过 java -jar 启动时指定 -javaagent 即可使用 JRebel,而无需修改代码。同时 JRebel 也提供了多种的 IDE 插件,避免了手动启动指定 agent。

    JRebel 在 Idea 中的使用

    由于目前大家多使用 Idea 作为 IDE,因此这里介绍下 JRebel 在 Idea 中的使用。

    1. 下载

    首先在 Idea 的插件市场搜索 JRebel,并选择 JRebel and XRebel,然后 install,之后重启 IDE 使插件生效。

    图片
    2. 激活

    然后点击 Help->JRebel->Activation 进入激活页面。

    选择 Team URL,在 https://jrebel.qekang.com/ 网站可以查找 可用的 Team URL,然后输入任意邮箱即可激活。

    3. 项目支持配置

    选择 View->Tool Windows->JRebel 对项目进行配置。

    勾选项目名称右侧的第一个复选框即可快速开启 JRebel 对项目的支持。此时将在 resources 目录下生成一个 rebel.xml 文件,这个文件用于配置 JRebel 监听的类路径。

    4. 自动编译配置

    访问 Setting,在 Compiler 页面下勾选 Build project automatically 开启自动构建功能。

    访问 Setting 页面,在 System Settings 页面下勾选 Save file if the IDE is idle for

    图片
    5. 启动项目

    然后使用 JRebel 进行 debug 就可以啦,当代码变更触发 IDE 构建后,JRebel 会自动使用新的 class 代码。

    图片

    图片

    JRebel 实现原理

    虽然 JRebel 在 Idea 中的使用方式比较简单,但当我试图探究其实现方式时却发现并没有那么容易。网上的文章前篇一律介绍的是其使用方式,即便其官网也只是简简单单概述为:JRebel 主要在 ClassLoader 级别与 JVM 及应用集成。它不会创建新的 ClassLoader,当监测到 class 文件发生变化时通过扩展类加载器更新应用。

    从官网的描述来看,也并没有深入到具体的实现方式上,真是 听君一席话,如听一席话,由于 JRebel 并未开源,并且其提供的 .jar 文件也进行了代码混淆,因此这里只能对其实现方式进行推测,并逐步验证。这里将推测及分析过程分享给大家。

    推测:JRebel 通过 Java Agent 进行实现

    JRebel 核心为一个普通的 jar 包,并通过 -javaagent 指定这个 jar 包,因此可以猜测它使用到了 Java Agent 的某些特性。

    Java Agent 的主要作用为替换加载的 class,运行时修改方法体。由于 JRebel 支持在运行时添加、删除方法,因此 JRebel 必然不是通过运行时修改已加载到 JVM 的类路径下 class 方法体的方式来实现热部署的。那么大概率 JRebel 是修改了某些加载到 JVM 的 class。

    推测:JRebel 会在 class 文件发生变化后重新加载 class 文件

    推测 JRebel 使用了 Java Agent 之后,我们还是不能了解其主要实现方式,不过当我们的 class 文件发生变动后,JRebel 必然会重新加载变动后的 class 文件,以便执行新的代码,因此我们可以在 ClassLoader 加载类的某个流程上打上断点,以便查看堆栈信息。

    Spring Boot 项目的示例代码如下。

    @SpringBootApplication
    @RestController
    public class DemoApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DemoApplication.class, args);
        }
    
        @GetMapping("/hello")
        public String hello() {
            return "hallo";
        }
    
    }
    

    不过呢,由于我们误将 hello 拼成了 hallo,因此需要修改代码,改动后成功进入了我们的断点。

    图片

    JRebel 在 rebel-change-detector-thread 线程监测 class 文件的变动,文件变动后使用 AppClassLoader 加载了 com.zzuhkp.DemoApplication 开头的类,并且类名后还带了 $$M$_jr_ 开头的后缀。可以想到的是同一个 ClassLoader 只能加载一个类,因此 JRebel 对类名进行了修改。这也是官网所描述的,不创建新的 ClassLoader,当 class 发生变化时更新应用。

    问题:JRebel 如何替换新的 class 的?

    JRebel 加载新的 class 后必然会实例化,然后替换旧的对象,那么它是怎么实例化的呢?有多个构造方法时又该如何选择?

    修改我们的示例代码如下。

    @SpringBootApplication
    @RestController
    public class DemoApplication {
    
        private String str;
    
        public DemoApplication() {
            this.str = "你好";
        }
    
        public DemoApplication(String str) {
            this.str = "你好呀";
        }
    
        public static void main(String[] args) {
            SpringApplication.run(DemoApplication.class, args);
        }
    
        @GetMapping("/hello")
        public String hello() {
            return str;
        }
    }
    

    这里添加了一个成员变量和两个构造方法,访问 /hello 接口,发现返回 你好 二字,可以看出 JRebel 会自动使用无参的构造方法实例化对象。

    那么 JRebel 又是怎么替换旧对象的呢?我们知道,对于注解驱动的 Spring MVC,Controller 方法会被当做一个 handler 处理请求,如果新添加一个 Controller 方法,那么它必然被注册为 handler 才能处理请求。我们添加一个 hello2 的方法,并在注册 handler 的流程上打断点。

    @GetMapping("/hello2")
    public String hello2() {
        return str;
    }
    

    当访问 /hello2 果然进入了断点。

    图片

    从堆栈信息来看,多出了 JRebel 的相关类,可以断定,JRebel 对 Spring 的某些 class 做出了修改,当 class 发生变动后,JRebel 自动使用新的 class 实例化的对象注册到 Spring 内部。

    JRebel 小结

    从上述推测和验证的过程来看,JRebel 对热部署的支持利用 Java Agent 修改了 Spring 的某些 class,当应用的 class 发生变化时,JRebel 自动加载新的 class 文件,并利用 Spring 的API 替换 Spring 中的旧对象,从而支持了 Spring 的热部署。

    总结

    由于 spring-boot-devtools 会引入新的依赖,并且 class 文件变更会引起应用重启,而 JRebel 只会加载变动的 class 并利用 Spring 的 API 替换新的对象,因此 JRebel 比 spring-boot-devtools 会快上不少,相对来说比较个人比较支持使用 JRebel。

  • 如何设计一个 70w 在线人数的弹幕系统 ?

    来源:www.cyningsun.com/03-31-2019/live-streaming-danmaku.html

    • 背景
    • 问题分析
    • 带宽优化
    • 弹幕卡顿、丢失分析
    • 可靠与性能
    • 总结

    背景

    为了更好的支持东南亚直播业务,产品设计为直播业务增加了弹幕。第一期弹幕使用腾讯云支持,效果并不理想,经常出现卡顿、弹幕偏少等问题。最终促使我们开发自己的弹幕系统。性能要求是需要支持,单房间百万用户同时在线。

    问题分析

    按照背景来分析,系统将主要面临以下问题:

    1. 带宽压力

      假如说每3秒促达用户一次,那么每次内容至少需要有15条才能做到视觉无卡顿。15条弹幕+http包头的大小将超过3k,那么每秒的数据大小约为8Gbps,而运维同学通知我们所有服务的可用带宽仅为10Gbps。

    2. 弱网导致的弹幕卡顿、丢失

      该问题已在线上环境

    3. 性能与可靠性

      百万用户同时在线,按照上文的推算,具体QPS将超过30w QPS。如何保证在双十一等重要活动中不出问题,至关重要。性能也是另外一个需要着重考虑的点。

    带宽优化

    为了降低带宽压力,我们主要采用了以下方案:

    1. 启用Http压缩

      通过查阅资料,http gzip压缩比率可以达到40%以上(gzip比deflate要高出4%~5%)。

    2. Response结构简化

    3. 内容排列顺序优化

      根据gzip的压缩的压缩原理可以知道,重复度越高,压缩比越高,因此可以将字符串和数字内容放在一起摆放

    4. 频率控制

    • 带宽控制:通过添加请求间隔参数(下次请求时间),保证客户端的请求频率服务端可控。以应对突发的流量增长问题,提供有损的服务。
    • 稀疏控制:在弹幕稀疏和空洞的时间段,通过控制下次请求时间,避免客户端的无效请求。

    弹幕卡顿、丢失分析

    在开发弹幕系统的的时候,最常见的问题是该怎么选择促达机制,推送 vs 拉取 ?

    Long Polling via AJAX

    客户端打开一个到服务器端的 AJAX 请求,然后等待响应,服务器端需要一些特定的功能来允许请求被挂起,只要一有事件发生,服务器端就会在挂起的请求中送回响应。如果打开Http的Keepalived开关,还可以节约握手的时间。

    图片

    优点: 减少轮询次数,低延迟,浏览器兼容性较好。缺点: 服务器需要保持大量连接。

    WebSockets

    长轮询虽然省去了大量无效请求,减少了服务器压力和一定的网络带宽的占用,但是还是需要保持大量的连接。那么人们就在考虑了,有没有这样一个完美的方案,即能双向通信,又可以节约请求的 header 网络开销,并且有更强的扩展性,最好还可以支持二进制帧,压缩等特性呢?于是人们就发明了这样一个目前看似“完美”的解决方案 —— WebSocket。它的最大特点就是,服务器可以主动向客户端推送信息,客户端也可以主动向服务器发送信息,是真正的双向平等对话。

    图片

    优点:较少的控制开销,在连接创建后,服务器和客户端之间交换数据时,用于协议控制的数据包头部相对较小。在不包含扩展的情况下,对于服务器到客户端的内容,此头部大小只有2至10字节(和数据包长度有关);对于客户端到服务器的内容,此头部还需要加上额外的4字节的掩码。相对于 HTTP 请求每次都要携带完整的头部,此项开销显著减少了。更强的实时性,由于协议是全双工的,所以服务器可以随时主动给客户端下发数据。相对于HTTP请求需要等待客户端发起请求服务端才能响应,延迟明显更少;即使是和Comet等类似的长轮询比较,其也能在短时间内更多次地传递数据。长连接,保持连接状态。

    Long Polling vs Websockets

    无论是以上哪种方式,都使用到TCP长连接,那么TCP的长连接是如何发现连接已经断开了呢?

    TCP Keepalived会进行连接状态探测,探测间隔主要由三个配置控制。

    keepalive_probes:探测次数(默认:7次)

    keepalive_time 探测的超时(默认:2小时)

    keepalive_intvl 探测间隔(默认:75s)

    但是由于在东南亚的弱网情况下,TCP长连接会经常性的断开:

    Long Polling 能发现连接异常的最短间隔为:min(keepalive_intvl, polling_interval)

    Websockets能发现连接异常的最短间隔为:Websockets: min(keepalive_intvl, client_sending_interval)

    如果下次发送数据包的时候可能连接已经断开了,所以使用TCP长连接对于两者均意义不大。并且弱网情况下Websockets其实已经不能作为一个候选项了

    • 即使Websockets服务端已经发现连接断开,仍然没有办法推送数据,只能被动等待客户端重新建立好连接才能推送,在此之前数据将可能会被采取丢弃的措施处理掉。
    • 在每次断开后均需要再次发送应用层的协议进行连接建立。

    根据了解腾讯云的弹幕系统,在300人以下使用的是推送模式,300人以上则是采用的轮训模式。但是考虑到资源消耗情况,他们可能使用的是Websocket来实现的弹幕系统,所以才会出现弹幕卡顿、丢失的情况。综上所述,Long Polling和Websockets都不适用我们面临的环境,所以我们最终采取了短轮训 的方案来实现弹幕促达

    图片

    可靠与性能

    为了保证服务的稳定性我们对服务进行了拆分,将复杂的逻辑收拢到发送弹幕的一端。同时,将逻辑较为复杂、调用较少的发送弹幕业务与逻辑简单、调用量高的弹幕拉取服务拆分开来。服务拆分主要考虑因素是为了不让服务间相互影响,对于这种系统服务,不同服务的QPS往往是不对等的,例如像拉取弹幕的服务的请求频率和负载通常会比发送弹幕服务高1到2个数量级,在这种情况下不能让拉弹幕服务把发弹幕服务搞垮,反之亦然,最⼤度地保证系统的可用性,同时也更更加方便对各个服务做Scale-Up和Scale-Out。服务拆分也划清了业务边界,方便协同开发。

    在拉取弹幕服务的一端 ,引入了本地缓存。数据更新的策略是服务会定期发起RPC调⽤从弹幕服务拉取数据,拉取到的弹幕缓存到内存中,这样后续的请求过来时便能直接⾛走本地内存的读取,⼤大幅降低了调用时延。这样做还有另外一个好处就是缩短调⽤链路,把数据放到离⽤户最近的地⽅,同时还能降低外部依赖的服务故障对业务的影响,

    图片

    为了数据拉取方便,我们将数据按照时间进行分片,将时间作为数据切割的单位,按照时间存储、拉取、缓存数据(RingBuffer),简化了数据处理流程。与传统的Ring Buffer不一样的是,我们只保留了尾指针,它随着时间向前移动,每⼀秒向前移动一格,把时间戳和对应弹幕列表并写到一个区块当中,因此最多保留60秒的数据。同时,如果此时来了一个读请求,那么缓冲环会根据客户端传入的时间戳计算出指针的索引位置,并从尾指针的副本区域往回遍历直至跟索引重叠,收集到一定数量的弹幕列表返回,这种机制保证了缓冲区的区块是整体有序的,因此在读取的时候只需要简单地遍历一遍即可,加上使用的是数组作为存储结构,带来的读效率是相当高的。

    再来考虑可能出现数据竞争的情况。先来说写操作,由于在这个场景下,写操作是单线程的,因此⼤可不必关心并发写带来的数据一致性问题。再来说读操作,由图可知写的方向是从尾指针以顺时针⽅向移动,⽽读⽅向是从尾指针以逆时针方向移动,⽽决定读和写的位置是否出现重叠取决于index的位置,由于我们保证了读操作最多只能读到30秒内的数据,因此缓冲环完全可以做到无锁读写

    在发送弹幕的一端 ,因为用户一定时间能看得过来弹幕总量是有限的,所以可以对弹幕进行限流,有选择的丢弃多余的弹幕。同时,采用柔性的处理方式,拉取用户头像、敏感词过滤等分支在调用失败的情况下,仍然能保证服务的核心流程不受影响,即弹幕能够正常发送和接收,提供有损的服务。

    总结

    图片

    最终该服务在双十二活动中,在Redis出现短暂故障的背景下,高效且稳定的支撑了70w用户在线,成功完成了既定的目标。

  • 2万字系统总结,帮你实现 Linux 命令自由

    前言

    Linux 的学习对于一个程序员的重要性是不言而喻的。前端开发相比后端开发,接触 Linux 机会相对较少,因此往往容易忽视它。但是学好它却是程序员必备修养之一。

    如果本文对你有所帮助,请点个👍 吧。

    作者使用的是阿里云服务器 ECS (最便宜的那种) CentOS 7.7 64位。当然你也可以在自己的电脑安装虚拟机,虚拟机中再去安装 CentOS 系统(这就完全免费了)。至于它的安装教程可以去谷歌搜索下,相关教程非常多。

    Linux 基础

    操作系统

    操作系统 Operating System 简称 OS ,是软件的一部分,它是硬件基础上的第一层软件,是硬件和其它软件沟通的桥梁。

    操作系统会控制其他程序运行,管理系统资源,提供最基本的计算功能,如管理及配置内存、决定系统资源供需的优先次序等,同时还提供一些基本的服务程序。

    image.png

    什么是 Linux

    Linux 系统内核与 Linux 发行套件的区别

    • Linux 系统内核指的是由 Linus Torvalds 负责维护,提供硬件抽象层、硬盘及文件系统控制及多任务功能的系统核心程序。

    • Linux 发行套件系统是我们常说的 Linux 操作系统,也即是由 Linux 内核与各种常用软件的集合产品。

    「总结:真正的 Linux 指的是系统内核,而我们常说的 Linux 指的是“发行版完整的包含一些基础软件的操作系统”。」

    Linux 对比 Windows

    1. 稳定且有效率;
    2. 免费(或少许费用);
    3. 漏洞少且快速修补;
    4. 多任务多用户;
    5. 更加安全的用户与文件权限策略;
    6. 适合小内核程序的嵌入系统;
    7. 相对不耗资源。

    Linux 系统种类

    • 「红帽企业版 Linux:」 RHEL 是全世界内使用最广泛的 Linux 系统。它具有极强的性能与稳定性,是众多生成环境中使用的(收费的)系统。

    • 「Fedora:」 由红帽公司发布的桌面版系统套件,用户可以免费体验到最新的技术或工具,这些技术或工具在成熟后会被加入到 RHEL 系统中,因此 Fedora 也成为 RHEL 系统的试验版本。

    • 「CentOS:」 通过把 RHEL 系统重新编译并发布给用户免费使用的 Linux 系统,具有广泛的使用人群。

    • 「Deepin:」 中国发行,对优秀的开源成品进行集成和配置。

    • 「Debian:」 稳定性、安全性强,提供了免费的基础支持,在国外拥有很高的认可度和使用率。

    • 「Ubuntu:」 是一款派生自 Debian 的操作系统,对新款硬件具有极强的兼容能力。 Ubuntu 与 Fedora 都是极其出色的 Linux 桌面系统,而且 Ubuntu 也可用于服务器领域。

    终端连接阿里云服务器

    通过执行 ssh root@121.42.11.34 命令,然后输入服务器连接密码就可以顺利登陆远程服务器。从现在开始我们就可以在本地电脑操作远程服务器。

    1. 这个黑色的面板就是终端也就是 Shell (命令行环境)。

    2. ssh root@xxx 这是一条命令,必须要在 Shell 中才能执行。

    Shell

    Shell 这个单词的原意是“外壳”,跟 kernel(内核)相对应,比喻内核外面的一层,即用户跟内核交互的对话界面。

    • Shell 是一个程序,提供一个与用户对话的环境。这个环境只有一个命令提示符,让用户从键盘输入命令,所以又称为命令行环境( command line interface ,简写为 CLI )。 Shell 接收到用户输入的命令,将命令送入操作系统执行,并将结果返回给用户。

    • Shell 是一个命令解释器,解释用户输入的命令。它支持变量、条件判断、循环操作等语法,所以用户可以用 Shell 命令写出各种小程序,又称为 Shell 脚本。这些脚本都通过 Shell 的解释执行,而不通过编译。

    • Shell 是一个工具箱,提供了各种小工具,供用户方便地使用操作系统的功能。

    Shell 的种类

    Shell 有很多种,只要能给用户提供命令行环境的程序,都可以看作是 Shell 。

    历史上,主要的 Shell  有下面这些:

    • Bourne Shell(sh)
    • Bourne Again shell(bash)
    • C Shell(csh)
    • TENEX C Shell(tcsh)
    • Korn shell(ksh)
    • Z Shell(zsh)
    • Friendly Interactive Shell(fish)

    其中 Bash 是目前最常用的 Shell 。 MacOS 中的默认 Shell  就是 Bash 。

    通过执行 echo $SHELL 命令可以查看到当前正在使用的 Shell 。还可以通过 cat /etc/shells 查看当前系统安装的所有 Shell  种类。

    命令

    命令行提示符

    进入命令行环境以后,用户会看到 Shell 的提示符。提示符往往是一串前缀,最后以一个美元符号 $ 结尾,用户可以在这个符号后面输入各种命令。

    执行一个简单的命令 pwd :

    [root@iZm5e8dsxce9ufaic7hi3uZ ~]# pwd
    /root
    

    命令解析:

    • root:表示用户名;
    • iZm5e8dsxce9ufaic7hi3uZ:表示主机名;
    • ~:表示目前所在目录为家目录,其中 root 用户的家目录是 /root 普通用户的家目录在 /home 下;
    • #:指示你所具有的权限( root 用户为 # ,普通用户为 $ )。
    • 执行 whoami 命令可以查看当前用户名;
    • 执行 hostname 命令可以查看当前主机名;

    关于如何创建、切换、删除用户,在后面的用户与权限会具体讲解,这里先使用 root 用户进行演示。

    [备注] root  是超级用户,具备操作系统的一切权限。

    命令格式

    command parameters(命令 参数)
    

    长短参数

    • 「单个参数」:ls -a(a 是英文 all 的缩写,表示“全部”)
    • 「多个参数」:ls -al(全部文件 + 列表形式展示)
    • 「单个长参数」:ls –all
    • 「多个长参数」:ls –reverse –all
    • 「长短混合参数」:ls –all -l

    参数值

    • 「短参数」:command -p 10(例如:ssh root@121.42.11.34 -p 22)
    • 「长参数」:command –paramters=10(例如:ssh root@121.42.11.34 –port=22)

    快捷方式

    在开始学习 Linux 命令之前,有这么一些快捷方式,是必须要提前掌握的,它将贯穿整个 Linux 使用生涯。

    • 通过上下方向键 ↑ ↓ 来调取过往执行过的 Linux 命令;
    • 命令或参数仅需输入前几位就可以用 Tab 键补全;
    • Ctrl + R :用于查找使用过的命令(history 命令用于列出之前使用过的所有命令,然后输入 ! 命令加上编号( !2 )就可以直接执行该历史命令);
    • Ctrl + L:清除屏幕并将当前行移到页面顶部;
    • Ctrl + C:中止当前正在执行的命令;
    • Ctrl + U:从光标位置剪切到行首;
    • Ctrl + K:从光标位置剪切到行尾;
    • Ctrl + W:剪切光标左侧的一个单词;
    • Ctrl + Y:粘贴 Ctrl + U | K | Y 剪切的命令;
    • Ctrl + A:光标跳到命令行的开头;
    • Ctrl + E:光标跳到命令行的结尾;
    • Ctrl + D:关闭 Shell 会话;

    文件和目录

    文件的组织

    查看路径

    pwd

    显示当前目录的路径

    which

    查看命令的可执行文件所在路径, Linux 下,每一条命令其实都对应一个可执行程序,在终端中输入命令,按回车的时候,就是执行了对应的那个程序, which 命令本身对应的程序也存在于 Linux 中。

    总的来说一个命令就是一个可执行程序。

    浏览和切换目录

    ls

    列出文件和目录,它是 Linux 最常用的命令之一。

    【常用参数】

    • -a 显示所有文件和目录包括隐藏的
    • -l 显示详细列表
    • -h 适合人类阅读的
    • -t 按文件最近一次修改时间排序
    • -i 显示文件的 inode ( inode 是文件内容的标识)

    cd

    cd 是英语 change directory 的缩写,表示切换目录。

    cd / --> 跳转到根目录
    cd ~ --> 跳转到家目录
    cd .. --> 跳转到上级目录
    cd ./home --> 跳转到当前目录的home目录下
    cd /home/lion --> 跳转到根目录下的home目录下的lion目录
    cd --> 不添加任何参数,也是回到家目录
    

    [注意] 输入cd /ho + 单次 tab 键会自动补全路径 + 两次 tab 键会列出所有可能的目录列表。

    du

    列举目录大小信息。

    【常用参数】

    • -h 适合人类阅读的;
    • -a 同时列举出目录下文件的大小信息;
    • -s 只显示总计大小,不显示具体信息。

    浏览和创建文件

    cat

    一次性显示文件所有内容,更适合查看小的文件。

    cat cloud-init.log
    

    【常用参数】

    • -n 显示行号。

    less

    分页显示文件内容,更适合查看大的文件。

    less cloud-init.log
    

    【快捷操作】

    • 空格键:前进一页(一个屏幕);
    • b 键:后退一页;
    • 回车键:前进一行;
    • y 键:后退一行;
    • 上下键:回退或前进一行;
    • d 键:前进半页;
    • u 键:后退半页;
    • q 键:停止读取文件,中止 less 命令;
    • = 键:显示当前页面的内容是文件中的第几行到第几行以及一些其它关于本页内容的详细信息;
    • h 键:显示帮助文档;
    • / 键:进入搜索模式后,按 n 键跳到一个符合项目,按 N 键跳到上一个符合项目,同时也可以输入正则表达式匹配。

    head

    显示文件的开头几行(默认是10行)

    head cloud-init.log
    

    【参数】

    • -n 指定行数 head cloud-init.log -n 2

    tail

    显示文件的结尾几行(默认是10行)

    tail cloud-init.log
    

    【参数】

    • -n 指定行数 tail cloud-init.log -n 2
    • -f 会每过1秒检查下文件是否有更新内容,也可以用 -s 参数指定间隔时间 tail -f -s 4 xxx.log

    touch

    创建一个文件

    touch new_file
    

    mkdir

    创建一个目录

    mkdir new_folder
    

    【常用参数】

    • -p 递归的创建目录结构 mkdir -p one/two/three

    文件的复制和移动

    cp

    拷贝文件和目录

    cp file file_copy --> file 是目标文件,file_copy 是拷贝出来的文件
    cp file one --> 把 file 文件拷贝到 one 目录下,并且文件名依然为 file
    cp file one/file_copy --> 把 file 文件拷贝到 one 目录下,文件名为file_copy
    cp *.txt folder --> 把当前目录下所有 txt 文件拷贝到 folder 目录下
    

    【常用参数】

    • -r 递归的拷贝,常用来拷贝一整个目录

    mv

    移动(重命名)文件或目录,与cp命令用法相似。

    mv file one --> 将 file 文件移动到 one 目录下
    mv new_folder one --> 将 new_folder 文件夹移动到one目录下
    mv *.txt folder --> 把当前目录下所有 txt 文件移动到 folder 目录下
    mv file new_file --> file 文件重命名为 new_file
    

    文件的删除和链接

    rm

    删除文件和目录,由于 Linux 下没有回收站,一旦删除非常难恢复,因此需要谨慎操作

    rm new_file  --> 删除 new_file 文件
    rm f1 f2 f3  --> 同时删除 f1 f2 f3 3个文件
    

    【常用参数】

    • -i 向用户确认是否删除;
    • -f 文件强制删除;
    • -r 递归删除文件夹,著名的删除操作 rm -rf 。

    ln

    英文 Link 的缩写,表示创建链接。

    学习创建链接之前,首先要理解链接是什么,我们先来看看 Linux 的文件是如何存储的:

    Linux  文件的存储方式分为3个部分,文件名、文件内容以及权限,其中文件名的列表是存储在硬盘的其它地方和文件内容是分开存放的,每个文件名通过 inode 标识绑定到文件内容。

    Linux 下有两种链接类型:硬链接和软链接。

    硬链接

    使链接的两个文件共享同样文件内容,就是同样的 inode ,一旦文件1和文件2之间有了硬链接,那么修改任何一个文件,修改的都是同一块内容,它的缺点是,只能创建指向文件的硬链接,不能创建指向目录的(其实也可以,但比较复杂)而软链接都可以,因此软链接使用更加广泛。

    ln file1 file2  --> 创建 file2 为 file1 的硬链接
    

    如果我们用 rm file1 来删除 file1 ,对 file2 没有什么影响,对于硬链接来说,删除任意一方的文件,共同指向的文件内容并不会从硬盘上删除。只有同时删除了 file1 与 file2 后,它们共同指向的文件内容才会消失。

    软链接

    软链接就类似 windows 下快捷方式。

    ln -s file1 file2
    

    执行 ls -l 命名查看当前目录下文件的具体信息

    total 0
    -rw-r--r-- 1 root root 0 Jan 14 06:29 file1
    lrwxrwxrwx 1 root root 5 Jan 14 06:42 file2 -> file1  # 表示file2 指向 file1
    

    其实 file2 只是 file1 的一个快捷方式,它指向的是 file1 ,所以显示的是 file1 的内容,但其实 file2 的 inode  与 file1 并不相同。如果我们删除了 file2 的话, file1 是不会受影响的,但如果删除 file1 的话, file2 就会变成死链接,因为指向的文件不见了。

    用户与权限

    用户

    Linux 是一个多用户的操作系统。在 Linux 中,理论上来说,我们可以创建无数个用户,但是这些用户是被划分到不同的群组里面的,有一个用户,名叫 root ,是一个很特殊的用户,它是超级用户,拥有最高权限。

    自己创建的用户是有限权限的用户,这样大大提高了 Linux 系统的安全性,有效防止误操作或是病毒攻击,但是我们执行的某些命令需要更高权限时可以使用 sudo 命令。

    sudo

    root 身份运行命令

    sudo date  --> 当然查看日期是不需要sudo的这里只是演示,sudo 完之后一般还需要输入用户密码的
    

    useradd + passwd

    • useradd 添加新用户
    • passwd  修改用户密码

    这两个命令需要 root 用户权限

    useradd lion --> 添加一个lion用户,添加完之后在 /home 路径下可以查看
    passwd lion --> 修改lion用户的密码
    

    userdel

    删除用户,需要 root 用户权限

    userdel lion --> 只会删除用户名,不会从/home中删除对应文件夹
    userdel lion -r --> 会同时删除/home下的对应文件夹
    

    su

    切换用户,需要 root 用户权限

    sudo su --> 切换为root用户(exit 命令或 CTRL + D 快捷键都可以使普通用户切换为 root 用户)
    su lion --> 切换为普通用户
    su - --> 切换为root用户
    

    群组的管理

    Linux 中每个用户都属于一个特定的群组,如果你不设置用户的群组,默认会创建一个和它的用户名一样的群组,并且把用户划归到这个群组。

    groupadd

    创建群组,用法和 useradd 类似。

    groupadd friends
    

    groupdel

    删除一个已存在的群组

    groupdel foo  --> 删除foo群组
    

    groups

    查看用户所在群组

    groups lion  --> 查看 lion 用户所在的群组
    

    usermod

    用于修改用户的账户。

    【常用参数】

    • -l 对用户重命名。需要注意的是 /home 中的用户家目录的名字不会改变,需要手动修改。
    • -g 修改用户所在的群组,例如 usermod -g friends lion 修改 lion 用户的群组为 friends 。
    • -G 一次性让用户添加多个群组,例如 usermod -G friends,foo,bar lion
    • -a -G 会让你离开原先的群组,如果你不想这样做的话,就得再添加 -a 参数,意味着 append 追加的意思。

    chgrp

    用于修改文件的群组。

    chgrp bar file.txt --> file.txt文件的群组修改为bar
    

    chown

    改变文件的所有者,需要 root 身份才能运行。

    chown lion file.txt --> 把其它用户创建的file.txt转让给lion用户
    chown lion:bar file.txt --> 把file.txt的用户改为lion,群组改为bar
    

    【常用参数】

    • -R 递归设置子目录和子文件, chown -R lion:lion /home/frankfrank 文件夹的用户和群组都改为 lion 。

    文件权限管理

    chmod

    修改访问权限。

    chmod 740 file.txt
    

    【常用参数】

    • -R 可以递归地修改文件访问权限,例如 chmod -R 777 /home/lion

    修改权限的确简单,但是理解其深层次的意义才是更加重要的。下面我们来系统的学习 Linux 的文件权限。

    [root@lion ~]# ls -l
    drwxr-xr-x 5 root root 4096 Apr 13  2020 climb
    lrwxrwxrwx 1 root root    7 Jan 14 06:41 hello2.c -> hello.c
    -rw-r--r-- 1 root root  149 Jan 13 06:14 hello.c
    

    其中 drwxr-xr-x 表示文件或目录的权限。让我们一起来解读它具体代表什么?

    • d :表示目录,就是说这是一个目录,普通文件是 - ,链接是 l
    • r : read 表示文件可读。
    • w : write 表示文件可写,一般有写的权限,就有删除的权限。
    • x : execute 表示文件可执行。
    • - :表示没有相应权限。

    权限的整体是按用户来划分的,如下图所示:

    现在再来理解这句权限 drwxr-xr-x 的意思:

    • 它是一个文件夹;
    • 它的所有者具有:读、写、执行权限;
    • 它的群组用户具有:读、执行的权限,没有写的权限;
    • 它的其它用户具有:读、执行的权限,没有写的权限。

    现在理解了权限,我们使用 chmod 来尝试修改权限。 chmod 它不需要是 root 用户才能运行的,只要你是此文件所有者,就可以用 chmod 来修改文件的访问权限。

    数字分配权限

    因此要改变权限,只要做一些简单的加法就行:

    chmod 640 hello.c 
    
    # 分析
    6 = 4 + 2 + 0 表示所有者具有 rw 权限
    4 = 4 + 0 + 0 表示群组用户具有 r 权限
    0 = 0 + 0 + 0 表示其它用户没有权限
    
    对应文字权限为:-rw-r-----
    
    用字母来分配权限
    • u : user 的缩写,用户的意思,表示所有者。
    • g : group 的缩写,群组的意思,表示群组用户。
    • o : other 的缩写,其它的意思,表示其它用户。
    • a : all 的缩写,所有的意思,表示所有用户。
    • + :加号,表示添加权限。
    • - :减号,表示去除权限。
    • = :等于号,表示分配权限。
    chmod u+rx file --> 文件file的所有者增加读和运行的权限
    chmod g+r file --> 文件file的群组用户增加读的权限
    chmod o-r file --> 文件file的其它用户移除读的权限
    chmod g+r o-r file --> 文件file的群组用户增加读的权限,其它用户移除读的权限
    chmod go-r file --> 文件file的群组和其他用户移除读的权限
    chmod +x file --> 文件file的所有用户增加运行的权限
    chmod u=rwx,g=r,o=- file --> 文件file的所有者分配读写和执行的权限,群组其它用户分配读的权限,其他用户没有任何权限
    

    查找文件

    locate

    搜索包含关键字的所有文件和目录。后接需要查找的文件名,也可以用正则表达式。

    安装 locate

    yum -y install mlocate --> 安装包
    updatedb --> 更新数据库
    
    locate file.txt
    locate fil*.txt
    

    [注意] locate 命令会去文件数据库中查找命令,而不是全磁盘查找,因此刚创建的文件并不会更新到数据库中,所以无法被查找到,可以执行 updatedb 命令去更新数据库。

    find

    用于查找文件,它会去遍历你的实际硬盘进行查找,而且它允许我们对每个找到的文件进行后续操作,功能非常强大。

    find   
    
    • 「何处」:指定在哪个目录查找,此目录的所有子目录也会被查找。
    • 「何物」:查找什么,可以根据文件的名字来查找,也可以根据其大小来查找,还可以根据其最近访问时间来查找。
    • 「做什么」:找到文件后,可以进行后续处理,如果不指定这个参数, find 命令只会显示找到的文件。

    根据文件名查找

    find -name "file.txt" --> 当前目录以及子目录下通过名称查找文件
    find . -name "syslog" --> 当前目录以及子目录下通过名称查找文件
    find / -name "syslog" --> 整个硬盘下查找syslog
    find /var/log -name "syslog" --> 在指定的目录/var/log下查找syslog文件
    find /var/log -name "syslog*" --> 查找syslog1、syslog2 ... 等文件,通配符表示所有
    find /var/log -name "*syslog*" --> 查找包含syslog的文件 
    

    [注意] find 命令只会查找完全符合 “何物” 字符串的文件,而 locate 会查找所有包含关键字的文件。

    根据文件大小查找

    find /var -size +10M --> /var 目录下查找文件大小超过 10M 的文件
    find /var -size -50k --> /var 目录下查找文件大小小于 50k 的文件
    find /var -size +1G --> /var 目录下查找文件大小查过 1G 的文件
    find /var -size 1M --> /var 目录下查找文件大小等于 1M 的文件
    

    根据文件最近访问时间查找

    find -name "*.txt" -atime -7  --> 近 7天内访问过的.txt结尾的文件
    

    仅查找目录或文件

    find . -name "file" -type f  --> 只查找当前目录下的file文件
    find . -name "file" -type d  --> 只查找当前目录下的file目录
    

    操作查找结果

    find -name "*.txt" -printf "%p - %un" --> 找出所有后缀为txt的文件,并按照 %p - %un 格式打印,其中%p=文件名,%u=文件所有者
    find -name "*.jpg" -delete --> 删除当前目录以及子目录下所有.jpg为后缀的文件,不会有删除提示,因此要慎用
    find -name "*.c" -exec chmod 600 {} ; --> 对每个.c结尾的文件,都进行 -exec 参数指定的操作,{} 会被查找到的文件替代,; 是必须的结尾
    find -name "*.c" -ok chmod 600 {} ; --> 和上面的功能一直,会多一个确认提示
    

    软件仓库

    Linux 下软件是以包的形式存在,一个软件包其实就是软件的所有文件的压缩包,是二进制的形式,包含了安装软件的所有指令。 Red Hat 家族的软件包后缀名一般为 .rpm , Debian 家族的软件包后缀是 .deb 。

    Linux 的包都存在一个仓库,叫做软件仓库,它可以使用 yum 来管理软件包, yum 是 CentOS 中默认的包管理工具,适用于 Red Hat 一族。可以理解成 Node.js 的 npm 。

    yum 常用命令

    • yum update | yum upgrade  更新软件包
    • yum search xxx 搜索相应的软件包
    • yum install xxx 安装软件包
    • yum remove xxx 删除软件包

    切换 CentOS 软件源

    有时候 CentOS 默认的 yum 源不一定是国内镜像,导致 yum  在线安装及更新速度不是很理想。这时候需要将 yum 源设置为国内镜像站点。国内主要开源的镜像站点是网易和阿里云。

    1、首先备份系统自带 yum 源配置文件 mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup

    2、下载阿里云的 yum 源配置文件到 /etc/yum.repos.d/CentOS7

    wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
    

    3、生成缓存

    yum makecache 
    

    阅读手册

    Linux  命令种类繁杂,我们凭借记忆不可能全部记住,因此学会查用手册是非常重要的。

    man

    安装更新 man

    sudo yum install -y man-pages --> 安装
    sudo mandb --> 更新
    

    man 手册种类

    1. 可执行程序或 Shell 命令;
    2. 系统调用( Linux 内核提供的函数);
    3. 库调用(程序库中的函数);
    4. 文件(例如 /etc/passwd );
    5. 特殊文件(通常在 /dev 下);
    6. 游戏;
    7. 杂项( man(7) ,groff(7) );
    8. 系统管理命令(通常只能被 root 用户使用);
    9. 内核子程序。

    man + 数字 + 命令

    输入 man + 数字 + 命令/函数,可以查到相关的命令和函数,若不加数字, man 默认从数字较小的手册中寻找相关命令和函数

    man 3 rand  --> 表示在手册的第三部分查找 rand 函数
    man ls    --> 查找 ls 用法手册
    

    man 手册核心区域解析:(以 man pwd  为例)

    NAME # 命令名称和简单描述
         pwd -- return working directory name
    
    SYNOPSIS # 使用此命令的所有方法
         pwd [-L | -P]
    
    DESCRIPTION # 包括所有参数以及用法
         The pwd utility writes the absolute pathname of the current working directory to the standard output.
    
         Some shells may provide a builtin pwd command which is similar or identical to this utility.  Consult the builtin(1) manual page.
    
         The options are as follows:
    
         -L      Display the logical current working directory.
    
         -P      Display the physical current working directory (all symbolic links resolved).
    
         If no options are specified, the -L option is assumed.
    
    SEE ALSO # 扩展阅读相关命令
         builtin(1), cd(1), csh(1), sh(1), getcwd(3)
    

    help

    man 命令像新华词典一样可以查询到命令或函数的详细信息,但其实我们还有更加快捷的方式去查询, command --help 或 command -h ,它没有 man 命令显示的那么详细,但是它更加易于阅读。

    Linux 进阶

    文本操作

    grep

    全局搜索一个正则表达式,并且打印到屏幕。简单来说就是,在文件中查找关键字,并显示关键字所在行。

    基础语法

    grep text file # text代表要搜索的文本,file代表供搜索的文件
    
    # 实例
    [root@lion ~]# grep path /etc/profile
    pathmunge () {
        pathmunge /usr/sbin
        pathmunge /usr/local/sbin
        pathmunge /usr/local/sbin after
        pathmunge /usr/sbin after
    unset -f pathmunge
    

    常用参数

    • -i 忽略大小写, grep -i path /etc/profile
    • -n 显示行号,grep -n path /etc/profile
    • -v 只显示搜索文本不在的那些行,grep -v path /etc/profile
    • -r 递归查找, grep -r hello /etc ,Linux 中还有一个 rgrep 命令,作用相当于 grep -r

    高级用法

    grep 可以配合正则表达式使用。

    grep -E path /etc/profile --> 完全匹配path
    grep -E ^path /etc/profile --> 匹配path开头的字符串
    grep -E [Pp]ath /etc/profile --> 匹配path或Path
    

    sort

    对文件的行进行排序。

    基础语法

    sort name.txt # 对name.txt文件进行排序
    

    实例用法

    为了演示方便,我们首先创建一个文件 name.txt ,放入以下内容:

    Christopher
    Shawn
    Ted
    Rock
    Noah
    Zachary
    Bella
    

    执行 sort name.txt 命令,会对文本内容进行排序。

    常用参数

    • -o 将排序后的文件写入新文件, sort -o name_sorted.txt name.txt ;
    • -r 倒序排序, sort -r name.txt ;
    • -R 随机排序, sort -R name.txt ;
    • -n 对数字进行排序,默认是把数字识别成字符串的,因此 138 会排在 25 前面,如果添加了 -n 数字排序的话,则 25 会在 138 前面。

    wc

    word count 的缩写,用于文件的统计。它可以统计单词数目、行数、字符数,字节数等。

    基础语法

    wc name.txt # 统计name.txt
    

    实例用法

    [root@lion ~]# wc name.txt 
    13 13 91 name.txt
    
    • 第一个13,表示行数;
    • 第二个13,表示单词数;
    • 第三个91,表示字节数。

    常用参数

    • -l 只统计行数, wc -l name.txt ;
    • -w 只统计单词数, wc -w name.txt ;
    • -c 只统计字节数, wc -c name.txt ;
    • -m 只统计字符数, wc -m name.txt 。

    uniq

    删除文件中的重复内容。

    基础语法

    uniq name.txt # 去除name.txt重复的行数,并打印到屏幕上
    uniq name.txt uniq_name.txt # 把去除重复后的文件保存为 uniq_name.txt
    

    【注意】它只能去除连续重复的行数。

    常用参数

    • -c 统计重复行数, uniq -c name.txt ;
    • -d 只显示重复的行数, uniq -d name.txt 。

    cut

    剪切文件的一部分内容。

    基础语法

    cut -c 2-4 name.txt # 剪切每一行第二到第四个字符
    

    常用参数

    • -d 用于指定用什么分隔符(比如逗号、分号、双引号等等) cut -d , name.txt ;
    • -f 表示剪切下用分隔符分割的哪一块或哪几块区域, cut -d , -f 1 name.txt 。

    重定向 管道 流

    Linux 中一个命令的去向可以有3个地方:终端、文件、作为另外一个命令的入参。

    命令一般都是通过键盘输入,然后输出到终端、文件等地方,它的标准用语是 stdin 、 stdout 以及 stderr 。

    • 标准输入 stdin ,终端接收键盘输入的命令,会产生两种输出;
    • 标准输出 stdout ,终端输出的信息(不包含错误信息);
    • 标准错误输出 stderr ,终端输出的错误信息。

    重定向

    把本来要显示在终端的命令结果,输送到别的地方(到文件中或者作为其他命令的输入)。

    输出重定向 >

    > 表示重定向到新的文件, cut -d , -f 1 notes.csv > name.csv ,它表示通过逗号剪切 notes.csv 文件(剪切完有3个部分)获取第一个部分,重定向到 name.csv 文件。

    我们来看一个具体示例,学习它的使用,假设我们有一个文件 notes.csv  ,文件内容如下:

    Mark1,951/100,很不错1
    Mark2,952/100,很不错2
    Mark3,953/100,很不错3
    Mark4,954/100,很不错4
    Mark5,955/100,很不错5
    Mark6,956/100,很不错6
    

    执行命令: cut -d , -f 1 notes.csv > name.csv 最后输出如下内容:

    Mark1
    Mark2
    Mark3
    Mark4
    Mark5
    Mark6
    

    【注意】使用 > 要注意,如果输出的文件不存在它会新建一个,如果输出的文件已经存在,则会覆盖。因此执行这个操作要非常小心,以免覆盖其它重要文件。

    输出重定向 >>

    表示重定向到文件末尾,因此它不会像 > 命令这么危险,它是追加到文件的末尾(当然如果文件不存在,也会被创建)。

    再次执行 cut -d , -f 1 notes.csv >> name.csv ,则会把名字追加到 name.csv 里面。

    Mark1
    Mark2
    Mark3
    Mark4
    Mark5
    Mark6
    Mark1
    Mark2
    Mark3
    Mark4
    Mark5
    Mark6
    

    我们平时读的 log 日志文件其实都是用这个命令输出的。

    输出重定向 2>

    标准错误输出

    cat not_exist_file.csv > res.txt 2> errors.log
    
    • 当我们 cat 一个文件时,会把文件内容打印到屏幕上,这个是标准输出;
    • 当使用了 > res.txt 时,则不会打印到屏幕,会把标准输出写入文件 res.txt 文件中;
    • 2> errors.log 当发生错误时会写入 errors.log 文件中。

    输出重定向 2>>

    标准错误输出(追加到文件末尾)同 >> 相似。

    输出重定向 2>&1

    标准输出和标准错误输出都重定向都一个地方

    cat not_exist_file.csv > res.txt 2>&1  # 覆盖输出
    cat not_exist_file.csv >> res.txt 2>&1 # 追加输出
    

    目前为止,我们接触的命令的输入都来自命令的参数,其实命令的输入还可以来自文件或者键盘的输入。

    输入重定向

     符号用于指定命令的输入。

    cat # 指定命令的输入为 name.csv
    

    虽然它的运行结果与 cat name.csv 一样,但是它们的原理却完全不同。

    • cat name.csv 表示 cat 命令接收的输入是 notes.csv 文件名,那么要先打开这个文件,然后打印出文件内容。
    • cat  表示 cat 命令接收的输入直接是 notes.csv 这个文件的内容, cat 命令只负责将其内容打印,打开文件并将文件内容传递给 cat 命令的工作则交给终端完成。

    输入重定向

    将键盘的输入重定向为某个命令的输入。

    sort -n # 输入这个命令之后,按下回车,终端就进入键盘输入模式,其中END为结束命令(这个可以自定义)
    
    wc -m # 统计输入的单词
    

    管道 |

    把两个命令连起来使用,一个命令的输出作为另外一个命令的输入,英文是 pipeline ,可以想象一个个水管连接起来,管道算是重定向流的一种。

    举几个实际用法案例:

    cut -d , -f 1 name.csv | sort > sorted_name.txt 
    # 第一步获取到的 name 列表,通过管道符再进行排序,最后输出到sorted_name.txt
    
    du | sort -nr | head 
    # du 表示列举目录大小信息
    # sort 进行排序,-n 表示按数字排序,-r 表示倒序
    # head 前10行文件
    
    grep log -Ir /var/log | cut -d : -f 1 | sort | uniq
    # grep log -Ir /var/log 表示在log文件夹下搜索 /var/log 文本,-r 表示递归,-I 用于排除二进制文件
    # cut -d : -f 1 表示通过冒号进行剪切,获取剪切的第一部分
    # sort 进行排序
    # uniq 进行去重
    

    流并非一个命令,在计算机科学中,流 stream 的含义是比较难理解的,记住一点即可:「流就是读一点数据, 处理一点点数据。其中数据一般就是二进制格式。」 上面提及的重定向或管道,就是把数据当做流去运转的。

    到此我们就接触了,流、重定向、管道等 Linux 高级概念及指令。其实你会发现关于流和管道在其它语言中也有广泛的应用。 Angular 中的模板语法中可以使用管道。 Node.js 中也有 stream 流的概念。

    查看进程

    Windows 中通过 Ctrl + Alt + Delete 快捷键查看软件进程。

    w

    帮助我们快速了解系统中目前有哪些用户登录着,以及他们在干什么。

    [root@lion ~]# w
     06:31:53 up 25 days,  9:53,  1 user,  load average: 0.00, 0.01, 0.05
    USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
    root     pts/0    118.31.243.53    05:56    1.00s  0.02s  0.00s w
     
    06:31:53:表示当前时间
    up 25 days, 9:53:表示系统已经正常运行了“25天9小时53分钟”
    1 user:表示一个用户
    load average: 0.00, 0.01, 0.05:表示系统的负载,3个值分别表示“1分钟的平均负载”,“5分钟的平均负载”,“15分钟的平均负载”
    
     USER:表示登录的用于
     TTY:登录的终端名称为pts/0
     FROM:连接到服务器的ip地址
     LOGIN@:登录时间
     IDLE:用户有多久没有活跃了
     JCPU:该终端所有相关的进程使用的 CPU 时间,每当进程结束就停止计时,开始新的进程则会重新计时
     PCPU:表示 CPU 执行当前程序所消耗的时间,当前进程就是在 WHAT 列里显示的程序
     WHAT:表示当下用户正运行的程序是什么,这里我运行的是 w
    

    ps

    用于显示当前系统中的进程, ps 命令显示的进程列表不会随时间而更新,是静态的,是运行 ps 命令那个时刻的状态或者说是一个进程快照。

    基础语法

    [root@lion ~]# ps
      PID TTY          TIME CMD
     1793 pts/0    00:00:00 bash
     4756 pts/0    00:00:00 ps
     
     PID:进程号,每个进程都有唯一的进程号
     TTY:进程运行所在的终端
     TIME:进程运行时间
     CMD:产生这个进程的程序名,如果在进程列表中看到有好几行都是同样的程序名,那么就是同样的程序产生了不止一个进程
    

    常用参数

    • -ef 列出所有进程;
    • -efH 以乔木状列举出所有进程;
    • -u 列出此用户运行的进程;
    • -aux 通过 CPU 和内存使用来过滤进程 ps -aux | less ;
    • -aux --sort -pcpu 按 CPU 使用降序排列, -aux --sort -pmem 表示按内存使用降序排列;
    • -axjf 以树形结构显示进程, ps -axjf 它和 pstree 效果类似。

    top

    获取进程的动态列表。

    top - 07:20:07 up 25 days, 10:41,  1 user,  load average: 0.30, 0.10, 0.07
    Tasks:  67 total,   1 running,  66 sleeping,   0 stopped,   0 zombie
    %Cpu(s):  0.7 us,  0.3 sy,  0.0 ni, 99.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
    KiB Mem :  1882072 total,   552148 free,   101048 used,  1228876 buff/cache
    KiB Swap:        0 total,        0 free,        0 used.  1594080 avail Mem 
    
      PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND                                                                                                       
      956 root      10 -10  133964  15848  10240 S  0.7  0.8 263:13.01 AliYunDun                                                                                                     
        1 root      20   0   51644   3664   2400 S  0.0  0.2   3:23.63 systemd                                                                                                       
        2 root      20   0       0      0      0 S  0.0  0.0   0:00.05 kthreadd                                                                                                      
        4 root       0 -20       0      0      0 S  0.0  0.0   0:00.00 kworker/0:0H    
    
    • top - 07:20:07 up 25 days, 10:41,  1 user,  load average: 0.30, 0.10, 0.07 相当 w 命令的第一行的信息。
    • 展示的这些进程是按照使用处理器 %CPU 的使用率来排序的。

    kill

    结束一个进程, kill + PID 。

    kill 956 # 结束进程号为956的进程
    kill 956 957 # 结束多个进程
    kill -9 7291 # 强制结束进程
    

    管理进程

    进程状态

    主要是切换进程的状态。我们先了解下 Linux 下进程的五种状态:

    1. 状态码 R :表示正在运行的状态;
    2. 状态码 S :表示中断(休眠中,受阻,当某个条件形成后或接受到信号时,则脱离该状态);
    3. 状态码 D :表示不可中断(进程不响应系统异步信号,即使用kill命令也不能使其中断);
    4. 状态码 Z :表示僵死(进程已终止,但进程描述符依然存在,直到父进程调用 wait4() 系统函数后将进程释放);
    5. 状态码 T :表示停止(进程收到 SIGSTOP 、 SIGSTP 、 SIGTIN 、 SIGTOU 等停止信号后停止运行)。

    前台进程 & 后台进程

    默认情况下,用户创建的进程都是前台进程,前台进程从键盘读取数据,并把处理结果输出到显示器。例如运行 top 命令,这就是一个一直运行的前台进程。

    后台进程的优点是不必等待程序运行结束,就可以输入其它命令。在需要执行的命令后面添加 & 符号,就表示启动一个后台进程。

    &

    启动后台进程,它的缺点是后台进程与终端相关联,一旦关闭终端,进程就自动结束了。

    cp name.csv name-copy.csv &
    

    nohup

    使进程不受挂断(关闭终端等动作)的影响。

    nohup cp name.csv name-copy.csv
    

    nohup 命令也可以和 & 结合使用。

    nohup cp name.csv name-copy.csv &
    

    bg

    使一个“后台暂停运行”的进程,状态改为“后台运行”。

    bg %1 # 不加任何参数的情况下,bg命令会默认作用于最近的一个后台进程,如果添加参数则会作用于指定标号的进程
    

    实际案例1:

    1. 执行 grep -r "log" / > grep_log 2>&1 命令启动一个前台进程,并且忘记添加 & 符号
    2. ctrl + z 使进程状态转为后台暂停
    3. 执行 bg 将命令转为后台运行
    

    实际案例2:

    前端开发时我们经常会执行 yarn start 启动项目
    此时我们执行 ctrl + z 先使其暂停
    然后执行 bg 使其转为后台运行
    这样当前终端就空闲出来可以干其它事情了,如果想要唤醒它就使用 fg 命令即可(后面会讲)
    

    jobs

    显示当前终端后台进程状态。

    [root@lion ~]# jobs
    [1]+  Stopped                 top
    [2]-  Running                 grep --color=auto -r "log" / > grep_log 2>&1 &
    

    fg

    fg 使进程转为前台运行,用法和 bg 命令类似。

    我们用一张图来表示前后台进程切换:

    我们可以使程序在后台运行,成为后台进程,这样在当前终端中我们就可以做其他事情了,而不必等待此进程运行结束。

    守护进程

    一个运行起来的程序被称为进程。在 Linux 中有些进程是特殊的,它不与任何进程关联,不论用户的身份如何,都在后台运行,这些进程的父进程是 PID 为1的进程, PID 为1的进程只在系统关闭时才会被销毁。它们会在后台一直运行等待分配工作。我们将这类进程称之为守护进程 daemon 。

    守护进程的名字通常会在最后有一个 d ,表示 daemon 守护的意思,例如 systemd 、httpd 。

    systemd

    systemd 是一个 Linux 系统基础组件的集合,提供了一个系统和服务管理器,运行为 PID 1 并负责启动其它程序。

    [root@lion ~]# ps -aux
    USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
    root         1  0.0  0.2  51648  3852 ?        Ss   Feb01   1:50 /usr/lib/systemd/systemd --switched-root --system --deserialize 22
    

    通过命令也可以看到 PID 为1的进程就是 systemd 的系统进程。

    systemd 常用命令(它是一组命令的集合):

    systemctl start nginx # 启动服务
    systemctl stop nginx # 停止服务
    systemctl restart nginx # 重启服务
    systemctl status nginx # 查看服务状态
    systemctl reload nginx # 重载配置文件(不停止服务的情况)
    systemctl enable nginx # 开机自动启动服务
    systemctl disable nginx # 开机不自动启动服务
    systemctl is-enabled nginx # 查看服务是否开机自动启动
    systemctl list-unit-files --type=service # 查看各个级别下服务的启动和禁用情况
    

    文件压缩解压

    • 打包:是将多个文件变成一个总的文件,它的学名叫存档、归档。
    • 压缩:是将一个大文件(通常指归档)压缩变成一个小文件。

    我们常常使用 tar 将多个文件归档为一个总的文件,称为 archive 。 然后用 gzip 或 bzip2 命令将 archive 压缩为更小的文件。

    tar

    创建一个 tar 归档。

    基础用法

    tar -cvf sort.tar sort/ # 将sort文件夹归档为sort.tar
    tar -cvf archive.tar file1 file2 file3 # 将 file1 file2 file3 归档为archive.tar
    

    常用参数

    • -cvf 表示 create(创建)+ verbose(细节)+ file(文件),创建归档文件并显示操作细节;
    • -tf 显示归档里的内容,并不解开归档;
    • -rvf 追加文件到归档, tar -rvf archive.tar file.txt ;
    • -xvf 解开归档, tar -xvf archive.tar 。

    gzip / gunzip

    “压缩/解压”归档,默认用 gzip 命令,压缩后的文件后缀名为 .tar.gz 。

    gzip archive.tar # 压缩
    gunzip archive.tar.gz # 解压
    

    tar 归档+压缩

    可以用 tar 命令同时完成归档和压缩的操作,就是给 tar 命令多加一个选项参数,使之完成归档操作后,还是调用 gzip 或 bzip2 命令来完成压缩操作。

    tar -zcvf archive.tar.gz archive/ # 将archive文件夹归档并压缩
    tar -zxvf archive.tar.gz # 将archive.tar.gz归档压缩文件解压
    

    zcat、zless、zmore

    之前讲过使用 cat less more 可以查看文件内容,但是压缩文件的内容是不能使用这些命令进行查看的,而要使用 zcat、zless、zmore 进行查看。

    zcat archive.tar.gz
    

    zip/unzip

    “压缩/解压” zip 文件( zip 压缩文件一般来自 windows 操作系统)。

    命令安装

    # Red Hat 一族中的安装方式
    yum install zip 
    yum install unzip 
    

    基础用法

    unzip archive.zip # 解压 .zip 文件
    unzip -l archive.zip # 不解开 .zip 文件,只看其中内容
    
    zip -r sort.zip sort/ # 将sort文件夹压缩为 sort.zip,其中-r表示递归
    

    编译安装软件

    之前我们学会了使用 yum 命令进行软件安装,如果碰到 yum 仓库中没有的软件,我们就需要会更高级的软件安装“源码编译安装”。

    编译安装

    简单来说,编译就是将程序的源代码转换成可执行文件的过程。大多数 Linux 的程序都是开放源码的,可以编译成适合我们的电脑和操纵系统属性的可执行文件。

    基本步骤如下:

    1. 下载源代码
    2. 解压压缩包
    3. 配置
    4. 编译
    5. 安装

    实际案例

    1、下载

    我们来编译安装 htop 软件,首先在它的官网下载源码:

    https://bintray.com/htop/source/htop#files

    下载好的源码在本机电脑上使用如下命令同步到服务器上:

    scp 文件名 用户名@服务器ip:目标路径
    
    scp ~/Desktop/htop-3.0.0.tar.gz root@121.42.11.34:.
    

    也可以使用 wegt 进行下载:

    wegt+下载地址
    
    wegt https://bintray.com/htop/source/download_file?file_path=htop-3.0.0.tar.gz
    
    2、解压文件
    tar -zxvf htop-3.0.0.tar.gz # 解压
    
    cd htop-3.0.0 # 进入目录
    
    3、配置

    执行 ./configure ,它会分析你的电脑去确认编译所需的工具是否都已经安装了。

    4、编译

    执行 make 命令

    5、安装

    执行 make install 命令,安装完成后执行 ls /usr/local/bin/ 查看是否有 htop 命令。如果有就可以执行 htop 命令查看系统进程了。

    网络

    ifconfig

    查看 ip 网络相关信息,如果命令不存在的话, 执行命令 yum install net-tools 安装。

    [root@lion ~]# ifconfig
    
    eth0: flags=4163  mtu 1500
            inet 172.31.24.78  netmask 255.255.240.0  broadcast 172.31.31.255
            ether 00:16:3e:04:9c:cd  txqueuelen 1000  (Ethernet)
            RX packets 1592318  bytes 183722250 (175.2 MiB)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 1539361  bytes 154044090 (146.9 MiB)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
    
    lo: flags=73  mtu 65536
            inet 127.0.0.1  netmask 255.0.0.0
            loop  txqueuelen 1000  (Local Loopback)
            RX packets 0  bytes 0 (0.0 B)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 0  bytes 0 (0.0 B)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
    

    参数解析:

    • eth0 对应有线连接(对应你的有线网卡),就是用网线来连接的上网。 eth 是 Ethernet 的缩写,表示“以太网”。有些电脑可能同时有好几条网线连着,例如服务器,那么除了 eht0 ,你还会看到 eth1 、 eth2 等。

    • lo 表示本地回环( Local Loopback 的缩写,对应一个虚拟网卡)可以看到它的 ip 地址是 127.0.0.1 。每台电脑都应该有这个接口,因为它对应着“连向自己的链接”。这也是被称之为“本地回环”的原因。所有经由这个接口发送的东西都会回到你自己的电脑。看起来好像并没有什么用,但有时为了某些缘故,我们需要连接自己。例如用来测试一个网络程序,但又不想让局域网或外网的用户查看,只能在此台主机上运行和查看所有的网络接口。例如在我们启动一个前端工程时,在浏览器输入 127.0.0.1:3000 启动项目就能查看到自己的 web 网站,并且它只有你能看到。

    • wlan0 表示无线局域网(上面案例并未展示)。

    host

    ip 地址和主机名的互相转换。

    软件安装

    yum install bind-utils
    

    基础用法

    [root@lion ~]# host github.com
    baidu.com has address 13.229.188.59
     
    [root@lion ~]# host 13.229.188.59
    59.188.229.13.in-addr.arpa domain name pointer ec2-13-229-188-59.ap-southeast-1.compute.amazonaws.com.
    

    ssh 连接远程服务器

    通过非对称加密以及对称加密的方式(同 HTTPS 安全连接原理相似)连接到远端服务器。

    ssh 用户@ip:port
    
    1、ssh root@172.20.10.1:22 # 端口号可以省略不写,默认是22端口
    2、输入连接密码后就可以操作远端服务器了
    

    配置 ssh

    config 文件可以配置 ssh ,方便批量管理多个 ssh 连接。

    配置文件分为以下几种:

    • 全局 ssh 服务端的配置: /etc/ssh/sshd_config ;
    • 全局 ssh 客户端的配置: /etc/ssh/ssh_config(很少修改);
    • 当前用户 ssh 客户端的配置: ~/.ssh/config 。

    【服务端 config 文件的常用配置参数】

    [注意] 修改完服务端配置文件需要重启服务 systemctl restart sshd

    【客户端 config 文件的常用配置参数】

    配置当前用户的 config :

    # 创建config
    vim ~/.ssh/config
    
    # 填写一下内容
    Host lion # 别名
     HostName 172.x.x.x # ip 地址
      Port 22 # 端口
      User root # 用户
    

    这样配置完成后,下次登录时,可以这样登录 ssh lion 会自动识别为 root 用户。

    [注意] 这段配置不是在服务器上,而是你自己的机器上,它仅仅是设置了一个别名。

    免密登录

    ssh 登录分两种,一种是基于口令(账号密码),另外一种是基于密钥的方式。

    基于口令,就是每次登录输入账号和密码,显然这样做是比较麻烦的,今天主要学习如何基于密钥实现免密登录。

    基于密钥验证原理

    客户机生成密钥对(公钥和私钥),把公钥上传到服务器,每次登录会与服务器的公钥进行比较,这种验证登录的方法更加安全,也被称为“公钥验证登录”。

    具体实现步骤

    1、在客户机中生成密钥对(公钥和私钥) ssh-keygen(默认使用 RSA 非对称加密算法)

    运行完 ssh-keygen 会在 ~/.ssh/ 目录下,生成两个文件:

    • id_rsa.pub :公钥
    • id_rsa :私钥

    2、把客户机的公钥传送到服务

    执行 ssh-copy-id root@172.x.x.xssh-copy-id 它会把客户机的公钥追加到服务器 ~/.ssh/authorized_keys 的文件中)。

    执行完成后,运行 ssh root@172.x.x.x 就可以实现免密登录服务器了。

    配合上面设置好的别名,直接执行 ssh lion 就可以登录,是不是非常方便。

    wget

    可以使我们直接从终端控制台下载文件,只需要给出文件的HTTP或FTP地址。

    wget [参数][URL地址]
    
    wget http://www.minjieren.com/wordpress-3.1-zh_CN.zip
    

    wget 非常稳定,如果是由于网络原因下载失败, wget 会不断尝试,直到整个文件下载完毕。

    常用参数

    • -c 继续中断的下载。

    备份

    scp

    它是 Secure Copy 的缩写,表示安全拷贝。 scp 可以使我们通过网络,把文件从一台电脑拷贝到另一台电脑。

    scp 是基于 ssh 的原理来运作的, ssh 会在两台通过网络连接的电脑之间创建一条安全通信的管道, scp 就利用这条管道安全地拷贝文件。

    scp source_file destination_file # source_file 表示源文件,destination_file 表示目标文件
    

    其中 source_file 和 destination_file 都可以这样表示: user@ip:file_name , user 是登录名, ip 是域名或 ip 地址。 file_name 是文件路径。

    scp file.txt root@192.168.1.5:/root # 表示把我的电脑中当前文件夹下的 file.txt 文件拷贝到远程电脑
    scp root@192.168.1.5:/root/file.txt file.txt # 表示把远程电脑上的 file.txt 文件拷贝到本机
    

    rsync

    rsync 命令主要用于远程同步文件。它可以同步两个目录,不管它们是否处于同一台电脑。它应该是最常用于“增量备份”的命令了。它就是智能版的 scp 命令。

    软件安装

    yum install rsync
    

    基础用法

    rsync -arv Images/ backups/ # 将Images 目录下的所有文件备份到 backups 目录下
    rsync -arv Images/ root@192.x.x.x:backups/ # 同步到服务器的backups目录下
    

    常用参数

    • -a 保留文件的所有信息,包括权限,修改日期等;
    • -r 递归调用,表示子目录的所有文件也都包括;
    • -v 冗余模式,输出详细操作信息。

    默认地, rsync 在同步时并不会删除目标目录的文件,例如你在源目录中删除一个文件,但是用 rsync 同步时,它并不会删除同步目录中的相同文件。如果向删除也可以这么做: rsync -arv --delete Images/ backups/ 。

    系统

    halt

    关闭系统,需要 root 身份。

    halt
    

    reboot

    重启系统,需要 root 身份。

    reboot
    

    poweroff

    直接运行即可关机,不需要 root 身份。

    Vim 编辑器

    Vim 是什么?

    Vim 是从 vi 发展出来的一个文本编辑器。其代码补完、编译及错误跳转等方便编程的功能特别丰富,在程序员中被广泛使用。和 Emacs 并列成为类 Unix 系统用户最喜欢的编辑器。

    Vim 常用模式

    • 交互模式
    • 插入模式
    • 命令模式
    • 可视模式

    交互模式

    也成为正常模式,这是 Vim 的默认模式,每次运行 Vim 程序的时候,就会进入这个模式。

    例如执行 vim name.txt 则会进入交互模式。

    交互模式特征:

    • 在这个模式下,你不能输入文本;
    • 它可以让我们在文本间移动,删除一行文本,复制黏贴文本,跳转到指定行,撤销操作,等等。

    插入模式

    这个模式是我们熟悉的文本编辑器的模式,就是可以输入任何你想输入的内容。进入这个模式有几种方法,最常用的方法是按字母键 ii、I、a、A、o、O 都可以进入插入模式,只是所处的位置不同),退出这种模式,只需要按下 Esc 键。

    • i, I 进入输入模式 Insert mode : i 为“从目前光标所在处输入”, I 为“在目前所在行的第一个非空格符处开始输入”;
    • a, A 进入输入模式 Insert mode : a 为“从目前光标所在的下一个字符处开始输入”, A 为“从光标所在行的最后一个字符处开始输入”;
    • o, O 进入输入模式 Insert mode : o 为“在目前光标所在的下一行处输入新的一行”; O 为在目前光标所在处的上一行输入新的一行。

    命令模式

    命令模式也称为底线命令模式,这个模式下可以运行一些命令例如“退出”,“保存”,等动作。

    也可以用这个模式来激活一些 Vim 配置,例如语法高亮,显示行号,等。甚至还可以发送一些命令给终端命令行,例如 ls、cp 。

    为了进入命令模式,首先要进入交互模式,再按下冒号键。

    用一张图表示三种模式如何切换:

    基本操作

    打开 Vim

    在终端命令行中输入 vim 回车后 Vim 就会被运行起来,也可以用 Vim 来打开一个文件,只需要在 vim 后面再加文件名。如 vim file.name ,如果文件不存在,那么会被创建。

    插入

    进入文件之后,此时处于交互模式,可以通过输入 i 进入插入模式。

    移动

    Vim 的交互模式下,我们可以在文本中移动光标。

    • h 向左移动一个字符
    • j 向下移动一个字符
    • k 向上移动一个字符
    • i 向右移动一个字符

    当然也可以使用四个方向键进行移动,效果是一样的。

    跳至行首和行末

    • 「行首:」 在交互模式下,为了将光标定位到一行的开始位置,只需要按下数字键 0 即可,键盘上的 Home 键也有相同效果。
    • 「行末:」 在交互模式下,为了将光标定位到一行的末尾,只需要按下美元符号键 $ 即可,键盘上的 End 键也有相同效果。

    按单词移动

    在交互模式下,按字母键 w 可以一个单词一个单词的移动。

    退出文件

    在交互模式下,按下冒号键 : 进入命令模式,再按下 q 键,就可以退出了。

    如果在退出之前又修改了文件,就直接想用 :q 退出 Vim ,那么 Vim 会显示一个红字标明错误信息。此时我们有两个选择:

    1. 保存并退出 :wq  或 :x
    2. 不保存且退出 :q!

    标准操作

    删除字符

    在交互模式下,将光标定位到一个你想要删除的字符上,按下字母键 x 你会发现这个字符被删除了。

    也可以一次性删除多个字符,只需要在按 x 键之前输入数字即可。

    删除(剪切)单词,行

    • 「删除一行」:连按两次 d 来删除光标所在的那一行。
    • 「删除多行」:例如先输入数字 2 ,再按下 dd ,就会删除从光标所在行开始的两行。
    • 「删除一个单词」:将光标置于一个单词的首字母处,然后按下 dw 。
    • 「删除多个单词」:例如先按数字键 2 再按 dw 就可以删除两个单词了。
    • 「从光标所在位置删除至行首」d0 。
    • 「从光标所在位置删除至行末」d$ 。

    复制单词,行

    • 「复制行」:按两次 y 会把光标所在行复制到内存中,和 dd 类似, dd 用于“剪切”光标所在行。
    • 「复制单词」yw 会复制一个单词。
    • 「复制到行末」y$ 是复制从光标所在处到行末的所有字符。
    • 「复制到行首」y0  是复制光标所在处到行首的所有字符。

    粘贴

    如果之前用 dd 或者 yy 剪切复制过来的,可以使用 p 来粘贴。同样也可以使用 数字+p 来表示复制多次。

    替换一个字符

    在交互模式下,将光标置于想要替换的字符上。按下 r 键,接着输入你要替换的字符即可。

    撤销操作

    如果要撤销最近的修改,只需要按下 u 键,如果想要撤销最近四次修改,可以按下4,再按下 u 。

    重做

    取消撤销,也就是重做之前的修改使用 ctrl + r

    跳转到指定行

    Vim 编辑的文件中,每一行都有一个行号,行号从1开始,逐一递增。

    行号默认是不显示,如果需要它显示的话,可以进入命令模式,然后输入 set nu ,如果要隐藏行号的话,使用 set nonu

    • 跳转到指定行: 数字+gg ,例如 7gg ,表示跳转到第7行。
    • 要跳转到最后一行,按下 G 。
    • 要跳转到第一行,按下 gg 。

    高级操作

    查找

    处于交互模式下,按下 / 键,那么就进入查找模式,输入你要查找的字符串,然后按下回车。光标就会跳转到文件中下一个查找到的匹配处。如果字符串不存在,那么会显示 "pattern not found" 。

    • n 跳转到下一个匹配项;
    • N 跳转到上一个匹配项。

    [注意] 用斜杠来进行的查找是从当前光标处开始向文件尾搜索,如果你要从当前光标处开始,向文件头搜索则使用 ? ,当然也可以先按下 gg 跳转到第一行在进行全文搜索。

    查找并替换

    替换光标所在行第一个匹配的字符串:

    # 语法
    :s/旧字符串/新字符串
    
    # 实例
    :s/one/two
    

    替换光标所在行所有旧字符串为新字符串:

    # 语法
    :s/旧字符串/新字符串/g
    

    替换第几行到第几行中所有字符串:

    # 语法
    :n,m s/旧字符串/新字符串/g
    
    # 实例
    :2,4 s/one/two/g
    

    最常用的就是全文替换了:

    # 语法
    :%s/旧字符串/新字符串/g
    

    合并文件

    可以用冒号 +r  ( :r ) 实现在光标处插入一个文件的内容。

    :r filename # 可以用Tab键来自动补全另外一个文件的路径
    

    分屏

    Vim 有一个特别便捷的功能那就是分屏,可以同时打开好几个文件,分屏之后,屏幕每一块被称为一个 viewport ,表示“视口”。

    • 横向分屏 :sp 文件名
    • 垂直分屏 :vsp 文件名

    分屏模式下的快捷键

    • Ctrl + w 再加 Ctrl + w ,表示从一个 viewport 移动光标到另外一个 viewport ;
    • Ctrl + w 再加 “方向键”,就可以移动到这个方向所处的下一个视口了;
    • Ctrl + w 再加 + 号,表示扩大当前视口;
    • Ctrl + w 再加 - 号,表示缩小当前视口;
    • Ctrl + w 再加 = 号,表示平均当前视口;
    • Ctrl + w 再加 r 键,会反向调换视口位置;
    • Ctrl + w 再加 q 键,会关闭当前视口;
    • Ctrl + w 再加 o 键,会关闭除当前视口以外的所有视口;

    运行外部命令 :!

    Vim 中可以运行一些终端命令,只要先输入 :! ,然后接命令名称。

    例如:

    :!ls # 在Vim中打开的文件所在的目录运行ls命令
    

    可视模式

    前面只讲了 Vim 的三种模式,其实还有一种模式叫做可视模式。

    进入它的三种方式(都是从交互模式开始):

    • v 字符可视模式,进入后配合方向键选中字符后,然后再按 d 键可以删除选中。
    • V 行可视模式,进入后光标所在行默认被选中,然后再按 d 键可以删除所在行。
    • Ctrl + v 块可视模式,它是可视模式最有用的功能了,配合 d  和 I 键可以实现删除选中的内容和插入内容。

    同时选中多行,并在选中行头部插入内容的具体操作步骤:

    1. ctrl + v 进入块可视模式
    2. 使用方向键进行选中(上下左右)假设选中5行
    3. 输入 I 键进行多行同时插入操作
    4. 插入完成后连续按两下 esc 键,实现多行同时插入相同字符

    进入可视模式之后的操作键:

    • d 键,表示删除选中;
    • I 键,表示在选中之前插入;
    • u 键,表示选中变为小写;
    • U 键,表示选中变为大写;

    Vim 配置

    选项参数

    Vim 被启动后,可以运行一些指令来激活一些选项参数,但是这些选项参数的配置在退出 Vim 时会被忘记,例如前面讲解的激活行号。如果希望所在的配置是永久性的,那么需要在家目录( cd ~ )创建一个 Vim 的配置文件 .vimrc 。

    .vimrc

    set number " 显示行号
    syntax on " 激活语法高亮
    set showcmd " 实时看到输入的命令
    set ignorecase " 搜索时不区分大小写
    set mouse=a " 激活鼠标,用鼠标选中时相当于进入可视模式
    

    Vim 配置非常丰富,我们可以通过个性化配置把 Vim 打造成属于自己的 IDE 等等。在 github 上也可以搜索到一些强大的 Vim 配置文件。

    总结

    相信通过本文的学习,你应该会对 Linux 有一个更加全面的认识。

    都看到这里了,就点个👍 👍 👍 吧。

  • Spring Boot Admin 服务监控利器 !

     

    来源:blog.csdn.net/qq_p48721706/article/details/126092702

     

    一、简介

    用于对 Spring Boot 应用的管理和监控。可以用来监控服务是否健康、是否在线、以及一些jvm数据等等。

    Spring Boot Admin 分为服务端(spring-boot-admin-server)和客户端(spring-boot-admin-client),服务端和客户端之间采用 http 通讯方式实现数据交互;单体项目中需要整合 spring-boot-admin-client 才能让应用被监控。

    在 SpringCloud 项目中,spring-boot-admin-server 是直接从注册中心抓取应用信息,不需要每个微服务应用整合 spring-boot-admin-client 就可以实现应用的管理和监控。

    图片

    主要的功能点有:

    • 显示应用程序的监控状态
    • 应用程序上下线监控
    • 查看 JVM,线程信息
    • 可视化的查看日志以及下载日志文件
    • 动态切换日志级别
    • Http 请求信息跟踪

    二、搭建

    1、服务端

    需先搭建服务端,监控服务,被监控的服务连接过来即可,开箱即用。

    1、新建一个项目做为服务端

    2、引入spring-boot-admin服务端依赖

      
     
         org.springframework.boot
         spring-boot-starter-actuator
     
      
     
         de.codecentric
         spring-boot-admin-starter-server
         2.3.1
     
       
     
          org.springframework.boot
          spring-boot-starter-security
      

    3、启动类上开启admin@EnableAdminServer

    4、security安全防护配置

    import de.codecentric.boot.admin.server.config.AdminServerProperties;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler;
    import org.springframework.security.web.csrf.CookieCsrfTokenRepository;

    @Configuration
    public class SecuritySecureConfig extends WebSecurityConfigurerAdapter {

        private final String adminContextPath;

        public SecuritySecureConfig(AdminServerProperties adminServerProperties) {
            this.adminContextPath = adminServerProperties.getContextPath();
        }


        @Override
        protected void configure(HttpSecurity http) throws Exception {
            // 登录成功处理类
            SavedRequestAwareAuthenticationSuccessHandler successHandler = new SavedRequestAwareAuthenticationSuccessHandler();
            successHandler.setTargetUrlParameter("redirectTo");
            successHandler.setDefaultTargetUrl(adminContextPath + "/");

            http.authorizeRequests()
                    //静态文件允许访问
                    .antMatchers(adminContextPath + "/assets/**").permitAll()
                    //登录页面允许访问
                    .antMatchers(adminContextPath + "/login""/css/**""/js/**""/image/*").permitAll()
                    //其他所有请求需要登录
                    .anyRequest().authenticated()
                    .and()
                    //登录页面配置,用于替换security默认页面
                    .formLogin().loginPage(adminContextPath + "/login").successHandler(successHandler).and()
                    //登出页面配置,用于替换security默认页面
                    .logout().logoutUrl(adminContextPath + "/logout").and()
                    .httpBasic().and()
                    .csrf()
                    .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
                    .ignoringAntMatchers(
                            "/instances",
                            "/actuator/**"
                    );
        }
    }

    5、yml配置

    server:
      port: 9111
    spring:
      boot:
        admin:
          ui:
            title: HMB服务监控中心
          client:
            instance:
              metadata:
                tags:
                  environment: local
             #要获取的client的端点信息
          probed-endpoints: health,env,metrics,httptrace:trace,threaddump:dump,jolokia,info,logfile,refresh,flyway,liquibase,heapdump,loggers,auditevents
          monitor: # 监控发送请求的超时时间
            default-timeout: 20000
      security: # 设置账号密码
        user:
          name: admin
          password: admin
    # 服务端点详细监控信息
    management:   
      trace:
        http:
          enabled: true
      endpoints:
        web:
          exposure:
            include: "*"
      endpoint:
        health:
          show-details: always

    6、启动项目

    访问 http://ip:端口,如我的http://localhost:9111,账号密码都是admin(上面的security配的)

    图片

    7、自定义服务状态变化后,提醒功能

    import de.codecentric.boot.admin.server.domain.entities.Instance;
    import de.codecentric.boot.admin.server.domain.entities.InstanceRepository;
    import de.codecentric.boot.admin.server.domain.events.InstanceEvent;
    import de.codecentric.boot.admin.server.notify.AbstractStatusChangeNotifier;
    import org.springframework.stereotype.Component;
    import reactor.core.publisher.Mono;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Map;

    @Component
    public class WarnNotifier extends AbstractStatusChangeNotifier {
     public WarnNotifier(InstanceRepository repository) {
      super(repository);
     }

     @Override
     protected Mono doNotify(InstanceEvent event, Instance instance) {
      // 服务名
      String serviceName = instance.getRegistration().getName();
      // 服务url
      String serviceUrl = instance.getRegistration().getServiceUrl();
      // 服务状态
      String status = instance.getStatusInfo().getStatus();
      // 详情
      Map details = instance.getStatusInfo().getDetails();
      // 当前服务掉线时间
      Date date = new Date();
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      String format = simpleDateFormat.format(date);
      // 拼接短信内容
      StringBuilder str = new StringBuilder();
      str.append("服务名:【" + serviceName + "】 rn");
      str.append("服务状态:【"+ status +"】 rn");
      str.append("地址:【" + serviceUrl + "】rn");
      str.append("时间:" + format +"rn");

      return Mono.fromRunnable(()->{
       // 这里写你服务发生改变时,要提醒的方法
       // 如服务掉线了,就发送短信告知
      });
     }
    }

    8、服务端配置

    2、客户端

    被监控的服务,需要连接服务端

    1、依赖
     
         de.codecentric
         spring-boot-admin-starter-client
         2.3.1
     
     
         org.springframework.boot
         spring-boot-starter-actuator
     
    2、yml配置
    server:
      port: 9222

    spring:
      application:
        name: client
      boot:
        admin:
          client: # spring-boot-admin 客户端配置
            url: http://localhost:9111 #服务端连接地址
            username: admin # 服务端账号
            password: admin # 服务端密码
            instance:
              prefer-ip: true # 使用ip注册

    # 服务端点详细监控信息
    management:
    # health:  # 检测服务状态是通过http://localhost:9111/actuator/health接口,可去掉不用检测项
    #  mail: # 健康检测时,不要检测邮件
    #   enabled: false 
      trace:
        http:
          enabled: true
      endpoints:
        web:
          exposure:
            include: "*"
      endpoint:
        health:
          show-details: always
        logfile: # 日志(想在线看日志才配)
          external-file: ./logs/client-info.log # 日志所在路径
    3、启动项目

    此时客户端就已经注册进来了。

    点击可查看更多信息

    点击日志也可在线查看日志

    图片

    此时,如果我们服务掉线了,就会触发服务端的预警功能,告知我们。

    4、客户端配置

    图片

    3、微服务

    除特别说明外,都是在上面的基础上添加

    3.1、服务端

    1、添加依赖

      
      
          com.alibaba.cloud
          spring-cloud-starter-alibaba-nacos-discovery
          2.2.5.RELEASE
      

    2、yml添加配置

    spring:
      cloud: 
        nacos: 
          discovery:
            server-addr: localhost:8848
    #        namespace: # 要和你的服务同一命名空间
    3.2、客户端

    客户端不用引spring-boot-admin-starter-clien依赖,springbootadmin会去服务列表里找

    如果服务有配置context-path路径,则需添加yml配置

    spring:
      cloud:
        nacos:
          discovery:
            metadata:  # minitor监控的context-path配置
              management:
                context-path: ${server.servlet.context-path}/actuator

    4、我的微服务预警发送其他服务状态信息思路

    问题:由于该组件重写状态发生变化时的接口,没有提供其他服务的状态信息,只有本服务,但是如果是集群、多实例,我又想知道,该服务其他实例或者其他的服务状态信息,是否存活。

     

    思路:我在发送预警之前,访问其他服务的检测健康接口,如:http://localhost:7050/attendance/actuator/nacos-discovery,有返回值,就可提取里面的信息,报错了说明没有该服务没有启动

     

    结果展示:如我的预警内容,发送当前服务状态、当前服务剩余健康实例、其他健康服务数等等

    图片

     

     

  • IDEA代码重构小技巧(超实用)

    一、重构函数
      • 1、提取方法
      • 2、合并方法
      • 3、方法重命名
      • 4、函数参数位置更改与重命名
    • 二、重构变量
    • 三、提取方法到父类

    一、重构函数

    1、提取方法

    提取想要的代码,按快捷键Ctrl+Alt+M,就会弹出框,写出方法名称即可提取一个方法

    2、合并方法

    反向操作,选中方法后,把方法代码直接并入主方法里面

    3、方法重命名

    Ctrl+Shift+Alt+T,或者Shift+F6

    4、函数参数位置更改与重命名

    二、重构变量

    • Ctrl+Alt+C 快速提取常量(Constant)

    • Ctrl+Alt+V快速提取变量(Variable)

    • Ctrl+Alt+F快速提取成员变量(Filed Variable)

    • Ctrl+Shift+f6 重构变量的类型

    点击变量,直接使用快捷键

    三、提取方法到父类

  • MySQL 批量操作,一次插入多少行数据效率最高?

    MySQL 批量操作,一次插入多少行数据效率最高?来源:blog.csdn.net/LJFPHP/article/details/99708888

    • 一、前言
    • 二、批量插入前准备
      • 1、插入到数据表的字段
      • 2、计算一行字段占用的空间
      • 3、在数据里做插入操作的时候,整体时间的分配
    • 三、批量插入数据测试
      • 1、SQL语句的大小限制
      • 2、查看服务器上的参数:
      • 3、计算一次能插入的最大行记录
      • 4、测试插入数据比对
      • 5、如果插入的值就是sql语句限制的最大值,那么性能真的好吗?
    • 四、其他影响插入性能的因素
      • 1、首先是插入的时候,要注意缓冲区的大小使用情况
      • 2、插入缓存
      • 3、使用事务提升效率
      • 4、通过配置提升读写性能
      • 5、索引影响插入性能
    • 五、总结

    一、前言

    我们在操作大型数据表或者日志文件的时候经常会需要写入数据到数据库,那么最合适的方案就是数据库的批量插入。只是我们在执行批量操作的时候,一次插入多少数据才合适呢?

    假如需要插入的数据有百万条,那么一次批量插入多少条的时候,效率会高一些呢?这里博主和大家一起探讨下这个问题,应用环境为批量插入数据到临时表。

    二、批量插入前准备

    博主本地原本是循环查出来的数据,然后每1000条插入一次,直至完成插入操作。但是为什么要设置1000条呢,实不相瞒,这是因为项目里的其他批量插入都是一次插1000条。。汗,博主不服,所以想要测试下。

    首先是查看当前数据库的版本,毕竟各个版本之间存在差异,脱离版本讲数据库就是耍流氓(以前没少耍啊):

    mysql> select version();
    +------------+
    | version()  |
    +------------+
    | 5.6.34-log |
    +------------+
    1 row in set (0.00 sec)
    

    1、插入到数据表的字段

    对于手动创建的临时表来说,字段当然是越少越好,而且字段占用的空间要尽量小一些,这样临时表不至于太大,影响表操作的性能。这里需要插入的字段是:

    字段1 int(10)
    字段2 int(10)
    字段3 int(10)
    字段4 varchar(10)
    

    我们一共插入四个字段,分别是3个int类型的,一个varchar类型的,整体来说这些字段都比较小,占用的内存空间会小一些。

    2、计算一行字段占用的空间

    对于innodb引擎来说,int类型可以存储4个字节,里面的Int(M)并不会影响存储字节的大小,这个M只是数据的展示位数,和mysql的ZEROFILL属性有关,即在数字长度不够的数据前面填充0,以达到设定的长度。此处不多说,想要了解的朋友可以百度一下,还是很有意思的。

    varchar(10)代表可以存储10个字符,不管是英文还是中文,最多都是10个,这部分假设存储的是中文,在utf-8mb4下,10个中文占用10*4 = 40个字节那么一行数据最多占用:4+4+4+40 = 52字节

    3、在数据里做插入操作的时候,整体时间的分配

    链接耗时 (30%)
    发送query到服务器 (20%)
    解析query (20%)
    插入操作 (10% * 词条数目)
    插入index (10% * Index的数目)
    关闭链接 (10%)
    

    从这里可以看出来,真正耗时的不是操作,而是链接,解析的过程。单条sql的话,会在链接,解析部分耗费大量的时间,因此速度会很慢,所以我们一般都是采用批量插入的操作,争取在一次链接里面写入尽可能多的数据,以此来提升插入的速度。但是这个尽可能多的数据是多少呢?一次到底插入多少才合适呢?

    三、批量插入数据测试

    开始测试,但是一开始插入多少是合适的呢,是否有上限?查询mysql手册,我们知道sql语句是有大小限制的。

    1、SQL语句的大小限制

    my.ini 里有 max_allowed_packet 这个参数控制通信的 packet 大小。mysql默认的sql语句的最大限制是1M(mysql5.7的客户端默认是16M,服务端默认是4M),可以根据设置查看。官方解释是适当增大 max_allowed_packet 参数可以使client端到server端传递大数据时,系统能够分配更多的扩展内存来处理。

    官方手册:https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html

    2、查看服务器上的参数:

    mysql> show variables like '%max_allowed_packet%';
    +--------------------------+------------+
    | Variable_name            | Value      |
    +--------------------------+------------+
    | max_allowed_packet       | 33554432   |
    | slave_max_allowed_packet | 1073741824 |
    +--------------------------+------------+
    2 rows in set (0.00 sec)
    

    33554432字节 = 32M ,也就是规定大小不能超过32M。

    3、计算一次能插入的最大行记录

    1M计算的话,(1024*1024)/52 ≈ 20165 ,为了防止溢出,最大可一次性插入20000条(根据自己的配置和sql语句大小计算)。那么32M的话就是:20000 *32 = 640000 也就是64W条。

    4、测试插入数据比对

    (1)插入11W条数据,按照每次10,600,1000,20000,80000来测试:
    +---------------+
    | count(c1.uin) |
    +---------------+
    |         110000 |
    +---------------+
    

    有个博客说一次插入10条最快,,我觉得一次插的有点少,咱们试试

    参考:https://www.cnblogs.com/aicro/p/3851434.html

    这个博主测试后,认为一次插10条是性能最快的,他的每条记录是3kb,相当于我的59行数据,取个整数60,那么对于这个博主是插入10条,对我来说插入:600,这几个值都试试。

    耗时:

    11W的数据,每次插入10条。耗时:2.361s
    11W的数据,每次插入600条。耗时:0.523s
    11W的数据,每次插入1000条。耗时:0.429s
    11W的数据,每次插入20000条。耗时:0.426s
    11W的数据,每次插入80000条。耗时:0.352s
    

    从这部分看,随着批量插入的增加,速度略有提升,最起码一次插10条应该不是最佳的。插入数据量多,减少了循环的次数,也就是在数据库链接部分的耗时有所减少,只是这个8W并不是极限数据,具体一次插入多少条,还有待参考。

    (2)加大数据量到24w
    +---------------+
    | count(c1.uin) |
    +---------------+
    |        241397 |
    +---------------+
    

    耗时:

    24W的数据,每次插入10条。耗时:4.445s
    24W的数据,每次插入600条。耗时:1.187s
    24W的数据,每次插入1000条。耗时:1.13s
    24W的数据,每次插入20000条。耗时:0.933s
    24W的数据,每次插入80000条。耗时:0.753s
    

    一次插入24W反而性能最佳,这么代表我们的测试数据量依然不够。

    (3)加大测试量到42W
    +---------------+
    | count(c1.uin) |
    +---------------+
    |        418859 |
    

    耗时:

    42W的数据,每次插入1000条。耗时:2.216s
    42W的数据,每次插入80000条。耗时:1.777s
    42W的数据,每次插入16W条。耗时:1.523s
    42W的数据,每次插入20W条。耗时:1.432s
    42W的数据,每次插入30W条。耗时:1.362s
    42W的数据,每次插入40W条。耗时:1.764s
    

    随着插入量的增加,批量插入条数多了之后,性能是有所提升的。但是在达到30W以上之后,效率反而有所下降。这部分我的理解是mysql是要分配一定的内存给传过来的数据包使用,当批量插入的数据量到达一定程度之后,一次插入操作的开销就很耗费内存了。

    个人感觉,最佳大小是max_allowed_packet的一半,也就是极限能插入64W,选用32W也许性能会更好一些,同时也不会对mysql的其他操作产生太大的影响。

    5、如果插入的值就是sql语句限制的最大值,那么性能真的好吗?

    博主疯狂谷歌百度,都没有找到有人来具体的说一下这个问题,不过在高性能mysql里面发现一句话:

    客户端用一个单独的数据包将查询请求发送给服务器,所以当查询语句很长的时候,需要设置max_allowed_packet参数。但是需要注意的是,如果查询实在是太大,服务端会拒绝接收更多数据并抛出异常。与之相反的是,服务器响应给用户的数据通常会很多,由多个数据包组成。但是当服务器响应客户端请求时,客户端必须完整的接收整个返回结果,而不能简单的只取前面几条结果,然后让服务器停止发送。因而在实际开发中,尽量保持查询简单且只返回必需的数据,减小通信间数据包的大小和数量是一个非常好的习惯,这也是查询中尽量避免使用SELECT *以及加上LIMIT限制的原因之一。

    后面通过各种百度,博主觉得最大只是代表传输数据包的最大长度,但性能是不是最佳就要从各个方面来分析了。比如下面列出的插入缓冲,以及插入索引时对于缓冲区的剩余空间需求,以及事务占有的内存等,都会影响批量插入的性能。

    四、其他影响插入性能的因素

    1、首先是插入的时候,要注意缓冲区的大小使用情况

    在分析源码的过程中,有一句话:如果buffer pool余量不足25%,插入失败,返回DB_LOCK_TABLE_FULL。这个错误并不是直接报错:max_allowed_packet 不够大之类的,这个错误是因为对于innodb引擎来说,一次插入是涉及到事务和锁的,在插入索引的时候,要判断缓冲区的剩余情况,所以插入并不能仅仅只考虑max_allowed_packet的问题,也要考虑到缓冲区的大小。

    参考淘宝的数据库日报:http://mysql.taobao.org/monthly/2017/09/10/

    2、插入缓存

    另外对于innodb引擎来说,因为存在插入缓存(Insert Buffer)这个概念,所以在插入的时候也是要耗费一定的缓冲池内存的。当写密集的情况下,插入缓冲会占用过多的缓冲池内存,默认最大可以占用到1/2的缓冲池内存,当插入缓冲占用太多缓冲池内存的情况下,会影响到其他的操作。

    也就是说,插入缓冲受到缓冲池大小的影响,缓冲池大小为:

    mysql> show variables like 'innodb_buffer_pool_size';
    +-------------------------+-----------+
    | Variable_name           | Value     |
    +-------------------------+-----------+
    | innodb_buffer_pool_size | 134217728 |
    +-------------------------+-----------+
    

    换算后的结果为:128M,也就是说,插入缓存最多可以占用64M的缓冲区大小。这个大小要超过咱们设置的sql语句大小,所以可以忽略不计。

    详细解释:

    我们都知道,在InnoDB引擎上进行插入操作时,一般需要按照主键顺序进行插入,这样才能获得较高的插入性能。当一张表中存在非聚簇的且不唯一的索引时,在插入时,数据页的存放还是按照主键进行顺序存放,但是对于非聚簇索引叶节点的插入不再是顺序的了,这时就需要离散的访问非聚簇索引页,由于随机读取的存在导致插入操作性能下降。

    InnoDB为此设计了Insert Buffer来进行插入优化。对于非聚簇索引的插入或者更新操作,不是每一次都直接插入到索引页中,而是先判断插入的非聚集索引是否在缓冲池中,若在,则直接插入;若不在,则先放入到一个Insert Buffer中。

    看似数据库这个非聚集的索引已经查到叶节点,而实际没有,这时存放在另外一个位置。然后再以一定的频率和情况进行Insert Buffer和非聚簇索引页子节点的合并操作。这时通常能够将多个插入合并到一个操作中,这样就大大提高了对于非聚簇索引的插入性能。

    参考:https://cloud.tencent.com/developer/article/1200824

    参考:mysql技术内幕 Innodb篇

    3、使用事务提升效率

    还有一种说法,使用事务可以提高数据的插入效率,这是因为进行一个INSERT操作时,MySQL内部会建立一个事务,在事务内才进行真正插入处理操作。通过使用事务可以减少创建事务的消耗,所有插入都在执行后才进行提交操作。大概如下:

    START TRANSACTION;
    INSERT INTO `insert_table` (`datetime`, `uid`, `content`, `type`) 
        VALUES ('0''userid_0''content_0', 0);
    INSERT INTO `insert_table` (`datetime`, `uid`, `content`, `type`) 
        VALUES ('1''userid_1''content_1', 1);
    ...
    COMMIT;
    

    参考:https://my.oschina.net/songhongxu/blog/163063

    事务需要控制大小,事务太大可能会影响执行的效率。MySQL有innodb_log_buffer_size配置项,超过这个值会把innodb的数据刷到磁盘中,这时,效率会有所下降。所以比较好的做法是,在数据达到这个这个值前进行事务提交。

    查看:show variables like '%innodb_log_buffer_size%';

    +------------------------+----------+
            | Variable_name          | Value    |
            +------------------------+----------+
            | innodb_log_buffer_size | 67108864 |
            +------------------------+----------+
    

    大概是:64M

    这种写法和批量写入的效果差不多,只不过sql语句还是单句的,然后统一提交。一个瓶颈是SQL语句的大小,一个瓶颈是事务的大小。当我们在提交sql的时候,首先是受到sql大小的限制,其次是受到事务大小的限制。在开启事务的情况下使用批量插入,会节省不少事务的开销,如果要追求极致的速度的话,建议是开着事务插入的。

    不过需要注意一下,内存是有限且共享的,如果批量插入占用太多的事务内存,那么势必会对其他的业务操作等有一定的影响。

    4、通过配置提升读写性能

    也可以通过增大innodb_buffer_pool_size 缓冲区来提升读写性能,只是缓冲区是要占用内存空间的,内存很珍贵,所以这个方案在内存富裕,而性能瓶颈的时候,可以考虑下。

    参考:https://my.oschina.net/anuodog/blog/3002941

    5、索引影响插入性能

    如果表中存在多个字段索引,当对表中的数据进行增加、删除和修改的时候,索引也要动态的维护。这样就降低了数据的插入速度。对于普通的数据表,主键索引是肯定要有的,想要加快性能的话,就是要有序插入,每次插入记录都在索引的最后面,索引的定位效率很高,并且对索引调整较小。如果插入的记录在索引中间,需要B+tree进行分裂合并等处理,会消耗比较多计算资源,并且插入记录的索引定位效率会下降,数据量较大时会有频繁的磁盘操作。

    五、总结

    博主经过测试+谷歌,最终是选用的一次批量插入数据量为max_allowed_packet大小的一半。只是在不断的搜索中,发现影响插入性能的地方挺多的,如果仅仅是拿max_allowed_packet这个参数作为分析,其实是没有意义的,这个参数只是设置最大值,但并不是最佳性能。

    不过需要注意,由于sql语句比较大,所以才执行完插入操作之后,一定要释放变量,不要造成无谓的内存损耗,影响程序性能。

    对于我们的mysql来说也是一样的,mysql的最佳性能是建立在各个参数的合理设置上,这样协同干活儿的效果最佳。如果其他设置不到位的话,就像是木桶原理一样,哪怕内存缓冲区设置的很大,但是性能取决的反而是设置最差的那个配置。关于mysql的配置调优,我们都在路上,加油!

  • 用上这几个开源管理系统做项目,领导看了直呼专业!

    SCUI Admin 中后台前端解决方案

    SCUI 是一个中后台前端解决方案,基于 VUE3和 elementPlus 实现。使用最新的前端技术栈,提供各类实用的组件方便在业务开发时的调用,并且持续性的提供丰富的业务模板帮助你快速搭建企业级中后台前端任务。

    • 项目地址:https://gitee.com/lolicode/scui
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    Vue + .NetCore 前后端分离的快速发开框架

    框架内置了大量的通用组件可直接使用,并内置了基于本框架定制开发的代码生成器,尽量避免重复性代码编写。支持前端、后台自定义业务代码扩展,后台提供了大量常用扩展与通用类;前端、后台提供了近300个扩展方法与属性,开发人员可在此功能上编写扩展自定义业务代码

    • 项目地址:https://gitee.com/x_discoverer/Vue.NetCore
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    next-admin 适配移动端、pc的后台模板

    基于 vue3.x + CompositionAPI + typescript + vite + element plus + vue-router-next + next.vuex,适配手机、平板、pc 的后台开源免费模板,希望减少工作量,帮助大家实现快速开发。

    • 项目地址:https://gitee.com/lyt-top/vue-next-admin
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    django-vue-admin-pro 快速开发平台

    django-vue-admin-pro 是一套全部开源的快速开发平台,毫无保留给个人及企业免费使用。前端采用 D2Admin 、Vue。后端采用 Python 语言 Django 框架。权限认证使用 Jwt,支持多终端认证系统。支持加载动态权限菜单,多方式轻松实现权限控制。

    • 项目地址:https://gitee.com/dvadmin/django-vue-admin-pro
    用上这几个开源管理系统做项目,领导看了直呼专业!

    Admin.NET 通用管理平台

    基于 Furion/.NET 6实现的通用管理平台。整合最新技术,模块插件式开发,前后端分离,开箱即用。集成EF Core、多租户、缓存、数据校验、鉴权、事件总线、动态 API、通讯、远程请求、任务调度、gRPC 等众多黑科技。代码简洁、易扩展,让开发更简单、更通用、更流行!

    • 项目地址:https://gitee.com/zuohuaijun/Admin.NET
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    RuoYi 若依权限管理系统

    基于 SpringBoot 的权限管理系统 易读易懂、界面简洁美观。核心技术采用Spring、MyBatis、Shiro 没有任何其它重度依赖,直接运行即可用。

    • 项目地址:https://gitee.com/y_project/RuoYi
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    Vue3.2 + Element-Plus 后台管理框架

    Geeker Admin,基于 Vue3.2、TypeScript、Vite3、Pinia、Element-Plus 开源的一套后台管理框架。

    • 项目地址:https://github.com/HalseySpicy/Geeker-Admin
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    Pig RABC权限管理系统

    基于 Spring Boot 2.6、 Spring Cloud 2021 & Alibaba、 OAuth2 的微服务RBAC 权限管理系统。基于数据驱动视图的理念封装 element-ui,即使没有 vue 的使用经验也能快速上手。

    • 项目地址:https://gitee.com/log4j/pig
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    zheng 分布式敏捷开发系统架构

    基于 Spring+SpringMVC+Mybatis 分布式敏捷开发系统架构,提供整套公共微服务服务模块:集中权限管理(单点登录)、内容管理、支付中心、用户管理(支持第三方登录)、微信平台、存储系统、配置中心、日志分析、任务和通知等,支持服务治理、监控和追踪,努力为中小型企业打造全方位 J2EE 企业级开发解决方案。

    • 项目地址:https://gitee.com/shuzheng/zheng
    用上这几个开源管理系统做项目,领导看了直呼专业!

    Guns 快速开发平台

    Guns 基 于Spring Boot2,致力于做更简洁的后台管理系统。支持单体和微服务架构。

    • 项目地址:https://gitee.com/stylefeng/guns
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    D2Admin 企业中后台产品前端集成方案

    D2Admin 是一个完全 开源免费 的企业中后台产品前端集成方案,使用最新的前端技术栈,小于 60kb 的本地首屏 js 加载,已经做好大部分项目前期准备工作,并且带有大量示例代码,助力管理系统敏捷开发。

    • 项目地址:https://github.com/d2-projects/d2-admin
    用上这几个开源管理系统做项目,领导看了直呼专业!

    JeeSpringCloud 权限管理系统

    基于 SpringBoot2.0的后台权限管理系统界面简洁美观敏捷开发系统架构。核心技术采用 Spring、MyBatis、Shiro 没有任何其它重度依赖。互联网云快速开发框架,微服务分布式代码生成的敏捷开发系统架构。项目代码简洁,注释丰富,上手容易,还同时集中分布式、微服务,同时包含许多基础模块和监控、服务模块。

    • 项目地址:https://gitee.com/JeeHuangBingGui/jeeSpringCloud
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    BootstrapAdmin 后台管理框架

    基于 RBAC 的 Net6 后台管理框架,权限管理,前后台分离,支持多站点单点登录,兼容所有主流浏览器,内置微信、支付宝、QQ等多种登录方式,内置多种样式,可切换至 Blazor 多 Tabs 模式,权限控制细化到网页内任意元素(按钮、表格、文本框等等)

    • 项目地址:https://gitee.com/LongbowEnterprise/BootstrapAdmin
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    eladmin 后台管理系统

    EL-ADMIN (opens new window)一个基于 Spring Boot 2.1.0 、 Spring Boot Jpa、 JWT、Spring Security、Redis、Vue、Element-UI 的前后端分离的后台管理系统。

    • 项目地址:https://gitee.com/elunez/eladmin
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    FastAdmin 基于 ThinkPHP 和 Bootstrap

    FastAdmin 是一款基于 ThinkPHP 和 Bootstrap 的极速后台开发框架,基于 Auth 验证的权限管理系统,一键生成 CRUD,自动生成控制器、模型、视图、JS、语言包、菜单、回收站。

    • 项目地址:https://gitee.com/karson/fastadmin
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    Vben-Admin 中大型项目后台解决方案

    Vue-Vben-Admin 是一个基于 Vue3.0、Vite、 Ant-Design-Vue、TypeScript 的后台解决方案,目标是为开发中大型项目提供开箱即用的解决方案。包括二次封装组件、utils、hooks、动态菜单、权限校验、按钮级别权限控制等功能。项目会使用前端较新的技术栈,可以作为项目的启动模板,以帮助你快速搭建企业级中后台产品原型。

    • 项目地址:https://github.com/vbenjs/vue-vben-admin
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    smart-admin 通用型中后台解决方案

    SmartAdmin 由河南·洛阳 1024创新实验室团队研发的一套互联网企业级的通用型中后台解决方案!使用最前沿的前后台技术栈 SpringBoot 和 Vue,前后端分离,我们开源一套漂亮的代码和一套整洁的代码规范,让大家在这浮躁的代码世界里感受到一股把代码写好的清流!同时又让开发者节省大量的时间,减少加班,快乐工作,热爱生活。SmartAdmin 让你从认识到忘不了,绝对是你最想要的!

    • 项目地址:https://gitee.com/lab1024/smart-admin
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    erupt 低代码全栈类框架

    Erupt 是一个低代码 全栈类 框架,它使用 Java 注解 动态生成页面以及增、删、改、查、权限控制等后台功能。零前端代码、零 CURD、自动建表,仅需 一个类文件 + 简洁的注解配置,快速开发企业级 Admin 管理后台。高扩展性,支持 CURD 自由扩展 @DataProxy 、自定义数据源、逻辑删除、LDAP、OSS。

    • 项目地址:https://gitee.com/erupt/erupt
    用上这几个开源管理系统做项目,领导看了直呼专业!
    用上这几个开源管理系统做项目,领导看了直呼专业!

    ID:GitHubKY

    来源:开源技术专栏

  • 图文详解 Java 泛型,写得太好了!

    图文详解 Java 泛型,写得太好了!来源:iyu77.blog.csdn.net/article/details/125304857

    • 一、泛型的引入
    • 二、使用泛型的好处
    • 三、泛型常见用法
      • 1.定义泛型接口
      • 2.定义泛型集合
    • 四、泛型使用细节
      • 1.<>中类型规范
      • 2.继承性体现
      • 3.简写形式
    • 五、自定义泛型
      • 1.自定义方法使用类声明的泛型
      • 2.自定义泛型方法
      • 3.注意事项

    泛型—— 一种可以接收数据类型的数据类型,本文将通俗讲解Java泛型的优点、方法及相关细节。

    一、泛型的引入

    我们都知道,继承是面向对象的三大特性之一,比如在我们向集合中添加元素的过程中add()方法里填入的是Object类,而Object又是所有类的父类,这就产生了一个问题——添加的类型无法做到统一 由此就可能产生在遍历集合取出元素时类型不统一而报错问题。

    例如:我向一个ArrayList集合中添加Person类的对象,但是不小心手贱添加了一个Boy类的对象,这就会导致如下结果

    图文详解 Java 泛型,写得太好了!

    图片

    传统的方式不能对加入到集合ArrayList中的数据类型进行约束(不安全)遍历的时候,需要进行类型转换,如果集合中的数据量较大,对效率有影响 这就极大地降低了程序的健壮性,因此设计者针对此问题引入了泛型!

    二、使用泛型的好处

    1.提升了程序的健壮性和规范性

    针对上述问题,当我们采用泛型就会显得非常简单,只需要在编译类型后利用泛型指定一个特定类型,编译器就会自动检测出不符合规范的类并抛出错误提示

    图文详解 Java 泛型,写得太好了!

    图片

    2.编译时,检查添加元素的类型,提高了安全性

    3.减少了类型转换的次数,提高效率

    • 当不使用泛型时:

    图文详解 Java 泛型,写得太好了!

    图片
    • 当使用泛型时:

    图文详解 Java 泛型,写得太好了!

    图片

    4.在类声明时通过一个标识可以表示属性类型、方法的返回值类型、参数类型

    class Person<E> {
        E s;   //可以是属性类型
        public Person(E s) {  //可以是参数类型
            this.s = s;
        }
        public E f() { //可以是返回类型
            return s;
        }
        public void show() {
            System.out.println(s.getClass());  //显示S的运行类型
        }
    }
    

    可以这样理解:上述的class Person< E >中的“E”相当于这里的E是一个躯壳 占位用的 以后定义的时候程序员可以自己去自定义。

    就像这样

    public static void main(String[] args) {
        Person<String> person1 = new Person<String>("xxxx");// E->String
        person.show();
        Person<Integer> person2 = new Person<Integer>(123); // E->Integer
        person.show();
    }
    运行结果:
    class java.lang.String
    class java.lang.Integer
    

    三、泛型常见用法

    1.定义泛型接口

    曾经写接口的时候都没有定义泛型,它默认的就是Object类,其实这样写是不规范的!

    如果说接口的存在是一种规范,那泛型接口就是规范中的规范

    interface Im<U,R>{
        void hi(R r);
        void hello(R r1,R r2,U u1,U u2);
        default R method(U u){
            return null;
        }
    }
    

    在上述的泛型接口中已经规定传入其中的必须是U,R类的对象,那么当我们传入其他类的对象时就会报错,如图:

    图文详解 Java 泛型,写得太好了!

    图片

    根据规则,当我们实现接口时,就必须实现他的所有方法,而在这时我们就可以向<U,R>中传入我们自己规定的类。在IDEA中重写接口中的方法时,编译器会自动将<U,R>替换成我们事先规定的类。

    2.定义泛型集合

    1.使用泛型方式给HashSet中放入三个学生对象,并输出对象信息

     HashSet<Student> students = new HashSet<Student>();
     students.add(new Student("懒羊羊",21));
     students.add(new Student("喜羊羊",41));
     students.add(new Student("美羊羊",13));
     for (Student student :students) {
         System.out.println(student);
     }
    

    上述的 泛型中Student的是我事先定义好的一个类,把它放到其中作为泛型来约束传入的对象,以及在遍历时减少转型的次数提高效率

    2.使用泛型方式给HashMap中放入三个学生对象,并输出对象信息

    HashMap<String, Student> hm = new HashMap<String, Student>();
    // K-> String  V->Student与下面的对应
    hm.put("001",new Student("喜羊羊",21));
    hm.put("002",new Student("懒羊羊",32));
    hm.put("003",new Student("美羊羊",43));
    Set<Map.Entry<String,Student>> ek=hm.entrySet();
    Iterator<Map.Entry<String, Student>> iterator = ek.iterator();//取出迭代器
    while (iterator.hasNext()) {
        Map.Entry<String, Student> next =  iterator.next();
        System.out.println(next.getKey()+" - "+next.getValue());
    }
    

    [HashMap是一个双列集合,以K-V]的方式存储对象,因此在使用泛型时要向其中传入两个类型

    我们都知道使用迭代器遍历HashMap时要先通过entrySet()取出键值对,然后通过转型得到对应的类来得到对象信息。而在使用泛型定义[K-V]就规定了取出的键值对的类型,所以就省去了转型这一步骤,同样也使程序变得简单,高效。

    四、泛型使用细节

    1.<>中类型规范

    图文详解 Java 泛型,写得太好了!

    图片

    2.继承性体现

    在给泛型指定具体类型后,可以传入该类型或者其子类类型

    P<A> ap = new P<A>(new A());
    P<A> ap1 = new P<A>(new B()); //A的子类
    class A {}
    class B extends A{}
    

    3.简写形式

     P<A> ap = new P(new A());
    

    五、自定义泛型

    1.自定义方法使用类声明的泛型

    在形参列表中传入的数据类型与泛型不一致时会报错,体现规范性

    public static void main(String[] args) {
        U<String, Double, Integer> u = new U<>();
        u.hi("hello", 1.0);  //X->String Y->Double
    }
    class U<X, Y, Z> {
        public void hi(X x, Y y) {} //使用类声明的泛型
    }
    

    2.自定义泛型方法

    public static void main(String[] args) {
        U<String, Double, Integer> u = new U<>();
        u.m1("xx",22);
        //当调用方法时,传入参数编译器会自己确定类型 会自动装箱
    }
    class U<X, Y, Z> {
        public <X,Y> void m1(X x,Y y){} //自定义泛型方法
    }
    

    这里的自动装箱很有意思,他是在三个类型中自动匹配当前输入的数据类型,也不用考虑顺序问题,如图所示

    图文详解 Java 泛型,写得太好了!

    图片

    3.注意事项

    ①泛型数组不能初始化,因为数组在 new 不能确定A 的类型,就无法在内存开空间

    错误写法: A[] a=new A[];

    ②静态方法不能使用类定义的泛型

    图文详解 Java 泛型,写得太好了!

    图片

    原因是静态成员是和类相关的,在类加载时,对象还没有创建所以,如果静态方法和静态属性使用了泛型,JVM就无法完成初始化。