一、验证注解

1.1 Java已有注解

常用的一些验证注解：

@Null    被注释的元素必须为 null
@NotNull    被注释的元素必须不为 null
@AssertTrue    被注释的元素必须为 true
@AssertFalse    被注释的元素必须为 false
@Min(value)    被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@Max(value)    被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@DecimalMin(value)    被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@DecimalMax(value)    被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@Size(max, min)    被注释的元素的大小必须在指定的范围内
@Digits (integer, fraction)    被注释的元素必须是一个数字，其值必须在可接受的范围内
@Past    被注释的元素必须是一个过去的日期
@Future    被注释的元素必须是一个将来的日期
@Pattern(value)    被注释的元素必须符合指定的正则表达式

1.2 自定义验证注解

我们可以根据项目实际需求，自定义合适的验证注解来帮助我们对数据进行校验。实现自定义注解做验证需要借助Java官方提供的@Constraint注解，使用此注解来引入验证注解所需要的验证逻辑。

1.2.1 创建自定义注解

自定义注解的处理逻辑，可以指定一个，也可以指定多个，多个时使用逗号分隔。

/**
 * 自定义验证注解
 *
 * @author maomaochong
 * @date 2021/11/19 10:56
 **/
@Documented
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RUNTIME)
// 指定验证处理逻辑所在类，可以指定多个，用逗号分隔
@Constraint(validatedBy = RequiredValidator.class)
public @interface Required {
    int min() default 0;
    int max() default 0;
    // 提示消息
    String message() default "参数校验不通过，请重新输入";
    // 分组
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

1.2.2 创建验证处理逻辑

验证逻辑处理类可以直接使用内部类的形式定义在注解内部，也可以定义在外部。
此处理类需要实现接口ConstraintValidator<A extends Annotation, T>，它有两个泛型，第一个是自定义的注解类，第二个就是要验证的数据的类型（例如写了String类型的数据，那么这个注解就要放在String类型的字段上才会起作用，也可以直接写两个，自动识别String和Long, 最简便的写成Object，那么它可以接收任何数据类型的数据）。
而且在类里面需要实现接口的两个方法，initialize和isValid，第一个是初始化方法，第二个是验证的逻辑方法，返回true，则验证通过，否则则不通过。

参考：https://www.jianshu.com/p/4688c55e0d64

/**
 * 验证注解逻辑
 *
 * @author maomaochong
 * @date 2021/11/19 11:06
 **/
public class RequiredValidator implements ConstraintValidator<Required, Object> {
    private Integer min;
    private Integer max;
    /**
     * 初始化方法
     * @param constraintAnnotation
     */
    @Override
    public void initialize(Required constraintAnnotation) {
        this.min = constraintAnnotation.min();
        this.max = constraintAnnotation.max();
    }
    /**
     * 验证处理逻辑:
     *      返回true,则验证通过，否则则不通过
     *
     * @param value
     * @param context
     * @return
     */
    @Override
    public boolean isValid(Object value, ConstraintValidatorContext context) {
        if (value == null) {
            return false;
        }
        if (value.toString().trim().length() < min || value.toString().trim().length() > max) {
            return false;
        }
        return true;
    }
}

自定义注解逻辑处理类由于实现了ConstraintValidator接口，所以它默认被spring管理成bean,所以可以在这个逻辑处理类里面用@Autowiredu或者@Resources注入别的服务，而且不用在类上面用@Compent注解成spring的bean.<br />自定义验证类型注解类里面由于是用于验证数据，一般在里面加上：

String message() default "参数校验不通过，请重新输入";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};

二、Bean生命周期

对于bean来说，其大致的生命周期如下：

2.1 注册bean时指定初始化和销毁方法

在Spring中，通过IOC容器来管理bean的生命周期，我们可以自定义初始化和销毁方法，容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法。

构造bean对象的时机：

• 单实例：在容器启动的时候创建对象
• 多实例：在每次获取的时候创建对象

我们可以在注册bean的时候，指定该bean对象的自定义初始化方法和销毁方法：

/**
 * @author maomaochong
 * @date 2022/06/07 22:48
 **/
public class Car {
    public Car() {
        System.out.println("car constructor...");
    }
    public void init() {
        System.out.println("car...init...");
    }
    public void destroy() {
        System.out.println("car...destroy...");
    }
}

/**
 * bean生命周期 配置类
 *
 * @author maomaochong
 * @date 2022/06/07 22:51
 **/
@Configuration
public class MainConfigOfLifeCycle {
    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }
}

可以看到，在创建及关闭容器时，bean的初始化及销毁方法被调用，即：

• 初始化：在对象创建完成，并赋好值后调用初始化方法，

• 销毁：

  • 单实例：在容器关闭时调用销毁方法

  • 多实例：容器不负责bean的销毁，所以不会调用销毁方法

    /**
    * 测试
    *
    * @author maomaochong
    * @date 2022/06/07 22:54
    **/
    public class BeanLifeCycleTest {
    @Test
    public void test01() {
    // 创建ioc容器
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
    System.out.println("容器创建完成。。");
    // 关闭容器
    applicationContext.close();
    }
    }

    car constructor...
    car...init...
    容器创建完成。。
    car...destroy...

2.2 通过让Bean实现指定接口

对于InitializingBean接口，其中只定义了一个afterPropertiesSet()方法，其是在BeanFactory设置所有属性后做出反应的 bean 实现的接口，相应的Bean可以实现此接口，重写其中方法，可以在方法内部执行整体配置和最终初始化的验证，可以在配置错误的情况下（例如未能设置基本属性）或由于任何其他原因初始化失败，抛出异常。
对于DisposableBean接口，其中只定义了一个destroy()方法，由想要在销毁时释放资源的 bean 实现的接口。 BeanFactory将在单独销毁作用域 bean 时调用 destroy 方法，在spring容器销毁前执行。我们可以让 bean 实现此接口并重启其方法，在方法内部做自定义的销毁操作。在关闭错误的情况下。 异常将被记录但不会重新抛出以允许其他 bean 也释放它们的资源。
通过让bean实现InitializingBean（定义初始化逻辑）及DisposableBean（定义销毁逻辑）接口，重写其方法，来实现初始化和销毁操作的指定。

/**
 * @author maomaochong
 * @date 2022/06/07 23:40
 **/
@Component
public class Cat implements InitializingBean, DisposableBean {
    public Cat() {
        System.out.println("cat constructor..");
    }
    /**
     * 销毁方法
     *      销毁单例时由BeanFactory调用
     *
     * @throws Exception 在出现终止错误时抛出
     *                   异常将会被记录，但不会允许其他bean继续释放他们的资源
     */
    @Override
    public void destroy() throws Exception {
        System.out.println("cat destroy...");
    }
    /**
     * 初始化方法
     *      在设置了bean所有的属性之后由BeanFactory调用
     *
     * @throws Exception 配置错误（如未能设置基本属性），或初始化失败时抛出异常
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("cat afterPropertiesSet...");
    }
}

/**
 * bean生命周期 配置类
 *
 * @author maomaochong
 * @date 2022/06/07 22:51
 **/
@ComponentScan("com.moomooyu")
@Configuration
public class MainConfigOfLifeCycle {
    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }
}

2.3 使用JSR250注解指定

@PostConstruct：在bean创建完成并且属性赋值完成后，来执行初始化
@PreDestroy：在容器销毁bean之前通知我们进行清理工作

/**
 * @author maomaochong
 * @date 2022/06/09 23:45
 **/
@Component
public class Dog {
    public Dog() {
        System.out.println("dog constructor...");
    }
    // 对象创建并赋值之后调用
    @PostConstruct
    public void init() {
        System.out.println("Dog...@PostConstructor...");
    }
    // 容器移除对象之前
    @PreDestroy
    public void destroy() {
        System.out.println("Dog...@PreDestroy....");
    }
}

2.4 bean的后置处理器BeanPostProcessor

在bean的初始化前后做一些操作。

public interface BeanPostProcessor {
    // 对任意新bean实例，
    // 在其任何初始化回调之前执行
    //         （如 InitializingBean 的afterPropertiesSet或自定义 init 方法）
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
    // 对任意新bean实例，
    // 在其任何初始化回调之后执行
    //         （如 InitializingBean 的afterPropertiesSet或自定义 init 方法）
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
｝

/**
 * @author maomaochong
 * @date 2022/06/07 23:40
 **/
@Component
public class Cat implements InitializingBean, DisposableBean {
    public Cat() {
        System.out.println("cat constructor..");
    }
    /**
     * 销毁方法
     *      销毁单例时由BeanFactory调用
     *
     * @throws Exception 在出现终止错误时抛出
     *                   异常将会被记录，但不会允许其他bean继续释放他们的资源
     */
    @Override
    public void destroy() throws Exception {
        System.out.println("cat destroy...");
    }
    /**
     * 初始化方法
     *      在设置了bean所有的属性之后由BeanFactory调用
     *
     * @throws Exception 配置错误（如未能设置基本属性），或初始化失败时抛出异常
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("cat afterPropertiesSet...");
    }
}

/**
 * @author maomaochong
 * @date 2022/06/09 23:45
 **/
@Component
public class Dog {
    public Dog() {
        System.out.println("dog constructor...");
    }
    // 对象创建并赋值之后调用
    @PostConstruct
    public void init() {
        System.out.println("Dog...@PostConstructor...");
    }
    // 容器移除对象之前
    @PreDestroy
    public void destroy() {
        System.out.println("Dog...@PreDestroy....");
    }
}

执行结果如下：

cat constructor..
postProcessBeforeInitialization...com.moomooyu.bean.Cat@5824a83dcat
cat afterPropertiesSet...
postProcessAfterInitialization...com.moomooyu.bean.Cat@5824a83dcat
dog constructor...
postProcessBeforeInitialization...com.moomooyu.bean.Dog@4686afc2dog
Dog...@PostConstructor...
postProcessAfterInitialization...com.moomooyu.bean.Dog@4686afc2dog
Dog...@PreDestroy....
cat destroy...

可以看到：
postProcessBeforeInitialization()方法在bean的构造方法执行后、其他初始化方法之前执行。
postProcessAfterInitialization()方法在其他初始化方法完成之后执行。

Spring底层对BeanPostProcessor也有许多应用的地方，如bean的赋值，注入其他组件，@Autowired注解，生命周期注解功能等。

三、配置文件读取

3.1 配置文件提示及校验

3.1.1 依赖引入

<!--
  在 META-INF/additional-spring-configuration-metadata.json 中配置
  可以去除 application.yml 中自定义配置的红线警告，并且为自定义配置添加 hint 提醒
 -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-configuration-processor</artifactId>
  <optional>true</optional>
</dependency>

3.1.2 增加辅助配置文件

在resources目录下创建META-INF文件夹，然后在其中创建additional-spring-configuration-metadata.json文件，配置如下内容（示例），重新build项目，即可实现配置文件提示及校验功能：

{
  "properties": [
    {
      "name": "application.name",
      "description": "Default value is artifactId in pom.xml.",
      "type": "java.lang.String"
    },
    {
      "name": "application.version",
      "description": "Default value is version in pom.xml.",
      "type": "java.lang.String"
    }
  ]
}

四、组件注册

4.1 使用包扫描+组件标注注解

4.1.1 扫描指定包

可使用的组件标注注解有@Controller、@Service、@Repository、@Configuration等，通过使用包扫描注解@ComponentScan(value = "要扫描的包路径")，指定好要扫描的包路径，即可将扫描到的符合规则的bean注册到IOC容器中。

/**
 * 配置类
 *      等同于配置文件
 *
 * @author maomaochong
 * @date 2022/06/05 20:15
 **/
@Configuration  // 指定配置类
@ComponentScan(value = "com.moomooyu")  // 包扫描，指定扫描的包
public class MyConfigForComponentScan {
}

4.1.2 扫描指定包，指定排除过滤规则

在@ComponentScan注解中，通过配置excludeFilters字段的值，来配置要排除掉的扫描规则。
可以配置多个过滤器Filter，其中：
type指定过滤器类型，常用的有：

     - `FilterType._ANNOTATION_`：过滤标注有指定注解的选项
     - `FilterType._ASSIGNABLE_TYPE_`_：过滤掉指定类型的选项_
     - `FilterType._CUSTOM_`：根据自定义的过滤器来过滤

classes指定对应类型的值。

1. 指定注解类型过滤

FilterType._ANNOTATION_

/**
 * 配置类
 *      等同于配置文件
 *
 * @author maomaochong
 * @date 2022/06/05 20:15
 **/
@Configuration  // 指定配置类
@ComponentScan(value = "com.moomooyu", // 包扫描，指定扫描的包
        // 排除过滤器：根据注解类型过滤掉指定的类型，不加入IOC容器中
        excludeFilters = {
            // 过滤器：
            @ComponentScan.Filter(type = FilterType.ANNOTATION,     // 过滤器类型
                    classes = {Controller.class}     // 要过滤的类型
            )
        })
public class MyConfigForComponentScan {
}

2. 指定类型过滤

FilterType._ASSIGNABLE_TYPE_

/**
 * 配置类
 *      等同于配置文件
 *
 * @author maomaochong
 * @date 2022/06/05 20:15
 **/
@Configuration  // 指定配置类
@ComponentScan(value = "com.moomooyu", // 包扫描，指定扫描的包
        // 只包含过滤器：根据注解类型过只包含指定的类型，加入IOC容器中
        includeFilters = {
                // 过滤器：
                @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,     // 过滤器类型
                        classes = {Person.class}     // 要过滤的类型
                )
        }, useDefaultFilters = false)
public class MyConfigForComponentScan {
}

3. 自定义过滤器

FilterType._CUSTOM_

通过实现org.springframework.core.type.filter.TypeFilter来自定义过滤规则。

/**
 * 自定义的包扫描过滤器
 *
 * @author maomaochong
 * @date 2022/06/05 21:32
 **/
public class MyTypeFilter implements TypeFilter {
    /**
     * 确定此过滤器与指定的类是否符合规则
     *
     * @param metadataReader        目标类的元数据读取器
     * @param metadataReaderFactory 父类或接口的元数据读取器获取工厂
     * @return 是否符合过滤规则
     * @throws IOException 读取元数据时可能出现的io异常
     */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        // 获取目标类注解信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        // 获取目标类的类信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        // 获取当前类的资源信息
        Resource resource = metadataReader.getResource();
        // 获取类名
        String className = classMetadata.getClassName();
        System.out.println("className = " + className);
        // 类名包含“er”的加入IOC容器
        if (className.contains("er")) {
            return true;
        }
        return false;
    }
}

/**
 * 配置类
 *      等同于配置文件
 *
 * @author maomaochong
 * @date 2022/06/05 20:15
 **/
@Configuration  // 指定配置类
@ComponentScan(value = "com.moomooyu", // 包扫描，指定扫描的包
        // 只包含过滤器：根据注解类型过只包含指定的类型，加入IOC容器中
        includeFilters = {
                // 过滤器：
                @ComponentScan.Filter(type = FilterType.CUSTOM, classes = MyTypeFilter.class)
        }, useDefaultFilters = false)
public class MyConfigForComponentScan {
}

4.1.3 扫描指定包，指定只包含过滤规则

通过指定includeFilters只包含过滤器，来限定只包含指定类型的bean注册至IOC容器。

注意：需要配置useDefaultFilters = false来关闭自动检测规则，阻止@Component、@Repository、@Service或@Controller的自动扫描。

/**
 * 配置类
 *      等同于配置文件
 *
 * @author maomaochong
 * @date 2022/06/05 20:15
 **/
@Configuration  // 指定配置类
@ComponentScan(value = "com.moomooyu", // 包扫描，指定扫描的包
        // 只包含过滤器：根据注解类型过只包含指定的类型，加入IOC容器中
        includeFilters = {
                // 过滤器：
                @ComponentScan.Filter(type = FilterType.ANNOTATION,     // 过滤器类型
                        classes = {Controller.class}     // 要过滤的类型
                )
        }, useDefaultFilters = false)
public class MyConfigForComponentScan {
}

在JDK1.8以后，可以通过使用多个@ComponentScan注解，来同时指定规则，若是以前版本，则可以通过@ComponentScans来指定多个@ComponentScan来实现。

4.2 使用@Bean注解

在配置类中使用@Bean注解即可将bean注册至IOC容器中。

/**
 * 配置类
 *      等同于配置文件
 *
 * @author maomaochong
 * @date 2022/06/05 20:15
 **/
@Configuration  // 指定配置类
public class MyConfig {
    /**
     * 给容器中注册一个Bean，类型为返回值的类型，id默认使用方法名作为id
     *      可以通过修改方法名来改变bean的名称
     *      也可以在@Bean注解中指定bean的名称
     *
     * @return  bean对象
     */
    @Bean("person")
    public Person person01() {
        return new Person("lisi", 20);
    }
}

4.2.1 使用@Scope注解配置组件的作用域

1. 默认为单实例

默认情况下，Spring中的组件为单实例。

/**
 * 配置类
 *      等同于配置文件
 *
 * @author maomaochong
 * @date 2022/06/05 20:15
 **/
@Configuration  // 指定配置类
public class MyConfigForScope {
    /**
     *
     * @return  bean对象
     */
    // 默认是单实例的
    @Bean("person")
    public Person person() {
        return new Person("lisi", 20);
    }
}

/**
 * @author maomaochong
 * @date 2022/06/05 20:34
 **/
public class IocTest {
    @Test
    public void test02(){
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfigForScope.class);
        String[] beanNamesForType = applicationContext.getBeanDefinitionNames();
        for (String name : beanNamesForType) {
            System.out.println(name);
        }
        // 获取两个Person类型的bean对象
        Object person = applicationContext.getBean("person");
        Object person1 = applicationContext.getBean("person");
        System.out.println("person = " + person);
        System.out.println("person1 = " + person1);
        // 返回结果为true
        System.out.println(person == person1);
    }
}

2. 指定为多实例

可通过@Scope注解指定为多实例，配置value属性为ConfigurableBeanFactory._SCOPE_PROTOTYPE_。
注意：

• ConfigurableBeanFactory.SCOPE_PROTOTYPE：
  • 多实例
  • IOC容器启动时，未创建对象，待获取指定类型对象时，才创建对象，获取几次创建几次

• ConfigurableBeanFactory.SCOPE_SINGLETON

  • 单实例
  • IOC容器启动时，就会调用方法创建对象，放入IOC容器中，以后每次获取都是直接从容器获取。 ```java /**
    • 配置类
    • 等同于配置文件 *
    • @author maomaochong
    • @date 2022/06/05 20:15 **/ @Configuration // 指定配置类 public class MyConfigForScope {

  /**

  • 可以通过@Scope注解指定组件的作用域：
  • // 常用
  • ConfigurableBeanFactory.SCOPE_PROTOTYPE, 多实例
  • IOC容器启动时，未创建对象，待获取指定类型对象时，才创建对象，获取几次创建几次
  • ConfigurableBeanFactory.SCOPE_SINGLETON, 单实例
  • IOC容器启动时，就会调用方法创建对象，放入IOC容器中，以后每次获取都是直接从容器获取。
  • // 不常用
  • org.springframework.web.context.WebApplicationContext.SCOPE_REQUEST, 同一次请求创建一个实例
  • org.springframework.web.context.WebApplicationContext.SCOPE_SESSION 同一次会话（session）创建一个实例 *
  • @return bean对象 */ // 默认是单实例的 @Bean(“person”) @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) // 指定为多实例 public Person person() { return new Person(“lisi”, 20); } } ```

    3. 通过@Lazy注解配置组件懒加载

    此注解适用于组件的单例作用域，可将指定组件在作用域为单例时，调整为IOC容器启动时不创建对象，当获取指定组件对象时才创建。 ```java /**
  • 配置类
  • 等同于配置文件 *
  • @author maomaochong
  • @date 2022/06/05 20:15 **/ @Configuration // 指定配置类 public class MyConfigForScope {

  /*

  • @return bean对象 */ // 默认是单实例的 @Bean(“person”) @Lazy // 配置为懒加载 public Person person() { return new Person(“lisi”, 20); } } ```

4.2.2 使用@Conditional注解按条件注册组件

可以通过此注解，传入org.springframework.context.annotation.Condition实现类，重写其matches() 方法来根据条件判断是否注册组件。
放在指定方法上，则控制指定bean是否注册，若放在类上，则当满足条件时，这个类中配置的所有bean注册才生效。

/**
 * 判断是否是linux系统
 *
 * @author maomaochong
 * @date 2022/06/05 23:29
 **/
public class LinuxCondition implements Condition {
    /**
     * 决定条件是否符合
     *
     * @param context  判断条件能使用的上下文环境
     * @param metadata 注解信息
     * @return {@code true} 条件符合，且组件可以被注册
     * or {@code false} 否决注册
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 获取IOC使用的beanfactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 获取类加载器
        ClassLoader classLoader = context.getClassLoader();
        // 获取当前环境信息
        Environment environment = context.getEnvironment();
        // 可以判断容器中bean注册情况，也可以给容器中注册bean
        boolean definition = registry.containsBeanDefinition("person");
        // 获取到bean定义的注册类
        BeanDefinitionRegistry registry = context.getRegistry();
        // 获取操作系统，如果是Linux则注册
        String property = environment.getProperty("os.name");
        if (property.contains("linux")) {
            return true;
        }
        return false;
    }
}

/**
 * 判断是否是windows系统
 *
 * @author maomaochong
 * @date 2022/06/05 23:29
 **/
public class WindowsCondition implements Condition {
    /**
     * 决定条件是否符合
     *
     * @param context  判断条件能使用的上下文环境
     * @param metadata 注解信息
     * @return {@code true} 条件符合，且组件可以被注册
     * or {@code false} 否决注册
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 获取IOC使用的beanfactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 获取类加载器
        ClassLoader classLoader = context.getClassLoader();
        // 获取当前环境信息
        Environment environment = context.getEnvironment();
        // 获取到bean定义的注册类
        BeanDefinitionRegistry registry = context.getRegistry();
        // 获取操作系统，如果是windows则注册
        String property = environment.getProperty("os.name");
        if (property.contains("Windows 10")) {
            return true;
        }
        return false;
    }
}

/**
 * 配置类
 *      等同于配置文件
 *
 * @author maomaochong
 * @date 2022/06/05 20:15
 **/
@Configuration  // 指定配置类
public class MyConfigForConditional {
    /**
     * 给容器中注册一个Bean，类型为返回值的类型，id默认使用方法名作为id
     *      可以通过修改方法名来改变bean的名称
     *      也可以在@Bean注解中指定bean的名称
     *
     * @return  bean对象
     */
    @Bean("person")
    public Person person() {
        return new Person("lisi", 20);
    }
    /**
     * @Conditional({Condition}) ：按照一定的条件进行判断，满足条件给容器中注册bean
     *      如果是windows系统，给容器注册“bill”
     *      如果是linux系统，给容器注册“linus”
     * @return  返回bill gates
     */
    @Bean("Bill")
    @Conditional({WindowsCondition.class})
    public Person person01() {
        return new Person("Bill Gates", 62);
    }
    /**
     *
     * @return  返回bill gates
     */
    @Bean("Linus")
    @Conditional(LinuxCondition.class)
    public Person person02() {
        return new Person("Linus", 48);
    }
}

4.3 使用@Import注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {
    /**
     * {@link Configuration}, {@link ImportSelector}, {@link ImportBeanDefinitionRegistrar}
     * or regular component classes to import.
     */
    Class<?>[] value();
}

4.3.1 导入指定的组件

可以在配置类上使用此注解，传入要导入的常规组件类，即可快速的导入组件，id默认是组件的全类名。

/**
 * @author maomaochong
 * @date 2022/06/06 23:33
 **/
public class Color {
}

/**
 * 配置类  使用import导入bean
 *      等同于配置文件
 *
 * @author maomaochong
 * @date 2022/06/05 20:15
 **/
@Configuration  // 指定配置类
@Import(Color.class)    // 使用此注解快速导入组件，id默认是组件的全类名
public class MyConfigForImport {
    /**
     * 给容器中注册一个Bean，类型为返回值的类型，id默认使用方法名作为id
     *      可以通过修改方法名来改变bean的名称
     *      也可以在@Bean注解中指定bean的名称
     *
     * @return  bean对象
     */
    @Bean("person")
    public Person person01() {
        return new Person("lisi", 20);
    }
}

此注解也可传入多个组件的字节码，实现批量导入指定组件。

/**
 * @author maomaochong
 * @date 2022/06/06 23:33
 **/
public class Red {
}

/**
 * 配置类  使用import导入bean
 *      等同于配置文件
 *
 * @author maomaochong
 * @date 2022/06/05 20:15
 **/
@Configuration  // 指定配置类
@Import({Color.class, Red.class})    // 使用此注解快速导入组件，id默认是组件的全类名
public class MyConfigForImport {
    /**
     * 给容器中注册一个Bean，类型为返回值的类型，id默认使用方法名作为id
     *      可以通过修改方法名来改变bean的名称
     *      也可以在@Bean注解中指定bean的名称
     *
     * @return  bean对象
     */
    @Bean("person")
    public Person person01() {
        return new Person("lisi", 20);
    }
}

4.3.2 导入符合条件的组件

我们可以通过实现org.springframework.context.annotation.ImportSelector接口，重写其selectImports() 方法，根据自定义的导入逻辑，选择符合规则的组件，返回其全类名字符串。将自定义的实现类传入@Import注解中。

/**
 * 自定义的导入选择器，自己配置导入组件的逻辑
 *
 * @author maomaochong
 * @date 2022/06/06 23:51
 **/
public class MyImportSelector implements ImportSelector {
    /**
     * 选择并返回要导入的组件，返回组件的全类名
     *
     * @param importingClassMetadata    当前标注@Import注解的类的所有注解信息
     * @return 要导入的组件的全类目
     */
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // 方法不要返回null值
        return new String[]{"com.moomooyu.bean.Blue", "com.moomooyu.bean.Yellow"};
    }
}

/**
 * 配置类  使用import导入bean
 *      等同于配置文件
 *
 * @author maomaochong
 * @date 2022/06/05 20:15
 **/
@Configuration  // 指定配置类
// 使用此注解快速导入组件，传入自定义的导入选择器，id默认是组件的全类名
@Import({Color.class, Red.class, MyImportSelector.class})    
public class MyConfigForImport {
    /**
     * 给容器中注册一个Bean，类型为返回值的类型，id默认使用方法名作为id
     *      可以通过修改方法名来改变bean的名称
     *      也可以在@Bean注解中指定bean的名称
     *
     * @return  bean对象
     */
    @Bean("person")
    public Person person01() {
        return new Person("lisi", 20);
    }
}

4.3.3 手动导入Bean定义

通过实现org.springframework.context.annotation.ImportBeanDefinitionRegistrar接口，重写其registerBeanDefinitions()方法，根据自定义逻辑，来直接手动创建bean的定义信息，将其添加到bean定义信息注册表中。然后将实现类传入@Import注解中。

/**
 * 配置类  使用import导入bean
 *      等同于配置文件
 *
 * @author maomaochong
 * @date 2022/06/05 20:15
 **/
@Configuration  // 指定配置类
//@Import(Color.class)    // 使用此注解快速导入组件，id默认是组件的全类名
@Import({Color.class, Red.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})    // 使用此注解快速导入组件，id默认是组件的全类名
public class MyConfigForImport {
    /**
     * 给容器中注册一个Bean，类型为返回值的类型，id默认使用方法名作为id
     *      可以通过修改方法名来改变bean的名称
     *      也可以在@Bean注解中指定bean的名称
     *
     * @return  bean对象
     */
    @Bean("person")
    public Person person01() {
        return new Person("lisi", 20);
    }
}

/**
 * @author maomaochong
 * @date 2022/06/07 00:15
 **/
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    /**
     * Register bean definitions as necessary based on the given annotation metadata of
     * the importing {@code @Configuration} class.
     * <p>Note that {@link BeanDefinitionRegistryPostProcessor} types may <em>not</em> be
     * registered here, due to lifecycle constraints related to {@code @Configuration}
     * class processing.
     *
     * @param importingClassMetadata 当前类的注解信息
     * @param registry               BeanDefinition注册类（注册表）
     *                               把所有需要添加到容器中的bean的定义信息添加到注册表中
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean red = registry.containsBeanDefinition("com.moomooyu.bean.Red");
        boolean blue = registry.containsBeanDefinition("com.moomooyu.bean.Blue");
        if (red && blue) {
            // 创建bean的定义信息
            RootBeanDefinition beanDefinition = new RootBeanDefinition(Rainbow.class);
            // 将bean的定义信息添加到注册表中
            registry.registerBeanDefinition("rainbow", beanDefinition);
        }
    }
}

4.4 使用Spring提供的FactoryBean

通过实现org.springframework.beans.factory.FactoryBean接口，重启其方法，来创建对应的工厂bean。
然后在配置类中导入工厂bean组件，默认情况下，我们获取此组件，可获得工厂bean调用getObject()方法创建的所包装的bean对象。如果我们想要获取工厂bean本身，可以在获取bean时，在工厂bean的id前加上&符号，如：&colorFactoryBean。

/**
 * 工厂bean
 *
 * @author maomaochong
 * @date 2022/06/07 00:28
 **/
public class ColorFactoryBean implements FactoryBean<Color> {
    /**
     * 返回一个Color对象，此对象会添加到容器中
     *      获取工厂bean时，此方法会被调用，返回对应的被包装类对象
     *
     * @return an instance of the bean (can be {@code null})
     * @throws Exception in case of creation errors
     * @see FactoryBeanNotInitializedException
     */
    @Override
    public Color getObject() throws Exception {
        return new Color();
    }
    /**
     * 返回对象的类型
     *
     * @return the type of object that this FactoryBean creates,
     * or {@code null} if not known at the time of the call
     * @see ListableBeanFactory#getBeansOfType
     */
    @Override
    public Class<?> getObjectType() {
        return Color.class;
    }
    /**
     * 是否是单例
     *
     * @return 返回true：这个bean是单实例，在容器中只保存一份
     *          返回false，这个bean是多实例，每次获取都会创建一个新的bean
     * @see #getObject()
     * @see SmartFactoryBean#isPrototype()
     */
    @Override
    public boolean isSingleton() {
        return false;
    }
}

/**
 * 配置类
 *      等同于配置文件
 *
 * @author maomaochong
 * @date 2022/06/05 20:15
 **/
@Configuration  // 指定配置类
public class MyConfigForFactoryBean {
    /**
     * 给容器中注册一个Bean，类型为返回值的类型，id默认使用方法名作为id
     *      可以通过修改方法名来改变bean的名称
     *      也可以在@Bean注解中指定bean的名称
     *
     * @return  bean对象
     */
    @Bean("person")
    public Person person01() {
        return new Person("lisi", 20);
    }
    /**
     * 导入工程bean组件
     * 
     * @return
     */
    @Bean
    public ColorFactoryBean colorFactoryBean() {
        return new ColorFactoryBean();
    }
}

    @Test
    public void test05(){
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfigForFactoryBean.class);
        // 获取当前环境
        ConfigurableEnvironment environment = applicationContext.getEnvironment();
        String property = environment.getProperty("os.name");
        System.out.println("property = " + property);
        // 获取所有bean定义名称
        printBeans(applicationContext);
        Object bean = applicationContext.getBean("colorFactoryBean");
        Object bean2 = applicationContext.getBean("colorFactoryBean");
        System.out.println("bean = " + bean.getClass());    // bean = class com.moomooyu.bean.Color
        System.out.println(bean == bean2); // false
        // 通过&符号前缀，可以指明我们要获取的是工厂bean本身
        Object bean3 = applicationContext.getBean("&colorFactoryBean");
        System.out.println("bean3 = " + bean3); // bean3 = com.moomooyu.bean.ColorFactoryBean@6574a52c
    }

五、AOP

aop基于动态代理实现，是指在程序运行期间动态地将某段代码切入到指定位置进行运行的编程方式。

5.1 一个简单aop示例

5.1.1 导入aop模块

        <!--aop  4.3.12.RELEASE-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${aspects.version}</version>
        </dependency>

5.1.2 定义一个业务逻辑类

在业务逻辑类MyCalculator中，当业务逻辑运行的时候将日志进行打印。

/**
 * 业务逻辑
 *
 * @author maomaochong
 * @date 2022/06/17 10:29
 **/
public class MathCalculator {
    public int div(int num1, int num2) {
        System.out.println("com.moomooyu.aop.business.MathCalculator.div  执行。。");
        return num1/num2;
    }
}

5.1.3 定义一个日志切面类

定义一个日志切面类LogAspects，切面类中的方法需要动态感知MathCalculator.div方法运行到什么状态。
对于切面，有以下几种通知方法：

• 前置通知（@Before）：在目标方法运行之前运行
• 后置通知（@After）：在目标方法运行结束之后运行，无论是方法正常结束还是异常结束
• 返回通知（@AfterReturning）：在目标方法正常返回之后运行
• 异常通知（@AfterThrowing）：在目标方法出现异常之后运行

• 环绕通知（@Around）：动态代理，手动推进目标方法运行（joinPoint.procced()）

  /**
  * 切面类
  *
  * @author maomaochong
  * @date 2022/06/17 10:29
  **/
  public class LogAspects {
  /**
  * 抽取公共的切入点表达式
  * 1、本类引用
  * 2、其他切面引用
  */
  @Pointcut("execution(public int com.moomooyu.aop.business.MathCalculator.div(int, int))")
  public void pointCut(){}
  /**
  * 前置通知
  *
  * @Before在目标方法之前切入，切入点表达式（指定在哪个方法切入）
  */
  public void logStart() {
     System.out.println("除法运行。。。参数列表是：{}");
  }
  /**
  *  后置通知
  */
  public void logEnd() {
     System.out.println("除法结束。。。");
  }
  /**
  * 返回通知
  */
  public void logReturn() {
     System.out.println("除法正常返回。。。运行结果是：{}");
  }
  /**
  * 异常通知
  */
  public void logException() {
     System.out.println("除法异常。。。异常信息：{}");
  }
  }

  5.1.4 给切面类的目标方法标注何时何地运行（通知注解）

  通过使用通知注解，来给切面类中的通知方法指定运行时机及运行目标位置。

  /**
  * 切面类
  *
  * @author maomaochong
  * @date 2022/06/17 10:29
  **/
  public class LogAspects {
  /**
  * 抽取公共的切入点表达式
  * 1、本类引用
  * 2、其他切面引用
  */
  @Pointcut("execution(public int com.moomooyu.aop.business.MathCalculator.div(int, int))")
  public void pointCut(){}
  /**
  * 前置通知
  *
  * @Before在目标方法之前切入，切入点表达式（指定在哪个方法切入）
  */
  @Before("com.moomooyu.aop.aspects.LogAspects.pointCut")
  public void logStart() {
     System.out.println("除法运行。。。参数列表是：{}");
  }
  /**
  *  后置通知
  */
  @After("pointCut()")
  public void logEnd() {
     System.out.println("除法结束。。。");
  }
  /**
  * 返回通知
  */
  @AfterReturning("pointCut()")
  public void logReturn() {
     System.out.println("除法正常返回。。。运行结果是：{}");
  }
  /**
  * 异常通知
  */
  @AfterThrowing("pointCut()")
  public void logException() {
     System.out.println("除法异常。。。异常信息：{}");
  }
  }

  5.1.5 将切面类和业务逻辑类（目标方法所在类）都加入容器

  将切面类和业务逻辑类都注册到ioc容器中。

  /**
  * aop配置类
  *
  * @author maomaochong
  * @date 2022/06/17 10:27
  **/
  @Configuration
  public class MyConfigOfAop {
  /**
  * 业务逻辑类
  * @return
  */
  @Bean
  public MathCalculator mathCalculator() {
     return new MathCalculator();
  }
  /**
  * 切面类
  * @return
  */
  @Bean
  public LogAspects logAspects() {
     return new LogAspects();
  }
  }

  5.1.6 指明切面类

  使用注解@Aspect指明切面类。

  /**
  * 切面类
  *
  * @author maomaochong
  * @date 2022/06/17 10:29
  **/
  @Aspect    // 指明切面类
  public class LogAspects {
  /**
  * 抽取公共的切入点表达式
  * 1、本类引用
  * 2、其他切面引用
  */
  @Pointcut("execution(public int com.moomooyu.aop.business.MathCalculator.div(int, int))")
  public void pointCut(){}
  /**
  * 前置通知
  *
  * @Before在目标方法之前切入，切入点表达式（指定在哪个方法切入）
  */
  @Before("com.moomooyu.aop.aspects.LogAspects.pointCut()")
  public void logStart(JoinPoint joinPoint) {
     Object[] args = joinPoint.getArgs();
     System.out.println(joinPoint.getSignature().getName() + "除法运行。。。参数列表是：{" + Arrays.asList(args) + "}");
  }
  /**
  *  后置通知
  */
  @After("pointCut()")
  public void logEnd(JoinPoint joinPoint) {
     System.out.println(joinPoint.getSignature().getName() + "除法结束。。。");
  }
  /**
  * 返回通知
  */
  @AfterReturning(value = "pointCut()", returning = "result")
  public void logReturn(Object result) {
     System.out.println("除法正常返回。。。运行结果是：{" + result + "}");
  }
  /**
  * 异常通知
  */
  @AfterThrowing(value = "pointCut()", throwing = "exception")
  public void logException(Exception exception) {
     System.out.println("除法异常。。。异常信息：{" + exception + "}");
  }
  }

  注意：JointPoint一定要在参数的第一位，否则会报错

  5.1.7 启用aop注解支持

  在配置类中使用注解@EnableAspectAutoProxy，开启基于注解的aop支持。

  /**
  * aop配置类
  *
  * @author maomaochong
  * @date 2022/06/17 10:27
  **/
  @EnableAspectJAutoProxy // 开启aop的注解支持
  @Configuration
  public class MyConfigOfAop {
  /**
  * 业务逻辑类
  * @return
  */
  @Bean
  public MathCalculator mathCalculator() {
     return new MathCalculator();
  }
  /**
  * 切面类
  * @return
  */
  @Bean
  public LogAspects logAspects() {
     return new LogAspects();
  }
  }

  5.1.8 测试类

  /**
  * @author maomaochong
  * @date 2022/06/17 11:11
  **/
  public class AopTest {
  @Test
  public void test01() {
     AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfigOfAop.class);
     // 此种方式无法被aop拦截
  //        MathCalculator mathCalculator = new MathCalculator();
  //        mathCalculator.div(1, 1);
     // 从容器中获取业务逻辑类bean对象
     MathCalculator mathCalculator = applicationContext.getBean(MathCalculator.class);
     mathCalculator.div(1, 1);
     applicationContext.close();
  }
  }

  运行结果：
  div除法运行。。。参数列表是：{[1, 1]}
  com.moomooyu.aop.business.MathCalculator.div 执行。。
  div除法结束。。。
  除法正常返回。。。运行结果是：{1}

5.2 规则

5.2.1 多个切面类的执行顺序

如果应用中包含多个切面类，则他们的执行顺序如下：

• 默认是按照切面类的名称的字典排序，按照顺序执行的。
• 如果需要自定义执行顺序，使用@Order注解来指定执行的顺序，给注解传入值，值越小越优先执行。

5.2.2 各通知方法执行顺序

5.3 aop源码及原理分析

六、声明式事务

6.1 一个简单的声明式事务示例

6.1.1 环境搭建

1. 导入相关依赖

导入数据源、数据库驱动、Spring-jdbc模块

        <!--jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.jdbc.version}</version>
        </dependency>
        <!--mysql-connector-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.connector.version}</version>
        </dependency>
        <!--c3p0-->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0.version}</version>
        </dependency>

2. 配置数据源，使用JdbcTemplate操作数据

/**
 * 事务配置类
 *
 * @author maomaochong
 * @date 2022/06/18 17:12
 **/
@ComponentScan("com.moomooyu.tx")
@Configuration
public class TxConfig {
    /**
     * 数据源配置
     * @return
     */
    @Bean
    public DataSource dataSource() throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser("root");
        dataSource.setPassword("root");
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://192.168.222.88:3306/test");
        return dataSource;
    }
    /**
     * jdbcTemplate
     *
     * @return
     * @throws Exception
     */
    @Bean
    public JdbcTemplate jdbcTemplate() throws Exception {
        // Spring对@Configuration类会特殊处理，给容器中加组件的方法，多次调用都只是从容器中找组件
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource());
        return jdbcTemplate;
    }
}

3. 方法标注@Transactional注解

/**
 * @author maomaochong
 * @date 2022/06/18 17:05
 **/
@Repository
public class UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    public void insert() {
        String sql = "INSERT INTO tb_user(username, age) VALUES(?, ?)";
        String username = UUID.randomUUID().toString().substring(0, 5);
        jdbcTemplate.update(sql, username, 19);
    }
}

/**
 * @author maomaochong
 * @date 2022/06/18 17:36
 **/
@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    public void insert() {
        userDao.insert();
        System.out.println("数据插入完成。。。");
    }
    @Transactional    // 使用事务注解，声明事务方法
    public void insert02() {
        userDao.insert();
        System.out.println("数据插入完成。。。");
        int i = 10/0;
    }
}

4. 使用@EnableTransactionManagement开启基于注解的事务管理功能

/**
 * 事务配置类
 *
 * @author maomaochong
 * @date 2022/06/18 17:12
 **/
@EnableTransactionManagement    // 使用此注解开启基于注解的事务管理功能
@ComponentScan("com.moomooyu.tx")
@Configuration
public class TxConfig {
    /**
     * 数据源配置
     * @return
     */
    @Bean
    public DataSource dataSource() throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser("root");
        dataSource.setPassword("root");
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://192.168.222.88:3306/test");
        return dataSource;
    }
    /**
     * jdbcTemplate
     *
     * @return
     * @throws Exception
     */
    @Bean
    public JdbcTemplate jdbcTemplate() throws Exception {
        // Spring对@Configuration类会特殊处理，给容器中加组件的方法，多次调用都只是从容器中找组件
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource());
        return jdbcTemplate;
    }
}

5. 配置事务管理器来控制事务

/**
 * 事务配置类
 *
 * @author maomaochong
 * @date 2022/06/18 17:12
 **/
@EnableTransactionManagement
@ComponentScan("com.moomooyu.tx")
@Configuration
public class TxConfig {
    /**
     * 数据源配置
     * @return
     */
    @Bean
    public DataSource dataSource() throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser("root");
        dataSource.setPassword("root");
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://192.168.222.88:3306/test");
        return dataSource;
    }
    /**
     * jdbcTemplate
     *
     * @return
     * @throws Exception
     */
    @Bean
    public JdbcTemplate jdbcTemplate() throws Exception {
        // Spring对@Configuration类会特殊处理，给容器中加组件的方法，多次调用都只是从容器中找组件
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource());
        return jdbcTemplate;
    }
    /**
     * 将事务管理器注册到容器中
     *
     * @return
     * @throws Exception
     */
    @Bean
    public PlatformTransactionManager transactionManager() throws Exception {
        return new DataSourceTransactionManager(dataSource());
    }
}

6.1.2 测试

/**
 * @author maomaochong
 * @date 2022/06/18 20:29
 **/
public class TxTest {
    /**
     * 数据可以正确插入
     */
    @Test
    public void test01() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(TxConfig.class);
        UserService userService = applicationContext.getBean(UserService.class);
        userService.insert();
    }
    /**
     * 出现异常时，数据仍可以插入数据库
     */
    @Test
    public void test02() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(TxConfig.class);
        UserService userService = applicationContext.getBean(UserService.class);
        userService.insert();
        int i = 10/0;
    }
    /**
     * 配置事务管理器，使用声明式事务注解
     *
     * 出现异常时，可以回滚操作
     */
    @Test
    public void test03() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(TxConfig.class);
        UserService userService = applicationContext.getBean(UserService.class);
        userService.insert02();
    }
}