springboot2（黑马程序员）入门

springboot2课程学习

1. 课程特点
   1. 课程内容多，知识点杂乱，
   2. 课程面向业务需求大
2. 课程定位：小白：完全没有用过springboot技术（目前阶段）
   1. 初学者：基于springboot进行ssm框架的整合，掌握第三方的技术与springboot整合版
   2. 积累springboot的实战开发的经验
3. 课程模块：
   1. 基础篇
      1. 学习要求：
         1. 能够创建springboot工程
         2. 基于springboot实现ssm的框架的整合（springboot的目的本身就是为了简化开发而设计实用的）
   2. 实用篇
      1. 运维实用篇
         1. 学习要求
            1. 掌握springboot程序的多环境开发
            2. 基于linux系统发布springboot工程
               1. linux的课程学习提上进程
            3. 灵活配置springboot工程
      2. 开发实用篇
         1. 基于springboot整合任意的第三方技术（redis、netty）
   3. 原理篇（先学习完黑马——再转战雷神的原理）
4. 学习要求:（前置课程学习）
   1. java SE
   2. spring、springMVC 
   3. mybatis和mybatis-plus（暂时未学）
   4. 数据库mysql（基础的增删改查语句）
   5. 服务器（javaweb servlet）
   6. maven （知道依赖服务、依赖传递、排除依赖、可选依赖、继承）
   7. web技术（还未学习）（明白vue是如何发送ajax请求，如何获得相应数据、如何进行数据模型的双向绑定）
5. 实用篇的开发学习
   1. linux（centers 057）
      1. 熟系lunux基础指令、掌握linux系统的目录结构
   2. 实用开发技术
      1. 缓存redis、mongoDB
      2. 消息中间件roctketmq：rabbitMQ
      3. .........
6. 原理的学习：
   1. 了解spring加载bean的各种方式
   2. 知道spring容器底层的工作原理，能够简单的读懂spring底层原码（相关的知识还需要扩展“设计模式”等方面的学习

springboot入门案例

1. 使用目的
   1. 简化spring应用的初始搭建以及相应的开发过程
      1. 写起来快、方便
2. 安装注意点
   1. 使用springboot的时候要求要在联网的环境下进行配置
   2. 在选择使用jdk的版本的时候，使用本机配置的jdk8（市面上通常情况下使用jdk8较为常见、也有使用jdk11的版本）
3. 编写简单的打印语句（findById）打印相应的语句
   1. 在运行程序的时候，点击

    即可以直接进行运行（无需要像springmvc 配置xml文件或者配置类）,也无需像web一样进行启动服务器 ，即可以直接看到相应的配置文件

配置文件的相应信息

springboot在使用时候，无需要配置相应的类（pom中maven的坐标、web中的相应配置、spring、springmvc中的config类、xml等的配置类）等，在模块选定的时候勾选即可以一键式选定，使用者的唯一要求就是使用控制器进行相应的手工配置

springboot的程序运行Application程序的入口进入

1. springboot的优点
2. 缺点：
   1. 要求idea在使用过程中要确保联网，才能够加载到程序的框架
   2. 由于idea在联网时下载速度较慢，因此可以通过登入到spring.io官网进行手动配置，下载，通过idea将其加载进行，可以实现同idea的相同功能
   3. 
   4. 
   5. 下载好，安装到对象的包中，即可以直接进行使用打开
3. 若国外的spring.io没有办法顺利的打开话，可以在设置模块中设置镜像，使用阿里云提供的组块用于使用（速度相对于国外的会更快一些）
4. 遇到问题：当前在使用springboot创建相应的项目时，发现无法打开创建的项目
   1. 解决办法
      1.  根据我的项目结构进行相应的调整处理

       application是在com.liu 包下，那么就是controller要求在其包层次的下个层，con.liu.controller

要么将DemoApplication入口类的package改为com.lcf  要么将DemoController类的package改为com.lcf.demo.controller.

自己的失误：忘记配置getMapper

1. 若计算机确实不能联网的话（涉密机构），需要怎么做
   1. 使用maven的继承机制，将相应的内容（jar包）
   2. 手动配置相应的属性（application）、引导类

总结：配置springboot的工程具有四种方式

1. 基于idea自身创建的springboot工程
2. 基于官网创建的springboot工程（比起idea下载速度要快）
3. 基于阿里鱼创建的springboot工程（访问国内的网站速度要比国外的网站快）
4. 手工创建maven工程，并将其修改成springboot工程（主要适用于不联网（涉密））

选择隐藏springboot工程中的其他的文件

        适用file type的文件，将工程中多余的文件后缀进行相应的隐藏，使得界面更为干净整洁

springboot 入门案例解析

1. 与原始的spring程序比较
   1. 传统的spring程序相比
      1. 依赖设置繁琐
         1. 使用springMVC，需要导入相应的jar
         2. 使用jdbc，则需要导入相应的jar包
      2. 配置繁琐
         1. 相应的properties 、xml、config等配置都省略，并且对于扫描文件、导入等相关配置
   2. springboot的程序优点
      1. 起步依赖（简化依赖配置）
      2. 自动配置（简化常用的工程相关配置 ）
      3. 辅助功能（内置服务器。。。。。。）（最强功能）
   3. 具体实现上述优点
      1. parent
         1. dependenc y中引入的jar包相同，通过设置相同的模板，子类进行引用
         2. （对模板中的jar包的版本设置了相应的最优版本（maven 的属性） ）
            1. project-parent：pom.xml (左边只进行相应的版本管理)
               1. 
               2. 将所有的jar包都进行导入（好处：避免调包，由springboot进行设置）
            2. project -dependencies:pom.xml(右边只进行相应的坐标管理) 
               1. 
            3. 整合优化后的使用
               1. 定义一系列的常用坐标  ：project -dependencies:pom.xml
               2. 定义一系列的常用坐标组合project -dependencies:pom.xml
               3. 直接进行使用
            4. 在创建的springboot的文件中，存在（pom.xml）文件
               1. 通过继承中的springboot-starter-parent进行文件版本的指定
               2. 继承与springboot-denpencies
               3. 在中定义了相关的属性
               4. （依赖管理）
               5. 在使用阿里云导入的包中，阿里直接将的相关内容直接进行导入（本质相同）（引入依赖的形式）
               6. 上面的版本（jar包）根据着springboot的版本号不同有所变化
            5. 好处：避免多个依赖使用相同的技术时出现依赖版本冲突
      2. starter（parent定义了想要的jar包的属性，而使用则是由starter进行调用）
         1. 前面（parent）定义了相应的版本号，在pom.xml文件中，使用者通过写入相应的jar的坐标，进行自动的导入
         2. starter（包含着若干个的坐标管理文件）（若一个starter中包含着其他的starter，则也有将其他的starter中内容进行导入并使用））
            1. 例子:做A技术进行开发，则只需要导入相应A技术的starter进行，而使用B技术进行开发，则相应的导入B技术的starter进行使用（starter中则自动帮助导入相应的配置）
         3. 总结：
            1. starter 定义了当前项目使用的所有依赖坐标，以达到减少依赖配合的目的
            2. parent 定义了若干个坐标版本号（依赖管理）以达到减少依赖冲突的目的
               1. 各个版本之间存在着不同的坐标版本
      3. 引导类（本质：以application结尾的类（在此上进行相应的启动））
         1. SpringApplication.run（Springboot0102QuickstartApplication.class, args）
            1. 无论是spring、springMVC 都是使用容器，将对象交付给容器进行相应的管理，
            2. run方法的本质：加载一个容器（加载bean）
               1. 验证：通过将其run方法生成对象，并且使用getBean方法获取对象并输出
            3. 引导类的核心功能：在注解（@SpringBootApplication）上体现
               1. 本质就是加载配置类：在springbootApplication中存在 springbootconfiguration的configuration
               2. 通过configuration中进行自动扫描（@componentScan）该注解的当前注释类所在包以及 下面的子包（以及是我们创建的controller类）的所有的注解，从而实现自动的加载容器
         2. 总结
            1. springboot的引导类是boot工程的执行入口，运行main方法就可以启动项目
            2. 运行后初始化spring的容器，扫描引导类所在包加载bean
      4. 内嵌tomcat（启动web服务器）
         1. 通过加载相应的来进行相应的内置tomcat
         2. 调用内嵌的tomcat的核心（启动可以直接使用）（将服务器内置到程序中）
         3. 服务器的修改
            1. 在dependencies中导入相应的spring-Boot-starter-web的服务器坐标
               1. 核心本质是spring-Boot-starter-tomcat（默认）中的spring-Boot-ember-tomcat在起到核心作用
            2. 当选择进行修改相应的服务器类型，使用exclusions，将相应的坐标进行排除
            3. 导入相应的服务器的starter的坐标
               1. 添加jetty服务器
               2. 服务器的类型
                  1. tomcat：Apache（应用面广、负责这若干较重组件）
                  2. jetty：轻量级的服务器（若tomcat中的配置文件不需要使用，可以使用jetty的服务器）
                  3. undertow：（负载性能勉强赢tomcat）
      5. 基本配置：（修改服务器上的相应的配置信息（修改服务器的端口、））
         1. 写哪
            1. 为了将相应的工程整合在一起，方便后面复习，将所有的工程整合在一起，因此使用复制工程
               1. 复制工程原则：保留工程的基础结构；抹掉原始工程的痕迹
               2. 
               3. 总结：通过设置相应的模板，进行复制，从而避免后续要创建springboot工程的步骤（学习期间）
            2. 配置端口号（在resource中的application.properties）中（key value）
               1. 端口配置：server:port = 80
               2. 在book中的配置文件是application.properties 可以在上面修改相关的任意属性
               3. 按照key value的属性值即可
               4. 修改别的配置
                  1. 修改banner（修改）banner可以修改显示在控制台上的图标信息（off、console）
                  2. 控制日志：
                     1. logging。level .rootdebug (加载日志的debug的过程)
                     2. logging.level.error(仅在出错时候才有相应的信息)
                     3. logging.level.root = info 表示在初始时候的相应信息
                  3. 具体的文档操作（查阅官方文档 ）有具体信息的说明
                  4. 核心：用什么技术就相应的开什么相应的配置
               5. springboot提供的属性配置的方式
                  1.  application.properties(key value ) 的相关属性配置
                  2. application.yml（现代企业推荐使用这个格式）
                  3. application.yaml
                  4. 若三个配置文件同时出现，则properties为准，若只有yml和yaml共存时，则yml为准 
                  5. 不同配置文件中相同的配置加载顺序（properties>yml>yaml）不同配置文件中的不同配置全部保留
            3. 属性提示消失的解决办法
               1. 提示出现是因为springboot在idea的环境下的功能实现，若没有功能实现，表示其可能
               2. 
               3. 
            4. 格式
               1. 优点
                  1. yaml的数据格式更容易阅读
                  2. 与其他的脚本语言更容易 的进行交换
                  3. 以数据为核心，重数据轻格式
               2. yaml文件扩展名
                  1. 类型
                     1. yml（主流）
                        1.  
                     2. yaml
                        1. 

                     3. 语法规则

                        1. 

                     4. 数据前面要加空格与冒号隔开

                        1. 

                        2. 

                  2. yaml的数据读取方式

                     1. 读取方式

                        1. 读取单一属性的数据

                           1. 先定义变量（不一定要与配置文件中的属性名相对应）

                           2. 使用springboot中的注解

                              1. （@value（${\"属性值\"}））

                           3. 若存在多级结构，则按照级别，使用·进行分格

                              1. （@value（${\"类名.属性值\"}））

                           4. 若存在数据类型的，则使用数据名+索引（在数据中的编号）

                              1. （@value（${\"类名[编号]\"}））

                        2. 读取引用类型的数据

                           1. 使用${\"属性名\"}的方式进行引用数据

                           2. 在yaml中支持转义字符，在使用时候需要使用\"\"将其包裹起来

                        3. 读取全部属性的数据

                           1. 通过使用注解（自动转配）

                              1. 使用environment对象来封装所有的配置信息

                              2. 使用@Autowired自动装配数据到Enviromment对象中

1. 使用springboot整合第三方的技术

   1. 要求
      1. 明确整合的技术（得到一个通用的结论以及步骤）
   2. 整合技术类型
      1. 整合JUnit
         1. 使用的注解（@SpringBootTest）测试类的注解
         2. springboot中的junit无需额外的操作整合，由创建的maven的本身就自带（maven本身的生命周期中就存在测试的环境，因此自带）（即导入测试对应的starter）
         3. 位置：位于创建的test类中的方法之上
         4. 作用：设置JUnit加载的springboot启动类上
         5. 图解
            1. 
         6. 具体步骤
            1. 定义并注入所需要测试的对象
               1. 创建BookDao对象，并且采用自动注解的方法进行注入对象
            2. 执行测试方法
               1. 在 void contextLoads() {}通过调用对象.方法名，执行相应的测试方法
         7. 测试类的执行范围
            1. Test类中的结构与main包中的结构相对应，如果Test包中的springBootTest的测试范围是在引导类所在包及其下面的子包，如果超出相应的范围，则就会相应的进行报错
            2. 若确实由于业务需求导致Test的所在包与Main中不相同，通过设置classes属性，（springbootTest（classes =引导类 名.class）来进行相应的指定
            3. 本质原因是：如果没有在相对应的位置，则没有办法获取得到相应的spring的容器，因此需要通过输入类名.class，从而去进行相应的检索
      2. 整合MyBatis
         1. 前置（了解）mybatis在工作时需要连接那些相关的信息
            1. 核心配置：
            2. 映射配置：SQL映射（XML/注解）
      3. 整合MyBatis-plus
         1. 暂时还没学习（本章节跳过）
      4. 整合Druid
         1. 指定相应是数据类型
            1. 从maven中寻找相应的坐标，并且导入pom文件
               1. 
            2. 在yml配置文件中指定相应的类型
               1. 两种方法
                  1. （通用性）
                  2.                               （推荐这种（整合性））
            3. 总结：整合第三方通用技术
               1. 导入对应的starter文件
               2. 根据提供的配置各式，配置非默认值对象的配置项

综合案例：基于springboot的SSMP的整合案例

1. 实习的技术分析（只有简单的增删改查的相关操作）
   1. 
      1. 先完成基础的CRUD功能并且进行测试
      2. 调通页面，确定异步提交成功后，制作相应的功能
      3. 添加分页功能与查询功能
   2. 流程
      1. 当前的项目架构
         1. 手机浏览器————前端服务器————后端服务器（微服务：在不同的服务器上进行相应的信息处理）
      2. 本次项目：
         1. 手机浏览器——服务器（前端、后端服务器合并在一起）
      3. 具体步骤（数据层的开发）
         1. 在创建模块中勾选springmvc（spring web）和数据库驱动 （MySQL driver）
         2. 修改配置文件的格式（properties 转变为yml）并且配置相应的参数（修改端口号：80）
         3. 根据数据库中的表，创建相应的实体类对象
            1. 使用lombok进行
               1. Lombok 一个java类库，提供了一组注解，能够简化pojo实体类的开发
                  1. 步骤
                     1. 先导入相应的Lombok的坐标
                     2. Lombok中存在着许多的注解，通过下载插件可以查看Lombok中的相关消息（crtl+F12）进行查看
                     3. @Data（封装了get、set、tostring、equal等相关的方法，但是没有构造器，因此需要手动进行配置）
            2. 使用传统的get、set方法
         4. 使用继承baseMapper来实现简化开发
         5. 开启MP运行日志
            1. 导入：使用BaseMapper进行开发时，在console端口只能看到相应的结果，缺不完看到其过程
            2. 日志：在配置文件中启动
               1. 开启：

                    mybatis-plus:
                  configuration:
                      log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

         6. 实现数据库分页

            1. api

                IPage page = new Page(1,5);
                       bookDao.selectPage(page,null);

                创建相应的ipage的对象，1表示起始的页面，5表示限制分页的数量

            2. selectPage本身就是

            3. 设置相应的拦截器

               1. public class MPconfig {
                      @Bean
                      public MybatisPlusInterceptor mybatisPlusInterceptor(){
                          MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
                          interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
                          return interceptor;
                      }
                  }
                  

               2. 通过add方法新增相应的拦截器，完成相应的逻辑业务

               3. 本质就是实现动态拼写SQL语句来实现分页的功能，其写法是相对的固定

               4. 调试过程中需要开启相应的日志，才能够看到具体的信息

         7. 实现分页查询

            1. 本质：通过使用动态SQL的进行相应的数据层的查询

            2. 具体实现

               1. 使用queryWarpper进行查询

                  1.        //创建querywrapper查询对象
                             QueryWrapper queryWrapper= new QueryWrapper<>();
                             //封装相应的查询条件
                             queryWrapper.like(\"name\",\"Spring\");
                             //（like方法中，第一个是数据库中的数据项，第二个是Spring中的搜索条件）
                             //执行查询
                             bookDao.selectList(queryWrapper);

               2. 为避免查询错误，使用LamdaQueryWrapper可以避免查询时数据项输错（语法集出错（有着系统自动提示））

                  1.         String name = \"spring\";
                             LambdaQueryWrapperlambdaQueryWrapper = new LambdaQueryWrapper<>();
                             lambdaQueryWrapper.like(name != null,Book::getName,name);
                             bookDao.selectList(lambdaQueryWrapper);

               3. 在使用的时候，一般是接受上面的封装对象，因此需要将结果进行非空判断，如果未进行非空判断，则会导致搜索以null为结果

业务层的开发（基础的CRUD）操作

1. 业务层定义的接口：更加关注的是业务本身的逻辑
   1. login（String username ，String password）（业务层的接口）(注重功能的体现)
   2. selectByNameAndPassword（String username ，String password）（数据层的接口）(注重数据的相应功能（增删改查）)
2. 进行业务层调用数据层的相应操作
   1. 封装相应的对象
3. 使用快速开发（模板）去简化重复的接口定义、调用
   1. 使用业务层提供的通用接口（Iservice）以及与业务层通用实现类（ServiceImpl）
      1. 具体的实现类：extend ServiceImpl(相应的数据层的接口、数据的实体对象) Implement IBookService
      2. 对于常用方法，有提供相应的模板，可以直接进行调用
      3. 对于特定方法，如同正常的方法一样，直接进行定义，实现接口即可
      4. 对于重写的方法，通过使用@override进行相应的重写操作（方法名相同）

表现层的开发

1. 类型
   1. 基于Restful进行表现层的接口开发
      1. 返回的结果用json的形式进行返回
   2. 使用Postman测试表示层的接口功能
   3. 后端将相应的数据封装后，通过json将相应的结果返回，但是不同的操作返回的类型各不相同，因此需要将结果进行统一格式，方便前端进行数据表示
      1. 表现层的消息一致性处理
         1. 例如（增删改：（返回 true/false），查询单条记录（json），查询所有{json数组}）
         2. 通过设计相应的数据类（用于前后端的数据格式统一（前后端数据协议））
            1.