Spring Bean教程

目录:



配置形式

基于XML文件的形式

id:Bean 的名称。
在 IOC 容器中必须是唯一的
若 id 没有指定,Spring 自动将权限定性类名作为 Bean 的名字
id 可以指定多个名字,名字之间可用逗号、分号、或空格分隔

<!-- 配置一个 bean -->
    <bean id="helloWorld" class="com.spring.helloworld.HelloWorld">
        <!-- 为属性赋值 -->
        <property name="user" value="Jerry"></property>
    </bean>

基于注解的方式

组件扫描(component scanning):Spring能够从classpath下自动扫描,侦测和实例化具有特定注解的组件。
特定的组件包括:

  • @Component:基于注解,标识了一个受Spring管理的组件;
  • @Resposity:标识持久层组件;
  • @Service:标识服务层(业务层)组件;
  • @Controller:标识表现层组件;

  • @Autowired默认按类型匹配注入Bean;
  • @Resource按名称匹配注入Bean;
  • @Inject和@Autowired一样按类型注入Bean的,只不过他没有required属性。

Spring通过@Autowired注解实现Bean的依赖注入
1.首先通过注解的方式创建bean

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component 
@Scope("prototype") //多态的Bean
public class Student {

}
@Scope(“prototype”)   
@Lazy(true)   
@Component(“userDao”)   
public class UserDao {   
    ……   
    // 用于设置初始化方法   
    @PostConstruct  
    public void myInit() {   

    }   

    // 用于设置销毁方法   
    @PreDestroy  
    public void myDestroy() {   
    }   
}

2.通过@Autowire注入

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

public class Use {

    @Autowired
    @Qualifier("car")
    private Car car;

    @Resource
    private  UserDao userDao; 
    ....
    public String toString(){
        return car.toString();
    }

}

基于java配置的形式

<context:component-scan>除了知道如何自动注册那些使用某种构造型(stereotype)的注解所标注的Bean,它也会自动加载使用 @Configuration注解所标注的类。在上面的配置中,base-package属性告知Spring在哪个包内查找使用@Configuration注解所标注的所有类。

<?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-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:component-scan
base-package="包名 " />
</beans>
@Configuration  
public class SpringIOConf {   
    @Scope(“prototype”)   
    @Bean(“loginUserDao”)   
    public Car getCarInstance() {   
        return new Car();   
    }   
    @Bean
    public Bus getBusInstance() {
        return new Bus();
    }
}

获取Bean实例的方式

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

Spring 提供了两种类型的 IOC 容器实现(获取bean).

  • BeanFactory: IOC 容器的基本实现.
  • ApplicationContext: 提供了更多的高级特性. 是 BeanFactory 的子接口.
    BeanFactory 是 Spring 框架的基础设施,面向 Spring 本身;ApplicationContext 面向使用 Spring 框架的开发者,几乎所有的应用场合都直接使用 ApplicationContext 而非底层的 BeanFactory
    无论使用何种方式, 配置文件时相同的.

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

public static void main(String[] args) {  
       //实例化BeanFactory  
    BeanFactory factory = new BeanFactory();  
    //调用初始化方法,传入xml路径  
    factory.init("spring.xml");  
    //通过bean id 获取对象  
    Car car = (CourseService) factory.getBean("car");  
    System.out.print(car);   
}  

ApplicationContext

ApplicationContext 的主要实现类:
  • ClassPathXmlApplicationContext:
    从类路径下加载配置文件
  • FileSystemXmlApplicationContext:
    从文件系统中加载配置文件
    ConfigurableApplicationContext 扩展于 ApplicationContext,新增加两个主要方法:refresh() 和 close(), 让 ApplicationContext 具有启动、刷新和关闭上下文的能力
    ApplicationContext 在初始化上下文时就实例化所有单例的 Bean。
  • WebApplicationContext 是专门为 WEB 应用而准备的,它允许从相对于 WEB 根目录的路径中完成初始化工作
    这里写图片描述

从 IOC 容器中获取 Bean
调用 ApplicationContext 的 getBean() 方法
这里写图片描述

依赖注入的方式

Spring 支持 3 种依赖注入的方式

  • 属性注入
  • 构造器注入
  • 工厂方法注入(很少使用,不推荐)

属性注入

  • 属性注入即通过 setter 方法注入Bean 的属性值或依赖的对象
  • 属性注入使用 元素, 使用 name 属性指定 Bean 的属性名称,value 属性或 子节点指定属性值
  • 属性注入是实际应用中最常用的注入方式
<!-- 配置一个 bean -->
    <bean id="helloWorld2" class="com.spring.helloworld.HelloWorld">
        <!-- 为属性赋值 -->
        <!-- 通过属性注入: 通过 setter 方法注入属性值 -->
        <property name="user" value="Tom"></property>
    </bean>

构造器注入

  • 按索引匹配入参
<bean id="car" class="com.spring.helloworld.Car">
        <constructor-arg value="KUGA" index="0"></constructor-arg>
        <constructor-arg value="ChangAnFord" index="1"></constructor-arg>
        <constructor-arg value="250000" index="2"></constructor-arg>
    </bean>
  • 按类型匹配入参
<bean id="car" class="com.spring.helloworld.Car">
        <constructor-arg value="KUGA" type="java.util.String"></constructor-arg>
        <constructor-arg value="ChangAnFord" type="string"></constructor-arg>
        <constructor-arg value="250000" type="float"></constructor-arg>
    </bean>

注入细节讲解

  • 字面值:可用字符串表示的值,可以通过 <value>元素标签或 value 属性进行注入。
  • 基本数据类型及其封装类、String 等类型都可以采取字面值注入的方式
  • 若字面值中包含特殊字符,可以使用 <![CDATA[]]>把字面值包裹起来。
<!-- 通过构造器注入属性值 -->
    <bean id="helloWorld" class="com.spring.helloworld.HelloWorld">
        <!-- 要求: 在 Bean 中必须有对应的构造器.  -->
        <constructor-arg value="Mike"></constructor-arg>
    </bean>

    <!-- 若一个 bean 有多个构造器, 如何通过构造器来为 bean 的属性赋值 -->
    <!-- 可以根据 index 和 value 进行更加精确的定位. (了解) -->
    <bean id="car" class="com.spring.helloworld.Car">
        <constructor-arg value="KUGA" index="1"></constructor-arg>
        <constructor-arg value="ChangAnFord" index="0"></constructor-arg>
        <constructor-arg value="250000" type="float"></constructor-arg>
    </bean>
    <bean id="car2" class="com.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.spring.ref.Dao"></bean>

    <bean id="service" class="com.spring.ref.Service">
        <!-- 通过 ref 属性值指定当前属性指向哪一个 bean! -->
        <property name="dao" ref="dao5"></property>
    </bean>
    <bean id="action" class="com.spring.ref.Action">
        <property name="service" ref="service2"></property>
        <!-- 设置级联属性(了解) -->
        <property name="service.dao.dataSource" value="DBCP2"></property>
    </bean>

内部 Bean

  • 当 Bean 实例仅仅给一个特定的属性使用时, 可以将其声明为内部 Bean. 内部 Bean 声明直接包含在 或 元素里, 不需要设置任何 id 或 name 属性
  • 内部 Bean 不能使用在任何其他地方
<!-- 声明使用内部 bean -->
    <bean id="service2" class="com.spring.ref.Service">
        <property name="dao">
            <!-- 内部 bean, 类似于匿名内部类对象. 不能被外部的 bean 来引用, 也没有必要设置 id 属性 -->
            <bean class="com.spring.ref.Dao">
                <property name="dataSource" value="c3p0"></property>
            </bean>
        </property>
    </bean>

注入参数详解:null 值和级联属性

  • 可以使用专用的 <null/> 元素标签为 Bean 的字符串或其它对象类型的属性注入 null 值
  • 和 Struts、Hiberante 等框架一样,Spring 支持级联属性的配置。
<bean id="dao2" class="com.spring.ref.Dao">
        <!-- 为 Dao 的 dataSource 属性赋值为 null, 若某一个 bean 的属性值不是 null, 使用时需要为其设置为 null(了解) -->
        <property name="dataSource"><null/></property>
    </bean>

集合属性

  • 在 Spring中可以通过一组内置的 xml 标签(例如: <list>, <set> 或 <map>) 来配置集合属性.
  • 配置 java.util.List 类型的属性, 需要指定 <list> 标签, 在标签里包含一些元素. 这些标签可以通过 <value>指定简单的常量值, 通过 <ref>指定对其他 Bean 的引用. 通过<bean>指定内置 Bean 定义. 通过 <null/>指定空元素. 甚至可以内嵌其他集合.
  • 数组的定义和 List 一样, 都使用 <list>
  • 配置 java.util.Set 需要使用 <set>标签, 定义元素的方法与 List 一样.

  • Java.util.Map 通过<map>标签定义, <map>标签里可以使用多个 <entry>作为子标签. 每个条目包含一个键和一个值.

  • 必须在 <key> 标签里定义键
  • 因为键和值的类型没有限制, 所以可以自由地为它们指定 <value> ,<ref>, <bean> 或 <null> 元素.
  • 可以将 Map 的键和值作为<entry> 的属性定义: 简单常量使用 key 和 value 来定义; Bean 引用通过 key-ref 和 value-ref 属性定义
  • 使用 <props>定义 java.util.Properties, 该标签使用多个 <prop> 作为子标签. 每个<prop>标签必须定义 key 属性.
<!-- 装配集合属性 -->
    <bean id="user" class="com.spring.helloworld.User">
        <property name="userName" value="Jack"></property>
        <property name="cars">
            <!-- 使用 list 元素来装配集合属性 -->
            <list>
                <ref bean="car"/>
                <ref bean="car2"/>
            </list>
        </property>
    </bean>

    <!-- 声明集合类型的 bean -->
    <util:list id="cars">
        <ref bean="car"/>
        <ref bean="car2"/>
    </util:list>

    <bean id="user2" class="com.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>元素属性的方式配置 Bean 的属性。
  • 使用 p 命名空间后,基于 XML 的配置方式将进一步简化
<bean id="user3" class="com.spring.helloworld.User"
        p:cars-ref="cars" p:userName="Titannic"></bean>

bean 之间的关系:

继承

  • 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 id="user" class="com.spring.helloworld.User">
        <property name="userName" value="Jack"></property>
        <property name="cars">
            <!-- 使用 list 元素来装配集合属性 -->
            <list>
                <ref bean="car"/>
                <ref bean="car2"/>
            </list>
        </property>
    </bean>
<!-- bean 之间使用 parent 来完成继承 --> 
    <bean id="user4" parent="user" p:userName="Bob"></bean>

    <bean id="user6" parent="user" p:userName="维多利亚"></bean>

依赖

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

关联

<!--  
        在 IOC 容器中配置 bean 之间的关联关系
    -->
    <bean id="userDao"
        class="com.spring.ref.UserDao"></bean>

    <bean id="userService"
        class="com.spring.ref.UserService">
        <property name="userDao" ref="userDao"></property>  
    </bean>

    <bean id="userAction" 
        class="com.spring.ref.UserAction">
        <property name="userService" ref="userService"></property>
    </bean>

bean 的作用域:singleton、prototype

  • 在 Spring 中, 可以在 元素的 scope 属性里设置 Bean 的作用域.
  • 默认情况下, Spring 只为每个在 IOC 容器里声明的 Bean 创建唯一一个实例, 整个 IOC 容器范围内都能共享该实例:所有后续的 getBean() 调用和 Bean 引用都将返回这个唯一的 Bean 实例.该作用域被称为 singleton, 它是所有 Bean 的默认作用域.
    这里写图片描述
    <!--  
        1. 默认情况下, IOC 容器中的 bean 是单例的! 若对象是单例的, 则在创建 IOC 容器时即创建 bean 的实例, 并对 bean 的属性进行初始化. 
        2. 可以通过 bean 的 scope 属性来修改 bean 的作用域. 若取值为 prototype, 则 bean 为原型的: 每次向容器获取实例, 得到的都是一个新的对象.
        而且, 不在创建 IOC 容器时创建 bean 的实例了. 
        3. IOC 容器中 bean 的生命周期: 
        3.1 一般地, 讨论 bean 的生命周期, 是建立在 bean 是单例的基础上的. 
        3.2 可以为 bean 指定 init 和 destroy 方法
        3.3 还可以通过 bean 的后置处理器来更加丰富 bean 的生命周期方法(面试时.).
    -->
    <bean id="helloWorld" 
        class="com.spring.helloworld.HelloWorld" 
        scope="singleton"
        init-method="init"
        destroy-method="destroy">
        <property name="userName" value="atguigu"></property>
    </bean>

http://blog.csdn.net/z3881006/article/details/53932779

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值