当前位置:首页 > 图片 > 视野图片 > 正文
文章正文

java动态代理类 JAVA 动态代理

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

JAVA 动态代理

具体场景

为了使代理类和被代理类对第三方有相同的函数,代理类和被代理类一般实现一个公共的interface,该interface定义如下

被代理类定义如下

代理需求:在add函数和minus函数调用前后分别输出before invocation和after invocation字样

静态代理解决方案

代码如下:简单直接,无需赘言,如果calculator里边不仅有add和minus,还有divide,product,log,sin…呢,呵呵哒

动态代理解决方案

首先编写实现InvocationHandler接口的类,用于请求转发,实现如下

生成动态代理

无论calculator中包含多少函数,动态代理只需实现一次,实际工程中,System.out.println(“in calculatorhandler, before invocation”)可能是加缓存,打日志等操作

动态代理如何工作的

为了搞清楚动态代理如何工作,首先看看生成的动态代理的代码是什么,借助[1]中ProxyUtil代码

得到了生成的动态代理代码如下:

有点长,按照初始化顺序慢慢来分析,首先分析静态代码块:

得到公共interface中的add函数和minus函数对应的Method方法,同事也得到了equals,toString,hashCode三个函数的Method,所以调用代理类的equals,toString,hashCode也是要执行被代理类的方法的,知道这点很有必要

构造函数

初始化了内部的InvocationHandler变量,也就是下文的super.h

以add为例看一下请求的转发

super.h.invoke就是invocationhandler.invoke就是传入的CalculatorHandler中实现的

最终执行的就是CalculatorHandler对应的invoke函数

总结

生成动态代理的过程步骤如下[2]:

Proxy.newProxyInstance帮我们做了2,3,4步,直接返回给我们一个动态代理对象,代理对象最终执行InvocationHandler中invoke函数。顺便强推文章[2],自行复制链接即可打开。

References(java动态代理类)

  1. https://github.com/android-cn/android-open-project-demo/tree/master/java-dynamic-proxy

  2. https://www.ibm.com/developerworks/cn/java/j-lo-proxy1/index.html返回搜狐,查看更多

  3. (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

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

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

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

(java动态代理类)

接下来我们来看看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.

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

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

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

(java动态代理类)

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

publicinterfaceSubject { publicvoidrent(); publicvoidhello(String str); }

接着,定义了一个类来实现这个接口,这个类就是我们的真实对象,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类型了。

(java动态代理类)

同时我们一定要记住,通过 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中动态代理是怎么回事,和静态代理最大的区别是什么

在目前的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动态代理是什么

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动态代理与静态代理的定义与区别??5分

JAVA的静态代理与动态代理比较
一、概念
代理模式是常用的Java 设计模式,它的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息等。代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务。按照代理类的创建时期,代理类可分为两种。

静态代理类:
由程序员创建或由特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了。动态代理类:在程序运行时,运用反射机制动态创建胆抚册幌夭呵差童倡阔而成。

二、静态代理类
如下, HelloServiceProxy 类是代理类,HelloServiceImpl类是委托类,这两个类都实现了HelloService接口。其中HelloServiceImpl类是HelloService接口的真正实现者,而HelloServiceProxy类是通过调用HelloServiceImpl 类的相关方法来提供特定服务的。HelloServiceProxy类的echo()方法和getTime()方法会分别调用被代理的HelloServiceImpl 对象的echo()方法和getTime()方法,并且在方法调用前后都会执行一些简单的打印操作。

由此可见,代理类可以为委托类预处理消息、把消息转发给委托类和事后处理消息等。

例程1 HelloService.java
package proxy;
import java.util.Date;
public interface HelloService{
public String echo(String msg);
public Date getTime();
}
例程2 HelloServiceImpl.java
package proxy;
import java.util.Date;
public class HelloServiceImpl implements HelloService{
public String echo(String msg){
return "echo:"+msg;
}
public Date getTime(){
return new Date();
}
}
例程3 HelloServiceProxy.java
package proxy;
import java.util.Date;
public class HelloServiceProxy implements HelloService{
private HelloService helloService; //表示被代理的HelloService 实例
public HelloServiceProxy(HelloService helloService){
this.helloService=helloService;
}
public void setHelloServiceProxy(HelloService helloService){
this.helloService=helloService;
}
public String echo(String msg){
System.out......余下全文>>


四.如何获得Java动态代理的代理类

AOP的拦截功能是由java中的动态代理来实现的。说白了,就是在目标类的基础上增加切面逻辑,生成增强的目标类(该切面逻辑或者在目标类函数执行之前,或者目标类函数执行之后,或者在目标类函数抛出异常时候执行。不同的切入时机对应不同的Interceptor的种类,如BeforeAdviseInterceptor,AfterAdviseInterceptor以及ThrowsAdviseInterceptor等)。

那么动态代理是如何实现将切面逻辑(advise)织入到目标类方法中去的呢?下面我们就来详细介绍并实现AOP中用到的两种动态代理。

AOP的源码中用到了两种动态代理来实现拦截切入功能:jdk动态代理和cglib动态代理。两种方法同时存在,各有优劣。jdk动态代理是由Java内部的反射机制来实现的,cglib动态代理底层则是借助asm来实现的。总的来说,反射机制在生成类的过程中比较高效,而asm在生成类之后的相关执行过程中比较高效(可以通过将asm生成的类进行缓存,这样解决asm生成类过程低效问题)。还有一点必须注意:jdk动态代理的应用前提,必须是目标类基于统一的接口。如果没有上述前提,jdk动态代理不能应用。由此可以看出,jdk动态代理有一定的局限性,cglib这种第三方类库实现的动态代理应用更加广泛,且在效率上更有优势。。

1、定义接口和实现

[java] view plain copy print?
package com.meituan.hyt.test3.service;

public interface UserService {
public String getName(int id);

public Integer getAge(int id);
}

[java] view plain copy print?
package com.meituan.hyt.test3.service.impl;

import com.meituan.hyt.test3.service.UserService;

public class UserServiceImpl implements UserService {
@Override
public String getName(int id) {
System.out.println("------getName------");
return "Tom";
}

@Override
public Integer getAge(int id) {
System.out.println("------getAge------");
return 10;
}
}

2、jdk动态代理实现

[java] view plain copy print?
package com.meituan.hyt.test3.jdk;

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

public class MyInvocationHandler implements InvocationHandler {
private Object target;

MyInvocationHandler() {
super();
}
......余下全文>>


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

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


六.如何获得Java动态代理的代理类

JDK 代理生成器,在生成类是会根据参数“sun.misc.ProxyGenerator.saveGeneratedFiles”来决定是否将二进制保存到本地文件中,
具体的路径查看源码:
ProxyGenerator.access$000(this.val$name) + ".class"
根据access$000这个方法生成的路径来保存

在openjdk中这个access$000 是对应

private static String dotToSlash(String nam肠常斑端职得办全暴户e) {
return name.replace('.', '/');
}


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

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

反射是通过肌单冠竿攉放圭虱氦僵字节码文件对象,将类的字段,方法,构造器等映射成相应的类,并进行各自的操作;
类加载器是通过某个类的.classLoader()方法,将该类的.class文件从硬盘中加载到java虚拟机中,形成字节码文件;
动态代理是为了实现目标类的功能,并添加特有的系统功能,传入类加载器,目标类的接口,以及InvocationHandler接口的实现子类,
(InvocationHandler接口的invoke()方法,要传入代理对象,方法名,方法的参数,在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/pic60219/

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