代理java

1. java中的代理有什麼用

建議看看《java與模式》代理模式那節。代理就是對一個類進行的代理，或是託管。簡單的講就是對原有類加了一個殼，當程序執行的時候不執行原來的類，首先執行代理類，代理類，可以決定是否執行真正要調用的類。
用途，最常見的就是資料庫連接池，資料庫連接池裡的連接是不能被關閉的，那麼，你總不能單獨寫一個connectionClose方法吧？所以就要代理掉Conection介面的實現類（java的代理是面向介面的代理），代理類判斷當執行的方法是close方法的時候就不予執行close操作。其他就是spring中的aop，大量用到了代理。事實上，struts的攔截器也是一種代理。

2. 想用java編寫個代理伺服器，求具體一些思路，詳細一些，謝謝

在編寫代理伺服器之前，首先應該明白一點，Java的代理機制，如圖所示：

那麼Java就處於中間這層代理伺服器，代理伺服器所作的事情如下：
1、接收客戶端請求，進行處理，然後發送給服務端
2、接收服務端響應，進行處理，然後發送給客戶端
這樣，就更清晰了，Java提供了代理的API為，java.net.Proxy類。此類表示代理設置，通常為類型（http、socks）和套接字地址。Proxy 是不可變對象。

也就是說Java可以製作高級協議的代理，如 HTTP 或 FTP。也可以製作SOCKS（V4 或 V5）代理。
首先，使用到了URL類，HttpURLConnection類及其我們的代理類Proxy類。他們都位於java.net包中。

第一步：生成代理，指定埠為8888：

第二步：使用URLConnection類進行連接www.moonsos.com

第三步：打開URL，並且讀取HTML源碼

3. java中的代理是什麼意思

代理模式在設計模式中的定義就是：為其他對象提供一種代理以控制對這個對象的訪問。說白了就是，在一些情況下客戶不想或者不能直接引用一個對象，而代理對象可以在客戶和目標對象之間起到中介作用，去掉客戶不能看到的內容和服務或者增添客戶需要的額外服務。

4. 內網java程序通過代理訪問外網

你可以在啟動JAVA的命令行中使用這樣的設定:
java -Dhttp.proxyHost=myproxyserver.com -Dhttp.proxyPort=80 MyJavaApp

或在源碼 中這樣寫:
System.setProperty("http.proxyHost", "myProxyServer.com");
System.setProperty("http.proxyPort", "80");

——JDK 6 或之後的版本

5. java中的代理類一般在什麼時候使用呢

1.代理模式

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

代理模式一般涉及到的角色有：

抽象角色 ：聲明真實對象和代理對象的共同介面；

代理角色 ：代理對象角色內部含有對真實對象的引用，從而可以操作真實對象，同時代理對象提供與真實對象相同的介面以便在任何時刻都能代替真實對象。同時，代理對象可以在執行真實對象操作時，附加其他的操作，相當於對真實對象進行封裝。

真實角色 ：代理角色所代表的真實對象，是我們最終要引用的對象。

代理模式使用原因和應用方面

（1）授權機制 不同級別的用戶對同一對象擁有不同的訪問權利,如Jive論壇系統中,就使用Proxy進行授權機制控制,訪問論壇有兩種人:注冊用戶和遊客(未注冊用戶),Jive中就通過類似ForumProxy這樣的代理來控制這兩種用戶對論壇的訪問許可權.

（2）某個客戶端不能直接操作到某個對象,但又必須和那個對象有所互動.
舉例兩個具體情況:
如果那個對象是一個是很大的圖片,需要花費很長時間才能顯示出來,那麼當這個圖片包含在文檔中時,使用編輯器或瀏覽器打開這個文檔,打開文檔必須很迅速,不能等待大圖片處理完成,這時需要做個圖片Proxy來代替真正的圖片.

如果那個對象在Internet的某個遠端伺服器上,直接操作這個對象因為網路速度原因可能比較慢,那我們可以先用Proxy來代替那個對象.

總之原則是,對於開銷很大的對象,只有在使用它時才創建,這個原則可以為我們節省很多寶貴的Java內存. 所以,有些人認為Java耗費資源內存,我以為這和程序編制思路也有一定的關系.

（3）現實中，Proxy應用范圍很廣,現在流行的分布計算方式RMI和Corba等都是Proxy模式的應用

6. JAVA中如何設置代理伺服器，取消代理伺服器

在JAVA中怎麼設置代理伺服器呢，非常簡單
publicvoidsetServiceProxy(Configconfig){
this.config=config;
System.setProperty("http.proxyHost",config.getProxyHost());
System.setProperty("http.proxyPort",config.getProxyPort());
System.setProperty("https.proxyHost",config.getProxyHost());
System.setProperty("https.proxyPort",config.getProxyPort());
}
然後在每一個HttpUrlConnection請求中，設置代理伺服器用戶名和密碼，並進行Base64加密（看你代理伺服器的要求，可能因代理伺服器不同而不同），代碼如下
()throwsIOException{
Stringauthorization=config.getProxyUser()+":"
+config.getProxyPassword();
URLurl=newURL(config.getRequestUrl());
HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
conn.setRequestProperty("Proxy-Authorization",
"Basic"+Base64.encodeBase64String(authorization.getBytes()));
returnconn;
}

7. Java 幾種動態代理實現及其性能比較

1. 動態代理是指在運行時，動態生成代理類。代理類的位元組碼將在運行時生成並載入當前的ClassLoader.

生成動態代理類的方法很多，如JDK自帶的動態代理、CGLIB、Javassist或者ASM庫。

JDK動態代理使用簡單，它內置在JDK中，因此不需要引入第三方Jar包，但相對功能比較弱。CGLIB和Javassist都是高級的位元組碼生成庫，總體性能比JDK自帶的動態代理好，而且功能十分強大。ASM是低級的位元組碼生成工具，使用ASM已經近乎在於使用Javabytecode編程，對開發人員要求較高，也是性能最好的一種動態代理生辰工具。但ASM的使用是在過於繁瑣，而且性能也沒有數量級的提升，與CGLIB等高級位元組碼生成工具相比，ASM程序的可維護性也較差。

JDK實現

1、步驟

1）通過實現InvocationHandler介面創建自己的調用處理器

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

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

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

2、創建代理
//InvocationHandlerImpl 實現了InvocationHandler介面，並能實現方法調用從代理類到委託類的分派轉發
//其內部通常包含指向委託類實例的引用，用於真正執行分派轉發過來的方法調用
InvocationHandler handler = new InvocaitonHandlerImpl(..);

//通過Proxy為包括Interface介面在內的一組介面動態創建代理類的對象
Class clazz = Proxy.getProxyClass(classLoader,new Class[]{Interface.class,...});

//通過反射從生成的類對象獲得構造函數對象
Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});

//通過構造函數對象創建動態代理類實例
Interface Proxy = (Interface)constructor.newInstance(new Object[]{handler});

//Proxy類的靜態方法newProxyInstance對上面具體步驟的後三步做了封裝，簡化了動態代理對象的獲取過程。
//InvocationHandlerImpl實現了InvocaitonHandler介面，並能實現方法調用從代理類到委託類的分派轉發
InvocaitonHandler handler = new InvocationHandlerImpl(..);
//通過Proxy直接創建動態代理類實例

nterface proxy = (Interface)Proxy.newProxyInstance(classLoader,new Class[]{Interface.class},handler);

3、代碼

/**
* 介面
*
*/
public interface IDBQuery {

String request();
}

/**
* 真實的實現類，具體的目標對象
*
*/
public class DBQuery implements IDBQuery {

public DBQuery(){
try {
Thread.sleep(1000); //可能包含資料庫連接等耗時操作
} catch (InterruptedException e) {
e.printStackTrace();
}
}

@Override
public String request() {

return "request string";
}

}

/**
* JDK動態代理的實現類
*
*/
public class JdkDbQueryHandler implements InvocationHandler{

IDBQuery real = null; //主題介面

/**
* 生成Handler
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if(real == null)
real = new DBQuery(); //如果是第一次調用，則生成真實對象
return real.request(); //使用真實主題完成實際的操作
}

/**
* 利用Handler生成動態代理對象
*/
public static IDBQuery createJdkProxy(){

//根據指定的類載入器和介面以及截獲器，返回代理類的一個實例對象
//ClassLoader loader :指定被代理對象的類載入器
//Class[] Interfaces ：指定被代理對象所以事項的介面
//InvocationHandler h :指定需要調用的InvocationHandler對象
IDBQuery jdkProxy = (IDBQuery) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{IDBQuery.class}, new JdkDbQueryHandler());
return jdkProxy;
}

}

8. 如何獲得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++++++

9. Java代理的三種模式有什麼

Java的三種代理模式簡述

本文著重講述三種代理模式在java代碼中如何寫出，為保證文章的針對性，暫且不討論底層實現原理，具體的原理將在下一篇文章中講述。

代理模式是什麼

代理模式是一種設計模式，簡單說即是在不改變源碼的情況下，實現對目標對象的功能擴展。

比如有個歌手對象叫Singer，這個對象有一個唱歌方法叫sing()。

假如你希望，通過你的某種方式生產出來的歌手對象，在唱歌前後還要想觀眾問好和答謝，也即對目標對象Singer的sing方法進行功能擴展。

但是往往你又不能直接對源代碼進行修改，可能是你希望原來的對象還保持原來的樣子，又或許你提供的只是一個可插拔的插件，甚至你有可能都不知道你要對哪個目標對象進行擴展。這時就需要用到java的代理模式了。網上好多用生活中的經理人的例子來解釋「代理」，看似通俗易懂，但我覺得不適合程序員去理解。程序員應該從代碼的本質入手。

10. 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();