spring源码分析(一)——bean的注册

柔情只为你懂 2021-09-27 15:30 292阅读 0赞

# #

## 1、从容器中获取bean的两种方式 ##

a、xml注册获取

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

b、注解方式注册的bean

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

## 2、注解方式注册bean ##

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

## 3、包扫描 ##

@Configuration 
    @ComponentScans(value = {@ComponentScan(value="com.atguigu")	})
    public class MainConfig {
    }

ComponentScans指定扫描的包，然后获取出来的就是这个包下，所有标注有@component、@controller、@service、@repository等注解的类。

@controller、@service、@repository都是@component的派生类

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    String[] definitionNames = applicationContext.getBeanDefinitionNames();
    for (String name : definitionNames) {
    	System.out.println(name);
    }

@Configuration  
    @ComponentScans(
    		value = {
    			@ComponentScan(value="com.atguigu",includeFilters = {
    /*			@Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
    			@Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),*/
    			@Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})
    		},useDefaultFilters = false)	}
    )
    //@ComponentScan  value:指定要扫描的包    
    //excludeFilters = Filter[] 指定扫描的时候，按照什么规则，排除哪些组件    排除有controller注解的组件
    //includeFilters = Filter[] 指定扫描的时候，按照什么规则，只需要哪些组件
    //FilterType.ANNOTATION   按照注解方式扫描，上面是只扫描标注controller注解的组件
    //FilterType.ASSIGNABLE_TYPE   按照给定类型 只扫描BookService或其子类或实现类
    //FilterType.ASPECTJ  使用ASPECTJ指定
    //FilterType.REGEX  使用正则指定
    //FilterType.CUSTOM  自定义
    //useDefaultFilters = false   禁用默认的规则，只有设置为false,只包含才生效
    public class MainConfig {
    	
    }

自定义过滤规则，必须实现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;
    	}
    
    }

## 4、@Scope注解  调整作用域 ##

//默认是单实例的
    	/**
    	 * @Scope:调整作用域
    	 * prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。
    	 * 					每次获取的时候才会调用方法创建对象；
    	 * singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。
    	 * 			以后每次获取就是直接从容器（map.get()）中拿，
    	 * request：同一次请求创建一个实例
    	 * session：同一个session创建一个实例
    	 
    	 */
    	@Scope("prototype")
    	@Bean("person")
    	public Person person(){
    		System.out.println("给容器中添加Person....");
    		return new Person("张三", 25);
    	}

## 5、@Lazy懒加载 ##

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

## 6、@Conditional注解 ##

按照一定的条件进行判断，满足条件给容器中注册bean。
    首先要自己写一个类，继承Condition，并实现match方法

//判断是否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;
    	}
    
    }

然后在注册bean的时候，在方法上加上@Conditional注解，并制定LinuxCondition的类。
    如果标在类上面，则满足条件的时候，这个配置类里面的bean才会生效。

//类中组件统一设置。满足当前条件，这个类中配置的所有bean注册才能生效；
    @Conditional({WindowsCondition.class})
    @Configuration
    public class MainConfig2 {
    	
    	/**
    	 * @Conditional({Condition}) ： 按照一定的条件进行判断，满足条件给容器中注册bean
    	 * 
    	 * 如果系统是windows，给容器中注册("bill")
    	 * 如果是linux系统，给容器中注册("linus")
    	 */
    	@Conditional({WindowsCondition.class})
    	@Bean("bill")
    	public Person person01(){
    		return new Person("Bill Gates",62);
    	}
    }

## 7、@Import 快速给容器导入一个组件 ##

`给容器中注册组件； 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`

### 使用@import注解 ###

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

### 使用ImportSelector注解  ###

ImportSelector可以自己定义导入哪些类，返回一个数组，返回要导入的类的全类名，需要实现ImportSelector接口，

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

然后在配置类上，需要导入自己写的导入选择器

@Import({MyImporxtSelector.class})

### ImportBeanDefinitionRegistrar:手动注册bean到容器中。 ###

需要自己写一个注册的规则类，实现ImportBeanDefinitionRegistrar接口，并在配置类上导入这个类

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

### 使用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;
    	}
    
    }

在配置类进行注册

/* 使用Spring提供的 FactoryBean（工厂Bean）;
    	 * 	默认获取到的是工厂bean调用getObject创建的对象
    	 */
    	@Bean
    	public ColorFactoryBean colorFactoryBean(){
    		return new ColorFactoryBean();
    	}

获取已经注册的bean

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    Object bean2 = applicationContext.getBean("colorFactoryBean");
    		
    Object bean4 = applicationContext.getBean("&colorFactoryBean");

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