java动态代理实现

Java中的代理有静态代理和动态代理，下面我会分别用一个简单的例子来介绍一下静态代理和动态代理代码实现。
1 静态代理
代理接口：UserDao.java

public interface UserDao {

    void save();

}

目标对象：UserDaoImpl.java

public class UserDaoImpl implements UserDao {

    @Override
    public void save() {
        System.out.println("正在保存用户...");
    }

}

代理对象：TransactionHandler.java

public class TransactionHandler implements UserDao {

    //目标代理对象
    private UserDaoImpl target;

    //构造代理对象时传入目标对象
    public TransactionHandler(UserDaoImpl target) {
        this.target = target;
    }

    @Override
    public void save() {
        //调用目标方法前的处理
        System.out.println("开启事务控制...");
        //调用目标对象的方法
        target.save();
        //调用目标方法后的处理
        System.out.println("关闭事务控制...");
    }

}

测试类：Main.java

public class Main {

    public static void main(String[] args) {

        //新建目标对象
        UserDaoImpl target = new UserDaoImpl();

        //创建代理对象, 并使用接口对其进行引用
        UserDao userDao = new TransactionHandler(target);

        //针对接口进行调用
        userDao.save();

    }

}

测试结果：

总结：

总的来说静态代理实现简单也容易理解，但是静态代理不能使一个代理类反复作用于多个目标对象，代理对象直接持有目标对象的引用，这导致代理对象和目标对象类型紧密耦合了在一起。如果UserDao接口下还有另一个实现类也需要进行事务控制，那么就要重新写一个代理类，这样就会产生许多重复的模版代码，不能达到代码复用的目的。而动态代理就可以很好的解决这样的问题。

2.动态代理

import java.lang.reflect.InvocationHandler;  

import java.lang.reflect.Method;  

import java.lang.reflect.Proxy;  

/**

 * 动态代理类使用到了一个接口InvocationHandler和一个代理类Proxy ，这两个类配合使用实现了动态代理的功能。

 * 那么什么是动态代理呢？

 * 我们平常说的代理类是指： 给每个具体类写一个代理类，以后要使用某个具体类时，只要创建它的代理类的对象，然后调用代理类的方法就可以了。

 * 可是如果现在有许多的具体类，那就需要有许多的代理类才可以，这样很显然不合适。所以动态代理就应运而生了，我们只要写一个类实现

 * InvocationHandler 并实现它的invoke方法，然后再用Proxy的工厂方法newProxyInstance（）创建一个代理对象，这个对象同样可以实现对具体类的代理功能。

 * 而且想代理哪个具体类，只要给Handler（以下代码中的Invoker）的构造器传入这个具体对象的实例就可以了。感觉是不是自己为该具体类造了一个代理类呢？呵呵~

 */  

//接口类  

interface AbstractClass {  

public void show();  

}  

// 具体类A  

class ClassA implements AbstractClass {  

@Override  

public void show() {  

// TODO Auto-generated method stub  

System.out.println("我是A类！");  

    }  

}  



// 具体类B  

class ClassB implements AbstractClass {  

@Override  

public void show() {  

// TODO Auto-generated method stub  

System.out.println("我是B类！");  

    }  

}  

//动态代理类，实现InvocationHandler接口  

class Invoker implements InvocationHandler {  

    AbstractClass ac;  

public Invoker(AbstractClass ac) {  

this.ac = ac;  

    }  

@Override  

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

throws Throwable {  

//调用之前可以做一些处理  

        method.invoke(ac, arg);  

//调用之后也可以做一些处理  

return null;  

    }  

}  



/**

 * 测试类

 */  

class DynamicProxyTest {  

public static void main(String[] args) {  

//创建具体类ClassB的处理对象  

Invoker invoker1=new Invoker(new ClassA());  

//获得具体类ClassA的代理  

        AbstractClass ac1 = (AbstractClass) Proxy.newProxyInstance(  

AbstractClass.class.getClassLoader(),  

new Class[] { AbstractClass.class }, invoker1);  

//调用ClassA的show方法。  

        ac1.show();  

//创建具体类ClassB的处理对象  

Invoker invoker2=new Invoker(new ClassB());  

//获得具体类ClassB的代理  

        AbstractClass ac2 = (AbstractClass) Proxy.newProxyInstance(  

AbstractClass.class.getClassLoader(),  

new Class[] { AbstractClass.class }, invoker2);  

//调用ClassB的show方法。  

        ac2.show();  

    }  

}  

程序运行后的结果如下：

Java代码

我是A类！

我是B类！