关于java中socket的简单应用

开头

最近想看一看关于JAVA的Socket编程方面的东西
照着网上的一些资料简单的试验了一下

JAVA的TCP(流套接字)

低配版

服务端

/**
 * Created by 张 on 2018/5/23.
 */
import java.io.*;
import java.net.*;

public class TcpServer {
    public static void main(String[] args) throws Exception {

        ServerSocket server = new ServerSocket(10086);

        try {
            System.out.println("创建之前");
            //线程会一直阻塞在这里，直到接受请求，所以最好是单开一条线程，见levelup
            Socket client = server.accept();
            System.out.println("创建之后");
            try {
                BufferedReader input =
                        new BufferedReader(new InputStreamReader(client.getInputStream()));

                boolean flag = true;
                int count = 1;

                while (flag) {
                    System.out.println("客户端要开始发骚了，这是第" + count + "次！");
                    count++;

                    String line = input.readLine();
                    //System.out.println("客户端说：" + line);

                    if (line.equals("exit")) {
                        flag = false;
                        System.out.println("客户端不想玩了！");
                    } else {
                        System.out.println("客户端说： " + line);
                    }

                }
            } finally {
                client.close();
            }

        } finally {
            server.close();
        }
    }
}

客户端

/**
 * Created by 张 on 2018/5/23.
 */
import java.io.*;
import java.net.*;
import java.util.Scanner;

public class TcpClient {
    public static void main(String[] args) throws Exception {


        Socket client = new Socket("127.0.0.1", 10086);

        try {
            PrintWriter output =
                    new PrintWriter(client.getOutputStream(), true);
            Scanner cin = new Scanner(System.in);
            String words;
            System.out.println("qian");
            while (cin.hasNext()) {
                words = cin.nextLine();
                System.out.println("hou");
                output.println(words);

                System.out.println("写出了数据: " + words);
            }

            cin.close();
        } finally {
            client.close();
        }
    }
}

进阶版(多线程版)

服务端

/**
 * Created by 张 on 2018/5/23.
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServer {
    private static int clientNum = 0;

    public static void main(String args[]) throws Exception {
        ServerSocket listener = new ServerSocket(9898, 0, InetAddress.getByName("127.0.0.1"));
        try {
            while (true) {
                Capitalizer multip = new Capitalizer(listener.accept(), TcpServer.clientNum ++);
                Thread t = new Thread(multip);
                t.start();
            }
        } finally {
            listener.close();
        }
    }

    private static class Capitalizer implements Runnable {
        private Socket client;
        private int id;

        public Capitalizer(Socket s, int id) {
            this.client = s;
            this.id = id;
        }

        public void run() {
            try {
                BufferedReader input =
                        new BufferedReader(new InputStreamReader(this.client.getInputStream()));

                while (true) {
                    String data = input.readLine();

                    if (data.equals("bye")) {
                        System.out.println("当前第" + this.id + "个客户端度不想玩了!");
                        break;
                    } else {
                        System.out.println("当前第" + this.id + "个客户端说：" + data);
                    }
                    //睡一会儿
                    Thread.sleep(3000);
                }

            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                try {
                    this.client.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

客户端

/**
 * Created by 张 on 2018/5/23.
 */
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class TcpClient {
    public static void main(String[] args) throws Exception {
        Socket client = new Socket("127.0.0.1", 9898);
        try {
            PrintWriter output = new PrintWriter(client.getOutputStream(), true);
            Scanner cin = new Scanner(System.in);
            String words;

            while (cin.hasNext()) {
                words = cin.nextLine();
		/**
		 *向服务器传数据
		 */
                output.println(words);

                if (words.equals("bye")) {
                    break;
                }

                // 每写一次数据需要sleep一会
                Thread.sleep(3000);
            }

            cin.close();
        } finally {
            client.close();
        }
    }
}

JAVA的UDP(数据报套接字)

低配版

服务端代码

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 * Created by 张 on 2018/5/23.
 */
public class UdpServer {
    public static void main(String[] args) throws IOException {
        /**
         * 创建一个udp套接字对象
         */
        DatagramSocket socket = null;
        /**
         * 负责接收客户端的信息的数据报
         */
        DatagramPacket inDataPacket;
        /**
         * 返回给客户端的数据报
         */
        DatagramPacket outDataPacket;
        /**
         * 存放客户端的地址信息
         */
        InetAddress clientAddress;

        DatagramPacket res = null;
        /**
         * 客户端的端口号
         */
        int port;
        /**
         * 存放客户端数据的缓冲区
         */
        byte[] pwd = new byte[100];
        //byte[] lineInfo;

        String str = null;
        /**
         * 创建套接字,7070是端口号
         */
        socket = new DatagramSocket(7070);

        System.out.println("服务器已启动");
        /**
         * 创建数据报
         */
        inDataPacket = new DatagramPacket(pwd,pwd.length);
        /**
         * 读取客户端输入的数据
         */
        while (true){
            /**
             * 这个会阻塞线程，最好使用runnable
             */
            socket.receive(inDataPacket);
            /**
             * 读取客户端的地址信息
             */
            clientAddress = inDataPacket.getAddress();
            port = inDataPacket.getPort();
            /**
             * 从数据报中读取信息
             */
            str = new String(inDataPacket.getData(), 0, inDataPacket.getLength());
            /**
             * 输出信息
             */
            System.out.println(str);

            String result = "success\n客户IP:" + clientAddress + "端口号：" + port;
            /**
             * 将结果置于数据报当中，并指定要发往的地址和端口号
             */
            outDataPacket = new DatagramPacket(result.getBytes(), result.getBytes().length, clientAddress, port);
            /**
             * 发送数据报
             */
            socket.send(outDataPacket);
            if(str.equals("byebye")){
                break;
            }
        }
    }
}

客户端代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 * Created by 张 on 2018/5/23.
 */
public class UdpClient {
    public static void main(String[] args) throws IOException{
        /**
         * 解析主机地址
         */
        InetAddress addr = InetAddress.getByName("127.0.0.1");
        /**
         * udp套接字对象
         */
        DatagramSocket ds = null;
        /**
         * 接受服务器返回的缓冲区
         */
        byte [] income = new byte[1024];
        /**
         * 接受服务器信息的数据报
         */
        DatagramPacket inDatagramPacket = null;
        /**
         * 发给服务器的数据报
         */
        DatagramPacket outDatagramPacket;

        ds = new DatagramSocket();
        /**
         * 从键盘读取输入流
         */
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));

        String str;
        String str1 = "";
        System.out.println("输入你要发给服务端的数据：");

        while(true) {
            /**
             * 构建接受服务器返回的数据报
             */
            inDatagramPacket = new DatagramPacket(income, 1024);
            /**
             * 从键盘读取数据
             */
            str = stdin.readLine();

            /**
             * 构建发往服务器的数据报信息
             */
            outDatagramPacket = new DatagramPacket(str.getBytes(), str.getBytes().length, addr, 7070);
            /**
             * 发送数据报
             */
            ds.send(outDatagramPacket);
            /**
             * 接受服务端返回的数据报
             */
            ds.receive(inDatagramPacket);
            /**
             * 从返回的数据报中拿到信息
             */
            str1 = new String(inDatagramPacket.getData(), 0, inDatagramPacket.getLength());
            System.out.println("服务器返回为：" + str1);

            if(str.equals("byebye")){
                break;
            }
        }
    }
}

进阶版(多线程版)

服务端代码

import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.Socket;

/**
 * Created by 张 on 2018/5/23.
 */
public class UdpServer {

    static int count=0;

    public static void main(String[] args) throws IOException{

        int port = 7070;
        DatagramSocket socket = new DatagramSocket(port);
        DatagramPacket inPacket;

        /**
         * 接收到之后就开启一个新线程
         */
        while(true) {
            /**
             * 接受数据的缓冲区
             */
            byte[] inBuffer = new byte[1024];
            inPacket = new DatagramPacket(inBuffer,inBuffer.length);
            /**
             * 阻塞，直到收到数据报
             */
            socket.receive(inPacket);
            ServerUdpThread serverUdpThread = new ServerUdpThread(inPacket,count++);
            new Thread(serverUdpThread).start();
        }

    }

    static class ServerUdpThread implements Runnable {

        DatagramSocket responseSocket;
        DatagramPacket receivePacket;
        DatagramPacket responsePacket;
        int id;
        InetAddress cientInetAddress;
        int clientPort;

        public ServerUdpThread(DatagramPacket receivePacket,int id){
            this.receivePacket = receivePacket;
            this.id = id;
        }

        @Override
        public void run() {
            try {
                /**
                 * 返回数据的socket
                 */
                responseSocket = new DatagramSocket();

                /**
                 * 接受客户端信息
                 */
                String ClientInformation = new String(receivePacket.getData(),0,receivePacket.getLength());
                //打印出客户端的信息
                System.out.println("客户端"+id+"传来"+ClientInformation );

                /**
                 * 从客户端发来的包中获取信息
                 */
                cientInetAddress = receivePacket.getAddress();
                clientPort = receivePacket.getPort();

                /**
                 * 服务器返回给客户端的消息
                 */
                String response = "客户端"+id+"号,"+"你的地址是："+cientInetAddress+"你的端口号是："+clientPort+"\n";
                /**
                 * 构造返回数据报
                 */
                responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,cientInetAddress,clientPort);
                /**
                 * 返回数据给客户端
                 */
                responseSocket.send(responsePacket);
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                responseSocket.close();
            }
        }
    }
}

上面这一段代码在本地上跑着没题，可是在服务器上会出现无法返回数据报的情况
不知道怎么回事，待研究，什么时候知道了再来补:blush:。

客户端代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 * Created by 张 on 2018/5/23.
 */
public class UdpClient {
    public static void main(String[] args) throws IOException{
        /**
         * 解析主机地址
         */
        InetAddress addr = InetAddress.getByName("127.0.0.1");
        /**
         * udp套接字对象
         */
        DatagramSocket ds = null;
        /**
         * 接受服务器返回的缓冲区
         */
        byte [] income = new byte[1024];
        /**
         * 接受服务器信息的数据报
         */
        DatagramPacket inDatagramPacket = null;
        /**
         * 发给服务器的数据报
         */
        DatagramPacket outDatagramPacket;

        ds = new DatagramSocket();
        /**
         * 从键盘读取输入流
         */
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));

        String str;
        String str1 = "";
        System.out.println("输入你要发给服务端的数据：");

        while(true) {
            /**
             * 构建接受服务器返回的数据报
             */
            inDatagramPacket = new DatagramPacket(income, 1024);
            /**
             * 从键盘读取数据
             */
            str = stdin.readLine();

            /**
             * 构建发往服务器的数据报信息
             */
            outDatagramPacket = new DatagramPacket(str.getBytes(), str.getBytes().length, addr, 7070);
            /**
             * 发送数据报
             */
            ds.send(outDatagramPacket);
            /**
             * 接受服务端返回的数据报
             */
            ds.receive(inDatagramPacket);
            /**
             * 从返回的数据报中拿到信息
             */
            str1 = new String(inDatagramPacket.getData(), 0, inDatagramPacket.getLength());
            System.out.println("服务器返回为：" + str1);

            if(str.equals("byebye")){
                break;
            }
        }
    }
}