chatroomserver.java

用JAVA实现的socket网络通信

package chatserver;
//chat room server

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;

public class ChatRoomServer extends Frame implements Runnable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	Panel panel;
	ScrollPane sPanel;
	TextArea textArea;
	Button button1;
	
	//net
	ServerSocket serverSock;
	public final static int DEFAULT_PORT=6666;//默认端口号
	Thread chatAcceptThread;//启动接受连接的线程
	BroadcastThread broadcastThread;//广播线程，在服务器监听的时候运行
	java.util.Vector clients;//记录连接的线程
	java.util.Vector clientsInfor;//记录连接线程的信息
	public static int index=0;
	
	public ChatRoomServer(){
		super("ChatRoomServer");//设定标题栏
		try{
			jbInit();
		}catch(Exception e){
			e.printStackTrace();
		}
		serverListen();//服务器开始监听
	}
	
	private void jbInit(){//初始化界面
		panel=new Panel();
		sPanel=new ScrollPane();
		textArea=new TextArea("服务器信息：\n");
		button1=new Button("退出");
		
		sPanel.add(textArea);
		
		button1.addActionListener(new java.awt.event.ActionListener(){//退出
			public void actionPerformed(ActionEvent e){
				button1_actionPerformed(e);
			}
		});
		panel.add(button1);
		this.addWindowListener(new ChatFrame_WindowAdapter(this));
		//注册到继承了窗口适配器的类
		
		this.setSize(600,600);
		this.setLayout(new BorderLayout());
		this.add(sPanel,BorderLayout.CENTER);
		this.add(panel,BorderLayout.SOUTH);
		this.setVisible(true);
	}
	
	private void button1_actionPerformed(ActionEvent e){
		exit();
	}
	
	public void processMsg(String str){
		textArea.append(str);
	}
	
	private void serverListen(){//侦听线程
		try{
			serverSock=new ServerSocket(DEFAULT_PORT);
		}catch(IOException e){
			processMsg(e.toString());
			processMsg("Server failed!\n");
		}
		processMsg("Server Listening on Port:"+DEFAULT_PORT+"\n");
		clients=new java.util.Vector();
		clientsInfor=new java.util.Vector();
		
		chatAcceptThread=new Thread(this);//启动接受连接的线程
		chatAcceptThread.start();
		
		broadcastThread=new BroadcastThread(this);//广播线程
		broadcastThread.start();
		
		//还有一个回收无用连接thread的线程
	}
	
	public void run(){//接受连接并记录线程信息
		int i=0;
		try{
			while(true){
				Socket clientSock=serverSock.accept();
				CommunicateThread ct=new CommunicateThread(clientSock,this,index);
				//创建线程保持连接
				clients.add(ct);//记录通信线程
				i++;
				index++;//version 2
				clientsInfor.add("Thread-"+i);
				processMsg("Thread-"+i+" join in\n");
			}
		}catch(IOException e){
				processMsg(e.toString());
			}
		}
		
		public void exit(){
			broadcastThread.broadcast("Server exit!");
			try{
				serverSock.close();
			}catch(IOException ioe){}
			finally{
				System.exit(0);
			}
		}
		
		public static void main(String[] args){
			ChatRoomServer chat=new ChatRoomServer();
			chat.setVisible(true);
		}
	}

class CommunicateThread extends Thread{//保持连接线程
	protected Socket clientSock;
	protected BufferedReader in=null;
	protected PrintWriter out;
	ChatRoomServer chatFrame;
	boolean isTrue=true;//run()
	java.util.Vector inforStack;
	int index2;//
	
	public CommunicateThread(Socket Sock,ChatRoomServer cFrame,int index){
		clientSock=Sock;
		chatFrame=cFrame;
		index2=index;
		inforStack=new java.util.Vector();
		
		try{
			in=new BufferedReader(new InputStreamReader(clientSock.getInputStream()));
			out=new PrintWriter(clientSock.getOutputStream());
		}catch(IOException ei){
			try{
				clientSock.close();
			}catch(IOException ei2){}
			
			chatFrame.processMsg(ei.toString());
			return;
		}
		this.start();
	}
	
	public void run(){
		String infor;
		try{
			while(isTrue){
				infor=in.readLine();
				if(infor.equals("Client exit!")){
					writeInformation(infor);//写信息到信息栈，以广播出去
					stopRun();
				}
				else if(infor!=null){
					writeInformation(infor);
				}//else break
				try{
					Thread.sleep(100);//version2
				}catch(InterruptedException ex){}
			}
		}catch(IOException e){;}
		finally{
			try{
				in.close();
				out.close();
				clientSock.close();
				chatFrame.clients.remove(index2);//在clients中清除本线程
				ChatRoomServer.index--;
			}catch(IOException ei){;}
		}
	}
	
	public void writeInformation(String infor){//写信息栈
		inforStack.add(infor);
	}
	
	public void stopRun(){//终止线程
		isTrue=false;
	}
	
	public void sendInformation(String str){//发送信息
		try{
			out.println(str);
			out.flush();
		}catch(Exception e){;}
	}
}

class BroadcastThread extends Thread{//广播线程
	ChatRoomServer chatFrame2;
	java.util.Vector chatClients;//连接线程信息
	java.util.Vector msgStack;//信息栈
	java.util.Vector clientMsg;//记录客户发送的信息
	CommunicateThread comThread1;
	CommunicateThread comThread2;
	String string;//信息栈中的信息
	String clientName;//客户线程名
	String broadcastInfor;//广播信息=客户名+字符串
	public BroadcastThread(ChatRoomServer cFrame){
		chatFrame2=cFrame;
		chatClients=chatFrame2.clients;
		clientMsg=chatFrame2.clientsInfor;
		//开始程序
	}
	
	public void broadcast(String str){//广播
		for(int k=0;k<chatClients.size();k++){//发送给每个用户，分别调用每个连接线程，发送信息
			comThread2=(CommunicateThread)chatClients.get(k);
			comThread2.sendInformation(str);
		}
	}
	public void run(){
		try{
			while(true){
				for(int i=0;i<chatClients.size();i++){
					comThread1=(CommunicateThread)chatClients.get(i);
					msgStack=comThread1.inforStack;//得到每个连接的信息栈
					clientName=(String)clientMsg.get(i);//客户名
					//读取每个连接线程的信息栈并把信息发送出去
					for(int j=0;j<msgStack.size();j++){
						string=(String)msgStack.get(j);
						broadcastInfor=clientName+"->"+string;
						broadcast(broadcastInfor);
					}
					//清除信息栈
					msgStack.removeAllElements();
				}
				try{
					Thread.sleep(100);//version2
				}catch(InterruptedException ex){}
			}
		}catch(Exception e){;}
	}
}
class ChatFrame_WindowAdapter extends java.awt.event.WindowAdapter{
	ChatRoomServer chatFrame;
	public ChatFrame_WindowAdapter(ChatRoomServer chatFrame){
		this.chatFrame=chatFrame;
	}
	public void windowClosing(WindowEvent e){//退出程序
		chatFrame.exit();
	}
}