java伺服器簡單

1. 如何用java 5分鍾實現一個最簡單的mysql代理伺服器

首先，准備開發工具套件，我們並不會引入過多工具包，僅僅需要：
java8
vert.x 3
如果你是用maven做為項目管理工具，請將vert.x 3引入：

1
2
3
4
5

<dependency>

<groupId>io.vertx</groupId>

<artifactId>vertx-core</artifactId>

<version>3.3.2</version>

</dependency>

代碼實現：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

package
com.maxleap.mysqlproxy;

import
io.vertx.core.AbstractVerticle;

import
io.vertx.core.Vertx;

import
io.vertx.core.logging.Logger;

import
io.vertx.core.logging.LoggerFactory;

import
io.vertx.core.net.NetClient;

import
io.vertx.core.net.NetServer;

import
io.vertx.core.net.NetSocket;

/**

*
@author sneaky

*
@since 1.0.0

*/

public
class
MysqlProxyServer
{

private
static
final
Logger
logger
=
LoggerFactory.getLogger(MysqlProxyServer.class);

public
static
void
main(String[]
args)
{

Vertx.vertx().deployVerticle(new
MysqlProxyServerVerticle());

}

public
static
class
MysqlProxyServerVerticle
extends
AbstractVerticle
{

private
final
int
port
=
3306;

private
final
String
mysqlHost
=
"10.10.0.6";

@Override

public
void
start()
throws
Exception
{

NetServer
netServer
=
vertx.createNetServer();//創建代理伺服器

NetClient
netClient
=
vertx.createNetClient();//創建連接mysql客戶端

netServer.connectHandler(socket
->
netClient.connect(port,
mysqlHost,
result
->
{

//響應來自客戶端的連接請求，成功之後，在建立一個與目標mysql伺服器的連接

if
(result.succeeded())
{

//與目標mysql伺服器成功連接連接之後，創造一個MysqlProxyConnection對象,並執行代理方法

new
MysqlProxyConnection(socket,
result.result()).proxy();

2. java伺服器軟體有哪些簡單一點的，我要在桌面上就能用的。

tomcat,是目前最簡單的，開發java web 程序，這個最簡單，其他的weblogic 等太麻煩，

3. 如何創建基本的Java伺服器

以下是Sun提供的一個簡單的「Knock Knock"」伺服器：
import java.net.*;import java.io.*;public class KnockKnockServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = null;
try {
serverSocket = new ServerSocket(4444);
} catch (IOException e) {
System.err.println("Could not listen on port: 4444.");
System.exit(1);
}
Socket clientSocket = null;
try {
clientSocket = serverSocket.accept();
} catch (IOException e) {
System.err.println("Accept failed.");
System.exit(1);
}
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
BufferedReader in = new BufferedReader(
new InputStreamReader(
clientSocket.getInputStream()));
String inputLine, outputLine;
KnockKnockProtocol kkp = new KnockKnockProtocol();
outputLine = kkp.processInput(null);
out.println(outputLine);
while ((inputLine = in.readLine()) != null) {
outputLine = kkp.processInput(inputLine);
out.println(outputLine);
if (outputLine.equals("Bye."))
break;
}
out.close();
in.close();
clientSocket.close();
serverSocket.close();
}}
再簡單不過了。

4. java 如何搭建http伺服器

看你具體是想做什麼，現在現成的開源的java的http伺服器有很多，像tomcat之類的都有http伺服器功能，如果你只是單純的需要用的話，直接用tomcat就好了

但是如果你是做要自己用java實現一個http伺服器的話就要稍微麻煩一點

http伺服器，本質上還是基於tcpip協議的伺服器，首先用java的ServerSocket監聽一個埠（也可以使用開源的server組件，如quickserver之類的），然後對客戶端發上來的數據進行處理，這里就需要了解一下http協議了，因為上來的數據，都是按照http協議來組織的，你需要將請求數據解析後，將響應數據組織成http的響應，發回給客戶端。這樣一個簡單的http伺服器就實現了。

但是這個請求和響應都有很多種類，一個完整的http伺服器應該要都能夠支持，所以這裡面的工作量還是有一點的。

另外，上面說的http伺服器只是一個靜態的伺服器，如果你想讓你寫的服務具有動態功能，那你的伺服器還得提供javaee的容器功能，這樣做下去，沒准你也能寫一個tomcat出來了……

5. JAVA實現簡單的WEB伺服器

處理和接收http的請求的應該是request對象吧,

6. JAVA是什麼啊它可以用來做什麼

Java是目前主流的編程語言之一，如果學會Java，可以從事的崗位還是比較多的，這里簡單列舉一些。

Java可以做的：

1、Java可以做網站

現在很多大型網站都用Jsp寫的，JSP全名Java Server Pages。

2、Java可以做android

Android是一種基於Linux的自由及開放源代碼的操作系統，其源代碼是Java。Java做安卓不單單是指系統，還有APP對於更多的開發人員來說，他們更多的時間是花在開發APP上面。

3、Java可以做游戲

手機游戲有90%以上都是Java開發的。

電腦上也有Java開發的游戲，《我的世界》(minecraft ，簡稱MC)《英雄聯盟》（簡稱lol）等。

4、Java可以做軟體

比如：企業級應用開發，這里是JAVA的天地，大到全國聯網的系統，小到中小企業的應用解決方案，Java都佔有極為重要的地位。

想要系統學習，你可以考察對比一下開設有相關專業的熱門學校，好的學校擁有根據當下企業需求自主研發課程的能力，建議實地考察對比一下。

祝你學有所成，望採納。

7. 新手用Java怎麼做簡單後天安卓系統

使用J2EE技術或者叫JavaWeb技術開發一個Web伺服器，伺服器返回Json數據，android客戶端解析json數據，使用http協議和伺服器通信，android有相應模塊和API。首先樓主得懂Java後台也就是JavaEE，用Servlet搭建Web服務，Serlvet映射一個URL，Android請求這個URL，Servlet處理請求，然後就是Java編程，Web分層、JDBC等技術。伺服器返回標準的JSON輕量數據（就是純文本），Android來解析。
具體技術：（1）JavaServlet作為Web服務的處理入口；（2）Java編程編寫業務處理程序；（3）JDBC訪問資料庫；（4）Android端的HTTP模塊，API；（5）Android端解析JSON數據；（6）Servlet或者Java端生成JSON數據；
等樓主技術強了，就可以接觸各種框架、EJB技術了。Spring、SpringMVC、Struts、Hibernate，甚至NOSQL、分布式、負載、node.js、模板技術等等。

8. 雖能告訴我伺服器端最簡單的java程序

15.3 服務多個客戶
JabberServer可以正常工作，但每次只能為一個客戶程序提供服務。在典型的伺服器中，我們希望同時能處理多個客戶的請求。解決這個問題的關鍵就是多線程處理機制。而對於那些本身不支持多線程的語言，達到這個要求無疑是異常困難的。通過第14章的學習，大家已經知道Java已對多線程的處理進行了盡可能的簡化。由於Java的線程處理方式非常直接，所以讓伺服器控制多名客戶並不是件難事。
最基本的方法是在伺服器（程序）里創建單個ServerSocket，並調用accept()來等候一個新連接。一旦accept()返回，我們就取得結果獲得的Socket，並用它新建一個線程，令其只為那個特定的客戶服務。然後再調用accept()，等候下一次新的連接請求。
對於下面這段伺服器代碼，大家可發現它與JabberServer.java例子非常相似，只是為一個特定的客戶提供服務的所有操作都已移入一個獨立的線程類中：

//: MultiJabberServer.java
// A server that uses multithreading to handle
// any number of clients.
import java.io.*;
import java.net.*;

class ServeOneJabber extends Thread {
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public ServeOneJabber(Socket s)
throws IOException {
socket = s;
in =
new BufferedReader(
new InputStreamReader(
socket.getInputStream()));
// Enable auto-flush:
out =
new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
socket.getOutputStream())), true);
// If any of the above calls throw an
// exception, the caller is responsible for
// closing the socket. Otherwise the thread
// will close it.
start(); // Calls run()
}
public void run() {
try {
while (true) {
String str = in.readLine();
if (str.equals("END")) break;
System.out.println("Echoing: " + str);
out.println(str);
}
System.out.println("closing...");
} catch (IOException e) {
} finally {
try {
socket.close();
} catch(IOException e) {}
}
}
}

public class MultiJabberServer {
static final int PORT = 8080;
public static void main(String[] args)
throws IOException {
ServerSocket s = new ServerSocket(PORT);
System.out.println("Server Started");
try {
while(true) {
// Blocks until a connection occurs:
Socket socket = s.accept();
try {
new ServeOneJabber(socket);
} catch(IOException e) {
// If it fails, close the socket,
// otherwise the thread will close it:
socket.close();
}
}
} finally {
s.close();
}
}
} ///:~

每次有新客戶請求建立一個連接時，ServeOneJabber線程都會取得由accept()在main()中生成的Socket對象。然後和往常一樣，它創建一個BufferedReader，並用Socket自動刷新PrintWriter對象。最後，它調用Thread的特殊方法start()，令其進行線程的初始化，然後調用run()。這里採取的操作與前例是一樣的：從套掃字讀入某些東西，然後把它原樣反饋回去，直到遇到一個特殊的"END"結束標志為止。
同樣地，套接字的清除必須進行謹慎的設計。就目前這種情況來說，套接字是在ServeOneJabber外部創建的，所以清除工作可以「共享」。若ServeOneJabber構建器失敗，那麼只需向調用者「擲」出一個違例即可，然後由調用者負責線程的清除。但假如構建器成功，那麼必須由ServeOneJabber對象負責線程的清除，這是在它的run()里進行的。
請注意MultiJabberServer有多麼簡單。和以前一樣，我們創建一個ServerSocket，並調用accept()允許一個新連接的建立。但這一次，accept()的返回值（一個套接字）將傳遞給用於ServeOneJabber的構建器，由它創建一個新線程，並對那個連接進行控制。連接中斷後，線程便可簡單地消失。
如果ServerSocket創建失敗，則再一次通過main()擲出違例。如果成功，則位於外層的try-finally代碼塊可以擔保正確的清除。位於內層的try-catch塊只負責防範ServeOneJabber構建器的失敗；若構建器成功，則ServeOneJabber線程會將對應的套接字關掉。
為了證實伺服器代碼確實能為多名客戶提供服務，下面這個程序將創建許多客戶（使用線程），並同相同的伺服器建立連接。每個線程的「存在時間」都是有限的。一旦到期，就留出空間以便創建一個新線程。允許創建的線程的最大數量是由final int maxthreads決定的。大家會注意到這個值非常關鍵，因為假如把它設得很大，線程便有可能耗盡資源，並產生不可預知的程序錯誤。

//: MultiJabberClient.java
// Client that tests the MultiJabberServer
// by starting up multiple clients.
import java.net.*;
import java.io.*;

class JabberClientThread extends Thread {
private Socket socket;
private BufferedReader in;
private PrintWriter out;
private static int counter = 0;
private int id = counter++;
private static int threadcount = 0;
public static int threadCount() {
return threadcount;
}
public JabberClientThread(InetAddress addr) {
System.out.println("Making client " + id);
threadcount++;
try {
socket =
new Socket(addr, MultiJabberServer.PORT);
} catch(IOException e) {
// If the creation of the socket fails,
// nothing needs to be cleaned up.
}
try {
in =
new BufferedReader(
new InputStreamReader(
socket.getInputStream()));
// Enable auto-flush:
out =
new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
socket.getOutputStream())), true);
start();
} catch(IOException e) {
// The socket should be closed on any
// failures other than the socket
// constructor:
try {
socket.close();
} catch(IOException e2) {}
}
// Otherwise the socket will be closed by
// the run() method of the thread.
}
public void run() {
try {
for(int i = 0; i < 25; i++) {
out.println("Client " + id + ": " + i);
String str = in.readLine();
System.out.println(str);
}
out.println("END");
} catch(IOException e) {
} finally {
// Always close it:
try {
socket.close();
} catch(IOException e) {}
threadcount--; // Ending this thread
}
}
}

public class MultiJabberClient {
static final int MAX_THREADS = 40;
public static void main(String[] args)
throws IOException, InterruptedException {
InetAddress addr =
InetAddress.getByName(null);
while(true) {
if(JabberClientThread.threadCount()
< MAX_THREADS)
new JabberClientThread(addr);
Thread.currentThread().sleep(100);
}
}
} ///:~

JabberClientThread構建器獲取一個InetAddress，並用它打開一個套接字。大家可能已看出了這樣的一個套路：Socket肯定用於創建某種Reader以及／或者Writer（或者InputStream和／或OutputStream）對象，這是運用Socket的唯一方式（當然，我們可考慮編寫一、兩個類，令其自動完成這些操作，避免大量重復的代碼編寫工作）。同樣地，start()執行線程的初始化，並調用run()。在這里，消息發送給伺服器，而來自伺服器的信息則在屏幕上回顯出來。然而，線程的「存在時間」是有限的，最終都會結束。注意在套接字創建好以後，但在構建器完成之前，假若構建器失敗，套接字會被清除。否則，為套接字調用close()的責任便落到了run()方法的頭上。
threadcount跟蹤計算目前存在的JabberClientThread對象的數量。它將作為構建器的一部分增值，並在run()退出時減值（run()退出意味著線程中止）。在MultiJabberClient.main()中，大家可以看到線程的數量會得到檢查。若數量太多，則多餘的暫時不創建。方法隨後進入「休眠」狀態。這樣一來，一旦部分線程最後被中止，多作的那些線程就可以創建了。大家可試驗一下逐漸增大MAX_THREADS，看看對於你使用的系統來說，建立多少線程（連接）才會使您的系統資源降低到危險程度。

9. 在java開發過程中要用到什麼伺服器

你的問題有些太廣了，你可以問的具體點。
開發一個程序，涉及到的東西比較多，軟體自身，資料庫，第三方服務等等。
簡單點說有兩個伺服器，應用軟體伺服器，和資料庫伺服器。

10. 如何用JAVA實現一個代理伺服器

代理伺服器的應用非常廣泛。比如，在企業網內部，它可以用來控制員工在工作時瀏覽的Internet內容，阻止員工訪問某些類型的內容或某些指定的網站。代理伺服器實際上扮演著瀏覽器和Web伺服器之間的中間人的角色，能夠對瀏覽器請求進行各種各樣的處理，能夠過濾廣告和Cookie，能夠預先提取Web頁面，使得瀏覽器訪問頁面的速度更快，等等。
一、基礎知識
不管以哪種方式應用代理伺服器，其監控HTTP傳輸的過程總是如下：
步驟一：內部的瀏覽器發送請求給代理伺服器。請求的第一行包含了目標URL。
步驟二：代理伺服器讀取該URL，並把請求轉發給合適的目標伺服器。
步驟三：代理伺服器接收來自Internet目標機器的應答，把應答轉發給合適的內部瀏覽器。

例如，假設有一個企業的雇員試圖訪問www.cn.ibm.com網站。如果沒有代理伺服器，雇員的瀏覽器打開的Socket通向運行這個網站的Web伺服器，從Web伺服器返回的數據也直接傳遞給雇員的瀏覽器。如果瀏覽器被配置成使用代理伺服器，則請求首先到達代理伺服器；隨後，代理伺服器從請求的第一行提取目標URL，打開一個通向www.cn.ibm.com的Socket。當www.cn.ibm.com返回應答時，代理伺服器把應答轉發給雇員的瀏覽器。
當然，代理伺服器並非只適用於企業環境。作為一個開發者，擁有一個自己的代理伺服器是一件很不錯的事情。例如，我們可以用代理伺服器來分析瀏覽器和Web伺服器的交互過程。測試和解決Web應用中存在的問題時，這種功能是很有用的。我們甚至還可以同時使用多個代理伺服器（大多數代理伺服器允許多個伺服器鏈接在一起使用）。例如，我們可以有一個企業的代理伺服器，再加上一個用java編寫的代理伺服器，用來調試應用程序。但應該注意的是，代理伺服器鏈上的每一個伺服器都會對性能產生一定的影響。
二、設計規劃
正如其名字所示，代理伺服器只不過是一種特殊的伺服器。和大多數伺服器一樣，如果要處理多個請求，代理伺服器應該使用線程。下面是一個代理伺服器的基本規劃：
等待來自客戶（Web瀏覽器）的請求。
啟動一個新的線程，以處理客戶連接請求。
讀取瀏覽器請求的第一行（該行內容包含了請求的目標URL）。
分析請求的第一行內容，得到目標伺服器的名字和埠。
打開一個通向目標伺服器（或下一個代理伺服器，如合適的話）的Socket。
把請求的第一行發送到輸出Socket。
把請求的剩餘部分發送到輸出Socket。
把目標Web伺服器返回的數據發送給發出請求的瀏覽器。

當然，如果考慮細節的話，情況會更復雜一些。實際上，這里主要有兩個問題要考慮：第一，從Socket按行讀取數據最適合進一步處理，但這會產生性能瓶頸；第二，兩個Socket之間的連接必需高效。有幾種方法可以實現這兩個目標，但每一種方法都有各自的代價。例如，如果要在數據進入的時候進行過濾，這些數據最好按行讀取；然而，大多數時候，當數據到達代理伺服器時，立即把它轉發出去更適合高效這一要求。另外，數據的發送和接收也可以使用多個獨立的線程，但大量地創建和拆除線程也會帶來性能問題。因此，對於每一個請求，我們將用一個線程處理數據的接收和發送，同時在數據到達代理伺服器時，盡可能快速地把它轉發出去。
三、實例
在用java編寫這個代理伺服器的過程中，注意可重用性是很重要的。因為這樣的話，當我們想要在另一個工程中以不同的方式處理瀏覽器請求時，可以方便地重用該代理伺服器。當然，我們必須注意靈活性和效率之間的平衡。
圖一顯示了本文代理伺服器實例（HttpProxy.java）的輸出界面，當瀏覽器訪問http://www-900.ibm.com/cn/時，代理伺服器向默認日誌設備（即標准輸出設備屏幕）輸出瀏覽器請求的URL。圖二顯示了SubHttpProxy的輸出。SubHttpProxy是HttpProxy的一個簡單擴展。
圖一

圖二

為了構造代理伺服器，我從Thread基類派生出了HttpProxy類（文章正文中出現的代碼是該類的一些片斷，完整的代碼請從本文最後下載）。HttpProxy類包含了一些用來定製代理伺服器行為的屬性，參見Listing 1和表一。
【Listing 1】
/*************************************
* 一個基礎的代理伺服器類
*************************************
*/
import java.net.*;
import java.io.*;
public class HttpProxy extends Thread {
static public int CONNECT_RETRIES=5;
static public int CONNECT_PAUSE=5;
static public int TIME-OUT=50;
static public int BUFSIZ=1024;
static public boolean logging = false;
static public OutputStream log=null;
// 傳入數據用的Socket
protected Socket socket;
// 上級代理伺服器，可選
static private String parent=null;
static private int parentPort=-1;
static public void setParentProxy(String name, int pport) {
parent=name;
parentPort=pport;
}
// 在給定Socket上創建一個代理線程。
public HttpProxy(Socket s) { socket=s; start(); }
public void writeLog(int c, boolean browser) throws IOException {
log.write(c);
}
public void writeLog(byte[] bytes,int offset,
int len, boolean browser) throws IOException {
for (int i=0;i<len;i++) writeLog((int)bytes[offset+i],browser);
}
// 默認情況下，日誌信息輸出到
// 標准輸出設備，
// 派生類可以覆蓋它
public String processHostName(String url, String host, int port, Socket sock) {
java.text.DateFormat cal=java.text.DateFormat.getDateTimeInstance();
System.out.println(cal.format(new java.util.Date()) + " - " +
url + " " + sock.getInetAddress()+"<BR>");
return host;
}

表一
變數/方法 說明
CONNECT_RETRIES 在放棄之前嘗試連接遠程主機的次數。
CONNECT_PAUSE 在兩次連接嘗試之間的暫停時間。
TIME-OUT 等待Socket輸入的等待時間。
BUFSIZ Socket輸入的緩沖大小。
logging 是否要求代理伺服器在日誌中記錄所有已傳輸的數據（true表示「是」）。
log 一個OutputStream對象，默認日誌常式將向該OutputStream對象輸出日誌信息。
setParentProxy 用來把一個代理伺服器鏈接到另一個代理伺服器（需要指定另一個伺服器的名稱和埠）。

當代理伺服器連接到Web伺服器之後，我用一個簡單的循環在兩個Socket之間傳遞數據。這里可能出現一個問題，即如果沒有可操作的數據，調用read方法可能導致程序阻塞，從而掛起程序。為防止出現這個問題，我用setSoTimeout方法設置了Socket的超時時間（參見Listing 2）。這樣，如果某個Socket不可用，另一個仍舊有機會進行處理，我不必創建一個新的線程。
【Listing 2】
// 執行操作的線程
public void run() {
String line;
String host;
int port=80;
Socket outbound=null;
try {
socket.setSoTimeout(TIMEOUT);
InputStream is=socket.getInputStream();
OutputStream os=null;
try {
// 獲取請求行的內容
line="";
host="";
int state=0;
boolean space;
while (true) {
int c=is.read();
if (c==-1) break;
if (logging) writeLog(c,true);
space=Character.isWhitespace((char)c);
switch (state) {
case 0:
if (space) continue;
state=1;
case 1:
if (space) {
state=2;
continue;
}
line=line+(char)c;
break;
case 2:
if (space) continue; // 跳過多個空白字元
state=3;
case 3:
if (space) {
state=4;
// 只分析主機名稱部分
String host0=host;
int n;
n=host.indexOf("//");
if (n!=-1) host=host.substring(n+2);
n=host.indexOf('/');
if (n!=-1) host=host.substring(0,n);
// 分析可能存在的埠號
n=host.indexOf(":");
if (n!=-1) {
port=Integer.parseInt(host.substring(n+1));
host=host.substring(0,n);
}
host=processHostName(host0,host,port,socket);
if (parent!=null) {
host=parent;
port=parentPort;
}
int retry=CONNECT_RETRIES;
while (retry--!=0) {
try {
outbound=new Socket(host,port);
break;
} catch (Exception e) { }
// 等待
Thread.sleep(CONNECT_PAUSE);
}
if (outbound==null) break;
outbound.setSoTimeout(TIMEOUT);
os=outbound.getOutputStream();
os.write(line.getBytes());
os.write(' ');
os.write(host0.getBytes());
os.write(' ');
pipe(is,outbound.getInputStream(),os,socket.getOutputStream());
break;
}
host=host+(char)c;
break;
}
}
}
catch (IOException e) { }
} catch (Exception e) { }
finally {
try { socket.close();} catch (Exception e1) {}
try { outbound.close();} catch (Exception e2) {}
}
}

和所有線程對象一樣，HttpProxy類的主要工作在run方法內完成（見Listing 2）。run方法實現了一個簡單的狀態機，從Web瀏覽器每次一個讀取字元，持續這個過程直至有足夠的信息找出目標Web伺服器。然後，run打開一個通向該Web伺服器的Socket（如果有多個代理伺服器被鏈接在一起，則run方法打開一個通向鏈裡面下一個代理伺服器的Socket）。打開Socket之後，run先把部分的請求寫入Socket，然後調用pipe方法。pipe方法直接在兩個Socket之間以最快的速度執行讀寫操作。
如果數據規模很大，另外創建一個線程可能具有更高的效率；然而，當數據規模較小時，創建新線程所需要的開銷會抵消它帶來的好處。
Listing 3顯示了一個很簡單的main方法，可以用來測試HttpProxy類。大部分的工作由一個靜態的startProxy方法完成（見Listing 4）。這個方法用到了一種特殊的技術，允許一個靜態成員創建HttpProxy類（或HttpProxy類的子類）的實例。它的基本思想是：把一個Class對象傳遞給startProxy類；然後，startProxy方法利用映像API（Reflection API）和getDeclaredConstructor方法確定該Class對象的哪一個構造函數接受一個Socket參數；最後，startProxy方法調用newInstance方法創建該Class對象。
【Listing 3】
// 測試用的簡單main方法
static public void main(String args[]) {
System.out.println("在埠808啟動代理伺服器\n");
HttpProxy.log=System.out;
HttpProxy.logging=false;
HttpProxy.startProxy(808,HttpProxy.class);
}
}

【Listing 4】
static public void startProxy(int port,Class clobj) {
ServerSocket ssock;
Socket sock;
try {
ssock=new ServerSocket(port);
while (true) {
Class [] sarg = new Class[1];
Object [] arg= new Object[1];
sarg[0]=Socket.class;
try {
java.lang.reflect.Constructor cons = clobj.getDeclaredConstructor(sarg);
arg[0]=ssock.accept();
cons.newInstance(arg); // 創建HttpProxy或其派生類的實例
} catch (Exception e) {
Socket esock = (Socket)arg[0];
try { esock.close(); } catch (Exception ec) {}
}
}
} catch (IOException e) {
}
}

利用這種技術，我們可以在不創建startProxy方法定製版本的情況下，擴展HttpProxy類。要得到給定類的Class對象，只需在正常的名字後面加上.class（如果有某個對象的一個實例，則代之以調用getClass方法）。由於我們把Class對象傳遞給了startProxy方法，所以創建HttpProxy的派生類時，就不必再特意去修改startProxy。（下載代碼中包含了一個派生得到的簡單代理伺服器）。
結束語
利用派生類定製或調整代理伺服器的行為有兩種途徑：修改主機的名字，或者捕獲所有通過代理伺服器的數據。processHostName方法允許代理伺服器分析和修改主機名字。如果啟用了日誌記錄，代理伺服器為每一個通過伺服器的字元調用writeLog方法。如何處理這些信息完全由我們自己決定——可以把它寫入日誌文件，可以把它輸出到控制台，或進行任何其他滿足我們要求的處理。writeLog輸出中的一個Boolean標記指示出數據是來自瀏覽器還是Web主機。
和許多工具一樣，代理伺服器本身並不存在好或者壞的問題，關鍵在於如何使用它們。代理伺服器可能被用於侵犯隱私，但也可以阻隔偷窺者和保護網路。即使代理伺服器和瀏覽器不在同一台機器上，我也樂意把代理伺服器看成是一種擴展瀏覽器功能的途徑。例如，在把數據發送給瀏覽器之前，可以用代理伺服器壓縮數據；未來的代理伺服器甚至還可能把頁面從一種語言翻譯成另一種語言……可能性永無止境。