　　BeanFactory 是基础类型的 IoC 容器，它由 org.springframework.beans.facytory.BeanFactory 接口定义，并提供了完整的 IoC 服务支持。简单来说，BeanFactory 就是一个管理 Bean 的工厂，它主要负责初始化各种 Bean，并调用它们的生命周期方法。

　　BeanFactory 接口有多个实现类，最常见的是 org.springframework.beans.factory.xml.XmlBeanFactory，它是根据 XML 配置文件中的定义装配 Bean 的。

　　创建 BeanFactory 实例时，需要提供 Spring 所管理容器的详细配置信息，这些信息通常采用 XML 文件形式管理。其加载配置信息的代码具体如下所示：

BeanFactory beanFactory = new XmlBeanFactory(newFileSystemResource("D://applicationContext.xml"));

　　ApplicationContext

　　ApplicationContext 是 BeanFactory 的子接口，也被称为应用上下文。该接口的全路径为 org.springframework.context.ApplicationContext，它不仅提供了 BeanFactory 的所有功能，还添加了对 i18n（国际化）、资源访问、事件传播等方面的良好支持。

　　ApplicationContext 接口有两个常用的实现类，具体如下。

　　1）ClassPathXmlApplicationContext

该类从类路径 ClassPath 中寻找指定的 XML 配置文件，找到并装载完成 ApplicationContext 的实例化工作，具体如下所示。

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation);

在上述代码中，configLocation 参数用于指定 Spring 配置文件的名称和位置，如 applicationContext.xml。

　　2）FileSystemXmlApplicationContext

　　该类从指定的文件系统路径中寻找指定的 XML 配置文件，找到并装载完成 ApplicationContext 的实例化工作，具体如下所示。

ApplicationContext applicationContext = new FileSystemXmlApplicationContext(String configLocation);

　　它与 ClassPathXmlApplicationContext 的区别是：在读取 Spring 的配置文件时，FileSystemXmlApplicationContext 不再从类路径中读取配置文件，而是通过参数指定配置文件的位置，它可以获取类路径之外的资源，“F：/workspaces/applicationContext.xml”。

　　在使用 Spring 框架时，可以通过实例化其中任何一个类创建 Spring 的 ApplicationContext 容器。

　　通常在 Java 项目中，会采用通过 ClassPathXmlApplicationContext 类实例化 ApplicationContext 容器的方式，而在 Web 项目中，ApplicationContext 容器的实例化工作会交由 Web 服务器完成。Web 服务器实例化 ApplicationContext 容器通常使用基于 ContextLoaderListener 实现的方式，它只需要在 web.xml 中添加如下代码：

<!--指定Spring配置文件的位置，有多个配置文件时，以逗号分隔-->
<context-param>
<param-name>contextConfigLocation</param-name>
<!--spring将加载spring目录下的applicationContext.xml文件-->
<param-value>
classpath:spring/applicationContext.xml
</param-value>
</context-param>
<!--指定以ContextLoaderListener方式启动Spring容器-->
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>

　　需要注意的是，BeanFactory 和 ApplicationContext 都是通过 XML 配置文件加载 Bean 的。

　　二者的主要区别在于，如果 Bean 的某一个属性没有注入，则使用 BeanFacotry 加载后，在第一次调用 getBean() 方法时会抛出异常，而 ApplicationContext 则在初始化时自检，这样有利于检查所依赖的属性是否注入。
　　因此，在实际开发中，通常都选择使用 ApplicationContext，而只有在系统资源较少时，才考虑使用 BeanFactory。

2.4、控制反转的演示

2.4.1、导入jar包

　　4个核心包+1个日志包

spring-beans-5.1.9.RELEASE
spring-context-5.1.9.RELEASE
spring-core-5.1.9.RELEASE
spring-expression-5.1.9.RELEASE
spring-jcl-5.1.9.RELEASE

2.4.2、编写代码

public interface UserService {
    void addUser();
}


public class UserServiceImpl implements UserService{
    @Override
    public void addUser(){
        System.out .println("添加用户成功");
    }
}

2.4.3、编写配置文件

<?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：是创建对象的唯一值 不能有特殊符号 我们获取对象就需要这个id从IOC容器中获取
            Class：表示要创建的类的完整路径（底层使用反射）
    -->
    <bean id="userService" class="com.shangma.cn.service.impl.UserServiceImpl"/>
</beans>

2.4.4、编写测试类

public class IOCTest {

    public statice void main(String[] args){
        //加载配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取对象  从IOC容器中拿到创建的对象，参数1：XML中设置的ID属性（根据ID找到对应的Bean） 参数2：要拿到的对应的类（返回的类型是对应的类的类型，不用在进行强制转换） 
　　　　　UserService userService= applicationContext.getBean("userService",UserService.class);

         userService.addUser(); 
　　　　} 
}

3、Spring的依赖注入（DI）

　　Spring 容器在创建被调用者的实例时，会自动将调用者需要的对象实例注入给调用者，这样，调用者通过 Spring 容器获得被调用者实例，这称为依赖注入。说白了就是给创建出来的对象的成员变量自动的赋值。

　　依赖注入有三种方式分别是：set赋值，构造方法赋值和P命名空间赋值。

3.1、使用set给属性赋值

　　指 IoC 容器使用 setter 方法注入被依赖的实例。通过调用无参构造器或无参 static 工厂方法实例化 bean 后，调用该 bean 的 setter 方法，即可实现基于 setter 的 DI。

3.1.1、给基本数据类型和字符串类型的属性赋值

<!--给基本数据类型类型赋值  name：表示类中的属性名 value：是指这个属性名对应的值 -->
<bean id="man" class="com.sm.qy30.entity.Man" >
    <property name="name" value="tom"/>
    <property name="age" value="25"/>
    <property name="flag" value="true"/>
</bean>

3.1.2、给自定义的引用类型赋值

<!--给自定义的引用类型赋值  name：表示类中的属性名 ref：是指这个属性名对应的Bean标签的ID -->
<bean id="man" class="com.sm.qy30.entity.Man" >
    <property name="name" value="tom"/>
    <property name="age" value="25"/>
    <property name="wife" ref="wife111"/>
</bean>

<bean id="wife111" class="com.sm.qy30.entity.Wife">
    <property name="name" value="lisa"/>
    <property name="age" value="14"/>
</bean>

3.2、使用构造方法给属性赋值

　　指 IoC 容器使用构造方法注入被依赖的实例。基于构造器的 DI 通过调用带参数的构造方法实现，每个参数代表一个依赖。

<bean id= "user" class="com.shangma .cn.entity.user">
    <!--  构造方法的方式赋值  name：表示属性名  value：表示基本数据类型的值  ref：表示自定义类型对应Bean标签的ID-->
     <constructor-arg  name="username" value= "tom"/>
     <constructor-arg  name="age" value= "33"/>
     <constructor-arg  name="flag" value= "true"/>
     <constructor-arg  name="wife" ref= "wife111"/>
</bean>

3.3、使用P命名空间给属性赋值（了解）

　　底层依赖于set方法

3.3.1、在配置文件中添加约束

<?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:p="http://www.springframework.org/schema/p"


       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

3.3.2、使用P空间方式赋值

<!--  p命名空间方式赋值    需要导入命名空间   编写在标签的属性位置  自定义引用类型使用p:xxxx-ref:xxxx对应的Bean标签ID-->
<bean id= "user" class="com.shangma .cn.entity.user" p:usernaem="tom"  p:age="32" p:wife-ref="wife111">
</bean>

4、Spring创建对象的方式（Bean的实例化）

4.1、Bean的配置及常用属性

　　作为 Spring 核心机制的依赖注入，改变了传统的编程习惯，对组件的实例化不再由应用程序完成，转而交由 Spring 容器完成，在需要时注入应用程序中，从而对组件之间依赖关系进行了解耦。这一切都离不开 Spring 配置文件中使用的 <bean> 元素。

　　Spring 容器可以被看作一个大工厂，而 Spring 容器中的 Bean 就相当于该工厂的产品。如果希望这个大工厂能够生产和管理 Bean，这时则需要告诉容器需要哪些 Bean，以及需要以何种方式将这些 Bean 装配到一起。

　　Spring 配置文件支持两种不同的格式，分别是 XML 文件格式和 Properties 文件格式。

　　通常情况下，Spring 会以 XML 文件格式作为 Spring 的配置文件，这种配置方式通过 XML 文件注册并管理 Bean 之间的依赖关系。

　　XML 格式配置文件的根元素是 <beans>，该元素包含了多个 <bean> 子元素，每一个 <bean> 子元素定义了一个 Bean，并描述了该 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" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
    <!-- 使用id属性定义person1，其对应的实现类为com.mengma.person1 -->
    <bean id="person1" class="com.mengma.damain.Person1" />
    <!--使用name属性定义person2，其对应的实现类为com.mengma.domain.Person2-->
    <bean name="Person2" class="com.mengma.domain.Person2"/>
</beans>

　　在上述代码中，分别使用 id 和 name 属性定义了两个 Bean，并使用 class 元素指定了 Bean 对应的实现类。

　　<bean> 元素中包含很多属性，其常用属性如表所示。

<bean>元素的常用属性
属性名称	描述
id	是一个 Bean 的唯一标识符，Spring 容器对 Bean 的配置和管理都通过该属性完成
name	Spring 容器同样可以通过此属性对容器中的 Bean 进行配置和管理，name 属性中可以为 Bean 指定多个名称，每个名称之间用逗号或分号隔开
class	该属性指定了 Bean 的具体实现类，它必须是一个完整的类名，使用类的全限定名
scope	用于设定 Bean 实例的作用域，其属性值有 singleton（单例）、prototype（原型）、request、session 和 global Session。其默认值是 singleton
constructor-arg	<bean>元素的子元素，可以使用此元素传入构造参数进行实例化。该元素的 index 属性指定构造参数的序号（从 0 开始），type 属性指定构造参数的类型
property	<bean>元素的子元素，用于调用 Bean 实例中的 Set 方法完成属性赋值，从而完成依赖注入。该元素的 name 属性指定 Bean 实例中的相应属性名
ref	<property> 和 <constructor-arg> 等元素的子元索，该元素中的 bean 属性用于指定对 Bean 工厂中某个 Bean 实例的引用
value	<property> 和 <constractor-arg> 等元素的子元素，用于直接指定一个常量值
list	用于封装 List 或数组类型的依赖注入
set	用于封装 Set 类型属性的依赖注入
map	用于封装 Map 类型属性的依赖注入
entry	<map> 元素的子元素，用于设置一个键值对。其 key 属性指定字符串类型的键值，ref 或 value 子元素指定其值

4.2、无参构造的方式（默认情况下）

　　在无参构造中打印一句话就可以查看到

4.3、静态工厂的方式

　　1)创建一个空的实体类Person

　　2) 创建一个工厂类 MyBeanFactory

　　3)创建静态方法 createBean()

package com.mengma.instance.static_factory;

public class MyBeanFactory {
    // 创建Bean实例的静态工厂方法
    public static Person createBean() {
        return new Person();
    }
}

　　4) 创建配置文件applicationContext.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" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
    <bean id="person" class="com.shangma.cn.static_factory.MyBeanFactory"
        factory-method="createBean" />
</beans>

　　5)创建测试类

package com.mengma.instance.static_factory;

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

public class InstanceTest2 {
    @Test
    public void test() {
        // 定义Spring配置文件的路径
        String xmlPath = "com/mengma/instance/static_factory/applicationContext.xml"; // 初始化Spring容器，加载配置文件，并对bean进行实例化
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        // 通过容器获取id为person实例
        System.out.println(applicationContext.getBean("person"));
    }
}

4.4、实例工厂的方式

　　顾名思义必须现有工厂实例对象。通过实例对象创建对象，提供所有的方法都是“费静态的”

　　把静态工厂中，静态方法的static去掉就是一个实例工厂

4.5、使用XML配置方式装配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" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
    <!-- 使用set方式装配Person实例 -->
    <bean id="person1" class="com.mengma.assembly.Person">
        <property name="name" value="zhangsan" />
        <property name="age" value="20" />
    </bean>
    <!-- 使用构造方法装配Person实例 -->
    <bean id="person2" class="com.mengma.assembly.Person">
        <constructor-arg index="0" value="lisi" />
        <constructor-arg index="1" value="21" />
    </bean>
</beans>

XML配置包扫描的方式装配Bean

　　1) 添加aop.jar

　　　　 spring-aop-5.1.9.RELEASE

　　2) 配置包扫描

<!-- 
    开启包扫描
    会自动扫描  指定包和它的子包下有@Component注解的类

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

　　3) 在类上添加注解

　　　　@component（）在类上添加这个注解，参数指定的是id 如果不写默认的id就是类的首字母小写

　　说明点：

- @component注解在一个类上加了这个注解，表示这个类成为了Spring的一个组件，加入到IOC容器中
- @component注解针对Java的三层架构有延伸的注解@Controller @Service @Repository

4.6、使用Annotation（注解）方式装配Bean

　　在 Spring 中，尽管使用 XML 配置文件可以实现 Bean 的装配工作，但如果应用中 Bean 的数量较多，会导致 XML 配置文件过于臃肿，从而给维护和升级带来一定的困难。

　　Java 从 JDK 5.0 以后，提供了 Annotation（注解）功能，Spring 也提供了对 Annotation 技术的全面支持。Spring3 中定义了一系列的 Annotation（注解），常用的注解如下。

1）@Component

可以使用此注解描述 Spring 中的 Bean，但它是一个泛化的概念，仅仅表示一个组件（Bean），并且可以作用在任何层次。使用时只需将该注解标注在相应类上即可。

2）@Repository

用于将数据访问层（DAO层）的类标识为 Spring 中的 Bean，其功能与 @Component 相同。

3）@Service

通常作用在业务层（Service 层），用于将业务层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。

4）@Controller

通常作用在控制层（如 Struts2 的 Action），用于将控制层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。

5）@Autowired

用于对 Bean 的属性变量、属性的 Set 方法及构造函数进行标注，配合对应的注解处理器完成 Bean 的自动配置工作。默认按照 Bean 的类型进行装配。

6）@Resource

其作用与 Autowired 一样。其区别在于 @Autowired 默认按照 Bean 类型装配，而 @Resource 默认按照 Bean 实例名称进行装配。

@Resource 中有两个重要属性：name 和 type。

Spring 将 name 属性解析为 Bean 实例名称，type 属性解析为 Bean 实例类型。如果指定 name 属性，则按实例名称进行装配；如果指定 type 属性，则按 Bean 类型进行装配。

如果都不指定，则先按 Bean 实例名称装配，如果不能匹配，则再按照 Bean 类型进行装配；如果都无法匹配，则抛出 NoSuchBeanDefinitionException 异常。

7）@Qualifier

与 @Autowired 注解配合使用，会将默认的按 Bean 类型装配修改为按 Bean 的实例名称装配，Bean 的实例名称由 @Qualifier 注解的参数指定。

4.7、自动装配Bean

　　除了使用 XML 和 Annotation 的方式装配 Bean 以外，还有一种常用的装配方式——自动装配。自动装配就是指 Spring 容器可以自动装配（autowire）相互协作的 Bean 之间的关联关系，将一个 Bean 注入其他 Bean 的 Property 中。

　　要使用自动装配，就需要配置 <bean> 元素的 autowire 属性。autowire 属性有五个值，具体说明如下所示。

autowire 的属性和作用
名称	说明
byName	根据 Property 的 name 自动装配，如果一个 Bean 的 name 和另一个 Bean 中的 Property 的 name 相同，则自动装配这个 Bean 到 Property 中。
byType	根据 Property 的数据类型（Type）自动装配，如果一个 Bean 的数据类型兼容另一个 Bean 中 Property 的数据类型，则自动装配。
constructor	根据构造方法的参数的数据类型，进行 byType 模式的自动装配。
autodetect	如果发现默认的构造方法，则用 constructor 模式，否则用 byType 模式。
no	默认情况下，不使用自动装配，Bean 依赖必须通过 ref 元素定义。

举一个栗子

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:p="http://www.springframework.org/schema/p" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="  
            http://www.springframework.org/schema/beans 
            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
            http://www.springframework.org/schema/aop 
            http://www.springframework.org/schema/aop/spring-aop-2.5.xsd  
            http://www.springframework.org/schema/tx 
            http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
    <bean id="personDao" class="com.mengma.annotation.PersonDaoImpl" />
    <bean id="personService" class="com.mengma.annotation.PersonServiceImpl"
        autowire="byName" />
    <bean id="personAction" class="com.mengma.annotation.PersonAction"
        autowire="byName" />
</beans>

　　在上述配置文件中，用于配置 personService 和 personAction 的 <bean> 元素中除了 id 和 class 属性以外，还增加了 autowire 属性，并将其属性值设置为 byName（按属性名称自动装配）。

　　默认情况下，配置文件中需要通过 ref 装配 Bean，但设置了 autowire="byName"，Spring 会在配置文件中自动寻找与属性名字 personDao 相同的 <bean>，找到后，通过调用 setPersonDao（PersonDao personDao）方法将 id 为 personDao 的 Bean 注入 id 为 personService 的 Bean 中，这时就不需要通过 ref 装配了。

5、Bean的生命周期

　　首先要了解Spring默认启动的时候就创建Bean并且是个单实例的Bean，如果其他组件需要使用这个Bean的时候直接从容器中取。

5.1、延迟加载的配置

　　默认情况下Spring已启动对象则会被实例化，我们配置延迟加载，让对象使用的时候在实例化

　　使用lazy-init属性开启延迟加载，设置为true则表示开启延迟加载。

<bean id= "user " class="com.shangma.cn.entity.User" lazy-init="true"/>

5.2、生命周期的属性

　　实例化：默认情况下，配置文件一加载就实例化了

　　初始化：初始化的方法可以自己指定，使用的是init-method属性

　　销毁：销毁的方法也是可以自己指定，使用的是destrop-method属性指定

5.3、Bean的作用域

　　Spring 容器在初始化一个 Bean 的实例时，同时会指定该实例的作用域。Spring3 为 Bean 定义了五种作用域，具体如下。

1）singleton

　　单例模式，使用 singleton 定义的 Bean 在 Spring 容器中只有一个实例，这也是 Bean 默认的作用域。

2）prototype

　　原型模式，每次通过 Spring 容器获取 prototype 定义的 Bean 时，容器都将创建一个新的 Bean 实例。

3）request

　　在一次 HTTP 请求中，容器会返回该 Bean 的同一个实例。而对不同的 HTTP 请求，会返回不同的实例，该作用域仅在当前 HTTP Request 内有效。

4）session

　　在一次 HTTP Session 中，容器会返回该 Bean 的同一个实例。而对不同的 HTTP 请求，会返回不同的实例，该作用域仅在当前 HTTP Session 内有效。

5）global Session

　　在一个全局的 HTTP Session 中，容器会返回该 Bean 的同一个实例。该作用域仅在使用 portlet context 时有效。

在上述五种作用域中，singleton 和 prototype 是最常用的两种。

　　单例模式（singleton）是默认值：全局只有一个对象

　　多例模式（prototype）：用一次创建一个新对象，本身实现延迟加载，就算取消延迟加载也是无效的。

6、加载外部配置文件和取值

　　需求：把properties中定义的键值对，赋值到spring所创建对象的属性中

<!--加载配置文件的方式
        第一种：键值对写法 （在XML中编写）
        第一步：使用context:property-placeholder location=记载配置文件
        第二步：${key}取里面的值
 -->
        <context:property-placeholder location="properties.properties"/>
        <bean id="" class="" >
            <property name="" value="${xxx}"/>
        </bean>

        <!-- 第二种：注解写法  （在类中编写） -->
        @PropertySource（value="properties.properties"）
        @Value("${xxx}")

XML配置

XML配置文件以包扫描的方式

注解的方式

码农公寓

1、耦合

2、Spring的控制反转（IOC）

3、Spring的依赖注入（DI）

4、Spring创建对象的方式（Bean的实例化）

5、Bean的生命周期

6、加载外部配置文件和取值

相关文章