作为一个现代人，我们对当前众多的聊天通信平台并不陌生，facebook，qq，微信等都是大部分人每天都会接触的。那你有想过构建一个自己打造的聊天室，按照自己喜欢的模式，然后和朋友一起使用吗？下面就讲下聊天室的前身——群聊服务器的实现，之后你就可以在其基础上设计独属的聊天室了。
     要实现群聊服务器，首先要先了解下面的几个问题？
   1.Socket 与ServerSocket区别！？
   2.程序中的阻塞机制是怎样的？怎样解决“阻塞”现象？
   3.群聊服务器至少需要几个类才能实现？各个类应该实现的功能？

接下来将结合代码，逐步带大家了解这些问题的答案，认识体会实现过程的思路与期间遇到的种种问题。

最先，当然就是服务器的创建。建立绑定在指定端口的服务器，然后调用服务器的接受方法，进入阻塞状态。这相当于你开了家咖啡厅，然后等待客人的光顾。不过比较遗憾的是，当前的咖啡厅只能迎接一个客人！！

ServerSocket server=new ServerSocket(port);//建立绑定在指定端口的服务器"+port);   
   while(true)
   {
   Socket client=server.accept();//调用服务器接受方法，进入阻塞状态
   System.out.println("连接上"+client.getRemoteSocketAddress());

..........}

看着这几行代码，就涉及到我们上面提到的前两个问题：

对于第一个问题，ServerSocket是对应服务器，而Socket是对应客户端；ServerSocket用于绑定端点，提供服务，并接受连接请求。Socket就是普通的连接套接字，在建立网络连接时使用的；在连接成功时，应用程序两端都会产生一个Socket实例，就相当于两头连通了一根电话线，能完成所需的会话。因此，真正进行通信的是服务器端的Socket与客户端的Socket，在ServerSocket 调用accept方法之后，它就“默默退出舞台“，由accept方法产生的Socket主权。

那么程序中的阻塞机制又是怎么回事呢？事实上，当ServerSocket调用accept方法时，会产生服务端的Socket实例，在没有用户连接上绑定的端口号时，此Socket会一直等待连接，相当于”阻塞“。当一个用户连接端口号后，服务端的Socket和用户的Socket就会连接上。若有其他用户连接端口号，会出现无法连接服务器的现象，直到之前连接的用户与服务器断开连接后才能轮到下一位，简而言之就是”一对一“；这也即”阻塞“现象。那怎么破呢？？？答案就是我们熟悉的线程！一个线程处理一个用户的Socket，这样多线程处理多用户，就能完美解决”僧多粥少“的困境。

因此我们要创建一个线程类，负责处理与用户的连接。当新的用户连接上端口号，就会创建一个线程，传入一个连接。

/*
 * 线程类，实现一个线程绑定一个处理对象
 */
public class ServerThread extends Thread{

private  Socket client;
 private OutputStream ous;
 private UserInfo user;
 
 //构造函数
 public ServerThread(Socket cs)
 {
  this.client=cs;
 }
 
 //取得线程对象所处理的用户对象
 public UserInfo getRelatedUser()
 {
  return this.user;
 }
  
  //处理连接对象的方法，传送服务器与客户端之间的字符串实现聊天功能
  private void Process(Socket client) throws IOException
  {
     
   InputStream ins=client.getInputStream();
      ous=client.getOutputStream();
   //将输入流封ins装为可以读取一行字符串,也就是以\r\n结尾的字符串
      BufferedReader bfr=new BufferedReader(new InputStreamReader(ins));
    
      //获取到用户输入的用户名与密码
      readmsg("请输入你的用户名");
      String username=bfr.readLine();
      readmsg("请输入你的密码");
      String pwd=bfr.readLine();
     
      //创建UserInfo对象，将它用所给信息实体化，以待与数据库中信息比较核实
      user=new UserInfo();
      user.setUsername(username);
      user.setCode(pwd);
     
      //调用数据库模块，验证用户信息是否存在
      boolean loginstate=DaoTool.UserLogin(user);
      if(!loginstate)
      {
       readmsg("您输入的用户不存在，请重新输入");
       this.closeUp();
       return;
      }    
     
      ChatTool.addClient(this);//调用管理处理类中的方法
     
   String s="你好，可以开始与服务器正式通话";
   this.readmsg(s);
   
   //String input=ReadString(ins);//调用读取字符串的方法，读取输入流中的字符串
   String input=bfr.readLine();//一行行读取用户输入的信息
   while(!input.equals("bye"))
   {
    System.out.println(this.user.getUsername()+"说:"+input);
    //将每条信息传到其他客户上
    ChatTool.sendMsg(this.user, input);
    //s="服务器收到："+input+"\r\n";
    //this.readmsg(s);
    //input=ReadString(ins);//接受下一次通话信息
    input=bfr.readLine();
   }
   
   ChatTool.clearClient(this);//用户下线，调用管理类的方法
   
   s="通话结束，欢迎再次连接";
   this.readmsg(s);
   
   this.closeUp();
  }
  //读取信息的方法,传入前信息不用加\r\n
  public void readmsg(String str)
  {
   str+="\r\n";
   byte[] data=str.getBytes();
   try {
    ous.write(data);
    ous.flush();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   
  }
  
  //读取字符串的方法
  private String ReadString(InputStream ins) throws IOException
  {
   StringBuffer stb=new StringBuffer();//创建字符串缓冲区
   char c=0;
   //读取字符串，当按下空格键时表示一个字符串输入完成
   while(c!=13)
   {
    
    int ch=ins.read();
    c=(char)ch;//强制转换，将c转换成字符型
    stb.append(c);//将读取的字符添加到字符串缓冲区上   
   }
   String str=stb.toString().trim();//读取字符串缓冲区中的完整字符串，去掉空格
   return str;
  }
  public void run()
  {
   //在线程中调用连接处理方法     
    try {
     Process(this.client);
    } catch (IOException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }   
   //处理方法结束后，线程就退出
   
  }
  
  //关闭线程处理对象
  public void closeUp()
  {
   try {
    client.close();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
}

其中有几个地方要解释下，归纳如下：

1、输出要调用flush函数：flush函数是把缓冲区的数据强行输出。在读写时，数据是先被读到内存当中，后再写到文件里；故当数据读完并不意味着数据写完，若此时调用close方法关闭IO流，遗留在内存缓冲区上的数据就会流失。所以要在close前先flush一下，正如买的饮料要喝完才丢掉瓶子！

2.发送字符串时，首先调用字符串的 getBytes()方法，得到组成这个字符串的字节数组，发送出的实际上是这个字节数组。读取字符串的时候，有两种方法。第一种，因为系统本身是一个字节一个字节的读取，我们

可以创建一个字符串缓冲区，每次把读的字节转换成字符形式再放进去，当读到回车再把缓冲区的数据输出来，如此便能读取字符串了。第二种，就是使用了系统提供的 BufferedReader API，包装了从 Socket
上得到的输入流对象，调用其已有的 readLine()方法读取一行字符串，如此在读取中文时不会乱码。

对于群聊服务器，其实最初应该有一个验证环节。用户输入用户名和密码，然后系统核实后才能连接上。所以还需要有三个类：用户信息类、数据访问类、连接处理类。

1）用户信息类，就是定义用户属性，如用户名、密码、登陆时间、地址等等。

2）数据访问类，即是对用户数据进行增、删、查、改，即 CRUD 操作。这样的一个类命名时，通常以 Dao 作为前缀（ Data Access Object）。这里暂时只提供确认用户存在的方法，其他方法大家可以自行添加。

/*
 * 数据对象访问类
 */
public class DaoTool {
    
 //用户信息数据库，储存所有用户信息
 private static Map<String,UserInfo> UserDP=new HashMap();
 
 //确认用户存在的方法，核对用户名是否与用户信息数据库中的匹配
 public static boolean UserLogin(UserInfo ui)
 {
  if(UserDP.containsKey(ui.getUsername()))
  {
   return true;
  }
  
  System.out.println("您输入的用户不存在，请重新输入！");
  return false;
 }
 
 //静态块，在类自动加载之前先存入10个用户信息
 static
 {
  for(int i=0;i<10;i++)
  {
   UserInfo user=new UserInfo();
   user.setUsername("user"+i);
   user.setCode("pwd"+i);
   UserDP.put(user.getUsername(), user);//存入用户信息数据库
  }
 }
 
}

这里出现了静态块，它里面的内容会在类加载之前就先执行。java中的类加载机制分为预先加载和依需求加载。java运行所需的基本类是预先加载，而我们平常用的new关键字就是进行依需求加载；如定义一个类实例时，Student stu=new Student();此时JRE才真正把Student类加载进来。

3）用户连接类，用于管理连接处理的线程对象。

//连接处理类，管理连接处理线程对象
public class ChatTool {
 
   private static List <ServerThread>stList=new ArrayList();//创建队列，存储所有的连接处理线程
   private ChatTool(){};//设置构造器私有，其他类无法生成该类对象，但可以调用其方法，适用于工具类

/*
    * 当新的用户连接上服务器时，会同时产生一个连接处理类线程对象，把这个线程添加到队列中
    */
 public static void addClient(ServerThread st) throws IOException
 {
 stList.add(st);//添加线程到队列上
 sendMsg(st.getRelatedUser(),"我上线了，大家好!!目前在线人数："+stList.size()); 
 
 }
/*
 * 当用户退出连接时，对应的线程对象也从队列中移除
 */
 public static void clearClient(ServerThread st)
 {
  stList.remove(st);//从队列中移除线程
  sendMsg(st.getRelatedUser(),st.getRelatedUser().getUsername()+"下线了，目前在线人数："+stList.size());
 }
 
 /*
  * 发送信息给每个在线的用户
  */
public static void sendMsg(UserInfo user,String msg)
{

msg=user.getUsername()+"说"+msg;
 
 for(int i=0;i<stList.size();i++)
 {
  ServerThread st=stList.get(i); //从队列中获取到所有用户
  st.readmsg(msg);//将信息输出给每个用户
 }
 
}

}

这里大家应该会注意到构造器的私有设定！当构造器私有时，它只能被包含它的类自身所访问，而无法在类的外部调用，故而可以阻止对象的生成。这种构造器私有的用法一般是针对工具类的，如字符串的验证、枚举转换之类的，可以认为是作为静态接口被外部调用。我们不需要实例它们，只是需要类名调用到它们里面的方法即可。

通过这5个类，我们就能实现简单的群聊服务器了！