SpringBoot

什么是微服务

微服务和以往有什么区别

为什么SpringBoot适合做微服务框架

SpringBoot或者微服务的不足

springBoot启动过程

springBoot如何进行自动装配和自定义配置

首先有几个注解 @configuration:声明一个配置类 @ConfigurationProperties：用于将xxx.yml配置文件中的对象与xxxproperties类进行对应，相当于@value逐一进行注入 @EnableConfigurationProperties：该注解用于自动配置属性，将配置类和xxxproperties进行对应 @ConditionalOnxxx：判断后接条件是否全部满足，满足则注入bean

  1. @EnableAutoConfiguration注解引入了一个自动配置导入搜索器（AutoConfigurationImportSelector）

  1. 这个搜索器会使用SpringFactoriesLoader加载器去扫描METE-INF/spring.factories路径下的文件

    1.  在METE-INF/spring.factories中存在许多的configuration配置类路径，

  2. 这些配置类使用@EnableConfigurationProperties注解与xxxproperties配置文件类进行对应

  3. xxxproperties配置文件类中使用@ConfigurationProperties注解将配置文件中的属性与注入到该类中

所以修改配置文件中的属性值即可实现自定义配置。

SpringBoot如何使得配置变得简单

springBoot的依赖在父工程中【spring-boot-dependencies】

版本号定义在spring-boot-dependencies中

springboot将部分功能场景变成一个个的启动器，使用时直接引入对应的启动器即可

springboot在启动是会加载大量的自动配置类

METE-INF/spring.factories

默认配置文件，如果在该文件中不配置的话需要进行手动配置

在springboot启动的时候不会全部加载，需要判断是否引入了对应的start启动器。

SpringBoot如何使得部署变得简单

  • SpringBoot内置tomcat、jetty等web容器
  • SpringBoot生成的jar包可以使用java -jar直接执行
  • SpringBoot提供Spring-boot-devtools用来实现热部署

@SpringBootApplication

  • springboot的核心注解
    @SpringBootConfiguration,@EnableAutoConfiguration和@ComponentScan三个注解的合集

@ComponentScan进行component扫描，将bean加载到容器中

@EnableAutoConfiguration允许自动配置，通过这个注解spring通过【AutoConfigurationImportSelector】把所需的bean注入到容器中。

@SpringBootConfiguration作用等同于@Configuration，用来声明当前类是一个配置类。通过@Bean将bean对象交给spring容器管理。

@ConditionalONXXX

表示如果该注解的条件都满足才会生效

springboot启动时@springbootApplication做了哪些操作

  1. 将所有依赖jar包导入到
  2. 声明启动类是一个component，将其交给spring容器管理
  3. 扫描所有的component，将其加载到容器中

SpringApplication类

  1. 推断是普通项目还是web项目【根据dispatchServlet，servletContainer】
  2. 加载所有初始化器
  3. 设置所有监听器
  4. 确定主类

springBoot配置文件

  • 两种格式【yml或者properties】
  • 名称固定【application.yml或application.properties】
  • yaml可以存储对象,properties只能存储键值对
  • 推荐yml

语法结构：

  1. application.properties
  2. key=value
  3. ----------
  4. application.yml
  5. key:空格value

application.yml

  1. #存储对象
  2. student: 
  3.     name: hh
  4.     age: 2
  5. student: {name: hh,age: 3}
  7. #数组/list
  8. name: 
  9.     - zhagn
  10.     - wang
  11.     - zhao
  13. name: [zhang,wang,zhao]
  15. #map
  16. map: {k1: v1,k2: ${random.int}}

  • @ConfigurationProperties

    可以使用该注解将yml配置文件中的对象进行注入 @ConfigurationProperties（prefix=”person”）

  • @PropertySource

    @PropertySource(value = “classpath:test01.properties”) 用于加载指定配置文件【适用于properties格式】

  • @Vlidated

    数据校验 @email(message=”不符合email格式”) private String email;

  • 配置文件的优先级：

  1. 项目目录下的config文件夹
  2. 项目根目录
  3. 类路径【resource】下的config文件夹
  4. 类路径下
  • 多环境配置 ``` properties格式 spring.profiles.active=dev

yml格式 多个版本可以同时写在同一个文件中 定义不同的名字，使用—-隔开 使用： spring： profiles: active: dev

  2. <a name="e6576bc0"></a>
  3. #### yml配置文件是如何解析的
  5. > 在METE-INF/spring.factories中存在许多的configuration配置类路径，
  6. > 这些配置类使用@EnableConfigurationProperties注解与xxxproperties配置文件类进行对应
  7. > xxxproperties配置文件类中使用@ConfigurationProperties注解将配置文件中的属性与注入到该类中
  8. > 所以修改配置文件中的属性值即可实现自定义配置。
  11. <a name="Ck5Ne"></a>
  12. ## Springboot注解
  14. 1. SpringbootApplication<br />springboot项目的主类入口
  15. 1. EnableAutoConfiguration<br />开启自动配置。加载自动配置类
  16. 1. ComponentScan<br />进行组件扫描
  17. 1. SpringbootConfiguration<br />作用和Configuration相同表明该类是一个配置类
  18. 1. Import<br />导入一个类。
  19. 1. ImportResource<br />用于在springboot中导入spring的配置。
  20. 1. Configuration<br />指明当前类是一个配置类，用来代替之前的spring配置。使用了这个注解就可以不使用importResouce了
  21. 1. enableAutoConfigurationImportSelector<br />读取META-INF/spring.factories中的自动配置类列表。
  22. 1. ConfigurationProperties<br />从配置文件中读取配置与当前类进行绑定。`@configurationProerties(perfix = "spring.http.encoding")`
  23. 1. EnableConfigurationProperties(）<br />允许开启某个配置类的自动配置，需要与配置类（使用了ConfigurationProperties注解的类）进行绑定。
  24. 1. Conditional<br />根据不同的条件进行判断，满足条件配置才会生效。
  25. 1. ConditionalOnWebApplication<br />Conditional注解的扩展，要求该项目是一个web项目。
  26. 1. value<br />用于注入配置文件中某个参数的值。
  27. 1. validated<br />进行数据校验
  28. 1. configurationproperties -> propertySource<br />configurationProperties注解读取application.properties配置文件中的数据，为了避免主配置文件过大，索引需要对配置文件进行分离，这时使用的propertySource可以读取单个properties配置文件。
  29. 1. Bean<br />给容器中添加一个组件，标在方法上就是将返回值添加到容器
  30. 1. Qualifier:<br />当有多个同一类型的Bean时，可以用@Qualifier(“name”)来指定。与@Autowired配合使用；
  32. > Springmvc相关
  35. 1. pathvariable<br />从url中提取参数。
  36. 1. requestBody<br />表明参数从url从请求体中获取不是从url中获取。接受post请求。
  37. 1. ResponseBody<br />将返回值直接返回页面，而不是通过视图解析器去寻找对应的页面。一般用于ajax请求，返回json。
  38. 1. RestController<br />相当于@responseBody和Controller的合集，同样是直接返回。
  39. 1. requestMapping<br />springmvc的注解，用于表明处理的请求路径
  41. <a name="m3qmP"></a>
  42. ## 自动配置原理
  44. 主要使用@EnableAoutConfiguration[@enableAutoConfigurationImportSelector]
  46. enableAutoConfigurationImportSelector将/META-INF/spring.factories下的EnableAutoConfiguration列表进行加载到容器中。
  48. EnableAutoConfiguration列表中包含了所有的自动配置类。
  50. 一个自动配置类（如：httpEncodingAutoConfiguration类）中包含的注解
  52. 1. ConfigurationProperties：表明该类是一个配置类
  53. 1. EnableAutoConfigurationProperties：允许使用自动配置并绑定对应的配置类
  54. 1. ConditionalOnWebApplication：判断当前是否为web应用
  55. 1. ConditionalOnClass（）：判断当前项目是否存在某个类
  56. 1. ConditionOnProperty：判断配置文件是否存在某个配置
  58. 每一个自动配置类使用以下注解将其与配置文件进行绑定。所以在配置文件能够配置的属性都来自其properties.class类中定义的属性。
  60. httpEncodingAutoConfiguration类中定义了不同的方法，方法上定义了不同生效条件，当配置对应的方法生效时的，由于该方法使用@Bean进行标注，所以方法的返回值就会注入到spring容器中，所以能够达到配置文件自动注入的目的。
  62. > 自定义start
  65. 同样自定义配置类（Starts），也是通过上面的方法。是对自动配置原理的反向应用。
  67. 1. 有一个自定义配置类（PersonProperties.class）<br />该类中规定了person能够配置的属性。
  68. 1. 一个自动配置类（PerSonAutoConfiguration.class）<br />将该类与Person配置类进行绑定
  69. 1. 创建/METE-INF/spring.factories文件，按照其他AutoConfiguration类的规则，让后将项目打包
  70. 1. 在pom.xml中引入自定义的Starter。
  71. 1. 配置文件中能够配置的都是personProperties类中规定的属性。
  73. <a name="6af0193a"></a>
  74. # 整合
  75. <a name="5af4b523"></a>
  76. ## 整合数据库
  78. 在yml配置文件中配置了datasource数据源之后
  80. 可以使用datasource的bean对象连接数据库进行操作。
  82. - application.yml
  83. ```yml
  84. spring:
  85.   datasource:
  86.     username: root
  87.     password: root
  88.     url: jdbc:mysql://127.0.0.1:3306/gl_itgs?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8
  89.     driver-class-name: com.mysql.jdbc.Driver
  90.     type: com.alibaba.druid.pool.DruidDataSource
  92.     filters: wall,ltog4j,stat

  • testControllet

    1. @RestController
    2. public class testController {
    3.   @Autowired
    4.   DataSource dataSource;
    6.   //自动注入jdbctmeplate即可
    7.   @Autowired
    8.   JdbcTemplate jdbcTemplate;
    9.   @GetMapping("/findAll/{dmlb}")
    10.   public List<Map<String, Object>> getData(@PathVariable String dmlb) throws SQLException {
    11.       String sql = "select * from gl_sys_code where dmlb =" +dmlb +" limit 10";
    12.       List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
    13.       return  list;
    14.   }
    15. }

  • xxxtemplate
    spring已经配置好的bean，拿来即用，如jdbctemplate

整合DRUID

DRUID 是阿里巴巴平台上一个数据库连接池实现 结合了DBCP，C3P0等数据库连接池的有点，同时加入了日志监控

详情连接https://www.bilibili.com/video/av75233634?p=32

整合mybatis

整合springSecurity

主要功能：认证，授权

整合swagger

API框架

作用：REST API 文档在线自动生成工具

直接运行，可以在线测试API接口

支持多种语言

使用

  • 导入jar包、
    swagger2，UI ```xml io.springfox springfox-swagger2 2.9.2

io.springfox springfox-swagger-ui 2.9.2 

  2. - 配置swaggerConfiguration
  3. ```java
  4. //自定义swagger配置
  5. @Configuration
  6. @EnableSwagger2
  7. public class SwaggerConfig {
  8. }

  • 自定扫描包
    Docket的select方法自定义扫描包，是否可用等。

    1. @Configuration
    2. @EnableSwagger2
    3. public class SwaggerConfig {
    5.   @Bean
    6.   public Docket docket(Environment environment) {
    7.       //根据项目运行环境设置是否可用
    8.       boolean flag = true;
    9.       Profiles profiles = Profiles.of("dev");
    10.       flag = environment.acceptsProfiles(profiles);
    12.       return new Docket(DocumentationType.SWAGGER_2)
    13.               .apiInfo(apiInfo())
    14.               .enable(flag)
    15.               .select()
    16.               //指定要扫描的包
    17.          .apis(RequestHandlerSelectors.basePackage("com.example.demo.controller"))
    18.               .build();
    19.   }
    21.   private ApiInfo apiInfo() {
    22.       Contact DEFAULT_CONTACT = new Contact("", "", "");
    23.       return new ApiInfo(
    24.               "Api Documentation",
    25.               "Api Documentation",
    26.               "1.0",
    27.               "urn:tos",
    28.               DEFAULT_CONTACT,
    29.               "Apache 2.0",
    30.               "http://www.apache.org/licenses/LICENSE-2.0",
    31.               new ArrayList()
    32.       );
    33.   }
    34. }

  • 设置多个分组

  2.   生成多个docketBean对象，设置不同的分组名称
  4.   ```java
  5.   @Bean
  6.   public Docket docket1(Environment environmen) {
  7.       return new Docket(DocumentationType.SWAGGER_2).groupName("A");
  8.   }
  10.   @Bean
  11.   public Docket docket1(Environment environmen) {
  12.       return new Docket(DocumentationType.SWAGGER_2).groupName("B");
  13.   }
  • 注释操作 ```java @ApiOperation(“获取用户”) @Api(tags = “controller”) @ApiParam(“用户id”)

@ApiModel(“用户类”) public class User { @ApiModelProperty(“用户名”) private String name; @ApiModelProperty(“密码”) private String password;

}

@Api(tags = “controller”) @RestController public class testController { @Autowired DataSource dataSource;

  1. @Autowired
  2. JdbcTemplate jdbcTemplate;
  3. @GetMapping("/findAll/{dmlb}")
  4. public List<Map<String, Object>> getData(@PathVariable String dmlb) throws SQLException {
  5.     String sql = "select * from gl_sys_code where dmlb =" +dmlb +" limit 10";
  6.     List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
  7.     return  list;
  8. }
  10. @ApiOperation("获取用户")
  11. @RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
  12. public String getUser(@ApiParam("用户id") @PathVariable String id){
  13.     return id + "";
  14. }

}

  2. <a name="99333a08"></a>
  3. ## springBoot 与docker
  5. <a name="Docker"></a>
  6. ### Docker
  8. <a name="e2d6d0e3"></a>
  9. #### 基本概念
  11. 1. 镜像（images）
  12. > 用于创建docker的模板
  14. 2. 容器
  15. > 镜像启动后的实例称为一个容器，是独立运行的一个或一组应用
  17. 3. 客户端
  18. > 连接docker主机进行操作
  20. 4. 主机
  21. > 安装了Docker程序的机器
  23. 5. 仓库
  24. > 用来保存各种打包好的镜像【dockhub】
  27. <a name="67d92f75"></a>
  28. #### 与虚拟机的不同
  30. <a name="867ac76e"></a>
  31. #### 使用步骤
  33. 1. 安装docker
  34. 2. 去仓库找到对应的镜像
  35. 3. 使用docker运行这个镜像，生成一个docker容器
  36. 4. 对容器的启动停止就是对软件的启动停止。
  38. <a name="e655a410"></a>
  39. #### 安装
  1. sudo apt-get update

  2. sudo apt-get install \ apt-transport-https \ ca-certificates \ curl \ gnupg-agent \ software-properties-common

  3. sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

  4. sudo apt-key fingerprint 0EBFCD88
  5. sudo add-apt-repository \ “deb [arch=amd64] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) \ stable”
  6. sudo apt-get update
  7. 安装最新版：sudo apt-get install docker-ce docker-ce-cli containerd.io
  8. 安装指定版本： 获取可用版本信息： apt-cache madison docker-ce 安装： sudo apt-get install docker-ce= docker-ce-cli= containerd.io
  9. 验证：docker —version 或： docker —version ```

使用

  1. 检索

    docker search mysql

  2. 拉取

    docker pull mysql docker pull mysql：5.5

  3. 列表

    docker images

  4. 删除镜像

    docker rmi

  5. 启动容器

    docker run —name -d : docker run —name mytomcat -d tomcat:8.5-jdk11-openjdk

  6. 重启容器

    docker restart /

  7. 查看运行的容器

    docker ps

  8. 查看所有容器

    docker ps -a

  9. 容器重命名

    docker rename

  10. 停止运行的容器

    docker stop

  11. 删除容器

    dock rm

  12. 端口映射

    docker run -d -p 主机端口号:映射端口号 镜像名 docker run -d -p 8888:8080 tomcat -d : 后台运行 -p : 端口映射

  13. 容器日志

    docker log /:

  14. 进入容器目录

    docker exec -it /bin/bash docker docker exec -it 968996d73e77 /bin/bash

实例

使用MySQL

  1. //开启mysql
  2. docker run -p 3307:3306 --name mysql01 -e MYSQL_ROOT_PASSWORD=000000 -d mysql:5.5 
  3.     run : 执行
  4.     -p：端口映射
  5.     --name: 自定义容器名
  6.     -e MYSQL_ROOT_PASSWORD：设置MySQLROOT用户密码
  7.     -d：后台执行