Java版SockeDemo案例，有很详细的注释

一般是用一个线程池来处理接受到的请求

直接上代码(一)

ServerThread层

 import java.io.BufferedReader;
 import java.io.InputStreamReader;
 import java.io.PrintWriter;
 import java.net.Socket;

 public class ServerThread extends Thread {
     private static int number = 0; // 保存本进程的客户计数

     Socket socket = null; // 保存与本线程相关的Socket对象

     public ServerThread(Socket socket, int clientnum) {

         this.socket = socket;
         number = clientnum;
         System.out.println("当前在线的用户数: " + number);
     }

     @Override
     public void run() {
         try {

             // 由Socket对象得到输入流,并构造相应的BufferedReader对象
             BufferedReader in = new BufferedReader(new InputStreamReader(socket
                     .getInputStream()));

             // 由Socket对象得到输出流,并构造PrintWriter对象
             PrintWriter out = new PrintWriter(socket.getOutputStream());

             // 由系统标准输入设备构造BufferedReader对象
             BufferedReader sysin = new BufferedReader(new InputStreamReader(
                     System.in));

             // 在标准输出上打印从客户端读入的字符串
             System.out.println("[Client " + number + "]: " + in.readLine());

             String line; // 保存一行内容

             // 从标准输入读入一字符串
             line = sysin.readLine();

             while (!line.equals("bye")) { // 如果该字符串为 "bye",则停止循环

                 // 向客户端输出该字符串
                 out.println(line);

                 // 刷新输出流,使Client马上收到该字符串
                 out.flush();

                 // 在系统标准输出上打印读入的字符串
                 System.out.println("[Server]: " + line);

                 // 从Client读入一字符串,并打印到标准输出上
                 System.out.println("[Client " + number + "]: " + in.readLine());

                 // 从系统标准输入读入一字符串
                 line = sysin.readLine();
             }

             out.close(); // 关闭Socket输出流
             in.close(); // 关闭Socket输入流
             socket.close(); // 关闭Socket
         } catch (Exception e) {
             System.out.println("Error. " + e);
         }
     }
 }

SocketClient层

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * 客户端Socket
 *
 * @author Administrator
 *
 */
public class SocketClient {

    /**
     * 客户端Socket构造方法
     */
    public SocketClient() {
        try {

            // 向本机的2121端口发出客户请求
            Socket socket = new Socket("localhost", 2121);

            System.out.println("Established a connection...");

            // 由系统标准输入设备构造BufferedReader对象
            BufferedReader sysin = new BufferedReader(new InputStreamReader(
                    System.in));

            // 由Socket对象得到输出流,并构造PrintWriter对象
            PrintWriter out = new PrintWriter(socket.getOutputStream());

            // 由Socket对象得到输入流,并构造相应的BufferedReader对象
            BufferedReader in = new BufferedReader(new InputStreamReader(socket
                    .getInputStream()));

            String line; // 保存一行内容

            // 从系统标准输入读入一字符串
            line = sysin.readLine();

            while (!line.equals("bye")) { // 若从标准输入读入的字符串为 "bye"则停止循环

                // 将从系统标准输入读入的字符串输出到Server
                out.println(line);

                // 刷新输出流,使Server马上收到该字符串
                out.flush();

                // 在系统标准输出上打印读入的字符串
                System.out.println("[Client]: " + line);

                // 从Server读入一字符串，并打印到标准输出上
                System.out.println("[Server]: " + in.readLine());

                // 从系统标准输入读入一字符串
                line = sysin.readLine();

            }

            out.close(); // 关闭Socket输出流
            in.close(); // 关闭Socket输入流
            socket.close(); // 关闭Socket
        } catch (Exception e) {
            System.out.println("Error. " + e);
        }
    }

    /**
     * 主方法
     *
     * @param args
     */
    public static void main(String[] args) {
        new SocketClient();
    }
}

SocketServer层

import java.net.ServerSocket;

/**
 * 服务器端Socket
 *
 * @author Administrator
 *
 */
public class SocketServer {
    /**
     * 服务器端Socket构造方法
     */

    public SocketServer() {
        try {

            int clientcount = 0; // 统计客户端总数

            boolean listening = true; // 是否对客户端进行监听

            ServerSocket server = null; // 服务器端Socket对象

            try {
                // 创建一个ServerSocket在端口2121监听客户请求
                server = new ServerSocket(2121);

                System.out.println("Server starts开始启动...");
            } catch (Exception e) {
                System.out.println("Can not listen to. " + e);
            }

            while (listening) {
                // 客户端计数
                clientcount++;

                // 监听到客户请求,根据得到的Socket对象和客户计数创建服务线程,并启动之
                new ServerThread(server.accept(), clientcount).start();
            }
        } catch (Exception e) {
            System.out.println("Error. " + e);
        }
    }
    /**
     * 主方法
     *
     * @param args
     */
    public static void main(String[] args) {
        new SocketServer();
    }
}

下面是Demo案例

Server端

package cn.kgc.sockettest.demo1;

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

/**
 * 服务端
 */
public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("服务器启动完成...监听中");
            //开启监听，等待客户端的访问
            Socket socket = serverSocket.accept();
            //获取输入流，因为是客户端向服务端发送了数据
            InputStream inputStream = socket.getInputStream();
            //创建一个缓冲流
            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
            String info = null;
            while ((info = br.readLine()) != null) {
                System.out.println("这里是服务端 客户端是：" + info);
            }
            //向客户端做出相应
            OutputStream outputStream = socket.getOutputStream();
            info = "这里是服务端我们接受到了你消息";
            outputStream.write(info.getBytes());
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Client端

package cn.kgc.sockettest.demo1;

import java.io.*;
import java.net.Socket;

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        try {
            //IP地址
            Socket socket = new Socket("localhost",8080);
            OutputStream outputStream = socket.getOutputStream();
            String info ="你好";
            //输出！
            outputStream.write(info.getBytes());
            socket.shutdownOutput();
            //接受服务器的响应
            InputStream inputStream = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
            while((info =br.readLine())!=null){
                System.out.println("接收到了服务器的响应:"+info);
            }
            outputStream.flush();
            outputStream.close();
            inputStream.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

（二）

User层

package cn.kgc.sockettest.demo1.demo2;

import java.io.Serializable;

public class User implements Serializable {
    private String userName;
    private String password;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    @Override
    public String toString() {
        return "Server{" +
                "userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

Server端

package cn.kgc.sockettest.demo1.demo2;

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

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("服务器启动完成。。。。。");
            //开始监听
            Socket socket = serverSocket.accept();
            InputStream inputStream = socket.getInputStream();
            ObjectInputStream stream = new ObjectInputStream(inputStream);
            User user =(User)stream.readObject();
            System.out.println("客户端发过来的数据是:"+user);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Client层

package cn.kgc.sockettest.demo1.demo2;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * 客户端
 */

public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost",8080);
            OutputStream outputStream = socket.getOutputStream();
            User user = new User();
            user.setUserName("张三");
            user.setPassword("admin");
            //创建对象输出流
            ObjectOutputStream oos = new ObjectOutputStream(outputStream);
            //序列化对象
            oos.writeObject(user);
            //关闭流
            oos.close();
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}