一 SpringBoot基础信息：

概述：
SpringBoot并不是Spring的新技术，只是提供了一种快速使用Spring体系的架构，其实就是对Sping做了的技术统一集成，形成一套最优的搭配方案！！简化使用Spring的难度！！！

结论：只是名字高大上，其实使用很简单，没有什么难度！！！

Spring使用的缺点：

依赖搭配繁琐，各个层级的jar包依赖优点混乱，配置比较的繁琐！用过的都知道，配置文件简直是有点难搞，反正我是记不住，弄模板修改的！

SpringBoot项目创建和结构解析(忽略):

这个要说明一下，SpringBoot项目的打包方式为jar包！！

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

这块大有研究，在SpringBoot的注解追踪中可以看到，后面对这块做详细的解释！

SpringBoot的起步依赖:

SpringBoot的起步依赖其实就是所有的SpringBoot项目起步都以依赖的父类！这个父类提供了一套最优的技术搭配版本，对各个版本的技术做了版本锁定！注意，只是版本锁定，并不是依赖引入，在需要使用时候在maven的pom文件中指明需要的依赖，然后根据起步依赖中的本版进行引入！这个是基于maven依赖传递进行的！关于maven的高级使用，后期有时间我在做专门的梳理！！！！

SpringBoot的起步依赖！


        org.springframework.boot
        spring-boot-starter-parent
        2.1.8.RELEASE

从起步依赖一直追踪下去就可以看待如下信息，看到这就该明白起步依赖只是做了版本控制！！

一 SpringBoot基础信息：

概述：

SpringBoot的自动配置：

SpringBoot的起步依赖:

二 SpringBoot的配置文件

SpringBoot的常用三种配置文件：

yaml/yml基本语法：

创建完成的SpringBooot的引导类。。。。。。。。，没啥好说的，就那样了！但是必须注意，在SpringBoot项目中，引导类必须位于其他类的上层目录，最多支持其他类和引导类同级别，但是绝对不允许其他类处于引导类之前的目录，否则其他类注解信息不会被扫描到！！

@SpringBootApplication
public class InitbootApplication {

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

}

注意：SpringBoot是对Spring使用的简化，并不是新技术。。。。。。！！！！啦啦啦啦

二 SpringBoot的配置文件

SpringBoot的常用三种配置文件：
SpringBoot的配置文件默认名字为appiclaition:

application.properties

application.yaml

application.yml

配置文件优先级别：

在同一个文件目录下SpringBoot配置文件优先级别为properties,yml,yaml

propeties文件格式忽略，yaml和yml其实就是同一个文件，只是后缀名不同而已!

yaml/yml基本语法：大小写敏感数据值前边必须有空格，作为分隔符使用缩进表示层级关系，缩进时不允许使用Tab键，只允许使用空格（各个系统 Tab对应的空格数目可能不同，导致层次混乱），缩进的空格数目不重要，只要相同层级的元素左侧对齐即可 # 表示注释，从这个字符一直到行尾，都会被解析器忽略。 yml的数据格式：

#  yml语法
#  大小写敏感
#  数据值前边必须有空格，作为分隔符
#  使用缩进表示层级关系
#  缩进时不允许使用Tab键，只允许使用空格（各个系统 Tab对应的 空格数目可能不同，导致层次混乱）。
#  缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
#   # 表示注释，从这个字符一直到行尾，都会被解析器忽略。
#  双引号内的转义字符可以别识别，但是单引号的转义字符不能被识别

#Map类型数据，键值对类型
persion:
  name: zhangsan
  age: 23

# 行内写法
persion2: {name: lisi,age: 24}

# 数组类型
hobby:
  - eat
  - drink
  - play
  - sing
# 行内写法
hobby2: {吃,喝,玩,乐}

# 单个数据写法：
#  双引号内的转义字符可以别识别，但是单引号的转义字符不能被识别
message1: '转义字符n识别'
message2: "转义字符n识别"

# 参数引用，通过美元符号引用配置文件中的其他指
eg: ${message1}

配置文件中数据获取，主要是ymal,其实properties文件中的数据也可以这样去获取！

@RestController
public class GetDateController {

    @Value("${test}")
    private String test;
    @Value("${eg}")
    private String eg;
    @Value("${persion.name}")
    private String name;
    @Value("${persion2.age}")
    private String age;
    @Value("${hobby[1]}")
    private String hobby;
    @Value("${message1}")
    private String message1;
    @Value("${message2}")
    private String message2;

    @RequestMapping("/first")
    public String getDate1() {
        System.out.println(test);
        System.out.println(eg);
        System.out.println(name);
        System.out.println(age);
        System.out.println(hobby);
        System.out.println(message1);
        System.out.println(message2);
        return "seccussful";
    }

    
    
    @Autowired
    private Environment environment;


    @RequestMapping("/second")
    public String getDate2() {
        String test = environment.getProperty("test");
        System.out.println(this.test);
        String eg = environment.getProperty("eg");
        System.out.println(this.eg);
        return "seccussful";
    }

    
    @Autowired
    private Persion persion;

    @RequestMapping("/thried")
    public String getDate3() {
        System.out.println(persion);
        return "seccussful";
    }
}

第三种获取数据方式需要的注解坐标！不要也行，不影响！

@Component

@ConfigurationProperties(prefix = "persion")
public class Persion {
    private String name;
    private String age;
//get,set方法必须拥有，这块省略
}

补充，获取当前使用的配置文件信息

@Autowired private Environment environment;

三 SpringBoot切换配置文件：

概述：其实就是配置多个环境的配置文件，根据情况进行对应的配置文件激活（配置这些的同时必须有主配置文件，激活这些配置文件的三种方式之一就是在主配置文件中进行激活的）：

• application-dev.properties/yml 开发环境 • application-test.properties/yml 测试环境 • application-pro.properties/yml 生产环境

其中在yml文件中还可以使用---作为分割符号进行多片段的配置！

示例：

---
# 修改项目的访问路径 默认值为
server.servlet.context-path: /hello1
server.port: 8081
spring.profiles: dev # 起名字
---
server.servlet.context-path: /hello2
server.port: 8082
spring.profiles: test # 起名字
---
server.servlet.context-path: /hello3
server.port: 80
spring.profiles: run # 起名字
---
##激活文件
spring:
  profiles:
    active: run

激活配置文件的方式：

1在主配置文件中激活：

properties中激活的方式：spring.profiles.active=dev

yml激活的方式：上面案例有

2 虚拟机参数：

在VM options 指定：-Dspring.profiles.active=dev

3 命令行参数：

java –jar xxx.jar --spring.profiles.active=dev

注意：说到命令行参数这块，我们在运行SpringBoot项目时候可以在命令行进行一些简单的参数指定：

java -jar .initboot-0.0.1-SNAPSHOT.jar --server.port=88

SpringBoot配置文件加载顺序：

示例项目path：D:summarySpringBootStudyinitboot

优先级别最高的是initboot同目录级别下的config目录下配置文件，接下来是initboot同目录级别的配置文件，这两个目录下的配置文件称为外置配置文件（不过这个是idea目录依据，打包配置文件不会被打进去），接下来就是resources目录下config目录下的配置文件，最后才是resources中的配置文件，结论就是外置配置文件优先级别会高于内置配置文件的优先级别！

知道这个我们就可以在项目打包后若是有问题，找到当前项目的jar包，在项目的jar包下创建config文件目录，或者配置文件，对已经的包的项目进行配置文件的替换！

四 SpringBoot整合junit

坐标(快速创建自己就会加载):


    org.springframework.boot
    spring-boot-starter-test
    test

junit
junit
4.12

测试范例类(注意引导类位置,其他没啥好说的....):

@RunWith(SpringRunner.class)
@SpringBootTest(classes = 启动类字节码文件.class)
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void test() {
        
    }
}

五 SpringBoot整合MyBatis(分页插件):

坐标创(建项目时候勾选即可):


    org.mybatis.spring.boot
    mybatis-spring-boot-starter
    2.1.0



    mysql
    mysql-connector-java

com.github.pagehelper
pagehelper-spring-boot-starter
1.2.5

SpringBoot配置文件:

properties类型的

# 修改项目的访问路径 (虚拟目录),默认值为/
server.servlet.context-path=/hello
# ?serverTimezone=UTC做时区标准化，否则报错
spring.datasource.url=jdbc:mysql:///springboot?serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root
#com.mysql.cj.jdbc.Driver和com.mysql.jdbc.Driver一样的，前面新版本，后面老版本
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# mybatis
# mapper映射文件路径,若是mapper文件存放路径和接口窜访的路径相同则这块不需要指明mapper
mybatis.mapper-locations=classpath:mapper
    //@Conditional()注解参数为判断bean加载的条件
    @Conditional(ConditionMain.class)
    @Bean
    public ConditionClass conditionClass() {
        return new ConditionClass();
    }
}
实现接口类:
public class ConditionMain implements Condition {
    
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypemetadata metadata) {
     //根据已经知道的全类名加载该类,若是加载到乐就去创建该对象到ioc容器中
            try {
                Class aClass = Class.forName(s);
                return true;
            } catch (ClassNotFoundException e) {

                return false;
            }
    }
}
示例二(自定注解类,这个可以实现多个判断.比较的灵活)

自定义的注解类(其实就是将上面的@Conditional注解添加到自定的注解类上,其他的几乎不变):
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@documented
@Conditional(ConditionMain.class)
public @interface MyCondition {
    String[] value();
}
配置类:
@Configuration
public class TestConfig {
    

    //@Conditional(ConditionMain.class)
    @Bean
    @MyCondition("判断依据")
    public ConditionClass conditionClass1() {
        return new ConditionClass();
    }
}
condition实现类接口:
public class ConditionMain implements Condition {
    
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypemetadata metadata) {
        boolean result = false;
        //获取注解类中字符串数组的数据
        Map map = metadata.getAnnotationAttributes(MyCondition.class.getName());
        System.out.println(map);
        //自定义的注解中使用的就是value
        String[] o = (String[]) map.get("value");
        for (String s : o) {
            //s就是自定义数组中参数,一般就是判断的条件!
            System.out.println(s);
            try {
                Class aClass = Class.forName(s);
                result=true;
            } catch (ClassNotFoundException e) {
            }
        }
        return result;
    }
}
示例三(根据配饰文件中的条件进行添加):

配置类(其实就是根据@ConditionalOnProperty注解的键值对获取进行动态的加载......):
@Configuration
public class TestConfig {
   
    //ConditionalOnProperty配置文件中满足name=zhangsan,值为lisi才加载值
    @Bean
    @ConditionalOnProperty(name="张三",value="李四")
    public ConditionClass conditionClass2() {
        return new ConditionClass();
    }
}
获取这些测试:
@SpringBootApplication
public class ConditionApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(ConditionApplication.class, args);
        Object conditionClass = run.getBean("conditionClass1");
        System.out.println(conditionClass);
    }
}
ConditionalOnMissingBean：判断环境中没有对应Bean才初始化Bean

自动配置Condition基本上就是这样实现的,查看源码也就是一大堆的Condiotion注解,做的事几乎大同小异!

SpringBoot加载jar中的class文件的方式:
1 通过@ComponentScan扫描包

2 使用@import导入Config类

3 使用自定注解,其实就是自定注解又使用@import注解标注,类似上面的@Conditional注解的使用!

示例:
@SpringBootApplication
//扫描指定的包,将类加载到SpringBoot的ioc容器
@ComponentScan(value = "com")
//通过配置类将对应的class加载
@import(MyConfig.class)
//自定义注解,但是实际还是使用的@import注解,这里就不做演示
public class ConditionApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(ConditionApplication.class, args);
        //Object conditionClass = run.getBean("conditionClass1");
        //System.out.println(conditionClass);
    }
}
@import注解详细使用:
1 导入类

@import(MyJavaBean.class)

2 导入配置文件

@import(MyConfig.class)

3 导入 importSelector 实现类,这个主要是用在SpringBoot的源码上,看源码认识就行

importSelector接口其实就是加载一些配置文件中的类

4 导入 importBeanDefinitionRegistrar 的实现类
public class Test implements importBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(Annotationmetadata importingClassmetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {

    }

    @Override
    public void registerBeanDefinitions(Annotationmetadata importingClassmetadata, BeanDefinitionRegistry registry) {
    //todo
        AbstractBeanDefinition beanDefinition =
                BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
        //参数一:bean的名称
        //参数二:bean的定义
        //反正就是这样,大概这样子写就ok
        registry.registerBeanDefinition("user", beanDefinition);

    }
}
@SpringBootApplication解析:

@EnableAutoConfiguration @AutoConfigurationPackage @import({Registrar.class}) Registrar 类主要是登记自定义注解标注的类或者方法,主要还是要看有无 @import({AutoConfigurationimportSelector.class}) AutoConfigurationimportSelector 间接的实现了 importantSelector 这个接口,在该接口中的 selectimportant 方法有返回值,返回值为一个 String 类型的数组, 数组中是需要加载类的全名,最终是在下面文件中读取加载的类的全名(读到不一定会加载,主要还要@Conditional 中的条件类)

大体流程图:

bean加载过程:

八切换SpringBoot内置服务器:
没啥说的,就是maven的pom.xml中引入;

org.springframework.boot
spring-boot-starter-web

spring-boot-starter-tomcat
org.springframework.boot

spring-boot-starter-jetty
org.springframework.boot

九 SpringBoot执行流程:

配置启动引导类（判断是否有启动主类）

判断是否是Web环境

获取初始化类、监听器类

感觉没啥用!!!!!! 十年八辈子都不用,并不影响开发!!!
十 SpringBoot项目部署:
1 jar包:
java -jar -..jar

2 war包

改pom文件的打包方式
war
修改引导类:
@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);
    }
}
完成打包即可,然后在服务器上的toncat的webapp目录下即可,启动该tomcat就完成war包部署

基本上就到这吧!!!!!

SpringBoot梳理

一 SpringBoot基础信息：

二 SpringBoot的配置文件

Java相关栏目本月热门文章