javaproxy代理

① 如何用java使用代理

Java中，使用proxy是通過設置java環境變數來實現的，也就是JVM的系統屬性。

我們需要設置三個屬性，proxySet proxyHost和proxyPort。
proxySet 是個boolean類型的，可以設置為true或者false，true代表使用代理伺服器。
proxyHost 是代理伺服器的IP地址
proxyPort 是代理伺服器的埠地址。

我們有兩種方法設置這種系統屬性，
一種是命令行下運行Java程序的時候，通過參數付值
一種是在java源程序中設置。

第一種方法的格式如下：
java -DproxySet=true -DproxyHost=myProxyServer.come -DproxyPort=80 MyJavaApp

第二種方法，就是直接在源程序中通過系統屬性來寫，如下：
import java.util.Properties;
...
...

strProxy="221.15.5.67";
strPort="8080";

Properties systemProperties = System.getProperties();
systemProperties.setProperty("http.proxyHost",strProxy);
systemProperties.setProperty("http.proxyPort",strPort);
....

JDK1.3以上版本，只要設置了proxyHost和proxyPort就不用寫proxySet了。

那麼反過來，顯示這些系統屬性，就可以看到有沒有使用代理了。

② Java怎麼設置代理來訪問網路

你的問題應該是：在java中通過編程設置代理伺服器並訪問網路，現在作答如下：

1，講解一下基礎知識：
HTTP：是應用層協議，是基於傳輸層協議的。
TCP: 是傳輸層協議，是基於網路層協議的。
IP: 是網路層協議。
一個TCP的連接要進行三次握手（就像轉戶口一樣，不詳說），HTTP只是一個應用協議，也就是相當於一個自定義協議，即其沒有對底層的傳輸方式進行干涉，只是對數據內容格式進行了定義。

2，我們再說說HTTP代理，從上可以理解，HTTP代理伺服器就是這樣一台機器：你把所有的HTTP請求都發到這個 HTTP代理伺服器，然後這個HTTP代理伺服器請求你要訪問的最終地址，把響應回傳給你。這里還要注意它代理的是HTTP協議，而HTTP又是基於 TCP的，也就是說這個伺服器代理的是指定HTTP內容格式的TCP連接。再說下去也沒意思了，看以下代碼：
//以下地址是代理伺服器的地址
Socket socket = new Socket("10.1.2.188", 80);
//寫與的內容就是遵循HTTP請求協議格式的內容，請求網路
socket.getOutputStream().write(new String("GET http://www..com/ HTTP/1.1\r\n\r\n").getBytes());
byte[] bs = new byte[1024];
InputStream is = socket.getInputStream();
int i;
while ((i = is.read(bs)) > 0) {
System.out.println(new String(bs, 0, i));
}
is.close();
3，當然在Java中，有Proxy代理上網的使用，此時使用URL(HTTP)就不涉及Socket(TCP)了，看如下代碼
//設置代理
System.setProperty("http.proxySet", "true");
System.setProperty("http.proxyHost", "10.1.2.188");
System.setProperty("http.proxyPort", "80");

//直接訪問目的地址
URL url = new URL("http://www..com");
URLConnection con = url.openConnection();
InputStreamReader isr = new InputStreamReader(con.getInputStream());
char[] cs = new char[1024];
int i = 0;
while ((i = isr.read(cs)) > 0) {
System.out.println(new String(cs, 0, i));
}
isr.close();

③ Java 中怎樣在程序中設置代理伺服器

importjava.io.BufferedReader;
importjava.io.InputStreamReader;
importjava.net.Authenticator;
importjava.net.HttpURLConnection;
importjava.net.InetSocketAddress;
importjava.net.PasswordAuthentication;
importjava.net.Proxy;
importjava.net.URL;

publicclassProxyDemo2{
publicstaticvoidmain(String[]args)throwsException{
URLurl=newURL("http://www.3lai8.com");
///創建代理伺服器
InetSocketAddressaddr=newInetSocketAddress("192.168.0.254",8080);
//Proxyproxy=newProxy(Proxy.Type.SOCKS,addr);//Socket代理
Proxyproxy=newProxy(Proxy.Type.HTTP,addr);//http代理
Authenticator.setDefault(newMyAuthenticator("username","password"));//設置代理的用戶和密碼
HttpURLConnectionconnection=(HttpURLConnection)url.openConnection(proxy);//設置代理訪問
InputStreamReaderin=newInputStreamReader(connection.getInputStream());
BufferedReaderreader=newBufferedReader(in);
while(true){
Strings=reader.readLine();
if(s!=null){
System.out.println(s);
}
}
}

{
privateStringuser="";
privateStringpassword="";

publicMyAuthenticator(Stringuser,Stringpassword){
this.user=user;
this.password=password;
}

(){
(user,password.toCharArray());
}
}

}

④ 如何使用Proxy模式及Java內建的動態代理機制

在學習Spring的時候，我們知道Spring主要有兩大思想，一個是IoC，另一個就是AOP，對於IoC，依賴注入就不用多說了，而對於Spring的核心AOP來說，我們不但要知道怎麼通過AOP來滿足的我們的功能，我們更需要學習的是其底層是怎麼樣的一個原理，而AOP的原理就是java的動態代理機制，所以本篇隨筆就是對java的動態機制進行一個回顧。
在java的動態代理機制中，有兩個重要的類或介面，一個是 InvocationHandler(Interface)、另一個則是 Proxy(Class)，這一個類和介面是實現我們動態代理所必須用到的。首先我們先來看看java的API幫助文檔是怎麼樣對這兩個類進行描述的：
InvocationHandler:
InvocationHandler is the interface implemented by the invocation handler of a proxy instance.

Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the invoke method of its invocation handler.

每一個動態代理類都必須要實現InvocationHandler這個介面，並且每個代理類的實例都關聯到了一個handler，當我們通過代理對象調用一個方法的時候，這個方法的調用就會被轉發為由InvocationHandler這個介面的 invoke 方法來進行調用。我們來看看InvocationHandler這個介面的唯一一個方法 invoke 方法：
Object invoke(Object proxy, Method method, Object[] args) throws Throwable

我們看到這個方法一共接受三個參數，那麼這三個參數分別代表什麼呢？
Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy:指代我們所代理的那個真實對象
method:指代的是我們所要調用真實對象的某個方法的Method對象
args:指代的是調用真實對象某個方法時接受的參數

如果不是很明白，等下通過一個實例會對這幾個參數進行更深的講解。
接下來我們來看看Proxy這個類：
Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.

Proxy這個類的作用就是用來動態創建一個代理對象的類，它提供了許多的方法，但是我們用的最多的就是 newProxyInstance 這個方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
Returns an instance of a proxy class for the specified interfaces that dispatches method invocations to the specified invocation handler.

這個方法的作用就是得到一個動態的代理對象，其接收三個參數，我們來看看這三個參數所代表的含義：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

loader:一個ClassLoader對象，定義了由哪個ClassLoader對象來對生成的代理對象進行載入

interfaces:一個Interface對象的數組，表示的是我將要給我需要代理的對象提供一組什麼介面，如果我提供了一組介面給它，那麼這個代理對象就宣稱實現了該介面(多態)，這樣我就能調用這組介面中的方法了

h:一個InvocationHandler對象，表示的是當我這個動態代理對象在調用方法的時候，會關聯到哪一個InvocationHandler對象上

好了，在介紹完這兩個介面(類)以後，我們來通過一個實例來看看我們的動態代理模式是什麼樣的：
首先我們定義了一個Subject類型的介面，為其聲明了兩個方法：
public interface Subject
{
public void rent();

public void hello(String str);
}

接著，定義了一個類來實現這個介面，這個類就是我們的真實對象，RealSubject類：

public class RealSubject implements Subject
{
@Override
public void rent()
{
System.out.println("I want to rent my house");
}

@Override
public void hello(String str)
{
System.out.println("hello: " + str);
}
}

下一步，我們就要定義一個動態代理類了，前面說個，每一個動態代理類都必須要實現 InvocationHandler 這個介面，因此我們這個動態代理類也不例外：

public class DynamicProxy implements InvocationHandler
{
//這個就是我們要代理的真實對象
private Object subject;

// 構造方法，給我們要代理的真實對象賦初值
public DynamicProxy(Object subject)
{
this.subject = subject;
}

@Override
public Object invoke(Object object, Method method, Object[] args)
throws Throwable
{
//在代理真實對象前我們可以添加一些自己的操作
System.out.println("before rent house");

System.out.println("Method:" + method);

// 當代理對象調用真實對象的方法時，其會自動的跳轉到代理對象關聯的handler對象的invoke方法來進行調用
method.invoke(subject, args);

//在代理真實對象後我們也可以添加一些自己的操作
System.out.println("after rent house");

return null;
}

}

最後，來看看我們的Client類：

public class Client
{
public static void main(String[] args)
{
// 我們要代理的真實對象
Subject realSubject = new RealSubject();

// 我們要代理哪個真實對象，就將該對象傳進去，最後是通過該真實對象來調用其方法的
InvocationHandler handler = new DynamicProxy(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方法去執行：

public Object invoke(Object object, Method method, Object[] args)
throws Throwable
{
//在代理真實對象前我們可以添加一些自己的操作
System.out.println("before rent house");

System.out.println("Method:" + method);

// 當代理對象調用真實對象的方法時，其會自動的跳轉到代理對象關聯的handler對象的invoke方法來進行調用
method.invoke(subject, args);

//在代理真實對象後我們也可以添加一些自己的操作
System.out.println("after rent house");

return null;
}

我們看到，在真正通過代理對象來調用真實對象的方法的時候，我們可以在該方法前後添加自己的一些操作，同時我們看到我們的這個 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代理的作用和實現

JDK 動態代理

動態代理的核心其實就是代理對象的生成，即 Proxy.newProxyInstance(classLoader, proxyInterface, handler)。

讓我們進入newProxyInstance方法觀摩下，核心代碼其實就三行。

這個方法需要三個參數：

• ClassLoader，用於載入代理類的 Loader 類，通常這個 Loader 和被代理的類是同一個 Loader 類。

• Interfaces，是要被代理的那些那些介面。

• InvocationHandler，就是用於執行除了被代理介面中方法之外的用戶自定義的操作，也是用戶需要代理的最終目的。用戶調用目標方法都被代理到 InvocationHandler 類中定義的唯一方法 invoke 中。

• //獲取代理類 Class cl = getProxyClass(loader, interfaces);


• //獲取帶有InvocationHandler參數的構造方法 Constructor cons = cl.getConstructor(constructorParams);


• //把handler傳入構造方法生成實例 return (Object) cons.newInstance(new Object[] { h });



一個典型的動態代理創建對象過程可分為以下四個步驟：

1、通過實現InvocationHandler介面創建調用處理器

• IvocationHandler handler = new InvocationHandlerImpl(...);



2、通過為Proxy類指定ClassLoader對象和一組interface創建動態代理類

• Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});



3、通過反射機制獲取動態代理類的構造函數，其參數類型是調用處理器介面類型

• Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});



4、通過構造函數創建代理類實例，此時需將調用處理器對象作為參數被傳入

• Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));



為了簡化對象創建過程，Proxy類中的newProxyInstance方法封裝了2~4，只需兩步即可完成代理對象的創建。

• Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),


• new Class[]{Subject.class}, new InvocationHandlerImpl (real));



生成的proxySubject繼承Proxy類實現Subject介面。實現的Subject的方法實際是調用處理器的invoke方法，而invoke方法利用反射調用的是被代理對象的方法（Object result=method.invoke(proxied,args)）；
重點Proxy.newProxyInstance，源碼分析，會在其他文檔中單獨總結記錄。類Proxy的getProxyClass方法調用ProxyGenerator的 generateProxyClass方法產生ProxySubject.class的二進制數據。

創建代理對象時序圖



獲取代理類

getProxyClass(loader, interfaces)方法用於獲取代理類，它主要做了三件事情：

在當前類載入器的緩存里搜索是否有代理類，沒有則生成代理類並緩存在本地JVM里。

• // 緩存的key使用介面名稱生成的List Object key = Arrays.asList(interfaceNames);


• synchronized (cache) {


• do {


• Object value = cache.get(key);


• // 緩存里保存了代理類的引用 if (value instanceof Reference) {


• proxyClass = (Class) ((Reference) value).get();


• }


• if (proxyClass != null) {


• // 代理類已經存在則返回


• return proxyClass;


• } else if (value == pendingGenerationMarker) {


• // 如果代理類正在產生，則等待


• try {


• cache.wait();


• } catch (InterruptedException e) {


• }


• continue;


• } else {


• //沒有代理類，則標記代理准備生成


• cache.put(key, pendingGenerationMarker);


• break;


• }


• } while (true);


• }



生成並載入代理類

代理類的生成主要是以下這兩行代碼：

• //生成代理類的位元組碼文件並保存到硬碟中(默認不保存到硬碟) proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);


• //使用類載入器將位元組碼載入到內存中 proxyClass = defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);



代理類的生成過程


ProxyGenerator.generateProxyClass()方法屬於sun.misc包下，Oracle並沒有提供源代碼，但是我們可以使用
JD-GUI這樣的反編譯軟體打開jrelib t.jar來一探究竟，以下是其核心代碼的分析。

• //添加介面中定義的方法，此時方法體為空 for (int i = 0; i < this.interfaces.length; i++) {


• localObject1 = this.interfaces[i].getMethods();


• for (int k = 0; k < localObject1.length; k++) {


• addProxyMethod(localObject1[k], this.interfaces[i]);


• }


• }


• //添加一個帶有InvocationHandler的構造方法 MethodInfo localMethodInfo = new MethodInfo("<init>", "(Ljava/lang/reflect/InvocationHandler;)V", 1);


• //循環生成方法體代碼（省略） //方法體里生成調用InvocationHandler的invoke方法代碼。（此處有所省略） this.cp.getInterfaceMethodRef("InvocationHandler", "invoke", "Object; Method; Object;")


• //將生成的位元組碼，寫入硬碟，前面有個if判斷，默認情況下不保存到硬碟。 localFileOutputStream = new FileOutputStream(ProxyGenerator.access$000(this.val$name) + ".class");


• localFileOutputStream.write(this.val$classFile);



生成的代理類源碼

那麼通過以上分析，我們可以推出動態代理為我們生成了一個這樣的代理類。把方法doSomeThing的方法體修改為調用LogInvocationHandler的invoke方法。

• public class ProxyBusiness extends Proxy implements IBusiness, IBusiness2 {


• private LogInvocationHandler h;


• @Override public void doSomeThing2() {


• try {


• Method m = (h.target).getClass().getMethod("doSomeThing2",null);


• h.invoke(this, m, null);


• } catch (Throwable e) {


• // 異常處理（略）


• }


• }


• @Override public boolean doSomeThing() {


• try {


• Method m = (h.target).getClass().getMethod("doSomeThing", null);


• return (Boolean) h.invoke(this, m, null);


• } catch (Throwable e) {


• // 異常處理（略）


• }


• return false;


• }


• public ProxyBusiness(LogInvocationHandler h) {


• this.h = h;


• }



測試代理的代碼如下：

• //測試public static void main(String[] args) {


• //構建AOP的Advice


• LogInvocationHandler handler = new LogInvocationHandler(new Business());


• new ProxyBusiness(handler).doSomeThing();


• new ProxyBusiness(handler).doSomeThing2();


• }



下面看一個自定義代理的實現。

被代理類介面

• public interface Subject {


• public void doSomething();


• }



被代理類

• //目標對象public class RealSubject implements Subject{ public void doSomething() {


• System.out.println( "call doSomething()" );


• }


• }



調用處理器(切面)

• public class ProxyHandler implements InvocationHandler {


• private Object proxied;


• public ProxyHandler( Object proxied ) {


• this.proxied = proxied;


• }


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


• //在轉調具體目標對象之前，可以執行一些功能處理System.out.println( "doSomething before" ); //轉調具體目標對象的方法


• return method.invoke( proxied, args);


• //在轉調具體目標對象之後，可以執行一些功能處理System.out.println( "doSomething after" );


• }


• }



測試我們的代理實現

• public class DynamicProxy {


• public static void main( String args[] ) {


• RealSubject real = new RealSubject();


• Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),


• new Class[]{Subject.class}, new ProxyHandler(real));


• proxySubject.doSomething(); //write proxySubject class binary data to file


• createProxyClassFile();


• }


• public static void createProxyClassFile() {


• String name = "ProxySubject";


• byte[] data = ProxyGenerator.generateProxyClass( name, new Class[] { Subject.class } );


• try{


• FileOutputStream out = new FileOutputStream( name + ".class" );


• out.write( data );


• out.close();


• }catch( Exception e ) {


• e.printStackTrace();


• }


• }


• }



運行結果：

• doSomething beforecall doSomething()doSomething after



Proxy 介面

Proxy 的主要靜態變數

• // 映射表：用於維護類裝載器對象到其對應的代理類緩存private static Map loaderToCache = new WeakHashMap();// 標記：用於標記一個動態代理類正在被創建中private static Object pendingGenerationMarker = new Object();// 同步表：記錄已經被創建的動態代理類類型，主要被方法 isProxyClass 進行相關的判斷private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap());// 關聯的調用處理器引用protected InvocationHandler h;


• Proxy的構造方法// 由於 Proxy 內部從不直接調用構造函數，所以 private 類型意味著禁止任何調用private Proxy() {}// 由於 Proxy 內部從不直接調用構造函數，所以 protected 意味著只有子類可以調用protected Proxy(InvocationHandler h) {this.h = h;}



ProxySubject 源碼

創建的代理類 ProxySubject.class

• import java.lang.reflect.*;


• public final class ProxySubject extends Proxy implements Subject{


• private static Method m1;


• private static Method m0;


• private static Method m3;


• private static Method m2;


• public ProxySubject(InvocationHandler invocationhandler){


• super(invocationhandler);


• }


• public final boolean equals(Object obj){


• try {


• return ((Boolean)super.h.invoke(this, m1, new Object[] {


• obj


• })).booleanValue();


• }catch(Error _ex) {


• }catch(Throwable throwable){


• throw new UndeclaredThrowableException(throwable);


• }


• }


• public final int hashCode() {


• try {


• return ((Integer)super.h.invoke(this, m0, null)).intValue();


• }catch(Error _ex) {


• }catch(Throwable throwable){


• throw new UndeclaredThrowableException(throwable);


• }


• }


• /*關鍵部分*/


• public final void doSomething() {


• try {


• // Proxy類中protected InvocationHandler h;關聯的調用處理器引用


• super.h.invoke(this, m3, null);


• return;


• }catch(Error _ex) {


• }catch(Throwable throwable) {


• throw new UndeclaredThrowableException(throwable);


• }


• }


• public final String toString() {


• try {


• return (String)super.h.invoke(this, m2, null);


• } catch(Error _ex) {


• } catch(Throwable throwable){


• throw new UndeclaredThrowableException(throwable);


• }


• }


• static{


• try {


• m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {


• Class.forName("java.lang.Object")


• });


• m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);


• m3 = Class.forName("Subject").getMethod("doSomething", new Class[0]);


• m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);


• }catch(NoSuchMethodException nosuchmethodexception) {


• throw new NoSuchMethodError(nosuchmethodexception.getMessage());


• }catch(ClassNotFoundException classnotfoundexception){


• throw new NoClassDefFoundError(classnotfoundexception.getMessage());


• }


• }


• }



CGLib 動態代理

動態位元組碼生成。使用動態位元組碼生成技術實現AOP原理是在運行期間目標位元組碼載入後，生成目標類的子類，將切面邏輯加入到子類中，所以使用Cglib實現AOP不需要基於介面。

• public static void main(String[] args) {


• byteCodeGe();


• }


• public static void byteCodeGe() {


• //創建一個織入器


• Enhancer enhancer = new Enhancer();


• //設置父類


• enhancer.setSuperclass(Business.class);


• //設置需要織入的邏輯


• enhancer.setCallback(new LogIntercept());


• //使用織入器創建子類


• IBusiness2 newBusiness = (IBusiness2) enhancer.create();


• newBusiness.doSomeThing2();


• }


• /**


• * 記錄日誌


• */ public static class LogIntercept implements MethodInterceptor {


• @Override


• public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable {


• //執行原有邏輯，注意這里是invokeSuper


• Object rev = proxy.invokeSuper(target, args);


• //執行織入的日誌


• if (method.getName().equals("doSomeThing2")) {


• System.out.println("記錄日誌");


• }


• return rev;


• }


• }