spring学习之AOP基础

实现接口，使用代理对象完成AOP模拟

AOP在项目中主要实现权限的控制，包括细粒度和粗粒度的区分。对那些方法实施拦截，拦截之后干什么，就是属于横切性关注点。

主要通过代理模式来实现
–静态代理
–动态代理：通过JDK或第三方框架生成字节码，如Proxy。目标对性要实现代理的接口。

代码：

• 创建service和bean对象

package cn.gc.service;

public interface PersonService {
    public void save(String name);

    public void update(String name, String personId);

    public String getName(String personId);
}

package cn.gc.service;

public class PersonServiceBean implements PersonService {
    //拦截所有业务方法 
    //判断用户是否有权限 有(user不为null)则允许执行业务方法 无则不执行业务方法

    private String user = null;

    public String getUser() {
        return user;
    }

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

    @Override
    public String getName(String personId) {
        // TODO Auto-generated method stub
        return "XXX";
    }

    @Override
    public void save(String name) {
        // TODO Auto-generated method stub
        System.out.println("save方法");
    }

    @Override
    public void update(String name, String personId) {
        // TODO Auto-generated method stub
        System.out.println("update方法");
    }

}

• 代理模式创建代理对象

package cn.gc.aop;

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

import cn.gc.service.PersonServiceBean;

/**
 * 代理工厂
 * 
 * @author gc
 * 
 */
public class JDKProxyFactory implements InvocationHandler {
    private Object obj;

    /**
     * 创建代理实例，在调用代理对象的业务方法时，会被this对象所拦截
     * 
     * @param obj
     * @return
     */
    public Object createproxyInstance(Object obj) {
        this.obj = obj;
        // 在调用代理对象的业务方法时，会被this对象所拦截，而this对象通过执行invoke方法
        return Proxy.newProxyInstance(this.obj.getClass().getClassLoader(),
                this.obj.getClass().getInterfaces(), this);
    }

    /**
     * 实现InvocationHandler接口的方法，把方法的调用委派给目标对象
     * 
     * @param proxy
     *            代理对象
     * @param method
     *            拦截到的方法
     * @param args
     *            传入的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        PersonServiceBean beanImpl  =(PersonServiceBean)this.obj;
        Object result = null;
        if(beanImpl.getUser()!=null){
            //用户名不为空才执行业务方法
            result = method.invoke(obj, args);
        }
        return result;
    }
}

• junit测试

package junit.test;

import org.junit.BeforeClass;
import org.junit.Test;

import cn.gc.aop.JDKProxyFactory;
import cn.gc.service.PersonService;
import cn.gc.service.PersonServiceBean;

public class AOPTest {

    @BeforeClass
    public static void setUpBeforeClass() throws Exception {

    }

    @Test
    public void proxyTest() {
        JDKProxyFactory jpf = new JDKProxyFactory();
        // 代理对象要通过接口的形式来实现，因为代理对象实现了接口。
        // jpf.createproxyInstance(new PersonServiceImpl("xxx"));

    /*  //控制台输出
        PersonService service = (PersonService) jpf
        .createproxyInstance(new PersonServiceImpl("vv"));
        */
        //控制台不输出
        PersonService service = (PersonService) jpf
                .createproxyInstance(new PersonServiceBean(null));
        service.save("save le ");
    }
}

• 结果
  传入有参数的对象控制台会输出，传入null控制台无输出
  

---

使用spring中cglib实现AOP功能

通过spring2.5提供的cglib的jar文件实现代理。
过程和实现JDK的思路一样 只不过工厂类变成如下的方式：

package cn.gc.aop;

import java.lang.reflect.Method;

import cn.gc.service.PersonServiceBean;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CGlibProxyFactory implements MethodInterceptor{
    private Object obj;

    /**
     * 创建代理实例，在调用代理对象的业务方法时，会被this对象所拦截
     * 
     * @param obj
     * @return
     */
    public Object createproxyInstance(Object obj)  {
        this.obj = obj;
        //必须设置父类（目标类）
        Enhancer enhancer = new Enhancer();
        //把目标类设置为代理对象的父类，则代理对象会产生目标对象的子类，
        //这个子类中会覆盖目标类中所有非final的所有方法。在覆盖的的代码中添加自身的代码
        enhancer.setSuperclass(this.obj.getClass());
        //设置回调方法,当代理对象的业务方法被调用的时候这个毁掉方法会被执行（就是拦截）
        //要想实现这个毁掉必须要实现接口--MethodInterceptor
        enhancer.setCallback(this);
        return enhancer.create();
    }

    /**
     * 回调方法
     * @param proxy
     *            代理对象
     * @param method
     *            拦截到的方法
     * @param args
     *            传入的参数
     * @param MethodProxy 方法的代理对象
     */
    @Override
    public Object intercept(Object arg0, Method method, Object[] args,
            MethodProxy methodProxy) throws Throwable {
        PersonServiceBean beanImpl  =(PersonServiceBean)this.obj;
        Object result = null;
        if(beanImpl.getUser()!=null){
            //用户名不为空才执行业务方法
            result = methodProxy.invoke(obj, args);
        }
        return result;
    }
}

---

一些AOP概念

–横切性关注点
AOP在项目中主要实现权限的控制，包括细粒度和粗粒度的区分。对那些方法实施拦截，拦截之后干什么，就是属于横切性关注点。

–什么是切面？
对横切性关注点的抽象的实现的过程，如上面的类就是一个切面。和类比较相似，类是对物体特征的抽象，而切面是对横切性关注点实现的过程。

–连接点
被拦截的方法。spring中连接点是方法，而其他框架中也可能是类或者构造器。

–切入点
对连接点进行拦截的定义

–通知
在拦截到连接点之后的通知，通知分前置通知，后置通知，异常通知，最终通知，环绕通知。

–目标对象
代理的目标对象 如上所例为bean对象。

–织入
将切面应用到目标对象并导致代理对象创建的过程。例如bean无法进行权限判断，但我们对他拦截 创建代理对象在应用到目标对象。

–引入
在不修改原代码的情况下，为这个类在运行期动态在这个类的代理对象创建一些方法。