Spring注解开发-全面解析常用注解使用方法之组件注册

1. @Configuration
2. @ComponentScan
3. @Bean
- @Scope
- @Lazy
4. Conditional
5. @Import
6. 通过实现FactoryBean注册组件
小结

本文github位置:https://github.com/WillVi/Spring-Annotation/

1. @Configuration

@Configuration //配置注解类似 applicationcontext.xml 只是将xml配置改为注解方式进行

2. @ComponentScan

进行包扫描会根据注解进行注册组件,value="包名"

@ComponentScan(value="cn.willvi")

FilterType

ANNOTATION 通过注解类型列如 @Controller为Controller.class @Service 为 Service.class
ASSIGNABLE_TYPE, 一组具体类例如PersonController.class
ASPECTJ, 一组表达式,使用Aspectj表达式命中类
REGEX 一组表达式,使用正则命中类
CUSTOM 自定义的TypeFilter.

excludeFilters

excludeFIlters = Filter[] 根据规则排除组件

@ComponentScan(value="cn.willvi",excludeFilters= {
  	    //根据注解排除注解类型为@Controller
		@Filter(type=FilterType.ANNOTATION,value= {Controller.class}),
		@Filter(type=FilterType.ASSIGNABLE_TYPE,value= {IncludeConfig.class,MainConfig.class}),
})

includeFilters

includeFIlters = Filter[] 根据规则只包含哪些组件（ps：useDefaultFilters设置为false）

@ComponentScan(value="cn.willvi",includeFilters= {
        //根据注解类型扫描注解类型为@Controller的类
		@Filter(type=FilterType.ANNOTATION,value= {Controller.class})
},useDefaultFilters=false)

使用自定义TypeFilter

当过滤有特殊要求时，可以实现TypeFilter来进行自定的过滤规则

自定义TypeFilter:

public class CustomTypeFilter implements TypeFilter {
	/**
	 * metadataReader the metadata reader for the target class 读取当前扫描类的信息
	 * metadataReaderFactory a factory for obtaining metadata readers
	 * for other classes (such as superclasses and interfaces) 获取其他类的信息
	 */
	public boolean match(MetadataReader reader, MetadataReaderFactory factory) throws IOException {
		//获取当前扫描类信息
		ClassMetadata classMetadata = reader.getClassMetadata();
		//获取当前注解信息
		AnnotationMetadata annotationMetadata = reader.getAnnotationMetadata();
		//获取当前类资源(类路径)
		Resource resource = reader.getResource();
		String className = classMetadata.getClassName();
		System.out.println("----->"+className);
		if(className.contains("PersonService")) {
			return true;
		}
		return false;
	}
}

使用：

//自定义过滤组件
@ComponentScan(value="cn.willvi",includeFilters= {
		@Filter(type=FilterType.CUSTOM,value= {CustomTypeFilter.class})
},useDefaultFilters=false)
//或者
//自定义过滤组件
@ComponentScan(value="cn.willvi",excludeFilters= {
		@Filter(type=FilterType.CUSTOM,value= {CustomTypeFilter.class})})

3. @Bean

注册bean与spring 的xml配置异曲同工之妙只是将xml配置转换为注解

  <bean id="person" class="cn.willvi.bean.Person"  scope="prototype" >
		<property name="age" value="23"></property>
		<property name="name" value="willvi"></property>
	</bean>

@Scope

在 Spring IoC 容器是指其创建的 Bean 对象相对于其他 Bean 对象的请求可见范围。

singleton单例模式全局有且仅有一个实例
prototype原型模式每次获取Bean的时候会有一个新的实例
request 每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效
session session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效
global session global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。

以上5个一般只用第一个和第二个

原型模式使用：

	@Bean
	@Scope("prototype")
	public Person person() {
		return new Person("willvi",23);
	}

验证：

	    ApplicationContext ioc = new AnnotationConfigApplicationContext(MainConfig.class);
		Person person = (Person) ioc.getBean("personScope");
		Person person1 = (Person) ioc.getBean("personScope");
		//返回true说明为单例
		System.out.println(person==person1);

@Lazy

懒加载。当Scope为单例模式时，当容器被初始化时就会被实例化。

当有@Lazy时，在容器初始化时不会被实例化，在获取实例时才会被初始化

单例模式懒加载使用

@Bean
	@Scope
	@Lazy //去掉和加上看输出结果
	public Person person() {
        System.out.println("bean初始化");
		return new Person("willvi",23);
	}

验证：

    ApplicationContext ioc = new AnnotationConfigApplicationContext(MainConfig.class);
	System.out.println("容器初始化完成");
	Person person = (Person) ioc.getBean("personScope");

4. Conditional

根据自定义条件注册组件。需要实现Condition接口

接口实现例子：

package cn.willvi.conditional;

import java.util.LinkedList;

import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class LinuxConditional implements Condition{
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		//获取环境
		Environment environment = context.getEnvironment();
        //获取组件注册类
		BeanDefinitionRegistry registry = context.getRegistry();
       //判断容器是否包含注册“person02”注册类
		boolean containsBeanDefinition = registry.containsBeanDefinition("person02");
       //获取当前操作系统并判断是否为Linux是的话 返回true；
      //返回true表示满足条件，ioc容器会注册该bean。反之则不会
		String property = environment.getProperty("os.name");
		if(property.contains("Linux")) {
			return true;
		}
		return false;
	}
}

运用：

    //根据自定义条件进行注测
    //给定自定义的class
	@Conditional({WindowConditional.class})
	@Bean
	public Person person01() {
		return new Person("windows",11);
	}
	@Conditional({LinuxConditional.class})
	@Bean
	public Person person02() {
		return new Person("linux",11);
	}
----------------------------------------------------------
    //也可以直接写在类前面
    //表示类中统一满足该条件才会被注册
	@Configuration
    @Conditional({WindowConditional.class})
  public mainConfig(){
  ....
	}

5. @Import

直接通过@Import({Dog.class,Pig.class})

实现ImportSelector接口 @Import({Dog.class,ImportSelector.class})

package cn.willvi.selector;

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

/**
 * ImportSelector @Import注解其中之一 选择器例子
 * @author willvi
 *
 */
public class AnnoImportSelector implements ImportSelector{

	/**
	 * AnnotationMetadata获取当前类的注解信息
	 */
	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
		//需要返回全类名
		String [] beans = {"cn.willvi.bean.Pig"};
		return beans;
	}

}

实现ImportBeanDefinitionRegistrar实现手工注册组件 @Import({Dog.class,AnnoImportBeanDefinitionRegistrar.class})

package cn.willvi.selector;

import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

import cn.willvi.bean.Person;

/**
 * 
 * ImportBeanDefinitionRegistrar接口实现
 * @author willvi
 *
 */
public class AnnoImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar{

	/**
	 * AnnotationMetadata获取当前类的注解信息
	 * BeanDefinitionRegistry 注册类 可以手工注册组件
	 */
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Person.class);
		//参数为：bean id名 bean定义信息
		registry.registerBeanDefinition("person", rootBeanDefinition);
		
	}

}

使用：

package cn.willvi.config;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

import cn.willvi.bean.Dog;
import cn.willvi.bean.Pig;
import cn.willvi.selector.AnnoImportBeanDefinitionRegistrar;
import cn.willvi.selector.AnnoImportSelector;

/**
 * @Import注解的运用
 * @author willvi
 *
 */
@Configuration
//快速导入到容器内 输入的组件名称为全类名
//通过实现ImportSelector接口
//通过实现ImportBeanDefinitionRegistrar手工注册
@Import({Dog.class,AnnoImportSelector.class,AnnoImportBeanDefinitionRegistrar.class})

public class AnnoImportConfig {

	public static void main(String[] args) {
		ApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(AnnoImportConfig.class);
		String[] beanNames = annotationConfigApplicationContext.getBeanDefinitionNames();
		for (String bean : beanNames) {
			System.out.println(bean);
		}
	}
}

6. 通过实现FactoryBean注册组件

通过实现FactoryBean接口（工厂bean）通常用于整合第三方框架

接口实现：

package cn.willvi.bean;

import org.springframework.beans.factory.FactoryBean;

public class MyFactoryBean implements FactoryBean<Pig>{

	public Pig getObject() throws Exception {
		return new Pig();
	}

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

	//是否单例
	public boolean isSingleton() {
		return true;
	}

}

使用：

package cn.willvi.config;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import cn.willvi.bean.MyFactoryBean;
import cn.willvi.bean.Pig;

/**
 * 通过FactoryBean的实现注册
 * @author willvi
 *
 */
@Configuration
public class FactoryBeanConfig {

	@Bean
	public MyFactoryBean MyFactoryBean() {
		return new MyFactoryBean();
	}
	
	public static void main(String[] args) {
		ApplicationContext  applicationContext= new AnnotationConfigApplicationContext(FactoryBeanConfig.class);
		//获取的是MyFactoryBean中getObject()返回的实例
		System.out.println(applicationContext.getBean("MyFactoryBean"));
		//添加'&' 获取的是MyFactoryBean实例
		System.out.println(applicationContext.getBean("&MyFactoryBean"));
	}
}

小结

给容器注册组件的几种方式：

包扫描配合注解（`@Controller@Service@Repository@Component）[自己写的类]
@Bean 导入第三方包的组件
@Import
- 直接通过 @Import({Dog.class,Pig.class})
- 通过实现ImportSelector接口返回全类名数组 @Import({实现的类})
- 通过实现ImportBeanDefinitionRegistrar接口手工注册组件 @Import({实现的类})
通过实现FactoryBean接口（工厂bean）通常用于整合第三方框架
- 默认获取到的是FactoryBean的getObject()返回的对象
- 要获取当前工厂类对象需添加 &符号

posted @ 2018-08-03 14:24 纯鈞阅读(445) 评论(0) 编辑收藏举报

刷新页面返回顶部

纯鈞

笨就要努力