Spring IOC 经常使用的注解

1、@Bean

一、配置类

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

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

二、测试类：

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")); } }

2、@ComponentScan 

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

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

一、basePackages 包扫描的路径

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

二、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; } }

三、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{ }

四、测试类

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(); } }

 

3、配置Bean的做用域对象

一、在不指定 @Scope 的状况下，全部的bean都是单实例的bean,并且是饿汉加载(容器启动实例就建立好了)

 

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

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

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

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

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

4、@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 加载是有顺序的， 越在前越更早的被加载；

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

一、经过 @CompentScan + @Controller @Service @Respository @compent

　　适用场景: 针对咱们本身写的组件能够经过该方式来进行加载到容器中。

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

三、经过 @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 { }

运行结果

 

 

 四、经过实现 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名称 以前加一个 & ；

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

什么是bean的生命周期?

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

由容器管理Bean的生命周期，咱们能够经过本身指定bean的初始化方法和bean的销毁方法？

一、方法一：使用 @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容器的管理；

二、经过 实现 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(); } }

运行结果：

 

 

 

三、经过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 的方法"); } }

运行结果：

 

 四、经过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; } }

运行结果

 

 

 

 7、经过@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; }

 

8、自动装配

 一、@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自动注入策略。

三、@InJect（JSR330规范）

 须要导入jar包依赖

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

@Inject 默认 By type 自动注入， 能够 经过@Qualifier 显式指定 ByName 注入。

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

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

咱们本身的组件，须要使用spring ioc的底层组件的时候, 好比 ApplicationContext等，咱们能够经过实现XXXAware接口来实现