Java课程大纲(个人整理)

在无清风

已于 2022-12-01 09:02:20 修改

阅读量1.1k

点赞数 4

分类专栏： springboot springcloud java基础文章标签： java spring

于 2022-11-28 11:19:18 首次发布

本文链接：https://blog.csdn.net/qq_53573029/article/details/128075546

版权

springboot 同时被 3 个专栏收录

8 篇文章 0 订阅

订阅专栏

java基础

6 篇文章 0 订阅

订阅专栏

springcloud

4 篇文章 0 订阅

订阅专栏

Java课程大纲

（未写完，后续会继续更新和修改，如有错误请私聊斧正）

思维导图的图片：http://assets.processon.com/chart_image/631aefeae0b34d59536069f2.png

个人更推荐看导图密码（WZG6）：Java课程大纲 | 173649_PO | 思维导图（新） | ProcessOn

Java Sc核心基础
- Java入门基础
  - JDK,JRE,JVM区别与联系
    - 区别
      - JDK：java开发工具包，针对Java开发人员，可以编译运行Java程序
        JDK是Java的核心,包含运行Java运行环境(JRE)和一些Java工具及Java基础类库。
      - JRE：java运行时环境，针对使用java程序的客户，可以运行字节码（.class），但不能编译Java源码
        JRE是Java运行环境,所有Java程序必须依赖JRE才能运行.只有JVM是不能运行字节码文件的(.class),因为解释的字节码的时候需要lib库. JRE里面有两个文件夹bin/,lib/。bin/就是JVM,lib就是JVM所需要库。JVM+lib=JRE
      - JVM：用来执行解释执行字节码文件（.class），但不能正确的执行
        JVM是JRE的一部分,是虚拟出来的一台计算机.通过实体计算机仿真各种计算功能来实现,JVM有自己完善的硬件架构,如处理器,堆栈,寄存器等,还有相应的指令集.JVM是Java跨平台的核心,Java程序通过JVM的跨平台,从而使Java程序跨平台.Java程序首选会被编译成字节码文件(.class),JVM的核心任务就是解释字节码文件(.class)并映射到真实CPU指令集或者系统调用.JVM不关系上层Java程序,只关系字节码(.class).
    - 联系
      - JDK包含JRE，JRE包含JVM
  - 单行和多行注释的使用
    - 单行注释
      - //
    - 多行注释
      - /**/
  - 关键字，标识符
    - 标识符
      - 标识符由数字(0~9)和字母(A~Z和a~z)，美元符号($)，下划线(_)以及Unicode字符集种符号大于0xC0的说有符号组合构成(各符号之间没有空格)
      - 标识符的第一个符号为字母，下划线和美元符，后面可以是任何字母，数字，美元符号或下划线。
    - 关键字
      - 数据类型
        boolean
        布尔型
        该类型只有两个字面值：true和false
        int
        long
        short
        byte
        float
        double
        char
        class
        interface
      - 流程控制
        if
        else
        do
        while
        for
        switch
        case
        default
        break
        continue
        return
        try
        catch
        finally
      - 修饰符
        public
        protected
        private
        final
        void
        static
        strict
        abstract
        synchronized
        volatile
        native
      - 动作
        package
        import
        throw
        throws
        extends
        implements
        this
        supper
        instanceof
        new
      - 保留字
        true
        false
        null
        goto
        const
  - 变量，数据类型，运算符
    - 变量定义
      - String name="张三";
    - 数据类型
      - 整型
        字节型
        byte
        1字节8位
        短整型
        short
        2字节16位
        整型
        int
        4字节32位
        长整型
        long
        8字节64位
      - 浮点型
        单浮点型
        float
        4字节32位浮点数
        双浮点型
        double
        8字节64浮点数
      - 字符型
        char
      - 布尔型
        boolean（true，false）
      - 字符串型
        一串字符
    - 运算符
      - 表达式就是符号（如加号，减号）与操作数（如b，3等）的组合
      - 算数运算符
        基本的算数运算符
        +、-、*、/、%、++、- -
        复合算数运算符
        +=、-=、*=、/=、%=
      - 关系运算符
        ==
        等于
        ！=
        不等于
        >
        大于
        <
        小于
        >=
        大于等于
        <=
        小于等于
      - 逻辑运算符
        &&
        与
        两个为真才是真，由一个为假则是假
        ||
        或
        有一个为真就是真，两个为假则是假
        ^
        非
        取反
      - 条件运算符
        条件？表达式1：表达式2
        ？：表达式的取决于条件的计算结果。如果条件为真，则表达式1的值，且表达式1的计算结果则为整个？：表达式的值。如果表达式的值。如果表达式1为假，则计算表达式2的值，表达式2的计算结果为整个？：表达式的值
        ？被称为三元运算符，因为它需要三个操作数
  - 分支语句（if，switch）
    - if
      - 在某些情况下，需要当某一条件满足时才执行响应代码，条件不满足则执行其他代码。
      - 分支
        单分支
        if (布尔表达式) {//布尔表达式为true时需执行的代码;}
        双分支
        if (布尔表达式) {         //布尔表达式为true时需执行的代码;   }else {         //布尔表达式为false时需执行的代码; }
        多分支
        if（布尔表达式1）｛        //布尔表达式1为true时执行的代码｝else if（布尔表达式2）｛        //布尔表达式1为false但是布尔表达式2为true时执行的代码｝else if（布尔表达式3）｛        //布尔表达式1和布尔表达式2为false但是布尔表达式3为true时执行的代码｝else｛        //布尔表达式1、布尔表达式2和布尔表达式3均为false时执行的代码｝
        嵌套if
        if（布尔表达式1)｛       //布尔表达式1为true时执行的代码       if（布尔表达式2)｛           //布尔表达式1和布尔表达式2均为true时执行的代码      ｝else｛            //布尔表达式1为true，但布尔表达式2均为false时执行的代码      ｝｝else ｛       //布尔表达式1为false时执行的代码｝
    - switch
      - switch分支与发放
        switch (date){ case 1: System.out.println("星期一"); break; //break结束当前switch,return结束当前方法 case 2: System.out.println("星期二"); default: //当以上条件均不满足时执行default System.out.println("###"); }
  - 循环语句（for，forEach，while，do...while）
    - for
      - 先判断后执行
        for(int x = 10; x < 20; x = x+1) { System.out.print("value of x : " + x ); System.out.print("\n"); }
    - forEach
      - for(类型变量名:集合) { 语句块;}
        int [] numbers = {10, 20, 30, 40, 50}; for(int x : numbers ){ System.out.print( x ); System.out.print(","); }
    - while
      - 先判断后执行
        while( x < 20 ) { System.out.print("value of x : " + x ); x++; System.out.print("\n"); }
    - do...while
      - 线执行在判断
        do{ System.out.print("value of x : " + x ); x++; System.out.print("\n"); }while( x < 20 );
  - 特殊流程控制continuc，brcak使用
    - break
      - 作用于循环中，表示跳出当前循环
    - continue
      - 作用于循环中，表示跳过当前循环剩余的部分，进入到下一次循环
    - return
      - 作用于方法中，表示结束该方法
  - 数组的简介及作用
    - 简介
      - 数组可以把一组相关的数据一起存放，并提供方便的访问（获取）方式；
      - 数组是指一组数据的集合，其中的每个数据被称作元素，在数组中可以存放任意类型的元素。数组时一种将一组数据存储在单个变量名下的优雅方式
    - 作用
  - 数组的创建及基本语法
    - 语法
      - 数据类型 [] 数组名字 int[] a;数据类型数组名字 [] int a[];
    - 创建
      - 声明数组的同时，根据指定的长度分配内存，单数组中元素值都为默认的初始化值；（动态创建）
        Int[] ary0 = new int[10];//创建一个长度为10的连续空间。
      - 声明数组并分配内存，同时将其初始化；
        int[] ary1 = new int[]{1,2,3,4,5};
      - 与前一种方式相同，仅仅只是语法相对简略；
        int[] ary2 = {1,2,3,4,5};
  - 数组元素的获取和遍历
    - 遍历
      - 使用for循环
        for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); }
    - 获取
      - int num = arrayC[3];
  - 数组的排序算法（冒泡排序法）
    - 冒泡排序
      - int[] numbers=new int[]{1,5,8,2,3,9,4}; //需进行length-1次冒泡 for(int i=0;i<numbers.length-1;i++) { for(int j=0;j<numbers.length-1-i;j++) { if(numbers[j]>numbers[j+1]) { int temp=numbers[j]; numbers[j]=numbers[j+1]; numbers[j+1]=temp; } } } System.out.println("从小到大排序后的结果是:"); for(int i=0;i<numbers.length;i++) System.out.print(numbers[i]+" "); }
- Java面向对象
  - 面向对象和面向过程概述
  - 面向对象的三大特征
  - 类和对象
  - 成员变量使用
  - 方法的四要素及方法重载
  - 构造器特征
  - 信息的封装和隐藏
  - 访问修饰符
  - package/import语句
  - 类的继承
  - 方法重写，重写与重载的区别
  - 方法参数的传递
  - 值传递和引用地址传递
  - 多态
  - Object简介及相关方法使用
  - this，super，abstract，static，final关键字
  - 抽象类
  - 接口
- Java常用包与类
  - API帮助文档使用
  - java long，java util，java io, java net, java,sql包
  - 八种基本类型对应的包装类使用
  - String类，StringBuffer类，StringBuilder类
  - Date类，DateFormat类，Calendar类
  - Math类，Random类
  - Biginteger类，BigDecimal
- Java集合，IO
  - java异常概述
  - 处理机制
  - try...catch...finally
  - throw，throws
  - Java集合概述
  - Collection接口，List接口，Set接口
  - List接口的学习，Set接口的学习，TreeSet排序
  - Map接口
  - Collections工具类
  - 泛型
  - 迭代器
  - IO概述
  - File类
  - IO分类，InputStrcam，OutputStrcam
  - Beade，Writcr
  - 对象序列化和反序列化
- Java高级
  - 线程的概述
  - 线程的创建与启动（Thread）
  - 线程的创建与启动（Runnable）
  - 线程的常用方法
  - 线程的生命周期
  - 线程同步Lock
  - 线程的调度和通信
  - 生产者和消费者模式
  - 线程池
  - 枚举
  - 反射
  - 注解
  - XML的基本语法
  - 网络编程的概述及作用
  - TCP/IP模型
  - Socket和ServerSocket
- 数据库（mySQL）
  - 数据库常用语句
    - 查看所有的数据库
      - show databases
    - 创建数据库
      - create database 数据库命;
    - 删除数据库
      - drop database 数据库名;
    - 选择数据库use数据库名
      - use 库名;
    - 显示数据库中所有的表
      - show tables;
    - 创建一张表
      - 当前键值不能为空
        NOT NULL
      - 默认值为null
        DEFAULT NULL
      - 字段为int类型且占用11位
        INT(11)
      - 位当前字段添加备注
        COMMENT'备注内容'
      - 设置为主键,同时设置为外键约束
        PRIMARY KEY(ID)
      - 设置数据库引擎为innodb并且默认编码方式为UTF-8.
        ENGINE = INNODB DEFAULT CHARSET = UTF8;
    - 显示表中字段
      - desc 表名;
        desc user1
    - 删除表
      - drop table 表名;
        drop table user1;
    - 查看数据库的详细信息
      - show create database 库名;
        show create database user1;
    - 操作表的结构常用指令
      - 修改字段的类型
        alter table 表名 modify 字段字段类型;
        alter table user1 modify age int(11);
      - 添加新字的字段
        alter table 表名 add 字段字段类型;
        alter table user add age int(8);
      - 添加字段到指定位置后
        alter table 表名 add 字段字段类型 after 字段；
        alter table user add sex int(8) after age;
      - 删除表中字段
        alter table 表名 drop 字段;
        alter table user drop sex;
      - 修改指定的字段
        alter table 表名 change 原字段名新字段名字段的类型;
        alter table user change uid userid int(8);
    - 操作表中数据的常用指令
      - 增加数据
        insert into 表名 value(值1，值2，值3)；
        insert into user1 value (1,'root','root');
        insert into 表名(字段1,字段2,字段3) value (值1,值2,值3,);
        insert into user1(id,username,password) values (2,'admin','admin');
        insert into 表名(字段1,字段2,字段3) value (值1,值2,值3),(值1,值2,值3);
        insert into user1(id,username,password) values (3,'Alascanfu','123456'),(4,'phone','7900');
      - 删除数据
        delete from 表名 where 字段 = 值;
        delete from user1 where id = 2;
        delet from 表名
        delet from user1;
      - 更新数据
        update 表名 set 字段1 = 值1，字段2 = 值2 where 字段3 = 值3；
        update user1 set password = '123' where id = 3;
      - 查询数据
        select * from 表名；
        select * from user1;
        select 字段 from 表名；
        select username from user1;
        select 字段1 from 表名 where 字段2 = 值；
        select username from user1 where password = 123;
      - 排序查询
        select * from 表名 order by 字段排序关键词（desc 降序 \ asc 升序）
        select * from user1 order by id desc;
        多字段排序
        select 字段 from 表名 order by 字段1 desc/asc, 字段2 desc/asc....;
        select * from user1 order by id desc,password asc;
      - 常用函数查询
        去重 distinct()
        select distinct 字段 = 值 from 表名;
        select distinct username = 'phone' from user1;
        统计总数 sum()
        select sum(字段) as 显示名(课随便设置) 库名
        select sum(password) as sum_ from user1;
        计算个数 count()
        select count(字段) from 表名;
        select count(*) from user1;
        平均数 avg()
        select avg(字段) as 查询命名 from 表名；
        select avg(id) as id_avg from user1;
        最大值 max()
        select max(字段) from 表名；
        select max(id) from user1;
        最小值 min()
        select min(字段) from 表名
        select min(id) from user1;
  - mysql查询，mysql多表查询https://blog.csdn.net/fuijiawei/article/details/122432727
    - 关联查询
      - select user.username,role.name,role.nameZh from user,role,user_role where user.id = user_role.uid and user_role.rid = role.id;
    - 内链接
      - inner join
      - 内链接时一种映射关系，如果两张表都存在相同的内容，则回显示出来。(在数学中一般称为“交集”)
      - select 表名1.字段1 as A_PK, 表名.字段2 as A_Value,表名2.字段1 as B_PK,表名2.字段2 as B_Valuefrom 表名1 快捷表名inner join 表名2 快捷表名on 表名1.字段1 = 表名2.字段1;
        通过字段1进行来连接
        select a.pk as A_PK,a.value as A_Value,b.pk as B_PK,b.Value as B_Value -> from table_a a -> inner join table_b b -> on a.pk=b.pk;
        table_a 用a代替，table_b用b代替连接使用table_a的pk和table_b的pk作为连接的基础经行连接
    - 左连接
      - select 表名1.字段1 as A_PK, 表名.字段2 as A_Value,表名2.字段1 as B_PK,表名2.字段2 as B_Valuefrom 表名1 快捷表名left join 表名2 快捷表名on 表名1.字段1 = 表名2.字段1;
        select a.pk as A_PK,a.value as A_Value,b.pk as B_PK,b.Value as B_Value -> from table_a a -> left join table_b b -> on a.pk = b.pk;
    - 右连接
      - select 表名1.字段1 as A_PK, 表名.字段2 as A_Value,表名2.字段1 as B_PK,表名2.字段2 as B_Valuefrom 表名1 快捷表名right join 表名2 快捷表名on 表名1.字段1 = 表名2.字段1;
        select a.pk as A_PK,a.value as A_Value,b.pk as B_PK,b.Value as B_Value -> from table_a a -> right join table_b b -> on a.pk = b.pk;
    - 全连接
      - select 表名1.字段1 as A_PK, 表名.字段2 as A_Value,表名2.字段1 as B_PK,表名2.字段2 as B_Valuefrom 表名1 快捷表名left join 表名2 快捷表名on 表名1.字段1 = 表名2.字段1unionselect 表名1.字段1 as A_PK, 表名.字段2 as A_Value,表名2.字段1 as B_PK,表名2.字段2 as B_Valuefrom 表名1 快捷表名right join 表名2 快捷表名on 表名1.字段1 = 表名2.字段1;
        select a.pk as A_PK,a.value as A_Value,b.pk as B_PK,b.Value as B_Value -> from table_a a -> left join table_b b -> on a.pk = b.pk -> union -> select a.pk as A_PK,a.value as A_Value,b.pk as B_PK,b.Value as B_Value -> from table_a a -> left join table_b b -> on a.pk = b.pk;
        就是在左连接和右连接中间加一个union全连接 = 左连接+右连接+去重（union）
    - 左连接不包含内连接（左表独有数据）
      - select 表名1.字段1 as A_PK, 表名.字段2 as A_Value,表名2.字段1 as B_PK,表名2.字段2 as B_Valuefrom 表名1 快捷表名left join 表名2 快捷表名on 表名1.字段1 = 表名2.字段1where b.value is null;
        select a.pk as A_PK,a.value as A_Value,b.pk as B_PK,b.Value as B_Value -> from table_a a -> left join table_b b -> on a.pk = b.pk -> where b.value is null;
    - 右连接不包含内连接(右表独有数据)
      - select 表名1.字段1 as A_PK, 表名.字段2 as A_Value,表名2.字段1 as B_PK,表名2.字段2 as B_Valuefrom 表名1 快捷表名right join 表名2 快捷表名on 表名1.字段1 = 表名2.字段1where b.value is null;
        select a.pk as A_PK,a.value as A_Value,b.pk as B_PK,b.Value as B_Value -> from table_a a -> right join table_b b -> on a.value = b.value -> where a.pk is null;
    - 外连接|全连接不包含内连接（全集-交集=两集各不同的数据）
      - select 表名1.字段1 as A_PK, 表名.字段2 as A_Value,表名2.字段1 as B_PK,表名2.字段2 as B_Valuefrom 表名1 快捷表名left join 表名2 快捷表名on 表名1.字段1 = 表名2.字段1where 表名2.字段1 is nullunion allselect * from 表名1 快捷表名right join 表名2 快捷表名 on 表名1.字段1 = 表名2.字段1where 表名1.字段1 is null;
        select a.pk as A_PK,a.value as A_Value,b.pk as B_PK,b.value as B_Value -> from table_a a -> left join table_b b -> on a.pk = b.pk -> where b.pk is null -> union all -> select * from table_a a right join table_b b on a.pk = b.pk where a.pk is null;
      - select 表名1.字段1 as A_PK, 表名.字段2 as A_Value,表名2.字段1 as B_PK,表名2.字段2 as B_Valuefrom 表名1 快捷表名left join 表名2 快捷表名on 表名1.字段1 = 表名2.字段1where 表名2.字段1 is nullunion allselect * from 表名1 快捷表名right join 表名2 快捷表名 on 表名1.字段1 = 表名2.字段1where 表名1.字段1 is null;
        select a.pk as A_PK,a.value as A_Value,b.pk as B_PK,b.Value as B_Value -> from table_a a -> left join table_b b -> on a.value = b.value -> where b.pk is null -> union all -> select * from table_a a right join table_b b on a.value = b.value where a.pk is null;
  - 子查询，分组，排序，分页查询
    - 分组数据查询
      - group by
        分组，就是将相同的分到一组，或者说融合；
      - having
        筛选相当与一个if(判断)
      - select 字段1，字段2，字段3，from 表名 group by password habving 判断条件;
        select id,password,username from user1 group by password having id > 2;
    - 分页数据查询
      - select * from 表名 limit 偏移量，数量；
        不写偏移量的话就是默认的为0实现分页的时候必须写偏移量偏移量怎么计算？:limit (n-1)*数量 ,数量
        select * from user1 limit 2,3;
        从第二个开始，显示后面三个数据
  - mysql事务，事务的ACID
    - ACID，是指数据库管理系统（DBMS）在写入或更新资料的过程中，为保证事务（transaction）是正确可靠的，所必须具备的四个特性：原子性（atomicity，或称不可分割性）、一致性（consistency）、隔离性（isolation，又称独立性）、持久性（durability）。https://blog.csdn.net/dengjili/article/details/82468576
      - 原子性（Atomicity）
        原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
      - 一致性(Consistency)
        事务前后数据保持一致
      - 隔离性(Isolation)
        事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
      - 持久性(Durability)
        持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响
  - myslq索引https://developer.aliyun.com/article/831250
    - 索引分类
      - 主键索引(primary key)
        设定为主键后，数据库自动建立索引，InnoDB为聚簇索引，主键索引列值不能为空(Null)。
      - 唯一索引
        索引列的值必须唯一，单允许有空值(Null),单只允许有一个空值(Null)。但只允许有一个空值(Null)。
      - 复合索引
        一个索引可以包含多个列，多个列共同构成一个复合索引。
      - 全文索引
        Full Test(MySQL5.7之前，只有MYISAM储存引擎支持全文搜索)。全文索引类型为FULLTEXT，在定义索引的列上支持值的全文查找允许在这些索引列中查找重复值和空值，全文索引可以在Char，VarChar上创建
      - 空间索引
        MySQL在5.7之后的版本支持OpenGIS几何数据模型，MySQL在空间索引这方面遵循OpenGIS几何数据模型规则。
      - 前缀索引
        在文本类型为char，varchar，text类列上创建索引时，可以指定索引列的长度，但是数值类型不能指定。
    - 索引的优缺点
      - 优点
        大大提高数据查询速度
        可以提高数据检索的效率，降低数据的io成本，类似于书的目录
        可以通过索引对数据进行排序，降低数据的排序成本降低了CPU的消耗
        被索引的列会自动进行排序，包括(单列索引)和(组合索引)，只是组合索引的排序需要复杂一些。
        如果按照索引列的循序尽心排序，对order不用语句来说，效率就会提高很多。
      - 缺点
        索引会占据磁盘空间。
        索引虽然会提高查询效率，但是会降低更新表的效率，比如每次对表进行增删改查操作，MySQL不仅要保持数据还有保存或者更新对应的索引文件。
        维护索引需要消耗数据库资源。
      - 综合索引的优缺点
        数据库中不是索引越多越好，而是仅为那些常用的搜索字段建立索引效果最佳！
    - 索引语句
      - 查看索引
        show index from 表名；
        show index from user1;
      - 创建索引
        创建主键索引
        字段类型 primary key
        id int primary key,
        创建单例索引
        create index 索引名(自定义) on 表名(字段)；
        create index password_index on user1(password);
        创建唯一索引
        create unique index 索引名(自定义) on 表名(字段);
        create unique index img1_index on java1(img1);
        创建复合索引
        create index 索引名(自定义) on 表名(字段1，字段2)；
        create index user_pass_index on user1(username,password)；
        满足复合索引的查询的两大原则
        加入创建的复合索引为三个字段，按顺序分表是(name,age,sex);
        在查询时能利用复合索引的查询条件如下
        最左前缀原则(如下四种都满足条件)
        select * from user where name = ? select * from user where name = ? and age = ?select * from user where name = ? and sex = ?select * from user where name = ? and age = ? and sex = ?
        如下是不满足最左前缀条件(但是不是全部都不生效，如下解释)
        select * from user where name = ? and sex = ? and age = ?select * from user where age = ? and sex = ? and name = ?select * from user where sex = ? and age = ? and name = ?select * from user where age = ? and sex = ?…………等等
        MySQL引擎在执行查询时，为了更好利用索引，在查询过程中会动态调整查询直段的顺序！(也就是说，当条件中的字段全部达到复合索引中的字段时，可以动态调整字段顺序，使起满足最左前缀)
        #可以使用复合索引：索引中包含的字段数都有，只是顺序不正确，在执行的时候可以动态调整为最前左缀select * from user where sex = ? and age = ? and name = ?select * from user where age = ? and sex = ? and name = ?#不可以使用复合索引：因为缺少字段，并且顺序不正确select * from user where sex = ? and age = ? select * from user where age = ? and name = ?select * from user where age = ?select * from user where sex = ?
索引的数据结构
- MySQL索引使用数据结构主要有B-Tree索引和hash索引。https://blog.csdn.net/yb546822612/article/details/108659260
  - Hash索引
    - 优点
      - Hash 索引结构的特殊性，其检索效率非常高，索引的检索可以一次定位，不像B-Tree 索引需要从根节点到枝节点，最后才能访问到页节点这样多次的IO访问，所以 Hash 索引的查询效率要远高于 B-Tree 索引。
    - 缺点
      - Hash索引仅仅能满足"=","IN"和"<=>"查询，不能使用范围查询。
      - Hash索引无法被用来避免数据的排序操作。
      - Hash素银不能利用部分索引键查询。
      - Hash索引在任何时候都不能避免表扫描。
      - Hash索引遇到大量Hash值相等的情况后性能并不一定就会比B-Tree索引高。
  - B-Tree索引
    - 优点
      - B-Tree 索引是 MySQL 数据库中使用最为频繁的索引类型，除了 Archive 存储引擎之外的其他所有的存储引擎都支持 B-Tree 索引。不仅仅在 MySQL 中是如此，实际上在其他的很多数据库管理系统中B-Tree 索引也同样是作为最主要的索引类型，这主要是因为 B-Tree 索引的存储结构在数据库的数据检索中有非常优异的表现。
  - B-tree和hash性能比较
    - 10万*30万数据查询，member_id,buyer_id均加了索引
      - 执行引擎InnoDB,索引类型btree
        使用时间：5.025s
      - 执行引擎MEMORY,索引类型hash
        使用时间：3.742s
- mysql索引与引擎关系
  - 存储引擎，允许索引类型
    - InnoDB
      - BTREE
    - MyISAM
      - BTREE
    - MEMORY/HEAP
      - HASH,BTREE
    - NDB
      - HASH,BTREE(see note in text)
- 对于哈市索引来说，底层的数据结构就是哈希表，因此在绝大多数需求为单条记录查询的时候，可以选着哈希索引，查询性能最快；其余大部分场景建议选着BTree索引。
JDBC的学习
- 自己之前有写过
  - https://blog.csdn.net/qq_53573029/article/details/123907172?spm=1001.2014.3001.5502
myslq优化https://blog.csdn.net/zhangbijun1230/article/details/81608252
- 选取最适用的字段属性
  - 不用设置过多的字段空间
    - 如邮政编码，设置为char(255)就明显多了，可以直接设置为char(6)就可以了
    - 应该尽量把字段设置为NOTNULL，这样在将来执行查询的时候，数据库不用去比较NULL值
    - 对于某些文本字段，例如“省份”或者“性别”，我们可以将它们定义为ENUM类型。因为在MySQL中，ENUM类型被当作数值型数据来处理，而数值型数据被处理起来的速度要比文本类型快得多。这样，我们又可以提高数据库的性能。
- 使用连接(JOIN)来代替子查询(Sub-Queries)
  - MySQL从4.1开始支持SQL的子查询。这个技术可以使用SELECT语句来创建一个单列的查询结果，然后把这个结果作为过滤条件用在另一个查询中。例如，我们要将客户基本信息表中没有任何订单的客户删除掉，就可以利用子查询先从销售信息表中将所有发出订单的客户ID取出来，然后将结果传递给主查询，
- 使用联合(UNION)来代替手动创建临时表
  - MySQL从4.0的版本开始支持union查询，它可以把需要使用临时表的两条或更多的select查询合并的一个查询中。在客户端的查询会话结束的时候，临时表会被自动删除，从而保证数据库整齐、高效。使用union来创建查询的时候，我们只需要用UNION作为关键字把多个select语句连接起来就可以了，要注意的是所有select语句中的字段数目要想同
- 事务
  - 尽管我们可以使用子查询（Sub-Queries）、连接（JOIN）和联合（UNION）来创建各种各样的查询，但不是所有的数据库操作都可以只用一条或少数几条SQL语句就可以完成的。更多的时候是需要用到一系列的语句来完成某种工作。但是在这种情况下，当这个语句块中的某一条语句运行出错的时候，整个语句块的操作就会变得不确定起来。设想一下，要把某个数据同时插入两个相关联的表中，可能会出现这样的情况：第一个表中成功更新后，数据库突然出现意外状况，造成第二个表中的操作没有完成，这样，就会造成数据的不完整，甚至会破坏数据库中的数据。要避免这种情况，就应该使用事务，它的作用是：要么语句块中每条语句都操作成功，要么都失败。换句话说，就是可以保持数据库中数据的一致性和完整性。事物以BEGIN关键字开始，COMMIT关键字结束。在这之间的一条SQL操作失败，那么，ROLLBACK命令就可以把数据库恢复到BEGIN开始之前的状态
    - insert into 表名(字段1,字段2,字段3) value (值1-1，值1-2，值1-3),(值2-1，值2-2，值2-3);commit;
      - insert into user1(id,username,password) value (6,'caca',3223),(7,'baii',367890);commit;
- 锁定表
  - 尽管事务是维护数据库完整性的一个非常好的方法，但却因为它的独占性，有时会影响数据库的新能，尤其是在很大的应用系统中，由于在事务执行过程中，数据库将会被锁定，因此其它的用户请求只能暂时等待直到该事务结束。如果一个数据库系统只有少数几个用户来使用，事务造成的影响不会成为一个太大的问题；但假设有成千上万的用户同是访问一个数据库系统，列如访问一个电子商务网站，就会产生比较严重的响应延迟。
  - 具体操作
- 使用外键
  - 锁定表的方法可以维护数据的完整性，但是它却不能保证数据的关联性。这个时候我们就可以使用外键。
  - 具体操作
- 使用索引
  - 索引是提高数据库性能的常用方法，它可以令数据库服务器以比没有索引快得多的速度检索特定的行，尤其是在查询语句当中包含有MAX(),MIN()和ORDERBY这些命令的时候，性能提高更为明显。
  - 该对哪些字段建立索引？
    - 一般说来，索引应建立在那些将用于JOIN,WHERE判断和ORDERBY排序的字段上。尽量不要对数据库中某个含有大量重复的值的字段建立索引。对于一个ENUM类型的字段来说，出现大量重复值是很有可能的情况
- 优化得查询语句
  - 绝大多数情况下，使用索引可以提高查询的速度，但如果SQL语句使用不恰当的话，索引将无法发挥它应有的作用。
  - 注意的几个方面
    - 第一：最好是在相同类型的字段间进行比较的操作
    - 第二：在建有索引的字段上尽量不要使用函数进行操作
    - 第三：在搜索字符型字段时，我们有时会使用LIKE关键字和通配符，这种做法虽然简单但时以牺牲系统新能为代价的
- 优化方案
  - 1.对查询进行优化，要尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。
  - 2.应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，最好不要给数据库留NULL，尽可能的使用 NOT NULL填充数据库.备注、描述、评论之类的可以设置为 NULL，其他的，最好不要使用NULL。
  - 3.应尽量避免在 where 子句中使用 != 或 <> 操作符，否则将引擎放弃使用索引而进行全表扫描。
  - 4.应尽量避免在 where 子句中使用 or 来连接条件，如果一个字段有索引，一个字段没有索引，将导致引擎放弃使用索引而进行全表扫描，
- 数据链接池
- 手写ORM
web前端
- HTML+CSS
  - HTML基本标签使用
  - 表格及表单标签
  - DIV标签
  - CSS的学习
  - CSS常用选择器
  - CSS常用样式表
  - CSS盒子模型
  - CSS布局，浮动
  - H5+CSS新特性
- JavaScript+Jquery
  - JavaScript的概述
  - JavaScript基础语法
  - JavaScript函数
  - JavaScript的DOM编程
  - 定时器，考试
  - JQuery的概述
  - JQuery的基本选择器，属性选择器，过滤选择器
  - JQuery数组的迭代
  - JQuery的常用方法find(),children(),parent()
  - JQuery操作dom
  - JQuery表单验证
  - 正则表达式
  - JSON概述与使用
  - JSON字符串与JSON对象互相转换
  - JSON循环遍历
  - FastJSON使用
- Layui
  - Layui的初步认识
  - Layui栅格布局
  - LayUI常用的页面元素（颜色，图标，按钮，导航）
  - Laycr弹出层
  - 日期与时间选择
  - 分页组件
  - 文件上传
  - 模板引擎
  - 表单
  - 数据表格
javaEE 企业级开发
- Java Web环境搭建
  - Tomcat服务的安装与使用
  - Tomcat目录结构
  - Tomcat项目发布
  - Tomcat启动与关闭
  - Tomcat整合IDEA
  - Maven简介与概述
  - Maven下载安装及环境变量搭建
  - Maven本地仓库配置
  - Maven配置阿里云镜像
  - Maven常用的命令
  - Maven项目的目录结构
  - Maven整合IDEA
- JSP+Servlet
  - Servlet的概述及作用
  - Servlet的三种创建方式
  - Servlet的生命周期
  - HttpServletRequest，HttpServletResponse对象
  - Servlet参数的接收和编码处理
  - Servlet请求转发和重定向
  - 会话技术（Cookie/Session）
  - Servlet三大域对象
  - JSP概述及作用
  - JSP组成部分
  - JSP的执行原理
  - JSP九大内置对象
  - JSP四大域对象
  - EL表达式
  - JSTL标签
  - 监听器(Listener)域过滤器(Filter)
  - Ajax概述及原理
  - Ajax常用的实现方法
- 项目
  - 使用：Servlet+JDBC+DBUtils+C3P0+Maven+Layui实现RBAC项目实战
Java EE 高级框架阶段
- Mybatis
  - ORM及MyBatis概述
    - ORM思想
      - 对象关系映射（Object Relational Mapping，简称，ORM）：是一种为了解决面向对象与关系数据库存在的互不匹配的问题的技术。
      - 简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将Java程序中的对象自动持久化到关系数据库中
    - 常见的ORM框架
      - JPA：本身是一种ORM规范，不是ORM框架，由各大ORM框架提供实现。（类似日志门面Slf4j）
        Hibernate
        以前最流行的ORM框架
        MyBatis
        是目前最受欢迎的持久层ORM框架
        概述
        MyBatis是一款优秀的持久层框架
        它支持定制化SQL，存储过程以及高级映射
        MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集
        MyBatis可以使用简单的XML或注解来配置和映射原生类型，接口和Java的POJO(Plain Old Java Objects,普通老式Java对象)为数据库中的记录。
- 理解Mybatis的实现原理
  - 对比
    - JDBC有四个核心对象：
      - 1.DriverManager
        用于注册数据库连接
      - 2.Connection
        与数据库连接对象
      - 3.Statement/PrepareStatement
        操作数据库SQL语句的对象
      - 4.ResultSet
        结果集或一张虚拟表
    - Mybatis也有四个核心对象：
      - 1.SqlSession对象
        该对象中包含了执行SQL语句的所有方法。类似于JDBC里面的Connection
      - 2.Executor接口
        它将根据SqlSession传递的参数动态地生成需要执行地SQL语句，同时负责查询缓存的维护。类似于JDBC里面地Statemnt/PrepareStatemnt
      - 3.MappedStatement对象
        该对象是对映射SQL的封装，用于存储映射的SQL语句的id,参数等信息
      - 4.ResultHandler对象，用于返回的结果进行处理，最终得到自己想要的数据各式或类型。可以自定义返回类型
- Mybatis入门配置
  - 1.在maven中构建配置文件
    - <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.11</version> </dependency>
- 基本的CRUD操作
- 核心配置文件及Mapper.xml详解
- Dao层开发及常用规则
- 动态Sql使用
- 一对多，多对一的关系处理
- 一级缓存和二级缓存说明及使用
- 分页的实现及插件PageHelper的使用
- generator逆向工程使用
Spring
- Spring框架介绍
- IOC/DI解偶合及实现原理
- Spring的配置详解
- SpringAOP与动态代理
- AOP具体实现（XML和注解）
- Spring-JdbcTemplete
- Spring编程式事务与申明事务管理
- Spring源码解析
Spring MVC
- MVC设计模式
- Spring MVC概述和入门
- Spring MVC的执行原理及运行流程
- Spring MVC数据绑定
- Spring MVC视图的跳转，往域对象传值
- Spring MVC常用的注解
- Spring MVC和Ajax通过JSON进行互交
- Spring MVC+Restful+相关注解实现
- Spring MVC上传文件/下载文件
- 拦截器的创建于配置
- I18N国际化实现
- SpringBoot自定义starters
SpringBoot
- SpringBoot简介于入门
- Spring和SpringBoot对比和介绍
- SpringBoot的配置类和配置文件
- SpringBoot核心开发
- SpringBoot整合Web开发
- SpringBoot整合日志
- SpringBoot整合缓存
- SpringBoot与安全
- SpringBoot跨域请求
- SpringBoot Stater原理
- SpringBoot自定义starters
- SpringBoot的注解使用和作用
  - @SpringBootApplication
    - 这个注解是SpringBoot最核心的注解，用在SpringBoot的主类上，标识这是一个Springboot应用，用来开启SpringBoot的各项能力。实际上这个注解是@Configuration，@EnableAutoConfiguration，@ComponentScan三个注解的组合。
  - @EnableAutoConfiguration
    - 允许SpringBoot自动配置注解，开启这个注解之后，SpringBoot就能够根据当前类路径下的包或者类来配置SpringBean
  - @Configuration
    - 用于定义配置类，指出该类是Bean配置的信息源，相当于传统的xml配置文件，一般加在主类上。如果有一些第三方库需要用到xml文件任然建议通过@Configuration类作为项目的配置主类——可以使用@ImportResource注解加载xml配置文件。
  - @ComponentScan
    - 组件扫描。让Spring Boot扫描到Configuration类并把它加入到程序上下文。@ComponentScan注解默认就会配置标识符了@Controller，@Service，@Repository，@Component注解的类到Spring容器中
  - @Repository
    - 用于标注数据访问组件，及DAO组件使用@Repository注解可以确保DAO或者repositoriees提供异常转译，这个注解修饰的DAO或者repositories类会被ComponetScan发现并配置，同时也不需要它们提供XML配置项。
  - @Service
    - 一般用于修饰service层的组件
  - @RestController
    - 用于标注控制层组件（如struts中action），表示这是个控制器bean，并且是将函数的返回值直接填入HTTPX响应体中，是REST风格的控制器；它是@Controller和@ResponseBody的集合。
  - @ResponseBody
    - 表示该方法的返回结果直接写入HTTP response body中一般在异步获取数据时使用，在使用@RequestMapping后，返回值通常解析为跳转路径，加上@responsebody后会返回结果不会被解析为跳转路径，而是直接写入HTTP response body中，比如异步获取json数据，加上@responsebody后会直接返回json数据。
  - @Conmponent
    - 泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注
  - @Bean
    - 相当于XML中的，放在方法上面，而不是类，意思是产生一个bean，并交给Spirng管理。
  - @AutoWired
    - byType方式。把配置好的bean拿来用，完成属性，方法的组装，它可以对类成员变量，方法及构造函数进行标注，完成自动装配的工作。当加上（required=false）时，就算找不到bean也不报错。
  - @Qualifier
    - 当有多个同一类型的bean时，可以用@Qualifier（“name”）来指定。于@Autowired配合使用
  - @Resource(name="name",type="type")
    - 没有括号内内容的话，默认byName。与@Autowired干类似的事。
  - @RequestMapping
    - RequestMapping是一个用来处理请求地址映射的注解；提供路由信息，负责URL到Controller中的具体函数的映射，可用于类或方法上。用于类上，表示类汇总的所有响应请求的方法都是以该地址作为路径。
  - @RequestParam
    - 用在方法的参数前面。例：@RequestParam String a = request.getParamenter("a")
  - @PathVariable
    - 路径变量。参数与大括号里的名字一样要相同。例：RequestMapping("user/get/mac/{macAddress}")public String getByMacAddress(@PathVariable String macAddress){ //do something;}
  - @Profiles
    - Spring Profiles提供了一种隔离应用程序配置的方式，并让这些配置只能在特定的环境下生效。任何@Component或@Configuration都能被@Profile标记，从而限制加载它的时机。@Configuration@Profile("prod")public class ProductionConfiguration{//...}
  - @ConfigurationProperties
    - Spring Boot可以使用注解的方式将自定义的properties文件映射到实体bean中，比如config.properties文件@Data@ConfigurationProperties("rocketmq.consumer")public class RocketMQConsumerProperties extends RocketMQProperties{private int consumeThreadMin = 20;private int consumeThreadMax = 64;private int consumeConcurrentlyMaxSpan = 2000;private int pullThresholdForQueue = 1000;private int pullnterval = 0;pricate int consumeMessageBatchMaxSize = 1;pricate int pullBatchSize =32;}
Mybatis-Plus
- MP的简介与快速入门
- MP和SpringBoot的集成配置
- MP和SpringBoot完成基本的CRUD
- MP的分页插件
- MP条件构造器Wrapper
- MP代码生成器
Quartz
- Quartz任务调度简介
- Quartz基本使用
- Quartz核心类讲解
- 掌握Quartz触发规则
- Quartz Trigger触发器
- Quartz Job&JobDetai
- Quartz Calendars日历讲解
- JobListener监听器和TriggerListener监听器
- Spring整合Quartz
Shiro
- Shiro概述与入门
- Shiro执行流程
- Shiro.ini文件说明
- 权限URL配置
- 自定义Realm实现权限与授权
- 标签与权限注解
- SSM+Shiro的集成配置
- 缓存机制
- 记住我功能的使用
- 单点登录以及其他应用场景
Git/Github
- Git的下载和安装
- Git和SVN对比
- Git创建版本库
- Git版本控制
- Git远程仓库
- Git分支管理
- Git标签管理
- Git常用命令总结
- GitHub简介与账号注册
- Git与Github远程仓库配置
项目实战
- SpringBoot+SpringMVC+Spring+Mybatis+Mybatis-Plas+Quartz+Git多模块电商项目
微服务
- Spring Cloud Alibaba 简介
  - 主要功能
    - 服务限流降级
      - 默认支持WebServlet,WebFlux,OpenFeign,RestTemplate,Spring Cloud Gateway,Zuul,Dubbo和RocketMQ限流降级功能的接入，可以运行时通过控制台实时修改限流降级规则，还支持查看限流降级Metrics监控
    - 服务注册与发现
      - 适配Spring Cloud服务注册与发现标准，默认集成了Ribbon的支持
    - 分布式配置管理
      - 支持分布式系统中的外部化配置，配置更该时自动刷新
    - 消息驱动能力
      - 基于Spring Cloud Stream为微服务应用构建消息驱动能力
    - 分布式事务
      - 使用@GlobalTransactional注解，高效并且对业务零侵入地解决分布式事务问题
    - 阿里云对象存储
      - 阿里云提供的海量，安全，低成本，高可靠的云存储服务，支持在任何应用，任何时间，任何地点存储和访问任意类型的数据
    - 分布式任务调度
      - 提供妙级，精准，高可靠，高可用的定时（基于Cron表达式）任务调度服务。同时提供分布式的任务
    - 阿里云短信服务
      - 覆盖全球的短信服务，友好，高效，智能的互联化通讯能力，帮助企业迅速搭建客户触达通道
- 服务注册中心
  - （不推荐）Eureka
  - Zookeeper
  - Consul
  - （推荐）Nacos
    - Nacos服务注册中心
      - 可以实现服务注册中心
        服务注册中心Nacos Server
        它是一个Nacos Server，可以为服务提供者和服务xiao
        服务消费者Nacos Client
        服务提供者Nacos Client
    - 解释：一个更易于构建云原生应用的动态服务发现，配置管理和服务管理平台
- 服务调用
  - Ribbon
  - LoadBalancer
- 服务调用2
  - （不推荐）Feign
  - OpenFeign
- 服务降级
  - （不推荐）Hystrix
  - resilience4j
  - sentinel
    - 解释：把流量作为切入点，从流量控制，熔断降级，系统负载保护等多个维度保护服务的稳定性
- 服务网关
  - （不推荐）Zuul
  - （可以用，不推荐）Zuul2
  - gateway
- 服务配置
  - （不推荐）Config
  - Nacos
- 服务总线
  - （不推荐）Bus
  - Nacos
分布式
- Oracle
  - Oracle的概述，Oracle的安装，新建用户，授权，表空间
  - Oracle的DQL
  - Oracle的PL/SQL语句块（语句块，判断，循环）
  - Oracle的子程序（存储过程和函数）
  - 事务，视图
  - 索引，游标
  - Oracle调优
  - Oracle架构设计
- Linux/CentOS
  - 虚拟机介绍和应用场景
  - VMware的安装和使用
  - Linux/CentOS系统介绍
  - CentOS系统目录结构
  - CentOS常用命令
  - CentOS文件权限管理
  - CentOS环境搭建（jdk，tomcat，mysql）
  - LinuxShell编程
  - Linux运维指南
- Nginx
  - Nginx的简介和安装
  - Nginx的原型图
  - Nginx架构模型
  - Nginx负载均衡
  - Nginx+Vsftpd文件服务器
  - Nginx实现反向代理服务器
  - Nginx详细配置信息
  - LVS+Keepalived+Nginx安装及配置
- Zookeeper
  - Zookeeper简介和安装
  - Zookeeper概念解释
  - Zookeeper数据模型
  - Zookeper原生操作Zookeeper
  - ZClient操作Zookeeper
  - 使用Zookeeper实现配置文件中心
  - Zookeeper节点类型
  - Zookeeper分布式锁
- Dubbo
  - Dubbo简介
  - Dubbo架构分析
  - Dubbo的入门案例
  - Dubbo-admin的安装和使用
  - Dubbo注册中心
  - Dubbo提供者以及配置优化
  - Dubbo消费者和配置优化
  - Dubbo高可用，Dobbo负载均衡
  - SpringBoot整合Dubbo
  - 解释：Apache Dubbo是一款高性能Java RPC框架
- Redis
  - Nosql简介和Redis的安装
    - 什么是NoSQL
      - Not Only SQL
        NoSQL，泛指非关系型的数据库。随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。
      - NoSQL的特点
        解耦，没有太大的关联
        方便扩展（数据之间没有关系，很好扩展！）
        大数据量高性能（Redis一秒写8万次，读取11万次，NoSQL的缓存记录级，是一种细粒度的缓存，性能回比较高）
        传统类型是多样性的（不需要事先设计数据库，随取随用）
        传统RDBMS和NoSQL
      - 传统关键型数据库（MySQL,Oracle等）RDBMBS:
      - 比较
        传统的RDBMS
        结构化组织
        SQL
        数据和关系都存在单独的表中操作，数据定义语言
        基础的事务
        关系型数据库遵循ACID规则
        ....
        NoSQL
        代表着不仅仅是SQL
        没有声明性查询语言
        没有预定义的模式键值对存储，列存储，文档存储，图形数据库
        最终一致性，而非ACID属性
        非结构化和不可预知的数据
        CAP定理
        高性能
        ...
  - Redis的数据模型
  - Redis常用的命令
  - Redis发布订阅
  - Redis事务
  - Redis持久化
  - 使用Jedis操作Redis
  - RedisCluster集群搭建
  - Redis系能调优
  - SpringBoot整合Redis，RedisTemplete使用
- RabbitMQ
  - 详细队列RabbitMQ，ActiveMQ，Kafka各自优缺点
  - RabbitMQ简介
  - RabbitMQ环境搭建
  - RabbitMQ常用消息模式介绍
  - RabbitMQ消息发送原理
  - Spring集成RabbitMQ消息队列
  - SpringBoot集成RabbitMQ消息队列
  - RabbitMQ使用场景及面试刨析
  - 解释：一款开源的分布式消息系统，基于高可用分布式集群技术，提供低延时的，高可靠的消息发布于订阅服务
- 分布式事务
  - 分布式事务产生的原因
  - 分布式事务理论模型
  - 2PC模型
  - TCC模型
  - 本地事务表
  - MQ消息事务
  - GTS集成和使用
  - TCC实现
- 在线支付
  - 支付宝支付
  - 微信支付
  - 易宝支付
  - 银联支付
- Mycat
  - Mycat的简介和安装
  - Mycat架构模型
  - Mycat概念详解
  - Mycat主键自增
  - Mycat读写分离
  - Mycat分库分表
  - Mycat性能调优
  - Mycat权限控制
- 实战项目
  - Dubbo+Zookeeper+SpringBoot+Spring+Mybatis+Mybatis-Plus+Nginx+Redis+RabbitMQ分布式项目实战
- Docker
  - https://blog.csdn.net/q610376681/article/details/90483576?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166933825816800192297604%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=166933825816800192297604&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-90483576-null-null.142^v66^js_top,201^v3^add_ask,213^v2^t3_control1&utm_term=docker&spm=1018.2226.3001.4187
    - 解释：docker是一个用来装应用的容器，就像杯子可以装水，笔筒可以放笔，书包可以放书，可以把hello word放在docker中，可以把网站放入docker中，可以把任何想得到的程序放到docker中
    - 了解docker
      - 集装箱
        没有集装箱之前运输货物,东西零散容易丢失,有了集装箱之后货物不容易丢失,我们可以把货物想象成程序,目前我们要把程序部署到一台新的机器上,可能会启动不起来,比如少一些配置文件什么的或者少了什么数据,有了docker的集装箱可以保证我们的程序不管运行在哪不会缺东西.
      - 标准化
        运输方式
        docker运输东西有一个超级码头,任何地方需要货物都由鲸鱼先送到超级码头,然后再由鲸鱼从超级码头把货物送到目的地去.对应的技术来说,比如我们要把台式机的应用部署到笔记本上,我们可能选择用QQ发过去或者用U盘拷过去,docker就标准化了这个过程,我们只需在台式机上执行一个docker命令,把鲸鱼派过来,把程序送到超级码头去,再在笔记本上执行一个docker命令,然后由鲸鱼把程序从超级码头送到笔记本上去.
        存储方式
        当我们把程序存储到笔记本上时,我们需要一个目录,且我们要记住这个目录,因为下次我们可能还要修改,有了docker之后我们就不用记住了程序在哪里了,我们使用的时候只需要一条命令就行了.
        API接口
        docker提供了一系列rest api的接口,包含了对docker也就是对我们的应用的一个启动停止查看删除等等,如当我们要启动tomcat时我们要执行startup命令,当我们要停止时要执行shutdown命令,如果不是tomcat,我们可能还需要一些别的命令.有了docker我们记docker的命令就可以对其进行操作.
      - 隔离
        我们在使用虚拟机时有自己的cpu,硬盘,内存,完全感觉不到外面主机的存在,docker也差不多,不过它更轻量,我们创建虚拟机可能要几分钟,但是docker只需要一秒.最底层的技术时linux一种内核的限制机制,叫做LXC,LXC是一种轻量级的容器虚拟化技术.最大效率的隔离了进程和资源.通过cgroup,namespace等限制,隔离进程组所使用的物理资源,比如CPU,MEMORY等等,这个机制在7,8年前已经加入到linux内核了,直到2013年docker出世的时候才火起来,大家可能奇怪为什么这么好的技术埋没这么多年都没人发现呢?英雄造时势,时势造英雄,如果没有云计算,敏捷开发,高频度的弹性伸缩需求,没有IT行业这么多年长足的发展,也就没有docker.
    - docker解决的问题
      - 系统环境不一致
        开发:我本地没问题.运维:服务器没问题. 这个问题就变成了皮球.如果一个应用要正常的启动起来需要什么?比如java web应用.需要一个操作系统,操作系统之上要jdk,tomcat,我们的代码,配置文件.操作系统的改变可能会导致我们的应用开不起来,比如我们调用了某些系统命令.jdk版本也可能导致程序的运行失败.比如class文件需要1.7编译,我们装了个1.6的jdk.tomcat版本也能导致失败,比如旧的版本一些配置在新版本中不再支持.代码的话就比如应用了C盘,D盘的一个文件,或者是用了系统的一些环境编码.配置的话我们可能少了某个配置文件等等.下面docker来了,它把操作系统,jdk,tomcat,代码,配置全部放到集装箱里.再打包放到鲸鱼上,由鲸鱼给我们送到服务器上,在我的机器上怎么运行,在别的机器上也怎么运行.不会有任何的问题.一句话就是docker解决了运行环境不一致所带来的问题.
      - 系统好卡，哪个哥们又写是死循环了
        如果有根别人共用服务器的同学可能有这样的体会,莫名其妙发现自己的程序挂了,一查原因要不是内存不够了,要不是硬盘满了,还有就是发现某个服务变慢了,甚至敲终端都比较卡,但是linux本身就是一个多用户的操作系统本身就可以供多个用户使用,docker的隔离性可以解决这个问题,就算别人的程序还是死循环疯狂吃CPU,还是封装疯狂打日志把硬盘占满,还是内存泄漏,把内存占满,都不会导致我们的程序运行错误.因为docker在启动的时候就限定好了,它最大使用的CPU硬盘,如果超过了,就会杀掉对应进程.
      - 双11来了，服务器撑不住
        大部分系统业务量并不是每天都比较平均的,特别是一些电商系统,每天总有那么几天业务量是平时的几倍甚至几十倍,如果按双11的规模去准备服务器那么对于平时的规模来说又是极大的浪费,所以就在节日前临时扩展机器,过完节再把多余的节点下线,这就给运维带来了非常大的工作量,一到过节就在各个机器上部署各种各样的服务,我们启动程序需要java,tocmat等等,并且还可能起不来还要调试,这是非常恶心的工作,有了docker一切都变得美好了,只要点一下服务器就可以从10台变成100台甚至1000,1W台.都是分分钟的事情.为什么会这么快呢?都是用标准的方式把我们的程序运过来,下载过来,再用标准的方式把它运行起来,就可以做到只要在每台机器上都执行一两条命令,就可以让程序正常跑起来,并且不用担心有问题.
    - 走进doker
      - 镜像就是上面说的集装箱,仓库就是超级码头,容器就是我们运行程序的地方.docker运行程序的过程就是去仓库把镜像拉到本地,然后用一条命令把镜像运行起来变成容器.build:构建,就是构建镜像.ship:运输,运输镜像,从仓库和主机运输.run:运行的镜像就是一个容器.build,ship,run和镜像,仓库,容器是一一对应的.
      - 镜像
        镜像的英文名交image.前面我们讲到了集装箱,鲸鱼拖着的所有集装箱就是一个镜像.从本质上来说镜像就是一系列文件,可以包括我们应用程序的文件,也可以包括我们应用的运行环境的文件,既然是文件,那么是以什么样的格式在本地保存的呢?说到存储格式,就要提到linux的一个存储技术,叫做联合文件系统,是一种分层的文件系统,可以将不同的目录挂到同一个虚拟文件系统下.
      - 容器
        为了便于理解,大家可以把容器想象成虚拟机,每个虚拟机都有自己的文件系统,可以把图1整个一部分看成是文件系统,与虚拟机系统的区别是这里面的文件系统是一层一层的,并且最下面的n层都是只读的,只有上面一层是可写的.为什么要有可写的这层呢?大家的程序运行起来,势必会要写一些日志,写一些文件,或者对系统的某一些文件做一些修改,所以容器在最上面一层创建了可读可写的文件系统.在程序的运行过程中,如果要写镜像文件时,因为镜像的每一层都是只读的,它会把文件的每一层拷到文件的最上层,然后再对它进行修改,修改之后,当我们的应用读一个文件时会从顶层进行查找,如果没有才会找下一层.由于容器的最上一层是可以修改的,镜像是不能修改的,这样就能保证镜像可以生成多个容器独立运行,没有任何干扰.
      - 仓库
        我们的镜像是要在其它机器上运行,如何进行传输呢?这就用到了docker仓库,我们要先把我们的镜像传到docker仓库中,再由目的地把docker仓库拉过去,这就完成了这样的一次传输过程.谁提供了这样的仓库呢?docker自己提供了,hub.docker.com,但是非常慢,为了解决这个问题,国内很多公司也在做自己的仓库.比较知名的是由网易蜂巢提供的 https://c.163yun.com/hub#/m/home/

在无清风

关注

4
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
Java课程大纲(个人整理)

Java课程大纲目录Java Sc核心基础web前端javaEE 企业级开发Java EE 高级框架阶段微服务分布式Docker （未写完，后续会继续更新和修改，如有错误请私聊斧正）思维导图的图片：http://assets.processon.com/chart_image/631aefeae0b34d59536069f2.png个人更推荐看导图密码（WZG6）：Java课程大纲 | 173649_PO | 思维导图（新） | ProcessOn
复制链接

扫一扫