Java静态代理、动态代理实例

采用Java代理模式，代理类通过调用委托类对象的方法，来提供特定的服务。委托类需要实现一个业务接口，代理类返回委托类的实例接口对象。

按照代理类的创建时期，可以分为：静态代理和动态代理。

所谓静态代理：　指程序员创建好代理类，编译时直接生成代理类的字节码文件。

所谓动态代理：　在程序运行时，通过反射机制动态生成代理类。

 

一、静态代理类实例：

1、Serivce.java

 

package com.ibm.delegate;

/**
 * 定义一个服务接口
 * @author IBM
 */
public interface Service {

    /**
     * 查询日期
     */
    public String queryDate();
    /**
     * 计算两个整数之差
     */
    public int sub(int a, int b);
}

 

2、ServiceImpl.java

 

package com.ibm.delegate;

import java.util.Date;

/**
 * 委托类需要实现服务接口（必须)
 * @author IBM
 */
public class CountImpl implements Service {

    @Override
    public String queryDate() {
        return new Date().toString();
    }

    @Override
    public int sub(int a, int b) {
        return a-b;
    }

    public void ownMethod(){
        System.out.println("It's my own method");
    }
}

3、ServiceProxy.java

 

 

package com.ibm.staticproxy;

import com.ibm.delegate.Serivce;
import com.ibm.delegate.CountImpl;

/**
 * @author IBM
 * 静态代理类
 */
public class SerivceProxy implements Service {
    private CountImpl countImpl;

    public SerivceProxy(CountImpl countImpl){
        this.countImpl = countImpl;
    }

    @Override
    public String queryDate() {
        return countImpl.queryDate();
    }

    @Override
    public int sub(int a, int b) {
        return countImpl.sub(a, b);
    }

    public void ownMethod(){
        System.out.println("It's my own method");
    }
}

4、ServiceTest.java（测试类)

 

 

package com.ibm;

import com.ibm.delegate.ServiceImpl;
import com.ibm.staticproxy.ServiceProxy;

public class ServiceTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //创建委托类实例，即被代理的类对象
        ServiceImpl target = new ServiceImpl();
        //创建静态代理类
        ServiceProxy proxy = new ServiceProxy(target);
        String date = proxy.queryDate();
        System.out.println(date);
        int result = proxy.sub(10, 20);
        System.out.println("10-20 = "+result);
        proxy.ownMethod();
    }
}

静态代理类的特点： 代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。而且代理类只能为特定的接口(Service)服务。

 

动态代理实例：

3、ServiceProxy.java

 

package com.ibm.dynamicproxy;

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

public class ServiceProxy implements InvocationHandler {

    private Object target;

    public ServiceProxy(Object target){
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object result = null;
        result = method.invoke(target, args);
        return result;
    }

    /**
     * @param target
     * @return 返回委托类接口的实例对象
     */
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }
}

4、ServiceTest.java（测试类)

 

 

package com.ibm;

import com.ibm.delegate.Service;
import com.ibm.delegate.ServiceImpl;
import com.ibm.dynamicproxy.ServiceProxy;

public class ServiceTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //创建委托类实例，即被代理的类对象
        ServiceImpl target = new ServiceImpl();
        //创建动态代理类
        ServiceProxy proxy = new ServiceProxy(target);
        Service service = (Service) proxy.getProxyInstance();
        String date = service.queryDate();
        System.out.println(date);
        int result = service.sub(10, 20);
        System.out.println("10-20 = "+result);
    }
}

 

动态代理： 代理类需要实现InvocationHandler接口。

使用场合举例： 如果需要委托类处理某一业务，那么我们就可以先在代理类中，对客户的权限、各类信息先做判断，如果不满足某一特定条件，则将其拦截下来，不让其代理。

 

修改两个方法，做测试：

ServiceImpl.java

 

public String ownMethod(){
    System.out.println("It's my own method");
    return "user";
}

 

ServiceProxy.java

 

@Override
public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    Object result = null;
    if(!(target instanceof ServiceImpl)){
        System.out.println("不能代理该对象");
        return result;
    }else if(!((ServiceImpl)target).ownMethod().equals("admin")){
        System.out.println("权限不够");
        return result;
    }
    result = method.invoke(target, args);
    return result;
}

 

评论

10 楼 Link028 2012-07-16  

是我没表达清楚？还是你没看清楚？
答非所问。

9 楼 JamesQian 2012-07-02  

通过dynamic proxy 可以实现对其权限动态的处理,不错

8 楼 暗夜幽魂 2012-06-27  

Link028 写道

探讨下：
动态代理实现
ServiceImpl target = new ServiceImpl(); 
        //创建动态代理类 
        ServiceProxy proxy = new ServiceProxy(target); 
        Service service = (Service) proxy.getProxyInstance();

新建  代理类对象 ServiceProxy proxy 时已经将委托对象传递进来了，
然后 调用   Service service = (Service) proxy.getProxyInstance();得到接口是不是
多此一举了？感觉直接用 target 不就OK了吗？

用动态代理往往是要实现一些诸如:日志，权限等功能的插入。直接调用target就没办法实现这些额外功能。 例如本文中的权限控制。建议可以看一下spring中的AOP原理 就会明白了。

7 楼 w156445045 2012-06-27  

感觉没怎么说清楚，

6 楼 xlaohe1 2012-06-27  

我看见了IBM

5 楼 Link028 2012-06-27  

探讨下：
动态代理实现
ServiceImpl target = new ServiceImpl(); 
        //创建动态代理类 
        ServiceProxy proxy = new ServiceProxy(target); 
        Service service = (Service) proxy.getProxyInstance();

新建  代理类对象 ServiceProxy proxy 时已经将委托对象传递进来了，
然后 调用   Service service = (Service) proxy.getProxyInstance();得到接口是不是
多此一举了？感觉直接用 target 不就OK了吗？

4 楼 elan1986 2012-06-26  

3 楼 cpszy 2012-06-26  

对我有帮助，谢谢博主！

2 楼 xuelianbobo 2012-06-26  

1 楼 xpp02 2012-06-25  

动态代理，真的很好用的说