Spring入门一
一 简介
1.Spring为企业应用的开发提供了一个轻量级的解决方案,该解决方案包括:基于依赖注入的核心机制、基于AOP的声明式事务管理、与多种持久层技术
的整合,以及优秀的Web MVC框架等等。可以说,Spring是企业应用开发的“一站式”选择,它贯穿表现层、业务层、持久层。
2.下载:http://projects.spring.io/spring-framework/
当使用Spring框架时,必须使用Spring Core
Container(即Spring容器),它代表了Spring框架的核心机制。Spring Core
Container主要由org.framework.core、org.framework.beans、
org.framework.context、org.framework.expression四个包及其子包组成,主要由Spring
IoC容器支持。
使用Spring框架的Java Web项目,需要将Spring框架的JAR包和commons-logging-1.1.3.jar添加到Web应用的WEB-INF路径下。
3.描述
轻量级:Spring是非侵入性的,基于Spring开发的应用中的对象可以不依赖于Spring的API
依赖注入(DI--dependency injection),控制反转(IOC--Inversion of Control)
面向切面编程(AOP--aspect oriented programming)
容器:Spring是一个容器,因为它可以包含并管理应用对象的生命周期
框架:Spring实现了使用简单的组件配置组合成一个复杂的应用,在Spring中使用xml和java注解组合这些对象
一站式:在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库
二 使用Spring管理bean
Spring核心容器的理论很简单:Spring核心容器就是一个超级大工厂,所有的对象(包括数据源、Hibernate
SessionFactory等基础性)都会被当成Spring核心容器管理的对象。Spring把容器中的一切对象统称为Bean,Spring对
bean没有任何要求,只要是一个java类,Spring就可以管理该java类,并把它当做Bean处理。
先定义一个简单的类Axe.java
public class Axe {
public String chop(){
return "使用斧子砍柴";
}
}
再定义一个Person类
public class Perosn {
private Axe axe;
public void setAxe(Axe axe){
this.axe=axe;
}
public void useAxe(){
System.out.println("打算去砍柴点火");
System.out.println(axe.chop());
}
}
Perosn对象需要调用Axe对象的方法,这种情形成为依赖。
Spring通过xml配置文件来管理Bean,示例:
在项目的src下建立ApplicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">
<bean id="person" class="mySpring.Person">
<property name="axe" ref="axe"></property>
</bean>
<bean id="axe" class="mySpring.Axe" />
</beans>
配置文件中的<bean>元素默认以反射方式来调用该类无参数的构造器来创建实例,并将该实例作为Spring容器中的Bean.zai
Spring配置文件中配置bean时,class属性的值必须是Bean实现类的完整类名(必须带包名),不能是接口,不能是抽象类(除非有特殊配
置),否则Spring无法使用反射创建该类的实例。
<property>子元素会驱动Spring在底层以反射执行一次setter方法,name属性值会决定执行哪个setter方法,而
value或ref决定执行setter方法的传入参数。一旦bean被创建处理,Spring会立即根据<property>子元素执行
setter方法。也就是说,<bean>元素驱动Spring调用构造器创建对象,<property>子元素驱动
Spring执行setter方法,这两步是先后执行的,中间几乎没有任何间隔。
访问容器中的bean:
public class test {
public static void main(String[] args) {
ApplicationContext ctx=new ClassPathXmlApplicationContext("ApplicationContext.xml");
Perosn p=ctx.getBean("person",Perosn.class);
p.useAxe();
}
}
三 Spring的核心机制--依赖注入
1.在java应用中存在大量A对象调用B对象方法的情形,这种情形被Spring称为依赖,即A对象依赖B对象。Spring框架的核心功能有两个:
Spring容器作为超级大工厂,负责创建、管理所有的java对象,这些java对象被称为bean。
Spring容器通过依赖注入管理容器中Bean之间的依赖关系
2.什么是依赖注入
当某个java对象需要调用另一个java对象的方法时,在传统模式下通常有两种做法:
原始做法:调用者主动创建被依赖对象,即new一个对象,再调用对象的方法。这种做法主要有两个坏处:可扩展性差,当修改了被依赖对象时,还需要修改调用者;职责不清,调用者还需要关心被依赖对象的创建过程,实际上,它只需要调用其中的某些方法即可。
简单工厂模式:调用者找到被依赖对象的工厂,通过工厂去获取被依赖对象,调用其中的方法。这种模式要注意三点:调用者面向被依赖对象的接口编程;被依赖对象的创建交给工厂完成;调用者通过工厂来获得被依赖组件。
使用Spring框架后,调用者只需要被动接受Spring容器为调用者的成员变量赋值即可(配置一个<property>子元
素,Spring就会执行对应的setter方法为调用者的成员变量赋值)。控制反转和依赖注入是同一个行为的两种表述,只是描述的角度不同而已。依赖注
入通常有两种方式:
设值注入:IoC容器使用成员变量的setter方法来注入被依赖对象。
构造注入:IoC容器使用构造器来注入被依赖对象。
3.属性(设值)注入:
属性注入即通过setter方法注入Bean的属性值或依赖的对象,是实际应用中最常用的注入方式
属性注入使用<property>元素,使用name属性指定Bean的属性名称,value属性或<value>子节点指定属性值
构造方法注入:
通过构造方法注入Bean的属性值或依赖的对象,它保证了Bean实例在实例化后就可以使用
构造器注入在<constructor-arg>元素里声明属性,<constructor-arg>中没有name属性
Spring IoC容器有三个基本要点:
(1)应用程序的各组件面向接口编程,从而可以将组件之间的耦合关系提升到接口层次,有利于后期的扩展。
(2)应用程序的各组件不再由程序主动创建,而是由Spring容器负责产生并初始化。
(3)Spring采用配置文件或注解来管理bean的实现类、依赖关系,Spring容器则根据配置文件或注解,利用反射来创建实例,并为之注入依赖关系。
4.构造注入
Car.java
public class Car {
private String brand;
private String corp;
private double price;
private int maxSpeed;
public Car(String brand, String corp, double price) {
super();
this.brand = brand;
this.corp = corp;
this.price = price;
}
@Override
public String toString() {
return "Car [brand=" + brand + ", corp=" + corp + ", price=" + price
+ ", maxSpeed=" + maxSpeed + "]";
}
}ApplicationContext.xml
<!-- 通过构造方法来配置bean的属性 -->
<bean id="car" class="a.Car">
<constructor-arg value="Audi" index="0"></constructor-arg>
<constructor-arg value="ShangHai" index="1"></constructor-arg>
<constructor-arg value="300000" index="2"></constructor-arg>
</bean>
myTest.java:
public class myTest {
public static void main(String[] args) {
ApplicationContext ctx=new ClassPathXmlApplicationContext("a/ApplicationContext.xml");
Car car=ctx.getBean(Car.class);
System.out.println(car);
}
}
构造注入的本质是:驱动Spring在底层以反射方式执行带指定参数的构造器,当执行带参数的构造器时,就可以利用构造器参数对成员变量执行初始化。也就
是说,设值注入与构造器注入的区别在于:设值注入是先通过无参数的构造器创建一个Bean实例,然后调用对应的setter方法注入依赖关系;而构造器注
入则直接调用有参数的构造器,当Bean实例创建完成后,已经完成了依赖关系的注入。
若在car.java中再增加如下的构造器,并希望通过该构造器来配置bean的属性:
public Car(String brand, String corp, int maxSpeed) {
super();
this.brand = brand;
this.corp = corp;
this.maxSpeed = maxSpeed;
}
则相应的bean的属性为:
<bean id="car2" class="a.Car">
<constructor-arg value="BaoMa"></constructor-arg>
<constructor-arg value="ShangHai"></constructor-arg>
<constructor-arg value="240"></constructor-arg>
</bean>
由于有两个构造方法,相应的test.java中只能用id定位到相应的bean:
Car car=(Car)ctx.getBean("car");
System.out.println(car);
Car car2=(Car)ctx.getBean("car2");
System.out.println(car2);
结果为:Car [brand=Audi, corp=ShangHai, price=300000.0, maxSpeed=0]
Car [brand=BaoMa, corp=ShangHai, price=240.0, maxSpeed=0]
此时两个构造器就会发生歧义,仅靠顺序无法解决。可以靠参数列表解决,根据参数个数和参数类型来区分
<bean id="car2" class="a.Car">
<constructor-arg value="BaoMa" type="java.lang.String"></constructor-arg>
<constructor-arg value="ShangHai" type="java.lang.String"></constructor-arg>
<constructor-arg value="240" type="int"></constructor-arg>
</bean>
结果为:Car [brand=Audi, corp=ShangHai, price=300000.0, maxSpeed=0]
Car [brand=BaoMa, corp=ShangHai, price=0.0, maxSpeed=240]
也就是说,使用构造器注入属性值可以指定参数的个数和参数的类型,来区分重载的构造器
5.两种注入方式的对比
设值注入的优点:
对于复杂的依赖关系,如果采用构造注入,会导致构造器过于臃肿,难以阅读。Spring在创建Bean实例时,需要同时实例化其依赖的所有实例,从而导致性能下降,而使用设值注入则能避免这些问题。
在某些成员变量可选的情况下,多参数的构造器更加笨重。
构造注入的优点:
可以在构造器中决定依赖关系的注入顺序,优先依赖的优先注入。如组件中其他依赖关系的注入常常需要依赖于Datasource的注入。
对于依赖关系无须变化的Bean,构造注入更有用处。
建议采用设值注入为主,构造注入为辅的注入策略。
四 Spring容器
1.Spring有两个核心接口:BeanFactory和ApplicationContext。其中,ApplicationContext是
BeanFactory的子接口。它们都可以代表Spring容器,Spring容器是生成Bean实例的工厂,并管理容器中的Bean。由于
ApplicationContext本身就是BeanFactory的子接口,因此ApplicationContext完全可以作为Spring容器
来使用,而且功能更强,也被称为Spring上下文。
2.BeanFactory常用的实现类是DefaultListableBeanFactory
ApplicationContext的常用实现类是:
ClassPathXmlApplicationContext:从类路径下加载配置文件
FileSystemXmlApplicationContext:从文件系统中加载配置文件
AnnotationConfigApplicationContext
如果是在Web应用中使用Spring容器,则通常有XmlWebApplicationContext、AnnotationConfigWebApplicationContext两个实现类。
创建Spring容器的实例时,必须提供Spring容器管理的bean的详细配置信息,通常采用XML配置文件来设置,因此在创建ApplicationContext实例时,应该提供XML配置文件作为参数,XML配置文件通常采用Resource对象传入。
BeanFactory接口包含以下几个基本方法:
boolean containsBean(String name):判断Spring容器是否包含id为name的bean实例
<T> T getBean(Class<T> requiredType):获取Spring容器中属于requiredType类型的、唯一的Bean实例
Object getBean(String name):返回容器id为name的bean实例
<T> T getBean(String name,Class<T> requiredType):返回容器id为name且类型为requiredType的bean实例
Class<?> getType(String name):返回容器中id为name的Bean实例的类型
ApplicationContext除了BeanFactory所支持的全部功能外,它还有如下额外的功能:
(1)默认会预初始化所有的singleton Bean,也可以通过配置取消预初始化;
(2)继承了MessageSource接口,因此可以提供国际化支持;
(3)资源访问,比如访问URL和文件;
(4)事件机制;
(5)同时加载多个配置文件;
(6)以声明式方式启动并创建Spring容器。
当系统创建ApplicationContext容器时,默认会预初始化所有的singleton
Bean。这就意味着,系统前期创建ApplicationContext时将有较大的系统开销,但一旦ApplicationContext初始化完
成,程序后面获取singleton Bean实例时将有较好的性能。
一般情况下,对于一个普通的Bean,如果没有特殊配置,该bean就是singleton Bean,如果不想预初始化该bean,可以在<bean>元素内指定lazy-init="true"