JAVA动态代理

简介:

静态代理

在介绍动态代理之前,我们先来看看静态代理的实现过程,代理我们可以理解为为其他对象提供一种代理以控制对这个对象的访问。

首先我们创建一个接口:

public interface Animal
{
   public void sleep();
   public void run();
}
AI 代码解读

接下来,我们创建一个实现类:

public class Dog implements Animal
{

   @Override
   public void sleep()
   {
      System.out.println("dog sleep...");
   }

   @Override
   public void run()
   {
      System.out.println("dog run...");
   }
}
AI 代码解读

我们现在要对Dog类进行代理,所以需要创建代理类:

package dynamicproxy;

public class DogProxy implements Animal
{
   private Animal animal = null;

   public DogProxy(Animal animal)
   {
      this.animal = animal;
   }

   @Override
   public void sleep()
   {
      System.out.println("before invoke sleep...");
      animal.sleep();
      System.out.println("after invoke sleep...");
   }

   @Override
   public void run()
   {
      System.out.println("before invoke run...");
      animal.run();
      System.out.println("after invoke run...");
   }
}
AI 代码解读

下面我们用一个测试类测试一下:

package dynamicproxy;

public class Test
{
   public static void main(String[] args) throws Exception
   {
      Animal animal = new DogProxy(new Dog());
      animal.sleep();
      animal.run();
   }
}
AI 代码解读

运行结果:
before invoke sleep…
dog sleep…
after invoke sleep…
before invoke run…
dog run…
after invoke run…

动态代理

静态代理存在大量的重复代码且需要维护多个代理类,维护成本很大,所以使用动态代理是很有必要的。

动态代理需要用到java.lang.reflect.InvocationHandlerjava.lang.reflect.Proxy
InvocationHandler是代理实例的调用处理程序 实现的接口。Proxy提供用于创建动态代理类和实例的静态方法,它还是由这些方法创建的所有动态代理类的超类。

同样的我们还是以静态代理中的例子来演示动态代理的使用,实现同样的功能,我们可以编写一个类实现InvocationHandler接口:

package dynamicproxy;

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

public class AnimalInvocationHandler implements InvocationHandler
{
   private Object targetObject = null;

   public Object bind(Object targetObject)
   {
      this.targetObject = targetObject;
      return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
            targetObject.getClass().getInterfaces(), this);
   }

   @Override
   public Object invoke(Object proxy, Method method, Object[] args)
         throws Throwable
   {
      String name = method.getName();
      System.out.println("before invoke " + name + "...");
      Object result = method.invoke(targetObject, args);
      System.out.println("after invoke " + name + "...");
      return result;
   }
}
AI 代码解读

最后,我们编写一个测试类测试一下:

public class Test
{
   public static void main(String[] args) throws Exception
   {
      AnimalInvocationHandler invocationHandler = new AnimalInvocationHandler();
      Animal animal = (Animal) invocationHandler.bind(new Dog());
      animal.sleep();
      animal.run();
   }
}
AI 代码解读

运行结果:
before invoke sleep…
dog sleep…
after invoke sleep…
before invoke run…
dog run…
after invoke run…

通过对比动态代理与静态代理的实现方式,我们可以发现动态代理更加简洁,更易于维护。

我们可以将动态代理的相关实现提取出来,形成工具类,方便以后使用:

import java.lang.reflect.Method;

/**
 * 动态代理支持接口
 * 
 * @author jianggujin
 * 
 */
public interface DynamicProxySupport
{
   /**
    * 方法执行前执行
    * 
    * @param backIfFalse
    *           如果不继续执行的返回数据
    * @param delegate
    *           委托对象
    * @param proxy
    *           代理对象
    * @param method
    *           要执行的委托对象的方法
    * @param args
    *           要执行的委托对象的方法的参数
    * @return true 继续向下执行,否则不执行
    */
   public boolean beforeInvoke(Object backIfFalse, Object delegate,
         Object proxy, Method method, Object[] args);

   /**
    * 方法执行后执行
    * 
    * @param result
    *           要执行的委托对象的方法的结果
    * @param delegate
    *           委托对象
    * @param proxy
    *           代理对象
    * @param method
    *           要执行的委托对象的方法
    * @param args
    *           要执行的委托对象的方法的参数
    */
   public void afterInvoke(Object result, Object delegate, Object proxy,
         Method method, Object[] args);
}
AI 代码解读
import java.lang.reflect.Method;

/**
 * 动态代理支持接口实现类,实现代理指定方法,方法规则为
 * {@link #beforeMethodInvoke(Object, Object, Object, Object[])}
 * ,返回类型为Boolean(boolean)或
 * {@link #afterMethodInvoke(Object, Object, Object, Object[])},返回类型为void(不做拦截)
 * ,分别用于方法前与方法后执行,其中Method为实际需要代理的方法名,且方法首字母大写
 * 
 * @author jianggujin
 * 
 */
public class MethodDynamicProxy implements DynamicProxySupport
{
   private final String BEFORE = "before%c%sInvoke";
   private final String AFTER = "after%c%sInvoke";
   private final Class<?> OBJ_ARRAY = new Object[0].getClass();

   /**
    * 获得需要执行的方法
    * 
    * @param format
    * @param method
    * @return
    * @throws NoSuchMethodException
    */
   private Method getInvokeMethod(String format, Method method)
         throws NoSuchMethodException
   {
      String methodName = method.getName();
      Method invokeMethod = this.getClass()
            .getMethod(
                  String.format(format, Character.toUpperCase(methodName
                        .charAt(0)), methodName.length() == 1 ? "" : method
                        .getName().substring(1)), Object.class, Object.class,
                  Object.class, OBJ_ARRAY);
      return invokeMethod;
   }

   public boolean beforeInvoke(Object backIfFalse, Object delegate,
         Object proxy, Method method, Object[] args)
   {
      try
      {
         Method before = getInvokeMethod(BEFORE, method);
         if (!before.getReturnType().getSimpleName()
               .equalsIgnoreCase("boolean"))
         {
            throw new Exception("the method " + before.getName()
                  + "return type is not Boolean");
         }
         return (Boolean) before.invoke(this, backIfFalse, delegate, proxy,
               args);
      }
      catch (NoSuchMethodException e)
      {
      }
      catch (Exception e)
      {
         throw new RuntimeException(e);
      }
      return true;
   }

   public void afterInvoke(Object result, Object delegate, Object proxy,
         Method method, Object[] args)
   {
      try
      {
         Method after = getInvokeMethod(AFTER, method);
         after.invoke(this, result, delegate, proxy, args);
      }
      catch (NoSuchMethodException e)
      {
      }
      catch (Exception e)
      {
         throw new RuntimeException(e);
      }
   }
}
AI 代码解读
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 动态代理,获得委托对象的代理对象
 * 
 * @author jianggujin
 * 
 * @param <P>
 *           接口
 * @param <C>
 *           实现类
 */
public class DynamicProxy<P, C> implements InvocationHandler
{
   /** 委托对象 **/
   private Object delegate;
   /** 动态代理支持接口 **/
   private DynamicProxySupport dynamicProxySupport = null;

   /**
    * 返回指定类的代理对象,通过默认构造方法创建委托对象
    * 
    * @param clazz
    *           委托对象类
    * @return <P>
    *         p
    * @throws InstantiationException
    * @throws IllegalAccessException
    */
   @SuppressWarnings("unchecked")
   public P bind(Class<C> clazz) throws InstantiationException,
         IllegalAccessException
   {
      this.delegate = clazz.newInstance();
      // 取得代理对象
      return (P) Proxy.newProxyInstance(clazz.getClassLoader(),
            clazz.getInterfaces(), this);
   }

   /**
    * 返回指定类的代理对象,通过默认构造方法创建委托对象
    * 
    * @param clazz
    *           委托对象类
    * @return <P>
    *         p
    * @throws InstantiationException
    * @throws IllegalAccessException
    */
   @SuppressWarnings("unchecked")
   public P bind(Class<C> clazz, DynamicProxySupport dynamicProxySupport)
         throws InstantiationException, IllegalAccessException
   {
      this.delegate = clazz.newInstance();
      this.dynamicProxySupport = dynamicProxySupport;
      // 取得代理对象
      return (P) Proxy.newProxyInstance(clazz.getClassLoader(),
            clazz.getInterfaces(), this);
   }

   /**
    * 绑定委托对象并返回一个代理对象
    * 
    * @param target
    * @return <P>
    *         p
    */
   @SuppressWarnings("unchecked")
   public P bind(C target)
   {
      this.delegate = target;
      // 取得代理对象
      return (P) Proxy.newProxyInstance(target.getClass().getClassLoader(),
            target.getClass().getInterfaces(), this);
   }

   /**
    * 绑定委托对象并返回一个代理对象
    * 
    * @param target
    * @return <P>
    *         p
    */
   @SuppressWarnings("unchecked")
   public P bind(C target, DynamicProxySupport dynamicProxySupport)
   {
      this.delegate = target;
      this.dynamicProxySupport = dynamicProxySupport;
      // 取得代理对象
      return (P) Proxy.newProxyInstance(target.getClass().getClassLoader(),
            target.getClass().getInterfaces(), this);
   }

   /**
    * 执行方法
    * 
    * @param proxy
    *           代理对象
    * @param method
    *           要执行的委托对象的方法
    * @param args
    *           要执行的委托对象的方法的参数
    */
   public Object invoke(Object proxy, Method method, Object[] args)
         throws Throwable
   {
      Object result = null;
      if (dynamicProxySupport != null)
      {
         Object obj = new Object();
         if (dynamicProxySupport.beforeInvoke(obj, delegate, proxy, method,
               args))
         {
            result = method.invoke(delegate, args);
            dynamicProxySupport.afterInvoke(result, delegate, proxy, method,
                  args);
         }
         else
         {
            return obj;
         }
      }
      else
      {
         result = method.invoke(delegate, args);
      }
      return result;
   }

   /**
    * 获得动态代理支持接口
    * 
    * @return dynamicProxySupport
    */
   public DynamicProxySupport getDynamicProxySupport()
   {
      return dynamicProxySupport;
   }

   /**
    * 设置动态代理支持接口
    * 
    * @param dynamicProxySupport
    */
   public void setDynamicProxySupport(DynamicProxySupport dynamicProxySupport)
   {
      this.dynamicProxySupport = dynamicProxySupport;
   }

   /**
    * 获得委托对象
    * 
    * @return <C> c
    */
   @SuppressWarnings("unchecked")
   public C getDelegate()
   {
      return (C) delegate;
   }
}
AI 代码解读

我们可以这样使用工具类

import java.lang.reflect.Method;

public class Test
{
   public static void main(String[] args) throws Exception
   {
      DynamicProxy<Animal, Dog> dynamicProxy = new DynamicProxy<Animal, Dog>();
      Animal animal = dynamicProxy.bind(Dog.class, new DynamicProxySupport()
      {

         @Override
         public boolean beforeInvoke(Object backIfFalse, Object delegate,
               Object proxy, Method method, Object[] args)
         {
            System.out.println("before invoke " + method.getName());
            return true;
         }

         @Override
         public void afterInvoke(Object result, Object delegate, Object proxy,
               Method method, Object[] args)
         {
            System.out.println("after invoke " + method.getName());
         }
      });
      animal.sleep();
      animal.run();
   }
}
AI 代码解读

运行结果:
before invoke sleep
dog sleep…
after invoke sleep
before invoke run
dog run…
after invoke run

如果我们想代理指定的方法,我们可以这样去写:

package dynamicproxy;

public class Test
{
   public static void main(String[] args) throws Exception
   {
      DynamicProxy<Animal, Dog> dynamicProxy = new DynamicProxy<Animal, Dog>();
      Animal animal = dynamicProxy.bind(Dog.class, new MethodDynamicProxy()
      {
         public boolean beforeSleepInvoke(Object backIfFalse, Object delegate,
               Object proxy, Object[] args)
         {
            System.out.println("before invoke sleep");
            return false;
         }

         public boolean beforeRunInvoke(Object backIfFalse, Object delegate,
               Object proxy, Object[] args)
         {
            System.out.println("before invoke run");
            return true;
         }

         public void afterSleepInvoke(Object backIfFalse, Object delegate,
               Object proxy, Object[] args)
         {
            System.out.println("after invoke sleep");
         }

         public void afterRunInvoke(Object backIfFalse, Object delegate,
               Object proxy, Object[] args)
         {
            System.out.println("after invoke run");
         }
      });
      animal.sleep();
      animal.run();
   }
}
AI 代码解读

运行结果:
before invoke sleep
before invoke run
dog run…
after invoke run

目录
打赏
0
0
0
0
33
分享
相关文章
[Java]代理模式
本文介绍了代理模式及其分类,包括静态代理和动态代理。静态代理分为面向接口和面向继承两种形式,分别通过手动创建代理类实现;动态代理则利用反射技术,在运行时动态创建代理对象,分为JDK动态代理和Cglib动态代理。文中通过具体代码示例详细讲解了各种代理模式的实现方式和应用场景。
64 0
[Java]代理模式
|
2月前
|
JAVA 静态代理 & 动态代理
【11月更文挑战第14天】静态代理是一种简单的代理模式实现,其中代理类和被代理类的关系在编译时已确定。代理类实现与被代理类相同的接口,并持有被代理类的实例,通过调用其方法实现功能增强。优点包括代码结构清晰,易于理解和实现;缺点是对于多个被代理类,需为每个类编写相应的代理类,导致代码量大增,维护成本高。动态代理则在运行时动态生成代理类,更加灵活,减少了代码冗余,但可能引入性能损耗和兼容性问题。
|
3月前
|
深入理解Java动态代理
深入理解Java动态代理
99 1
Java代码解释静态代理和动态代理的区别
### 静态代理与动态代理简介 **静态代理**:代理类在编译时已确定,目标对象和代理对象都实现同一接口。代理类包含对目标对象的引用,并在调用方法时添加额外操作。 **动态代理**:利用Java反射机制在运行时生成代理类,更加灵活。通过`Proxy`类和`InvocationHandler`接口实现,无需提前知道接口的具体实现细节。 示例代码展示了两种代理方式的实现,静态代理需要手动创建代理对象,而动态代理通过反射机制自动创建。
从源码学习Java动态代理|8月更文挑战
从源码学习Java动态代理|8月更文挑战
day27:Java零基础 - 动态代理
【7月更文挑战第27天】🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
49 2
day27:Java零基础 - 动态代理
【独家揭秘】当WPF邂逅DirectX:看这两个技术如何联手打造令人惊艳的高性能图形渲染体验,从环境搭建到代码实践,一步步教你成为图形编程高手
【8月更文挑战第31天】本文通过代码示例详细介绍了如何在WPF应用中集成DirectX以实现高性能图形渲染。首先创建WPF项目并使用SharpDX作为桥梁,然后在XAML中定义承载DirectX内容的容器。接着,通过C#代码初始化DirectX环境,设置渲染逻辑,并在WPF窗口中绘制图形。此方法适用于从简单2D到复杂3D场景的各种图形处理需求,为WPF开发者提供了高性能图形渲染的技术支持和实践指导。
371 0
揭秘!JDK动态代理VS CGLIB:一场关于Java代理界的‘宫心计’,你站哪队?
【8月更文挑战第24天】Java 动态代理是一种设计模式,允许在不改动原类的基础上通过代理类扩展功能。主要实现方式包括 JDK 动态代理和 CGLIB。前者基于接口,利用反射机制在运行时创建代理类;后者采用继承方式并通过字节码技术生成子类实现类的代理。两者在实现机制、性能及适用场景上有明显差异。JDK 动态代理适用于有接口的场景,而 CGLIB 更适合代理未实现接口的类,尽管性能更优但存在一些限制。开发者可根据需求选择合适的代理方式。
238 0
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等