3.spring：自动装配/Bean之间的关系/作用域/外部文件/spel/

1.自动装配/手动装配

xml配置文件里的bean自动装配
Spring IOC 容器里可以自动的装配Bean，需要做的仅仅是在<bean>的autowire属性里面指定自动装配模式
->byType（根据类型自动进行装配）：若IOC容器里需要有多个与目标Bean类型一样的Bean，在这种情况子下，Spring无法判定那个Bean合适，所以不能执行自动装配
->byName(根据名称自动装配)：必须将目标Bean的名称和属性名设置完全相同，
->constuuctor（通过是构造器自动装配）：当bean中存在多个构造器时，这个方法将会复杂，不建议使用
一般情况下很少进行使用这个属性

Car.java

public class Car {
    private String brand;
    private int price;
　　//...
}

Person .java

public class Person {
    private String name;
    private Address address;
    private Car car;
　　//...
}

Address .java

public class Address {
    private String city;
    private String street;
　　//...
}

applicationContext.xml

<!-- 自动装配 -->
<bean id="address" class="com.MrChengs3.autowire.Address" p:city="BeiJing" p:street="sanqing_Street"></bean>
<bean id="car" class="com.MrChengs3.autowire.Car" p:brand="BMW" p:price="10000"></bean>
    <!-- 根据名字进行装配和setter方式类似    
        byName根据bean的setter风格进行装配，将address改为address1则不能自动进行，没有匹配的则不装配
        byType：假设我们配了两个address的变量，此时不唯一，不知道装配那个
     -->
    <bean id="person" class="com.MrChengs3.autowire.Person" p:name="MrChengs" 
    autowire="byType"></bean>
    
    <!-- 手动装配 -->
    <bean id="person" class="com.MrChengs3.autowire.Person" p:name="MrChengs" 
    p:car-ref="car" p:address-ref="address"></bean>

测试：

Person p = (Person) ctx.getBean("person");
System.out.println(p);

Person [name=MrChengs, address=Address [city=BeiJing, street=sanqing_Street],
 car=Car [brand=BMW, price=10000]]

2.Bean之间的关系

继承：

Spring允许继承bean之间的配置，被继承的bean称为父类bean，继承这个父bean的bean称为字bean
子bean从父类中继承配置，包括父类的属性配置
子bean也可以覆盖从父类继承过来的配置
父类可以作为模板，也可以作为bean实例，若相把父类的作为模板，可以设置父类bean的abstract属性为true，这样spring将不会实例化这个Bean
并不是bean元素里的属性都会被继承，比如autowire，abstract等
也可以忽略父bean的class属性，让子类指定子的类，面向共享的配置，但是此时abstract必须设为true

1、父bean是一个实例时。它本身是一个完整的bean

2、父bean是模板，抽象bean，不能被实例化，只是来被继承。

父bean一定不能实例化，因为它没有class属性，实例化会跑异常。那就一定要写abstract属性，让spring不实例化它。

当遇到一个类要实例化出很多相似的bean对象时，看起来是不是很不简洁。

applicationContext.xml

<bean id="address"   p:city="ShangHai" p:street="LaoRenJie" abstract="true"></bean>
<!-- 配置的继承，使用bean -->
<bean id="address1" class="com.MrChengs3.autowire.Address"   parent="address"></bean>

Address address1 = (Address) ctx.getBean("address1");

依赖：

Spring允许用户通过depend-on属性设置bean前置依赖关系，前置以来的bean会在本bean实例化之前创建好
如果依赖多个bean，则可以使用逗号，空格或的方式配置bean的名称

我们需要让某个属性必须存在，就像必填项一样。用depends-on 依赖

这样，依赖存在了，就可以正常实例化了

<bean id="car" class="com.MrChengs3.autowire.Car" p:brand="BMW" p:price="1234" ></bean>
<!-- 配置Person，并且必须有一个关联的car，就是说person这个bean依赖于car -->
<bean id="person" class="com.MrChengs3.autowire.Person" p:name="MrChengs" 
    p:address-ref="address1" depends-on="car"></bean>

3.bean的作用域

作用域：
singleton：单例，整个应用中只创建一个实例（默认）

prototype：原型，每次注入时都新建一个实例

session：会话，每个会话创建一个实例，在一个session会话中，是同一个bean，不同session就是不同bean

request：请求，每个请求创建一个实例，每一个HTTP请求生成一个新的bean

applicationContext.xml

<!-- bean的作用域 -->
<!-- 
    scope:bean的作用域
    singleton(默认值):在容器初始化的时候创建bean的实例，整个容器的生命周期里面仅仅只创建一个bean，单列的
    prototype:原型的，容器创建初始化时，不创建bean的实例，而每次请求时都会创建一个新的bean实例，并返回
 -->
<bean id="car" class="com.MrChengs3.autowire.Car" p:brand="Ford" 
p:price="4321" scope="singleton"></bean>

测试：

        Car car = (Car) ctx.getBean("car");
        Car car2 = (Car) ctx.getBean("car");
        System.out.println(car ==car2);

true

scope="prototype"则为false

4.使用外部文件

propertie.properties

user=root
password=1234
driverClass=com.mysql.jdbc.Driver
jdbcUrl=jdbc\:mysql\://localhost\:3307/shijian

applicationContext.xml

<!-- 使用外部的属性文件 -->
<!-- 需要导入context命名空间 -->
<context:property-placeholder location="classpath:propertie.properties"/>


<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- 使用外部话属性文件 -->
    <property name="username" value="${user}"></property>
    <property name="password" value="${password}"></property>
    <property name="driverClassName" value="${driverClass}"></property>
    <property name="url" value="${jdbcUrl}"></property>

</bean>

            DataSource dataSource = (DataSource) ctx.getBean("dataSource",DataSource.class);
            System.out.println("执行中");
            System.out.println(dataSource.getConnection());
            System.out.println("结束");

${},代表引用外部的变量

通过把配置信息独立到一个文件里面，bean用${}方式引用，便于维护、更清晰

如果响应修改只需要修改配置文件即可！

5.SpEl

SpEL---Spring Expression Language：

是一个支持运行时查询和操作对象图表达式语言、使用#{...}作为定界符，为bean属性动态赋值提供了便利。

1) 为属性赋值字面值

<bean id="address" class="com.MrChengs7.spel.Address">
    <!-- 为属性赋值字面值 -->
    <property name="city" value="#{'beijing'}"></property>
    <property name="street" value="Shangye"></property>
</bean>

        Address address= (Address) ctx.getBean("address");
        System.out.println(address);

Address [city=beijing, street=Shangye]

2)引用类的静态属性,用T()调用一个类的静态方法，它将返回一个Class Object，然后再调用相应的方法或属性

<bean id="car" class="com.MrChengs7.spel.Car">
    <property name="brand" value="Aodi"></property>
    <property name="price" value="12345"></property>
    <!-- 引用 类的静态属性 -->
    <property name="circle" value="#{T(java.lang.Math).PI * 80}"></property>
</bean>

        Car car = (Car) ctx.getBean("car");
        System.out.println(car);

Car [brand=Aodi, price=12345.0, circle=251.32741228718345]

3)其他

<bean id="person" class="com.MrChengs7.spel.Person">
    <!-- 引用其他的bean -->
    <property name="car" value="#{car}"></property>
    <!-- 其他bean的属性 -->
    <property name="city" value="#{address.city}"></property>
    <!-- 运算符的使用 -->
    <property name="info" value="#{car.price > 1000 ? '有钱' : '没钱'}"></property>
    <property name="name" value="MrChengs"></property>
</bean>

        Person p = (Person) ctx.getBean("person");
        System.out.println(p);

Person [name=MrChengs, car=Car [brand=Aodi, price=12345.0, circle=251.32741228718345], city=beijing, info=有钱]

等待还有很多其他的....

3.spring：自动装配/Bean之间的关系/作用域/外部文件/spel/

猜你喜欢