chatserver.java

java 聊天程序（c/s)适合初学者使用

            parent = userRoot;
        }
        usrModel.insertNodeInto(childNode, parent, 
                                 parent.getChildCount());
	  if (shouldBeVisible) {
            UserTree.scrollPathToVisible(new javax.swing.tree.TreePath(childNode.getPath()));
        }
        return childNode;
    }
}

class Host implements Runnable
{
		  int current=0;
        Thread t=null;
        int prt;
        ChatServer cs;
        ThreadBoss tb=null;
        java.net.ServerSocket serverSocket = null;
        public Host(int p, ChatServer csp)
        {
            prt=p;
            cs=csp;
	    
            t=new Thread(this);
            t.start();
        }
		public void run()
      		{
        	    boolean listening = true; 			tb=new ThreadBoss();
			try
			{
				serverSocket = new java.net.ServerSocket(prt);
			}
			catch (java.io.IOException e)
			{
				ChatServer.print("Failed");
				ChatServer.print("Could not create server socket on port: "+prt);
				ChatServer.print("Searching for available ports...");
				for(prt=1000;prt<=6000 && serverSocket==null;prt++)
				{
					try
					{
						serverSocket = new java.net.ServerSocket(prt);
					}
					catch (java.io.IOException ee)
					{
						serverSocket=null;
					}
				}
				if(serverSocket==null)
				{
					ChatServer.print("Failed");
					ChatServer.print("No ports available");
					return;
				}
		}
                try{cs.setHostName(java.net.InetAddress.getLocalHost().toString());} catch(Exception e){}
		ChatServer.print("OK");
		ChatServer.print("Listening on port: "+prt+"\n");
		while(listening)
		{
			ChatServer.printd("ChatServer:main:Listening");
			try{new ChatServerThread(serverSocket.accept(),tb,current);}catch(Exception e) {}
			current++;
		}
		try{serverSocket.close();}catch(Exception e) {}
        }
        public void kill()
        {
            try{serverSocket.close();}catch(Exception e) {}
            tb.stop();
            t.stop();
        }
	public ThreadBoss returnTb()
	{
		return tb;
	}
}

class ThreadBoss
{
	static String[] messageBuffer=new String[255];
	static int idno=0;
	static User[] Users=new User[255];
	static int currentWriteIndex=0;
	boolean stop=false;
	public ThreadBoss()
	{
		ChatServer.printd("ThreadBoss:ThreadBoss constructed");
 		messageBuffer[0]="Welcome to the Kaff Chat Server, Contact Yani Ioannou [e-mail] to report any bugs";
		currentWriteIndex++;

	}
	public synchronized void receiveRequest(String rec)
	{
		ChatServer.printd("ThreadBoss:Receive request");
		messageBuffer[currentWriteIndex]=rec;
		if(currentWriteIndex>=254)
		{
			currentWriteIndex=0;
		}else
		{
			currentWriteIndex++;
		}
	}
	public synchronized  String sendRequest(int index)
	{
		if(index==-1) index=currentWriteIndex;
		if(stop)
		{
			return "Bye.";
		}
		else if(index==currentWriteIndex)
		{
			return null;
		}else
		{
			ChatServer.printd("ThreadBoss:sendRequest");
			return messageBuffer[index];
		}
	}
	public void ResortBuffer(int index)
	{
		ChatServer.printd("ThreadBoss: Resort buffer");
		int i;
		messageBuffer[index]=null;
		for(i=index;messageBuffer[index]!=null && i!=index;i++)
		{
			messageBuffer[i]=messageBuffer[i+1];
		}
	}
	public int userId()
	{
		idno++;
		return idno;
	}
	public void addUser(User usr)
	{
		ChatServer.printd("ThreadBoss: Add User");
		receiveRequest("addUser");
		receiveRequest(usr.getname());
		receiveRequest("Server> "+usr.getname()+" has joined");
      ChatServer.addUsermsg(usr.getname());
	}
	public void removeUser(User usr)
	{
		String name=usr.getname();
		ChatServer.printd("ThreadBoss: Remove User");
		receiveRequest("removeUser");
		receiveRequest(""+name);
		receiveRequest("Server> "+name+" has left");
    ChatServer.removeUser(usr);
	}
	public void stop()
	{
		stop=true;
	}
}

class ChatServerThread implements Runnable
{
	String outputLine;
        private java.net.Socket socket = null;
        Thread t=new Thread(this);
        ThreadBoss tb=null;
        ThreadRecieveBoss trb=null;
        User usr=null;
        int index; 
        java.io.PrintWriter out=null;
	
	public ChatServerThread(java.net.Socket s, ThreadBoss tbp, int i)
	{
		ChatServer.printd("ChatServerThread: ChatServerThread constructed");
		tb=tbp;
		socket=s;
		index=-1;
		ChatServer.print("Accepted Client:"+s.toString());
                t.start();
                trb=new ThreadRecieveBoss(this,tb);
		}
		public void changeIndex(int i)
		{
			ChatServer.printd("ChatServerThread: changeindex");
			index=i;
		}
		public void send(String s)
		{
			ChatServer.printd("ChatServerThread:send");
			out.println(s);
		}
		public void run()
		{
			ChatServer.printd("ChatServerThread:run");
			try 
			{
	    		java.io.BufferedReader in = new java.io.BufferedReader(new java.io.InputStreamReader(socket.getInputStream()));
	    		out = new java.io.PrintWriter(socket.getOutputStream(), true);
			
		    	String inputLine;
            ChatServerProtocol csp = new ChatServerProtocol();
            outputLine = csp.process(null);
            out.println(outputLine);
            ChatServer.printd("outputLine: "+outputLine);
                        
	    		usr=new User(in.readLine(), socket.getInetAddress().toString(), tb.userId());
	    		tb.addUser(usr);
	    		ChatServer.printd("ChatServerThread: Added User");
	    		while ((inputLine = in.readLine()) != null)
	    		{
	    			if(tb.stop)
				   {
				   	out.close();
	    				in.close();
	    				socket.close();
						ChatServer.print("Socket closed: "+socket.toString());
						kill();
					 }
				   ChatServer.printd("Recieved: "+inputLine);
               outputLine = csp.process(inputLine);
               if(outputLine.equals("Cls"))
               {
               	out.println(outputLine);
               	}
               else if (outputLine.equals("Bye"))
					{
						ChatServer.print("Recieved BYE preparing to disconnect");
						break;
	    			}else
	    			{
	    				tb.receiveRequest(outputLine);
                 	ChatServer.print("Added to buffer: "+outputLine);
               }
	    		}
	    		out.close();
	    		in.close();
	    		socket.close();
	    		tb.removeUser(usr);
				ChatServer.print("Socket closed: "+socket.toString());
				trb.kill();
	    		t.stop();
			}
			catch (java.io.IOException e) 
			{
				e.printStackTrace();
			}
		}
		public void kill()
		{
			ChatServer.printd("ChatServerThreadKilled");
			trb.kill();
			t.stop();
		}
}

class ThreadRecieveBoss implements Runnable
{
	ChatServerThread Client=null;
	int index;
	ThreadBoss tb=null;
	String message=null;
	Thread t = new Thread(this);
  boolean f=true;
	public ThreadRecieveBoss(ChatServerThread c, ThreadBoss tbp)
	{
		ChatServer.printd("New ThreadRecieveBoss created");
		Client=c;
		tb=tbp;
		t.start();
	}
	public void run()
	{
		ChatServer.printd("New ThreadRecieveBoss: run");
		while(true)
		{
			try{
				Thread.sleep(10);
			} catch(Exception e) {}
			message=tb.sendRequest(index);
			if(message!=null)
			{
				Client.send(message);
				index++;
			}else
      {
        if(f==true)
        {
          Client.send("initover");
          f=false;
        }
      }
		}
	}
	public void kill()
	{
		ChatServer.printd("New ThreadRecieveBoss:kill");
		t.stop();
	}
}

class ChatServerProtocol
{
    public void ChatServerProtocol()
    {
    	ChatServer.printd("ChatServerProtocol:ChatServerProtocol constructed");
    }
    
    public String process(String input)
    {
    	ChatServer.printd("ChatServerProtocol: process");
        if(input==null)
        {
        	return "Cls";
        }
        if(input.equals("Bye."))
        {
        	return "Bye.";
        }else
        {
        	return input;
        }
    }
}

class User
{
	int id;
	String name;
	String ip;
	public User(String n, String i, int idn)
	{
		name=n;
		ip=i;
		id=idn;
		ChatServer.print("User Created: "+name+", "+ip+", "+id);
	}
	public int getid()
	{
		return id;
	}
	public String getname()
	{
		return name;
	}
}