Java Socket服务器与客户端实例

    本实例采用生产者/消费者模式进行设计，源码中包含了详细的注释。为了方便测试将服务器放在一个Servlet里面启动，浏览器访问该Servlet时启动服务器监听

1. 服务器源码

package test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
//此处使用Servlet方式进行编写，方便进行测试，在应用启动的时候就打开一个线程去监听客户端请求
public class ServerServlet implements Servlet {
    public void init(ServletConfig arg0) throws ServletException {
        Handler handler = new Handler();
        Thread thread = new Thread(handler);
        thread.start();
    }
    //客户端连接线程池
    private ExecutorService executor = Executors.newFixedThreadPool(20);
    //客户端请求处理线程池，此处要注意客户请求是否有先后顺序、共享资源
    private ExecutorService bizExecutor = Executors.newFixedThreadPool(1);
    //创建一个阻塞队列保存客户的请求信息
    public LinkedBlockingQueue<ClientInfo> queue = new LinkedBlockingQueue<ClientInfo>();
    //保存客户请求信息实体
    class ClientInfo{
        private String xml;
        private String ip;
        public ClientInfo(String xml, String ip){
            super();
            this.xml = xml;
            this.ip = ip;
        }
        public String getXml() {
            return xml;
        }
        public void setXml(String xml) {
            this.xml = xml;
        }
        public String getIp() {
            return ip;
        }
        public void setIp(String ip) {
            this.ip = ip;
        }
    }
    //服务器线程，监听客户端请求
    class Handler implements Runnable{
        public void run(){
            //开启一个业务处理线程，处理客户端的请求
            bizExecutor.submit(new BizHandler());
            ServerSocket server = null;
            try{
                server = new ServerSocket(11480);
            } catch(Exception e){
                e.printStackTrace();
            }
            if(server != null){
                System.out.println("服务器端口已打开");
                while(true){
                    try{
                        Socket socket = server.accept();
                        //开启一个与客户端连接的线程
                        ProgressThread proThread = new ProgressThread(socket);
                        executor.submit(proThread);
                    } catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    //客户端连接线程
    class ProgressThread implements Runnable{
        private Socket socket;
        public ProgressThread(Socket socket){
            super();
            this.socket = socket;
        }
        public void run(){
            try{
                StringBuilder sb = new StringBuilder();
                InputStream is = socket.getInputStream();
                BufferedReader in = new BufferedReader(new InputStreamReader(is,"utf-8"));
                String line = null;
                //以行为单位读取数据，长连接时若无换行符将不能读出数据，只能在socket关闭时一次性得到数据
                while((line = in.readLine()) != null){
                    if(line.trim().endsWith("/xml>")){
                        sb.append(line);
                        if(sb != null && !"".equals(sb.toString().trim())){
                            queue.put(new ClientInfo(sb.toString(),this.socket.getLocalAddress().toString()));
                        }
                        sb = new StringBuilder();
                    } else {
                        sb.append(line);
                    }
                }
//                //没有换行符的读取方式,需捕获connect reset异常
//                while (true){
//                    try{
//                        char[] ch = new char[1024];
//                        int n = in.read(ch);
//                        System.out.println(new String(ch, 0, n));
//                    } catch(Exception e){
//                        System.out.println("客户端连接已关闭");
//                        break;
//                    }
//                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
    //客户请求信息处理线程
    class BizHandler implements Runnable{
        public void run(){
            while(true){
                try{
                    //取出阻塞队列中的信息处理
                    final ClientInfo info = queue.poll();
                    if(info == null){
                        Thread.sleep(5000);
                    } else {
                        writeData(info.getXml(),info.getIp());
                    }
                } catch(Exception e){
                    e.printStackTrace();
                }
            }
        }
        public void writeData(String str1, String str2){
            System.out.println(str1);
            System.out.println(str2);
        }
    }
    public void destroy() {
    }
    public ServletConfig getServletConfig() {
        return null;
    }
    public String getServletInfo() {
        return null;
    }
    public void service(ServletRequest arg0, ServletResponse arg1)
            throws ServletException, IOException {
    }
}
2. 测试客户端

package test;
import java.io.OutputStream;
import java.net.Socket;
public class ClientTest {
    public static void main(String[] args) {
        Socket socket;
        try {
            socket = new Socket("localhost", 11480);
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write("<xml>Hello</xml>\r\n".getBytes("utf-8"));
            outputStream.flush();
            System.out.println(socket);
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}