spring的IOC和AOP实现的设计模式

spring通常采用属性注入的IOC方式和AOP织入方式相结合实现依赖注入

同时使用强制代理方式，代理类或者接口。

这里又涉及到单例模式（注入的类或者接口在容器中只存在一个）、工厂模式（通过反射实现类实例化过程的公用化）、楼上所说的装饰模式属于AOP织入的一部分。

想了解spring先从IOC和AOP开始吧。

一、单例模式案例：

一般Singleton模式通常有三种形式:

第一种形式: 也是常用的形式。

public class Singleton {

private static Singleton instance = null;

private Singleton(){

//do something

}

public static Singleton getInstance(){

if(instance==null){

instance = new Singleton();

}

return instance;

}

}

第二种形式:

public class Singleton {

//在自己内部定义自己的一个实例，只供内部调用

private static Singleton instance = new Singleton();

private Singleton(){

//do something

}

//这里提供了一个供外部访问本class的静态方法，可以直接访问

public static Singleton getInstance(){

return instance;

}

}

第三种形式: 双重锁的形式。

public class Singleton {

private static Singleton instance = null;

private Singleton(){

//do something

}

public static Singleton getInstance(){

if(instance==null){

synchronized(Singleton.class){

if(null == instance){

instance = new Singleton();

}

}

}

return instance;

}

}//这个模式将同步内容下方到if内部，提高了执行的效率，不必每次获取对象时都进行同步，只有第一次才同步，创建了以后就没必要了。

二、IOC通过单例模式+工厂模式的实现

抽象类

Java代码 

package com.factory;   

   

import com.singleton.Singleton;   

   

public abstract class AbstractFactory {   

   

    public abstract Singleton createSingleton();   

}  

工厂类

Java代码 

package com.factory;   

   

import com.singleton.Singleton;   

   

public class Factory extends AbstractFactory{   

   

    @Override  

    public Singleton createSingleton() {   

        return Singleton.getInstance();   

    }   

   

}  

单例类

Java代码 

package com.singleton;   

   

public class Singleton {   

   

    private static Singleton instance = null;   

        

    public Singleton(){   

            

    }   

        

    public static synchronized Singleton getInstance(){   

        if(instance == null){   

            instance = new Singleton();   

        }   

        return instance;   

    }   

        

    public String testSingleton(){   

        return "Hello Singleton";   

    }   

}  

测试类

Java代码 

package com.test;     

import com.factory.Factory;   

import com.singleton.Singleton;   

public class Test {        

    public static void main(String[] args){   

        Factory factory = new Factory();   

        Singleton s = factory.createSingleton();   

        System.out.print(s.testSingleton());   

    }   

} 

三、代理案例

1.定义提供方法的接口

public interface IHello {

       

       public void hello(String name);

}

2.接口实现类

public class HelloSpeaker implements IHello {

  

       public void hello(String name) {

             

            System. out.println("实现类中的hello():" +"Hello " + name);

             

      }

}

3.定义静态代理类注入接口通过实现类实现方法

public class HelloProxy implements IHello {

       private IHello iHello ;

       public HelloProxy(IHello iHello) {

             super();

             this.iHello = iHello;

      }

       public void hello(String name) {

            System. out.println("代理类中的hello():" );

             iHello.hello(name);

      }

}

4.静态代理类测试main方法入口

public class ProxyDemo {

       public static void main(String[] args) {

             

            IHello iHello = new HelloProxy(new HelloSpeaker());

             

            iHello. hello("long");

             

      }

}

5.定义动态代理类减少代理类对接口的依赖

public class LogHandler implements InvocationHandler {

       private Object implClass ;

       public Object bind(Object implClass) {

             

             this.implClass = implClass;

             

             return Proxy.newProxyInstance(implClass.getClass().getClassLoader(),

                        implClass.getClass().getInterfaces(), this);

             

      }

       /**

       * 代理对象，这里面还可以改变原有的方法

       */

       public Object invoke(Object proxy, Method method, Object[] args)

                   throws Throwable {

            Object result = null;

             try {

                  System. out.println("添加日志" );

                  result = method.invoke( implClass, args);

            } catch (Exception e) {

                  e.printStackTrace();

            }

             return null ;

      }

}

6.动态代理类的测试主入口

public class ProxyDt {

       public static void main(String[] args) { 

             

           LogHandler logHandler = new LogHandler(); 

           IHello iHello = (IHello) logHandler.bind( new HelloSpeaker()); 

           iHello.hello( "long"); 

         

           }

}

四、利用ProxyFactory连接CGLIB简单实现AOP： 

加入包aopalliance.jar\cglib-nodep-2.1_3.jar demo：

view plaincopy to clipboardprint?

package cn.partner4java.proxy.proxyfactory;  

   

/** 

* 被代理的对象 

* @author partner4java 

* 

*/  

public class MessageWriter {  

    public void writeMessage(){  

        System.out.println("world!");  

    }  

}  

package cn.partner4java.proxy.proxyfactory;  

   

import org.aopalliance.intercept.MethodInterceptor;  

import org.aopalliance.intercept.MethodInvocation;  

   

/** 

* 装饰者 

* MethodInterceptor接口是对方法调用连接点实现包围通知的AOP联盟标准接口 

* @author partner4java 

* 

*/  

public class MessageDecorator implements MethodInterceptor{  

   

    public Object invoke(MethodInvocation invocation) throws Throwable {  

        System.out.print("Hello ");  

        Object retVal = invocation.proceed();  

        return retVal;  

    }  

   

}  

package cn.partner4java.proxy.proxyfactory;  

   

import org.springframework.aop.framework.ProxyFactory;  

   

/** 

* 调用组装 

* 这里最重要的部分是我们使用ProxyFactory来创建一个目标对象代理，同时织入通知  

* @author partner4java 

* 

*/  

public class HelloWorldWeaver {  

   

    public static void main(String[] args) {  

        //目标  

        MessageWriter target = new MessageWriter();  

           

        //create the proxy  

        ProxyFactory proxyFactory = new ProxyFactory();  

           

        proxyFactory.addAdvice(new MessageDecorator());  

        proxyFactory.setTarget(target);  

           

        //获取返回被代理的目标  

        MessageWriter proxy = (MessageWriter) proxyFactory.getProxy();  

           

        target.writeMessage();  

        System.out.println("---");  

        proxy.writeMessage();  

//      后台打印：  

//      world!  

//      ---  

//      Hello world!  

    }  

   

}