JAVA之ServerSocket的几个单线程多线程的例子

这里把之前看过的几个ServerSocket的例子给放在这里.例子看看运行一下,修改一下部分内容感觉还是有些收获的,因为调试过.这里会有印象,因此保留以供以后使用:

例子之单线程,只有一个代码文件:

/*
 * 简单的一个发送时间的ServerSocket的例子
 * 
 * 单线程的,仅仅是能够应答连接的客户就立即断开连接了. 
 */
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;

public class TimeServer extends Thread
{
	private ServerSocket sock;

	public TimeServer()
	{
		super();
		try
		{
			sock = new ServerSocket(64415);
			System.out.println("TimeServer running ...");
		} catch (IOException e)
		{
			System.out.println("Error: couldn't create socket.");
			System.exit(1);
		}
	}

	@Override
	public void run()
	{
		Socket client = null;

		while (true)
		{
			if (sock == null)
				return;
			try
			{
				client = sock.accept();
				BufferedOutputStream bos = new BufferedOutputStream(
						client.getOutputStream());
				PrintWriter outputStream = new PrintWriter(bos, false);

				Date now = new Date();
				outputStream.println(now);
				System.out.println("New connection accepted "
						+ client.getInetAddress() + ":" + client.getPort());
				outputStream.flush();

				outputStream.close();
				client.close();
			} catch (IOException e)
			{
				System.out.println("Error: couldn't connect to client.");
				System.exit(1);
			}
		}
	}

	public static void main(String[] arguments)
	{
		TimeServer server = new TimeServer();
		server.start();
	}

}

例子之多线程简单解析应答服务器(两个文件)

文件一:启动服务器侦听连接来的客户端,连接客户端之后启动新的线程进行服务.

//类receiveServer 
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;

public class ReceiveServer
{
	final int RECEIVE_PORT = 9090;// 该服务器的端口号

	// receiveServer的构造器
	public ReceiveServer()
	{
		ServerSocket rServer = null;// ServerSocket的实例
		Socket request = null; // 用户请求的套接字
		Thread receiveThread = null;
		try
		{
			rServer = new ServerSocket(RECEIVE_PORT);
			// 初始化ServerSocket
			System.out.println("Welcome to the server!");
			System.out.println(new Date());
			System.out.println("The server is ready!");
			System.out.println("Port: " + RECEIVE_PORT);
			while (true)
			{
				// 等待用户请求
				request = rServer.accept();
				// 接收客户机连接请求
				receiveThread = new serverThread(request);
				// 生成serverThread的实例
				receiveThread.start();
				// 启动serverThread线程
			}
		} catch (IOException e)
		{
			System.out.println(e.getMessage());
		}
	}

	public static void main(String args[])
	{
		new ReceiveServer();
	} // end of main
} // end of class

文件二:服务线程

//类serverThread 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;

class serverThread extends Thread
{
	Socket clientRequest;// 用户连接的通信套接字
	BufferedReader input;// 输入流
	PrintWriter output;// 输出流

	// serverThread的构造器
	public serverThread(Socket s)
	{
		this.clientRequest = s;
		// 接收receiveServer传来的套接字
		InputStreamReader reader;
		OutputStreamWriter writer;
		try
		{ // 初始化输入、输出流
			reader = new InputStreamReader(clientRequest.getInputStream());
			writer = new OutputStreamWriter(clientRequest.getOutputStream());
			input = new BufferedReader(reader);
			output = new PrintWriter(writer, true);
		} catch (IOException e)
		{
			System.out.println(e.getMessage());
		}
		output.println("Welcome to the server!");
		// 客户机连接欢迎词
		output.println("Now is: " + new java.util.Date() + " " + "Port:"
				+ clientRequest.getLocalPort());
		output.println("What can I do for you?");
	}

	@Override
	public void run()
	{ // 线程的执行方法

		String command = null; // 用户指令
		String str = null;
		boolean done = false;
		while (!done)
		{
			try
			{
				str = input.readLine(); // 接收客户机指令
			} catch (IOException e)
			{
				System.out.println(e.getMessage());
			}
			command = str.trim().toUpperCase();
			if (str == null || command.equals("QUIT"))
			{// 命令quit结束本次连接
				done = true;
			} else if (command.equals("HELP"))
			{
				// 命令help查询本服务器可接受的命令
				output.println("query");
				output.println("quit");
				output.println("help");
			} else if (command.startsWith("QUERY"))
			{ // 命令query
				output.println("OK to query something!");
			}
			// else if …….. //在此可加入服务器的其他指令
			else if (!command.startsWith("HELP") && !command.startsWith("QUIT")
					&& !command.startsWith("QUERY"))
			{
				output.println("Command not Found! Please refer to the HELP!");
			}
		}// end of while

		try
		{
			clientRequest.close(); // 关闭套接字
		} catch (IOException e)
		{
			System.out.println(e.getMessage());
		}
		command = null;
	}// end of run
}

例子之多线程服务可以对每个客户都发送信息(两个文件)

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Date;

/**
 * @author yeeku.H.lee kongyeeku@163.com
 * @version 1.0 <br>
 *          Copyright (C), 2005-2008, yeeku.H.Lee <br>
 *          This program is protected by copyright laws. <br>
 *          Program Name: <br>
 *          Date:
 */
public class MyServer
{
	// 定义保存所有Socket的ArrayList
	public static ArrayList<Socket> socketList = new ArrayList<Socket>();

	public static void main(String[] args) throws IOException
	{
		ServerSocket ss = new ServerSocket(30000);
		while (true)
		{
			// 此行代码会阻塞，将一直等待别人的连接
			System.out.println("ServerSocket listening!!!");
			Socket s = ss.accept();
			socketList.add(s);
			System.out.println("SocketClient Accepted!");

			Date now = new Date();
			// outputStream.println(now);
			System.out.println("New connection accepted " + now
					+ s.getInetAddress() + ":" + s.getPort());

			// 每当客户端连接后启动一条ServerThread线程为该客户端服务
			Thread t1 = new Thread(new ServerThread(s));
			t1.start();
		}
	}
}

文件二:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;


/**
 * @author  yeeku.H.lee kongyeeku@163.com
 * @version  1.0
 * <br>Copyright (C), 2005-2008, yeeku.H.Lee
 * <br>This program is protected by copyright laws.
 * <br>Program Name:
 * <br>Date: 
 */
//负责处理每个线程通信的线程类
public class ServerThread implements Runnable 
{
	//定义当前线程所处理的Socket
	Socket s = null;
	//该线程所处理的Socket所对应的输入流
	BufferedReader br = null;
	String str = null;
	String content = null;

	public ServerThread(Socket s) throws IOException
	{
		this.s = s;
		// 初始化该Socket对应的输入流
		// br = new BufferedReader(new
		// InputStreamReader(s.getInputStream(),"unicode"));// "utf-8")); //②
		InputStreamReader reader;
		reader = new InputStreamReader(this.s.getInputStream(),"utf-8");
		br = new BufferedReader(reader);
	}

	@Override
	public void run()
	{
		try
		{
			// 采用循环不断从Socket中读取客户端发送过来的数据
			while (true)
			{
				content = readFromClient();
				if (content == null)
				{
					break;
				}
				// 遍历socketList中的每个Socket，
				// 将读到的内容向每个Socket发送一次
				for (Socket client : MyServer.socketList)
				{
					/*BufferedOutputStream bos = new BufferedOutputStream(
							client.getOutputStream());
					PrintWriter outputStream = new PrintWriter(bos, false);
					Date now = new Date();
					outputStream.println(now);
					System.out.println("New connection accepted "
							+ client.getInetAddress() + ":" + client.getPort());
					outputStream.flush();
					outputStream.close();
					*/
					OutputStream os = client.getOutputStream();
					os.write((content + "\n").getBytes("utf-8"));
				}
			}
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
	}
	//定义读取客户端数据的方法
	private String readFromClient()
	{
		try
		{
			str = br.readLine();
			return str;
		}
		//如果捕捉到异常，表明该Socket对应的客户端已经关闭
		catch (IOException e)
		{
			//删除该Socket。
			MyServer.socketList.remove(s);    //①
		}
		return null;
	}
}