Spring的Core模块
Posted liunianfeiyu
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Spring的Core模块相关的知识,希望对你有一定的参考价值。
Core模块主要的功能是实现了反向控制IOC(Inversion of Control)与依赖注入DI(Dependency Injection)、Bean配置以及加载。Core模块中有Beans、BeanFactory、BeanDefinitions、ApplicationContext等几个重要概念。
Beans为Spring里的各种对象,一般要配置在Spring配置文件中:BeanFactory为创建Beans的Factory,Spring通过BeanFactory加载各种Beans;BeanDefinition为Bean在配置文件中的定义,一般要定义id与class:ApplicationContext代表配置文件。
这些类都位于org.springframework.beans和org.springframework.context中。这是Spring最核心的包。Core模块依赖于Spring的Core类库。
BeanFactory工厂
BeanFactory是实例化、配置、管理众多Bean的容器。这些Bean类一般是离散的,但在Spring中被配置为相互依赖。BeanFactory根据配置实例化Bean对象,并设置相互的依赖性。
BeanFactory可用接口org.springframework.beans.factory.BeanFactory表示。BeanFactory有多种实现,最常用的为org.springframework.beans.factory.xml.XmlBeanFactory。XmlBeanFactory能加载XML格式的配置文件。
实例化BeanFactory
在Web程序中用户不需要实例化BeanFactory,Web程序加载的时候会自动实例化BeanFactory,并加载所有的Beans,将各种Bean设置到各个Servlet中、Struts的Action中、或者Hibernate资源中。开发者直接编写Servlet、Action、Hibernate相关的代码即可,无须操作 BeanFactory。
在Java桌面程序中,需要从BeanFactory中获取Bean,因此需要实例化BeanFactory,构造函数的参数为配置文件的路径。例如加载ClassPath下的配置文件可以用ClassPathResource加载,然后传递给XmlBeanFactory构造函数。代码如下:
ClassPathResource res = new ClassPathResource("applicationContext.xml"); // 获取配置资源 XmlBeanFactory factory = new XmlBeanFactory(res); // 获取对象工厂 IService hello = (IService)factory.getBean("service"); // 获取对象 ...// 其他代码略 factory.destorySingletons(); // 销毁对象
参数applicationContext.xml为ClassPath根目录下的文件。applicationContext.xml为Spring默认的配置文件名称,默认存储在ClassPath根目录下。或者使用文件流加载任意位置的配置文件,并传递给XmlBeanFactory构造函数,例如:
InputStream is = new FileInputStream("C:\\\\ApplicationContext.xml"); // 获取配置资源 XmlBeanFactory factory = new XmlBeanFactory(is); // 获取对象工厂 IService hello = (IService)factory.getBean("service"); // 获取对象
或者用ClassPathXmlApplicationContext加载多个配置文件(多个配置文件以字符串数组形式传入),并传递给XmlBeanFactory构造函数:
ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml", "applicationContext-part2.xml"}); // 多个配置 BeanFactory factory = (BeanFactory)appContext; // ApplicationContext继承自BeanFactory接口
XmlBeanFactory配置格式
一个BeanFactory中配置了多个Bean。在XmlBeanFactory中,配置文件的根节点为<beans>,里面定义了几个<bean>子节点,每个<bean>定义一个Bean。格式如下:
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans> <!-- Beans根节点 --> <bean id="..." class="..."> <!--Bean节点,定义Bean--> ... </bean> <bean id="..." class="..."> <!--Bean节点,定义Bean--> <property name="..." value="..."></property> <!-- Property定义属性 --> <property name="..." ref="..."></property> <!-- Property定义属性 --> </bean> </beans>
配置Java Bean
一个BeanDefinition定义一个Bean,在XML中对应一个<bean>标记。Spring通过<bean>配置来实例化Bean,设置Bean的属性,以及设置Bean之间相互的依赖性。
基本配置<bean>
一个<bean>通常需要定义id与class属性。class属性是必须的,如果有其它Bean引用了该Bean,则id属性是必须的。Bean之间通过id属性相互访问,如:
<bean id="exampleBean" class="example.ExampleBean"></bean>
上面代码等价于
ExampleBean exampleBean = new ExampleBean();
其中,对象名exampleBean相当于配置中的id属性。
工厂模式factory-method
如果一个Bean不能通过new直接实例化,而是通过工厂类的某个方法建的,可以把class设为工厂类,用factory-method指向创建对象的法:
<!-- createInstance()是静态方法 --> <bean id="exampleBean" class="example.MyFactoryBean" factory-method="createInstance" /> <!-- createInstance()是非静态方法 --> <bean id="exampleBean2" factory-bean="myFactoryBean" factory-method="createInstance" />
构造函数<constructor-arg>
如果Bean的构造函数带参数,那就需指定参数,用<constructor-arg>指定
<bean id="exampleBean" class="examples.ExampleBean"><!-- 定义Bean --> <constructor-arg><ref bean="anotherExampleBean" /></constructor-arg><!-- 构造函数参数 --> <constructor-arg><ref bean="yetAnotherBean" /></constructor-arg><!-- 构造函数参数 --> <constructor-arg><value>1</value></constructor-arg><!-- 构造函数参数 --> </bean>
每个<constructor-arg>的参数的顺序要与构造函数相同。
public class ExampleBean { private AnotherBean beanOne; private YetAnotherBean beanTwo; private int i; public ExampleBean(AnotherBean beanOne, YetAnotherBean beanTwo, int i){ this.beanOne = beanOne; this.beanTwo = beanTwo; this.i = i; } }
单态模式singleton
Bean可以定义为单态模式(Singleton)。即在程序中只有一个实例,像数据源等一般设为单例。Spring默认是单态模式,如果想使用非单例模式(称为Prototype模式),需把singleton属性置为false:
<bean id="exampleBean" class="examples.ExampleBean" singleton="false" />
非单例下,每次请求该Bean,都会生成一个新的对象。
配置属性<property>
Spring通过Bean的setter方法设置属性。因此,需要由Spring注射的属性一般都具有公共的setter,getter方法。例如下面的配置代码:
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="com.mysql.jdbc.Driver" /> <property name="url" value="jdbc:mysql://localhost:3306/spring?characterEncoding=UTF-8" /> <property name="username" value="root" /> <property name="password" value="admin" /> </bean>
destroy-method属性配置关闭方法。在销毁对象时会调用该方法。
注意:
<!-- 将password设为空字符串 --> <property name="password"><value></value></property> <!-- 将password设为null,也可以不设置 --> <property name="password"><null /></property>
设置对象属性<ref>
使用ref标签配置Bean的id属性使用。如:
<bean id="dao" class="com.helloweenvsfei.forum.dao.impl.DaoImpl"> <property name="sessionFactory" ref="sessionFactory"></property> </bean> <bean class="com.helloweenvsfei.forum.service.impl.ThreadServiceImpl"> <property name="dao" ref="dao"></property> </bean>
ref的内容为引用的Bean的id属性。
也可使用内部配置(或者内联配置),类似于JAVA中的匿名类对象。因为内部配置一般不会被其他的Bean引用,因此不需要配置内部Bean的id。例如:
<property name="dao">
<bean class="example.DaoImpl"></bean>
</property>
除了使用<ref>的bean属性,还可以使用local、parent,它们与bean属性的作用是一样的。不同的是,local只能使用本配置文件中的bean,而parent只能使用父配置文件中的bean,但bean则没有任何限制。
配置List属性<list>
<list>配置java.util.List类型的属性。list属性中可配置任意类型对象,如果为java对象,使用ref指定,或者<bean>定义新实例,如果是普通类型如String,int,double等,直接用字符串即可。<list>中的元素会按配置的先后顺序排序,例如:
<property name="someList"> <list> <value>String,Integer,Double,Boolean等类型对象</value> <ref bean="myDataSource" /> </list> </property>
配置Set属性<set>
<set>配置java.util.Set类型的属性。Set属性中可配置任意类型对象。如果为java对象,则使用<ref>指定,或者使用<bean>重新定义新实例。如果是普通类型如String,int,double等,直接用字符串即可。例如:
<property name="someSet"> <set> <value>String,Integer,Double,Boolean等类型对象</value> <ref bean="myDataSource" /> <set> </property>
配置Map属性<map>
<map>配置java.util.Map类型的属性。<entry>配置Map里的元素,key指定索引,value指定值。如果为java对象,则使用ref指定,或者使用<bean>重新定义新实例,如果key为对象,,使用key-ref属性,例如:
<property name="someMap"> <map> <entry key="yup an entry"> <value>just some string</value> </entry> <entry key-ref="myDataSource"> <ref bean="serviceImpl" /> </entry> </map> </property>
配置Properties属性<props>
使用<props>与<prop>配置Properties属性。<props/>配置一个Properties对象,<prop/>配置一条属性,属性key配置索引,例如:
<props> <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop> <prop key="hibernate.show_sql">true</prop> <prop key="hibernate.format_sql">false</prop> <prop key="hibernate.hbm2ddl.auto">create</prop> </props>
<idref>与<ref>的区别
<idref>与<ref>的作用是一样的,都是配置java对象的。<idref>的用法也与<ref>基本相同。不同的是,<idref>只有bean与local属性,没有parent属性,如
<idref local="dataSource" />
Spring加载XML配置文件时,会检查<idref>配置的Bean存在不存在。而<ref>只会在第一次调用时才会检查。换句话说,如果Bean不存在,<idref>能在启动程序的时候就抛出错误,而<ref>只会在运行中抛出错误。
设置destory-method销毁方法
有的对象(例如数据源,JDBC连接,输入输出流等)在使用完毕后需要执行close()方法释放资源。可以使用destory-method配置。Spring在注销这些资源时会调用destory-method里配置的方法。例如:
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
..... </bean>
设置depends-on依赖对象
Spring默认按照配置文件里Bean配置的先后顺序实例化Bean,但有时候在实例化A对象之前需要先实例化后面的B对象。这时候可以使用depends-on,强制先实例化B对象。如:
<bean id="a" class="examples.A" depends-on="b"></bean> <bean id="b" class="examples.B"></bean>
在实例化A的时候会检查B的实例是否存在,如果不存在,先实例化B
初始化方法init-method
与destory-method相反,有的对象在实例化后需要执行某些初始化代码,但这些初始化代码不能写在构造函数中。这时候可以把这部分初始化代码写在一个方法中,如init(),使用init-method属性,强制Spring执行该方法进行初始化,如:
<bean id="c" class="example.C" init-method="init"></bean>
属性自动装配autowire
为了防止配置文件过大,可以使用autowire属性
配置autowire自动装配
使用<bean>的autowire属性后,不需要再用<property name="" value="" />显示地设置该Bean的属性、依赖关系。Spring会根据反射,自动寻找符合条件的属性,设置到该Bean属性上。如果autowire设置为byType,将会按照属性的类型自动匹配。如:
<bean id="d" class="examples.D" autowire="byType"></bean>
autowire取值范围
autowire属性定义的不是需要自动装配的属性名,而是自动装配的规则。一但配置,所有的属性都将遵循autowire定义的规则。autowire所有的取值以及意义见下表
如果显示定义了<property>或者<constructor-arg>,会覆盖默认装配。自动装配一般与下面的依赖检查连用。
注意:在大型项目中不推荐使用,因为自动装配会隐藏依赖装配的细节。降低可读性与可维护性,并可能带来意想不到的麻烦。
依赖检查dependency
有时候某些Bean的属性配置有错误,比如某个属性没有设置。这种错误在程序启动的时候不会有任何异常表现,会一直潜伏到Spring调用该Bean时才会被发现。为了防止这种情况,Spring提供依赖检查,在程序启动的时候检查依赖配置。如果有错误,启动时就会抛出异常,以便发现配置错误。
配置dependency依赖检查
依赖检查能够检查属性是否被设置。如果配置了依赖检查,程序启动时会进行配置校验,以便及时地发现配置错误。通过设置<bean>的dependency-check设置依赖检查规则,如:
<bean id="bean" class="examples.Bean" dependency-check="all"></bean>
dependency属性取值范围
dependency属性有多种取值,分别应对不同的情况。但是需要注意,dependency依赖检查是很生硬的,例如设置为object,将会检查所有的java对象属性,只要有一个属性没有设置,就会抛出异常,即某属性明明不需要设置,但是没法避免dependency检查,容易造成“一竿子全打死”的现象。dependency的取值以及意义见表
Bean的高级特性
Spring程序中,JAVA Bean一般与Spring是非耦合的,不会依赖于Spring类库。这也是Spring的优点。但有时候Java Bean需要知道自己在Spring框架中的一些属性。Spring提供了一些接口,实例化Java Bean对象后Spring会调用接口的方法。
BeanNameAware接口获取Bean的id
BeanNameAware接口帮助Java Bean知道自己在配置文件中的id,实现BeanNameAware,实现方法名为setBeanName()方法,初始化该对象后Spring就会执行该回调方法,将id设置进来。Bean中设置一个变量,接受id名称即可,例如:
package com.helloweenvsfei.spring.example; import org.springframework.beans.factory.BeanNameAware; public class WhatsTheNameBean implements BeanNameAware { private String beanName; public void setBeanName(String beanName) { this.beanName = beanName; } }
提示:setBeanName()方法的回调发生在所有参数被设置完之后,初始化方法(init-method属性)被执行之前。
BeanFactoryAware接口获取BeanFactory
BeanFactoryAware接口帮助java Bean知道哪个BeanFactory实例化了自己,BeanFactoryAware接口中有setBeanFactory的回调方法,初始化该对象后,会回调该方法,将BeanFactory传递进来。BeanFactoryAware接口的代码如下:
public interface BeanFactoryAware{ void setBeanFactory(BeanFactory beanFactory) throws BeanException }
用法同BeanNameAware,实现了BeanFactoryAware接口的Java Bean能够获取到BeanFactory,从BeanFactory中能够获取到BeanFactory中配置的其他Java Bean。Spring不推荐这样做,因为这样会与Spring耦合。获取其它Java Bean一般通过设置getter、setter方法,用依赖注入实现
InitializingBean接口执行初始化方法
实现了InitializingBean接口的Java Bean会在实例后、所有属性被设置后调用初始化方法。但使用该接口会与Spring代码发生耦合,因此不推荐使用。InitializingBean接口代码如下:
public interface InitializingBean{ public void afterPropertiesSet(); }
Spring推荐使用init-method配置,效果等价:
<bean id="d" class="examples.D" init-method="afterPropertiesSet"></bean>
DisposableBean接口执行销毁方法
实现了DisposableBean接口的Java Bean会在对象丢弃的时候调用销毁方法。但使用该接口会与Spring代码发生耦合,因此不推荐使用。DisposableBean接口代码如下:
public interface DisposableBean{ void destory() throws Exception; }
Spring推荐使用destory-method配置,效果等价:
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destory-method="close"></bean>
BeanFactory高级特性
如果Java Bean实现了BeanFactoryAware接口,就能够获得BeanFactory对象。BeanFactory有下面几个常用的方法:
属性覆盖器
对于一些参数,更实用更简单的方法是使用properties配置,而不是配置在Spring的配置文件中。Spring提供属性替代配置,允许把某些属性配置在properties文件中。
配置PropertyOverrideConfigurer属性覆盖器
PropertyOverrideConfigurer允许把XML配置里的某些参数配置到properties文件中。这在数据库配置中很常见。配置时需要配置一个PropertyOverrideConfigurer对象,指定properties文件的位置,然后把替换的属性用形如${jdbc.url}的字符串替代,如:
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="${jdbc.driverClassName}" /> <property name="url" value="${jdbc.url}" /> <property name="username" value="${jdbc.username}" /> <property name="password" value="${jdbc.password}" /> </bean> <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="location" value="classpath:jdbc.properties" />
</bean>
PropertyOverrideConfigurer对象会到指定名称的properties文件(例如jdbc.properties)中,寻找属性名为${}变量的配置,${}中最好不要有空格
properties配置
具体的数据库配置是写在jdbc.properties里面的。properties中的配置比applicationContext.xml中更便于阅读、修改与维护。代码如下:
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/forum?characterEncoding=UTF-8
jdbc.username=root
jdbc.password="admin
以上是关于Spring的Core模块的主要内容,如果未能解决你的问题,请参考以下文章