spring IOC根本应用

通过后面的介绍咱们曾经晓得了Spring中十分重要的一个个性就是IOC,上面咱们将要来看一下如何应用IOC容器，帮忙大家更好的领会spring的劣势。

1、spring_helloworld

(1)应用手动加载jar包的形式实现，分为三个步骤，当初简直不必

导包：导入这五个包即可
commons-logging-1.2.jar spring-beans-5.2.3.RELEASE.jar spring-context-5.2.3.RELEASE.jar spring-core-5.2.3.RELEASE.jar spring-expression-5.2.3.RELEASE.jar
写配置
Person.java
package com.mashibing.bean;

public class Person {
private int id;
private String name;
private int age;
private String gender;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getGender() {
return gender;
}

public void setGender(String gender) {
this.gender = gender;
}

@Override
public String toString() {
return "Person{" +
"id=" + id +
", name='" + name + ''' +
", age=" + age +
", gender='" + gender + ''' +
'}';
}
}
ioc.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.or...">



<bean id="person" class="com.mashibing.bean.Person">

<property name="id" value="1"></property>
<property name="name" value="zhangsan"></property>
<property name="age" value="18"></property>
<property name="gender" value="男"></property>
</bean>
</beans>
测试

SpringDemoTest.java

package com.mashibing.test;

import com.mashibing.bean.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDemoTest {
public static void main(String[] args) {
//ApplicationContext:示意ioc容器
//ClassPathXmlApplicationContext:示意从以后classpath门路中获取xml文件的配置
//依据spring的配置文件来获取ioc容器对象
ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");
Person person = (Person) context.getBean("person");
System.out.println(person);
}
}

(2)应用maven的形式来构建我的项目

创立maven我的项目
定义我的项目的groupId、artifactId
增加对应的pom依赖
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/m...">
<modelVersion>4.0.0</modelVersion>

<groupId>com.mashibing</groupId>
<artifactId>spring_demo</artifactId>
<version>1.0-SNAPSHOT</version>

<dependencies>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
</dependencies>
</project>
编写代码
Person.java
package com.mashibing.bean;
public class Person {
private int id;
private String name;
private int age;
private String gender;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getGender() {
return gender;
}

public void setGender(String gender) {
this.gender = gender;
}

@Override
public String toString() {
return "Person{" +
"id=" + id +
", name='" + name + ''' +
", age=" + age +
", gender='" + gender + ''' +
'}';
}
}
测试
MyTest.java

import com.mashibing.bean.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");
Person person = (Person) context.getBean("person");
System.out.println(person);
}
}

总结：

以上两种形式创立spring的我的项目都是能够的，然而在当初的企业开发环境中应用更多的还是maven这样的形式，毋庸本人解决jar之间的依赖关系，也毋庸提前下载jar包，只须要配置相干的pom即可，因而举荐大家应用maven的形式，具体的maven操作大家能够看maven的具体操作文档。

搭建spring我的项目须要留神的点：

1、肯定要将配置文件增加到类门路中，应用idea创立我的项目的时候要放在resource目录下

2、导包的时候别忘了commons-logging-1.2.jar包

细节点：

1、ApplicationContext就是IOC容器的接口，能够通过此对象获取容器中创立的对象

2、对象在Spring容器创立实现的时候就曾经创立实现，不是须要用的时候才创立

3、对象在IOC容器中存储的时候都是单例的，如果须要多例须要批改属性

4、创建对象给属性赋值的时候是通过setter办法实现的

5、对象的属性是由setter/getter办法决定的，而不是定义的成员属性

2、spring对象的获取及属性赋值形式

1、通过bean的id获取IOC容器中的对象（下面曾经用过）

2、通过bean的类型获取对象

MyTest.java

import com.mashibing.bean.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");
Person bean = context.getBean(Person.class);
System.out.println(bean);
}
}

留神：通过bean的类型在查找对象的时候，在配置文件中不能存在两个类型统一的bean对象，如果有的话，能够通过如下办法

MyTest.java

import com.mashibing.bean.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");
Person person = context.getBean("person", Person.class);
System.out.println(person);
}
}

3、通过结构器给bean对象赋值

ioc.xml

<!--给person类增加构造方法--><bean id="person2" class="com.mashibing.bean.Person">    <constructor-arg name="id" value="1"></constructor-arg>    <constructor-arg name="name" value="lisi"></constructor-arg>    <constructor-arg name="age" value="20"></constructor-arg>    <constructor-arg name="gender" value="女"></constructor-arg></bean><!--在应用结构器赋值的时候能够省略name属性，然而此时就要求必须严格依照结构器参数的程序来填写了--><bean id="person3" class="com.mashibing.bean.Person">    <constructor-arg value="1"></constructor-arg>    <constructor-arg value="lisi"></constructor-arg>    <constructor-arg value="20"></constructor-arg>    <constructor-arg value="女"></constructor-arg></bean><!--如果想不依照程序来增加参数值，那么能够搭配index属性来应用--><bean id="person4" class="com.mashibing.bean.Person">    <constructor-arg value="lisi" index="1"></constructor-arg>    <constructor-arg value="1" index="0"></constructor-arg>    <constructor-arg value="女" index="3"></constructor-arg>    <constructor-arg value="20" index="2"></constructor-arg></bean><!--当有多个参数个数雷同，不同类型的结构器的时候，能够通过type来强制类型-->将person的age类型设置为Integer类型public Person(int id, String name, Integer age) {    this.id = id;    this.name = name;    this.age = age;    System.out.println("Age");}public Person(int id, String name, String gender) {    this.id = id;    this.name = name;    this.gender = gender;    System.out.println("gender");}<bean id="person5" class="com.mashibing.bean.Person">    <constructor-arg value="1"></constructor-arg>    <constructor-arg value="lisi"></constructor-arg>    <constructor-arg value="20" type="java.lang.Integer"></constructor-arg></bean><!--如果不批改为integer类型，那么须要type跟index组合应用--> <bean id="person5" class="com.mashibing.bean.Person">    <constructor-arg value="1"></constructor-arg>    <constructor-arg value="lisi"></constructor-arg>    <constructor-arg value="20" type="int" index="2"></constructor-arg></bean>

4、通过命名空间为bean赋值，简化配置文件中属性申明的写法

1、导入命名空间

2、增加配置

5、为简单类型进行赋值操作

在之前的测试代码中，咱们都是给最根本的属性进行赋值操作，在失常的企业级开发中还会遇到给各种简单类型赋值，如汇合、数组、其余对象等。

Person.java

package com.mashibing.bean;

import java.util.*;

public class Person {
private int id;
private String name="dahuang";
private int age;
private String gender;
private Address address;
private String[] hobbies;
private List<Book> books;
private Set<Integer> sets;
private Map<String,Object> maps;
private Properties properties;

public Person(int id, String name, int age, String gender) {
this.id = id;
this.name = name;
this.age = age;
this.gender = gender;
System.out.println("有参结构器");
}

public Person(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
System.out.println("Age");
}

public Person(int id, String name, String gender) {
this.id = id;
this.name = name;
this.gender = gender;
System.out.println("gender");
}

public Person() {
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getGender() {
return gender;
}

public void setGender(String gender) {
this.gender = gender;
}

public Address getAddress() {
return address;
}

public void setAddress(Address address) {
this.address = address;
}

public List<Book> getBooks() {
return books;
}

public void setBooks(List<Book> books) {
this.books = books;
}

public Map<String, Object> getMaps() {
return maps;
}

public void setMaps(Map<String, Object> maps) {
this.maps = maps;
}

public Properties getProperties() {
return properties;
}

public void setProperties(Properties properties) {
this.properties = properties;
}

public String[] getHobbies() {
return hobbies;
}

public void setHobbies(String[] hobbies) {
this.hobbies = hobbies;
}

public Set<Integer> getSets() {
return sets;
}

public void setSets(Set<Integer> sets) {
this.sets = sets;
}

@Override
public String toString() {
return "Person{" +
"id=" + id +
", name='" + name + ''' +
", age=" + age +
", gender='" + gender + ''' +
", address=" + address +
", hobbies=" + Arrays.toString(hobbies) +
", books=" + books +
", sets=" + sets +
", maps=" + maps +
", properties=" + properties +
'}';
}
}

Book.java

package com.mashibing.bean;

public class Book {

private String name;private String author;private double price;public Book() {}public Book(String name, String author, double price) {    this.name = name;    this.author = author;    this.price = price;}public String getName() {    return name;}public void setName(String name) {    this.name = name;}public String getAuthor() {    return author;}public void setAuthor(String author) {    this.author = author;}public double getPrice() {    return price;}public void setPrice(double price) {    this.price = price;}@Overridepublic String toString() {    return "Book{" +            "name='" + name + ''' +            ", author='" + author + ''' +            ", price=" + price +            '}';}

}

Address.java

package com.mashibing.bean;

public class Address {

private String province;private String city;private String town;public Address() {}public Address(String province, String city, String town) {    this.province = province;    this.city = city;    this.town = town;}public String getProvince() {    return province;}public void setProvince(String province) {    this.province = province;}public String getCity() {    return city;}public void setCity(String city) {    this.city = city;}public String getTown() {    return town;}public void setTown(String town) {    this.town = town;}@Overridepublic String toString() {    return "Address{" +            "province='" + province + ''' +            ", city='" + city + ''' +            ", town='" + town + ''' +            '}';}

}

ioc.xml

<bean id="person" class="com.mashibing.bean.Person">
<property name="name">

<null></null>
</property>

<property name="address" ref="address"></property>



<property name="books">
<list>

<bean id="book1" class="com.mashibing.bean.Book">
<property name="name" value="多线程与高并发"></property>
<property name="author" value="马士兵"></property>
<property name="price" value="1000"></property>
</bean>

<ref bean="book2"></ref>
</list>
</property>

<property name="maps" ref="myMap"></property>

<property name="properties">
<props>
<prop key="aaa">aaa</prop>
<prop key="bbb">222</prop>
</props>
</property>

<property name="hobbies">
<array>
<value>book</value>
<value>movie</value>
<value>game</value>
</array>
</property>

<property name="sets">
<set>
<value>111</value>
<value>222</value>
<value>222</value>
</set>
</property>
</bean>
<bean id="address" class="com.mashibing.bean.Address">
<property name="province" value="河北"></property>
<property name="city" value="邯郸"></property>
<property name="town" value="武安"></property>
</bean>
<bean id="book2" class="com.mashibing.bean.Book">
<property name="name" value="JVM"></property>
<property name="author" value="马士兵"></property>
<property name="price" value="1200"></property>
</bean>

<bean id="person2" class="com.mashibing.bean.Person">
<property name="address" ref="address"></property>
<property name="address.province" value="北京"></property>
</bean>

<util:map id="myMap">
<entry key="key1" value="value1"></entry>
<entry key="key2" value-ref="book2"></entry>
<entry key="key03">
<bean class="com.mashibing.bean.Book">
<property name="name" value="西游记" ></property>
<property name="author" value="吴承恩" ></property>
<property name="price" value="100" ></property>
</bean>
</entry>
</util:map>
</beans>

6、继承关系bean的配置

ioc.xml

<bean id="person" class="com.mashibing.bean.Person">    <property name="id" value="1"></property>    <property name="name" value="zhangsan"></property>    <property name="age" value="21"></property>    <property name="gender" value="男"></property></bean><!--parent:指定bean的配置信息继承于哪个bean--><bean id="person2" class="com.mashibing.bean.Person" parent="person">    <property name="name" value="lisi"></property></bean>

如果想实现Java文件的抽象类，不须要将以后bean实例化的话，能够应用abstract属性

 <bean id="person" class="com.mashibing.bean.Person" abstract="true">    <property name="id" value="1"></property>    <property name="name" value="zhangsan"></property>    <property name="age" value="21"></property>    <property name="gender" value="男"></property></bean><!--parent:指定bean的配置信息继承于哪个bean--><bean id="person2" class="com.mashibing.bean.Person" parent="person">    <property name="name" value="lisi"></property></bean>

7、bean对象创立的依赖关系

bean对象在创立的时候是依照bean在配置文件的程序决定的，也能够应用depend-on标签来决定程序

ioc.xml

<bean id="book" class="com.mashibing.bean.Book" depends-on="person,address"></bean><bean id="address" class="com.mashibing.bean.Address"></bean><bean id="person" class="com.mashibing.bean.Person"></bean>

8、bean的作用域管制，是否是单例

ioc.xml

<!--bean的作用域：singleton、prototype、request、session默认状况下是单例的prototype：多实例的    容器启动的时候不会创立多实例bean，只有在获取对象的时候才会创立该对象    每次创立都是一个新的对象singleton：默认的单例对象    在容器启动实现之前就曾经创立好对象    获取的所有对象都是同一个--><bean id="person4" class="com.mashibing.bean.Person" scope="prototype"></bean>

9、利用工厂模式创立bean对象

在之前的案例中，所有bean对象的创立都是通过反射失去对应的bean实例，其实在spring中还蕴含另外一种创立bean实例的形式，就是通过工厂模式进行对象的创立

在利用工厂模式创立bean实例的时候有两种形式，别离是动态工厂和实例工厂。

动态工厂：工厂自身不须要创建对象，然而能够通过静态方法调用，对象=工厂类.动态工厂办法名（）；

实例工厂：工厂自身须要创建对象，工厂类工厂对象=new 工厂类；工厂对象.get对象名（）；

PersonStaticFactory.java

package com.mashibing.factory;

import com.mashibing.bean.Person;

public class PersonStaticFactory {

public static Person getPerson(String name){
Person person = new Person();
person.setId(1);
person.setName(name);
return person;
}
}

ioc.xml

<bean id="person5" class="com.mashibing.factory.PersonStaticFactory" factory-method="getPerson">

<constructor-arg value="lisi"></constructor-arg>
</bean>

PersonInstanceFactory.java

package com.mashibing.factory;

import com.mashibing.bean.Person;

public class PersonInstanceFactory {
public Person getPerson(String name){
Person person = new Person();
person.setId(1);
person.setName(name);
return person;
}
}

ioc.xml

<bean id="personInstanceFactory" class="com.mashibing.factory.PersonInstanceFactory"></bean>

<bean id="person6" class="com.mashibing.bean.Person" factory-bean="personInstanceFactory" factory-method="getPerson">
<constructor-arg value="wangwu"></constructor-arg>
</bean>

10、继承FactoryBean来创建对象

FactoryBean是Spring规定的一个接口，以后接口的实现类，Spring都会将其作为一个工厂，然而在ioc容器启动的时候不会创立实例，只有在应用的时候才会创建对象

MyFactoryBean.java

package com.mashibing.factory;

import com.mashibing.bean.Person;
import org.springframework.beans.factory.FactoryBean;

/**

实现了FactoryBean接口的类是Spring中能够辨认的工厂类，spring会主动调用工厂办法创立实例
*/

public class MyFactoryBean implements FactoryBean<Person> {

/**

工厂办法，返回须要创立的对象
@return
@throws Exception
*/
@Override
public Person getObject() throws Exception {
Person person = new Person();
person.setName("maliu");
return person;
}

/**

返回创建对象的类型,spring会主动调用该办法返回对象的类型
@return
*/
@Override
public Class<?> getObjectType() {
return Person.class;
}

/**

创立的对象是否是单例对象
@return
*/
@Override
public boolean isSingleton() {
return false;
}

}

ioc.xml

11、bean对象的初始化和销毁办法

在创建对象的时候，咱们能够依据须要调用初始化和销毁的办法

Address.java

package com.mashibing.bean;

public class Address {

private String province;private String city;private String town;public Address() {    System.out.println("address被创立了");}public Address(String province, String city, String town) {    this.province = province;    this.city = city;    this.town = town;}public String getProvince() {    return province;}public void setProvince(String province) {    this.province = province;}public String getCity() {    return city;}public void setCity(String city) {    this.city = city;}public String getTown() {    return town;}public void setTown(String town) {    this.town = town;}public void init(){    System.out.println("对象被初始化");}public void destory(){    System.out.println("对象被销毁");}@Overridepublic String toString() {    return "Address{" +            "province='" + province + ''' +            ", city='" + city + ''' +            ", town='" + town + ''' +            '}';}

}

ioc.xml

<!--bean生命周期示意bean的创立到销毁

    如果bean是单例，容器在启动的时候会创立好，敞开的时候会销毁创立的bean    如果bean是多礼，获取的时候创建对象，销毁的时候不会有任何的调用--><bean id="address" class="com.mashibing.bean.Address" init-method="init" destroy-method="destory"></bean>

MyTest.java

import com.mashibing.bean.Address;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

public static void main(String[] args) {    ApplicationContext context = new ClassPathXmlApplicationContext("ioc2.xml");    Address address = context.getBean("address", Address.class);    System.out.println(address);    //applicationContext没有close办法，须要应用具体的子类    ((ClassPathXmlApplicationContext)context).close();}

}

12、配置bean对象初始化办法的前后解决办法

spring中蕴含一个BeanPostProcessor的接口，能够在bean的初始化办法的前后调用该办法，如果配置了初始化办法的前置和后置处理器，无论是否蕴含初始化办法，都会进行调用

MyBeanPostProcessor.java

package com.mashibing.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {
/**

在初始化办法调用之前执行
@param bean 初始化的bean对象
@param beanName xml配置文件中的bean的id属性
@return
@throws BeansException
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessBeforeInitialization:"+beanName+"调用初始化前置办法");
return bean;
}

/**

在初始化办法调用之后执行
@param bean
@param beanName
@return
@throws BeansException
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessAfterInitialization:"+beanName+"调用初始化后缀办法");
return bean;
}

}

ioc.xml

3、spring创立第三方bean对象

在Spring中，很多对象都是单实例的，在日常的开发中，咱们常常须要应用某些内部的单实例对象，例如数据库连接池，上面咱们来解说下如何在spring中创立第三方bean实例。

1、导入数据库连接池的pom文件

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.21</version>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>

2、编写配置文件

ioc.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.or...">

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="username" value="root"></property>
<property name="password" value="123456"></property>
<property name="url" value="jdbc:mysql://localhost:3306/demo"></property>
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
</bean>
</beans>

3、编写测试文件

MyTest.java

import com.alibaba.druid.pool.DruidDataSource;
import com.mashibing.bean.Address;
import com.mashibing.bean.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.sql.SQLException;

public class MyTest {

public static void main(String[] args) throws SQLException {    ApplicationContext context = new ClassPathXmlApplicationContext("ioc3.xml");    DruidDataSource dataSource = context.getBean("dataSource", DruidDataSource.class);    System.out.println(dataSource);    System.out.println(dataSource.getConnection());}

}

4、spring援用内部配置文件

在resource中增加dbconfig.properties

username=root
password=123456
url=jdbc:mysql://localhost:3306/demo
driverClassName=com.mysql.jdbc.Driver

编写配置文件

<?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.or...
http://www.springframework.or...
http://www.springframework.or...">

<context:property-placeholder location="classpath:dbconfig.properties"/>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="username" value="${username}"></property>
<property name="password" value="${password}"></property>
<property name="url" value="${url}"></property>
<property name="driverClassName" value="${driverClassName}"></property>
</bean>
</beans>

5、spring基于xml文件的主动拆卸

当一个对象中须要援用另外一个对象的时候，在之前的配置中咱们都是通过property标签来进行手动配置的，其实在spring中还提供了一个十分弱小的性能就是主动拆卸，能够依照咱们指定的规定进行配置，配置的形式有以下几种：

default/no：不主动拆卸

byName：依照名字进行拆卸，以属性名作为id去容器中查找组件，进行赋值，如果找不到则拆卸null

byType：依照类型进行拆卸,以属性的类型作为查找根据去容器中找到这个组件，如果有多个类型雷同的bean对象，那么会报异样，如果找不到则拆卸null

constructor：依照结构器进行拆卸，先依照有参结构器参数的类型进行拆卸，没有就间接拆卸null；如果依照类型找到了多个，那么就应用参数名作为id持续匹配，找到就拆卸，找不到就拆卸null

ioc.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.or...">

<bean id="address" class="com.mashibing.bean.Address">
<property name="province" value="河北"></property>
<property name="city" value="邯郸"></property>
<property name="town" value="武安"></property>
</bean>
<bean id="person" class="com.mashibing.bean.Person" autowire="byName"></bean>
<bean id="person2" class="com.mashibing.bean.Person" autowire="byType"></bean>
<bean id="person3" class="com.mashibing.bean.Person" autowire="constructor"></bean>
</beans>

6、SpEL的应用

SpEL:Spring Expression Language,spring的表达式语言，反对运行时查问操作对象

应用#{...}作为语法规定，所有的大括号中的字符都认为是SpEL.

ioc.xml