Spring学习总结1(基础与IOC依赖注入)

Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。

 

• 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
• Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
• Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
• Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
• Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
• Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
• Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

 

Spring是一种完全面向接口的设计。

Sping的两大核心为：IOC控制反转DI依赖注入[Inversion of Control]，AOP面向方面编程。

 

Spring Framework一个重要的原则就是无侵入性（non-invasiveness）; 这个思想指你不应当被迫引入框架特定的类和接口到你的业务/领域模型中。

 

Spring从简单理解，可以引申为工厂模式的一种封装。

工厂模式主要使用在实现的接口类对象的获取。

类对象的获取途径主要有以下几种：

1.直接用new的形式获取。接口类型 对象名 = new 实现接口的类型();   缺点：客户端在调用时必须明确知道实现接口的类型，程序之间耦合紧密。

2.使用工厂设计模式。 缺点：一个接口就需要一个工厂，接口多的话，工厂也会多，不易管理。

3.使用反射机制 Class.forName()

4.使用对象克隆 缺点：和1一样，耦合紧密。

 

Spring包的获取：

1.http://www.springframework.org/ 中下载最新的jar包

2.将下载下来的dist文件夹和lib文件夹中的文件拷贝到工程引用jar路径下

 

 

Spring的核心配置：

Spring的xml配置:applicationContext.xml

<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans> <bean id="bean的名字" class="类完全路径名"> </bean> </beans>

 

Spring IoC容器的实例化

ApplicationContext在本地应用中的实例化

// 可同时加载好几个配置 ApplicationContext context = new ClassPathXmlApplicationContext( new String[] {"applicationContext.xml", "daos.xml"}); // 获取的ApplicationContext对象与BeanFactory对象是接口与实现子类的关系 所以直接用context.getBean()方法即可 BeanFactory factory = context;

 

同时加载多个配置的另一种写法：

<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <!-- 都是相对于该xml的路径，开头的"/"有与没有都可以 --> <import resource="resources/messageSource.xml"/> <import resource="/resources/themeSource.xml"/> <beans> <bean id="bean的名字" class="类完全路径名"> </bean> </beans>

 

ApplicationContext在WEB应用中的实例化

1.ContextLoaderListener方式

<context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/daoContext.xml /WEB-INF/applicationContext.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>

 

2.ContextLoaderServlet方式

<context-param> <param-name>contextConfigLocation</param-name> <!-- 可以使用搜索符：* 可以加载放在classpath下的xml -> <param-value/WEB-INF/applicationContext-*.xml,classpath*:applicationContext-*.xml</param-value> </context-param> <servlet> <servlet-name>context</servlet-name> <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet>

 

 

注入类型一共分三种：

1.构造函数注入

2.属性注入(通过set和get方法)

3.接口注入(相当于将类似于set的方法声明在一个接口中)

 

Spring对以上前2种的注入有非常棒的支持，而第3种注入本身就很少使用（于通过接口注入需要额外声明一个接口，增加了类的数目，而且它的效果和属性注入并无本质区别，因此我们不提倡这种方式）。

 

在Spring中，BeanFactory是IoC容器的核心接口。 它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。

 

基于XML配置方式，注入示例：

Simple.java

package sp; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.Map; import java.util.Set; public class Simple { private String name; private Date d; private int age; private List list; private Map map; private Set set; private String[] array; private SimpleRef simpleRef; public Simple(String name,Date d){ this.name = name; this.d = d; } public Simple(Date d){ this.d = d; } public Simple(String name,int age){ this.name = name; this.age = age; } public String[] getArray() { return array; } public void setArray(String[] array) { this.array = array; } public SimpleRef getSimpleRef() { return simpleRef; } public void setSimpleRef(SimpleRef simpleRef) { this.simpleRef = simpleRef; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Date getD() { return d; } public void setD(Date d) { this.d = d; } public List getList() { return list; } public void setList(List list) { this.list = list; } public Map getMap() { return map; } public void setMap(Map map) { this.map = map; } public Set getSet() { return set; } public void setSet(Set set) { this.set = set; } }

 

applicationContext.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.org/schema/beans/spring-beans-2.0.xsd"> <bean id="simple" class="sp.Simple"> <!-- 构造函数注入 自动匹配（当构造函数的参数都是引用类型时） --> <constructor-arg> <bean class="java.util.Date"/> </constructor-arg> <!-- 构造函数注入 索引方式 --> <constructor-arg index="0" value="han"></constructor-arg> <constructor-arg index="1" ref="dateRef"></constructor-arg> <!-- 构造函数注入 类型匹配方式（当构造函数的参数都是基本类型时） --> <constructor-arg type="java.lang.String" value="han"></constructor-arg> <constructor-arg type="int" value="25"></constructor-arg> <!-- List类型属性注入 --> <property name="list"> <list> <value>1</value> <value>2</value> <ref bean="xxxx" /> </list> </property> <!-- Set类型属性注入 --> <property name="set"> <set> <value>1</value> <value>2</value> </set> </property> <!-- Map类型属性注入 --> <property name="map"> <map> <entry key="k1" value="v1"></entry> <entry key="k2" value="v2"></entry> <entry> <key> <value>a ref</value> </key> <ref bean="myDataSource" /> </entry> </map> </property> <!-- 数组类型属性注入 --> <property name="array"> <list> <value>1</value> <value>2</value> </list> </property> <!-- Properties类型注入 --> <property name="adminEmails"> <props> <prop key="administrator">administrator@example.org</prop> <prop key="support">support@example.org</prop> <prop key="development">development@example.org</prop> </props> </property> <!-- 引用类型属性注入 --> <property name="simple" ref="simpleRef"></property> <!-- 引用类型属性注入(另一种写法) --> <property name="simple"> <ref bean="simpleRef" /> </property> </bean> <bean id="simpleRef" class="sp.SimpleRef"></bean> <bean id="dateRef" class="java.util.Date"></bean> </beans>

 

idref

仅适用于对bean名称即String类型的引用，ref是对bean实例的引用。

 

ref

1.<ref bean="someBean"/>  在当前容器中查找someBean

2.<ref local="someBean"/>  在当前xml中查找someBean

3.<ref parent="someBean"/>  在父容器中查找someBean

 

内部bean

<bean id="outer" class="..."> <!-- instead of using a reference to a target bean, simply define the target bean inline --> <property name="target"> <bean class="com.example.Person"> <!-- this is the inner bean --> <property name="name" value="Fiona Apple"/> <property name="age" value="25"/> </bean> </property> </bean>

内部bean中的scope标记及id或name属性将被忽略。内部bean总是匿名的且它们总是prototype模式的。同时将内部bean注入到包含该内部bean之外的bean是不可能的。

空字符串的注入

<bean class="ExampleBean"> <property name="email"> <value/> </property> </bean>

 

null的注入

<bean class="ExampleBean"> <property name="email"> <null/> </property> </bean>

 

 

方法注入

在大部分情况下，容器中的bean都是singleton类型的。如果一个singleton bean要引用另外一个singleton bean，或者一个非singleton bean要引用另外一个非singleton bean时，通常情况下将一个bean定义为另一个bean的property值就可以了。不过对于具有不同生命周期的bean来说这样做就会有问题了，比如在调用一个singleton类型bean A的某个方法时，需要引用另一个非singleton（prototype）类型的bean B，对于bean A来说，容器只会创建一次，这样就没法在需要的时候每次让容器为bean A提供一个新的的bean B实例。

解决方案为：不直接将需要的bean注入，而是定义一个抽象方法，在需要的地方调用该抽象方法进行bean的获取，而该抽象方法在xml中进行配置注入

package fiona.apple; // no more Spring imports! public abstract class CommandManager { public Object process(Object commandState) { // 每次都需要一个新的Command实例 Command command = createCommand(); // set the state on the (hopefully brand new) Command instance command.setState(commandState); return command.execute(); } // okay... but where is the implementation of this method? protected abstract Command createCommand(); }

 

<!-- a stateful bean deployed as a prototype (non-singleton) --> <bean id="command" class="fiona.apple.AsyncCommand" scope="prototype"> <!-- inject dependencies here as required --> </bean> <!-- commandProcessor uses statefulCommandHelper --> <bean id="commandManager" class="fiona.apple.CommandManager"> <lookup-method name="createCommand" bean="command"/> </bean>

 

 

基于XML的元数据是最常用到的配置元数据格式。然而，它并 不是唯一的描述格式。Spring IoC容器在这一点上是 完全开放的。

Spring还提供了基于注解的配置元数据格式。