互联网程序设计第五讲

第5讲 多用户服务器程序设计

完成日期：2018.10.17
GitHub：https://github.com/fyinh/network_programming_course/tree/master/ch05

---

教学与实践目的：学会服务器支持多用户并发访问的程序设计技术。

1．多用户服务器

  是指服务器能同时支持多个用户并发访问服务器所提供的服务资源,如聊天服务、文件传输等。

2．TCPServer.java

  服务器程序是单用户版本，每次只能和一个用户对话。（请仔细阅读TCPServer.java程序（上一讲），了解其中原理，找出关键语句），只有前一个用户退出后，后面的用户才能完成服务器连接。

public class TCPServer {
	private final ServerSocket serverSocket;
 	public TCPServer() throws IOException {//构造方法
    	serverSocket = new ServerSocket(8008);//开启8008号监听端口
    }
    public void service() {//主服务方法，单客户版本
    while (true) {//真循环
    	Socket socket = serverSocket.accept(); //端口监听语句 
   		InputStream socketIn = socket.getInputStream();
   		BufferedReader br=new BufferedReader(new InputStreamReader(socketIn));
       //省略pw定义 
       while ((msg = br.readLine())!= null) { //从输入流中读入一行字符串。
	       pw.println("来自服务器: "+msg);//回送客户该字符串。
       	   if (msg.equals("bye")) //消息为“bye”，就结束通信
                break;
         }        
  }
 
	public static void main(String args[])throws IOException {
		new TCPServer().service();
	}
}

演示过程：
(1) 启动你的TCPServer.java程序(程序详见第二讲的附录代码)；
(2) 启动你的TCPClientThreadJFrame.java程序，完成一次对话，并保持在线；
(3) 再启动你的TCPClientThreadJFrame.java程序2次，并完成连接，尝试对话，发现无返回信息（服务器和客户端各阻塞在哪条语句？）；
(4) 退出第一次启动的TCPClientThreadJFrame.java程序，发现第二次启动的客户端有返回信息了，说明在一个客户退出后，第二个客户才连接成功。

原因：
服务器的主进程一次只能处理一个客户，但所有已连接的客户等候在监听队列中。

3．多用户服务器程序设计

  TCPServer.java程序能同时支持多个用户并发连接（TCP三次握手），但不能同时服务多用户对话。
程序设计第一步：解决服务多用户对话问题。
  用一个线程专门负责和一个客户对话，即一个客户请求成功后，创建一个线程来专门负责该客户，主进程只负责监听客户请求和接受连接请求。
  用语句executorService.execute(new Handler(socket))替换TCPServer程序中的粗体部分语句。
  Handler(socket)的源代码见附录。

演示过程：
（1）完成TCPThreadServer.java程序（见附录1）并启动它；
（2）多次启动你的TCPClientThreadJFrame.java客户程序，并保持它们同时在线，完成每一个客户的有效对话；

4．在服务程序中支持群组聊天技术

  TCPClient和TCPThreadServer只实现了客户端和服务器聊天，如何做到客户和客户的聊天？如客户A的聊天信息通过服务器转发到客户B和客户C 等其他用户。

程序设计第二步：在TCPThreadServer.java程序中添加其它功能，如转发客户之间的对话。

  在服务器端新增记录登陆的客户信息，可用在线方式、用户文件方式或数据库方式。本讲的程序用“在线方式“记录客户套接字，即用户登陆的套接字信息，来跟踪客户连接。

  将TCPThreadServer.java程序（上一讲）重构、复制并命名为GroupServer.java：

//在GroupServer主类中定义全局变量，在线组员集合：
private static Set<Socket>  Members; 
//在GroupServer主类构造方法中实例化在线组员集合
 Members=new HashSet<Socket> (); 

注意：用客户套接字socket来标示一个在线客户，每一个客户的IP地址和端口组合是不一样。

//在GroupServer主类中定义群组消息发送方法。
public static void sendToAllMembers(String msg)throws IOException{
	PrintWriter pw;
	Socket tempSocket;
	OutputStream out;
	Iterator it=Members.iterator();
	while(it.hasNext()){//遍历在线成员set集合.
		tempSocket=(Socket) it.next(); //取出一个成员
   		out =tempSocket.getOutputStream();//得到输出流
   		//装饰成字符流
   		pw=new PrintWriter(new OutputStreamWriter(out,"GB2312"),true);
   		pw.println(msg);//发送聊天信息给成员
   	}//end while群组发送结束。
}
 
//在GroupServer主类中定义组员退出方法。
public static void removeMember(Socket socket){
	Members.remove(socket);//删除一个成员
}

//在内部类中用群组发送语句替换TCPServer中的pw.println(msg)。
	sendToAllMembers(msg);

5．通用聊天室设计[选修]

  支持一对一（可看成2个人的群组，分别建立组员和组群在线表）、群组聊天以及文件传递等方式。
  服务器所有功能的实现，都是可以模仿上述的群组服务实现形式：用服务器实现聊天信息、文件的转发

附录：
一、 服务器多线程技术

public class TCPThreadServer {
    
    private int port = 8008;
    private ServerSocket serverSocket = null;
    private ExecutorService executorService = null; //线程池
    private final int POOL_SIZE = 15; //单个CPU时线程池中工作线程的数目
    
    public TCPThreadServer() throws IOException{
        serverSocket = new ServerSocket(port); //打开服务器端口
        
        //创建线程池
        //Runtime的availableProcessors()方法返回当前系统的CPU的数目
        //系统的CPU越多，线程池中工作线程的数目也应该越多
        executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);
        System.out.println("多用户服务器启动");
    }
    
    public void service(){
        while(true){
            Socket socket = null;
            try{
                socket = serverSocket.accept(); //监听客户请求, 阻塞语句.
                //接受一个客户请求,从线程池中拿出一个线程专门处理该客户.
                executorService.execute(new Handler(socket));
            }catch (IOException ex){
                ex.printStackTrace();
            }
        }
    }
    
    public static void main(String atgs[]) throws IOException{
        new TCPThreadServer().service();
    }


    //定义内部类，实现线程接口
    class Handler implements Runnable{
        private Socket socket;

        public Handler(Socket socket){
            this.socket = socket;
        }

        private PrintWriter getWriter(Socket socket) throws IOException{
            OutputStream socketOut = socket.getOutputStream();
            return new PrintWriter(new OutputStreamWriter(socketOut,"GB2312"),true);
        }

        private BufferedReader getReader(Socket socket)throws IOException{
            InputStream socketIn = socket.getInputStream();
            return new BufferedReader(new InputStreamReader(socketIn,"GB2312"));
        }

        @Override
        public void run() {
            try{
                System.out.println("New connection accepted " +socket.getInetAddress());
                BufferedReader br =getReader(socket);//字节装饰成字符流
                PrintWriter pw = getWriter(socket); //字节装饰成字符流
                String msg = null;
                while ((msg = br.readLine()) != null) {
                    pw.println("From ThreadServer: " + msg);
                    if (msg.contains("bye".subSequence(0, 2))){
                        System.out.println( socket.getInetAddress() + ":" +"Exit");
                        break;
                    }
                }
            }catch (IOException ex){
                ex.printStackTrace();
            }finally {
                try{
                    if(socket!=null)socket.close();
                }catch(IOException ex){
                    ex.printStackTrace();
                }
            }
        }
    
    }
}