Java——Socket

使用基于TCP协议的 Socket 编程模拟实现用户登陆功能

》》服务器端

public class Server {

    public static void main(String[] args) {
        try {
            //创建一个服务器端Socket,即ServerSocket,指定绑定端口，并监听此端口
            ServerSocket serverSocket = new ServerSocket(8800);
            System.out.println("*****服务器即将启动，等待客户端的连接*****");
            //调用accept()方法开始监听，等待客户端的连接
            Socket socket = serverSocket.accept();
            //获取输入流，并读取客户端信息
            InputStream is = socket.getInputStream();   //字节输入流
            InputStreamReader isr = new InputStreamReader(is);   //将字节流转换为字符流
            BufferedReader br = new BufferedReader(isr);  //为输入流添加缓存
            String info = null;
            while((info = br.readLine()) != null){
                System.out.println("我是服务器，客户端说：" + info);
            }
            socket.shutdownInput();  //关闭输入流
            
            
            //响应客户端的请求
            //获取字节输出流，并向客户端发送信息
            OutputStream os = socket.getOutputStream();  
            PrintWriter pw = new PrintWriter(os);  //将字节输出流包装成打印流
            pw.write("登陆成功，欢迎您！");
            pw.flush();  //刷新缓存
            socket.shutdownOutput();
            
            serverSocket.close();  //关闭资源
    
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

》》客户端

public class Client {

    public static void main(String[] args) {
        try {
            //创建客户端Socket,指定服务器地址的端口
            Socket socket =new Socket("localhost",8800);
            //获取输出流，向服务器端发送信息
            OutputStream os = socket.getOutputStream();  //字节输出流
            PrintWriter pw = new PrintWriter(os);  //将字节输出流包装为打印流
            pw.write("用户名：admin;密码：123");
            pw.flush();
            socket.shutdownOutput(); //关闭输出流
            System.out.println("****客户端已发出请求,等待服务器端的反馈*****");
            
            //接受服务器端的反馈
            //获取输入流，并读取服务端的反馈
            InputStream is = socket.getInputStream();   //字节流
            InputStreamReader isr = new  InputStreamReader(is); //将字节流转换为字符输入流
            BufferedReader br = new BufferedReader(isr);   //为输入流添加缓存流
            String info = null;
            while ( (info = br.readLine()) != null ) {
                System.out.println("我是客户端，服务器端说：" + info);
            }
            socket.shutdownInput();  //关闭输入流
            
            socket.close();  //关闭资源
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) { 
            e.printStackTrace();
        }
    }
}

注意：启动的时候一定要先启动服务端。

 使用多线程实现多客户端登陆 

》》服务器端

public class ServerThread extends Thread {

    //和本线程相关的 Socket
    Socket socket = null;
    
    public ServerThread(Socket socket){
        this.socket = socket;
    }
    
    //线程执行操作，响应客户端的请求
    @Override
    public void run() {
        try {
            //获取输入流，并读取客户端的信息
            InputStream is = socket.getInputStream();   //字节流
            InputStreamReader isr = new InputStreamReader(is);  //将字节输入流转换为字符输入流
            BufferedReader br = new BufferedReader(isr);   //为字符流添加缓存
            String info = null;
            while((info = br.readLine()) != null){     //循环读取客户的信息
                System.out.println("我是服务器，客户端说：" + info);
            }
            socket.shutdownInput();  //关闭输入流
            
            //获取字节输出流，并向客户端发送信息
            OutputStream os = socket.getOutputStream();
            PrintWriter pw = new PrintWriter(os);
            pw.write("登陆成功，欢迎您！");
            pw.flush();
            socket.shutdownOutput(); //关闭输出流
            
            socket.close(); //关闭资源流
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        try {
            //创建一个服务器端 Socket，即ServerSocket,指定绑定的端口，并监听此端口
            ServerSocket serverSocket = new ServerSocket(8800);
            Socket socket = null;
            System.out.println("*****客户端已启动，等待客户端的连接*****");
            //循环监听等待客户端的连接
            while(true){
                //调用 accept()方法开始监听，等待客户端的连接
                socket = serverSocket.accept();
                //创建一个新的线程
                ServerThread serverThread = new ServerThread(socket);
                serverThread.start();  //
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

》》客户端

public class Client {

    public static void main(String[] args) {
        try {
            //创建客户端Socket,指定服务器地址的端口
            Socket socket =new Socket("localhost",8800);
            //获取输出流，向服务器端发送信息
            OutputStream os = socket.getOutputStream();  //字节输出流
            PrintWriter pw = new PrintWriter(os);  //将字节输出流包装为打印流
            //pw.write("用户名：admin;密码：123");
            pw.write("用户名：szj;密码：123");
            pw.flush();
            socket.shutdownOutput(); //关闭输出流
            System.out.println("****客户端已发出请求,等待服务器端的反馈*****");
            
            //接受服务器端的反馈
            //获取输入流，并读取服务端的反馈  
            InputStream is = socket.getInputStream();   //字节流
            InputStreamReader isr = new  InputStreamReader(is); //将字节流转换为字符输入流
            BufferedReader br = new BufferedReader(isr);   //为输入流添加缓存流
            String info = null;
            while ( (info = br.readLine()) != null ) {
                System.out.println("我是客户端，服务器端说：" + info);
            }
            socket.shutdownInput();  //关闭输入流
                             
            socket.close();  //关闭资源
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) { 
            e.printStackTrace();
        }
    }
}

 基于 UDP 的 Socket

》》服务端

public class UDPServer {

    public static void main(String[] args) throws IOException {
        //创建服务器端DatagramSocket,指定端口
        DatagramSocket socket = new DatagramSocket(8800);
        //创建数据报，用于接收客户端的数据
        byte[] data = new byte[1024]; //创建字节数组,指定接收的数据报大小
        DatagramPacket packet = new DatagramPacket(data, data.length);
        System.out.println("*****服务器已经启动，等待客户端发送数据*****");
        //接收客户端发送的数据
        socket.receive(packet);  //此方法在接收到数据报之前会一直阻塞
        //读取数据
        String info = new String(data,0,packet.getLength());
        System.out.println("我是服务器，客户端说：" + info);
        
        /**
         * 向客户端响应数据
         */
        //定义客户端的地址、端口号、数据
        InetAddress address = packet.getAddress();
        int port = packet.getPort();
        byte[]  data1 = "欢迎您！".getBytes();
        //创建数据报，包含响应的数据信息
        DatagramPacket packet1 =new DatagramPacket(data1, data1.length, address, port);
        //响应客户端
        socket.send(packet1);
        socket.close();  //关闭资源
    }
}

 

》》客户端

public class UDPClient {

    public static void main(String[] args) throws IOException {
        InetAddress address = InetAddress.getByName("localhost");    
        int port = 8800;
        byte[] data = "用户名：admin;密码：123".getBytes(); 
        //创建数据报，包含发送的数据信息
        DatagramPacket packet = new DatagramPacket(data,data.length,address,port);
        //创建DatagramSocket对象
        DatagramSocket socket =new DatagramSocket();
        //向服务器发送数据报
        socket.send(packet);
        System.out.println("*****我是客户端，等待服务器的响应*****");
        /**
         * 接收服务器端的响应数据
         */
        //创建数据报，用于接收服务器响应的数据
        byte[] data2 =new byte[1024];
        DatagramPacket packet1 = new DatagramPacket(data2, data2.length);
        //接收服务器响应的数据     
        socket.receive(packet1);
        
        //读取数据
        String info = new String(data2,0,packet1.getLength());
        System.out.println("我是客户端，服务器说：" + info);
        
        socket.close();  //关闭资源
    }
}