一个简单网络服务器类的实现

网络服务器，顾名思义是一个可以接受连接的host，我们要实现的网络服务器类是一个

1.能够实现多个连接

2.仅仅通过继承或实现网络服务器类（或接口）的处理就能实现不同的连接功能

3.当服务器关闭时，已有建立的私有连接不被中断，但服务器不在接受新的连接

针对以上功能我们分解一下要实现的模块：

1.多线程实现多个连接，当serverSocket accept到一个连接请求时，开启一个独立的线程

2.关闭server后不接受连接，为关闭serverSocket的accept所阻塞的线程，关闭有两种方式，一种是中断，一种是close serverSocket。

下面不是最后的成品，但我认为尝试过程也会带给人很多启示，所以请跟我一起进行尝试吧。

我们首先想到的方式应该是这样的：

TCPServer类：

public class TCPServer extends Thread {

    ServerSocket server = null;
    volatile boolean shouldstop = false;

    public synchronized void startServer(int port) throws Exception {
        server = new ServerSocket(port);
        new TCPServer().start();
    }

    public void run() {
        while (!shouldstop) {
            try {
                Socket dataSocket = server.accept();
                TCPConnection newConnection = new TCPConnection(dataSocket);
                newConnection.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    public synchronized void stopServer(){
        if(server!=null){
            shouldstop = true;
            interrupt();
            try {
                server.close();
            } catch (Exception e) {
            }
            server = null;
        }
    }
}

TCPConnection类：

import java.net.Socket;


public class TCPConnection extends Thread{

　　　　
　　　　Socket dataSocket;

    public TCPConnection(Socket dataSocket) {
        this.dataSocket = dataScoket;
    }
    
    public void run(){
    //    dosomething();
    }
}

TCPServer类在run方法中循环等待接受请求连接，当有请求连接到来时，就为这个私有连接新建一个TCPConnection线程，并启动它。

看上去上面的实现还是可以的，每个连接都能独立运行，而且stopServer方法也做到了关闭server后并影响私有连接的通讯。但是要求二“仅通过继承或实现 TCPServer就能做到对连接功能的修改”

为了完成以上要求，显然要把TCPConnection集成到TCPServer中去。那么如何集成才能做到通过继承或实现 TCPServer 就能做到对连接的修改呢。

这里我采用的方式是让私有连接和TCPServer共享run方法，然后利用标志位来实现私有连接处理自己的事情，服务器Socket循环等待连接。

package com.choi.net.server;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author Choi
 * 
 * @version 1.0
 * 
 * */

public class TCPServer implements Cloneable, Runnable {

    Thread runner = null;
    protected ServerSocket server = null;
    Socket data = null;
    volatile boolean shouldStop = false;

    public synchronized void startServer(int port) throws IOException {
        if (runner == null) {
            server = new ServerSocket(port);
            runner = new Thread(this);
            runner.start();
        }
    }

    public synchronized void stopServer() {
        if (server != null) {
            shouldStop = true;
            runner.interrupt();
            runner = null;
            try {
                server.close();
            } catch (Exception e) {
            }
            server = null;
        }
    }

    @Override
    public void run() {
        if (server != null) {
            while (!shouldStop) {
                try {
                    Socket dataSocket = server.accept();
                    System.out.println("建立一个连接");
                    TCPServer newServer = (TCPServer) clone();
                    newServer.server = null;
                    newServer.data = dataSocket;
                    newServer.runner = new Thread(newServer);
                    newServer.runner.start();
                } catch (Exception e) {
                }
            }
        } else {
            System.out.println("新连接可用");
            run(data);
        }
    }

    public void run(Socket dataSocket) {
        System.out.println("空处理");
    }
}

通过让TCPServer实现cloneable接口的方式来建立新的连接，这样做只是为了方便；当我们为私有连接创建完新线程后把新对象的server赋值为null，这样run方法中的if(server!=null)就能把服务器Socket和私有连接Socket的处理分开了。私有连接的处理是63~65的空方法。

如果想要实现特有功能，只需要继承TCPServer并在子类中从写run(Socket dataSocket)就可以了。

完整的代码和实例，可在我的github主页下载：https://github.com/choitony/TCPServer