Spring注解开发之组件注册（一）

最新推荐文章于 2021-12-26 10:57:34 发布

当年明月又天涯

最新推荐文章于 2021-12-26 10:57:34 发布

阅读量129

点赞数

分类专栏： Java Spring 文章标签： Spring注解开发 java

本文链接：https://blog.csdn.net/qq_36297981/article/details/82902689

版权

Java 同时被 2 个专栏收录

13 篇文章 0 订阅

订阅专栏

Spring

11 篇文章 0 订阅

订阅专栏

前言

现今SpringBoot、SpringCloud技术非常火热，作为Spring之上的框架，他们大量使用到了Spring的一些底层注解、原理，比如@Conditional、@Import、@EnableXXX等。如果掌握这些底层原理、注解，那么我们对这些高层框架就能做到高度定制，使用的游刃有余。

组件注册-@Configuration&@Bean给容器中注册组件

在我们使用配置文件xml的方式，我们首先需要一个spring的核心配置文件, 然后使用ClassPathXmlApplicationContext加载配置文件

spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
	<bean id="person" class="com.atguigu.bean.Person"  scope="prototype" >
		<property name="age" value="${}"></property>
		<property name="name" value="zhangsan"></property>
	</bean>
</beans>

ClassPathXmlApplicationContext读取配置文件

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
Person bean = (Person) applicationContext.getBean("person");
System.out.println(bean);

而我们使用spring注解方式开发时首先需要一个类，对类使用@Configuration注解，告诉spring这是一个配置类，并使用AnnotationConfigApplicationContext加载该配置类。

java配置类

//配置类==配置文件
@Configuration  //告诉Spring这是一个配置类
public class MainConfig {
	
	//给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
	@Bean("person")
	public Person person01(){
		return new Person("lisi", 20);
	}

}

使用AnnotationConfigApplicationContext读取配置类

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
		Person bean = applicationContext.getBean(Person.class);
		System.out.println(bean);

组件注册-@ComponentScan-自动扫描组件&指定扫描规则

我们在xml的配置文件中，使用<context:component-scan base-package="com.sanfeng"></context:component-scan>来指定需要扫描的包，来扫描标注了@Controller、@Service、@Repository，@Component的类，而在spring注解中我们可以使用@ComponentScan来达到相同的效果

使用@ComponentScan注解指定扫描的包

@Configuration
@ComponentScan(value="com.sanfeng")	
public class MainConfig {
	
	//给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
	@Bean("person")
	public Person person01(){
		return new Person("lisi", 20);
	}
}

@ComponentScan一些常用的属性
excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件
includeFilters = Filter[]：指定扫描的时候只需要包含哪些组件
需要配置@Filter注解使用

@ComponentScan(value="com.atguigu",includeFilters = {
	@Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
	@Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),
	},useDefaultFilters = false)	
//excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件
//includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件
//Filter: 过滤器
//FiltetType: 过滤规则
	//FilterType.ANNOTATION：按照注解
	//FilterType.ASSIGNABLE_TYPE：按照给定的类型；
	//FilterType.ASPECTJ：使用ASPECTJ表达式
	//FilterType.REGEX：使用正则指定
	//FilterType.CUSTOM：使用自定义规则
public class MainConfig {
	
	//给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
	@Bean("person")
	public Person person01(){
		return new Person("lisi", 20);
	}
}

使用自定义规则进行过滤
使用自定义规则进行过滤我们需要一个指定过滤规则的类，该类需要继承spring的TypeFilter接口并实现match方法，如下：

// 自定义过滤规则
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")){ //扫描包名中包含er的包
			return true;
		}
		return false;
	}
}


// 使用自定义过滤规则
@Configuration
@ComponentScan(value="com.atguigu",includeFilters = {
			@Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})
		},useDefaultFilters = false)
public class MainConfig {

	@Bean(value="person")
	public Person person() {
		return new Person("bill", 64);
	}
}

组件注册-@Scope-设置组件作用域

@Scope:调整作用域

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

@Scope("prototype")
@Bean("person")
public Person person(){
		System.out.println("给容器中添加Person....");
		return new Person("张三", 25);
	}

组件注册-@Lazy-bean懒加载

懒加载：

单实例bean：默认在容器启动的时候创建对象；
懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；

@Lazy
@Bean(value="person")
public Person person() {
	System.out.println("创建一个Person类对象");
	return new Person("bill", 64);
}

组件注册-@Conditional-按照条件注册bean

@Conditional({Condition}) ：按照一定的条件进行判断，满足条件给容器中注册bean
@Conditional需要一个Condition类的值或数组，Condition是Spring内部的一个接口，我们需要实现Condtion接口

// 如果当前环境是Windows环境才将该Bean注册到Spring环境中
@Conditional(WindowsCondition.class)
@Bean("bill")
public Person person01(){
	return new Person("Bill Gates",62);
}
// 如果当前环境是Linux环境才将该Bean注册到Spring环境中
@Conditional(LinuxCondition.class)
@Bean("linus")
public Person person02(){
	return new Person("linus", 48);
}

LinuxCondition

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

	/**
	 * ConditionContext：判断条件能使用的上下文（环境）
	 * AnnotatedTypeMetadata：注释信息
	 */
	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		// TODO是否linux系统
		//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;
	}

}

WindowsCondition

public class WindowsCondition implements Condition {

	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		Environment environment = context.getEnvironment();
		String property = environment.getProperty("os.name");
		if(property.contains("Windows")){
			return true;
		}
		return false;
	}

}

@Conditional注解可以使用在方法上，也可以使用在配置类上，在配置类上表示只有满足条件，该配置类中的Bean在会注册到Spring容器中，否则都不注册

组件注册-@Import-给容器中快速导入一个组件

在做Spring开发时，我们经常需要使用第三方库，我们可以使用@Import快速将第三方库注册到Spring容器中
假设下面两个类为第三方类

public class Yellow {

}

public class Red{

}
public class Blue {

}

我们可以使用@Import将其快速注册到Spring容器中

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

}

@Import注解还可以接受一个ImportSelector类，该类是Spring的一个接口，通过实现该接口，我们可以指定需要导入的组件

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

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

@Import注解还接受一个ImportBeanDefinitionRegistrar类，该类可以让我们手动将Bean注册到Spring容器中，这也是Spring的一个接口类，需要我们手动实现它

public class RainBow {

}

// ===========================
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

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

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

组件注册-使用FactoryBean注册组件

使用Spring的FactoryBean接口也可以将主键注册到Spring中

//创建一个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();
}

注意:
*当我们使用applicaiton.getBean("colorFactoryBean")默认获取到的是工厂bean调用getObject创建的对象，如上面的Color对象
- 要获取工厂Bean本身，我们需要给id前面加一个&, &colorFactoryBean

总结：Spring注册组件的方法

给容器中注册组件；

包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类]
@Bean[导入的第三方包里面的组件]
@Import[快速给容器中导入一个组件]
- @Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名
- ImportSelector:返回需要导入的组件的全类名数组；
- ImportBeanDefinitionRegistrar:手动注册bean到容器中
使用Spring提供的 FactoryBean（工厂Bean）;
- 默认获取到的是工厂bean调用getObject创建的对象
- 要获取工厂Bean本身，我们需要给id前面加一个&，如&colorFactoryBean

当年明月又天涯

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring注解开发之组件注册（一）

前言现今SpringBoot、SpringCloud技术非常火热，作为Spring之上的框架，他们大量使用到了Spring的一些底层注解、原理，比如@Conditional、@Import、@EnableXXX等。如果掌握这些底层原理、注解，那么我们对这些高层框架就能做到高度定制，使用的游刃有余。组件注册-@Configuration&amp;amp;@Bean给容器中注册组件在我们使用配置文件xm...
复制链接

扫一扫