【Spring注解】1、Spring组件注册

1、@Configuration:

指定该注解的类是个配置类,对应之前的配置文件

 

2、@Bean:

指定该方法作为一个Bean组件,它会往容器中注册一个Bean组件;

其中类型为返回值,id默认为方法名;

也可以使用@Bean注解的name属性,来自定义id。

 

 

3、@ComponentScans:

可以配置多个@ComponentScan

3.1、@ComponentScan:

指定要扫描的包路径

  • excludeFilters=Filter[]: 指定扫描的时候要排除的组件。

  • useDefaultFilters: 过滤策略,默认为true,即会自动扫描带@Component注解(包括@Component@Controller@Service@Repository注解的类)。

  • includeFilters=Filter[]: 指定扫描符合规则的组件,如果只是想扫描某些指定组件,需要将useDefaultFilters设为false,禁用默认的扫描策略。

 

3.1.1、Filter类型:

  • FilterType.ANNOTATION: 按照注解
@Filter(type = FilterType.ANNOTATION, classes = {Controller.class})

        使用@Controller注解的类符合以上规则。

 

  • FilterType.ASSIGNABLE_TYPE: 按照给定的类型
@Filter(type = FilterType.ASSIGNABLE_TYPE, classes = xxx.class)

        符合xxx.java的类符合以上规则。

 

  • FilterType.ASPECTJ: 按照ASPECTJ表达式
  • FilterType.REGEX: 按照正则表达式
  • FilterType.CUSTOM: 使用自定义规则

        要使用该策略,类必须实现org.springframework.core.type.filter.TypeFilter接口。

public class MyTypeFilter implements TypeFilter {

	/**
	 * metadataReader: 读取到的当前正在扫描的类信息
	 * metadataReaderFactory: 可以获取到其他任何类信息的工厂类
	 */
	@Override
	public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
			throws IOException {
		// TODO Auto-generated method stub
		//获取当前类注解的信息
		AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
		
		//获取当前正在扫描的类信息
		ClassMetadata classMetadata = metadataReader.getClassMetadata();
		
		//获取当前类的资源(类路径)
		Resource resource = metadataReader.getResource();
		
		String className = classMetadata.getClassName();
		System.out.println(">>>>>" + className);
		//简单测试,如果扫描的类名中包含了er,则匹配
		if(className.contains("er")){
			return true;
		}
		return false;
	}
}

同时标注:

@Filter(type = FilterType.CUSTOM, classes = {MyTypeFilter.class})

        这样,在扫描的时候会将包含"er"字母的类加入到容器中。

 

4、@Scope:

指定组件的作用域,默认为单例:singleton

singleton:单实例,当ioc容器启动会调用方法创建对象并放到ioc容器中,而以后每次获取对象的时候直接从ioc容器中获取。

prototype:多实例,ioc容器启动并不会去调用方法创建对象,而是在每次获取的时候才会去调用方法创建对象,所以每次获取的对象都是不一样的。

@Scope(scopeName = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Bean
public Book book(){
    System.out.println("创建book实例...");
    return new Book();
}

@Bean
public Person person(){//默认单实例
    System.out.println("创建person实例...");
    return new Person("zhangsan", 20);
}

测试:

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig2.class);

//单实例
Object obj1 = applicationContext.getBean("person");
Object obj2 = applicationContext.getBean("person");
System.out.println(obj1 == obj2);//输出true

//多实例
Object obj3 = applicationContext.getBean("book");
Object obj4 = applicationContext.getBean("book");
System.out.println(obj3 == obj4);//输出false

 

5、@Lazy:

懒加载:只针对于单实例对象

默认加载Bean是在容器启动的时候就会去创建对象,并将其放入ioc容器中;而懒加载则相反,容器启动时不创建对象,而是在第一次使用(获取)对象的时候,才会去创建对象,再将其加入到ioc容器中,之后每次再获取该对象的时候,直接从ioc容器中获取,不再重新创建。

@Lazy
@Bean
public Book book2(){
    System.out.println("创建book2实例...");
    return new Book();
}

 

6、@Conditional:

该注解可以标注在类上,也可以标注在方法上

方法级别:根据条件创建bean,只有满足条件才会创建bean;

类级别:根据条件创建配置类,只有满足条件才会去创建配置类,如果不满足,则不会创建该配置类,同时配置类里的bean也就不会被创建。

配置类:

@Configuration
public class MyConfig3 {

	@Conditional(WindowsCondition.class)
	@Bean("bill")
	public Person person1(){
		return new Person("bill gates", 60);
	}
	
	@Conditional(LinuxCondition.class)
	@Bean("linus")
	public Person person2(){
		return new Person("linus", 50);
	}
}

 LinuxCondition条件类:

//判断是否是Linux系统
public class LinuxCondition implements Condition{

	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		// TODO Auto-generated method stub
		//获取到ioc使用的BeanFactory
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		
		//获取类加载器
		ClassLoader classLoader = context.getClassLoader();
		
		//获取当前环境变量
		Environment environment = context.getEnvironment();
		
		//获取到bean定义的注册类
		BeanDefinitionRegistry registry = context.getRegistry();
		
		//获取系统环境
		String systemName = environment.getProperty("os.name");
		if(systemName.contains("Linux")){
			return true;
		}
		return false;
	}

}

WindowsCondition条件类:

//判断是否是Windows系统
public class WindowsCondition implements Condition {

	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		// TODO Auto-generated method stub
		// 获取当前环境变量
		Environment environment = context.getEnvironment();
		// 获取系统环境
		String systemName = environment.getProperty("os.name");
		if (systemName.contains("Windows")) {
			return true;
		}
		return false;
	}

}

这样,使用不同的操作系统,创建的Bean也就不一样。

 

7、Spring导入组件的方式:

Spring导入组件的方式:

1、使用注解@Component@Controller@Service@Repository

2、使用@Bean导入第三方组件

3、使用@Import快速导入一个或多个第三方组件

3.1、指定类

3.2、使用ImportSelector接口

3.3、使用ImportBeanDefinitionRegistrar接口

4、 FactoryBean接口

 

7.1、@Import

7.1.1、指定类

假设有两个颜色类:Red.java和Green.class,可以在配置类上使用@Import注解注册该两个类。

@Import({Red.class, Green.class})

这样在Bean定义的注册表里有其两个组件,其组件的id为全类名

 

7.1.2、ImportSelector接口

需要实现ImportSelector接口

public class MyImportSelector implements ImportSelector {

	//返回值就是要导入到容器中的组件全类名
	//AnnotationMetadata:当前标注@Import注解的类的所有注解信息
	@Override
	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
		// TODO Auto-generated method stub
		//方法不要返回null
		return new String[]{"org.com.cay.spring.annotation.color.Blue", "org.com.cay.spring.annotation.color.Yellow"};
	}
}

导入:

@Import({Red.class, Green.class, MyImportSelector.class})

这样不仅会将@Import注解中指定的类加入到容器中,同样会将MyImportSelector#selectImports中方法返回的全类名进行注册到容器中。

 

7.1.3、ImportBeanDefinitionRegistrar接口

实现ImportBeanDefinitionRegistrar接口,实现registerBeanDefinitions方法,手动注册bean。

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

	/**
	 * AnnotationMetadata:当前类的注解信息
	 * 
	 * BeanDefinitionRegistry:BeanDefinition注册类
	 * 		把所有需要添加到容器中的bean,手动通过{@link BeanDefinitionRegistry#registerBeanDefinition(String, BeanDefinition)}进行注册
	 */
	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		// TODO Auto-generated method stub

        //因为Yellow这个Bean是通过@Import导入的,所以bean的id为全类名,所以这里需要判断全类名才行
		boolean hasBean = registry.containsBeanDefinition("org.com.cay.spring.annotation.color.Yellow");
		System.out.println(">>>>>>hasBean: " + hasBean);
		if(hasBean){
			BeanDefinition beanDefinition = new RootBeanDefinition(Tiger.class);
			registry.registerBeanDefinition("tiger", beanDefinition);
		}
	}
}

添加该实现类到@Import属性中:

@Import({ Red.class, Green.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class }) 

 

7.2、FactoryBean接口

实现FactoryBean接口

public class ColorFactory implements FactoryBean{

	//返回一个Color对象,这个对象会添加到容器中
	@Override
	public Color getObject() throws Exception {
		// TODO Auto-generated method stub
		return new Color();
	}

	@Override
	public Class getObjectType() {
		// TODO Auto-generated method stub
		return Color.class;
	}

	@Override
	public boolean isSingleton() {
		// TODO Auto-generated method stub
		return true;
	}
}

并将该factoryBean注册到容器中:

@Configuration
@Import({ Red.class, Green.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class })
public class MyConfig4 {

	@Bean
	public ColorFactory colorFactory(){
		return new ColorFactory();
	}
}

测试:

@Test
public void testFactoryBean(){
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig4.class);
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    Arrays.asList(beanDefinitionNames).stream().forEach(System.out::println);

	//获取到的是实现FactoryBean接口后通过getObject返回的实际bean
    Object bean = applicationContext.getBean("colorFactory");
    System.out.println("bean的类型: " + bean.getClass());
    
    //获取factorybean自身bean
    //org.springframework.beans.factory.BeanFactory.FACTORY_BEAN_PREFIX = "&";
    Object bean2 = applicationContext.getBean("&colorFactory");
    System.out.println("bean2的类型: " + bean2.getClass());
}

为何使用"&"?

package org.springframework.beans.factory;
public interface BeanFactory {
    
    /**
     * Used to dereference a {@link FactoryBean} instance and distinguish it from
     * beans created by the FactoryBean. For example, if the bean named
     * {@code myJndiObject} is a FactoryBean, getting {@code &myJndiObject}
     * will return the factory, not the instance returned by the factory.
    */
	String FACTORY_BEAN_PREFIX = "&";
    
    //other...
}

 

 

====================打个广告,欢迎关注====================

QQ:

412425870

微信公众号:Cay课堂

【Spring注解】1、Spring组件注册_第1张图片

csdn博客:

http://blog.csdn.net/caychen

码云:

https://gitee.com/caychen/

github:

https://github.com/caychen

点击群号或者扫描二维码即可加入QQ群:

328243383(1群)

 

【Spring注解】1、Spring组件注册_第2张图片

点击群号或者扫描二维码即可加入QQ群:
180479701(2群)

【Spring注解】1、Spring组件注册_第3张图片

--------------------- 作者:caychen 来源:CSDN 原文:https://blog.csdn.net/caychen/article/details/82887926?utm_source=copy 版权声明:本文为博主原创文章,转载请附上博文链接!

你可能感兴趣的:(Java,Spring)