Spring IoC与AOP的核心思想

IoC和AOP都是Spring的核心思想

    当然，最为一个框架级的轻量组件，大量的配置文件是不可缺少的，但是核心是要把这些配置文件，配置节组装起来，并将核心代码编写为完全业务无关的。我们看看Spring是怎么做的。

    首先，IoC，控制反转。Spring 开发的基本思想：面向接口的编程模式。框架做的越多，应该越能发现接口在其中起到的作用，而Spring将这种想法，开始贯彻到业务的开发中了。Bean 的Set方法使用接口作为参数，保证其扩展性，实现依赖关系的松偶尔。所谓的控制反转，作为中文更好理解的一个翻译应该是依赖注入，把依赖的类采用接口的方式，利用Set函数，传入Bean的内部，实现与外界的解耦合。这种注入也可作用于构造函数。

    其次，AOP，面向切面的编程方式，我觉得更通俗的说法应该是对容器内的Bean进行方法干涉。被容器中创建的类，看起来执行一个普通的函数调用，因为被容器预处理，而会在方法执行前/后进行一些其他的、可配置的操作。当然，这种方法也同样是面向接口的，或者直接使用反射的。利用java.lang.reflect.InvocationHandler接口可以达到这种干涉的效果。下面是转载的一个简单示例。

   import java.lang.reflect.InvocationHandler;   
2. 4  import java.lang.reflect.Method;   
3. 5  import java.lang.reflect.Proxy;   
4. 6  
5. 7  public class DynaProxyHello implements InvocationHandler {   
6. 8      
7.11    private Object proxy;   
8.12      
9.15    private Object delegate;   
10.16  
11.17      
12.24    public Object bind(Object delegate,Object proxy) {   
13.25           
14.26        this.proxy = proxy;   
15.27        this.delegate = delegate;   
16.28        return Proxy.newProxyInstance(   
17.29                this.delegate.getClass().getClassLoader(), this.delegate   
18.30                        .getClass().getInterfaces(), this);   
19.31    }   
20.32      
21.36    public Object invoke(Object proxy, Method method, Object[] args)   
22.37            throws Throwable {   
23.38        Object result = null;   
24.39        try {   
25.40            //反射得到操作者的实例   
26.41            Class clazz = this.proxy.getClass();   
27.42            //反射得到操作者的Start方法   
28.43            Method start = clazz.getDeclaredMethod("start",   
29.44                    new Class[] { Method.class });   
30.45            //反射执行start方法   
31.46            start.invoke(this.proxy, new Object[] { method });   
32.47            //执行要处理对象的原本方法   
            result = method.invoke(this.delegate, args);   
//            反射得到操作者的end方法   
            Method end = clazz.getDeclaredMethod("end",   
                    new Class[] { Method.class });   
//            反射执行end方法   
            end.invoke(this.proxy, new Object[] { method });   
  
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
        return result;   
    }   
  
}   
  
       
  
 public class Test {   
    public static void main(String[] args) {   
        IHello hello = (IHello)new DynaProxyHello().bind(new Hello(),new    LoggerOperation());   
        hello.sayGoogBye("Double J");   
        hello.sayHello("Double J");   
           
    }   
}  

     当然，不是只有这一个实现方式，java的代理功能只能代理接口，如果要代理类的化，可以使用cglib。

    Spring框架当然不会是上述的那么简单（实际上它非常复杂），不过我关注的是核心的实现方式和设计思想。在有些时候，我们不需要使用Spring，甚至不能使用Spring（比如不用Java开发），但是这种思想和方式是可以复用的。使用这种设计思想，按照当前的语言和环境要求，实现自己的IoC和 AOP框架。