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;
 }