spring学习

学习spring的过程，发现主要掌握3个概念，之后再根据实例做一个小程序，就基本入门了。

三个概念分别为AOP，IoC，和DI。

1、IoC(Inversion of control )反转控制

       先看IoC的概念。IoC，Inversion of Control，控制反转，其原理是基于OO设计原则的The Hollywood Principle：Don't call us, we'll call you。也就是说，所有的组件都是被动的（Passive），所有的组件初始化和调用都由容器负责。组件处在一个容器当中，由容器负责管理。

 

       然看举个例子看看IoC在Spring框架里是怎么实现的。所谓IoC就是一个用XML来定义生成对象的模式，我们看看如果来使用的。

要说明IoC模式最好的方法是使用代码。下边是一段正常的代码。

class ClassA...

public String aMethod(String arg){

    String result = instanceOfClassB.bMethod();

    do something;

    return result;

}

在上边的代码里，我们要解决的问题是：ClassA如何获得ClassB的实例？一个最直接的方法是在aMethod里声明：

IClassB instanceOfClassB = new ClassB();

这里使用了一个接口IClassB。

问题是，如果出现这样的情况：继续使用ClassA，但要求用IClassB的另一个实现ClassB2代替ClassB呢？更概括一点说：ClassA怎样才能找到IClassB的具体实现？很明显，上述代码增加ClassA和ClassB的耦合度，以致于无法在不修改ClassA的情况下变更IClassB的具体实现。

IoC模式就是用于解决这样的问题。当然，还有其他的方法，比如Service Locator模式，但现在我们只关注IoC。如前所述，IoC容器负责初始化组件（如IClassB），并将实例交给使用者。使用代码或配置文件以声明的方式将接口与实例关联起来，IoC容器负责进行实际的调用处理。对于调用者，只需要关注接口就行了。

根据实例传入方式的不同，IoC分为type 1 IoC（接口注入）、type 2 IoC（设值方法注入）和type 3 IoC（构造子注入）。分别用代码说明如下：

type 1 IoC（接口注入）

public interface GetClassB {

void getClassB(IClassB instanceOfClassB);

}

 

class ClassA implements GetClassB…

IClassB instanceOfClassB;

void getClassB(IClassB instanceOfClassB) {

this.instanceOfClassB = instanceOfClassB;

}

type 2 IoC（设值方法注入）

class ClassA...

IClassB instanceOfClassB;

public void setFinder(IClassB instanceOfClassB) {

    this.instanceOfClassB = instanceOfClassB;

}

type 3 IoC（构造子注入）

class ClassA…

ClassB instanceOfClassB;

public classA(IClassB instanceOfClassB) {

    this. instanceOfClassB = instanceOfClassB;

}

　　Spring使用的是type 2 IoC。

2、DI(Dependecy Injection)代码注入

    根据实例传入方式的不同，IoC分为type 1 IoC（接口注入）、type 2 IoC（设值方法注入）和type 3 IoC（构造子注入）。在spring里的是IOC的第二种，即设置方法注入。具体例子可以查看http://zhaoshg.iteye.com/blog/724202（Spring 依赖注入原理学习）

3、AOP(Aspect-Oriented Programming)面向方面的编程

        要理解AOP的原理，先看这篇文章，文章不长，通过例子通俗易懂的解释了AOP概念的来源以及JAVA的代理机制。

http://zhaoshg.iteye.com/blog/724205

        通过上文链接的文章，我们知道了在SPRING的AOP中，IoC功能用来对JAVA动态代理进行改进。来看一个例子。

        使用AOP，你可以将处理aspect的代码注入主程序，通常主程序的主要目的并不在于处理这些aspect。AOP可以防止代码混乱。
        为了理解AOP如何做到这点，考虑一下记日志的工作。日志本身不太可能是你开发的主程序的主要任务。如果能将“不可见的”、通用的日志代码注入主程序中，那该多好啊。AOP可以帮助你做到。
Spring framework是很有前途的AOP技术。作为一种非侵略性的，轻型的AOP framework，你无需使用预编译器或其他的元标签，便可以在Java程序中使用它。这意味着开发团队里只需一人要对付AOP framework，其他人还是象往常一样编程。
    AOP是很多直觉难以理解的术语的根源。幸运的是，你只要理解三个概念，就可以编写AOP模块。这三个概念是：advice，pointcut和 advisor。advice是你想向别的程序内部不同的地方注入的代码。pointcut定义了需要注入advice的位置，通常是某个特定的类的一个 public方法。advisor是pointcut和advice的装配器，是将advice注入主程序中预定义位置的代码。

    既然我们知道了需要使用advisor向主要代码中注入“不可见的”advice，让我们实现一个Spring AOP的例子。在这个例子中，我们将实现一个before advice，这意味着advice的代码在被调用的public方法开始前被执行。以下是这个before advice的实现代码：

代码:
package com.company.springaop.test;

import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;

public class TestBeforeAdvice implements MethodBeforeAdvice {

   public void before(Method m, Object[] args, Object target)
   throws Throwable {
     System.out.println("Hello world! (by "
         + this.getClass().getName()
         + ")");
   }
}



    接口MethodBeforeAdvice只有一个方法before需要实现，它定义了advice的实现。before方法共用三个参数，它们提供了相当丰富的信息。参数Method m是advice开始后执行的方法。方法名称可以用作判断是否执行代码的条件。Object[] args是传给被调用的public方法的参数数组。当需要记日志时，参数args和被执行方法的名称，都是非常有用的信息。你也可以改变传给m的参数，但要小心使用这个功能；编写最初主程序的程序员并不知道主程序可能会和传入参数的发生冲突。Object target是执行方法m对象的引用。

在下面的BeanImpl类中，每个public方法调用前，都会执行advice：

代码:
package com.company.springaop.test;

public class BeanImpl implements Bean {

   public void theMethod() {
     System.out.println(this.getClass().getName()
         + "." + new Exception().getStackTrace()[0].getMethodName()
         + "()"
         + " says HELLO!");
   }
}


类BeanImpl实现了下面的接口Bean：

代码:
package com.company.springaop.test;

public interface Bean {
   public void theMethod();
}



虽然不是必须使用接口，但面向接口而不是面向实现编程是良好的编程实践，Spring也鼓励这样做。

pointcut和advice通过配置文件来实现，因此，接下来你只需编写主方法的Java代码：
代码:


package com.company.springaop.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Main {

   public static void main(String[] args) {
     //Read the configuration file
     ApplicationContext ctx
         = new FileSystemXmlApplicationContext("springconfig.xml");

     //Instantiate an object
     Bean x = (Bean) ctx.getBean("bean");

     //Execute the public method of the bean (the test)
     x.theMethod();
   }
}



    我们从读入和处理配置文件开始，接下来马上要创建它。这个配置文件将作为粘合程序不同部分的“胶水”。读入和处理配置文件后，我们会得到一个创建工厂ctx。任何一个Spring管理的对象都必须通过这个工厂来创建。对象通过工厂创建后便可正常使用。

仅仅用配置文件便可把程序的每一部分组装起来。
代码:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC   "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
   <!--CONFIG-->
   <bean id="bean" class="org.springframework.aop.framework.ProxyFactoryBean">
     <property name="proxyInterfaces">
       <value>com.company.springaop.test.Bean</value>
     </property>
     <property name="target">
       <ref local="beanTarget"/>
     </property>
     <property name="interceptorNames">
       <list>
         <value>theAdvisor</value>
       </list>
     </property>
   </bean>

   <!--CLASS-->
   <bean id="beanTarget" class="com.company.springaop.test.BeanImpl"/>

   <!--ADVISOR-->
   <!--Note: An advisor assembles pointcut and advice-->
   <bean id="theAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
     <property name="advice">
       <ref local="theBeforeAdvice"/>
     </property>
     <property name="pattern">
       <value>com\.company\.springaop\.test\.Bean\.theMethod</value>
     </property>
   </bean>

   <!--ADVICE-->
   <bean id="theBeforeAdvice" class="com.company.springaop.test.TestBeforeAdvice"/>
</beans>



    四个bean定义的次序并不重要。我们现在有了一个advice，一个包含了正则表达式pointcut的advisor，一个主程序类和一个配置好的接口，通过工厂ctx，这个接口返回自己本身实现的一个引用。

    BeanImpl和TestBeforeAdvice都是直接配置。我们用一个唯一的ID创建一个bean元素，并指定了一个实现类。这就是全部的工作。

    advisor通过Spring framework提供的一个RegexMethodPointcutAdvisor类来实现。我们用advisor的一个属性来指定它所需的 advice-bean。第二个属性则用正则表达式定义了pointcut，确保良好的性能和易读性。

    最后配置的是bean，它可以通过一个工厂来创建。bean的定义看起来比实际上要复杂。bean是ProxyFactoryBean的一个实现，它是Spring framework的一部分。这个bean的行为通过一下的三个属性来定义：


     * 属性proxyInterface定义了接口类。
     * 属性target指向本地配置的一个bean，这个bean返回一个接口的实现。
     * 属性interceptorNames是唯一允许定义一个值列表的属性。这个列表包含所有需要在beanTarget上执行的advisor。注意，advisor列表的次序是非常重要的。



Spring工具

    虽然你可以手工修改Ant构建脚本，但使用SpringUI（译注：SpringUI现在是Spring framework的一部分，并改名为spring-ide），使用Spring AOP变得很简单，只要点点鼠标即可。你可以把SpringUI安装成Eclipse的一个plug-in。然后，你只需在你的project上右击鼠标，并选择“add Spring Project Nature”。在project属性中，你可以在“Spring Project”下添加Spring配置文件。在编译前把下面的类库加入project：aopalliance.jar，commons- logging.jar，jakarta-oro-2.0.7.jar和spring.jar。运行程序时你会看到下面的信息：

... (logging information)
Hello world! (by com.company.springaop.test.TestBeforeAdvice)
com.company.springaop.test.BeanImpl.theMethod() says HELLO!


优点和缺点

    Spring比起其他的framework更有优势，因为除了AOP以外，它提供了更多别的功能。作为一个轻型framework，它在J2EE 不同的部分都可以发挥作用。因此，即使不想使用Spring AOP，你可能还是想使用Spring。另一个优点是，Spring并不要求开发团队所有的人员都会用它。学习Spring应该从Spring reference的第一页开始。读了本文后，你应该可以更好地理解Spring reference了。Spring唯一的缺点是缺乏更多的文档，但它的mailing list是个很好的补充，而且会不断地出现更多的文档。