一、TCP编程

1、实现客户端向服务端发送一条消息

server.java:

public class Server {
    public static void main(String[] args) throws IOException {
        //开放本地端口，等待客户端的连接
        ServerSocket serverSocket = new ServerSocket(8888);
        //需要接受客户端传输过来的数据，所以需要Socket对象
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        DataInputStream dataInputStream = new DataInputStream(inputStream);
        String s = dataInputStream.readUTF();
        System.out.println(s);

        //关闭流
        dataInputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

client.java:

public class Client {
    public static void main(String[] args) throws IOException {
        //开启实现IO（数据传输）的虚拟接口，并且执行目标端的ip地址和端口号
        Socket socket = new Socket("localhost",8888);
        //获取输出流对象，向服务端发送数据
        OutputStream outputStream = socket.getOutputStream();
        //封装输出流对象，方便操作
        DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
        dataOutputStream.writeUTF("hello world");
        //关闭资源
        dataOutputStream.close();
        outputStream.close();
        socket.close();

    }
}

2、实现客户端与服务端的相互通信（一次）

server.java:

public class Server {
    public static void main(String[] args) throws IOException {
        //开放本地端口，等待客户端的连接
        ServerSocket serverSocket = new ServerSocket(8888);
        //需要接受客户端传输过来的数据，所以需要Socket对象
        Socket socket = serverSocket.accept();

        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int length = inputStream.read(buf);
        System.out.println("客户端发送过来的消息："+new String(buf,0,length));

        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("我已经收到消息了".getBytes());

        //关闭流
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

client.java:

public class Client {
    public static void main(String[] args) throws IOException {
        //开启实现IO（数据传输）的虚拟接口，并且执行目标端的ip地址和端口号
        Socket socket = new Socket("localhost",8888);

        //获取输出流对象，向服务端发送数据
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello java".getBytes());

        //获取输入流对象
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int length = inputStream.read(buf);//将输入的数据读到byte数组中，并得到数据的长度
        System.out.println("服务端返回的数据是："+new String(buf,0,length));

        //关闭资源
        inputStream.close();
        outputStream.close();
        socket.close();
    }
}

3、实现图片的上传（客户端->服务端）

PicServer.java

public class PicServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8000);
        Socket server = serverSocket.accept();
        InputStream inputStream = server.getInputStream();
        //因为数据量大，所以需要一个字节一个字节的写入，同时还需要存放到指定位置
        FileOutputStream fileOutputStream = new FileOutputStream("princess1.jpg");
        int temp = 0;
        while((temp = inputStream.read()) != -1){
            fileOutputStream.write(temp);
        }
        server.shutdownInput();

        ///向客户端返回接收成功的消息
        OutputStream outputStream = server.getOutputStream();
        outputStream.write("服务端接收成功".getBytes());
        server.shutdownOutput();

        //关闭资源
        outputStream.close();
        fileOutputStream.close();
        inputStream.close();
        server.close();
        serverSocket.close();
    }
}

PicClient.java

public class PicClient {
    public static void main(String[] args) throws IOException {
        //得到图片的输入流
        FileInputStream fileInputStream = new FileInputStream("src/yan.jpg");
        Socket client = new Socket("localhost",8000);
        OutputStream outputStream = client.getOutputStream();

        //一个字节一个字节的写出数据
        int temp = 0;
        while((temp = fileInputStream.read()) != -1){
            outputStream.write(temp);
        }

        //添加输出完成的标志
        client.shutdownOutput();

        //接收服务端的响应
        InputStream inputStream = client.getInputStream();
        byte[] bytes = new byte[1024];//1024个字节
        int length = inputStream.read(bytes);
        System.out.println(new String(bytes,0,length));

        //添加输入完成的标志
        client.shutdownInput();

        //关闭资源
        inputStream.close();
        outputStream.close();
        fileInputStream.close();
        client.close();
    }
}

4、登录功能（利用循环保持通信）

LoginServer.java：

public class LoginServer {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ServerSocket serverSocket = new ServerSocket(8888);
        while (true){
            Socket server = serverSocket.accept();
            ObjectInputStream objectInputStream = new ObjectInputStream(server.getInputStream());
            User clientUser = (User) objectInputStream.readObject();
            User serverUser = new User("wj","123");
            //进行判断
            String str = "";
            if(serverUser.equals(clientUser)){
                str = "登陆成功";
            }else {
                str = "登陆失败";
            }
            //表示输入完毕
            server.shutdownInput();

            DataOutputStream dataOutputStream = new DataOutputStream(server.getOutputStream());
            dataOutputStream.writeUTF(str);
            //标识输出完毕
            server.shutdownOutput();

            //关闭资源
            dataOutputStream.close();
            objectInputStream.close();
            server.close();
//            serverSocket.close();//一定不能关，因为serverSocket不在循环内
        }
    }
}

LoginClient.java：

public class LoginClient {
    public static void main(String[] args) throws IOException {
        while (true){
            Socket client = new Socket("localhost",8888);
            OutputStream outputStream = client.getOutputStream();
            //因为需要传输对象，所以要用ObjectOutputStream流
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
            User user = getUser();
            objectOutputStream.writeObject(user);
            //标志输出操作完毕
            client.shutdownOutput();

            DataInputStream dataInputStream = new DataInputStream(client.getInputStream());
            String s = dataInputStream.readUTF();
            System.out.println(s);
            //标志输入操作完毕
            client.shutdownInput();

            //关闭资源
            dataInputStream.close();//当关闭此流时，会将socket资源释放
            objectOutputStream.close();
            outputStream.close();
            client.close();
        }

    }

    public static User getUser(){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入账号：");
        String username = scanner.nextLine();
        System.out.println("请输入密码：");
        String password = scanner.nextLine();
        return new User(username,password);
    }
}

ps:客户端处只是为了演示可以一直通讯的效果，不涉及登录成功进行下一步操作的逻辑。

5、登录功能（利用多线程保持通信）

LoginThread.java：

public class LoginThread implements Runnable{
    private Socket socket;
    public LoginThread(){

    }

    public LoginThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        ObjectInputStream objectInputStream = null;
        DataOutputStream dataOutputStream = null;
        try {
            objectInputStream = new ObjectInputStream(socket.getInputStream());
            User clientUser = (User)objectInputStream.readObject();
            User serverUser = new User("wj","123");
            //进行判断
            String str = "";
            if(serverUser.equals(clientUser)){
                str = "登陆成功";
            }else {
                str = "登陆失败";
            }
            //表示输入完毕
            socket.shutdownInput();

            dataOutputStream = new DataOutputStream(socket.getOutputStream());
            dataOutputStream.writeUTF(str);
            //标识输出完毕
            socket.shutdownOutput();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally {
            try {
                dataOutputStream.close();
                objectInputStream.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    public Socket getSocket() {
        return socket;
    }

    public void setSocket(Socket socket) {
        this.socket = socket;
    }
}

LoginServer.java：

public class LoginServer {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ServerSocket serverSocket = new ServerSocket(8888);
        while (true){
            Socket server = serverSocket.accept();
            LoginThread loginServer = new LoginThread(server);
            new Thread(loginServer).start();
        }
    }
}

二、UDP编程

UDPServer.java：

public class UDPServer {
    public static void main(String[] args) throws IOException {
        DatagramSocket server = new DatagramSocket(8001);
        byte[] buf = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(buf,buf.length);
        //利用创建好的数据报对象来接收数据
        server.receive(datagramPacket);
        //buf中装着从客户端传来的数据内容
        System.out.println(new String(buf));
        System.out.println(new String(datagramPacket.getData(),datagramPacket.getData().length));
        server.close();
    }
}

UDPClient.java：

public class UDPClient {
    public static void main(String[] args) throws IOException {
        DatagramSocket client = new DatagramSocket(8000);
        System.out.println("请输入你想发送的内容");
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        //创建要发送的数据报对象
        DatagramPacket datagramPacket =
                new DatagramPacket(str.getBytes(),str.getBytes().length, InetAddress.getByName("localhost"),8001);
        //发送数据报
        client.send(datagramPacket);

        //关闭资源
        client.close();
    }
}