[关键字： java socket编程]
1)Server端
Java代码
import java.io.*;
import java.net.*;
public class PooledRemoteFileServer {
//服务器能同时处理的活动客户机连接的最大数目
protected int maxConnections;
//进入的连接的侦听端口
protected int listenPort;
//将接受客户机连接请求的 ServerSocket
protected ServerSocket serverSocket;
public PooledRemoteFileServer(int aListenPort, int maxConnections) {
listenPort= aListenPort;
this.maxConnections = maxConnections;
}
public void acceptConnections() {
try {
ServerSocket server = new ServerSocket(listenPort, 5);
Socket incomingConnection = null;
while(true) {
incomingConnection = server.accept();
handleConnection(incomingConnection);
}
}
catch(BindException e) {
System.out.println("");
}
catch(IOException e) {
System.out.println(""+listenPort);
}
}
/**
* 委派PooledConnectionHandler处理连接
*/
protected void handleConnection(Socket connectionToHandle) {
PooledConnectionHandler.processRequest(connectionToHandle);
}
/**
* 创建maxConnections个PooledConnectionHandler并在新Thread中激活它们。
* PooledConnectionHandler将等着处理进入的连接，每个都在它自己的Thread中进行。
*/
public void setUpHandlers() {
for(int i=0; i<maxConnections; i++) {
PooledConnectionHandler currentHandler = new PooledConnectionHandler();
new Thread(currentHandler, "Handler " + i).start();
}
}
public static void main(String args[]) {
PooledRemoteFileServer server = new PooledRemoteFileServer(1001, 3);
server.setUpHandlers();
server.acceptConnections();
}
}import java.io.*;
import java.net.*;
public class PooledRemoteFileServer {
//服务器能同时处理的活动客户机连接的最大数目
protected int maxConnections;
//进入的连接的侦听端口
protected int listenPort;
//将接受客户机连接请求的 ServerSocket
protected ServerSocket serverSocket;
public PooledRemoteFileServer(int aListenPort, int maxConnections) {
listenPort= aListenPort;
this.maxConnections = maxConnections;
}
public void acceptConnections() {
try {
ServerSocket server = new ServerSocket(listenPort, 5);
Socket incomingConnection = null;
while(true) {
incomingConnection = server.accept();
handleConnection(incomingConnection);
}
}
catch(BindException e) {
System.out.println("");
}
catch(IOException e) {
System.out.println(""+listenPort);
}
}
/**
* 委派PooledConnectionHandler处理连接
*/
protected void handleConnection(Socket connectionToHandle) {
PooledConnectionHandler.processRequest(connectionToHandle);
}
/**
* 创建maxConnections个PooledConnectionHandler并在新Thread中激活它们。
* PooledConnectionHandler将等着处理进入的连接，每个都在它自己的Thread中进行。
*/
public void setUpHandlers() {
for(int i=0; i<maxConnections; i++) {
PooledConnectionHandler currentHandler = new PooledConnectionHandler();
new Thread(currentHandler, "Handler " + i).start();
}
}
public static void main(String args[]) {
PooledRemoteFileServer server = new PooledRemoteFileServer(1001, 3);
server.setUpHandlers();
server.acceptConnections();
}
}
(2)实现线程池的类
Java代码
import java.io.*;
import java.net.*;
import java.util.*;
public class PooledConnectionHandler implements Runnable {
//connection是当前正在处理的 Socket
protected Socket connection;
//静态 LinkedList 保存需被处理的连接,工作队列
protected static List pool = new LinkedList();
public PooledConnectionHandler() {}
/**
* 将攫取连接的流，使用它们，并在任务完成之后清除它们
*/
public void handleConnection() {
try {
PrintWriter streamWriter = new PrintWriter(connection.getOutputStream());
BufferedReader streamReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
String fileToRead = streamReader.readLine();
BufferedReader fileReader = new BufferedReader(new FileReader(fileToRead));
String line = null;
while((line=fileReader.readLine())!=null)
streamWriter.println(line);
fileReader.close();
streamWriter.close();
streamReader.close();
}
catch(FileNotFoundException e) {
System.out.println("");
}
catch(IOException e) {
System.out.println(""+e);
}
}
/**
* 将把传入请求添加到池中，并告诉其它正在等待的对象该池已经有一些内容
* @param requestToHandle
*/
@SuppressWarnings("unchecked")
public static void processRequest(Socket requestToHandle) {
//确保没有别人能跟我们同时修改连接池
synchronized(pool) {
//把传入的Socket添加到LinkedList的尾端
pool.add(pool.size(), requestToHandle);
//通知其它正在等待该池的Thread，池现在已经可用
pool.notifyAll();
}
}
public void run() {
while(true) {
synchronized(pool) {
while(pool.isEmpty()) {
try {
//对池上的wait()的调用释放锁，而wait()接着就在自己返回之前再次攫取该锁
pool.wait();//在连接池上等待，并且池中一有连接就处理它
}
catch(InterruptedException e) {
e.printStackTrace();
}
}
//恰巧碰上非空池的处理程序将跳出while(pool.isEmpty())循环并攫取池中的第一个连接
connection= (Socket)pool.remove(0);
}
handleConnection();
}
}
}import java.io.*;
import java.net.*;
import java.util.*;
public class PooledConnectionHandler implements Runnable {
//connection是当前正在处理的 Socket
protected Socket connection;
//静态 LinkedList 保存需被处理的连接,工作队列
protected static List pool = new LinkedList();
public PooledConnectionHandler() {}
/**
* 将攫取连接的流，使用它们，并在任务完成之后清除它们
*/
public void handleConnection() {
try {
PrintWriter streamWriter = new PrintWriter(connection.getOutputStream());
BufferedReader streamReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
String fileToRead = streamReader.readLine();
BufferedReader fileReader = new BufferedReader(new FileReader(fileToRead));
String line = null;
while((line=fileReader.readLine())!=null)
streamWriter.println(line);
fileReader.close();
streamWriter.close();
streamReader.close();
}
catch(FileNotFoundException e) {
System.out.println("");
}
catch(IOException e) {
System.out.println(""+e);
}
}
/**
* 将把传入请求添加到池中，并告诉其它正在等待的对象该池已经有一些内容
* @param requestToHandle
*/
@SuppressWarnings("unchecked")
public static void processRequest(Socket requestToHandle) {
//确保没有别人能跟我们同时修改连接池
synchronized(pool) {
//把传入的Socket添加到LinkedList的尾端
pool.add(pool.size(), requestToHandle);
//通知其它正在等待该池的Thread，池现在已经可用
pool.notifyAll();
}
}
public void run() {
while(true) {
synchronized(pool) {
while(pool.isEmpty()) {
try {
//对池上的wait()的调用释放锁，而wait()接着就在自己返回之前再次攫取该锁
pool.wait();//在连接池上等待，并且池中一有连接就处理它
}
catch(InterruptedException e) {
e.printStackTrace();
}
}
//恰巧碰上非空池的处理程序将跳出while(pool.isEmpty())循环并攫取池中的第一个连接
connection= (Socket)pool.remove(0);
}
handleConnection();
}
}
}(3)Client端
Java代码
import java.io.*;
import java.net.*;
/**
* 用您想连接的机器的 IP 地址和端口实例化 Socket。
* 获取 Socket 上的流以进行读写。
* 把流包装进 BufferedReader/PrintWriter 的实例，如果这样做能使事情更简单的话。
* 对 Socket 进行读写。
* 关闭打开的流。
* @author Administrator
*/
public class RemoteFileClient {
protected BufferedReader socketReader;
protected PrintWriter socketWriter;
protected String hostIp;
protected int hostPort;
/**
* 构造方法
*/
public RemoteFileClient(String hostIp, int hostPort) {
this.hostIp = hostIp;
this.hostPort=hostPort;
}
/**
* 向服务器请求文件的内容,告诉服务器我们想要什么文件并在服务器传回其内容时接收该内容
*/
public String getFile(String fileNameToGet) {
StringBuffer fileLines = new StringBuffer();
try {
socketWriter.println(fileNameToGet);
socketWriter.flush();
String line = null;
while((line=socketReader.readLine())!=null)
fileLines.append(line+"/n");
}
catch(IOException e) {
System.out.println("Error reading from file: "+fileNameToGet);
}
return fileLines.toString();
}
/**
* 连接到远程服务器,创建我们的 Socket 并让我们访问该套接字的流
*/
public void setUpConnection() {
try {
Socket client = new Socket(hostIp,hostPort);
socketReader = new BufferedReader(new InputStreamReader(client.getInputStream()));
socketWriter = new PrintWriter(client.getOutputStream());
}
catch(UnknownHostException e) {
System.out.println("Error1 setting up socket connection: unknown host at "+hostIp+":"+hostPort);
}
catch(IOException e) {
System.out.println("Error2 setting up socket connection: "+e);
}
}
/**
* 使用完毕连接后负责“清除”。
*/
public void tearDownConnection() {
try {
socketWriter.close();
socketReader.close();
}catch(IOException e) {
System.out.println("Error tearing down socket connection: "+e);
}
}
public static void main(String args[]) {
RemoteFileClient remoteFileClient = new RemoteFileClient("127.0.0.1",1001);
remoteFileClient.setUpConnection();
StringBuffer fileContents = new StringBuffer();
fileContents.append(remoteFileClient.getFile("D:/test.txt"));
//remoteFileClient.tearDownConnection();
System.out.println(fileContents);
}
}
1028
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
