配置bean

配置形式

1.基于XML文件的方式

  • Spring 的配置文件: 一个典型的 Spring 项目需要创建一个或多个 Bean 配置文件, 这些配置文件用于在 Spring IOC 容器里配置 Bean. Bean 的配置文件可以放在 classpath 下(src), 也可以放在其它目录下.
< bean   id = "user DaoImpl" class = "com.shxt.dao.impl.UserDaoImpl" lazy-init = "true"  init-method = "myInit"  destroy-method = "myDestroy"  scope = "prototype" >      
</ bean >
  • 在XML配置中,通过<bean> </bean>来定义Bean,通过id或class属性定义Bean的名称,如果未指定id和class属性,Spring则自动将全限定类名作为Bean的名称,默认id为类名的第一个字母小写。通过<property>子元素或者p命名空间的动态属性为Bean注入值。还可以通过<bean>的init-method和destory-method属性指定Bean实现类的方法名来设置生命过程方法(最多指定一个初始化方法和销毁方法)。通过<bean>的scope属性指定Bean的作用范围。<bean>的lazy-init属性指定是否延迟初始化。
  • 当Bean的实现类来源于第三方类库,比如DataSource、HibernateTemplate等,无法在类中标注注解信息,只能通过XML进行配置;而且命名空间的配置,比如aop、context等,也只能采用基于XML的配置。

2.基于注解的方式

在 classpath 中扫描组件
  • 组件扫描(component scanning): Spring 能够从 classpath 下自动扫描, 侦测和实例化具有特定注解的组件.
  • 特定组件包括:
    1. @Component: 基本注解, 标识了一个受 Spring 管理的组件
    2. @Respository: 标识持久层组件
    3. @Service: 标识服务层(业务层)组件
    4. @Controller: 标识表现层组件
  • 对于扫描到的组件, Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称
    当在组件类上使用了特定的注解之后, 还需要在 Spring 的配置文件中声明 <context:component-scan>
    1. base-package 属性指定一个需要扫描的基类包,Spring 容器将会扫描这个基类包里及其子包中的所有类.
    2. 当需要扫描多个包时, 可以使用逗号分隔.
    3. 如果仅希望扫描特定的类而非基包下的所有类,可使用 resource-pattern 属性过滤特定的类,示例:
<!-- 扫描注释所在的包,com.shxt.spring.beans下的service包下的 -->      < context:component-scan   base-package = "com.shxt.spring.beans"   resource-pattern = "service/*.class" ></ context:component-scan > 
  1. <context:include-filter>子节点表示要包含的目标类
  2. <context:exclude-filter> 子节点表示要排除在外的目标类
  3. <context:component-scan> 下可以拥有若干
  4. <context:include-filter><context:exclude-filter>子节点
  5. <context:include-filter><context:exclude-filter>子节点支持多种类型的过滤表达式:
类型示例说明
annotationcom.shxt.XxxxAnnotation所有标注了XxxxAnnotation的类,该类型采用目标类是否标注了某个注解进行过滤
assinablecom.shxt.XxxxService所有继承扩展XxxxService的类,该类型采用目标类是否继承或扩展某个特定类进行处理
aspectjcom.shxt.*Service+所有类名以Service结尾的类及继承或扩展他们的类,该类型采用AspejctJ表达式进行过滤
regexcom.\shxt.anno…*所有com.shxt.anno包下的类,该类型采用正则表达式根据类的类名尽心过滤
customcom.shxt.XxxxTypeFilter采用XxxxTypeFilter通过代码的方式定义过滤规则,该类必须实现org.springframework.core.type.TypeFilter接口
组件装配
  • <context:component-scan> 元素还会自动注册 AutowiredAnnotationBeanPostProcessor 实例, 该实例可以自动装配具有 @Autowired 和 @Resource 、@Inject注解的属性.
使用 @Autowired 自动装配 Bean
  • @Autowired 注解自动装配具有兼容类型的单个 Bean属性
    1. 构造器, 普通字段(即使是非 public), 一切具有参数的方法都可以应用@Authwired 注解
    2. 默认情况下, 所有使用 @Authwired 注解的属性都需要被设置. 当 Spring 找不到匹配的 Bean 装配属性时, 会抛出异常, 为了避免这个异常出现,可以设置 @Authwired 注解的 required 属性为 false,Spring会尝试执行自动装配,但是如果没有匹配bean的话,Spring将会让这个bean处于未装配的状态,但是,把required设置成false时,需要谨慎,如果你的代码中没有进行null检查的话,这个为装配状态的属性有可能会出现NullPointerException。
    3. 默认情况下, 当 IOC 容器里存在多个类型兼容的 Bean 时, 通过类型的自动装配将无法工作. 此时可以在 @Qualifier 注解里提供 Bean 的名称. Spring 允许对方法的入参标注 @Qualifiter 已指定注入 Bean 的名称
    4. @Authwired 注解也可以应用在数组类型的属性上, 此时 Spring 将会把所有匹配的 Bean 进行自动装配.
    5. @Authwired 注解也可以应用在集合属性上, 此时 Spring 读取该集合的类型信息, 然后自动装配所有与之兼容的 Bean.
    6. @Authwired 注解用在 java.util.Map 上时, 若该 Map 的键值为 String, 那么 Spring 将自动装配与之 Map 值类型兼容的 Bean, 此时 Bean 的名称作为键值
使用 @Resource 或 @Inject 自动装配 Bean
  • Spring 还支持 @Resource 和 @Inject 注解,这两个注解和 @Autowired 注解的功用类似
  • @Resource 注解要求提供一个 Bean 名称的属性,若该属性为空,则自动采用标注处的变量或方法名作为 Bean 的名称
  • @Inject 和 @Autowired 注解一样也是按类型匹配注入的 Bean, 但没有 reqired 属性
  • 建议使用 @Autowired 注解

Bean的配置方式

1.通过全类名(反射)(推荐)

<!-- id为类名首字母小写 -->
< bean   id = "helloWorld"   class = "com.atguigu.spring.helloworld.HelloWorld" >
         <!-- 为属性赋值 -->
         < property   name = "user"   value = "Jerry" ></ property >  
</ bean > 

2.通过工厂方法(静态工厂方法&实例工厂方法)

通过调用静态工厂方法创建 Bean
  • 调用静态工厂方法创建 Bean是将对象创建的过程封装到静态方法中. 当客户端需要对象时, 只需要简单地调用静态方法, 而不同关心创建对象的细节.
  • 要声明通过静态方法创建的 Bean, 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用<constrctor-arg> 元素为该方法传递方法参数.
通过调用实例工厂方法创建 Bean
  • 实例工厂方法: 将对象的创建过程封装到另外一个对象实例的方法里. 当客户端需要请求对象时, 只需要简单的调用该实例方法而不需要关心对象的创建细节.
  • 要声明通过实例工厂方法创建的 Bean
    1. 在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean
    2. 在 factory-method 属性里指定该工厂方法的名称
    3. 使用 construtor-arg 元素为工厂方法传递方法参数
     <!-- 通过工厂方法的方式来配置 bean -->
     <!-- 1. 通过静态工厂方法: 一个类中有一个静态方法, 可以返回一个类的实例(了解) -->
     <!-- 在 class 中指定静态工厂方法的全类名, 在 factory-method 中指定静态工厂方法的方法名 -->
     < bean   id = "dateFormat"   class = " java.text.DateFormat "  factory-method = "getDateInstance" >
         <!-- 可以通过 constructor-arg 子节点为静态工厂方法的参数赋值 -->
         < constructor-arg   value = "2" ></ constructor-arg >
     </ bean >

     <!-- 2. 实例工厂方法: 先需要创建工厂对象, 再调用工厂的非静态方法返回实例(了解) -->
     <!-- ①. 创建工厂对应的 bean -->
     < bean   id = "simpleDateFormat"   class = "java.text.SimpleDateFormat" >
         < constructor-arg   value = "yyyy-MM-dd hh:mm:ss" ></ constructor-arg >
     </ bean >

     <!-- ②. 有实例工厂方法来创建 bean 实例 -->
     <!-- factory-bean 指向工厂 bean, factory-method 指定工厂方法(了解) -->
     < bean   id = "datetime"   factory-bean = "simpleDateFormat"   factory-method = "parse" >
         <!-- 通过 constructor-arg 执行调用工厂方法需要传入的参数 -->
         < constructor-arg   value = "1990-12-12 12:12:12" ></ constructor-arg >   
     </ bean >  

3.FactoryBean

  • Spring 中有两种类型的 Bean, 一种是普通Bean, 另一种是工厂Bean, 即FactoryBean.
  • 工厂 Bean 跟普通Bean不同, 其返回的对象不是指定类的一个实例, 其返回的是该工厂 Bean 的 getObject 方法所返回的对象
public   interface  FactoryBean {
     //FactoryBean返回的实例
    Object getObject()  throws  Exception;

     //FactoryBean 返回的类型
     Class  getObjectType();
     //FactoryBean 返回的实例是否为单例
     boolean  isSingleton();
}
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.FactoryBean;
import com.atguigu.spring.helloworld.Car;
import com.atguigu.spring.helloworld.User;
public class UserBean implements FactoryBean<User>{

/**
* 返回的 bean 的实例
*/
@Override
public User getObject() throws Exception {
User user = new User();
user.setUserName("abc");
user.setWifeName("ABC");

List<Car> cars = new ArrayList<>();
cars.add(new Car("ShangHai", "BuiKe", 180, 300000));
cars.add(new Car("ShangHai", "CRUZE", 130, 150000));

user.setCars(cars);
return user;
}


/**
* 返回的 bean 的类型
*/
@Override
public Class<?> getObjectType() {
return User.class;
}


/**
* 返回的 bean 是否为单例的
*/
@Override
public boolean isSingleton() {
return true;
}


}
                        <!-- 配置通过 FactroyBean 的方式来创建 bean 的实例(了解) -->
     < bean   id = "user"   class = "com.atguigu.spring.ref.UserBean" ></ bean >       

IOC容器BeanFactory & ApplicationContext

在 Spring IOC 容器读取 Bean 配置创建 Bean 实例之前, 必须对它进行实例化. 只有在容器实例化后, 才可以从 IOC 容器里获取 Bean 实例并使用。

  • Spring 提供了两种类型的 IOC 容器实现.
    1. BeanFactory: IOC 容器的基本实现.
    2. ApplicationContext: 提供了更多的高级特性. 是 BeanFactory 的子接口.
    3. BeanFactory 是 Spring 框架的基础设施,面向 Spring 本身;ApplicationContext 面向使用 Spring 框架的开发者,几乎所有的应用场合都直接使用 ApplicationContext 而非底层的 BeanFactory
    4. 无论使用何种方式, 配置文件时相同的.
  • ApplicationContext 的主要实现类:
    1> ClassPathXmlApplicationContext:从类路径下加载配置文件
    2> FileSystemXmlApplicationContext: 从文件系统中加载配置文件

  • ConfigurableApplicationContext 扩展于 ApplicationContext,新增加两个主要方法:refresh() 和 close(), 让 ApplicationContext 具有启动、刷新和关闭上下文的能力

  • ApplicationContext 在初始化上下文时就实例化所有单例的 Bean。

  • WebApplicationContext 是专门为 WEB 应用而准备的,它允许从相对于 WEB 根目录的路径中完成初始化工作

    需要示例代码

依赖注入的方式

1.属性注入

  • 属性注入即通过setter方法注入Bean 的属性值或依赖的对象
  • 属性注入使用<property> 元素, 使用 name 属性指定 Bean 的属性名称,value 属性或 <value>子节点指定属性值
  • 属性注入是实际应用中最常用的注入方式
package  com.atguigu.spring.helloworld;
public   class  HelloWorld {
     private  String  user ;
                //user为name的值

     public   void  setUser(String  user ) {
         this . user  =  user ;     } 
}
         <!-- 配置一个 bean -->
          < bean   id = "helloWorld"   class = "com.atguigu.spring.helloworld.HelloWorld" >
             <!-- 为属性赋值 -->
             <!-- 通过属性注入: 通过 setter 方法注入属性值,name属性值为setter方法,set后首字母小写 -->
             < property   name = "user"   value = "Tom" ></ property >
         </ bean >  

2.构造器注入

  • 通过构造方法注入Bean 的属性值或依赖的对象,它保证了 Bean 实例在实例化后就可以使用。
  • 构造器注入在<constructor-arg> 元素里声明属性, <constructor-arg> 中没有 name 属性,有value属性为其赋值
  public  HelloWorld(String  user ) {
         this . user  =  user ;     } 
                        <!-- 通过构造器注入属性值 -->
     < bean   id = "helloWorld"   class = "com.atguigu.spring.helloworld.HelloWorld" >
         <!-- 要求: 在 Bean 中必须有对应的构造器.  -->
         < constructor-arg   value = "Mike" ></ constructor-arg >
     </ bean >

     <!-- 若一个 bean 有多个构造器, 如何通过构造器来为 bean 的属性赋值 -->
     <!-- 可以根据 index 和 value 进行更加精确的定位. (了解) -->
     < bean   id = "car"   class = "com.atguigu.spring.helloworld.Car" >
                                   <!-- 按索引匹配 index -->

         < constructor-arg   value = "KUGA"   index = "1" ></ constructor-arg >
         < constructor-arg   value = "ChangAnFord"   index = "0" ></ constructor-arg >
                                                <!-- 按类型匹配 type -->
         < constructor-arg   value = "250000"   type = "float" ></ constructor-arg >
     </ bean >

3.工厂方法注入(了解)(此处不做解释)

注入属性的细节

字面值
  • 字面值:可用字符串表示的值,可以通过 <value> 元素标签或 value 属性进行注入。
  • 基本数据类型及其封装类、String 等类型都可以采取字面值注入的方式
  • 若字面值中包含特殊字符,可以使用 <![CDATA[]]>把字面值包裹起来。
< bean   id = "car2"   class = "com.atguigu.spring.helloworld.Car" >
         < constructor-arg   value = "ChangAnMazda" ></ constructor-arg >
         <!-- 若字面值中包含特殊字符, 则可以使用 DCDATA 来进行赋值. (了解) -->
         < constructor-arg >
             < value ><![CDATA[ <ATARZA> ]]></ value >
         </ constructor-arg >
         < constructor-arg   value = "180"   type = "int" ></ constructor-arg >      </ bean > 
引用其他 Bean
  • 组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能. 要使 Bean 能够相互访问, 就必须在 Bean 配置文件中指定对 Bean 的引用
  • 在 Bean 的配置文件中, 可以通过<ref> 元素或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用.
  • 也可以在属性或构造器里包含 Bean 的声明, 这样的 Bean 称为内部 Bean
<!-- 配置 bean -->
     < bean   id = "dao5"   class = "com.atguigu.spring.ref.Dao" ></ bean >
     < bean   id = "service"   class = "com.atguigu.spring.ref.Service" >
         <!-- 通过 ref 属性值指定当前属性指向哪一个 bean!  因为dao5属性是一个bean类型,可以使用ref指向ioc容器中的其他bean -->
         < property   name = "dao"   ref = "dao5" ></ property >      </ bean >  
内部Bean
  • 当 Bean 实例仅仅给一个特定的属性使用时, 可以将其声明为内部 Bean. 内部 Bean 声明直接包含在 <property><constructor-arg>元素里, 不需要设置任何 id 或 name 属性
  • 内部 Bean 不能使用在任何其他地方
<!-- 声明使用内部 bean -->
     < bean   id = "service2"   class = "com.atguigu.spring.ref.Service" >
         < property   name = "dao" >
             <!-- 内部 bean, 类似于匿名内部类对象. 不能被外部的 bean 来引用, 也没有必要设置 id 属性 -->
             < bean   class = "com.atguigu.spring.ref.Dao" >
                 < property   name = "dataSource"   value = "c3p0" ></ property >
             </ bean >
         </ property >      </ bean > 
注入参数详解:null 值和级联属性
  • 可以使用专用的<null/>元素标签为 Bean 的字符串或其它对象类型的属性注入 null 值
  • 和 Struts、Hiberante 等框架一样,Spring 支持级联属性的配置。
< bean   id = "action"   class = "com.atguigu.spring.ref.Action" >
         < property   name = "service"   ref = "service2" ></ property >
         <!-- 设置级联属性(了解) -->
         < property   name = "service.dao.dataSource"   value = "DBCP2" ></ property >
     </ bean >

     < bean   id = "dao2"   class = "com.atguigu.spring.ref.Dao" >
         <!-- 为 Dao 的 dataSource 属性赋值为 null, 若某一个 bean 的属性值不是 null, 使用时需要为其设置为 null(了解) -->
         < property   name = "dataSource" >< null /></ property >      </ bean > 
集合属性
  • 在 Spring中可以通过一组内置的 xml 标签(例如:<list>,<set><map>) 来配置集合属性.
  • 配置 java.util.List 类型的属性, 需要指定 标签, 在标签里包含一些元素. 这些标签可以通过 <value> 指定简单的常量值, 通过<ref> 指定对其他 Bean 的引用. 通过<bean>指定内置 Bean 定义. 通过 <null/>指定空元素. 甚至可以内嵌其他集合.
  • 数组的定义和 List 一样, 都使用
  • 配置 java.util.Set 需要使用<set> 标签, 定义元素的方法与 List 一样.
  • Java.util.Map 通过 标签定义, 标签里可以使用多个 作为子标签. 每个条目包含一个键和一个值.
  • 必须在 标签里定义键
  • 因为键和值的类型没有限制, 所以可以自由地为它们指定 , , 或 元素.
  • 可以将 Map 的键和值作为 的属性定义: 简单常量使用 key 和 value 来定义; Bean 引用通过 key-ref 和 value-ref 属性定义
  • 使用 定义 java.util.Properties, 该标签使用多个 作为子标签. 每个 标签必须定义 key 属性.
<!-- 装配集合属性 -->
     < bean   id = "user"   class = "com.atguigu.spring.helloworld.User" >
         < property   name = "userName"   value = "Jack" ></ property >
         < property   name = "cars" >
             <!-- 使用 list 元素来装配集合属性 -->
             < list >
                 < ref   bean = "car" />
                 < ref   bean = "car2" />
             </ list >
         </ property >
     </ bean >

使用 utility scheme 定义集合
  • 使用基本的集合标签定义集合时, 不能将集合作为独立的 Bean 定义, 导致其他 Bean 无法引用该集合, 所以无法在不同 Bean 之间共享集合.
  • 可以使用 util schema 里的集合标签定义独立的集合 Bean. 需要注意的是, 必须在 根元素里添加 util schema 定义
<!-- 声明集合类型的 bean -->
     < util:list   id = "cars" >
         < ref   bean = "car" />
         < ref   bean = "car2" />
     </ util:list >

     < bean   id = "user2"   class = "com.atguigu.spring.helloworld.User" >
         < property   name = "userName"   value = "Rose" ></ property >
         <!-- 引用外部声明的 list -->
         < property   name = "cars"   ref = "cars" ></ property >      </ bean > 
使用 p 命名空间
  • 为了简化 XML 文件的配置,越来越多的 XML 文件采用属性而非子元素配置信息。
  • Spring 从 2.5 版本开始引入了一个新的 p 命名空间,可以通过 元素属性的方式配置 Bean 的属性。
  • 使用 p 命名空间后,基于 XML 的配置方式将进一步简化
< bean   id = "user3"   class = "com.atguigu.spring.helloworld.User"
         p:cars-ref = "cars"   p:userName = "Titannic" ></ bean >           

自动封装

  • Spring IOC 容器可以自动装配 Bean. 需要做的仅仅是在 的 autowire 属性里指定自动装配的模式
  • byType(根据类型自动装配): 若 IOC 容器中有多个与目标 Bean 类型一致的 Bean. 在这种情况下, Spring 将无法判定哪个 Bean 最合适该属性, 所以不能执行自动装配.
  • byName(根据名称自动装配): 必须将目标 Bean 的名称和属性名设置的完全相同.
  • constructor(通过构造器自动装配): 当 Bean 中存在多个构造器时, 此种自动装配方式将会很复杂. 不推荐使用
  • 缺点:
  • 在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配 Bean 的所有属性. 然而, 若只希望装配个别属性时, autowire 属性就不够灵活了.
  • autowire 属性要么根据类型自动装配, 要么根据名称自动装配, 不能两者兼而有之.
  • 一般情况下,在实际的项目中很少使用自动装配功能,因为和自动装配功能所带来的好处比起来,明确清晰的配置文档更有说服力一些
<!-- 自动装配: 只声明 bean, 而把 bean 之间的关系交给 IOC 容器来完成 -->
     <!-- 
        byType: 根据类型进行自动装配. 但要求 IOC 容器中只有一个类型对应的 bean, 若有多个则无法完成自动装配.
        byName: 若属性名和某一个 bean 的 id 名一致, 即可完成自动装配. 若没有 id 一致的, 则无法完成自动装配
    -->
     <!-- 在使用 XML 配置时, 自动转配用的不多. 但在基于 注解 的配置时, 自动装配使用的较多.  -->
     < bean   id = "dao"   class = "com.atguigu.spring.ref.Dao" >
         < property   name = "dataSource"   value = "C3P0" ></ property >                       </ bean > 

bean之间的关系

1.继承

  • Spring 允许继承 bean 的配置, 被继承的 bean 称为父 bean. 继承这个父 Bean 的 Bean 称为子 Bean
  • 子 Bean 从父 Bean 中继承配置, 包括 Bean 的属性配置
  • 子 Bean 也可以覆盖从父 Bean 继承过来的配置
  • 父 Bean 可以作为配置模板, 也可以作为 Bean 实例. 若只想把父 Bean 作为模板, 可以设置 的abstract 属性为 true, 这样 Spring 将不会实例化这个 Bean
  • 并不是 元素里的所有属性都会被继承. 比如: autowire, abstract 等.
  • 也可以忽略父 Bean 的 class 属性, 让子 Bean 指定自己的类, 而共享相同的属性配置. 但此时 abstract 必须设为 true
<!-- bean 的配置能够继承吗 ? 使用 parent 来完成继承 -->    
< bean   id = "user4"   parent = "user"   p:userName = "Bob" ></ bean >
< bean   id = "user6"   parent = "user"   p:userName = "维多利亚" ></ bean > 

2.依赖

  • Spring 允许用户通过 depends-on 属性设定 Bean 前置依赖的Bean,前置依赖的 Bean 会在本 Bean 实例化之前创建好
  • 如果前置依赖于多个 Bean,则可以通过逗号,空格或的方式配置 Bean 的名称
< bean   id = "user5"  parent = "user"  p:userName = "Backham"   depends-on = "user6" ></ bean > 

bean的作用域

  • 在 Spring 中, 可以在 元素的 scope 属性里设置 Bean 的作用域.
  • 默认情况下, Spring 只为每个在 IOC 容器里声明的 Bean 创建唯一一个实例, 整个 IOC 容器范围内都能共享该实例:所有后续的 getBean() 调用和 Bean 引用都将返回这个唯一的 Bean 实例.该作用域被称为 singleton, 它是所有 Bean 的默认作用域.
类型说明
singleton在SpringIOC容器中仅存在一个Bean实例,Bean以单例的方式存在
prototype每次调用getBean()时都会返回一个新的实例
request每次HTTP请求都会创建一个新的Bean,该作用域仅适用于WebApplicationContext环境
session同一个HTTP session共享一个Bean,不同的HTTP session使用不同的Bean,该作用域仅适用于WebApplicationContext环境

1.singleton(单例)

<!-- 默认情况下 bean 是单例的! -->
     <!-- 但有的时候, bean 就不能使单例的. 例如: Struts2 的 Action 就不是单例的! 可以通过 scope 属性来指定 bean 的作用域 -->
     <!-- 
        prototype: 原型的. 每次调用 getBean 方法都会返回一个新的 bean. 且在第一次调用 getBean 方法时才创建实例
        singleton: 单例的. 每次调用 getBean 方法都会返回同一个 bean. 且在 IOC 容器初始化时即创建 bean 的实例. 默认值
    -->
     < bean   id = "dao2"   class = "com.atguigu.spring.ref.Dao"   scope = "prototype" ></ bean >

     < bean   id = "service"   class = "com.atguigu.spring.ref.Service"   autowire = "byName" ></ bean >
          < bean   id = "action"   class = "com.atguigu.spring.ref.Action"   autowire = "byType" ></ bean > 

2.prototype(原型)

3.WEB 环境作用域(request、session)

使用外部属性文件(重点)

  • 在配置文件里配置 Bean 时, 有时需要在 Bean 的配置里混入系统部署的细节信息(例如: 文件路径, 数据源配置信息等). 而这些部署细节实际上需要和 Bean 配置相分离
  • Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器, 这个处理器允许用户将 Bean 配置的部分内容外移到属性文件中. 可以在 Bean 配置文件里使用形式为 ${var} 的变量, PropertyPlaceholderConfigurer 从属性文件里加载属性, 并使用这些属性来替换变量.
  • Spring 还允许在属性文件中使用 ${propName},以实现属性之间的相互引用。
    <!-- 导入外部的资源文件 -->
     < context:property-placeholder   location = "classpath:db.properties" />

     <!-- 配置数据源 -->
     < bean   id = "dataSource"   class = "com.mchange.v2.c3p0.ComboPooledDataSource" >
         < property   name = "user"   value = "${jdbc.user}" ></ property >
         < property   name = "password"   value = "${jdbc.password}" ></ property >
         < property   name = "driverClass"   value = "${jdbc.driverClass}" ></ property >
         < property   name = "jdbcUrl"   value = "${jdbc.jdbcUrl}" ></ property >

         < property   name = "initialPoolSize"   value = "${jdbc.initPoolSize}" ></ property >
         < property   name = "maxPoolSize"   value = "${jdbc.maxPoolSize}" ></ property >      </ bean > 

SpEL

Spring 表达式语言(简称SpEL):是一个支持运行时查询和操作对象图的强大的表达式语言。

  • 语法类似于 EL:SpEL 使用 #{…} 作为定界符,所有在大框号中的字符都将被认为是 SpEL
  • SpEL 为 bean 的属性进行动态赋值提供了便利
  • 通过 SpEL 可以实现:
    1. 通过 bean 的 id 对 bean 进行引用
    2. 调用方法以及引用对象中的属性
    3. 计算表达式的值
    4. 正则表达式的匹配
SpEL:字面量
  • 字面量的表示:
    1. 整数:<property name="count" value="#{5}"/>
    2. 小数:<property name="frequency" value="#{89.7}"/>
    3. 科学计数法:<property name="capacity" value="#{1e4}"/>
    4. String可以使用单引号或者双引号作为字符串的定界符号:<property name=“name” value="#{'Chuck'}"/><property name='name' value='#{"Chuck"}'/>
    5. Boolean:<property name="enabled" value="#{false}"/>
SpEL:引用 Bean、属性和方法
  • 引用其他对象:#{teacher}
  • 引用其他对象的属性:#{teacher.name}
  • 调用其他方法,还可以链式操作#{teacher.toString().toUpperCase()}
SpEL支持的运算符号
  • 算数运算符:+,-,*,/,%,^;
  • 加号还可以用作字符串连接
  • 比较运算符:<,>,=,<=,>=,lt,gt,eq,le,ge
  • 逻辑运算符:and,or,not,|
  • if-else运算符:?:(ternary),?:(Elvis)
  • 正则表达式:mathes
  • 调用静态方法或静态属性:通过T()调用一个类的静态方法,它将返回一个Class Object,然后再调用响应的方法和属性:#{T(java,lang,Math).PI}


<!-- 测试 SpEL: 可以为属性进行动态的赋值(了解) -->
     < bean   id = "girl"   class = "com.atguigu.spring.helloworld.User" >
         < property   name = "userName"   value = "周迅" ></ property >
     </ bean >

     < bean   id = "boy"   class = "com.atguigu.spring.helloworld.User"   init-method = "init"   destroy-method = "destroy" >
         < property   name = "userName"   value = "高胜远" ></ property >
         < property   name = "wifeName"   value = "#{girl.userName}" ></ property >      </ bean > 

IOC容器中Bean的生命周期

IOC 容器中 Bean 的生命周期方法
  • Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务.
  • Spring IOC 容器对 Bean 的生命周期进行管理的过程:
    1. 通过构造器或工厂方法创建 Bean 实例
    2. 为 Bean 的属性设置值和对其他 Bean 的引用
    3. 调用 Bean 的初始化方法
    4. Bean 可以使用了
    5. 当容器关闭时, 调用 Bean 的销毁方法
  • 在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法.
创建 Bean 后置处理器
  • Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.
  • Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例. 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.
  • 对Bean 后置处理器而言, 需要实现 接口. 在初始化方法被调用前后, Spring 将把每个 Bean 实例分别传递给上述接口的以下两个方法:
<!-- 配置 bean 后置处理器: 不需要配置 id 属性, IOC 容器会识别到他是一个 bean 后置处理器, 并调用其方法 -->      < bean   class = "com.atguigu.spring.ref.MyBeanPostProcessor" ></ bean > 
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import com.atguigu.spring.helloworld.User;
public class MyBeanPostProcessor implements BeanPostProcessor {
//该方法在 init 方法之后被调用
@Override
public Object postProcessAfterInitialization(Object arg0, String arg1)
throws BeansException {
if(arg1.equals("boy")){
System.out.println("postProcessAfterInitialization..." + arg0 + "," + arg1);
User user = (User) arg0;
user.setUserName("李大齐");
}
return arg0;
}


//该方法在 init 方法之前被调用
//可以工作返回的对象来决定最终返回给 getBean 方法的对象是哪一个, 属性值是什么
/**
* @param arg0: 实际要返回的对象
* @param arg1: bean 的 id 值
*/
@Override
public Object postProcessBeforeInitialization(Object arg0, String arg1)
throws BeansException {
if(arg1.equals("boy"))
System.out.println("postProcessBeforeInitialization..." + arg0 + "," + arg1);
return arg0;
}


}

Spring IOC 容器对 Bean 的生命周期进行管理的过程:
通过构造器或工厂方法创建 Bean 实例
为 Bean 的属性设置值和对其他 Bean 的引用
将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法
调用 Bean 的初始化方法
将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization方法
Bean 可以使用了
当容器关闭时, 调用 Bean 的销毁方法

Spring 4.X 新特性:泛型依赖注入

Logo

权威|前沿|技术|干货|国内首个API全生命周期开发者社区

更多推荐