当前位置:首页 > 图片 > 国内图片 > 正文
文章正文

java 动态代理原理 Java动态代理机制详解

图片 > 国内图片 > :java 动态代理原理 Java动态代理机制详解是由美文导刊网(www.eorder.net.cn)为您精心收集,如果觉得好,请把这篇文章复制到您的博客或告诉您的朋友,以下是java 动态代理原理 Java动态代理机制详解的正文:

Java动态代理机制详解

在学习Spring的时候,我们知道Spring主要有两大思想,一个是IoC,另一个就是AOP,对于IoC,依赖注入就不用多说了,而对于Spring的核心AOP来说,我们不但要知道怎么通过AOP来满足的我们的功能,我们更需要学习的是其底层是怎么样的一个原理,而AOP的原理就是java的动态代理机制,所以本篇随笔就是对java的动态机制进行一个回顾。

在java的动态代理机制中,有两个重要的类或接口,一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class),这一个类和接口是实现我们动态代理所必须用到的。首先我们先来看看java的API帮助文档是怎么样对这两个类进行描述的:

InvocationHandler:

InvocationHandler isthe interfaceimplemented bythe invocation handler ofa proxy instance. Eachproxy instance hasan associated invocation handler. When a methodisinvokedonaproxyinstance, themethodinvocationisencodedanddispatchedtotheinvokemethodofitsinvocationhandler.

每一个动态代理类都必须要实现InvocationHandler这个接口,并且每个代理类的实例都关联到了一个handler,当我们通过代理对象调用一个方法的时候,这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法:

Object invoke(Object proxy, Methodmethod, Object[] args) throwsThrowable(java 动态代理原理)

我们看到这个方法一共接受三个参数,那么这三个参数分别代表什么呢?

  • proxy:  指代我们所代理的那个真实对象
  • method:  指代的是我们所要调用真实对象的某个方法的Method对象
  • args:  指代的是调用真实对象某个方法时接受的参数

如果不是很明白,等下通过一个实例会对这几个参数进行更深的讲解。

接下来我们来看看Proxy这个类:

Proxy provides staticmethods forcreating dynamicproxy classes andinstances, andit isalso the superclass ofall dynamicproxy classes created bythose methods.

Proxy这个类的作用就是用来动态创建一个代理对象的类,它提供了许多的方法,但是我们用的最多的就是 newProxyInstance 这个方法:

publicstaticObject newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throwsIllegalArgumentException Returns an instance ofa proxy classforthe specified interfaces that dispatches methodinvocationstothespecifiedinvocationhandler.

这个方法的作用就是得到一个动态的代理对象,其接收三个参数,我们来看看这三个参数所代表的含义:

(java 动态代理原理)
  • loader:一个ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载
  • (java 动态代理原理)
  • interfaces:一个Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口,如果我提供了一组接口给它,那么这个代理对象就宣称实现了该接口(多态),这样我就能调用这组接口中的方法了
  • h:一个InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上

    好了,在介绍完这两个接口(类)以后,我们来通过一个实例来看看我们的动态代理模式是什么样的:

首先我们定义了一个Subject类型的接口,为其声明了两个方法:

publicinterfaceSubject { publicvoidrent(); publicvoidhello(String str); }(java 动态代理原理)

接着,定义了一个类来实现这个接口,这个类就是我们的真实对象,RealSubject类:

publicclassRealSubjectimplementsSubject{@Overridepublicvoidrent() { System.out.println( "I want to rent my house"); } @Overridepublicvoidhello(String str) { System.out.println( "hello: "+ str); } }

下一步,我们就要定义一个动态代理类了,前面说个,每一个动态代理类都必须要实现 InvocationHandler 这个接口,因此我们这个动态代理类也不例外:

publicclassDynamicProxyimplementsInvocationHandler{// 这个就是我们要代理的真实对象privateObject subject; // 构造方法,给我们要代理的真实对象赋初值publicDynamicProxy(Object subject) { this.subject = subject; } @OverridepublicObject invoke(Object object, Method method, Object[] args) throwsThrowable { //  在代理真实对象前我们可以添加一些自己的操作System.out.println( "before rent house"); System.out.println( "Method:"+ method); // 当代理对象调用真实对象的方法时,其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用method.invoke(subject, args); //  在代理真实对象后我们也可以添加一些自己的操作System.out.println( "after rent house"); returnnull; } }

最后,来看看我们的Client类:

/** * Java学习交流QQ群:589809992 我们一起学Java! */publicclassClient{publicstaticvoidmain(String[] args) { // 我们要代理的真实对象Subject realSubject = newRealSubject(); // 我们要代理哪个真实对象,就将该对象传进去,最后是通过该真实对象来调用其方法的InvocationHandler handler = newDynamicProxy(realSubject); /* * 通过Proxy的newProxyInstance方法来创建我们的代理对象,我们来看看其三个参数 * 第一个参数 handler.getClass().getClassLoader() ,我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象 * 第二个参数realSubject.getClass().getInterfaces(),我们这里为代理对象提供的接口是真实对象所实行的接口,表示我要代理的是该真实对象,这样我就能调用这组接口中的方法了 * 第三个参数handler, 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上 */Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject .getClass().getInterfaces(), handler); System.out.println(subject.getClass().getName()); subject.rent(); subject.hello( "world"); } }

我们先来看看控制台的输出:

$Proxy0 before rent house Method:public abstract void com.xiaoluo.dynamicproxy.Subject.rent() I want to rent my house after rent house before rent house Method:public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java .lang.String) hello:world after rent house

我们首先来看看 $Proxy0 这东西,我们看到,这个东西是由 System.out.println(subject.getClass().getName()); 这条语句打印出来的,那么为什么我们返回的这个代理对象的类名是这样的呢?

Subject subject = (Subject)Proxy .newProxyInstance(handler .getClass() .getClassLoader(), realSubject .getClass() .getInterfaces(), handler) ;

可能我以为返回的这个代理对象会是Subject类型的对象,或者是InvocationHandler的对象,结果却不是,首先我们解释一下为什么我们这里可以将其转化为Subject类型的对象?原因就是在newProxyInstance这个方法的第二个参数上,我们给这个代理对象提供了一组什么接口,那么我这个代理对象就会实现了这组接口,这个时候我们当然可以将这个代理对象强制类型转化为这组接口中的任意一个,因为这里的接口是Subject类型,所以就可以将其转化为Subject类型了。

同时我们一定要记住,通过 Proxy.newProxyInstance 创建的代理对象是在jvm运行时动态生成的一个对象,它并不是我们的InvocationHandler类型,也不是我们定义的那组接口的类型,而是在运行是动态生成的一个对象,并且命名方式都是这样的形式,以$开头,proxy为中,最后一个数字表示对象的标号。

接着我们来看看这两句

subject.rent();

subject.hello(“world”);

这里是通过代理对象来调用实现的那种接口中的方法,这个时候程序就会跳转到由这个代理对象关联到的 handler 中的invoke方法去执行,而我们的这个 handler 对象又接受了一个 RealSubject类型的参数,表示我要代理的就是这个真实对象,所以此时就会调用 handler 中的invoke方法去执行:

/** * Java学习交流QQ群:589809992 我们一起学Java! */publicObject invoke(Object object, Method method, Object[] args) throwsThrowable { //  在代理真实对象前我们可以添加一些自己的操作System.out.println( "before rent house"); System.out.println( "Method:"+ method); // 当代理对象调用真实对象的方法时,其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用method.invoke(subject, args); //  在代理真实对象后我们也可以添加一些自己的操作System.out.println( "after rent house"); returnnull; }

我们看到,在真正通过代理对象来调用真实对象的方法的时候,我们可以在该方法前后添加自己的一些操作,同时我们看到我们的这个 method 对象是这样的:

public abstract void com.xiaoluo.dynamicproxy.Subject.rent() public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java .lang.String)

正好就是我们的Subject接口中的两个方法,这也就证明了当我通过代理对象来调用方法的时候,起实际就是委托由其关联到的 handler 对象的invoke方法中来调用,并不是自己来真实调用,而是通过代理的方式来调用的。

这就是我们的java动态代理机制。

本篇随笔详细的讲解了java中的动态代理机制,这个知识点非常非常的重要,包括我们Spring的AOP其就是通过动态代理的机制实现的,所以我们必须要好好的理解动态代理的机制。返回搜狐,查看更多


一.java什么是动态代理机制,谢谢!

护钉篙固蕻改戈爽恭鲸这个讲的比较详细。我这里就不多说了。
blog.csdn.net/...914697


二.java中动态代理是怎么回事,和静态代理最大的区别是什么

在目前的Java开发包中包含了对动态代理的支持,但是其实现只支持对接口的的实现。

其实现主要通过是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。

Proxy类主要用来获取动态代理对象,InvocationHandler接口用来约束调用者实现,如下,HelloWorld接口定义的业务方法,HelloWorldImpl是HelloWorld接口的实现,HelloWorldHandler是 InvocationHandler接口实现。代码如下:

业务接口:

public interface HelloWorld {
void sayHelloWorld() ;

}

业务接口实现:

public class HelloWorldImpl implements HelloWorld {
public void sayHelloWorld() {

System.out.println("Hello World!");

}

}

InvocationHandler实现,需要在接口方法调用前后加入一部份处理工作,这里仅仅在方法调用前后向后台输出两句字符串,其代码如下:

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

public class HelloWorldHandler implements InvocationHandler {

//要代理的原始对象

private Object objOriginal;

/**

* 构造函数。

* @param obj 要代理的原始对象。

*/

public HelloWorldHandler(Object obj) {

this.objOriginal = obj ;

}

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

Object result ;

//方法调用之前

doBefore();

//调用原始对象的方法

result = method.invoke(this.objOriginal ,args);

//方法调用之后

doAfter();

return result ;

}

private void doBefore() {

System.out.println("before method invoke!");

}

private void doAfter() {

System.out.println("after method invoke!");

}

}

测试代码:

import java.lang.reflect.InvocationHandler;
import java.......余下全文>>


三.java中反射、类加载器、动态代理之间的关系

你最好把结合框架 i/o复习好 还有多线程 线程池和反射 复习好 内加载器和代理 就问一下定义 老师给的现场笔试都是i/o 和集合框架
反射是Java的最重要的底层知识。而动态代理其实质就是依靠反射来实现的。

反射是通过肌单冠竿攉放圭虱氦僵字节码文件对象,将类的字段,方法,构造器等映射成相应的类,并进行各自的操作;
类加载器是通过某个类的.classLoader()方法,将该类的.class文件从硬盘中加载到java虚拟机中,形成字节码文件;
动态代理是为了实现目标类的功能,并添加特有的系统功能,传入类加载器,目标类的接口,以及InvocationHandler接口的实现子类,
(InvocationHandler接口的invoke()方法,要传入代理对象,方法名,方法的参数,在invoke方法中,可以添加特有的系统功能)
然后就可以根据运行时,目标类的不同,以及要实现系统功能的不同,动态生成代理类,来完成相应的功能类的创建;


四.Java中的动态代理相对于静态代理有何优点?

动态代理不需要自己写代理类咯


五.java反射和动态代理有什么关系

当然有了,发射是Java的最重要的底层知识。而动态代理其实质就是依靠反射来实现的。


六.java动态代理是什么

(java 动态代理原理)

import java.lang.reflect.Proxy;
A.创建一个实现接口InvocationHandler的类,他必须实现invoke方法
B.创建被代理的类以及接口。
C.通过Proxy的静态方法newProxyInstance(ClassLoader loader,Class【】interfaces,InvocationHandler handler)创建一个代理
D.通过代理调用方法。
java动态代理:是在运行是生成的class对象,在生成时必须提供一组或一个interface给它,然后该class就宣称它实现了这些interface。你当然可以把该class的实例当做这些interface中的任何一个来用,当然,这个DynamicProxy其实就是一个Proxy,他不会替你做实质性的工作,在生成它的实例时你必须提供一个handler,由它接管实际的工作。因此,Dynam骇罚粪核荼姑讽太釜咖icProxy必须实现InvocationHandler接口。
5)一个动态代理了和一个InvocationHandler 实现关联的。每一个动态代理实例的调用都要通过InvocationHandler接口的handler(调用处理器)来调用,动态代理不做任何执行操作,只是在创建动态代理时,把要实现的接口和handler关联,动态代理要帮助被代理执行的任务,要转交给handler来执行。其实就是调用invoke方法。

JAVA的动态代理
代理模式
代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息等。代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务。
按照代理的创建时期,代理类可以分为两种。
静态代理:由程序员创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了骇罚粪核荼姑讽太釜咖。
动态代理:在程序运行时,运用反射机制动态创建而成。


七.京东面试题 java 动态代理主要怎么实现的

在目前的Java开发包中包含了对动态代理的支持,但是其实现只支持对接口的的实现。

其实现主要通过是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。

Proxy
类主要用来获取动态代理对象,InvocationHandler接口用来约束调用者实现,如下,HelloWorld接口定义的业务方
法,HelloWorldImpl是HelloWorld接口的实现,HelloWorldHandler是InvocationHandler接口实
现。代码如下:

业务接口:

public interface HelloWorld {

void sayHelloWorld() ;

}

业务接口实现:

public class HelloWorldImpl implements HelloWorld {

public void sayHelloWorld() {

System.out.println("Hello World!");

}

}

InvocationHandler实现,需要在接口方法调用前后加入缉哗光狙叱缴癸斜含铆一部份处理工作,这里仅仅在方法调用前后向后台输出两句字符串,其代码如下:

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

public class HelloWorldHandler implements InvocationHandler {

//要代理的原始对象

private Object objOriginal;

/**

* 构造函数。

* @param obj 要代理的原始对象。

*/

public HelloWorldHandler(Object obj) {

this.objOriginal = obj ;

}

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

Object result ;

//方法调用之前

doBefore();

//调用原始对象的方法

result = method.invoke(this.objOriginal ,args);

//方法调用之后

doAfter();

return result ;

}

private void doBefore() {

System.out.println("before method invoke!");

}

private void doAfter() {

System.out.println("after method invoke!&......余下全文>>


八.spring的动态代理有几种实现方式

JAVA 代理实现
代理的实现分动态代理和静态代理,静态代理的实现是对已经生成了的JAVA类进行封装。
动态代理则是在运行时生成了相关代理累,在JAVA中生成动态代理一般有两种方式。

JDK自带实现方法
JDK实现代理生成,是用类 java.lang.reflect.Proxy, 实现方式如下
EX:
public class JDKProxy { public static Object getPoxyObject(final Object c) { return Proxy.newProxyInstance(c.getClass().getClassLoader(), c.getClass().getInterfaces(),// JDK实现动态代理,但JDK实现必须需要接口 new InvocationHandler() { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub Object reObj = null; System.out.print("you say: "); reObj = method.invoke(c, args); System.out.println(" [" + Calendar.getInstance().get(Calendar.HOUR) + ":" + Calendar.getInstance().get(Calendar.MINUTE) + " " + Calendar.getInstance().get(Calendar.SECOND) + "]"); return reObj; } }); }}测试代理类方法
public class TestForPoxy { public static void main(String[] args) { ServiceTest service = new ServiceTestImpl(); System.out.println(service.getClass().getSimpleName()); ServiceTest po......余下全文>>

查看"编程语言"分类更多问题

回顶部↑

九.java的动态代理为什么要用接口

java的动态代理是要代理一大堆类,用类你怎么实现这个功能呢

java 动态代理原理 Java动态代理机制详解由美文导刊网(www.eorder.net.cn)收集整理,转载请注明出处!原文地址http://www.eorder.net.cn/pic60228/

文章评论
Copyright © 2006 - 2016 www.eorder.net.cn All Rights Reserved
美文导刊网 版权所有