Spring容器装配组件的5种方式

1. 配置文件<bean>标签

spring配置文件中配置bean标签

<?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="testDao" class="com.xy.dao.TestDao" />

</beans>

将要注册的bean

public class TestDao {

    public void testDao() {
        System.out.println("testDao...");
    }
}

测试

    @Test
    public void testDao() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        TestDao testDao = (TestDao) app.getBean("testDao");
        testDao.testDao();
    }

2. 配置文件包扫描+组件标注注解

常用的组件标注注解有：

@Controller: 控制层
@Service: 业务逻辑层
@Repository: 数据访问层
@Component: 通用

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"
       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.xsd">

    <context:component-scan base-package="com.xy" />

</beans>

@Repository
public class TestDao {

    public void testDao() {
        System.out.println("testDao...");
    }
}

@Service
public class TestService {

    @Autowired
    private TestDao testDao;

    public void testService() {
        testDao.testDao();
    }
}

@Controller
public class TestController {

    @Autowired
    private TestService testService;

    public void testController() {
        testService.testService();
    }
}

测试

    @Test
    public void testController() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        TestController testController = (TestController) app.getBean("testController");
        testController.testController();

        System.out.println("Spring容器中的组件有：");
        String[] names = app.getBeanDefinitionNames();
        for (String s : names) {
            System.out.println(s);
        }
    }

测试结果

使用配置类代替配置文件

@ComponentScan("com.xy")
@Configuration
public class MyConfig {
}

3. 配置类@Configuration+@Bean

将要注册的bean

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
	// ...
}

配置类

@Configuration
public class MyConfig {

	/**
     *
     * @return 返回一个对象，并注入到Spring容器中，名字默认为方法名，可通过value指定名字
     */
    @Bean
    public Person person() {
        return new Person("lxg", 16);
    }
}

测试

    @Test
    public void testBean() {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MyConfig.class);
        String[] beans = app.getBeanDefinitionNames();
        for (String bean : beans) {
            System.out.println(bean);
        }
    }

4. @Import

配置类

@Configuration
@Import(Rainbow.class)
public class MyConfig {
}

value的值为数组类型，可以同时注册多个组件。可以实现ImportSelector接口返回一个将要装配bean的数组

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {

        return new String[]{"com.xy.bean.Red", "com.xy.bean.Green", "com.xy.bean.Blue"};  //将要装配的组件全限定名数组
    }
}

@Configuration
@Import({Rainbow.class, MyImportSelector.class})
public class MyConfig {
}

实现ImportBeanDefinitionRegistrar接口

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean red = registry.containsBeanDefinition("com.xy.bean.Red");
        boolean green = registry.containsBeanDefinition("com.xy.bean.Green");
        boolean blue = registry.containsBeanDefinition("com.xy.bean.Blue");
        
        if (red && green && blue) {
            RootBeanDefinition definition = new RootBeanDefinition(Rainbow.class);
            registry.registerBeanDefinition("rainbow", definition);
        }
    }
}

@Configuration
@Import({/*Rainbow.class, */MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
public class MyConfig {

}

测试

    @Test
    public void testImport() {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MyConfig.class);
        String[] beans = app.getBeanDefinitionNames();
        for (String bean : beans) {
            System.out.println(bean);
        }
    }

5. FactoryBean

配置类

@Configuration
public class MyConfig {
    @Bean
    public MyFactoryBean factoryBean() {
        return new MyFactoryBean();
    }
}

实现FactoryBean

public class MyFactoryBean implements FactoryBean<Rainbow> {
    @Override
    public Rainbow getObject() throws Exception {
	    /**
	    *  返回将要装配的组件到工厂中，但不会立即装配到spring容器中，返回的实例默认为单例
	    *  通过app.getBean()调用时才会装配到spring容器中
	    */
        return new Rainbow();
    }

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

    @Test
    public void testFactoryBean() {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MyConfig.class);
        String[] beans = app.getBeanDefinitionNames();
        for (String bean : beans) {
            System.out.println(bean);
        }

        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

        Object myFactoryBean = app.getBean("factoryBean");
        System.out.println(myFactoryBean.getClass());  // class com.xy.bean.Rainbow

        Object myFactoryBean02 = app.getBean("&factoryBean");
        System.out.println(myFactoryBean02.getClass());  // class com.xy.config.MyFactoryBean
    }

测试