Spring bean 自动装配、抽象、作用域、依赖、继承、使用

XML 配置里的 Bean 自动装配

Spring IOC容器可以自动装配Bean，通过 <bean> 的 autowire 属性里指定自动装配的模式

1）byName: 根据名字自动装配

2）byType: 根据类型自动装配

// person 
public class Person {
    private String name;
    private Car car;
    private Address address;
    public void setName(String name) {
        this.name = name;
    }
    public void setCar(Car car) {
        this.car = car;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    public String getName(){
        return name;
    }
    public Car getCar() {
        return car;
    }
    public Address getAddress() {
        return address;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", car=" + car +
                ", address=" + address +
                '}';
    }
}

// Address
public class Address {
    private String city;
    private String street;
    public void setCity(String city) {
        this.city = city;
    }
    public void setStreet(String street){
        this.street = street;
    }
    public String getCity() {
        return city;
    }
    public String getStreet() {
        return street;
    }
    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                ", street='" + street + '\'' +
                '}';
    }
}

// Car
public class Car {
    private String brand;
    private double price;
    public String getBrand(){
        return brand;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }
}

// 使用autowire属性指定自动装配的方式
// 1.byName根据bean的名字和当前bean的sette风格的属性名进行自动装配，若有装配的，则进行自动装配，若没有匹配的，则不装配
<bean id="address" class="com.sangyu.test01.Address" p:city="beijing" p:street="hh"></bean>

<bean id="car" class="com.sangyu.test01.Car"  p:brand="Audi" p:price="300000"></bean>

<bean id="person" class="com.sangyu.test01.Person" p:name="Tom" autowire="byName"></bean>

// 根据bean的类型和当前bean的属性的类型进行自动匹配
<bean id="address" class="com.sangyu.test01.Address" p:city="beijing" p:street="hh"></bean>
<bean id="car" class="com.sangyu.test01.Car"  p:brand="Audi" p:price="300000"></bean>
<bean id="person" class="com.sangyu.test01.Person" p:name="Tom" autowire="byType"></bean>

// 按照类型匹配要求类型必须是唯一，如果有两个相同类型类型会有异常
<bean id="address" class="com.sangyu.test01.Address" p:city="beijing" p:street="hh"></bean>
//<bean id="address2" class="com.sangyu.test01.Address"  p:city="beijing" p:street="hh"></bean> //如果有两个相同类型类型会有异常
<bean id="car" class="com.sangyu.test01.Car"  p:brand="Audi" p:price="300000"></bean>
<bean id="person" class="com.sangyu.test01.Person" p:name="Tom" autowire="byType"></bean>

// Main
public class Main {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person Person = (Person)ctx.getBean("person");
        System.out.println(Person);
    }
}

自动装配的缺点

1）在 Bean 配置文件里设置 autowire 属性进行自动装配将会配置 Bean 的所有属性。然后，若只希望装配个别属性时，autowire 属性就不够灵活了

2）要么根据类型自动匹配，要么根据名称自动装配，不能两者都有

bean 之间的关系：继承和依赖

1）Spring 允许继承 bean 的配置，被继承的 bean 称为父 bean，继承的 Bean 称为子 Bean，

2）子 Bean 继承父 Bean 中的配置，包括 Bean 的属性配置

3）子 Bean 可以覆盖从父 Bean 继承过来的配置

4）父 Bean 可以作为配置模版，也可以作为 Bean 实例，若只想把父 Bean 作为模版，可以设置 <bean> 的 abstact 属性为 true，这样 spring 将不会实例化这个
Bean

5）并不是 <bean> 元素里的所有都会被继承，如：autowire，abstract等

6）可以忽略父 Bean 的 class 属性，让子 Bean 指定自己的类，而共享相同的属性配置，但此时 abstract 必须设为 true

// 继承
<bean id="address" class="com.sangyu.test01.Address" p:city="Beijing" p:street="wudaokou"></bean>
<bean id="address2" parent="address"></bean>

// 覆盖
<bean id="address" class="com.sangyu.test01.Address" p:city="Beijing" p:street="wudaokou"></bean>
<bean id="address2" p:city="Shanghai" p:street="Dazhongsi" parent="address"></bean>

抽象Bean

// bean设置为抽象，抽象的bean只能继承不能实例化
<bean id="address" class="com.sangyu.test01.Address" p:city="Beijing" p:street="WuDaoKou" abstract="true"></bean>
<bean id="address2" class="com.sangyu.test01.Address" p:street="DaZhongSi" parent="address"></bean>

依赖 Bean

1. Spring 管理的 bean 都是单例模式(singleton)

2. 实例化对象应该顺序化的，比如 A 依赖 B ,B 依赖 C,C 依赖 D...

3. 一个 bean 可以依赖多个 bean，可以通过逗号(",")或者分号(";")来定义多个依赖对象：

<bean id="address" class="com.sangyu.test01.Address" p:city="Beijing" p:street="1111"></bean>
<bean id="person" class="com.sangyu.test01.Person" p:name="111" p:address-ref="address" depends-on="address"></bean>

bean 作用域

1. 通过 scope 属性设置 Bean 的作用域

2. 默认情况下，Spring 管理的 bean 都是单例模式

属性值	说明
singleton	单例的方式
prototype	每次调用getBean()都会返回一个新的实例
request	每次HTTP请求都会创建一个新的Bean，该作用域仅适用于WebApplicationContext环境
session	同一个HTTP Session共享一个Bean，不同的HTTP Session使用不同的Bean。该作用域仅适用于WebApplicationContext环境

// 设置为singleton 模式
<bean id="address" class="com.sangyu.test01.Address" p:city="Beijing" p:street="1111" scope="singleton"></bean>

// 设置为prototype 模式
<bean id="address" class="com.sangyu.test01.Address" p:city="Beijing" p:street="1111" scope="prototype"></bean> 

使用外部属性文件

PropertyPlaceholderConfigurer 会从指定的 location 属性文件里加载属性，并使用这些属性来替换变量${var}

<context:property-placeholder location="classpath*:db.properties"></context:property-placeholder>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="user" value="${user}"></property>
    <property name="password" value="${password}"></property>
    <property name="driverClass" value="${driverClass}"></property>
    <property name="jdbcUrl" value="${jdbcUrl}"></property>
</bean>

// db.properties
user = root
password = 1230
driverClass = com.mysql.jdbc.Driver
jdbcUrl = jdbc:mysql:///test`