Spring装配Bean-CSDN博客

本文链接：https://blog.csdn.net/Dcwjh/article/details/104167116

文章目录

FactoryBean和BeanFactory区别
1. 原始方式：通过XML装配Bean
2. 通过注解的方式来装配Bean
3. 自动装配Bean
4. Scope扫描规则
5. 懒加载
6. @Conditional条件注册Bean
7. @Import注册Bean

FactoryBean和BeanFactory区别

FactoryBean: 可以把我们Java实例Bean通过FacrotyBean注入到容器中
BeanFactory: 从容器中获取实例化后的Bean

1. 原始方式：通过XML装配Bean

创建maven项目
添加依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.enjoy</groupId>
    <artifactId>spring-anno</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.6.RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!-- 指定jdk版本 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <!-- 源码的编译器版本 -->
                    <source>1.8</source>
                    <!-- class的编译器版本 -->
                    <target>1.8</target>
                </configuration>
            </plugin>


        </plugins>
    </build>
</project>

在这里插入图片描述

配置beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	
    <bean id="person" class="cap1.Person">
        <property name="name" value="James"></property>
        <property name="age" value="19"></property>
    </bean>
</beans>

id就是Beans的名字
注意：Person类中必须要有默认构造函数
若没有需要这样配置

<bean id="person" class="cap1.Person">
        <constructor-arg index="0" value=""/>
        <constructor-arg index="1" value=""/>
        <property name="name" value="James"></property>
        <property name="age" value="19"></property>
    </bean>

测试

package cap1;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

//IOC容器其实是一个很大的容器
public class MainTest {
    public static void main(String[] args) {
        //原始方法：通过XML装配bean
        //把beans.xml的类加载到容器中
        ApplicationContext app= new ClassPathXmlApplicationContext("beans.xml"); //用它的接口来实现
       //从容器中获取Bean
        Person person = (Person) app.getBean("person");
        System.out.println(person);
    }
}

2. 通过注解的方式来装配Bean

配置文件

package cap2;

import cap1.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//配置类==配置文件
@Configuration
public class MainConfig {
    //给容器中注册一个bean,类型为返回值类型
    //@Bean("abc")
    //Beans名字上面没有指定就是方法名字，默认就是下面的方法名字
    @Bean
    public Person person1(){
        return new Person("Wang",20);
    }
}

测试

package cap2;

import cap1.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainTest2 {
    public static void main(String[] args) {

        ApplicationContext app = new AnnotationConfigApplicationContext(MainConfig.class);
        //从容器中获取Bean
        Person person = (Person) app.getBean("person1");
        System.out.println(person);
        String[] namesForBeans = app.getBeanNamesForType(Person.class);
        for(String name: namesForBeans)
            System.out.println(name);
    }

3. 自动装配Bean

Spring从两个角度来实现自动化装配：

组件扫描（component scanning): Spring会从自动发现应用上下文中所创建的bean.
自动装配（autowiring）：Spring自动满足bean之间的依赖。
组件扫描和自动装配组合在一起就能发挥出强大的威力，它们能够将你的显示配置降低到最少。
controller

package cap3.controller;

import org.springframework.stereotype.Controller;

@Controller
public class OrderController {
}

package cap3.dao;

import org.springframework.stereotype.Repository;

//数据库
@Repository
public class OrderDao {
}

service

package cap3.service;

import org.springframework.stereotype.Service;

@Service
public class OrderService {
}

测试类

import cap3.config.Cap3Config;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Cap3Test {
    @Test
    public void test01(){
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Cap3Config.class);
        String[] namesForBeans = app.getBeanDefinitionNames();

        for(String name: namesForBeans)
            System.out.println(name);
    }
}

注解扫描

配置类

有这些注解的类都会被扫描进来：@Controller, @Serivce, @Repository, @Component

package cap3.config;

import cap1.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;


@Configuration
//扫描cap3包下的注解组件
@ComponentScan(value = "cap3", excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class})
}, useDefaultFilters = true)     //扫描组件,使用自定义扫描
public class Cap3Config {
    @Bean
    public Person person01(){
        return new Person("wangjian",20);
    }
}

结果：排除Controller注解的组件
在这里插入图片描述

package cap3.config;

import cap1.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;


@Configuration
//扫描cap3包下的注解组件
@ComponentScan(value = "cap3", includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class})
}, useDefaultFilters = false)     //扫描组件，不使用自定义扫描
public class Cap3Config {
    @Bean
    public Person person01(){
        return new Person("wangjian",20);
    }
}

结果：
在这里插入图片描述

类型扫描

package cap3.config;

import cap1.Person;
import cap3.controller.OrderController;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;


@Configuration
@ComponentScan(value = "cap3", includeFilters = {
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {OrderController.class}) 
}, useDefaultFilters = false)     //扫描组件，使用注解类型
public class Cap3Config {
    @Bean
    public Person person01(){
        return new Person("wangjian",20);
    }
}

自定义扫描

文件目录结构
在这里插入图片描述

自定义类型 JamesTypeFilter

package cap3.config;

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;

import java.io.IOException;

public class JamesTypeFilter implements TypeFilter {
    private ClassMetadata classMetadata;
    /*
        MetadataReader:读取到当前正在扫描类的信息
        MetadataReaderFactory：可以获取到其他任何类的信息
     */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        //获取当前的注解信息
        AnnotationMetadata am = metadataReader.getAnnotationMetadata();
        //获取当前正在扫描的注解信息
        classMetadata = metadataReader.getClassMetadata();
        //获取当前类资源（类的路径)
        Resource resource = metadataReader.getResource();

        String className = classMetadata.getClassName();
        System.out.println("----->" + className);
        if(className.contains("Order"))
            return true;
        return false;

    }
}

配置文件设置

package cap3.config;

import cap1.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;

@Configuration
@ComponentScan(value = "cap3", includeFilters = {
        @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {JamesTypeFilter.class})
}, useDefaultFilters = false)     //扫描组件
public class Cap3Config {
    @Bean
    public Person person01(){
        return new Person("wangjian",20);
    }
}

结果：
在这里插入图片描述

指定ComponentScan可以被ComponentScans作为数组使用

@ComponentScans(value = { @ComponentScan(value = "cap1"),
		@ComponentScan(value = "cap3", includeFilters = {
				@Filter(type = FilterType.CUSTOM, value = ColorBeanLoadFilter.class) }) })
public class MainConfig {
 
	@Bean(name = "pers", initMethod = "init", destroyMethod = "destory")
	public Person person() {
		return new Person();
	}
}

4. Scope扫描规则

IOC容器：
多实例：仅当bean被使用的时候才创建
单实例：创建IOC容器的时候实例Bean就被创建（默认）
创建两个实例用“==”验证

package cap3.config;

import cap1.Person;
import org.springframework.context.annotation.*;

@Configuration
@ComponentScan(value = "cap3", includeFilters = {
        @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {JamesTypeFilter.class})
}, useDefaultFilters = false)

public class Cap3Config {
    /**
     * prototype:多实例 ，IOC容器启动的时候，IOC容器启动并不会调用方法创建对象，而是每次获取的时候才会调用方法创建对象，然后把对象放进容器
     * singleton：单实例（默认）：IOC容器启动的时候会调用方法创建对象放进IOC容器中，以后每次获取的就是从容器中（大MAP)拿到的同一个对象
     * request: 主要针对web应用，递交一次请求创建一个实例
     * sessio:同一个session创建一个实例
     */
    @Scope("prototype")
    @Bean("abc")
    public Person person(){
        return new Person("wangjian",20);
    }
}

在这里插入图片描述

5. 懒加载

无懒加载

package cap4;

import cap1.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(value = "cap4")

public class Cap4MainConfig {
    @Bean("abc")
    public Person person(){
        System.out.println("给容器中添加person.....");
        return new Person("wangjian",20);
    }
}

测试

import cap4.Cap4MainConfig;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Cap4Test {
    @Test
    public void test01(){
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Cap4MainConfig.class);
        System.out.println("IOC容器初始化完成");
        Object abc = app.getBean("abc");
    }
}

结果：
在这里插入图片描述

懒加载

package cap4;

import cap1.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

@Configuration
@ComponentScan(value = "cap4")

public class Cap4MainConfig {
    /**
     * 懒加载：主要针对单实例Bean:默认在容器启的时候创建对象，容器启动时候不创建对象，仅当第一次使用（获取）bean的时候才创建被初始化
     * @return
     */
    @Lazy
    @Bean("abc")
    public Person person(){
        System.out.println("给容器中添加person.....");
        return new Person("wangjian",20);
    }
}

结果：
在这里插入图片描述

6. @Conditional条件注册Bean

IOC就是对我们Bean进行管理：bean注册实例化管理
需求：运行测试用例时，若操作系统时Windows则让张三这个对象实例到容器中；若是Linux，则把李四这个对象实例放到容器中
在这里插入图片描述

WinCondition.java

package cap5;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
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 WinCondition implements Condition {
    /**
     *
     * @param conditionContext : 判断条件可以使用的上下文（环境）
     * @param annotatedTypeMetadata： 注解信息
     * @return
     */
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        //TODO 是否为WINDOWS
        //能获取到IOC容器正在时用的BeanFactory
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
        //获取当前环境变量（包括我们操作系统时WIN还是Linux??)
        Environment environment = conditionContext.getEnvironment();
        String os_name = environment.getProperty("os.name");
        if(os_name.contains("Windows"))
            return true;
        return false;
    }
}

LinuxCondition.java

package cap5;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
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 LinuxCondition implements Condition {
    /**
     *
     * @param conditionContext : 判断条件可以使用的上下文（环境）
     * @param annotatedTypeMetadata： 注解信息
     * @return
     */
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        //TODO 是否为WINDOWS
        //能获取到IOC容器正在时用的BeanFactory
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
        //获取当前环境变量（包括我们操作系统时WIN还是Linux??)
        Environment environment = conditionContext.getEnvironment();
        String os_name = environment.getProperty("os.name");
        if(os_name.contains("Linux"))
            return true;
        return false;
    }
}

Cap5MainConfig

package cap5;

import cap1.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class Cap5MainConfig {
    @Bean("person")
    public Person person(){
        System.out.println("将Person添加到容器中。。。。。。");
        return new Person("person",20);
    }

    @Conditional(value = WinCondition.class)
    @Bean("zhangsan")
    public Person zhangsan(){
        System.out.println("将张三添加到容器中。。。。。。");
        return new Person("zhangsan",60);
    }
    @Conditional(value = LinuxCondition.class)
    @Bean("lisi") //bean在容器中的ID为lisi，IOC容器为MAP,map.put("id",value)
    public Person lisi(){
        System.out.println("将李四添加到容器中。。。。。。");
        return new Person("lisi",100);
    }
}

Cap5Test

import cap5.Cap5MainConfig;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;


public class Cap5Test {
    @Test
    public void test01() {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Cap5MainConfig.class);
        System.out.println("IOC容器初始化完成");
    }
}

实验结果：张三注入到Windows
在这里插入图片描述

实验结果：李四注入到Linux中

7. @Import注册Bean

在这里插入图片描述

配置类

package Cap6;

import Cap6.bean.Cat;
import Cap6.bean.Dog;
import cap1.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import(value = {Dog.class, Cat.class})
public class Cap6MainConfig {
    /**
     * 给容器中注册组件的方式
     * 1. @Bean: 导入第三方类或包的组件
     * 2. 包扫描+组件的标注注解（@ComponentScan: @Controller, @Service, @Repository, @Component), 一般是针对我们自己写的类，使用这个
     * 3. @Import:快速给容器导入一个组件
     * 		a.@Import(要导入到容器中的组件）：容器会自动注册这个组件，bean的id为全类名
     * 4. 使用Spring提供的Factory(工厂Bean)进行注册
     
     * 注意：@Bean有点简单
     * @return
     */
    //容器启动时初始化Person的Bean实例
    @Bean("person")
    public Person person1(){
        return new Person("Wang",20);
    }
}

测试

import Cap6.Cap6MainConfig;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Cap6Test {
    @Test
    public void test01() {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Cap6MainConfig.class);
        System.out.println("IOC容器初始化完成");
        String[] beanDefinitionNames = app.getBeanDefinitionNames();
        for(String name: beanDefinitionNames)
            System.out.println(name);

    }
}

在这里插入图片描述

Selector：

b. ImportSelector:是一个接口，返回需要导入到容器的组件的全类名数组
在这里插入图片描述

WangImportConfig.java

package Cap6;

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

public class WangImportSelect implements ImportSelector {

    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        //返回全类名
        return new String[]{"cap6.bean.Fish","cap6.bean.Tiger"};
    }
}

配置类：

package Cap6;

import Cap6.bean.Cat;
import Cap6.bean.Dog;
import cap1.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import(value = {Dog.class, Cat.class, WangImportSelect.class})
public class Cap6MainConfig {
    /**
     * 给容器中注册组件的方式
     * 1. @Bean: 导入第三方类或包的组件
     * 2. 包扫描+组件的标注注解（@ComponentScan: @Controller, @Service, @Repository, @Component), 一般是针对我们自己写的类，使用这个
     * 3. @Import:快速给容器导入一个组件
     *  	b. ImportSelector:是一个接口，返回需要导入到容器的组件的全类名数组
     * 注意：@Bean有点简单
     * @return
     */
    //容器启动时初始化Person的Bean实例
    @Bean("person")
    public Person person1(){
        return new Person("Wang",20);
    }
}

测试类：

import Cap6.Cap6MainConfig;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Cap6Test {
    @Test
    public void test01() {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Cap6MainConfig.class);
        System.out.println("IOC容器初始化完成");
        String[] beanDefinitionNames = app.getBeanDefinitionNames();
        for(String name: beanDefinitionNames)
            System.out.println(name);
    }
}

结果：
在这里插入图片描述

ImportBeanDefinitionRegistrar：

c. ImportBeanDefinitionRegistrar:可以手动添加组件到IOC容器，所有Bean注册可以使用BeanDifinitionRegistry写WangImportBeanDefinitionRegistrar实现ImportBeanDefinitionRegistrar接口即可

package cap6;

import cap6.bean.Pig;
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;

public class WangImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    /**
     *
     * @param annotationMetadata: 当前类的注解信息
     * @param beanDefinitionRegistry：BeanDefinition注册类
     *                              把所有需要添加到容器中的bean加入；
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        boolean b1 = beanDefinitionRegistry.containsBeanDefinition("cap6.bean.Dog");
        boolean b2 = beanDefinitionRegistry.containsBeanDefinition("cap6.bean.Cat");
        //如果Dog和Cat同时存在于我们的IOC容器中，那么创建Pig类，加入到容器
        //对于我们要注册的bean,给bean进行封装
        if(b1 && b2) {
            RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Pig.class);
            beanDefinitionRegistry.registerBeanDefinition("pig", rootBeanDefinition);
        }

    }
}

package cap6;

import cap6.bean.Cat;
import cap6.bean.Dog;
import cap1.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import(value = {Dog.class, Cat.class, WangImportSelect.class, WangImportBeanDefinitionRegistrar.class})
public class Cap6MainConfig {
    /**
     * 给容器中注册组件的方式
     * 1. @Bean: 导入第三方类或包的组件
     * 2. 包扫描+组件的标注注解（@ComponentScan: @Controller, @Service, @Repository, @Component), 一般是针对我们自己写的类，使用这个
     * 3. @Import:快速给容器导入一个组件
     *		c. ImportBeanDefinitionRegistrar:可以手动添加组件到IOC容器，所有Bean注册可以使用BeanDifinitionRegistry
     		写WangImportBeanDefinitionRegistrar实现ImportBeanDefinitionRegistrar接口即可
     * 注意：@Bean有点简单
     * @return
     */
    //容器启动时初始化Person的Bean实例
    @Bean("person")
    public Person person1(){
        return new Person("Wang",20);
    }
}

在这里插入图片描述

FactoryBean接口实现

使用Spring提供的Factory(工厂Bean)进行注册

WangFactoryBean.class

package cap6;

import cap6.bean.Monkey;
import org.springframework.beans.factory.FactoryBean;

public class WangFactoryBean implements FactoryBean<Monkey> {
    @Override
    public Monkey getObject() throws Exception {
        return new Monkey();
    }

    @Override
    public Class<?> getObjectType() {
        return Monkey.class;
    }

	//单实例还是多实例
    @Override
    public boolean isSingleton() {
        return false;
    }
}

配置

package cap6;

import cap6.bean.Cat;
import cap6.bean.Dog;
import cap1.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import(value = {Dog.class, Cat.class, WangImportSelect.class, WangImportBeanDefinitionRegistrar.class})
public class Cap6MainConfig {
    /**
     * 给容器中注册组件的方式
     * 1. @Bean: 导入第三方类或包的组件
     * 注意：@Bean有点简单
     * 2. 包扫描+组件的标注注解（@ComponentScan: @Controller, @Service, @Repository, @Component), 一般是针对我们自己写的类，使用这个
     * 3. @Import:快速给容器导入一个组件
   
     * 4. 使用Spring提供的Factory(工厂Bean)进行注册
     * @return
     */
    //容器启动时初始化Person的Bean实例
    @Bean("person")
    public Person person1(){
        return new Person("Wang",20);
    }

    @Bean
    public WangFactoryBean wangFactoryBean(){
        return new WangFactoryBean();

    }
}

测试类

import cap6.Cap6MainConfig;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Cap6Test {
    @Test
    public void test01() {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Cap6MainConfig.class);
        System.out.println("IOC容器初始化完成");

        Object bean1 = app.getBean("wangFactoryBean");
        System.out.println("Bean的类型=" + bean1.getClass());

        String[] beanDefinitionNames = app.getBeanDefinitionNames();
        for(String name: beanDefinitionNames)
            System.out.println(name);
    }
}