java對代理類代理
Ⅰ 如何用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中的代理類一般在什麼時候使用呢
1.代理模式
代理模式的作用是：為其他對象提供一種代理以控制對這個對象的訪問。在某些情況下，一個客戶不想或者不能直接引用另一個對象，而代理對象可以在客戶端和目標對象之間起到中介的作用。
代理模式一般涉及到的角色有：
抽象角色 ：聲明真實對象和代理對象的共同介面；
代理角色 ：代理對象角色內部含有對真實對象的引用，從而可以操作真實對象，同時代理對象提供與真實對象相同的介面以便在任何時刻都能代替真實對象。同時，代理對象可以在執行真實對象操作時，附加其他的操作，相當於對真實對象進行封裝。
真實角色 ：代理角色所代表的真實對象，是我們最終要引用的對象。
代理模式使用原因和應用方面
（1）授權機制 不同級別的用戶對同一對象擁有不同的訪問權利,如Jive論壇系統中,就使用Proxy進行授權機制控制,訪問論壇有兩種人:注冊用戶和遊客(未注冊用戶),Jive中就通過類似ForumProxy這樣的代理來控制這兩種用戶對論壇的訪問許可權.
（2）某個客戶端不能直接操作到某個對象,但又必須和那個對象有所互動.
舉例兩個具體情況:
如果那個對象是一個是很大的圖片,需要花費很長時間才能顯示出來,那麼當這個圖片包含在文檔中時,使用編輯器或瀏覽器打開這個文檔,打開文檔必須很迅速,不能等待大圖片處理完成,這時需要做個圖片Proxy來代替真正的圖片.
如果那個對象在Internet的某個遠端伺服器上,直接操作這個對象因為網路速度原因可能比較慢,那我們可以先用Proxy來代替那個對象.
總之原則是,對於開銷很大的對象,只有在使用它時才創建,這個原則可以為我們節省很多寶貴的Java內存. 所以,有些人認為Java耗費資源內存,我以為這和程序編制思路也有一定的關系.
（3）現實中，Proxy應用范圍很廣,現在流行的分布計算方式RMI和Corba等都是Proxy模式的應用
Ⅲ 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 });
- IvocationHandler handler = new InvocationHandlerImpl(...);
- Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});
- Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
- Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));
- Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),
- new Class[]{Subject.class}, new InvocationHandlerImpl (real));
- // 緩存的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);
- //添加介面中定義的方法，此時方法體為空 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);
- 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
- // 映射表：用於維護類裝載器對象到其對應的代理類緩存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;}
- 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());
- }
- }
- }
- 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;
- }
- }
一個典型的動態代理創建對象過程可分為以下四個步驟：
1、通過實現InvocationHandler介面創建調用處理器
2、通過為Proxy類指定ClassLoader對象和一組interface創建動態代理類
3、通過反射機制獲取動態代理類的構造函數，其參數類型是調用處理器介面類型
4、通過構造函數創建代理類實例，此時需將調用處理器對象作為參數被傳入
為了簡化對象創建過程，Proxy類中的newProxyInstance方法封裝了2~4，只需兩步即可完成代理對象的創建。
生成的proxySubject繼承Proxy類實現Subject介面。實現的Subject的方法實際是調用處理器的invoke方法，而invoke方法利用反射調用的是被代理對象的方法（Object result=method.invoke(proxied,args)）；
重點Proxy.newProxyInstance，源碼分析，會在其他文檔中單獨總結記錄。類Proxy的getProxyClass方法調用ProxyGenerator的 generateProxyClass方法產生ProxySubject.class的二進制數據。
創建代理對象時序圖
獲取代理類
getProxyClass(loader, interfaces)方法用於獲取代理類，它主要做了三件事情：
在當前類載入器的緩存里搜索是否有代理類，沒有則生成代理類並緩存在本地JVM里。
生成並載入代理類
代理類的生成主要是以下這兩行代碼：
代理類的生成過程
ProxyGenerator.generateProxyClass()方法屬於sun.misc包下，Oracle並沒有提供源代碼，但是我們可以使用
JD-GUI這樣的反編譯軟體打開jrelib
t.jar來一探究竟，以下是其核心代碼的分析。
生成的代理類源碼
那麼通過以上分析，我們可以推出動態代理為我們生成了一個這樣的代理類。把方法doSomeThing的方法體修改為調用LogInvocationHandler的invoke方法。
測試代理的代碼如下：
下面看一個自定義代理的實現。
被代理類介面
被代理類
調用處理器(切面)
測試我們的代理實現
運行結果：
Proxy 介面
Proxy 的主要靜態變數
ProxySubject 源碼
創建的代理類 ProxySubject.class
CGLib 動態代理
動態位元組碼生成。使用動態位元組碼生成技術實現AOP原理是在運行期間目標位元組碼載入後，生成目標類的子類，將切面邏輯加入到子類中，所以使用Cglib實現AOP不需要基於介面。
Ⅳ java中為什麼要給類使用代理它有哪些好處
代理模式的作用是：為其他對象提供一種代理以控制對這個對象的訪問。在某些情況下，一個客戶不想或者不能直接引用另一個對象，而代理對象可以在客戶端和目標對象之間起到中介的作用。
代理模式一般涉及到的角色有：
抽象角色：聲明真實對象和代理對象的共同介面；
代理角色：代理對象角色內部含有對真實對象的引用，從而可以操作真實對象，同時代理對象提供與真實對象相同的介面以便在任何時刻都能代替真實對象。同時，代理對象可以在執行真實對象操作時，附加其他的操作，相當於對真實對象進行封裝。
真實角色：代理角色所代表的真實對象，是我們最終要引用的對象。
Ⅳ 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 中怎樣在程序中設置代理伺服器
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());
}
}
}
Ⅶ java中的代理是什麼意思
動態代理在Java中是很重要的一部分，在很多框架中都會用到，如Spring中的AOP、Hadoop中的RPC等。為此在這把我對Java中的動態代理的理解分享給大家，同時寫了一個模擬AOP編程的實例。
有兩種方法可以實現，一種是利用繼承，另一種是利用聚合。舉例說明：
假設第三方中提供一個Run介面，裡面只一個run方法，以及它的實現類Person。
Run.java
如果要對第三方提供的JAR包中的某個類中的某個方法的前後加上自己的邏輯，比如打LOG，注意此時我們只有第三方提供的CLASS文件，因此根本不可能去修改別人的源代碼，那該怎麼辦？
有兩種方法可以實現，一種是利用繼承，另一種是利用聚合。舉例說明：
假設第三方中提供一個Run介面，裡面只一個run方法，以及它的實現類Person。
Run.java
如果要對第三方提供的JAR包中的某個類中的某個方法的前後加上自己的邏輯，比如打LOG，注意此時我們只有第三方提供的CLASS文件，因此根本不可能去修改別人的源代碼，那該怎麼辦？
有兩種方法可以實現，一種是利用繼承，另一種是利用聚合。舉例說明：
假設第三方中提供一個Run介面，裡面只一個run方法，以及它的實現類Person。
Run.java
分析動態代理過程
1.根據輸入的介面，利用反射機制，肯定可以拿到有哪些方法；
2.根據輸入的被代理類，同樣利用反射機制，肯定去調用其實現的方法。
到了這里，好像少了一點東西，就是少了對某個方法的前後的加強的邏輯。
Ⅷ 如何獲得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 print?
package com.meituan.hyt.test3.service;
public interface UserService {
public String getName(int id);
public Integer getAge(int id);
}
[java] view plain 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 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 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 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 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++++++
Ⅸ Java怎麼實現多層動態代理
java動態代理主要是通過Proxy類的newProxyInstance()方法，該方法需要三個參(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)，其中分別為：
①：該對象的類載入器classloader
②：被代理類的類對象
③：一個InvocationHandler 處理器介面
InvocationHandler中有一個方法：invoke(Object proxy, Method method, Object[] args) ，通過顯式調用可以實現對代理對象的類方法進行操作，這里主要是採用反射的原理，SrpingAop就是利用這一點進行實現的。
Ⅹ JAVA動態代理設計原理及如何實現
ava動態代理機制的出現，使得Java開發人員不用手工編寫代理類，只要簡單地制定一組介面及委託類對象，便能動態地獲得代理類。代理類會負責將所有的方法調用分配到委託對象上反射執行，配置執行過程中，開發人員還可以進行修改
代理設計模式
代理是一種常用的設計模式，其目的就是為其他對象提供一個代理以控制對某個對象的訪問。代理類負責為委託類預處理消息、過濾消息並轉發消息，以及進行消息被委託類執行後的後續處理。
1.
為了保持行為的一致性，代理類和委託類通常會實現相同的介面
2.
引入代理能夠控制對委託對象的直接訪問，可以很好的隱藏和保護委託對象，也更加具有靈活性
相關的類和介面
要了解
Java
動態代理的機制，首先需要了解以下相關的類或介面：
1.
java.lang.reflect.Proxy：這是
Java
動態代理機制的主類，它提供了一組靜態方法來為一組介面動態地生成代理類及其對象
2.
java.lang.reflect.InvocationHandler：這是調用處理器介面，它自定義了一個invoke方法，用於幾種處理在動態代理類對象上的方法調用。通常在該方法中實現對委託類的代理訪問。
3.
java.lang.ClassLoader：Proxy
靜態方法生成動態代理類同樣需要通過類裝載器來進行裝載才能使用，它與普通類的唯一區別就是其位元組碼是由
JVM
在運行時動態生成的而非預存在於任何一個.class
文件中。
代理機制及其特點
首先讓我們來了解一下如何使用
Java
動態代理。具體有如下四步驟：
1.
通過實現
InvocationHandler
介面創建自己的調用處理器;
2.
通過為
Proxy
類指定
ClassLoader
對象和一組
interface
來創建動態代理類;
3.
通過反射機制獲得動態代理類的構造函數，其唯一參數類型是調用處理器介面類型;
4.
通過構造函數創建動態代理類實例，構造時調用處理器對象作為參數被傳入。