Java 静态代理和动态代理

代理模式主要有两种：静态代理和动态代理

Java代码

 

1 > 接口

package com.proxy;

 

/**

 * 接口

 *

 */

public interface ITask {

    public String task(String name);

}

 

2 > 实理类

 

package com.proxy;

 

/**

 * 实现类

 *

 */

public class TaskImpl implements ITask {

 

    public String task(String name) {

       System.out.println("hello "+name);

       return "hello "+name;

    }

 

}

一. 静态代理：

 

3 > 静态代理类

package com.proxy;

 

/**

 * 静态理,就是实理接品中的所有方法,

 * 跟据传入的实理类,来调用实理类中的方法

 *

 */

public class StaticProxy implements ITask{

    private ITask task;

   

    public StaticProxy(ITask task){

       this.task = task;

    }

   

    /*

     * 实现接口中的方法,但是用传入的实理类来搞用自己的方法

     */

    public String task(String name) {

       return task.task(name);

    }

   

 

}

4 > 调用静态代理

package com.proxy.test;

 

import com.proxy.ITask;

import com.proxy.StaticProxy;

import com.proxy.TaskImpl;

 

/**

 * 测试静态理

 * @author Administrator

 *

 */

public class TestStaticProxy {

 

    public static void main(String[] args){

       ITask proxy = new StaticProxy(new TaskImpl());

       proxy.task("张三");

    }

}

 

二.动态代理：

5 > 动态代理类

 

package com.proxy.dy;

 

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

 

/**

 * 动态代理类只能代理接口，代理类都需要实现InvocationHandler类，实现invoke方法。

 * 该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类

 * @author Administrator

 *

 */

public class DynamicProxy implements InvocationHandler {

    private Object object;

   

    /*

     * 返回一个代理类

     * @param ob

     * @return

     */

    public Object bind(Object ob){

       this.object = ob;

       return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(), this);

    }

   

    /*

     * 对这个代理类中所有方法拦截

     */

    public Object invoke(Object arg0, Method arg1, Object[] arg2)

           throws Throwable {

       Object result = null;

      

       log("method start........");

       result = arg1.invoke(object, arg2);

       log("method end .........");

      

       return result;

    }

   

    /**

     * 日志输出方法

     * @param msg

     */

    public void log(String msg){

       System.out.println(msg);

    }

 

}

 

 

6 > 调用动态代理

 

package com.proxy.test;

 

import com.proxy.ITask;

import com.proxy.TaskImpl;

import com.proxy.dy.DynamicProxy;

 

/**

 * 测试动态代理

 * @author Administrator

 *

 */

public class TestDynamicProxy {

 

    /**

     * @param args

     */

    public static void main(String[] args) {

       DynamicProxy dynamicProxy = new DynamicProxy();

       ITask task = (ITask)dynamicProxy.bind(new TaskImpl());

       task.task("李四");

 

    }

 

}

总结：这其实是AOP的最底层实现，AOP的的好处就是用到了代理，把各种业务逻辑分离开来了，不管是核心要处理的还是作为辅助功能（或者测试）的业务逻辑，比如日志作为一个切面可以去测试每个方法是否都执行了，用AOP就不需要去改动任何核心业务，如果不要了，就不指定Pointcut就可以了(关于AOP的各种术语可以参考 spring reference），这应该算是一种思想的转变。