一、springboot相关概念

1.1 springboot的介绍

	 SpringBoot提供了一种快速使用Spring的方式，不是对spring的增强，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率
1

1.2 springboot的核心功能

1.2.1 自动配置

		Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是SpringBoot自动完成的。
1

1.2.1 起步依赖

		起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。
		简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。
1
2

1.2.1 辅助功能

		提供了一些大型项目中常见的非功能性特性，如嵌入式服务器（启动的时候不用去配置额外的服务器 ：例如tomcat）、安全、指标，健康检测、外部配置等。
1

1.3springboot的优势

	注意：Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式
	优势：弥补了spring的缺点
	spring缺点：
1
2
3

​ 1、配置文件 多 、难记、配置繁琐 ==>spring boot 自动配置功能解决spring这个缺点

​ 2、依赖繁琐 项目构造工具 导坐标—> 坐标–>版本兼容 ==>spring boot 自动起步依赖解决spring这个缺点

二、springboot快速入门

2.1 （一个基于springboot的简单web模块）流程步骤

		1、创建Maven工程
		2、添加SpringBoot的启动器
		3、编写SpringBoot引导类
		4、编写Controller
		5、测试
1
2
3
4
5

2.2 springboot的快速构建

	通过提供的服务器的统一资源定位符去初始化一个springboot项目，默认为starts.spring.io；但是忒慢了，建议使用starts.aliyun.io;（之后也可以在自己的maven工程的setting文件中设置拉取jar包的地址也为aliyun的 通过setting.xml文件中<miorres>标签设置，这样之后 你拉jar包的坐标会变快很多）
1

三、springboot的配置文件

3.1 springboot的配置文件分类

		spring-boot提供的配置文件的分类：
		1、properties
		2、yaml/yml
		之所以有些是因为：
		SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。
		1. 默认配置文件名称：application
		2. 在同一级目录下配置文件夹的**执行优先级**为：properties>yml > yaml
1
2
3
4
5
6
7

3.1.1 springboot配置文件中yaml(yml)后缀的配置文件的基本语法

3.1.1.1yaml(yml)的概念

			yaml ain‘t markup language 不是标记语言 是一种直观的能够被电脑识别的数据序列化格式，yaml是以数据为中心比传统的xml更简洁，更好的以数据为核心
1

3.1.1.2 基本语法

		- 大小写敏感
		- 数据值前边必须有空格，作为分隔符
		- 使用缩进表示层级关系
1
2
3

•     - 缩进时不允许使用Tab键，只允许使用空格（各个系统 Tab对应的 空格数目可能不同，导致层次混乱）。
      - 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
  1
  2

•     - ''#" 表示注释，从这个字符一直到行尾，都会被解析器忽略。
  1

3.1.1.2 数据格式

	yaml支持（三种不同的数据格式：对象 、数组、 纯（常）量）
1

3.1.1.2.1 对象（map）

	键值对的集合。缩进表示子父的关系  （注意空格）
	eg：
	[^1]: person:  
			 name: zhangsan
  行内写法：person: {name: zhangsan}
1
2
3
4
5

3.1.1.2.2 数组

	一组按次序排列的值 横杠+空格
	eg：
	address:
		- beijing
  		- shanghai
	行内写法
	address: [beijing,shanghai]
1
2
3
4
5
6
7

3.1.1.2.3 纯(常)量

		单个的、不可再分的值  （常量）
		eg:
		msg1: 'hello \n world'  # 单引忽略转义字符
		msg2: "hello \n world"  # 双引识别转义字符
1
2
3
4

3.1.1.2 yaml相关的参数，获取yaml中属性中的值 通过:${}符号

		eg：
		name: lisi 
		person:
			 name: ${name} # 引用上边定义的name值
1
2
3
4

3.1.1.3 获取数据方式

		第一，首先要先搞清楚，为什么要获取配置文件的数据，这是一位在配置文件中，会有两种关于不同内容的配置，一种是自定义另一种是会被springboot自动识别的，而自定义的配置信息springboot不会解析到，这时候 如何获取配置文件中的自定义信息 就极为重要了，在此提及三种活起配置文件中的数据；
		方式一：通过在需要获取配置文件中值的java类的有关属性上，使用@Value注解，通过“${}”这个符号，获取值
		方式二：通过Evironment对象中getProperty()方法
		方式三：通过@ConfigurationProperties ：配置内容 与 对象进行相互绑定的方式，注意：prefix（前缀）一定要写
1
2
3
4

3.1.2 springboot配置文件中profile属性的设置

3.1.2.1 profile是什么？

		profile是springboot配置文件中的一个属性，通过指定这个属性的值，从而完成切换不同的环境
1

3.1.2.2 profile的作用

		profile是用来完成不同环境下，配置动态切换功能的
1

3.1.2.3 profile的配置方式

多profile文件方式：提供多个配置文件，每个代表一种环境。

​ application-dev.properties/yml 开发环境

​ application-test.properties/yml 测试环境

​ application-pro.properties/yml 生产环境

yml多文档方式：

​ 在yml中使用 — 分隔不同配置

3.1.2.4 profile激活方式

	- 配置文件： 再配置文件中配置：spring.profiles.active=dev
	- 虚拟机参数：在VM options 指定：-Dspring.profiles.active=dev
	- 命令行参数：java –jar xxx.jar  --spring.profiles.active=dev
	执行顺序：虚拟机参数 >配置文件,命令行参数>配置文件
1
2
3
4

3.2 项目内部配置文件的加载顺序

	 加载顺序为以下的排列顺序，高优先级配置的属性会生效
	- file:./config/：当前项目下的/config目录下  ：高	
	- file:./           ：当前项目的根目录 ：中上
	- classpath:/config/：classpath的/config目录 ：中
	- classpath:/  ：classpath的根目录 ：下
1
2
3
4
5

3.3 项目外部配置的加载顺序

3.3.1 外部配置文件的作用

		与内部配置形成互补 ，当内部配置文件有错，配置外部配置 就可以减少去再次修改内部配置 减少打包次数
1

3.3.1 外部配置文件的位置

	1.命令行
	java -jar app.jar --name="Spring“ --server.port=9000
	2.指定配置文件位置
	 java -jar myproject.jar --spring.config.location=e://application.properties
	3.外部不带profile的properties文件
    classpath:/config/application.properties
    classpath:/application.properties
1
2
3
4
5
6
7

四、spring整合起他技术

4.1 SpringBoot整合Junit

步骤：
1. 搭建SpringBoot工程
2. 引入starter-test起步依赖
3. 编写测试类
涉及@runwith中SpringRunner.class
@SpringBootTest,SpringbootJunitApplication.class
test中和java包一摸一样，就可以不指定SpringBootTest中classes属性
4. 测试
起步依赖：

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
1
2
3
4
5
6
7
8
9
10
11
12

测试类

/**
 * 测试类
 */

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootJunitApplication.class )
public class UserServiceTest {

    @Test
    public void test(){
        System.out.println(111);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

4.2 SpringBoot整合Mybatis

步骤：

	①搭建SpringBoot工程
	②引入mybatis起步依赖，添加mysql驱动	
1
2

<dependencies>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <!--<scope>runtime</scope>-->
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

	③编写DataSource和MyBatis相关配置：application.yml
1

# datasource
spring:
  datasource:
    url: jdbc:mysql:///springboot?serverTimezone=UTC
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
# mybatis config-location：指定mybatis的核心配置文件
mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml # mapper映射文件路径
  type-aliases-package: com.itheima.springbootmybatis.domain

  # config-location:  # 指定mybatis的核心配置文件
1
2
3
4
5
6
7
8
9
10
11
12
13

	④定义表和实体类
	⑤编写dao和mapper文件/纯注解开发（xml/Annno）
	⑥测试
1
2
3

4.3 SpringBoot整合redis

步骤:
①搭建SpringBoot工程
②引入redis起步依赖
③配置redis相关属性
④注入RedisTemplate模板
⑤编写测试方法，测试:注意使用@RunWith(SpringRunner.class)指定测试环境

五、springboot进阶

5.1 springboot的自动配置

5.1.1关于自动配置中的条件注解@Condition

5.1.1.1先了解condition是啥？

		 Condition（条件）是Spring4.0后引入的条件化配置接口，通过实现Condition接口可以完成有条件的加载相应的Bean
1

5.1.1.2使用步骤：

	1、class条件接口 实现condition  重写方法 （返回boolean）
1

public class ClassCondition implements Condition {
    /**
     *
     * @param context 上下文对象。用于获取环境，IOC容器，ClassLoader对象
     * @param metadata 注解元对象。 可以用于获取注解定义的属性值
     * @return
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
      
        //1.需求： 导入Jedis坐标后创建Bean
        //思路：判断redis.clients.jedis.Jedis.class文件是否存在
        boolean flag = true;
        try {
	          //forName("类的全限定名")
            Class<?> cls = Class.forName("redis.clients.jedis.Jedis");
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;
      
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

   2、在需要spring创建的bean对象的地方加上一个@Condition条件标签
   	注意：@Conditional要配和Condition的实现类（ClassCondition）进行使用
1
2

5.1.1.3 condition的进阶使用

		需求：将类的判断定义为动态的。判断哪个字节码文件存在可以动态指定
		步骤：
		1、自定义条件注解类
1
2
3

import org.springframework.context.annotation.Conditional;
import java.lang.annotation.*;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ClassCondition.class)
public @interface ConditionOnClass {
    String[] value();
}
1
2
3
4
5
6
7
8
9

**注意：**此处@ConditionOnClass为自定义注解
2、创建bean对象的配置类

@Configuration
public class UserConfig {
    @Bean
    //@Conditional(ClassCondition.class)
    @ConditionOnClass("com.alibaba.fastjson.JSON")
    public User user(){
        return new User();
    }
    @Bean
    @ConditionalOnProperty(name = "itcast",havingValue = "itheima")
    public User user2(){
        return new User();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5.1.2 关于自动配置中的切换WEB服务器

		步骤：先排除原有项目中默认的tomcat服务器，然后再引入其他其他web服务器的坐标，例如：jetty服务器
1

5.1.3 关于自动配置中@Enable注解的原理

为啥有它？
	由于SpringBoot不能直接获取在其他工程中定义的Bean
1
2

5.1.4 关于自动配置中@Import详解

@Enable*底层依赖于@Import注解导入一些类，使用@Import导入的类会被Spring加载到IOC容器中。而@Import提供4中用法：
	①导入Bean
	②导入配置类
	③导入 ImportSelector 实现类。一般用于加载配置文件中的类
	④导入 ImportBeanDefinitionRegistrar 实现类。
1
2
3
4
5

5.1.5 关于自动配置中@EnableAntoConfiguration详解

@EnableAutoConfiguration 注解内部使用 @Import(AutoConfigurationImportSelector.class)来加载配置类。
配置文件位置：META-INF/spring.factories，该配置文件中定义了大量的配置类，当 SpringBoot 应用启动时，会自动加载这些配置类，初始化Bean
并不是所有的Bean都会被初始化，在配置类中使用Condition来加载满足条件的Bean

5.1.6 关于自动配置中自定义Starter

自定义starter步骤分析
①创建 redis-spring-boot-autoconfigure 模块
②创建 redis-spring-boot-starter 模块,依赖 redis-spring-boot-autoconfigure的模块
③在 redis-spring-boot-autoconfigure 模块中初始化 Jedis 的 Bean。并定义META-INF/spring.factories 文件
④在测试模块中引入自定义的 redis-starter 依赖，测试获取 Jedis 的Bean，操作 redis。
自定义starter步骤实现方式
实现方式一
1、创建redis-spring-boot-starter工程
2、创建redis-spring-boot-autoconfigure配置工程
3、创建RedisProperties配置文件参数绑定类
4、 创建RedisAutoConfiguration自动配置类
5、在resource目录下创建META-INF文件夹并创建spring.factories
6、在springboot-enable工程中引入自定义的redis的starter
测试
实现方式二
测试springboot-enable工程中的application.properties中的配置参数
使用注解完成有条件加载配置类
会报错：这是由于你在项目中配置redis的端口号，但是服务器的端口号，依然是6379

5.2 springboot的监控

Java中的事件监听机制定义了以下几个角色：
	①事件：Event，继承 java.util.EventObject 类的对象
	②事件源：Source ，任意对象Object
	③监听器：Listener，实现 java.util.EventListener 接口 的对象
SpringBoot 在项目启动时，会对这几个监听器进行回调
	- ApplicationContextInitializer、
		resource文件夹下添加META-INF/spring.factories，添加相关键值对配置
	- SpringApplicationRunListener、
		resource文件夹下添加META-INF/spring.factories，添加相关键值对配置
		使用要添加**构造器**
	- CommandLineRunner、
		使用@Component放入容器即可使用
	- ApplicationRunner
		使用@Component放入容器即可使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5.2.1 流程分析

	初始化
		1.  配置启动引导类（判断是否有启动主类）
		2.  判断是否是Web环境
		3.  获取初始化类、监听器类
		图解
			
	run
		1. 启动计时器
		2. 执行监听器
		3. 准备环境
		4. 打印banner：可以resource下粘贴自定义的banner
		5. 创建context
		图解
1
2
3
4
5
6
7
8
9
10
11
12
13

5.2.2 actuator工具基本使用

	是个啥？
	监控工具包,用来在程序运行时监控运行数据,开发者可以使用http端点或jmx来管理和监控应用程序的健康状况、应用信息、内存使用状况等
	步骤
		 ①导入依赖坐标
		②访问http://localhost:8080/acruator
		配置文件相关配置
			开启健康检查详细信息
				management.endpoint.health.show-details=always
			开启所有endpoint
				management.endpoints.web.exposure.include=*
springboot admin图形化界面使用
	SpringBoot Admin 有两个角色，客户端(Client)和服务端(Server)。
	步骤
		①创建 admin-server 模块
		②导入依赖坐标 admin-starter-server
		③在引导类上启用监控功能@EnableAdminServer
		4、创建 admin-client 模块
		5、导入依赖坐标 admin-starter-client
		6、配置相关信息：server地址等
		7、配置相关信息：server地址等
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

5.3 springboot的部署

支持两种方式部署到服务器
	①jar包(官方推荐)
	②war包
		步骤
			1、更改pom文件中的打包方式为war
1
2
3
4
5

可以在标签中设置,标签设置打war包后的名称
2、修改启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class SpringbootDeployApplication extends SpringBootServletInitializer {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootDeployApplication.class, args);
    }


    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(SpringbootDeployApplication.class);
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20