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();

        }

    }

}

巴特西

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

最新文章

热门文章