| Spring之初体验 |
- Spring是一个轻量级的Java Web开发框架，以IoC(Inverse of Control 控制反转)和AOP(Aspect Oriented Programming 面向切面编程)为内核，使用基本的JavaBean来完成以前只能有EJB完成的工作（现在这句话好像就是废话，以后我们会慢慢来说明）。
在实际开发当中，通常服务器端采用三层体系架构，分别为表示层（web）、业务逻辑层（service）、持久层（DAO）。Spring对每一层都提供了技术支持，在表示层提供了与Structs2框架的整合，在业务逻辑层可以管理事物，记录日志等，在持久层可以整合Hibernate、JDBCTemplate等技术，从设计上来看，给予了Java程序员很多*，为商业开发提供了良好的解决方案。
| Spring框架的优点 |
Spring具有简单、可测试和松耦合的特点，从这个角度出发，Spring不仅可以用于服务器端开发，而且可以应用于任何Java应用的开发中。其优点总结如下：
方便解耦、简化开发：Spring就是一个工厂，可以将所有对象创建和依赖关系维护交给Spring管理；
AOP编程的支持：Spring提供面向切面编程，可以方便的实现对程序进行权限管理、运行监控等功能；
声明式事物的支持：只需要通过配置就可以完成对事物的管理，无需手动编程；
方便程序的测试：Spring对JUnit4支持，可以通过注解方便地测试Spring程序；
方便集成各种优秀框架：Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（Struts2、Hibernate、MyBatis、Quartz等）的直接支持；
降低JavaEE API的使用难度：Spring对JavaEE开发中难以使用的一些API（JDBC、JavaMail、远程调用）都提供了封装，使API应用难度降低。
| Spring体系结构 |
Spring框架采用分层架构，其体系结构图如下，我们着重介绍一下Core Container、Data Access/Intergration、Web、AOP（Aspect Oriented Programming）部分。
- Core Container(核心容器)
Spring的核心容器是建立在其他模块的基础上的，由Beans模块、Core核心模块、Context上下文模块和Expression Language表达式语言模块组成。
Beans模块：提供BeanFactory，是工厂模式的经典实现，Spring将管理对象成为Bean；
Core核心模块：Spring的核心类库，提供了Spring框架的基本组成部分，包括IoC和DI功能；
Context上下文模块：建立在Core和Beans基础上，访问定义和配置任何对象的媒介，ApplicationContext接口就是上下文模块的焦点；
Expression Language模块：运行时查询和操作对象图的强大表达式语言。
- Data Access/Intergration(数据访问/集成)
JDBC模块：提供一个JDBC（Java Data Base Connectivity）的抽象层，大幅度减少了在开发过程中对数据库操作的代码；
ORM模块:提供对常用ORM框架的管理和辅助支持，Spring本身不对ORM进行实现，仅是对常见ORM框架的封装；
OXM模块：提供了一个支持对象/XML映射实现对JAXB、Castor使用XMLBeans、JiBX和XStream的抽象层
Transactions事物模块：支持编程和声明式事务管理实现特殊接口类，并且对所有的POJO都适用。
- Web模块
Spring的Web层包括web、Servlet、Struts和Portlet组件，具体介绍如下：
Web 模块提供了基本的面向 web 的集成特性，如多个文件上传的功能和使用 servlet 监听器的IOC容器初始化以及面向 web 应用程序的上下文；
Servlet模块：包括Spring模型-视图-控制器（MVC）实现web应用程序；
Struts模块：包含支持类内的Spring应用程序，集成经典的Struts web层；
Portlet模块：提供了在portlet环境中使用MVC实现，类似Web-Servlet模块的功能。
| 第一个Spring程序 |
- 当然啦，首先是下载Spring框架包，本文中使用的是4.3.4的版本，下载地址为：http://repo.spring.io/release/org/springframework/spring/4.3.4.RELEASE/，选择spring-framework-4.3.4.RELEASE-dist.zip下载。
- 然后在Eclipse中创建web项目，并将Spring所需要的jar包复制到项目的lib目录中，并且对包构建路径，jar包为Spring的4个基础包：
spring-core-4.3.4.RELEASE.jar：包含Spring框架基本的核心工具类，Spring其他组件都要用到这个包中的类；
spring-beans-4.3.4.RELEASE.jar：包含访问配置文件、创建和管理bean以及进行IoC或者DI操作相关的类；
spring-context-4.3.4.RELEASE.jar：Spring提供在IoC功能上的扩展服务，此外还提供企业级的服务，如邮件服务、任务调度、JNDI定位、缓存以及各种视图层框架的封装等；
spring-expression-4.3.4.RELEASE.jar：定义了spring的表达式语言。
其中还有一个记录日志的jar文件：文件下载路径为：http://commons.apache.org/proper/commons-logging/download_logging.cgi
项目的目录结构如下：
整个项目包的导入工作已经完成，随后是创建UserDao接口和UserDaoImpl实现类：
public interface UserDao {
public void sayHello();
}
public class UserDaoImpl implements UserDao{
@Override
public void sayHello() {
// TODO Auto-generated method stub
System.out.println("spring: hello user dao");
}
}
然后在src目录下创建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>
<!-- 将指定对象配置给spring，让spring创建其实例 -->
<bean id="userDao" class="com.ioc.UserDaoImpl"></bean>
</beans>
最后是创建主类Client，实现对方法的调用：
public class Client {
public static void main(String[] args) {
// TODO Auto-generated method stub
//定义配置文件路径
String xmlPath = "applicationContext.xml";
//初始化spring容器，加载配置文件
ApplicationContext application = new ClassPathXmlApplicationContext(xmlPath);
//通过容器获取UserDao实例
UserDao userDao = (UserDao) application.getBean("userDao");
userDao.sayHello();
}
}
最后整个项目的目录结构图如下：
运行该主函数就会在控制台中看到输出信息：“spring: hello user dao”。如上即为一个spring简单IoC的实例，实例不是有调用者来创建的，而是由Spring容器创建，Spring容器会控制程序之间的关系，而不是由程序代码直接控制，这样控制权由应用代码转移到了外部容器，控制权发生了反转，也就是IoC的思想。
接下来我们再来看一看DI（依赖注入），它与控制反转的含义相同，只不过从不同的角度描述同一个概念。如果A类需要使用B类的对象才能实现某个功能，这时可以说A类对象依赖B类对象，而Spring容器在创建A类对象时，会自动将A类对象需要的B类对象注入到A类对象中，此过程就是依赖注入。Spring支持两种依赖注入：setter方法注入、构造方法注入。
属性setter注入：指IoC容器使用setter方法注入被依赖实例，通过调用无参构造器或无参static工厂方法实例化Bean后，调用该Bean的setter方法，即可实现基于setter的DI
构造方法注入：指IoC容器使用构造方法来注入被依赖的实例，基于构造器的DI通过调用带参数的构造方法来实现，每个参数代表一个依赖。
我们通过setter注入的方式来说明DI，首先创建UserDaoImpl的两个依赖类BeforeAction和AfterAction，这两个类集成自Action接口，然后在UserDaoImpl类中加入两个私有的类对象，并实现两个对象的setter方法。
如下是BeforeAction和AfterAction的实现代码：
public interface Action {
public void doSomething();
}
public class BeforeAction implements Action{
@Override
public void doSomething() {
// TODO Auto-generated method stub
System.out.println("this is a method in BeforeAction");
}
}
public class AfterAction implements Action{
@Override
public void doSomething() {
// TODO Auto-generated method stub
System.out.println("this is a method in AfterAction");
}
}
然后是UserDaoImpl代码的改变：
public class UserDaoImpl implements UserDao{
//UserDaoImpl依赖的两个对象
private BeforeAction beforeAction;
private AfterAction afterAction;
//实现依赖对象的setter方法
public void setBeforeAction(BeforeAction beforeAction) {
this.beforeAction = beforeAction;
}
public void setAfterAction(AfterAction afterAction) {
this.afterAction = afterAction;
}
@Override
public void sayHello() {
// TODO Auto-generated method stub
this.beforeAction.doSomething();
System.out.println("spring: hello user dao");
this.afterAction.doSomething();
}
}
最后是修改applicationContext.xml文件，实现UserDaoImpl对BeforeAction和AfterAction类的依赖注入。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<!-- 将指定对象配置给spring，让spring创建其实例 -->
<bean id="beforeAction" class="com.action.BeforeAction"/>
<bean id="afterAction" class="com.action.AfterAction"/>
<bean id="userDao" class="com.ioc.UserDaoImpl">
<property name="beforeAction" ref="beforeAction"/>
<property name="afterAction" ref="afterAction"/>
</bean>
</beans>
整个项目最新的目录结构如下：
其中Client中的代码不变，从而通过setter的方法，实现了将两个Action对象加入到UserDaoImpl中。
思来想去还是想介绍一下构造器方法的注入，只是简单的说明一下吧，在setter依赖注入的实现的代码基础上，只对两个文件进行修改（UserDaoImpl和applicationContext.xml)。其中在UserDaoImpl中添加一个构造方法，其中参数为BeforeAction和AfterAction对象，UserDaoImpl中增加的代码如下：
public UserDaoImpl(BeforeAction before, AfterAction after){
this.beforeAction = before;
this.afterAction = after;
}
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>
<!-- 将指定对象配置给spring，让spring创建其实例 -->
<bean id="beforeAction" class="com.action.BeforeAction"/>
<bean id="afterAction" class="com.action.AfterAction"/>
<bean id="userDao" class="com.ioc.UserDaoImpl">
<!-- 如下为setter方法的依赖注入 -->
<!-- property name="beforeAction" ref="beforeAction"/ -->
<!-- property name="afterAction" ref="afterAction"/ -->
<!-- 如下是构造器方式的依赖注入 -->
<constructor-arg index="0" ref="beforeAction" />
<constructor-arg index="1" ref="afterAction" />
</bean>
</beans>
本篇博客主要讲解了Spring的基本知识，首先介绍了Spring框架的优缺点，随后介绍了框架体系结构，然后通过两个Spring实例分别实现了Spring的IoC和DI，帮助读者对Spring的控制反转（IoC）和依赖注入（DI）有进一步的理解。