两种动态代理的实现方式

最近浏览招聘信息，看到部分企业提到个人博客。我没有写博客的习惯，实话来说，我根本就没想到写博客。可能是我涉行不深，没有养成这种观念。看到很多大神都有自己的博客，里面各色各样的技术文章。让我非常向往。为了向他们看齐，同时也锻炼自己的叙述能力。我也必须养成写博客的习惯。正好最近在研究Spring，对其AOP有了一点了解。此处就写下我的一些见解。

aop 是aspect oriented programming 缩写，翻译为面向切面编程。通俗的讲，就是把部分代码划分开来，前后加上需要的业务代码。典型代表就是struts2 的Interceptor和spring 的事务管理。

面向切面的好处在于，帮助我们省去了很多繁琐的内容。例如程序运行时会记录日志，执行操作时判断用户权限，持久化时启用事务等。如果每个操作都加上这些内容，无疑会给人一种臃肿的感觉。而AOP则将我们从中解救了出来。

AOP具体实现如下，下面是使用两种动态代理的方法。一种JDK自带的，一种cglib。

---

以下是以JDK自带实现

用户类

package com.proxy.entity;

public class User{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

用户DAO接口

package com.proxy.dao.i;

import com.proxy.entity.User;

public interface UserDaoI{
    void addUsers(User User);

    void deleteUsers(User User);
}

用户DAO实现类

package com.proxy.dao.impl;

import com.proxy.dao.i.UserDaoI;
import com.proxy.entity.User;

/**
*用户DAO实现类
*/
public class UserDaoImpl implements UserDaoI{

    public void addUsers(User User){
        System.out.println("用户添加成功!");
    }

    public void deleteUsers(User User){
        System.out.println("用户删除成功!");
    }
}

此处为jdk自带动态代理，需实现InvocationHandler接口

package com.proxy.jdk.trans;

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

/**
*事务管理
*/
public class TransProxyByJDK implements InvocationHandler{
    private Object target;

    public void setTarget(Object object){
        this.target = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
        System.out.println("事务开始!");
        method.invoke(target, args);
        System.out.println("事务结束");
        return null;
    }
}

JDKProxy测试类

package com.proxy.jdk.test;

import java.lang.reflect.Proxy;

import com.proxy.dao.i.UserDaoI;
import com.proxy.dao.impl.UserDaoImpl;
import com.proxy.entity.User;
import com.proxy.jdk.trans.TransProxyByJDK;

public class TestJDKProxy {
    public static void main(String[] args) {

        TransProxyByJDK proxy = new TransProxyByJDK();
        // 实例化委托类对象
        UserDaoI userDao = new UserDaoImpl();
        proxy.setTarget(userDao);

        UserDaoI userProxy = (UserDaoI) Proxy.newProxyInstance(userDao
                .getClass().getClassLoader(), new Class[] { UserDaoI.class },
                proxy);

        User user = new User();
        user.setName("张三");

        userProxy.addUsers(user);
        userProxy.deleteUsers(user);
    }
}

JDK自带实现方法有一缺点，就是被代理类必须要实现接口。上文UserDaoImpl 实现UserDaoI接口

---

下面是以cglib方式实现

首先必须要导入cglib的jar包

实现MethodInterceptor接口

package com.proxy.cglib.trans;

import java.lang.reflect.Method;

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

public class TransCglibProxy implements MethodInterceptor {

    @Override
    public Object intercept(Object obj, Method arg1, Object[] arg2,
            MethodProxy proxy) throws Throwable {
        System.out.println("事务开始!");
        proxy.invokeSuper(obj, arg2);
        System.out.println("事务结束!");
        return null;
    }
}

cglib测试类

package com.proxy.cglib.test;


import net.sf.cglib.proxy.Enhancer;

import com.proxy.cglib.trans.TransCglibProxy;
import com.proxy.dao.i.UserDaoI;
import com.proxy.dao.impl.UserDaoImpl;
import com.proxy.entity.User;

public class TestCglib {
    public static void main(String[] args) {

        TransCglibProxy proxy = new TransCglibProxy();

        //实例化委托类
        UserDaoI userDaoI = new UserDaoImpl();


        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(userDaoI.getClass());
        enhancer.setCallback(proxy);
        //创建代理类
        UserDaoI transProxy = (UserDaoI) enhancer.create();

        User user = new User();
        user.setName("李四");
        transProxy.addUsers(user);

        transProxy.deleteUsers(user);

    }
}

以上如有不对的地方，希望大家能指出。