spring三种方式装配bean:

1. 自动化装配bean

2. 借助java来进行bean装配

3. 使用xml进行bean装配

自动化装配Bean

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

• 组件扫描，spring自动发现上下文中的Bean

• 自动装配，spring自动满足bean之间的依赖

比如我在在类上添加注解@Component,这表明该类会作为组件类，并告知spring会为这个类创建Bean,但是组件扫描默认是不启动的，我们任然需要配值Spring,命令其去寻找带有注解的@Component注解的类，并为其创建Bean.

这时可以使用@CompoentScan，默认会扫描与配值类相同的包，同时会扫描这个包下的子包.

当然也可以使用XML来启用组件扫描

1<context:component-scan base-package="cn.itcast" />

测试时使用spring的springJunit4ClassRunner,以便在测试的时候自动创建spring上下文。而注解@ContextConfiguration会告诉它需要在哪一个类中加载配值

每创建一个Bean,就会为其创建一个ID,一般是以这个类名的首字母小写命名的，同时你也可以为其起一个特别的名字。
@Component("nameclass")

在注入的时候我们可以用@Autowired来标注，进行注入。

例子：

1@Service
2public class FunctionService {
3
4    public String sayHallo(String word){
5        return "hello "+word+" !";
6    }
7}

选择使用@Component @Servie @Repository @Controller，把Bean交给Spring管理。

1//@Autowired是自动注入的注解，
2    @Autowired
3    FunctionService functionService;

将实例化好的FunctionService类注入到本类中的属性。

1@Configuration//声明当前类是一个配置类
2@ComponentScan("site.wangxin520.springstudy")//相当于xml中配置到 扫描包
3public class DiConfig {
4
5}

但是任然需要创建配值类，设置扫描包

1  AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(DiConfig.class);
2  UserFuctionService userFuctionService = context.getBean(UserFuctionService.class);

加载配值类。

通过Java代码装配Bean

使用第三方的库装配到你的应用上，就不能采用自动化的注解，这时就需要使用XML和JAVA来进行配值。
Java注解是Spring4.0推荐的方法,属于显式配值。
java注解中只不过去掉了@Service和@Autowrid

 1public class FunctionService {
 2
 3    public String sayHallo(String word){
 4        return "hello "+word+" !";
 5    }
 6}
 7//需要包含set方法
 8public class UserFuctionService {
 9
10    FunctionService functionService;
11
12    public void setFunctionService(FunctionService functionService) {
13        this.functionService = functionService;
14    }
15
16    public String sayHello(String word) {
17        return functionService.sayHallo(word);
18    }
19
20}

1. 创建配值类

2. 声明Bean,它会告诉Spring当前对象返回的是一个对象Bean,Spring会将其加载到其的上下文中。

3. 注入

 1@Configuration
 2//这里注意的是，没有使用包扫描的注解
 3public class JavaConfig {
 4
 5    @Bean//使用Bean注解声明当前方法的返回值是一个Bean，名称就是方法名
 6    public FunctionService functionService(){
 7        return new FunctionService();
 8    }
 9    //使用构造器注入
10    @Bean
11    public userFunctionService functionService(){
12        return new userFunctionService(functionService());
13    }
14
15    //使用set注入
16    @Bean
17    public UserFuctionService  userFuctionService(){
18        //当使用userFunctionService时候，就会调用这个里面的方法去获取bean
19        UserFuctionService userFuctionService=new UserFuctionService();
20        userFuctionService.setFunctionService(functionService());
21        return userFuctionService;
22
23    }
24
25    @Bean//这是另外一种注入的方式，直接使用参数注入的方式
26    public UserFuctionService userFuctionService(FunctionService functionService){
27
28        UserFuctionService userFuctionService=new UserFuctionService();
29        userFuctionService.setFunctionService(functionService());
30        return userFuctionService;
31
32    }
33}

使用XML装配Bean

使用XML配置文件的方式装配bean，首要的就是要创建一个基于Spring配置规范的XML文件，该配置文件以为根元素（相当于Java配置的@Configuration注解），包含一个或多个元素(相当于配置类中@Bean注解)。

1<?xml version="1.0" encoding="UTF-8"?>
2<beans xmlns="http://www.springframework.org/schema/beans"
3       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4       xsi:schemaLocation="http://www.springframework.org/schema/beans
5       http://www.springframework.org/schema/beans/spring-beans.xsd">
6
7    <!--通过类的全限定名来声明要创建的bean-->
8    <bean class="spring.impl.BenzCar"></bean>
9</beans>

加载配值文件

1 ApplicationContext context = new ClassPathXmlApplicationContext("resource/applicationContext.xml");
2        //XML的方式如果没有明确给定ID，默认bean的ID会根据类的全限定名来命名，以#加计数序号的方式命名。
3        Car car = (Car)context.getBean("spring.impl.BenzCar#0");

1. 构造器注入

1bean id="car" class="spring.impl.BenzCar"></bean>
2    <bean id="man" class="spring.impl.Man">
3        <!--通过Man的构造器注入Car的实例对象-->
4        <constructor-arg ref="car"></constructor-arg>
5    </bean>
6

如果构造器有很多属性也可以注入值

1<bean id="car" class="spring.impl.BenzCar"></bean>
2    <bean id="man" class="spring.impl.Man">
3        <!--分别注入字面值和对象的应用-->
4        <constructor-arg value="12"></constructor-arg>
5        <constructor-arg ref="car"></constructor-arg>
6    </bean>

或者是一个集合

1<constructor-arg>
2            <list>
3                <ref bean="benzCar"/>
4                <ref bean="qqCar"/>
5            </list>
6</constructor-arg>
7

2. setter注入

1 <bean id="man" class="spring.impl.Man">
2        <!--通过属性注入的方式注入Car的实例-->
3        <property name="car" ref="benzCar"></property>
4    </bean>

XML配置文件中属性注入的属性名必须要和Java类中Setter方法对应的属性名一致

配值的混合

在Java配值Spring时，如果配值类太大一般会将其拆分为两个或多个配值来，然后使用@Import(name.class)进行导入组合。

但是一个配值文件是JavaConfig，一个是Xml配值的，这是要用@ImportResource(xxxxx.xml)

那么如果想反过来在xml中引入java配值文件呢？
在xml中我们可以使用

1<import resource="classpath:xxx.xml" />

来引入xml配值文件
而如果要在XML中引入Java配置，只需将Java配置类当成普通的bean在XML中进行声明即可，但是在测试的时候要注意开启组件扫描，因为加载XML配置的上下文对象只会加载XML配置文件中的bean定义，无法让基于Java配置类产生bean的装配机制自动生效

1<!--开启组件扫描，在测试的时候配置类才能向容器中注册类中声明的bean-->
2    <context:component-scan base-package="spring"/>
3    <!--XML中引入Java配置类：将配置类声明为bean-->
4    <bean class="spring.config.CarConfig"></bean>
5    <bean id="man" class="spring.impl.Man">
6        <constructor-arg ref="laoSiJi"></constructor-arg>
7    </bean>