Spring AOP 代理模式

来源：互联网发布：清华大学c语言教材编辑：程序博客网时间：2024/05/21 10:37

Spring 为解耦而诞生，其中AOP（面向切面编程）是很浓重的一笔。

这里简单记录一下AOP 给我带来的好处：

用了一段时间，想通过简单的代码，更好的阐述以及理解它。

以前：假设我们有个简单的业务，还是经典的Hello World,那么我们定义一个Service 接口，一个ServiceImpl 实现类，一个sayHello 方法，这里使用网上很经典的日志记录的例子。

1.Service接口：定义一个sayHello 的业务方法

Java代码  
public interface Service {  
    public void sayHello();  
}  

2.ServiceImpl实现类：主要是打印HelloWord,但是日常项目中，在主要业务前后可能会添加日志记录，或者开启事务等其他必要操作。

Java代码  
public class ServiceImpl implements Service{  
  
    @Override  
    public void sayHello() {  
        System.out.println("前置日记：打印、启动事务等..");  
        System.out.println("Hello world!");  
        System.out.println("后置日记：打印、关闭事务等..");  
    }  
}  

例子很简单，那么假设，我们不光拥有sayHello ,还有sayBye 等多个方法，并且都需要其他操作呢？那么你是不是会写很多个这样的，重复的代码？

当然，你可以减少一部分工作量，你可以这样：

Java代码  
public class ServiceImpl implements Service{  
  
    @Override  
    public void sayHello() {  
        before();  
        System.out.println("Hello world!");  
        after();  
    }  
  
    @Override  
    public void sayBye() {  
        before();  
        System.out.println("Bye bye!");  
        after();  
    }  
      
    public static void before(){  
        System.out.println("前置日记：打印、启动事务等..");  
    }  
      
    public static void after(){  
        System.out.println("后置日记：打印、关闭事务等..");  
    }  
}  

我们再次假设，如果我们拥有更多的业务方法：sayHi(),sayOther()....，需要更多的其他操作：打印信息，传输记录....。并且其他ServiceImpl 里面的方法也需要这些方法呢？那么我们是不是每个类又要继续添加呢？

当然，你可以这样做：建立一个对Service 添加额外功能的类，统一提供。

Java代码  
public class ServiceFactory {  
    public static void before(){  
        System.out.println("前置日记：打印、启动事务等..");  
    }  
      
    public static void after(){  
        System.out.println("后置日记：打印、关闭事务等..");  
    }  
      
    public static void other(){  
        System.out.println("做其他的事..");  
    }  
}  

ServiceImpl 就成这样：

Java代码  
public class ServiceImpl implements Service{  
  
    @Override  
    public void sayHello() {  
        ServiceFactory.before();  
        System.out.println("Hello world!");  
        ServiceFactory.after();  
    }  
  
    @Override  
    public void sayBye() {  
        ServiceFactory.before();  
        System.out.println("Bye bye!");  
        ServiceFactory.after();  
    }  
  
    @Override  
    public void sayHi() {  
        ServiceFactory.before();  
        System.out.println("Hi");  
        ServiceFactory.after();  
          
        ServiceFactory.other();  
    }  
}  

这样代码，感觉是少了一些，但是我们的原则是尽量别重复同样的代码，提高代码的复用性，改动最小为基准。也许业务很复杂，比较多，那么你要重复多少代码，整个类要写得多麻烦所啊！如果到时候有些假设before 和after 需要变化位置，你又要改动多少呢？

当然，目前的的JDK （大于1.3）为了解决这些问题，为我们提供的反射机制，动态代理机制。看看如何更好的解决这个问题。这里先copy 下，什么是代理：

Java的动态代理机制
代理模式是常用的Java设计模式。代理类主要负责为委托类预处理消息、过滤信息、把消息转发给委托类，以及事后处理信息等。
理论 - -总是那么抽象（~。~），简单点说，就是：1.我的目的是去学校，那么校服　早餐校车，这些我都需要，但是不由我做，全部代理给我父母搞定了（当然我是自己搞定的。）2.再简单的说就是：我只关注我主要的事情，其他附加的事情，全部交给别人搞定。看代码..

MyPorxy 我的代理类：

Java代码  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
  
  
public class MyProxy implements InvocationHandler{  
      
    // 目标对象，也就是我们主要的业务，主要目的要做什么事  
    private Object delegate;  
      
    /** 
     * 和你额外需要做得事情，进行绑定，返回一个全新的对象（写法，基本上固定的） 
     * @param delegate 
     * @return 
     */  
    public Object bind(Object delegate){  
        this.delegate = delegate;  
        return Proxy.newProxyInstance(this.delegate.getClass().getClassLoader(),   
                this.delegate.getClass().getInterfaces(), this);  
    }  
      
    /** 
     * 你刚才需要执行的方法，都需要通过该方法进行动态调用 
     */  
    @Override  
    public Object invoke(Object proxy, Method method, Object[] args)  
            throws Throwable {  
        Object obj = null;  
        // 执行前置的方法  
        ServiceFactory.before();  
        // 通过反射，执行目标方法，也就是你的主要目的  
        obj = method.invoke(this.delegate, args);  
        // 执行后置的方法  
        ServiceFactory.after();  
        // 返回值给调用者  
        return obj;  
    }  
  
}  

这里运用的反射知识，还需要去看看，这里就不解释了。

ServiceImpl 变化：

Java代码  
public class ServiceImpl implements Service{  
  
    @Override  
    public void sayHello() {  
        System.out.println("Hello world!");  
    }  
  
    @Override  
    public void sayBye() {  
        System.out.println("Bye bye!");  
    }  
  
    @Override  
    public void sayHi() {  
        System.out.println("Hi");  
    }  
}  

测试类：

Java代码  
public class Test {  
  
    /** 
     * 测试类 
     * @param args 
     */  
    public static void main(String[] args) {  
        // 不启用代理  
        //Service service = new ServiceImpl();  
        // 使用代理  
        Service service = (Service)new MyProxy().bind(new ServiceImpl());  
          
        service.sayHello();  
        service.sayBye();  
        service.sayHi();  
    }  
}  

OK，那么你现在看看，我们的业务实现类ServiceImpl 是不是干净多了，代码是不是在某些地方见过呢？即时你再进行添加更多的方法，也可以同样实现了对吗？当然，在Test里面，假设我们有的方法想用，有的方法不想用，那么又该怎么实现呢？

0 0