Spring学习 - 注解驱动开发 - 《SSM web框架》

spirngBean生命周期

https://segmentfault.com/a/1190000022694615

https://blog.csdn.net/qq_44486437/article/details/118314144

https://www.bilibili.com/video/av63314239/

spirngBean生命周期

https://www.cnblogs.com/zrtqsk/p/3735273.html
https://www.jianshu.com/p/1dec08d290c1

@Configuration注解

将一个类标注为配置类，相当于之前的applicationContext.xml配置文件

@Bean

将一个对象注册到IOC容器中，其作用在方法上，方法的返回值类型作为bean的类型，方法的方法名作为bean的id

  @Configuration
  public class Config {
      @Bean
      public Person person() {
          return new Person("张三", "男", 20);
      }
  }

等同于

  <bean id="person" class="pers.lele.bean.Person">
      <property name="name" value="张三"/>
      <property name="gender" value="男"/>
      <property name="age" value="20"/>
  </bean>

若需要在不修改方法名的情况下，修改bean的id值，则可以设置@Bean注解中的name属性

@ComponentScan注解

扫描指定包下标有@Controller、@Service、@Repository、@Component注解的类加入到容器中，其id为类名首字母小写，当不同包下存在相同的类，会出现id冲突异常

  @Configuration
  @ComponentScan(value = {"pers.lele"})
  public class Config {
  }

关于扫描规则，如排除指定包

 @Configuration
  @ComponentScan(value = {"pers.lele"}, excludeFilters = {
          @ComponentScan.Filter(
                  type = FilterType.ANNOTATION, value = {Controller.class, Service.class}
          )
  })
  public class Config{
      //...
  }

在扫描指定包时，注意设置useDefaultFilters属性，因为默认是扫描标有@Controller、@Service、@Repository、@Component注解的类

@Configuration
@ComponentScan(value = {"pers.lele"}, includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, value = {
                Controller.class})
}, useDefaultFilters = false)
public class Config {
  //...
}

具体的配置看注解属性即可，对于对个包的扫描，使用@componentScans注解

@Configuration
@ComponentScans({@ComponentScan({"*","**"}),@ComponentScan({"*","**"})})
public class Config{
}

@ComponentScan.Filter的过滤规则

ANNOTATION 指定注解过滤
ASSIGNABLE_TYPE 指定具体的类

@Configuration
 //扫描将类型为BookService的类注入容器中
 @ComponentScan(value = {"pers.lele"}, includeFilters = {
         @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = {
                 BookService.class})
 }, useDefaultFilters = false)
 public class Config {
    //...
 }

ASPECTJ ASPECTJ表达式 execution(<修饰符><返回类型><包.类.方法(参数)><异常>)
REGEX 正则表达式
CUSTOM 自定义过滤器规则需自己实现org.springframework.core.type.filter.TypeFilter接口，重写匹配方法，若返回值为true，则注入到容器中

public class MyTypeFilterFilter implements TypeFilter {
  /**
   * @param metadataReader        metadataReader the metadata reader for the target class 读取到的当前正在扫描的类的信息
   * @param metadataReaderFactory metadataReaderFactory a factory for obtaining metadata readers 可以获取到其他任何类信息的
   * @return
   * @throws IOException
   */
  public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
    //获取当前类的注解信息
    AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
    //获取当前正在扫码的类的类信息
    ClassMetadata classMetadata = metadataReader.getClassMetadata();
    //获取当前类资源（类的路径）
    Resource resource = metadataReader.getResource();

    System.out.println("match: --->" + classMetadata.getClassName());
    return false;
  }
}

@Scope注解

调整bean对象的作用域

singleton：单例的,在容器加载的时候即创建对象，且以后均是同一个对象

prototype：多例的,在容器加载的时候不创建对象，在以后需要用到时才开始创建对象，且每次创建的对象均不同

@Configuration @ComponentScan("pers.lele") 
public class Config {
  @Scope("prototype") 
  //多实例 
  @Bean
   public Person person() {
      return new Person("张三", "男", 20); 
   } 
}

require: 一次请求
session：一次会话

@Lazy

对于单实例bean，默认是在容器创建时就加载组件，使用@Lazy可保证在容器创建时不创建bean，则在第一次使用时创建bean，且保证以后使用的bean都是同一个bean

@Conditional注解

对于Bean对象的创建，有时是根据一些条件动态决定的
@Conditional注解一般标注于方法上，决定改Bean是否被创建，当前，也可以标注于配置类上，决定该配置类下的Bean是否均需要创建
以标注于方法上创建Bean为例，注解的参数需要一个实现了Condition接口的类，根据matches的返回值来决定是否创建该Bean对象

@Configuration
public class Config {
    @Bean
    @Conditional(BillCondition.class)
    public Person bill(){
        return new Person("Bill Gates","男",66);
    }
    @Bean
    @Conditional(LinusCondition.class)
    public Person linus(){
        return new Person("linus","男",48);
    }
}

//根据操作系统创建不同的Bean，若为Windows则创建Bill,否则创建Linus

//Bill
public class BillCondition implements Condition {

   /**
    *
    * @param context 判断条件可以使用的上下文环境
    * @param metadata 注释信息
    * @return
    */
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //获取bean工厂
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //获取类加载器
        ClassLoader classLoader = context.getClassLoader();
        //获取运行时环境
        Environment environment = context.getEnvironment();
        //获取bean定义的注册类
        BeanDefinitionRegistry registry = context.getRegistry();

        String OS_Name = environment.getProperty("os.name");
        if (OS_Name.contains("Window"))
            return true;
        else
            return false;
    }
}
//Linus
public class LinusCondition implements Condition {
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment environment = context.getEnvironment();
        String OS_Name = environment.getProperty("os.name");
        if (OS_Name.contains("Linux"))
            return true;
        else
            return false;
    }
}

@Import注解

目前，给Bean容器中注册组件有如下两种方式

使用包扫描+注解的方式，局限于我们自己写的类
适应@Bean注解的方式，在@Configuration标注的类下新建一些个方法，表明该方法为注入Bean对象的方法
有时为了快速的进行组件注册，可以使用@Import注解,如下面所示，id为该类的全类名
@Import

@Import(要导入到容器中的组件)，容器中就会自动注册这个组件，id默认是全类名
ImportSelector：返回要导入组件的全类名数组
ImportBeanDefinitionRegistrar接口
```
@Configuration
@Import(ATM.class)
public class Config {}
```
关于@Import注解，查看它的文档，说明如下，还可以传入实现了ImportSelector接口的对象 ```java @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Import { /**
- {@link Configuration}, {@link ImportSelector}, {@link ImportBeanDefinitionRegistrar}
- or regular component classes to import. */ Class<?>[] value(); }

@Configuration @Import({ATM.class, MyImportSelector.class}) public class Config {}

//MyImportSelector实现了ImportSelector接口 public class MyImportSelector implements ImportSelector { // AnnotationMetadata 当前标注@Import注解的类的所有注解信息 public String[] selectImports(AnnotationMetadata importingClassMetadata) { return new String[]{“pers.lele.bean.Color”, “pers.lele.bean.HaHa”,”pers.lele.ATM”}; } }


除了实现ImportSelector接口外，还可以实现**ImportBeanDefinitionRegistrar**接口
```java
@Configuration
@Import({ATM.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
public class Config {}

//MyImportBeanDefinitionRegistrar实现ImportBeanDefinitionRegistrar
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
  /**
  * 
  * @param importingClassMetadata 当前类的注解信息
  * @param registry BeanDefinition 注册类 调用registerBeanDefinition方法手工注册
  */
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(RainBow.class);
        registry.registerBeanDefinition("rainbow", rootBeanDefinition);
    }
}

除了上面的三种创建Bean对象外，还可以使用FactoryBean来创建Bean
自定义类，实现FactoryBean接口，其中泛型为工厂所需类型

public class ColorFactoryBean implements FactoryBean<Color> {
    public Color getObject() throws Exception {
        return new Color();
    }

    public Class<?> getObjectType() {
        return Color.class;
    }

    public boolean isSingleton() {
        return true;
    }
}

在@Configure注解标注的类上定义即可

@Configuration
@Import({ATM.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
public class Config {
    @Bean
    public ColorFactoryBean colorFactoryBean(){
        return new ColorFactoryBean();
    } 
}

需要注意的是，若直接通过以下方式来获取bean，则获取的实例的类型非工厂本身类型，而是工厂里面所装入实例的类型
若需要获取工厂实例类型，请使用前缀&符号

public class ContextTest {

    @Test
    public void test06() {
        ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        Object bean1 = context.getBean("colorFactoryBean");
        Object bean2 = context.getBean("colorFactoryBean");
        System.out.println(bean1.getClass());//class pers.lele.bean.Color
        System.out.println(bean1 == bean2);//true
        Object bean3 = context.getBean("&colorFactoryBean");
        System.out.println(bean3.getClass());//class pers.lele.bean.ColorFactoryBean
    }
}

bean的生命周期:bean创建—初始化—销毁

创建

单实例：容器启动时创建
多实例：每次获取时创建
初始化对象创建完成并赋值，调用其初始化方法

销毁

单实例容器关闭时销毁
多实例手动销毁
容器管理bean的生命周期：自定义初始化和销毁方法，容器在bean进行到当前生命周期时调用自定义的初始化和销毁方法

init/destroy

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 指定初始化和销毁方法  
  @Bean(initMethod = "init", destroyMethod = "destroy")
  public Car car() {
    return new Car();
  }

InitializingBean/DisposableBean

通过让Bean实现InitializingBean(定义初始化逻辑) DisposableBean(定义销毁逻辑)

public class Cat implements InitializingBean, DisposableBean {

    public Cat() {
      System.out.println("cat constructor");
    }

    public void destroy() throws Exception {
      System.out.println("cat destroy");
    }

    public void afterPropertiesSet() throws Exception {
      System.out.println("cat afterPropertiesSet");
    }
  }

@PostConstruct和@PreDestroy

 public class Dog {
    public Dog() {
      System.out.println("Dog Constructor");
    }

    @PostConstruct
    public void init() {
      System.out.println("Dog PostConstruct");
    }

    @PreDestroy
    public void destroy() {
      System.out.println("Dog PreDestroy");
    }
  }

BeanPostProcessor

https://www.cnblogs.com/youzhibing/p/10559330.html

public class MyBeanPostProcessor implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
      System.out.println("postProcessBeforeInitialization" + bean + " ---> " + bean);
      return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
      System.out.println("postProcessAfterInitialization" + bean + " ---> " + bean);
      return bean;
    }
  }

加载配置文件PropertySource

@PropertySource(value = {"classpath:/person.properties"})
@Configuration()
public class ConfigLifeCycle {
    @Bean
    public Person person() {
        return new Person();
    }
}

可以使用getEnvironment方法获取environment，从而获取K-V值

ApplicationContext context = new AnnotationConfigApplicationContext(ConfigLifeCycle.class);
Environment environment = context.getEnvironment();
System.out.println(environment.getProperty("person.name"));

属性赋值@value

基本赋值

SpEL表达式赋值
${}赋值，读取配置文件 properties 中的值
自动装配:Spring利用DI，完成对IOC容器中各个组件的依赖关系赋值

@Autowire 自动注入
默认按照类型去容器中找对应组件,若指定类型的组件一个也不存在，则引发NoSuchBeanDefinitionException，若允许不存在组件时为null，则设置@Autowire中required为false
如果找到多个相同类型的组件，再将属性的名称作为组件id去容器中查找，若不存在以属性名为id的组件，则报错NoUniqueBeanDefinitionException,此时设置required无效，仍报错
若需在不修改属性名的前提下，装配指定id的组件，则可以使用@Qualifier组件
使用注解@Primary,使得Spring在装配时，默认使用首选bean,若存在多个@Primary注解，则报异常NoUniqueBeanDefinitionException

@Resource

可以和@Autowired一样实现自动装配功能，默认是按照组件名称进行装配的，与@Autowired的区别，不支持@Primary注解和@AutoWired中的属性等

@Inject

支持@Primary注解需要导入javax.inject 与@Autowired的区别不存在@AutoWired中的属性
@Autowire作用范围

方法上一般作用于set方法上，参考对象为方法参数装配规则与作用于属性上一致
构造器上若类只有一个有参构造器，则@Autowird可以省略，装配原则与作用于属性上一致
参数上在配置类定义bean时，参数可以为容器中的组件，@Autowird可以省略，装配原则与作用于属性上一致

自定义组件使用Spring容器底层的一些组件，则需实现接口xxxAware

public class Red implements ApplicationContextAware, EmbeddedValueResolverAware, BeanNameAware {
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    System.out.println(applicationContext);
  }

  public void setBeanName(String name) {
    System.out.println(name);
  }

  public void setEmbeddedValueResolver(StringValueResolver resolver) {
    String value = resolver.resolveStringValue("${os.name} #{20*1530}");
    System.out.println(value);
  }
}

@Profile

Spring为我们提供的动态配置组件,指定组件在哪个环境下才能被注册到容器中，若不指定，任何环境下都能注册到该组件
激活Profile

使用命令行动态参数/环境变量进行配置-Dspring.profiles.active=dev idea中可以不用-D
使用代码的方式 ```java AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); context.getEnvironment().setActiveProfiles(“test”, “dev”); context.register(ConfigAutowired.class); context.refresh();

```

注解驱动开发