一、spring诞生

spring是一个开源框架，目前在开源社区的人气很旺，被认为是最有前途的开源框架之一。她是由rod johnson创建的，她的诞生是为了简化企业级系统的开发。说道spring就不得不说ejb，因为spring在某种意义上是ejb的替代品，她是一种轻量级的容器。用过ejb的人都知道ejb很复杂，为了一个简单的功能你不得不编写多个java文件和部署文件，他是一种重量级的容器。也许你不了解ejb，你可能对“轻（重）量级”和“容器”比较陌生，那么这里我简单介绍一下。

1、什么是容器

“萜鳌保 飧龈拍罾 盼液镁谩４友 ?tomcat开始就一直对此感到困惑。感性的来讲，容器就是可以用来装东西的物品。那么在编程领域就是指用来装对象（oo的思想，如果你连oo都不了解，建议你去学习oo先）的对象。然而这个对象比较特别，它不仅要容纳其他对象，还要维护各个对象之间的关系。这么讲可能还是太抽象，来看一个简单的例子：

代码片断1：

public class container  
{ 
    public void init() 
    { 
    speaker s = new speaker(); 
    greeting g = new greeting(s); 
    } 
}

可以看到这里的container类（容器）在初始化的时候会生成一个speaker对象和一个greeting对象，并且维持了它们的关系，当系统要用这些对象的时候，直接问容器要就可以了。这就是容器最基本的功能，维护系统中的实例（对象）。如果到这里你还是感到模糊的话，别担心，我后面还会有相关的解释。

2、轻量级与重量级

所谓“重量级”是相对于“轻量级”来讲的，也可以说“轻量级”是相对于重量级来讲的。在spring出现之前，企业级开发一般都采用ejb，因为它提供的事务管理，声明式事务支持，持久化，分布计算等等都“简化”了企业级应用的开发。我这里的“简化”打了双引号，因为这是相对的。重量级容器是一种入侵式的，也就是说你要用ejb提供的功能就必须在你的代码中体现出来你使用的是ejb，比如继承一个接口，声明一个成员变量。这样就把你的代码绑定在ejb技术上了，而且ejb需要jboss这样的容器支持，所以称之为“重量级”。

相对而言“轻量级”就是非入侵式的，用spring开发的系统中的类不需要依赖spring中的类，不需要容器支持（当然spring本身是一个容器），而且spring的大小和运行开支都很微量。一般来说，如果系统不需要分布计算或者声明式事务支持那么spring是一个更好的选择。

二、几个核心概念

在我看来spring的核心就是两个概念，反向控制（ioc），面向切面编程（aop）。还有一个相关的概念是pojo，我也会略带介绍。

1、pojo

我所看到过的pojo全称有两个，plain ordinary java object，plain old java object，两个差不多，意思都是普通的java类，所以也不用去管谁对谁错。pojo可以看做是简单的javabean（具有一系列getter，setter方法的类）。严格区分这里面的概念没有太大意义，了解一下就行。

2、ioc

ioc的全称是inversion of control，中文翻译反向控制或者逆向控制。这里的反向是相对ejb来讲的。ejb使用jndi来查找需要的对象，是主动的，而spring是把依赖的对象注入给相应的类（这里涉及到另外一个概念“依赖注入”，稍后解释），是被动的，所以称之为“反向”。先看一段代码，这里的区别就很容易理解了。

代码片段2：

public void greet() 
{ 
speaker s = new speaker(); 
s.sayhello(); 
}

代码片段3：

public void greet() 
{ 
speaker s = (speaker)context.lookup("ejb/speaker"); 
s.sayhello(); 
}

代码片段4：

public class greeting  
{ 
    public speaker s; 
    public greeting(speaker s) 
    { 
        this.s = s; 
    } 
    public void greet() 
    { 
        s.sayhello(); 
    } 
}

我们可以对比一下这三段代码。其中片段2是不用容器的编码，片段3是ejb编码，片段4是spring编码。结合代码片段1，你能看出来spring编码的优越之处吗？也许你会觉得spring的编码是最复杂的。不过没关系，我在后面会解释spring编码的好处。

这里我想先解释一下“依赖注入”。根据我给的例子可以看出，greeting类依赖speaker类。片段2和片段3都是主动的去获取speaker，虽然获取的方式不同。但是片段4并没有去获取或者实例化speaker类，而是在greeting函数中直接使用了s。你也许很容易就发现了，在构造函数中有一个s被注入（可能你平时用的是，传入）。在哪里注入的呢？请回头看一下代码片段1，这就是使用容器的好处，由容器来维护各个类之间的依赖关系（一般通过setter来注入依赖，而不是构造函数，我这里是为了简化示例代码）。greeting并不需要关心speaker是哪里来的或是从哪里获得speaker，只需要关注自己分内的事情，也就是让speaker说一句问候的话。

3、aop

aop全称是aspect-oriented programming，中文翻译是面向方面的编程或者面向切面的编程。你应该熟悉面向过程的编程，面向对象的编程，但是面向切面的编程你也许是第一次听说。其实这些概念听起来很玄，说到底也就是一句话的事情。

现在的系统往往强调减小模块之间的耦合度，aop技术就是用来帮助实现这一目标的。举例来说，假如上文的greeting系统含有日志模块，安全模块，事务管理模块，那么每一次greet的时候，都会有这三个模块参与，以日志模块为例，每次greet之后，都要记录下greet的内容。而对于speaker或者greeting对象来说，它们并不知道自己的行为被记录下来了，它们还是像以前一样的工作，并没有任何区别。只是容器控制了日志行为。如果这里你有点糊涂，没关系，等讲到具体spring配置和实现的时候你就明白了。

假如我们现在为greeting系统加入一个valediction功能，那么aop模式的系统结构如下：

gretting

valedition

日志 安全 事务

这些模块是贯穿在整个系统中的，为系统的不同的功能提供服务，可以称每个模块是一个“切面”。其实“切面”是一种抽象，把系统不同部分的公共行为抽取出来形成一个独立的模块，并且在适当的地方（也就是切入点，后文会解释）把这些被抽取出来的功能再插入系统的不同部分。

从某种角度上来讲“切面”是一个非常形象的描述，它好像在系统的功能之上横切一刀，要想让系统的功能继续，就必须先过了这个切面。这些切面监视并拦截系统的行为，在某些（被指定的）行为执行之前或之后执行一些附加的任务（比如记录日志）。而系统的功能流程（比如greeting）并不知道这些切面的存在，更不依赖于这些切面，这样就降低了系统模块之间的耦合度。

三、spring初体验

这一节我用一个具体的例子greeting，来说明使用spring开发的一般流程和方法，以及spring配置文件的写法。

首先创建一个speaker类，你可以把这个类看做是pojo。

代码片段5：

public class speaker  
{ 
    public void sayhello() 
    { 
        system.out.println("hello!"); 
    } 
}

再创建一个greeting类。

代码片段6：

public class greeting  
{ 
    private speaker speaker; 
    public void setspeaker(speaker speaker) 
    { 
        this.speaker = speaker; 
    } 
    public void greet() 
    { 
        speaker.sayhello(); 
    } 
}

然后要创建一个spring的配置文件把这两个类关联起来。

代码片段7（applicationcontext.xml）：

"1.0" encoding="utf-8"?> 
"-//spring//dtd bean//en"  
    "http://www.springframework.org/dtd/spring-beans.dtd"> 
  

    <bean id="speaker" class="speaker"> 
    <bean id="greeting" class="greeting"> 
        <property name="speaker"> 
            <ref bean="speaker"/>

要用spring framework必须把spring的包加入到classpath中，我用的是eclipse+myeclipse，这些工作是自动完成的。推荐用spring的配置文件编辑器来编辑，纯手工编写很容易出错。我先分析一下这个xml文件的结构，然后再做测试。从节点开始，先声明了两个，第二个bean有一个speaker属性（property）要求被注入，注入的内容是另外一个bean speaker。这里的命名是符合javabean规范的，也就是说如果是speaker属性，那么spring容器就会调用setspeaker()来注入这个属性。是reference的意思，表示引用另外一个bean。

下面看一段简单的测试代码：

代码片段8：

public static void main(string[] args)  
{ 
        applicationcontext context =  
            new classpathxmlapplicationcontext("applicationcontext.xml"); 
        greeting greeting = (greeting)context.getbean("greeting"); 
        greeting.greet(); 
}

这段代码很简单，如果你上文都看懂了，那么这里应该没有问题。值得注意的是spring有两种方式来创建容器（我们不再用上文我们自己编写的container），一种是applicationcontext，另外一种是beanfactory。applicationcontext更强大一些，而且使用上两者没有太大区别，所以一般说来都用applicationcontext。spring容器帮助我们维护我们在配置文件中声明的bean以及它们之间的依赖关系，我们的bean只需要关注自己的核心业务。

四、面向接口的编程

看了这么多，也许你并没有觉得spring给开发带来了很多便利。那是因为我举的例子还不能突出spring的优越之处，接下来我将通过接口编程来体现spring的强大。

假如现在要求扩展greeting的功能，要让speaker用不同的语言来问候，也就是说有不同的speaker，比如chinesespeaker, englishspeaker。那么对上文提到的三种编码方式（代码片段2、3、4）分别加以修改，你会发现很麻烦。假如下次又要加入一个西班牙语，又得重复劳动。很自然的会考虑到使用一个ispeaker接口来简化工作,，更改后的代码如下（这里没有列出接口的相关代码，我想你应该明白怎么写）：

代码片段9：

public void greet() 
{ 
ispeaker s = new chinesespeaker(); 
s.sayhello(); 
}

代码片段10：

public void greet() 
{ 
ispeaker s = (ispeaker)context.lookup("ejb/chinesespeaker"); 
s.sayhello(); 
}

代码片段11：

public class greeting  
{ 
    public ispeaker s; 
    public greet(ispeaker s) 
    { 
        this.s = s; 
    } 
    public void greet() 
    { 
        s.sayhello(); 
    } 
}

对比三段代码，你会发现，第一种方法还是把具体的speaker硬编码到代码中了，第二中方法稍微好一点，但是没有本质改变，而第三种方法就不一样了，代码中并没有关于具体speaker的信息。也就是说，如果下次还有什么改动的话，第三种方法的greeting类是不需要修改，编译的。根据上文spring的使用介绍，只需要改动xml文件就能给greeting注入不同的speaker了，这样代码的扩展性是不是提高了很多？

关于spring的接口编程还有很多东西可以去挖掘，后文还会提到有关spring proxy的接口编程，我这里先介绍这么多，有兴趣话可以去google更多的资料。

五、应用spring中的切面

spring生来支持aop，首先来看几个概念：

1、切面（aspect）：切面是系统中抽象出来的的某一个功能模块，上文已经有过介绍，这里不再多说。

2、通知（advice）：通知是切面的具体实现。也就是说你的切面要完成什么功能，具体怎么做就是在通知里面完成的。这个名称似乎有点让人费解，等后面看了代码就明白了。

3、切入点（pointcut）：切入点定义了通知应该应用到系统的哪些地方。spring只能控制到方法（有的aop框架可以控制到属性），也就是说你能在方法调用之前或者之后选择切入，执行额外的操作。

4、目标对象（target）：目标对象是被通知的对象。它可以是任何类，包括你自己编写的或者第三方类。有了aop以后，目标对象就只需要关注自己的核心业务，其他的功能，比如日志，就由aop框架支持完成。

5、代理（proxy）：简单的讲，代理就是将通知应用到目标对象后产生的对象。spring在运行时会给每个目标对象生成一个代理对象，以后所有对目标对象的操作都会通过代理对象来完成。只有这样通知才可能切入目标对象。对系统的其他部分来说，这个过程是透明的，也就是看起来跟没用代理一样。

我为了简化，只介绍这5个概念。通过这几个概念应该能够理解spring的切面编程了。如果需要深入了解spring aop的话再去学习其他概念也很快的。

下面通过一个实际的例子来说明spring的切面编程。继续上文greeting的例子，我们想在speaker每次说话之前记录speaker被调用了。

首先创建一个logadvice类：

代码片段12：

public class logadvice implements methodbeforeadvice  
{ 
    public void before(method arg0, object[] arg1, object arg2)throws throwable  
    { 
        system.out.println("speaker called!"); 
    } 
}

这里涉及到一个类，methodbeforeadvice，这个类是spring类库提供的，类似的还有afterreturningadvice等等，从字面就能理解它们的含义。先不急着理解这个类，我稍后解释。我们继续看如何把这个类应用到我们的系统中去。

代码片段13：

<bean id="speaker" class="speaker"/> 
    <bean id="greeting" class="greeting"> 
        <property name="speaker"> 
            <ref bean="speakerproxy"/> 
         
     
    <bean id="logadvice" class="logadvice"/> 
    <bean id="speakerproxy" class="org.springframework.aop.framework.proxyfactorybean"> 
        <property name="proxyinterfaces"> 
            ispeaker 
         
        <property name="interceptornames"> 
             
                logadvice 
             
         
        <property name="target"> 
            <ref local="speaker"/>

可以看到我们的配置文件中多了两个bean，一个logadvice，另外一个speakerproxy。logadvice很简单。我着重分析一下speakerproxy。这个bean实际上是由spring提供的proxyfactorybean实现。下面定义了三个依赖注入的属性。

1、proxyinterfactes：这个属性定义了这个proxy要实现哪些接口，可以是一个，也可以是多个（多个的话，要用list标签）。我前面讲过proxy是在运行是动态创建的，那么这个属性就告诉spring创建这个proxy的时候实现哪些接口。

2、interceptornames：这个属性定义了proxy被切入了哪些通知，这里只有一个logadvice。

3、target：这个属性定义了被代理的对象。在这个例子中target是speaker。

这样的定义实际上约束了被代理的对象必须实现一个接口，这与上文讲的面向接口的编程有点类似。其实可以这样理解，接口的定义可以让系统的其他部分不受影响，以前用ispeaker接口来调用，现在加入了proxy还是一样的。但实际上内容已经不一样了，以前是speaker，现在是一个proxy。而target属性让proxy知道具体的方法实现在哪里。proxy可以看作是target的一个包装。当然spring并没有强制要求用接口，通过cglib（一个高效的代码生成开源类库）也可以直接根据目标对象生成子类，但这种方式并不推荐。

我们还像以前一样的测试我们的greeting系统，测试代码和代码片段8是一样的。运行结果如下：

speaker called!

hello!

看到效果了吧！而且你可以发现，我们加入log功能并没有改变以前的代码，甚至测试代码都没有改变，这就是aop的魅力所在！我们更改的只是配置文件。

下面解释一下刚才落下的methodbeforeadvice。关于这个类我并不详细介绍，因为这涉及到spring中的另外一个概念“连接点（jointpoint）”，我详细介绍一个before这个方法。这个方法有三个参数arg0表示目标对象在哪个点被切入了，既然是methodbeforeadvice，那当然是在method之前被切入了。那么arg0就是表示的那个method。第二个参数arg1是method的参数，所以类型是object[]。第三个参数就是目标对象了，在greeting例子中arg2的类型实际上是speaker。

在greeting例子中，我们并没有指定目标对象的哪些方法要被切入，而是默认切入所有方法调用（虽然speaker只有一个方法）。通过自定义pointcut，可以控制切入点，我这里不再介绍了，因为这并不影响理解spring aop，有兴趣的话去google一下就知道了。