AOP之Proxy技术实现AOP功能

AOP编程其实是很简单的事情，纵观AOP编程，程序员只需要参与三个部分：
1、定义普通业务组件
2、定义切入点，一个切入点可能横切多个业务组件
3、定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作

所以进行AOP编程的关键就是定义切入点和定义增强处理，一旦定义了合适的切入点和增强处理，AOP框架将自动生成AOP代理，即：代理对象的方法=增强处理+被代理对象的方法**
PersonServer.java

package liuyanxi.service;

public interface PersonService {
    public void save(String name);
    public void update(String name, Integer personid);
    public String getPersonName(Integer personid);
}

PersonServiceBean.java

package liuyanxi.service.impl;

import liuyanxi.service.PersonService;

public class PersonServiceBean implements PersonService{
    private String user = null;

    public String getUser() {
        return user;
    }

    public PersonServiceBean(){}

    public PersonServiceBean(String user){
        this.user = user;
    }

    public String getPersonName(Integer personid) {
        System.out.println("我是getPersonName()方法");
        return "xxx";
    }

    public void save(String name) {
        System.out.println("我是save()方法");
    }

    public void update(String name, Integer personid) {
        System.out.println("我是update()方法");
    }
}

JDKProxyFactory.java

package liuyanxi.aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import liuyanxie.impl.PersonServiceBean;

public class JDKProxyFactory implements InvocationHandler{
    private Object targetObject;

    public Object createProxyIntance(Object targetObject){
        this.targetObject = targetObject;
        return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(), 
                this.targetObject.getClass().getInterfaces(), this);
    }

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {//环绕通知
        PersonServiceBean bean = (PersonServiceBean) this.targetObject;
        Object result = null; 
        if(bean.getUser()!=null){
            //..... advice()-->前置通知
            try {
                result = method.invoke(targetObject, args);
                // afteradvice() -->后置通知
            } catch (RuntimeException e) {
                //exceptionadvice()--> 例外通知
            }finally{
                //finallyadvice(); -->最终通知
            }
        }
        return result;
    }
}

Test.java

package junit.test;
import org.junit.BeforeClass;
import org.junit.Test;

import liuyanxi.aop.CGlibProxyFactory;
import liuyanxi.aop.JDKProxyFactory;
import liuyanxi.service.PersonService;
import liuyanxi.service.impl.PersonServiceBean;

public class AOPTest {

    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
    }

    @Test public void proxyTest(){
        JDKProxyFactory factory = new JDKProxyFactory();
        PersonService service = (PersonService) factory.createProxyIntance(new PersonServiceBean("xxx"));
        service.save("888");
    }

    @Test public void proxyTest2(){
        CGlibProxyFactory factory = new CGlibProxyFactory();
        PersonServiceBean service = (PersonServiceBean) factory.createProxyIntance(new PersonServiceBean("xxx"));
        service.save("999");
    }
}

通过在代理对象设置切面拦截方法，管理目标对象，体现了java设计模式中的代理模式