java动态代理

代理：为其他对象提供代理，来控制对该对象的访问。起到客户端和目标对象之间的中介作用。（转：http://www.cnblogs.com/rollenholt/archive/2012/11/28/2792779.html）

代理模式：主要涉及到三方面：抽象接口、代理类、被代理类。代理对象与被代理对象有同样的接口。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。（转：http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html）

java动态代理机制，可采用如下方式使用，代码说明：

//抽象接口
public interface MyInterface {
    public void doSomething1();
    public void doSomething2();
    public void doSomething3(String s);
}

//被代理类，目标对象
public class MyImpl implements MyInterface {
    @Override
    public void doSomething1() {
        // TODO Auto-generated method stub
        System.out.println("doSomethings1");

    }
    @Override
    public void doSomething2() {
        // TODO Auto-generated method stub
        System.out.println("doSomethings2");
    }
    @Override
    public void doSomething3(String s) {
        // TODO Auto-generated method stub
        System.out.println("doSomething3 print:" + s);
    }
}

//InvocationHandler接口实现类，含有目标对象的引用，需要实现invoke方法
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {
    //代理的实际对象引用
    private MyInterface obj;
    public MyInvocationHandler(){
        
    }
    public MyInvocationHandler(MyInterface obj){
        this.obj = obj;
    }

    @Override
    public Object invoke(Object arg0, Method arg1, Object[] arg2)
            throws Throwable {
        // TODO Auto-generated method stub
        /*int flag = 1;
        if(arg1.getName().equals("doSomething1"))
            flag = 1;
        else if(arg1.getName().equals("doSomething2"))
            flag = 2;
        else
            flag = 3;*/
        //预处理
        //System.out.println("start up doSomething" + flag);
        System.out.println("start up doSomething");
        //调用目标对象的方法
        arg1.invoke(obj, arg2);
        //结束处理
        System.out.println("clean up doSomething");
        //System.out.println("clean up doSomething" + flag);
        return null;
    }

}

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


public class test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //创建目标对象
        MyInterface obj = new MyImpl();
        //创建InvocationHandler对象
        InvocationHandler invoker = new MyInvocationHandler(obj);
        //创建代理对象,调用Proxy的newProxyInstance方法
        MyInterface proxy = (MyInterface)Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), invoker);
        //调用代理方法，实际上回调用目标对象的方法
        proxy.doSomething1();
        System.out.println();
        proxy.doSomething2();
        System.out.println();
        proxy.doSomething3("HelloWorld");
    }

}

动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理。（转：http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html）

一致对java动态代理搞不懂，这次稍微看了下，我的理解是，java动态代理是针对接口的，而一个接口可以被多个类实现，这样可以省去为每个实现类创建代理类，大大减少了重复代码的编写，不知道是不是这样？这一块理解还是很浅，先记录下，后面在看看。

内容主要参考了下面两篇博客，万分感谢！！

http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html

http://www.cnblogs.com/rollenholt/archive/2012/11/28/2792779.html