`
evans_he
  • 浏览: 12334 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

动态代理

阅读更多

       java动态代理就是动态的为委托类生成代理类,相比静态代理需要预先编写代理类源码,动态代理只需要定义好接口,然后使用反射动态生成指定接口的实现类(代理类)。以下通过一个demo来分析动态代理的实现细节。

       

    步骤1:定义接口并提供接口实现类。

/**
 *	打电话服务接口
 */
interface CallService{
	public void call();
}

/**
 *	发信息服务接口 
 */
interface SendMessageService{
	public void sendMessage();
}

/**
 *	手机服务接口 
 */
interface PhoneService extends CallService, SendMessageService{

}

/**
 *	服务实现类
 */
class PhoneServiceImpl implements PhoneService{
	@Override
	public void call() {
		System.out.println("call----");
	}
	
	@Override
	public void sendMessage() {
		System.out.println("sendMessage----");
	}
}

 

   步骤2:为接口实现类提供代理。

 

/**
 *	代理逻辑
 */
class ServiceHandler implements InvocationHandler{
	
	/**
	 *	被代理对象
	 */
	private PhoneService target;
	
	public ServiceHandler(PhoneService target){
		this.target = target;
	}

	/**
	 * 提供需要被代理执行的逻辑
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		log("begin servie----");  
		Object rtn = method.invoke(target, args);
		log("finish servie----");  
		return rtn;
	}

	private void log(String info){
		System.out.println(new Date() + " : " + info);
	}
}

 

 以上两步已经准备好了接口和代理逻辑,接下来就测试代理的执行结果。

 

public class Demo {
	public static void main(String[] args) throws Exception {
		//创建被代理的对象
		PhoneService target = new PhoneServiceImpl();
		ServiceHandler serviceHandler = new ServiceHandler(target);
		//创建代理对象
		PhoneService proxy = (PhoneService)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), serviceHandler);    
		//通过代理执行业务逻辑
		proxy.call();
		proxy.sendMessage();
	}
}

   

   以上测试代码的执行结果如下:

 

Thu Mar 27 21:40:21 CST 2014 : begin servie----
call----
Thu Mar 27 21:40:21 CST 2014 : finish servie----
Thu Mar 27 21:40:21 CST 2014 : begin servie----
sendMessage----
Thu Mar 27 21:40:21 CST 2014 : finish servie----

 

   Demo1演示了为PhoneServiceImpl 提供动态代理类来打印日志服务,涉及到的相关类的关系如下: 

 

 



       

         InvocationHandler接口定义了invoke(Object proxy, Method method, Object[] args)方法,用户必须实现InvocationHandler接口,实现invoke 方法来提供代理类的处理逻辑。

       

          Proxy类是所有动态生成的代理类的父类,它提供了为接口动态生成代理类及其对象的方法。通过调用Proxy的静态方法newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)为指定接口interfaces生成名为$ProxyN(N由Proxy的计数器确定)的实现类,该实现类中实现了所有接口定义的方法,方法内部实际是对父类Proxy的InvocationHandler 类型成员h调用invoke方法,Proxy相关源代码如下:

 

 public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException{
        if (h == null) {
            throw new NullPointerException();
        }

        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, interfaces);
        }

        /*
         * Look up or generate the designated proxy class.
         */
        //为所有的接口生成一个实现类,并加载生成Class 对象cl
        Class<?> cl = getProxyClass0(loader, interfaces);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            //通过反射获取cl的构造方法,并传入h 构造出代理类实例
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
                // create proxy instance with doPrivilege as the proxy class may
                // implement non-public interfaces that requires a special permission
                return AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
                        return newInstance(cons, ih);
                    }
                });
            } else {
                return newInstance(cons, ih);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString());
        }
    }

    private static Object newInstance(Constructor<?> cons, InvocationHandler h) {
        try {
            return cons.newInstance(new Object[] {h} );
        } catch (IllegalAccessException | InstantiationException e) {
            throw new InternalError(e.toString());
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString());
            }
        }
    }

 

      跟踪Proxy源码,获取器动态生成的字节码并将其保存到.class文件,然后用jd-gui 反编译字节码文件可得到如下动态代理类代码:

 

package com.hsh.dynamicproxy;

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

public final class $Proxy0 extends Proxy
  implements PhoneService
{
  private static Method m4;
  private static Method m1;
  private static Method m3;
  private static Method m0;
  private static Method m2;

  public $Proxy0(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }

  public final void sendMessage()
    throws 
  {
    try
    {
      this.h.invoke(this, m4, null);
      return;
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final boolean equals(Object paramObject)
    throws 
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final void call()
    throws 
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final int hashCode()
    throws 
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final String toString()
    throws 
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  static
  {
    try
    {
      m4 = Class.forName("com.hsh.dynamicproxy.PhoneService").getMethod("sendMessage", new Class[0]);
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("com.hsh.dynamicproxy.PhoneService").getMethod("call", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
    }
    throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
  }
}

 

      通过看生成的代理类源码,代理的原理就一目了然了。 

 

  • 大小: 59.1 KB
分享到:
评论

相关推荐

    spring+动态代理

    在Java编程中,动态代理是一种强大的工具,它允许我们在运行时创建对象的代理,以便在调用实际方法之前或之后执行额外的操作。Spring框架提供了一种便捷的方式来实现动态代理,这使得我们可以在不修改原有代码的情况...

    动态代理设计模式 日志和源码

    动态代理设计模式是一种在运行时创建代理对象的技术,它允许我们为现有的对象提供额外的功能,如日志记录、性能监控、事务管理等,而无需修改原对象的代码。这种模式在Java和许多其他编程语言中都有应用,尤其在...

    关于jdk动态代理的源码剖析

    ### 关于JDK动态代理的源码剖析 #### 一、引言 在Java开发过程中,动态代理技术是一项非常实用的技术,它可以帮助我们实现在不修改原有代码的基础上为方法增加额外的功能,比如日志记录、权限校验等。本文将深入...

    浅谈JDK动态代理与CGLIB代理去区别

    在Java开发中,动态代理和CGLIB代理是两种常见的面向切面编程(AOP)实现方式,它们都用于在不修改原有代码的情况下,增强或扩展对象的功能。本篇文章将深入探讨JDK动态代理和CGLIB代理的区别,以及它们在实际应用中...

    JDK动态代理_JDK动态代理

    ### JDK动态代理详解 #### 一、引言 在软件工程中,代理模式是一种常见的设计模式,它通过为一个对象提供一个替代品或占位符来控制对这个对象的访问。这种模式通常用于添加额外的功能(例如日志记录、事务管理等)...

    qt qtableview动态代理

    然而,QTableView的功能可以进一步增强,通过实现动态代理(Dynamic Proxy)来扩展其交互性。动态代理允许我们在表格的单元格内嵌入其他UI元素,比如QSpinBox、QCheckBox或QComboBox,从而提供更丰富的用户交互体验...

    Java动态代理两种实现方式

    Java动态代理技术是Java编程中一个非常重要的特性,它允许我们在运行时动态创建具有特定行为的对象。这种技术常用于AOP(面向切面编程)和框架中,如Spring AOP,用于实现方法拦截、事务管理等功能。Java提供了两种...

    JVM技术,反射与动态代理

    本主题将深入探讨JVM技术,特别是反射与动态代理这两个关键特性。 一、JVM技术 1. 类加载机制:JVM通过类加载器(ClassLoader)来加载.class文件,分为启动类加载器、扩展类加载器和应用程序类加载器。类的加载...

    Jdk动态代理和cglib动态代理原理

    Java中的动态代理是一种重要的设计模式,它允许在运行时创建具有特定行为的代理对象,以扩展或增强原有对象的功能。动态代理主要分为两种技术:JDK动态代理和CGLIB动态代理。 ### JDK动态代理 JDK动态代理是Java...

    java + 动态代理 + 动态代理实际应用场景

    1:静态代理出现的实际背景,静态代理时如何演化成动态代理 2: 动态代理demo 举例实际应用场景(载入数据库驱动的时候,使用AIDL与系统Servic进行通信) 3: 动态代理使用到基础理论:ClassLoader 加载.class字节码...

    静态代理和动态代理Demo

    静态代理和动态代理是两种常见的代理模式,它们在Java中有着广泛的应用,特别是在SpringBoot等框架中。本资源提供了一个简单的Java实现,适用于JDK1.8版本,并经过了验证,对初学者理解设计模式具有指导意义。 静态...

    Java静态代理和动态代理

    Java的代理模式通过代理类提供了对委托类的扩展和控制,静态代理适合对已有代码不做修改的情况,而动态代理则提供了更高的灵活性和扩展性。在实际应用中,应根据项目需求和性能考虑选择静态代理或动态代理。对于需要...

    springboot中的 动态代理的选择测试代码

    在Spring Boot应用中,动态代理是一种非常重要的技术,主要用于实现AOP(面向切面编程)。在本场景下,"springboot中的 动态代理的选择测试代码"涉及到的是如何在Spring Boot环境中利用Java或CGLIB动态代理来实现...

    spring之AOP(动态代理)

    在Spring中,AOP主要通过两种动态代理技术实现:JDK动态代理和CGLIB动态代理。 首先,让我们详细了解一下JDK动态代理。JDK动态代理基于Java的接口实现,它适用于目标对象实现了至少一个接口的情况。在运行时,JDK...

    一篇讲动态代理的好文 <动态代理的前世今生>

    ### 动态代理的前世今生 #### 一、引言 动态代理作为一种广泛应用于软件开发中的设计模式,其重要性不言而喻。本文旨在深入探讨动态代理的概念、原理及其实现方式,并通过实例帮助读者更好地理解动态代理的应用...

    jdk动态代理技术详解

    JDK 动态代理技术详解 JDK 动态代理技术是 Java 语言自身对动态代理的支持,类似于 JDK 中在 java.util 包中提供 Observable 类和 Observer 接口提供对观察者模式的语言级支持。动态代理的优点是可以动态地为软件...

    动态代理例子

    动态代理在Java编程中是一种非常重要的技术,它允许我们在运行时创建代理类,这些代理类可以作为原有类的“中间人”,在调用原始方法之前或之后执行额外的操作。这通常用于实现AOP(面向切面编程)的概念,如日志、...

    反射实现 AOP 动态代理模式(Spring AOP 的实现原理)

    动态代理是实现AOP的一种常用技术,它允许在运行时创建代理对象,拦截对真实对象的调用,并在调用前后添加额外的行为。 在Java开发中,反射机制是实现动态代理的关键技术之一。反射提供了在运行时访问和操作类的...

    动态代理和静态代理demo

    代理模式通常分为静态代理和动态代理两种实现方式,这里我们将详细探讨这两种代理模式,并通过一个简单的Java示例进行演示。 ### 静态代理 静态代理是最基础的代理形式,它的实现主要依靠继承或接口实现。在静态...

    JDK动态代理和CGLIB代理

    Java动态代理是Java编程中一个重要的特性,它允许我们在运行时创建对象的代理,从而实现对原对象的一些额外操作或扩展功能。JDK动态代理和CGLIB代理是两种常用的实现方式。 首先,我们来看看JDK动态代理。JDK动态...

Global site tag (gtag.js) - Google Analytics