这里写目录标题

1. 原理分析
2. 监控
3. 项目部署
- 3.1
  
  jar 包
- 3.2
  
  war 包

1. 原理分析

1.1 自动配置

1.1.1
`@Condition`

Condition是在Spring 4.0增加的条件判断功能，通过这个可以功能可以实现选择性的创建Bean操作。

思考

SpringBoot是如何知道要创建哪个Bean的? 比如
- SpringBoot是如何知道要创建RedisTemplate的?

案例实操

在Spring 的IOC容器中有一个 User 的 Bean，现要求:
- 导入Jedis坐标后，加载该Bean，没导入，则不加载。

前期准备

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

package com.ithema.springbootconditional.domain;

public class User {
}

定义User的配置类(用来返回与user相关的Bean)

//定义配置类，用来返回与user相关的Bean
package com.ithema.springbootconditional.config;

import com.ithema.springbootconditional.condition.ClassCondition;
import com.ithema.springbootconditional.domain.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {

    //用来返回与user相关的Bean
    @Bean
    @Conditional(ClassCondition.class)
    public User user(){
        return  new User();
    }
}

定义判断类

//定义条件类
package com.ithema.springbootconditional.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class ClassCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //1.需求： 导入Jedis坐标后创建Bean
        //思路：判断redis.clients.jedis.Jedis.class文件是否存在
        boolean flag = true;
        try {
            Class<?> cls = Class.forName("redis.clients.jedis.Jedis");
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;
    }
}

执行引导类

package com.ithema.springbootcondition;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class SpringbootConditionApplication {

    public static void main(String[] args) {
        //启动SpringBoot的应用，返回Spring的IOC容器
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);

        //获取Bean，redisTemplate
        Object redisTemplate = context.getBean("redisTemplate");
        System.out.println(redisTemplate);
    }
}

在Spring 的IOC容器中有一个 Student 的 Bean，现要求:
- 将类的判断定义为动态的。判断哪个字节码文件存在可以动态指定。
  
  (高级)

package com.ithema.springbootconditional.domain;

public class Student {
}

//定义配置类，用来返回与user相关的Bean
package com.ithema.springbootconditional.config;

import com.ithema.springbootconditional.condition.ConditionOnClass;
import com.ithema.springbootconditional.domain.Student;
import org.springframework.context.annotation.Bean;

public class StudentConfig {
    @Bean
    @ConditionOnClass("redis.clients.jedis.Jedis")
    public Student student(){
        return  new Student();
    }
}

package com.ithema.springbootconditional.condition;
import java.lang.annotation.*;
import org.springframework.context.annotation.Conditional;

@Target({ElementType.TYPE, ElementType.METHOD})//表示该注解(ConditionOnClass)可以加在哪上面TYPE(类)/Method
@Retention(RetentionPolicy.RUNTIME)//注解生效的实际
@Documented//生成文档
@Conditional(StudentConditon.class)
public @interface ConditionOnClass {
    String[] value();
}

//定义条件类
package com.ithema.springbootconditional.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

import java.util.Map;

public class StudentConditon implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //2.需求： 导入通过注解属性值value指定坐标后创建Bean
        //获取注解属性值：value
        String s = ConditionOnClass.class.getName();
        System.out.println(s);
        Map<String, Object> map = metadata.getAnnotationAttributes("s");
        System.out.println(map);  //{value=[redis.clients.jedis.Jedis]}

        String[] value = (String[]) map.get("value");

        boolean flag = true;
        try {
            for (String className : value) {
                Class.forName(className);
            }
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;
    }
}

小结

自定义条件:
1. 定义条件类
  ：自定义类
  实现Condition接口
  ，重写matches方法，在matches方法中进行逻辑判断，返回 boolean值。matches方法两个参数:
  - context：上下文对象，可以获取属性值，获取类加载器，获取BeanFactory等。.
  - metadata：元数据对象，用于获取注解属性。
    
    2.
    判断条件
    ：在初始化Bean时，使用@conditional(条件类.class)注解
SpringBoot提供的常用条件注解:
- @ Conditional：根据条件，决定类是否加载到Spring Ioc容器中，在SpringBoot中有大量的运用
- @ConditionalonProperty：判断配置文件中是否有对应属性和值才初始化Bean.
- @ConditionalOnClass：判断环境中是否有对应字节码文件才初始化Bean
- @ConditionalOnMissingBean：判断环境中没有对应Bean才初始化Bean
@ConditionalonProperty
：
案例演示

//使用springboot提供的ConditionalonProperty注解 实现条件判断
@Bean("user2")
@ConditionalOnProperty(name = "itcast",havingValue = "heima")
public User getUser2(){
    return new User();
}

# 在yml或这propreties中配置相关内容
# itoldlu=oldlu
itoldlu: oldlu

1.1.2
`切换内置web服务器`

SpringBoot的web环境中默认使用tomcat作为内置服务器，其实SpringBoot提供了
4中内置服务器
供我们选择，我们可以很方便的进行切换。
- tomcat
- Jetty
- Netty
- Undertow

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
    <!--排除tomcat依赖-->
    <exclusions>
         <exclusion>
             <artifactId>spring-boot-starter-tomcat</artifactId>
             <groupId>org.springframework.boot</groupId>
         </exclusion>
    </exclusions>
</dependency>

<!--引入jetty的依赖-->
<dependency>
   <artifactId>spring-boot-starter-jetty</artifactId>
   <groupId>org.springframework.boot</groupId>
</dependency>

1.1.3
`@Enable*注解`

思考

SpringBoot工程是否可以直接获取jar包中定义的Bean?
- 回答：当然不可以
那么我们应该怎么获取呢?
- 请看下面讲解

案例讲解

前提准备
- 创建springboot-enable模块

//springboot-enable引导类，我们在这里获取springboot-enable-other的user Bean。
package com.ithema.springbootenableother;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
        //springboot不能直接获取其他模块的Bean,原因为@SpringBootApplication中的注解@ComponentScan
        Object user = context.getBean("user");
        System.out.println(user);
    }

}

前提准备2
- 创建springboot-enable-other模块，该模块主要提供Bean的定义，无实际操作。

//domian包下创建一个User类
package com.ithema.domain;

public class User {
}

//config目录下创建一个User的配置类
package com.ithema.config;

import com.ithema.domain.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {
    @Bean
    public User user(){
        return new User();
    }
}

前期准备3
- 让springboot-enable模块去依赖与springboot-enbale-other模块

<dependency>
     <groupId>com.ithema</groupId>
     <artifactId>springboot-enable-other</artifactId>
     <version>0.0.1-SNAPSHOT</version>
</dependency>

解决办法

方法1

：

package com.ithema.springbootenable;

import com.ithema.config.EnableUser;
import com.ithema.config.UserConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;

/**
 * @ComponentScan 扫描范围：当前引导类所在包及其子包
 *
 * com.ithema.springbootenable
 * com.ithema.config
 * 方法 1.解决springboot不能直接获取其他模块的Bean，可以使用@ComponentScan扫描com.ithema.config包
 */
@SpringBootApplication
@ComponentScan("com.ithema.config")  //com.ithema.domain.User@585ac855
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
   
        Object user = context.getBean("user");
        System.out.println(user);
    }

}

方法2

：

package com.ithema.springbootenable;

import com.ithema.config.EnableUser;
import com.ithema.config.UserConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;

/**
 * @ComponentScan 扫描范围：当前引导类所在包及其子包
 *
 * com.ithema.springbootenable
 * com.ithema.config
 * 方法 1.解决springboot不能直接获取其他模块的Bean，可以使用@ComponentScan扫描com.ithema.config包
 * 方法 2.可以使用@Import注解，加载类。这些类都会被Spring创建，并放入IOC容器
 */
@SpringBootApplication
@Import(UserConfig.class)  //com.ithema.domain.User@7c2a69b4
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
        //springboot不能直接获取其他模块的Bean,原因为@SpringBootApplication中的注解@ComponentScan
        Object user = context.getBean("user");
        System.out.println(user);
    }

}

方法3

：

//提前在springboot-enable-other模块中提供一个@EnableUser供使用
package com.ithema.config;

import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(UserConfig.class)
public @interface EnableUser {
}

package com.ithema.springbootenable;

import com.ithema.config.EnableUser;
import com.ithema.config.UserConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;

/**
 * @ComponentScan 扫描范围：当前引导类所在包及其子包
 *
 * com.ithema.springbootenable
 * com.ithema.config
 * 方法 1.解决springboot不能直接获取其他模块的Bean，可以使用@ComponentScan扫描com.ithema.config包
 * 方法 2.可以使用@Import注解，加载类。这些类都会被Spring创建，并放入IOC容器
 * 方法 3.可以对Import注解进行封装。
 */
@SpringBootApplication
@EnableUser  //com.ithema.domain.User@3eba57a7
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
        //springboot不能直接获取其他模块的Bean,原因为@SpringBootApplication中的注解@ComponentScan
        Object user = context.getBean("user");
        System.out.println(user);
    }

}

解析：
方法3就是我们接下来讲的SpringBoot为我们提供的
@Enable*注解
。

SpringBoot中提供了很多Enable开头的注解，这些注解都是用于动态启用某些功能的。而其底层原理是使用@lmport注解导入一些配置类，实现Bean的动态加载。

1.1.4
`@lmport注解`

@Enable*
底层依赖于@lmport注解导入一些类，使用@lmport导入的类会被Spring
加载到IOC容器
中。而@Import
提供4中用法
：

导入Bean
导入配置类
导入lmportSelector实现类。一般用于加载配置文件中的类
导入lmportBeanDefinitionRegistrar实现类。

用法 1：导入Bean

//用法1：导入Bean
@SpringBootApplication
@Import(User.class)
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
        
        User user = context.getBean(User.class);
        System.out.println(user);//com.ithema.domain.User@41477a6d

        Map<String,User> map =  context.getBeansOfType(User.class);
        System.out.println(map);//获取Bean的名称，全路径：{com.ithema.domain.User=com.ithema.domain.User@41477a6d}
    }
}

用法 2：导入配置类

//用法2：导入配置类，它可以同时把多个Bean 加载到IOC容器中
package com.ithema.domain;

public class Role {
}

package com.ithema.config;

import com.ithema.domain.Role;
import com.ithema.domain.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//@Configuration  使用方法2可以不加该注解
public class UserConfig {

    @Bean
    public User user() {
        return new User();
    }

    @Bean
    public Role role() {
        return new Role();
    }
}

//用法2：导入配置类，它可以同时把多个Bean 加载到IOC容器中
@SpringBootApplication
@Import(UserConfig.class)
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
        
        User user = context.getBean(User.class);
        System.out.println(user);

        Role role = context.getBean(Role.class);
        System.out.println(role);
    }
}

用法 3：导入lmportSelector实现类。一般用于加载配置文件中的类

package com.ithema.config;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.ithema.domain.User", "com.ithema.domain.Role"};
    }
}

package com.ithema.springbootenable;

import com.ithema.config.EnableUser;
import com.ithema.config.MyImportSelector;
import com.ithema.config.UserConfig;
import com.ithema.domain.Role;
import com.ithema.domain.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;

import java.util.Map;

@SpringBootApplication
@Import(MyImportSelector.class)
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
        
        User user = context.getBean(User.class);
        System.out.println(user);

        Role role = context.getBean(Role.class);
        System.out.println(role);
    }

}

用法4：导入lmportBeanDefinitionRegistrar实现类

//用法4
package com.ithema.config;

import com.ithema.domain.User;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
        registry.registerBeanDefinition("user", beanDefinition);

    }
}

package com.ithema.springbootenable;

import com.ithema.config.EnableUser;
import com.ithema.config.MyImportBeanDefinitionRegistrar;
import com.ithema.config.MyImportSelector;
import com.ithema.config.UserConfig;
import com.ithema.domain.Role;
import com.ithema.domain.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;

import java.util.Map;

@SpringBootApplication
@Import(MyImportBeanDefinitionRegistrar.class)
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);


        User user = context.getBean(User.class);
        System.out.println(user); //com.ithema.domain.User@796d3c9f

        Object user2 = context.getBean("user");
        System.out.println(user2);//com.ithema.domain.User@796d3c9f  为什么对象一样？是单例哦
    }

}

1.1.5
`@EnableAutoConfiguration注解`

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

1.1.6 小结：
`案例实操`

需求：
- 自定义redis-starter。要求当导入redis坐标时，SpringBoot自动创建Jedis的Bean。
实现步骤：
- 创建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。

1.2 监听机制

1.2.1 Java监听机制

SpringBoot的监听机制，其实是对
Java提供的事件监听机制的封装
。

Java中的事件监听机制定义了以下几个角色:

事件: Event，继承java.util.EventObject类的对象
事件源:Source，任意对象Object
监听器:Listener，实现java.util.EventListener 接口的对象

1.2.2 SpringBoot监听机制

SpringBoot在项目启动时，会对几个监听器进行回调，我们可以实现这些监听器接口，在项目启动时完成—些操作。

ApplicationContextInitializer、
SpringApplicationRunListener、
CommandLineRunner、
ApplicationRunner

1.3 启动流程分析

在这里插入图片描述

2. 监控

2.1 监控概述

SpringBoot自带
监控功能Actuator
，可以帮助实现对程序内部运行情况监控，比如

监控状况、
Bean加载情况
、
配置属性
、
日志信息等。

2.2 监控使用

2.2.1
`使用步骤`

第一步：
导入依赖坐标

<!--导入依赖坐标-->
<dependency>
	<groupld>org.springframework.boot</groupld>
	<artifactld>spring-boot-starter-actuator</artifactld>
</dependency>

第二步：
访问 http://localhost:8080/actuator

2.2.2
`案例实操`

可以在
application.properties
配置下面相关信息。若不配置则只能监控
info
和
health
的内容

# 注意：springboot2.7.2中，info端点默认是不启用，info开头的变量默认也是不启用的
info.name=zhangsan
info.age=23

# springboot2.7.2需要 启用配置里的info开头的变量
management.info.env.enabled=true

# 开启健康检查的完整信息
management.endpoint.health.show-details=always

# 将所有的监控endpoint暴露出来
management.endpoints.web.exposure.include=*

访问

2.3

SpringBoot Admin

Spring Boot Admin是一个开源社区项目，用于管理和监控SpringBoot应用程序。
Spring Boot Admin有两个角色，客户端
(Client)
和服务端
(Server)
。
应用程序作为
Spring Boot Admin Client
向为
Spring Boot Admin Server
注册
Spring Boot Admin Server
的
UI界面
将
Spring Boot Admin Client
的
Actuator Endpoint
上的一些监控信息。