用Java Socket开拓支持上千个并发的小型处事器（下）
副标题#e#
总结一下客户机
我们的类研究完了。在我们继承往前接头处事器端的环境之前，让我们回首一下建设和利用Socket的步调：
1.用您想毗连的呆板的IP地点和端话柄例化Socket（如有问题则抛出Exception）。
2.获取Socket上的流以举办读写。
3.把流包装进BufferedReader/PrintWriter的实例，假如这样做能使工作更简朴的话。
4.对Socket举办读写。
5.封锁打开的流。
5建设处事器Socket
建设RemoteFileServer类
1.import java.io.*;
2.import java.net.*;
3.public class RemoteFileServer {
4. int listenPort;
5. public RemoteFileServer(int listenPort) {
6. this.listenPort=listenPort;
7. }
8. //答允客户机毗连随处事器,期待客户机请求
9. public void acceptConnections() {
10. try {
11. ServerSocket server = new ServerSocket(listenPort);
12. Socket incomingConnection = null;
13. while(true) {
14. incomingConnection = server.accept();
15. handleConnection(incomingConnection);
16. }
17. }
18. catch(BindException e) {
19. System.out.println("Unable to bind to port "+listenPort);
20. }
21. catch(IOException e) {
22. System.out.println("Unable to instantiate a ServerSocket on port: "+listenPort);
23.
24. }
25. }
26. //与客户机Socket交互以将客户机所请求的文件的内容发送到客户机
27. public void handleConnection(Socket incomingConnection) {
28. try {
29. OutputStream outputToSocket = incomingConnection.getOutputStream();
30. InputStream inputFromSocket = incomingConnection.getInputStream();
31. BufferedReader streamReader = new BufferedReader(new InputStreamReader(inputFromSocket));
32. FileReader fileReader = new FileReader(new File(streamReader.readLine()));
33. BufferedReader bufferedFileReader = new BufferedReader(fileReader);
34. PrintWriter streamWriter = new PrintWriter(incomingConnection.getOutputStream());
35. String line = null;
36. while((line=bufferedFileReader.readLine())!=null){
37. streamWriter.println(line);
38. }
39. fileReader.close();
40. streamWriter.close();
41. streamReader.close();
42. }
43. catch(Exception e) {
44. System.out.println("Error handling a client: "+e);
45. e.printStackTrace();
46. }
47. }
48. public static void main(String args[]) {
49. RemoteFileServer server = new RemoteFileServer(1001);
50. server.acceptConnections();
51. }
52.}
#p#副标题#e#
跟客户机中一样，我们首先导入java.net的java.io。接着，我们给我们的类一个实例变量以生存端口，我们从该端口侦听进入的毗连。缺省环境下，端口是1001。
我们的类有一个main()要领和两个其它要领。稍后我们将探究这些要领的细节。此刻您只需知道acceptConnections()将答允客户机毗连随处事器以及handleConnection()与客户机Socket交互以将您所请求的文件的内容发送到客户机。
实现main()
这里我们实现main()要领，它将建设RemoteFileServer并汇报它接管毗连：处事器端的main()要领中，我们实例化一个新RemoteFileServer，它将在侦听端口（1001）上侦听进入的毗连请求。然后我们挪用acceptConnections()来汇报该server举办侦听。
接管毗连
这里我们实现acceptConnections()要领，它将建设一个ServerSocket并期待毗连请求：
1.public void acceptConnections() {
2. try {
3. ServerSocket server = new ServerSocket(listenPort);
4. Socket incomingConnection = null;
5. while(true) {
6. incomingConnection = server.accept();
7. handleConnection(incomingConnection);
8. }
9. }
10. catch(BindException e) {
11. System.out.println("Unable to bind to port "+listenPort);
12. }
13. catch(IOException e) {
14. System.out.println("Unable to instantiate a ServerSocket on port: "+listenPort);
15.
16. }
17. }
acceptConnections()用欲侦听的端标语来建设ServerSocket。然后我们通过挪用该ServerSocket的accept()来汇报它开始侦听。accept()要领将造成阻塞直到来了一个毗连请求。此时，accept()返回一个新的Socket，这个Socket绑定随处事器上一个随机指定的端口，返回的Socket被通报给handleConnection()。请留意我们在一个无限轮回中处理惩罚对毗连的接管。这里不支持任何干机。
#p#分页标题#e#
无论何时假如您建设了一个无法绑定到指定端口（大概是因为此外什么节制了该端口）的ServerSocket，Java代码都将抛出一个错误。所以这里我们必需捕获大概的BindException。就跟在客户机端上时一样，我们必需捕获IOException，当我们试图在ServerSocket上接管毗连时，它就会被抛出。请留意，您可以通过用毫秒数挪用setSoTimeout()来为accept()挪用配置超时，以制止实际长时间的期待。挪用setSoTimeout()将使accept()颠末指定占用时间后抛出IOException。
处理惩罚毗连
这里我们实现handleConnection()要领，它将用毗连的流来吸收输入和写输出：
1.public void handleConnection(Socket incomingConnection) {
2. try {
3. OutputStream outputToSocket = incomingConnection.getOutputStream();
4. InputStream inputFromSocket = incomingConnection.getInputStream();
5. BufferedReader streamReader = new BufferedReader(new InputStreamReader(inputFromSocket));
6. FileReader fileReader = new FileReader(new File(streamReader.readLine()));
7. BufferedReader bufferedFileReader = new BufferedReader(fileReader);
8. PrintWriter streamWriter = new PrintWriter(incomingConnection.getOutputStream());
9. String line = null;
10. while((line=bufferedFileReader.readLine())!=null){
11. streamWriter.println(line);
12. }
13. fileReader.close();
14. streamWriter.close();
15. streamReader.close();
16. }
17. catch(Exception e) {
18. System.out.println("Error handling a client: "+e);
19. e.printStackTrace();
20. }
21.}
跟在客户机中一样，我们用getOutputStream()和getInputStream()来获取与我们刚建设的Socket相关联的流。跟在客户机端一样，我们把InputStream包装进BufferedReader，把OutputStream包装进PrintWriter。在处事器端上，我们需要添加一些代码，用来读取方针文件和把内容逐行发送到客户机。这里是重要的代码：
FileReader fileReader = new FileReader(new File(streamReader.readLine()));
BufferedReader bufferedFileReader = new BufferedReader(fileReader);
String line = null;
while((line=bufferedFileReader.readLine())!=null)
{
streamWriter.println(line);
}
这些代码值得具体表明。让我们一点一点来看：
FileReader fileReader = new FileReader(new File(streamReader.readLine()));
首先，我们利用Socket的InputStream的BufferedReader。我们应该获取一条有效的文件路径，所以我们用该路径名结构一个新File。我们建设一个新FileReader来处理惩罚读文件的操纵。
BufferedReader bufferedFileReader = new BufferedReader(fileReader);
这里我们把FileReader包装进BufferedReader以使我们可以或许逐行地读该文件。
接着，我们挪用BufferedReader的readLine()。这个挪用将造成阻塞直到有字节到来。我们获取一些字节之后就把它们放到当地的line变量中，然后再写出到客户机上。完成读写操纵之后，我们就封锁打开的流。
请留意我们在完成从Socket的读操纵之后封锁streamWriter和streamReader。您或者会问我们为什么不在读取文件名之后立即封锁streamReader。原因是当您这样做时，您的客户机将不会获取任何数据。假如您在封锁streamWriter之前封锁streamReader，则您可以往Socket写任何对象，但却没有任何数据能通过通道（通道被封锁了）。
总结一下处事器
在我们接着接头另一个更实际的示例之前，让我们回首一下建设和利用ServerSocket的步调：
1.用一个您想让它侦听传入客户机毗连的端口来实例化一个ServerSocket（如有问题则抛出Exception）。
2.挪用ServerSocket的accept()以在期待毗连期间造成阻塞。
3.获取位于该底层Socket的流以举办读写操纵。
4.按使工作简朴化的原则包装流。
5.对Socket举办读写。
6.封锁打开的流（并请记着，永远不要在封锁Writer之前封锁Reader）。
6建设多线程Socket处事器
前面的示例教给您基本常识，但并不能令您更深入。假如您到此就遏制了，那么您一次只能处理惩罚一台客户机。原因是handleConnection()是一个阻塞要领。只有当它完成了对当前毗连的处理惩罚时，处事器才气接管另一个客户机。在大都时候，您将需要（也有须要）一个多线程处事器。
建设MultithreadedRemoteFileServer类
1.import java.io.*;
2.import java.net.*;
3.public class MultithreadedRemoteFileServer {
4. int listenPort;
5. public MultithreadedRemoteFileServer(int listenPort) {
6. this.listenPort=listenPort;
7. }
8. //答允客户机毗连随处事器,期待客户机请求
9. public void acceptConnections() {
10. try {
11. ServerSocket server = new ServerSocket(listenPort, 5);
12. Socket incomingConnection = null;
13. while(true) {
14. incomingConnection = server.accept();
15. handleConnection(incomingConnection);
16. }
17. }
18. catch(BindException e) {
19. System.out.println("Unable to bind to port "+listenPort);
20. }
21. catch(IOException e) {
22. System.out.println("Unable to instantiate a ServerSocket on port: "+listenPort);
23. }
24. }
25. //与客户机Socket交互以将客户机所请求的文件的内容发送到客户机
26. public void handleConnection(Socket connectionToHandle) {
27. new Thread(new ConnectionHandler(connectionToHandle)).start();
28. }
29. public static void main(String args[]) {
30. MultithreadedRemoteFileServer server = new MultithreadedRemoteFileServer(1001);
31. server.acceptConnections();
32. }
33.}
这里我们实现窜悔改acceptConnections()要领，它将建设一个可以或许处理惩罚待发请求的ServerSocket，并汇报ServerSocket接管毗连。
#p#分页标题#e#
新的server仍然需要acceptConnections()，所以这些代码实际上是一样的。突出显示的行暗示一个重大的差异。对这个多线程版，我们此刻可以指定客户机请求的最大数目，这些请求都能在实例化ServerSocket期间处于待发状态。假如我们没有指定客户机请求的最大数目，则我们假设利用缺省值50。
这里是它的事情机制。假设我们指定待发数（backlog值）是5而且有五台客户机请求毗连到我们的处事器。我们的处事器将着手处理惩罚第一个毗连，但处理惩罚该毗连需要很长时间。由于我们的待发值是5，所以我们一次可以放五个请求到行列中。我们正在处理惩罚一个，所以这意味着尚有其它五个正在期待。期待的和正在处理惩罚的一共有六个。当我们的处事器仍忙于接管一号毗连（记着行列中尚有2?6号）时，假如有第七个客户机提出毗连申请，那么，该第七个客户机将遭到拒绝。我们将在带有毗连池处事器示例中说明如何限定能同时毗连的客户机数目。
处理惩罚毗连：
public void handleConnection(Socket connectionToHandle) {
new Thread(new ConnectionHandler(connectionToHandle)).start();
}
我们对RemoteFileServer所做的大窜改就表此刻这个要领上。我们仍然在处事器接管一个毗连之后挪用handleConnection()，但此刻我们把该Socket通报给ConnectionHandler的一个实例，它是Runnable的。我们用ConnectionHandler建设一个新Thread并启动它。ConnectionHandler的run()要领包Socket读／写和读File的代码，这些代码本来在RemoteFileServer的handleConnection()中。
建设ConnectionHandler类
1.import java.io.*;
2.import java.net.*;
3.public class ConnectionHandler implements Runnable {
4. protected Socket socketToHandle;
5. public ConnectionHandler(Socket socketToHandle) {
6. this.socketToHandle=socketToHandle;
7. }
8. public void run() {
9. try {
10. PrintWriter streamWriter = new PrintWriter(socketToHandle.getOutputStream());
11. BufferedReader streamReader = new BufferedReader(new InputStreamReader(socketToHandle.getInputStream()));
12. String fileToRead = streamReader.readLine();
13. BufferedReader fileReader = new BufferedReader(new FileReader(fileToRead));
14. String line =null;
15. while((line=fileReader.readLine())!=null) {
16. streamWriter.println(line);
17. }
18. fileReader.close();
19. streamWriter.close();
20. streamReader.close();
21. }
22. catch(Exception e) {
23. System.out.println("Error handling a client: "+e);
24. e.printStackTrace();
25. }
26. }
27.}
这个助手类相当简朴。跟我们到今朝为止的其它类一样，我们导入java.net和java.io。该类只有一个实例变量socketToHandle，它生存由该实例处理惩罚的Socket。
类的结构器用一个Socket实例作参数并将它赋给socketToHandle。
请留意该类实现了Runnable接口。实现这个接口的类都必需实现run()要领。这里我们实现run()要领，它将攫取我们的毗连的流，用它来读写该毗连，并在任务完成之后封锁它。ConnectionHandler的run()要领所做的工作就是RemoteFileServer上的handleConnection()所做的工作。首先，我们把InputStream和OutputStream别离包装（用Socket的getOutputStream()和getInputStream()）进BufferedReader和PrintWriter。然后我们用这些代码逐行地读方针文件：
1.PrintWriter streamWriter = new PrintWriter(socketToHandle.getOutputStream());
2. BufferedReader streamReader = new BufferedReader(new InputStreamReader(socketToHandle.getInputStream()));
3. String fileToRead = streamReader.readLine();
4. BufferedReader fileReader = new BufferedReader(new FileReader(fileToRead));
5. String line =null;
6. while((line=fileReader.readLine())!=null) {
7. streamWriter.println(line);
8. }
#p#分页标题#e#
请记着我们应该从客户机获取一条有效的文件路径，这样用该路径名结构一个新File，把它包装进FileReader以处理惩罚读文件的操纵，然后把它包装进BufferedReader以让我们逐行地读该文件。我们while轮回中挪用BufferedReader上的readLine()直到不再有要读的行。请记注，对readLine()的挪用将造成阻塞，直到有字节来到为止。我们获取一些字节之后就把它们放到当地的line变量中，然后写出到客户机上。完成读写操纵之后，我们封锁打开的流。
总结一下多线程处事器
让我们回首一下建设和利用“多线程版”的处事器的步调：
1.修改acceptConnections()以用缺省为50（或任何您想要的大于1的指定命字）实例化ServerSocket。
2.修改ServerSocket的handleConnection()以用ConnectionHandler的一个实例生成一个新的Thread。
3.借用RemoteFileServer的handleConnection()要领的代码实现ConnectionHandler类。
7 建设带有毗连池的Socket处事器
我们此刻已经拥有的MultithreadedServer每当有客户机申请一个毗连时都在一个新Thread中建设一个新ConnectionHandler。这意味着大概有一捆Thread“躺”在我们周围。并且建设Thread的系统开销并不是微不敷道的。假如机能成为了问题（也请不要事惠临头才意识到它），更高效地处理惩罚我们的处事器是件功德。那么，我们如何更高效地打点处事器端呢？我们可以维护一个进入的毗连池，必然数量的ConnectionHandler将为它提供处事。这种设计能带来以下长处：
•它限定了答允同时毗连的数目。
•我们只需启动ConnectionHandler Thread一次。
幸运的是，跟在我们的多线程示例中一样，往代码中添加“池”不需要来一个大窜改。事实上，应用措施的客户机端基础就不受影响。在处事器端，我们在处事器启动时建设必然数量的ConnectionHandler，我们把进入的毗连放入“池”中并让ConnectionHandler打理剩下的工作。这种设计中有许多我们不规划接头的大概存在的能力。譬喻，我们可以通过限定答允在“池”中成立的毗连的数目来拒绝客户机。
请留意：我们将不会再次接头acceptConnections()。这个要领跟前面示例中的完全一样。它无限轮回地挪用ServerSocket上的accept()并把毗连通报到handleConnection()。
建设PooledRemoteFileServer类
1.import java.io.*;
2.import java.net.*;
3.import java.util.*;
4.public class PooledRemoteFileServer {
5. protected int maxConnections;
6. protected int listenPort;
7. protected ServerSocket serverSocket;
8. public PooledRemoteFileServer(int aListenPort, int maxConnections) {
9. listenPort= aListenPort;
10. this.maxConnections = maxConnections;
11. }
12. public void acceptConnections() {
13. try {
14. ServerSocket server = new ServerSocket(listenPort, 5);
15. Socket incomingConnection = null;
16. while(true) {
17. incomingConnection = server.accept();
18. handleConnection(incomingConnection);
19. }
20. }
21. catch(BindException e) {
22. System.out.println("");
23. }
24. catch(IOException e) {
25. System.out.println(""+listenPort);
26. }
27. }
28. protected void handleConnection(Socket connectionToHandle) {
29. PooledConnectionHandler.processRequest(connectionToHandle);
30. }
31. public void setUpHandlers() {
32. for(int i=0; i<maxConnections; i++) {
33. PooledConnectionHandler currentHandler = new PooledConnectionHandler();
34. new Thread(currentHandler, "Handler " + i).start();
35. }
36. }
37. public static void main(String args[]) {
38. PooledRemoteFileServer server = new PooledRemoteFileServer(1001, 3);
39. server.setUpHandlers();
40. server.acceptConnections();
41. }
42.}
请留意一下您此刻应该熟悉了的import语句。我们给类以下实例变量以生存：
•我们的处事器能同时处理惩罚的勾当客户机毗连的最大数目
•进入的毗连的侦听端口（我们没有指定缺省值，但假如您想这样做，并不会受到限制）
•将接管客户机毗连请求的ServerSocket
类的结构器用的参数是侦听端口和毗连的最大数目
#p#分页标题#e#
我们的类有一个main()要领和三个其它要领。稍后我们将探究这些要领的细节。此刻只须知道setUpHandlers()建设数目为maxConnections的大量PooledConnectionHandler，而其它两个要领例与我们前面已经看到的相似：acceptConnections()在ServerSocket上侦听传入的客户机毗连，而handleConnection则在客户机毗连一旦被成立后就实际处理惩罚它。
实现main()
这里我们实现需作窜改的main()要领，该要领将建设可以或许处理惩罚给定命目标客户机毗连的PooledRemoteFileServer，并汇报它接管毗连：
1.public static void main(String args[]) {
2. PooledRemoteFileServer server = new PooledRemoteFileServer(1001, 3);
3. server.setUpHandlers();
4. server.acceptConnections();
5.}
我们的main()要领很简朴。我们实例化一个新的PooledRemoteFileServer，它将通过挪用setUpHandlers()来成立三个PooledConnectionHandler。一旦处事器停当，我们就汇报它acceptConnections()。
成立毗连处理惩罚措施
1.public void setUpHandlers() {
2. for(int i=0; i<maxConnections; i++) {
3. PooledConnectionHandler currentHandler = new PooledConnectionHandler();
4. new Thread(currentHandler, "Handler " + i).start();
5. }
6. }
setUpHandlers()要领建设maxConnections（譬喻3）个PooledConnectionHandler并在新Thread中激活它们。用实现了Runnable的工具来建设Thread使我们可以在Thread挪用start()而且可以期望在Runnable上挪用了run()。换句话说，我们的PooledConnectionHandler将等着处理惩罚进入的毗连，每个都在它本身的Thread中举办。我们在示例中只建设三个Thread，并且一旦处事器运行，这就不能被改变。
处理惩罚毗连
这里我们实现需作窜改的handleConnections()要领，它将委派PooledConnectionHandler处理惩罚毗连：
protected void handleConnection(Socket connectionToHandle) {
PooledConnectionHandler.processRequest(connectionToHandle);
}
我们此刻叫PooledConnectionHandler处理惩罚所有进入的毗连（processRequest()是一个静态要领）。
建设PooledRemoteFileServer类
1.import java.io.*;
2.import java.net.*;
3.import java.util.*;
4.public class PooledConnectionHandler implements Runnable {
5. protected Socket connection;
6. protected static List pool = new LinkedList();
7. public PooledConnectionHandler() {}
8. public void handleConnection() {
9. try {
10. PrintWriter streamWriter = new PrintWriter(connection.getOutputStream());
11. BufferedReader streamReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
12. String fileToRead = streamReader.readLine();
13. BufferedReader fileReader = new BufferedReader(new FileReader(fileToRead));
14. String line = null;
15. while((line=fileReader.readLine())!=null)
16. streamWriter.println(line);
17. fileReader.close();
18. streamWriter.close();
19. streamReader.close();
20. }
21. catch(FileNotFoundException e) {
22. System.out.println("");
23. }
24. catch(IOException e) {
25. System.out.println(""+e);
26. }
27. }
28. public static void processRequest(Socket requestToHandle) {
29. synchronized(pool) {
30. pool.add(pool.size(), requestToHandle);
31. pool.notifyAll();
32. }
33. }
34. public void run() {
35. while(true) {
36. synchronized(pool) {
37. while(pool.isEmpty()) {
38. try {
39. pool.wait();
40. }
41. catch(InterruptedException e) {
42. e.printStackTrace();
43. }
44. }
45. connection= (Socket)pool.remove(0);
46. }
47. handleConnection();
48. }
49. }
50.}
这个助手类与ConnectionHandler很是相似，但它带有处理惩罚毗连池的手段。该类有两个实例变量：
•connection是当前正在处理惩罚的Socket
•名为pool的静态LinkedList生存需被处理惩罚的毗连
填充毗连池
#p#分页标题#e#
这里我们实现PooledConnectionHandler上的processRequest()要领，它将把传入请求添加到池中，并汇报其它正在期待的工具该池已经有一些内容：
public static void processRequest(Socket requestToHandle) {
synchronized(pool) {
pool.add(pool.size(), requestToHandle);
pool.notifyAll();
}
}
synchronized块是个稍微有些差异的对象。您可以同步任何工具上的一个块，而不可是在自己的某个要领中含有该块的工具。在我们的示例中，processRequest()要领包括有一个pool（请记着它是一个LinkedList，生存期待处理惩罚的毗连池）的synchronized块。我们这样做的原因是确保没有别人能跟我们同时修改毗连池。
既然我们已经担保了我们是独一“渡水”池中的人，我们就可以把传入的Socket添加到LinkedList的尾端。一旦我们添加了新的毗连，我们就用以下代码通知其它正在期待该池的Thread，池此刻已经可用：
pool.notifyAll();
Object的所有子类都担任这个notifyAll()要领。这个要领，连同我们下一屏将要接头的wait()要领一起，就使一个Thread可以或许让另一个Thread知道一些条件已经具备。这意味着该第二个Thread必然正在期待那些条件的满意。
从池中获取毗连
这里我们实现PooledConnectionHandler上需作窜改的run()要领，它将在毗连池上期待，而且池中一有毗连就处理惩罚它：
1.public void run() {
2. while(true) {
3. synchronized(pool) {
4. while(pool.isEmpty()) {
5. try {
6. pool.wait();
7. }
8. catch(InterruptedException e) {
9. e.printStackTrace();
10. }
11. }
12. connection= (Socket)pool.remove(0);
13. }
14. handleConnection();
15. }
16.}
追念一下在前面讲过的：一个Thread正在期待有人通知它毗连池方面的条件已经满意了。在我们的示例中，请记着我们有三个PooledConnectionHandler在期待利用池中的毗连。每个PooledConnectionHandler都在它自已的Thread中运行，并通过挪用pool.wait()发生阻塞。当我们的processRequest()在毗连池上挪用notifyAll()时，所有正在期待的PooledConnectionHandler都将获得“池已经可用”的通知。然后各自继承前行挪用pool.wait()，并从头查抄while(pool.isEmpty())轮回条件。除了一个处理惩罚措施，其它池对所有处理惩罚措施都将是空的，因此，在挪用pool.wait()时，除了一个处理惩罚措施，其它所有处理惩罚措施都将再次发生阻塞。刚巧碰上非空池的处理惩罚措施将跳出while(pool.isEmpty())轮回并攫取池中的第一个毗连：
connection=(Socket)pool.remove(0);
处理惩罚措施一旦有一个毗连可以利用，就挪用handleConnection()处理惩罚它。
在我们的示例中，池中大概永远不会有多个毗连，只是因为工作很快就被处理惩罚掉了。假如池中有一个以上毗连，那么其它处理惩罚措施将不必期待新的毗连被添加到池。当它们查抄pool.isEmpty()条件时，将发明其值为假，然后就从池中攫取一个毗连并处理惩罚它。
尚有另一件事需留意。当run()拥有池的互斥锁时，processRequest()如何可以或许把毗连放到池中呢？谜底是对池上的wait()的挪用释放锁，而wait()接着就在本身返回之前再次攫取该锁。这就使得池工具的其它同步代码可以获取该锁。
处理惩罚毗连：再一次
这里我们实现需做窜改的handleConnection()要领，该要领将攫取毗连的流，利用它们，并在任务完成之后排除它们：
1.public void handleConnection() {
2. try {
3. PrintWriter streamWriter = new PrintWriter(connection.getOutputStream());
4. BufferedReader streamReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
5. String fileToRead = streamReader.readLine();
6. BufferedReader fileReader = new BufferedReader(new FileReader(fileToRead));
7. String line = null;
8. while((line=fileReader.readLine())!=null)
9. streamWriter.println(line);
10. fileReader.close();
11. streamWriter.close();
12. streamReader.close();
13. }
14. catch(FileNotFoundException e) {
15. System.out.println("");
16. }
17. catch(IOException e) {
18. System.out.println(""+e);
19. }
20.}
跟在多线程处事器中差异，我们的PooledConnectionHandler有一个handleConnection()要领。这个要领的代码跟非池式的ConnectionHandler上的run()要领的代码完全一样。首先，我们把OutputStream和InputStream别离包装进（用Socket上的getOutputStream()和getInputStream()）BufferedReader和PrintWriter。然后我们逐行读方针文件，就象我们在多线程示例中做的那样。再一次，我们获取一些字节之后就把它们放到当地的line变量中，然后写出到客户机。完成读写操纵之后，我们封锁FileReader和打开的流。
总结一下带有毗连池的处事器
让我们回首一下建设和利用“池版”处事器的步调：
1.建设一个新种类的毗连处理惩罚措施（我们称之为PooledConnectionHandler）来处理惩罚池中的毗连。
2.修改处事器以建设和利用一组PooledConnectionHandler。
#p#分页标题#e#
Java语言简化了套接字在应用措施中的利用。它的基本实际上是java.net包中的Socket和ServerSocket类。一旦您领略了表象背后产生的环境，就能容易地利用这些类。在现实糊口中利用套接字只是这样一件事，即通过贯彻优秀的OO设计原则来掩护应用措施中各层间的封装。我们为您展示了一些有辅佐的类。这些类的布局对我们的应用措施埋没了Socket交互浸染的初级细节?使应用措施能只利用可插入的ClientSocketFacade和ServerSocketFacade。在有些处所（在Facade内），您仍然必需打点稍显混乱的字节细节，但您只须做一次就可以了。更好的是，您可以在未来的项目中重用这些初级此外助手类。
