【Spring注解】——组件注册

谁践踏了优雅 2022-05-21 13:21 202阅读 0赞

本文将主要针对Spring注解，讲解在组件注册过程会用到一些注解，对于小编本身是基础的回顾和巩固，也希望能帮助到需要的朋友，讲解偏颇之处，还请各位大神指正，小编不胜感激。

# 1、在容器中注册组件 #

## 1.1@Configuration ##

标注在类上，告诉spring这是一个配置类，代替spring的xml配置文件中<beans>。作用：配置spring容器（应用上下文）

**优点**

1、使用纯Java代码，不在需要xml

2、在配置中可以享受OO带来的好处

3、类型安全对重构也能提供良好的支持

4、依旧能享受到所有SpringIOC容器提供的功能

## 1.2@Bean ##

标注在方法上，相当于spring的xml配置文件中<bean>。作用：注册bean对象bean类

**注意：**

1、@Bean注解在返回实例的方法上，如果没有通过@Bean指定bean的名称，则默认与标注的方法名相同

2、@Bean注解默认作用域为单例singleton作用域，但是可以通过@Scope("prototype")设置为原型作用域（ps：@Scope下文有讲解）

3、@Bean的作用注册对象，也可以使用@Component，@Controller，@Service，@Repository等注解注册Bean，但是需要配置@ComponentScan注解进行自动扫描

# 2、扫描组件 #

## 2.1@ComponentScan(value) ##

标注在类上，相当于spring的xml配置文件中 <context:component-scan base-package="\*\*"/>。作用：在定义扫描的路径从中找到标识了需要装配的类自动装配到spring的容器中

## 2.2通过@ComponentScan指定扫描规则 ##

标注在@ComponentScan后面括号中，作用按照指定规则向spring容器中自动装配bean

excludeFilters = Filter\[\] ：指定扫描的时候按照什么规则排除那些组件，类似于spring中xml配置文件中

<context:component-scan base-package="**">
    	<context:exclude-filter type="**" expression="**" />
    </context:component-scan>

注解的使用方式

@ComponentScan(value="**",
    excludeFilters = {@Filter(type=**,classes={**})}

includeFilters = Filter\[\] ：指定扫描的时候只需要包含哪些组件，类似于spring中xml配置文件中

<context:component-scan base-package="**" use-default-filters="false">
            <context:include-filter type="**" expression="**"
        </context:component-scan>

注解的使用方式

@ComponentScan(value="**",excludeFilters = {@Filter(type=**,classes={**})},useDefaultFilters = false)}

**@Filter包含的过滤类型**

FilterType.ANNOTATION：按照注解
    FilterType.ASSIGNABLE_TYPE：按照给定的类型；
    FilterType.ASPECTJ：使用ASPECTJ表达式
    FilterType.REGEX：使用正则指定
    FilterType.CUSTOM：使用自定义规则

当使用自定义规则的时候即@Filter=FilterType.CUSTOM，自定义的类需要实现TypeFilter接口，然后按自己的需要重写过滤规则

Demo，过滤类名中包含er的类

import java.io.IOException;
    
    import org.springframework.core.io.Resource;
    import org.springframework.core.type.AnnotationMetadata;
    import org.springframework.core.type.ClassMetadata;
    import org.springframework.core.type.classreading.MetadataReader;
    import org.springframework.core.type.classreading.MetadataReaderFactory;
    import 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);
    		if(className.contains("er")){
    			return true;
    		}
    		return false;
    	}
    }

//只装配类名中包含er的类
    @ComponentScan(value="**",
                   excludeFilters = {@Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})},
                   useDefaultFilters = false)

## 2.3@ComponentScans，装配多个@ComponentScan装配规则 ##

在Java8以前不允许在一个类上定义两个相同的注解，可以使用@ComponentScans，装配多个@ComponentScan装配规则

@ComponentScans(
    		value = {@ComponentScan(value="**",
                    excludeFilters ={@Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})},useDefaultFilters = false)}
    )

# 3、设置组件作用域 #

## 3.1@Scope(value) ##

标注类上或者装载类的方法上，spring容器中bean默认是单例的，但是可以通过@Scope调整作用域，相当于spring中xml配置文件中的

注解使用方式

@Service("allusersService")
    @Scope("prototype")
    public class AllusersServiceImpl{}

作用域

prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。
    	   每次获取的时候才会调用方法创建对象；
    singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。
    	    以后每次获取就是直接从容器（map.get()）中拿，
    request：同一次请求创建一个实例
    session：同一个session创建一个实例

# 4、设置组件加载方式 #

## 4.1@Lazy懒加载 ##

单实例bean：默认在容器启动的时候创建对象；

懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；

标注类上或者装载类的方法上，当第一次使用获取Bean才创建对象并初始化，相当spring中xml配置文件中

//默认为false，即立即加载，设置为true则表示延迟加载
    <bean class="***" lazy-init="true">

注解使用方式，延迟装载

@Service("allusersService")
    @Lazy
    public class AllusersServiceImpl

# 5、按条件注册bean #

## 5.1@Conditional(\{Condition\})  ##

按照一定的条件进行判断，满足条件给容器中注册bean

在spring4中引入，用到带有@Bean注解的方法上，如果给定的条件计算结果为true，则会创建这个bean，否则这个bean就会被忽略。

条件化的创建bean，例如判断环境是为linux，如果是则注册

@Conditional(LinuxCondition.class)
    @Bean("linus")
    public Person person02(){
    	return new Person("linus", 48);
    }

**作为条件的bean，在实现的时候需要实现spring提供的Condition接口**

//判断是否linux系统
    public class LinuxCondition implements Condition {
    	/**
    	 * ConditionContext：判断条件能使用的上下文（环境）
    	 * AnnotatedTypeMetadata：注释信息
    	 */
    	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
    		//1、能获取到ioc使用的beanfactory
    		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    		//2、获取类加载器
    		ClassLoader classLoader = context.getClassLoader();
    		//3、获取当前环境信息
    		Environment environment = context.getEnvironment();
    		//4、获取到bean定义的注册类
    		BeanDefinitionRegistry registry = context.getRegistry();
    		
    		String property = environment.getProperty("os.name");
    		
    		//可以判断容器中的bean注册情况，也可以给容器中注册bean
    		boolean definition = registry.containsBeanDefinition("person");
    		if(property.contains("linux")){
    			return true;
    		}	
    		return false;
    	}
    }

Spring中@Profile注解根据环境注册bean，本质上也是利用@Conditional注解实现

# 6、给容器中导入组件 #

## 6.1@Import ##

@Import导入组件，id默认是组件的全类名，相对于@Bean是一种更快捷的方式

@Configuration
    //@Import导入组件，id默认是组件的全类名
    @Import({Color.class,Red.class})
    public class MainConfig{}

## 6.2@ImportSelector ##

返回需要导入的组件全类名数组

自定义的类需要使用@Import注解导入

自定义实现ImportSelector接口的方法

//自定义逻辑返回需要导入的组件
    public class MyImportSelector implements ImportSelector {
    	//返回值，就是到导入到容器中的组件全类名
    	//AnnotationMetadata:当前标注@Import注解的类的所有注解信息
    	@Override
    	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
    		//importingClassMetadata
    		//方法不要返回null值
    		return new String[]{"com.jia.bean.Blue","com.jia.bean.Yellow"};
    	}
    }

@Configuration
    @Import({MyImportSelector.class})
    public class MainConfig{}

## 6.3@ImportBeanDefinitionRegistrar ##

手动注册bean到容器中，自定义逻辑实现bean的注册

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    	/**
    	 * AnnotationMetadata：当前类的注解信息
    	 * BeanDefinitionRegistry:BeanDefinition注册类；
    	 * 		把所有需要添加到容器中的bean；调用
    	 * 		BeanDefinitionRegistry.registerBeanDefinition手工注册进来
    	 */
    	@Override
    	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    		
    		boolean definition = registry.containsBeanDefinition("com.jia.bean.Red");
    		boolean definition2 = registry.containsBeanDefinition("com.jia.bean.Blue");
    		if(definition && definition2){
    			//指定Bean定义信息；（Bean的类型，Bean。。。）
    			RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
    			//注册一个Bean，指定bean名
    			registry.registerBeanDefinition("rainBow", beanDefinition);
    		}
    	}
    }

@Configuration
    @Import({MyImportBeanDefinitionRegistrar.class})
    public class MainConfig{}

# 7、使用FactoryBean容器注册组件 #

创建一个spring定义的FactoryBean

import org.springframework.beans.factory.FactoryBean;
    
    //创建一个Spring定义的FactoryBean
    public class ColorFactoryBean implements FactoryBean<Color> {
    
    	//返回一个Color对象，这个对象会添加到容器中
    	@Override
    	public Color getObject() throws Exception {
    		// TODO Auto-generated method stub
    		System.out.println("ColorFactoryBean...getObject...");
    		return new Color();
    	}
    	@Override
    	public Class<?> getObjectType() {
    		// TODO Auto-generated method stub
    		return Color.class;
    	}
    	//是单例？
    	//true：这个bean是单实例，在容器中保存一份
    	//false：多实例，每次获取都会创建一个新的bean；
    	@Override
    	public boolean isSingleton() {
    		// TODO Auto-generated method stub
    		return false;
    	}
    }

@Bean
    public ColorFactoryBean colorFactoryBean(){
    	return new ColorFactoryBean();
    }

1）、默认获取到的是工厂bean调用getObject创建的对象  
2）、要获取工厂Bean本身，我们需要给id前面加一个&  
        &colorFactoryBean

//工厂Bean获取的是调用getObject创建的对象
    Object bean2 = applicationContext.getBean("colorFactoryBean");
    Object bean3 = applicationContext.getBean("colorFactoryBean");
    System.out.println("bean的类型："+bean2.getClass());
    System.out.println(bean2 == bean3);
    		
    Object bean4 = applicationContext.getBean("&colorFactoryBean");
    System.out.println(bean4.getClass());

# 8、加载spring的应用上下文 #

AnnotationConfigApplicationContext实现基于Java的配置类加载spring的应用上下文。避免使用application.xml进行配置，相比xml配置,更加便捷。

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);

管理注解Bean定义的容器有两个：

AnnotationConfigApplicationContext和 AnnotationConfigWebApplicationContex。这两个类是专门处理Spring注解方式配置的容器，直接依赖于注解作为容器配置信息来源的IoC容器。

AnnotationConfigWebApplicationContext是AnnotationConfigApplicationContext的web版本，两者的用法以及对注解的处理方式几乎没有什么差别，在后续的文章小编会进行更加详细的讲解。

# 总结 #

给容器中注册组件：

1、包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）\[自己写的类\]

2、@Bean\[导入的第三方包里面的组件\]  
 3、@Import\[快速给容器中导入一个组件\]  
    1）、@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名  
    2）、ImportSelector:返回需要导入的组件的全类名数组；  
    3）、ImportBeanDefinitionRegistrar:手动注册bean到容器中  
4、使用Spring提供的 FactoryBean（工厂Bean）;  
    1）、默认获取到的是工厂bean调用getObject创建的对象

2）、要获取工厂Bean本身，我们需要给id前面加一个&，即&colorFactoryBean

5、使用AnnotationConfigApplicationContext使用配置文件加载spring应用上下文。