Spring IOC 常用的注解

一、@Bean

1、配置类

@Configuration
public class MainConfig
{
    @Bean
    public Person person(){
        return new Person();
    }
}

注意：通过@Bean的形式是使用的话， bean的默认名称是方法名，可以使用 @Bean(value="bean的名称") 去指定bean的名称；

2、测试类：

public class MainClass
{
    public static void main(String[] args)
    {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
        //Arrays.stream(ctx.getBeanDefinitionNames()).forEach(System.out::println);
        System.out.println(ctx.getBean("person"));
    }
}

二、@ComponentScan 

在配置类上增加 @ComponentScan 注解，来进行包扫描；

@ComponentScan 注解 配合 @Controller、@Service、@Component、@Reposity 使用，将类注册到IOC容器中；

1、basePackages 包扫描的路径

@Configuration
//扫描com.yufeng.componentscan包下的所有
@ComponentScan(basePackages = {"com.yufeng.componentscan"})
public class MainConfig {
}

2、excludeFilters，排除

（a）FilterType.ANNOTATION ： 排除注解

（b）FilterType.ASSIGNABLE_TYPE：排除具体的类

@Configuration
//扫描com.yufeng.componentscan包下的所有, 排除有@Controller注解的类, 排除类TuService
@ComponentScan(basePackages = {"com.yufeng.componentscan"},
        excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Controller.class}),
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = {TuService.class})})
public class MainConfig {
}

（c）FilterType.CUSTOM：自定义规则去排除

@Configuration
//扫描com.yufeng.componentscan包下的所有, 按照自定义规则排除
@ComponentScan(basePackages = {"com.yufeng.componentscan"},
        excludeFilters = {@ComponentScan.Filter(type = FilterType.CUSTOM, value = {MyTypeFilter.class})})
public class MainConfig {
}

自定义的规则（实现 TypeFilter 接口）：类名中包含dao的需要排除

public class MyTypeFilter implements TypeFilter
{
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException
    {
        //获取当前类的注解源信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();

        //获取当前类的class的源信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        //获取当前类的资源信息
        Resource resource =  metadataReader.getResource();
        System.out.println("类的路径:"+classMetadata.getClassName());
        if(classMetadata.getClassName().contains("dao")) {
            return true;  //返回true, 则需要去过滤掉, 所以类名中包含dao的类不会被加载到IOC容器中
        }
        return false;
    }
}

3、includeFilters  包含，在包扫描的当前路径下只加载 includeFilters  包含的，其他的不加载；

注意：需要把 useDefaultFilter 属性设置为 false (true表示全表扫描) 

@Configuration
//--------------包含 includeFilters -------------
@ComponentScan(basePackages = {"com.yufeng.componentscan"},
        includeFilters = {@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = {Person.class})},
        useDefaultFilters = false)

public class MainConfig{
}

4、测试类

public class MainClass {
    public static void main(String[] args)
    {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
        Arrays.stream(ctx.getBeanDefinitionNames())
                .forEach(name -> System.out.println("bean的自定义: " + name));
        ctx.close();
    }
}

三、配置Bean的作用域对象

1、在不指定 @Scope 的情况下，所有的bean都是单实例的bean,而且是饿汉加载(容器启动实例就创建好了)

@Bean
public Person person() {
    return new Person();
}

2、指定@Scope为 prototype 表示为多实例的，而且还是懒汉模式加载（IOC容器启动的时候，并不会创建对象，而是在第一次使用的时候才会创建）

@Bean
@Scope(value = "prototype")
public Person person() {
　　return new Person();
}

3、@Scope指定的作用域方法取值
　　（a）singleton 单实例的(默认)
　　（b）prototype 多实例的
　　（c）request 同一次请求
　　（d）session 同一个会话级别
单实例的Bean要实现懒加载，可以使用 @Lazy 注解 (主要针对单实例的bean 容器启动的时候，不创建对象，在第一次使用的时候才会创建该对象)

@Bean
@Lazy
public Person person() {
    return new Person();
} 

四、@Conditional 进行条件判断

有二个组件TulingAspect 和 TulingLog ，我的TulingLog组件是依赖于TulingAspect的组件
自定义加载条件的类 TulingCondition，该类 实现Condition接口

public class MyCondition implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
        //判断容器中是否有tulingAspect的组件
        if(beanFactory.containsBean("tulingAspect")) {
            return true;
        }
        return false;
    }
}

配置类的配置

@Configuration
public class ConditionConfig  {
    //当前容器中有tulingAspect的组件，那么tulingLog才会被实例化
    @Bean
    @Conditional(value = MyCondition.class)
    public TulingLog tulingLog() {
        return new TulingLog();
    }

    @Bean
    public TulingAspect tulingAspect() {
        return new TulingAspect();
    }
}

运行结果如下：

注意：@Configuration 配置类中的 Bean 加载是有顺序的， 越在前越更早的被加载；

五、往IOC 容器中添加组件的方式

1、通过 @CompentScan + @Controller @Service @Respository @compent

　　适用场景: 针对我们自己写的组件可以通过该方式来进行加载到容器中。

2、通过 @Bean 的方式来导入组件(适用于导入第三方组件的类)

3、通过 @Import 来导入组件 （导入Bean的id为全类名路径）

（1）方式一： @Import(value = {Person.class,  Car.class})

配置类：

@Configuration
@Import(value = {Person.class, Car.class})
public class MainConfig {
}

运行结果：

 （2）方式二：按照全类名导入，通过@Import 的 ImportSeletor 类 (导入Bean的id为全类名路径)

实现  ImportSelector 接口，按照类的全路径名导入

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{"com.yufeng.importanno.component.Dog"};
    }
}

配置类：

@Configuration
//@Import(value = {Person.class, Car.class})
@Import(value = {Fish.class, MyImportSelector.class})
public class MainConfig {
}

运行结果

 （3）方式三： 通过 @Import 导入  ImportBeanDefinitionRegister 的实现类 (可以指定bean的名称) 

实现  ImportBeanDefinitionRegister  接口

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata,
                                        BeanDefinitionRegistry beanDefinitionRegistry) {
        //创建一个bean定义对象
        RootBeanDefinition beanDefinition = new RootBeanDefinition(Car.class);
        
        //把bean定义对象导入到容器中
        beanDefinitionRegistry.registerBeanDefinition("car", beanDefinition);
    }
}

配置类

@Configuration
//@Import(value = {Person.class, Car.class})
//@Import(value = {Fish.class, MyImportSelector.class})
@Import(value = {MyImportSelector.class, MyImportBeanDefinitionRegistrar.class, Person.class})
public class MainConfig {
}

运行结果

 4、通过实现 FacotryBean 接口来实现注册组件

 实现  FactoryBean 接口，重写 getObject、getObjectType、isSingleton 方法；

public class CarFactoryBean implements FactoryBean {
    //返回bean的对象
    @Override
    public Car getObject() throws Exception {
        return new Car();
    }

    //返回bean的类型
    @Override
    public Class<?> getObjectType() {
        return Car.class;
    }

    //是否为单利
    @Override
    public boolean isSingleton() {
        return true;
    }
}

配置类：

@Configuration
public class MainConfig {
    @Bean
    public CarFactoryBean carFactoryBean() {
        return new CarFactoryBean();
    }
}

测试类：

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
        Arrays.stream(ctx.getBeanDefinitionNames())
                .forEach(name -> System.out.println("bean名字: " + name));

        System.out.println("--------------");
        Object bean = ctx.getBean("carFactoryBean");
        System.out.println(bean.getClass().getName());

        System.out.println("--------------");
        Object bean2 = ctx.getBean("&carFactoryBean");
        System.out.println(bean2.getClass().getName());
    }
}

运行结果

 结论：

（1）实现 FactoryBean 接口的类，注册到IOC容器中，使用 bean名称 获取到的是Bean的 getObject 方法返回的对象；

（2）实现 FactoryBean 接口的类，注册到IOC容器中，要想获取到Bean本身，则在 bean名称 之前加一个 & ；

六、Bean的初始化和销毁方法

什么是bean的生命周期?

bean的创建----->初始化----->销毁方法

由容器管理Bean的生命周期，我们可以通过自己指定bean的初始化方法和bean的销毁方法？

1、方法一：使用 @Bean 注解的 initMethod  和 destroyMethod 

（1）组件：

public class Car {
    public Car() {
        System.out.println("-------Car构造方法------");
    }

    public void init(){
        System.out.println("-------Car的 init() 方法------");
    }

    public void destroy() {
        System.out.println("-------Car的 destroy() 方法------");
    }
}

（2）配置类，使用 @Bean 注解的 initMethod  和 destroyMethod

@Configuration
public class MainConfig
{
    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }
}

（3）测试类

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
        /*Arrays.stream(ctx.getBeanDefinitionNames())
                .forEach(name -> System.out.println("bean名字: " + name));*/
        ctx.close();
    }
}

运行结果：

注意：

（1）针对单实例bean的话，容器启动的时候，bean的对象就创建了，而且容器销毁的时候，也会调用Bean的销毁方法；

（2）针对多实例bean的话,容器启动的时候，bean是不会被创建的而是在获取bean的时候被创建，而且bean的销毁不受 IOC容器的管理；

2、通过 实现 InitializingBean 和 DisposableBean 接口，并重写bean的初始化以及销毁方法 ；

（1）组件实现 InitializingBean 和 DisposableBean 接口

@Component
public class Person implements InitializingBean, DisposableBean {
    public Person() {
        System.out.println("--Person的构造方法--");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("Person DisposableBean的destroy()方法");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Person InitializingBean的 afterPropertiesSet方法");
    }
}

（2）配置类

@Configuration
@ComponentScan(basePackages = "com.yufeng.beanlifecyle")
public class MainConfig
{
    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }
}

运行结果：

3、通过JSR250规范 提供的注解@PostConstruct 和@ProDestory标注的方法 

 （1）组件

@Component
public class Book
{
    public Book() {
        System.out.println("Book的构造方法");
    }

    @PostConstruct
    public void myInit(){
        System.out.println("Book 的标注 @PostConstruct 的方法");
    }

    @PreDestroy
    public void myDestroy() {
        System.out.println("Book 的标注 @PreDestroy 的方法");
    }
}

运行结果：

 4、通过Spring的 BeanPostProcessor 的 bean的后置处理器会拦截所有bean创建过程

（1）postProcessBeforeInitialization 在 init 方法之前调用

（2）postProcessAfterInitialization 在 init 方法之后调用

实现 BeanPostProcessor  接口

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyBeanPostProcessor...postProcessBeforeInitialization:"+beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyBeanPostProcessor...postProcessAfterInitialization:"+beanName);
        return bean;
    }
}

运行结果

 七、通过@Value +@PropertySource来给组件赋值

配置类

@Configuration
@PropertySource(value = {"classpath:person.properties"}) //指定外部文件的位置
public class MainConfig {
    @Bean
    public Person person() {
        return new Person();
    }
}

组件

public class Person {
    //通过普通的方式
    @Value("司马")
    private String firstName;

    //spel方式来赋值
    @Value("#{28-8}")
    private Integer age;
   
     //通过读取外部配置文件的值
    @Value("${person.lastName}")
    private String lastName;
}

八、自动装配

 1、@AutoWired的使用

 （1）@AutoWired:

　　自动装配首先时按照类型进行装配，若在IOC容器中发现了多个相同类型的组件，那么就按照 属性名称 来进行装配 ;

比如，容器中有二个 TulingDao 类型的组件 一个叫 tulingDao 一个叫 tulingDao2，

那么我们通过@AutoWired 来修饰的属性名称为tulingDao 时，那么那就加载容器的tulingDao组件，若属性名称为 tulignDao2 那么他就加载的时tulingDao2组件。

 （2）@AutoWired 和 @Qualifier(value)  配合使用

假设我们需要指定特定的组件来进行装配，我们可以通过使用 @Qualifier("tulingDao") 来指定装配的组件或者在配置类上的 @Bean 加上 @Primary 注解

@Autowired
@Qualifier("tulingDao")
private TulingDao tulingDao2; 

注意：若容器中既没有 tulingDao也没有 tulingDao2 时,  那么在装配的时候就会抛出异常 ；

           若我们想不抛异常 ，我们需要指定 required为false的时候可以了：@Autowired(required = false)

2、@Resource 使用 (JSR250规范)

　　功能和 @AutoWired 的功能差不多一样，但是 不支持@Primary 和@Qualifier的支持 ,由J2EE提供，需要导入包javax.annotation.Resource。

@Resource 默认按照ByName自动注入，@Resource有两个重要的属性：name和type，而Spring将@Resource注解的name属性解析为bean

的名字，而type属性则解析为bean的类型。所以，

如果使用name属性，则使用byName的自动注入策略；

如果使用type属性时则使用byType自动注入策略。

如果既不指定 name也不制定type属性，这时将通过反射机制使用byName自动注入策略。

3、@InJect（JSR330规范）

 需要导入jar包依赖

功能和支持 @Primary 功能 ,但是没有 Require=false 的功能

@Inject 默认 By type 自动注入， 可以 通过@Qualifier 显式指定 ByName 注入。

 @Autowired:Spring定义的;@Resource,@inject都是java规范。

九、通过实现XXXAware接口的实现，来从IOC容器中获取 Bean

我们自己的组件，需要使用spring ioc的底层组件的时候, 比如 ApplicationContext等，我们可以通过实现XXXAware接口来实现