java生成的proxy代理類（java動態代理生成的類）

本文目錄一覽：

• 1、Java代理的作用和實現？
• 2、Java的動態代理(Proxy.newInstance)是根據傳遞的參數拼接一個實現了所傳遞的介面
• 3、java 動態代理怎麼理解
• 4、java 動態代理 生成的$Proxy0 用什麼方式可以獲取$Proxy0類的源碼
• 5、如何獲得Java動態代理的代理類

Java代理的作用和實現？

代理模式的作用是：為其他對象提供一種代理以控制對這個對象的訪問。在某些情況下，一個客戶不想或者不能直接引用另一個對象，而代理對象可以在客戶端和目標對象之間起到中介的作用。

Java的動態代理(Proxy.newInstance)是根據傳遞的參數拼接一個實現了所傳遞的介面

對，但是我們的直覺不太一樣。Proxy。newInstance方法是使用ProxyGenerator來動態生成位元組碼的，生成的是位元組碼所以沒有編譯過程。

通過ProxyGenerator生成的位元組碼代表的類繼承了Proxy類，實現了newInstance參數傳遞進來的介面，只不過是代理所以在生成的類中都是通過newInstance方法的InvocationHandler的invoke方法代理的。

可以看一下這一篇文章，看一下ProxyGenerator生成的位元組碼反編譯之後的類的樣子，更加有助於理解Proxy方式的動態代理。

java 動態代理怎麼理解

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.println(“before calling echo()”); //預處理

String result=helloService.echo(msg); //調用被代理的HelloService 實例的echo()方法

System.out.println(“after calling echo()”); //事後處理

return result;

}

public Date getTime(){

System.out.println(“before calling getTime()”); //預處理

Date date=helloService.getTime(); //調用被代理的HelloService 實例的getTime()方法

System.out.println(“after calling getTime()”); //事後處理

return date;

}

}

在Client1 類的main()方法中，先創建了一個HelloServiceImpl對象，又創建了一個HelloServiceProxy對象，最後調用HelloServiceProxy對象的echo()方法。

常式4 Client1.java

package proxy;

public class Client1{

public static void main(String args[]){

HelloService helloService=new HelloServiceImpl();

HelloService helloServiceProxy=new HelloServiceProxy(helloService);

System.out.println(helloServiceProxy.echo(“hello”));

}

}

運行Client1 類，列印結果如下：

before calling echo()

after calling echo()

echo:hello

常式3 的HelloServiceProxy 類的源代碼是由程序員編寫的，在程序運行前，它的.class文件就已經存在了，這種代理類稱為靜態代理類。

三、動態代理類

與靜態代理類對照的是動態代理類，動態代理類的位元組碼在程序運行時由Java反射機制動態生成，無需程序員手工編寫它的源代碼。動態代理類不僅簡化了編程工作，而且提高了軟體系統的可擴展性，因為Java 反射機制可以生成任意類型的動態代理類。java.lang.reflect 包中的Proxy類和InvocationHandler 介面提供了生成動態代理類的能力。

Proxy類提供了創建動態代理類及其實例的靜態方法。

（1）getProxyClass()靜態方法負責創建動態代理類，它的完整定義如下：

public static Class getProxyClass(ClassLoader loader, Class[] interfaces) throws IllegalArgumentException

參數loader 指定動態代理類的類載入器，參數interfaces 指定動態代理類需要實現的所有介面。

（2）newProxyInstance()靜態方法負責創建動態代理類的實例，它的完整定義如下：

public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler handler) throws

IllegalArgumentException

參數loader 指定動態代理類的類載入器，參數interfaces 指定動態代理類需要實現的所有介面，參數handler 指定與動態代理類關聯的 InvocationHandler 對象。

以下兩種方式都創建了實現Foo介面的動態代理類的實例：

/**** 方式一 ****/

//創建InvocationHandler對象

InvocationHandler handler = new MyInvocationHandler(…);

//創建動態代理類

Class proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), new Class[] { Foo.class });

//創建動態代理類的實例

Foo foo = (Foo) proxyClass.getConstructor(new Class[] { InvocationHandler.class }).

newInstance(new Object[] { handler });

/**** 方式二 ****/

//創建InvocationHandler對象

InvocationHandler handler = new MyInvocationHandler(…);

//直接創建動態代理類的實例

Foo foo = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class[] { Foo.class }, handler);

由Proxy類的靜態方法創建的動態代理類具有以下特點：

動態代理類是public、final和非抽象類型的；

動態代理類繼承了java.lang.reflect.Proxy類；

動態代理類的名字以「$Proxy」開頭；

動態代理類實現getProxyClass()和newProxyInstance()方法中參數interfaces指定的所有介面；

Proxy 類的isProxyClass(Class cl)靜態方法可用來判斷參數指定的類是否為動態代理類。只有通過Proxy類創建的類才是動態代理類；

動態代理類都具有一個public 類型的構造方法，該構造方法有一個InvocationHandler 類型的參數。

由Proxy類的靜態方法創建的動態代理類的實例具有以下特點：

1. 假定變數foo 是一個動態代理類的實例，並且這個動態代理類實現了Foo 介面，那麼「foo instanceof Foo」的值為true。把變數foo強制轉換為Foo類型是合法的：

(Foo) foo //合法

2.每個動態代理類實例都和一個InvocationHandler 實例關聯。Proxy 類的getInvocationHandler(Object proxy)靜態方法返回與參數proxy指定的代理類實例所關聯的InvocationHandler 對象。

3.假定Foo介面有一個amethod()方法，那麼當程序調用動態代理類實例foo的amethod()方法時，該方法會調用與它關聯的InvocationHandler 對象的invoke()方法。

InvocationHandler 介面為方法調用介面，它聲明了負責調用任意一個方法的invoke()方法：

Object invoke(Object proxy,Method method,Object[] args) throws Throwable

參數proxy指定動態代理類實例，參數method指定被調用的方法，參數args 指定向被調用方法傳遞的參數，invoke()方法的返回值表示被調用方法的返回值。

四、最後看一個實例：

HelloServiceProxyFactory 類的getHelloServiceProxy()靜態方法負責創建實現了HelloService介面的動態代理類的實例。

常式5 HelloServiceProxyFactory.java

package proxy;

import java.lang.reflect.*;

public class HelloServiceProxyFactory {

/** 創建一個實現了HelloService 介面的動態代理類的實例

* 參數helloService 引用被代理的HelloService 實例

*/

public static HelloService getHelloServiceProxy(final HelloService helloService){

//創建一個實現了InvocationHandler介面的匿名類的實例

InvocationHandler handler=new InvocationHandler(){

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

System.out.println(“before calling “+method); //預處理

Object result=method.invoke(helloService,args);

//調用被代理的HelloService 實例的方法

System.out.println(“after calling “+method); //事後處理

return result;

}

};

Class classType=HelloService.class;

return (HelloService)Proxy.newProxyInstance(classType.getClassLoader(),

new Class[]{classType},

handler);

}

}

如下所示的Client2 類先創建了一個HelloServiceImpl 實例，然後創建了一個動態代理類實例helloServiceProxy，最後調用動態代理類實例的echo()方法。

常式6 Client2.java

package proxy;

public class Client2{

public static void main(String args[]){

HelloService helloService=new HelloServiceImpl();

HelloService helloServiceProxy=HelloServiceProxyFactory.getHelloServiceProxy(helloService);

System.out.println(“動態代理類的名字為”+helloServiceProxy.getClass().getName());

System.out.println(helloServiceProxy.echo(“Hello”));

}

}

運行Client2，列印結果如下：

動態代理類的名字為$Proxy0

before calling public abstract java.lang.String proxy.HelloService.echo(java.lang.String)

after calling public abstract java.lang.String proxy.HelloService.echo(java.lang.String)

echo:Hello

從結果看出，動態代理類的名字為$Proxy0。

PostScript

java 動態代理 生成的$Proxy0 用什麼方式可以獲取$Proxy0類的源碼

Proxy 提供用於創建動態代理類和實例的靜態方法.

newProxyInstance()

返回一個指定介面的代理類實例，該介面可以將方法調用指派到指定的調用處理程序

java.lang.reflect.InvocationHandler,

InvocationHandler 是代理實例的調用處理程序 實現的介面。

invoke()

在代理實例上處理方法調用並返回結果。在與方法關聯的代理實例上調用方法時，將在調用處理程序上調用此方法。

如何獲得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();

}

MyInvocationHandler(Object target) {

super();

this.target = target;

}

@Override

public Object invoke(Object o, Method method, Object[] args) throws Throwable {

if(“getName”.equals(method.getName())){

System.out.println(“++++++before ” + method.getName() + “++++++”);

Object result = method.invoke(target, args);

System.out.println(“++++++after ” + method.getName() + “++++++”);

return result;

}else{

Object result = method.invoke(target, args);

return result;

}

}

}

[java] view plain copy print?

package com.meituan.hyt.test3.jdk;

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

import com.meituan.hyt.test3.service.impl.UserServiceImpl;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Proxy;

public class Main1 {

public static void main(String[] args) {

UserService userService = new UserServiceImpl();

InvocationHandler invocationHandler = new MyInvocationHandler(userService);

UserService userServiceProxy = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),

userService.getClass().getInterfaces(), invocationHandler);

System.out.println(userServiceProxy.getName(1));

System.out.println(userServiceProxy.getAge(1));

}

}

運行結果

++++++before getName++++++

——getName——

++++++after getName++++++

Tom

——getAge——

10

3、cglib動態代理實現

Cglib是一個優秀的動態代理框架，它的底層使用ASM在內存中動態的生成被代理類的子類，使用CGLIB即使代理類沒有實現任何介面也可以實現動態代理功能。CGLIB具有簡單易用，它的運行速度要遠遠快於JDK的Proxy動態代理：

CGLIB的核心類：

net.sf.cglib.proxy.Enhancer – 主要的增強類

net.sf.cglib.proxy.MethodInterceptor – 主要的方法攔截類，它是Callback介面的子介面，需要用戶實現

net.sf.cglib.proxy.MethodProxy – JDK的java.lang.reflect.Method類的代理類，可以方便的實現對源對象方法的調用,如使用：

Object o = methodProxy.invokeSuper(proxy, args);//雖然第一個參數是被代理對象，也不會出現死循環的問題。

net.sf.cglib.proxy.MethodInterceptor介面是最通用的回調（callback）類型，它經常被基於代理的AOP用來實現攔截（intercept）方法的調用。這個介面只定義了一個方法

public Object intercept(Object object, java.lang.reflect.Method method,

Object[] args, MethodProxy proxy) throws Throwable;

第一個參數是代理對像，第二和第三個參數分別是攔截的方法和方法的參數。原來的方法可能通過使用java.lang.reflect.Method對象的一般反射調用，或者使用 net.sf.cglib.proxy.MethodProxy對象調用。net.sf.cglib.proxy.MethodProxy通常被首選使用，因為它更快。

[java] view plain copy print?

package com.meituan.hyt.test3.cglib;

import net.sf.cglib.proxy.MethodInterceptor;

import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {

@Override

public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

System.out.println(“++++++before ” + methodProxy.getSuperName() + “++++++”);

System.out.println(method.getName());

Object o1 = methodProxy.invokeSuper(o, args);

System.out.println(“++++++before ” + methodProxy.getSuperName() + “++++++”);

return o1;

}

}

[java] view plain copy print?

package com.meituan.hyt.test3.cglib;

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

import com.meituan.hyt.test3.service.impl.UserServiceImpl;

import net.sf.cglib.proxy.Enhancer;

public class Main2 {

public static void main(String[] args) {

CglibProxy cglibProxy = new CglibProxy();

Enhancer enhancer = new Enhancer();

enhancer.setSuperclass(UserServiceImpl.class);

enhancer.setCallback(cglibProxy);

UserService o = (UserService)enhancer.create();

o.getName(1);

o.getAge(1);

}

}

運行結果：

++++++before CGLIB$getName$0++++++

getName

——getName——

++++++before CGLIB$getName$0++++++

++++++before CGLIB$getAge$1++++++

getAge

——getAge——

++++++before CGLIB$getAge$1++++++