这段时间，看了一些Spring文档和资料，对其有了一个基本的了解。Spring的核心技术由两大部分组成：IoC和AOP，下面我们就分别对它们进行介绍。
1  IoC技术
1.1  预备知识
    IoC即Inversion of Control（控制反转）的简写，它是一种设计模式，Spring只不过是实现了该模式。IoC是工厂模式的升华，同时涉及到了反射的概念。所以，在正式介绍IoC之前，首先介绍一下几个基本的概念及技术：接口、工厂模式、反射。
1.1.1  接口
    作为面向对象的语言，和C++不同的是，JAVA不支持多重继承，即一个子类只能继承自一个父类，像Son extends FatherA,FatherB 是错误的。于是产生了接口这个概念，即JAVA可以实现多个接口，比如：Son extends FatherA implements FatherB, FatherC是允许的。接口的主要特征包括：
    A、其中的方法均没有实体（即只声名未实现），就这一点而言就相当于abstact class，如：
interface ITF
  {
    void func(int i);
  }
上例中，ITF是一个接口，它仅仅声明了一个方法func，而没有具体实现它。
    B、一个类欲实现某接口，则必须实现该接口内的所有方法。例如： 字串5
class aclass implements ITF
  {
    public void func (int i)
      {
        //在这里你可以不作任何处理，但是必须实现该方法
      }
  }
    C、一个类可以实现多个接口。
    D、接口没有实例变量。
    E、接口中所有变量都必须被定义为final static。
    F、接口可以继承多个接口。
    以上只是接口的几个典型特征，与其相关的内容还有很多，如果您想对其有更深的理解，请访问其他相关资源。
1.1.2  工厂模式
    工厂模式是最常用的设计模式之一（我对所谓的设计模式没有仔细研究过，该模式是我看到次数最多的一个，所以才这么说，呵呵）。今天看了一些例子，觉得工厂模式这个名字起得相当有创意，这是因为在该模式中，"工厂"、"车间"、"原料"、"加工设备"、"原型产品"、"产品"等概念样样俱全。下面，我们在一个经典例子的基础上，引用上述概念，对工厂模式进行较为形象的解释。
    现在我们模拟一个火腿（Ham）加工厂，该工厂可以生产若干种类型的Ham，在该厂中，上述概念可依次描述如下：
字串8


A、"原型产品"：即"产品"的模型，该模型定义（但未实现）了各类"产品"必须要具备的功
能，各类"产品"对应的"加工设备"可根据该"产品"的特点实现这些功能。所以，在工厂模式中，"原型产品"可以用一个接口来表示：
Java代码
1. interface Ham   
2.   {   
3.     void show();//由Ham"加工设备"生产出的各种Ham将有show()的功能   
4.   } 
interface Ham
  {
    void show();//由Ham"加工设备"生产出的各种Ham将有show()的功能
  }


B、"工厂"：即包含了"车间"、加工所需的"原料"、"加工设备"、最终加工的"产品"等实体的
复合型实体。在工厂模式中，"工厂"可以用一个类来表示，"车间"可以用该类中的函数来表示，"原料"可以用该函数中的实参来表示，最终的"产品"可以用该函数的返回值来表示。在这里，"车间"远程调用了"加工设备"（即每种"产品"的构造函数）。下面是"工厂"类的具体实现代码：
Java代码
1. public class FatoryModule   
2. //"工厂"类，用于生产不同种类的Ham   
3.  {   
4.  
5.  
6.  
7.     public Ham getHam(String HamType) throws Exception   
8.     //"工厂"中加工java核心技术有哪些Ham的"车间"；HamType为该"车间"中的"原料"   
9.       {   
10.         if (HamType.equals("HamA"))   
11.           {   
12.             return new HamA();//根据不同的"原料"得到不同的"产品"，下同   
13.           }   
14.         if (HamType.equals("HamB"))   
15.           {   
16.             return new HamB();   
17.           }   
18.         if (HamType.equals("HamC"))   
19.           { 字串8    
20.             return new HamC();   
21.           }   
22.         else 
23.             throw new Exception();           
24.       }   
25.     public static void main(String[] args)   
26.     //测试函数   
27.       {   
28.         FatoryModule fatorymodule = new FatoryModule();   
29.         try     
30.  {   
31.             Ham myHam =&Ham(args[0]);           
32.             myHam.show();//实际上调用的是args[0]所对应某类具体产品的show()   
33.           }   
34.         catch (Exception ex)   
35.           {   
36.             ex.printStackTrace();   
37.           }   
38.       }   
39.   } 
public class FatoryModule
//"工厂"类，用于生产不同种类的Ham
{
    public Ham getHam(String HamType) throws Exception
    //"工厂"中加工Ham的"车间"；HamType为该"车间"中的"原料"
      {
        if (HamType.equals("HamA"))
          {
            return new HamA();//根据不同的"原料"得到不同的"产品"，下同
          }
        if (HamType.equals("HamB"))
          {
            return new HamB();
          }
        if (HamType.equals("HamC"))
          { 字串8
            return new HamC();
          }
        else
            throw new Exception();       
      }
    public static void main(String[] args)
    //测试函数
      {
        FatoryModule fatorymodule = new FatoryModule();
        try 
{
            Ham myHam = Ham(args[0]);       
            myHam.show();//实际上调用的是args[0]所对应某类具体产品的show()
          }
        catch (Exception ex)
          {
            ex.printStackTrace();
          }
      }
  }

   
C、"产品"：即"原型产品"的模型实现实体。"车间"根据具体的"原料"调用对应的"加工设备"来实现"原型产品"定义的所有功能，最后得到所需的"产品"。所以，"产品"可以用一个类来表示，具体代码如下：
Java代码
1. class HamA implements Ham   
2. // "产品"HamA   
3.   {   
4.     public void show()   
5.       {   
6.         System.out.println("You got a HamA.");   
7.       }   
8.   }   
9. class HamB implements Ham   
10. // "产品"HamB   
11.   {   
12.     public void show()   
13.       {   
14.         System.out.println("You got a HamB.");   
15.       }   
16.   }   
17. class HamC implements Ham   
18. // "产品"HamC   
19.   {   
20.     public void show()   
21.       {   
22.         System.out.println("You got a HamC.");   
23.       }   
24.   } 
class HamA implements Ham
// "产品"HamA
  {
    public void show()
      {
        System.out.println("You got a HamA.");
      }
  }
class HamB implements Ham
// "产品"HamB
  {
    public void show()
      {
        System.out.println("You got a HamB.");
      }
  }
class HamC implements Ham
// "产品"HamC
  {
    public void show()
      {
        System.out.println("You got a HamC.");
      }
  }
   

小结：总体感觉工厂模式是接口的典型应用。该模式最大特点是方便我们"加工"指定参数条件下的产品。以上述情况为例，假如我们不采用该模式的话，要得到一种产品就必须new一个该产品类的实例，而且在程序中不同产品类的实例变量不能采用同一个变量名。假如有一天我们想更换某一类产品的名字，考虑到程序的可读性，该类产品的实例变量名也需要修改，这个工作量也需会很大（所有涉及到该变量名的地方都需要修改）。从这一点来讲，工厂模式能够减轻我们代码维护量。

1.1.3  反射（主要应用于Spring的四种Bean封装机制中的Bean Wrapper机制）
    反射是java的一种非常有趣且有用的特征，而且也是Java被视为动态（或准动态）语言的一个非常关键的性质。该机制允许java程序在运行时通过Reflection APIs（flect.*）取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（如Object等）、所实现的interfaces（如Cloneable等），以及fields和methods的所有信息，并可在程序运行时改变fields的内容或唤起methods。其实，反射的最重要作用就是允许我们通过类（方法）名调用类（方法）。
    更具体的内容请看候捷先生的文章："Java反射机制"，具体网址为：www.j2medev/Article/Class3/Class7/200604/1995.html。如果您想在短时间内对java的反射机制有一个大体的了解，请看一个网友的一篇博客："java的reflect机制（反射）"，网址为：jackleliu.spaces.live/blog/cns!。



1.2  正式进入IoC
    IoC实际上是一个高层次的概念，是一种思想或者设计模式，Spring等J2EE框架或者技术只不过是该思想的实现产品。简单的来讲，IoC要求我们利用容器，而不是我们自己编写的代码去控制系统中应用程序之间的关系。即对应用程序之间的关系由原来的手工编码控制转换为利用容器控制。所以，我们把这种思想叫做控制反转（IoC）。
    IoC有多种实现方法，其中，Spring是通过一种名为DI（Dependency Injection，即依赖注入）的方法实现的。用夏昕先生的话来讲，"所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，形象的来说，即由容器动态的将某种依赖关系注入到组件之中。"在Spring中，上面所说的容器一般是一种配置文件（.Xml等类型的文件）。
    通过使用DI，当组件之间关系发生变化时，我们只需要修改系统中相关的配置文件，不需要改动我们的代码，这既减少了我们的程序维护量，又提高了我们程序的可重用性。
    DI主要有三种实现方式：接口注入、设值注入、构造子注入，下面分别加以介绍：
1.2.1  接口注入
    该方式利用接口将调用组件和实现组件相分离。请看下面的代码：

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。