基于TCP的Java网络套接字编程

基于TCP的Java网络编程

功能分解1—单向通信

• 功能：客户端发送一句话到服务器

实现

• 客户端

package com.ruan.test02;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

public class TestClient {
    public static void main(String[] args) throws IOException {
        System.out.println("请输入信息");
        Scanner scanner = new Scanner(System.in);
        String next = scanner.nextLine();
        //1.创建套接字：指定服务器的ip和端口
        Socket socket = new Socket("192.168.15.1", 8888);
        //2.对于程序员来说，向外发送数据直接使用输出流
        OutputStream outputStream = socket.getOutputStream();
        DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
        dataOutputStream.writeUTF(next);
        //3.关闭流关闭网络资源
        dataOutputStream.close();
        outputStream.close();
        socket.close();
    }
}

• 服务端

package com.ruan.test02;

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

public class TestService {
    public static void main(String[] args) throws IOException {
        //1.创建套接字，指定服务端口
        ServerSocket serverSocket = new ServerSocket(8888);
        //2.等待客户端发送信息
        Socket accept = serverSocket.accept();//阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。返回值为socket
        //3.对于程序员来说最直观的感受是输入流
        InputStream inputStream = accept.getInputStream();
        DataInputStream dataInputStream = new DataInputStream(inputStream);
        //4.读取客户端发来的信息
        String str = dataInputStream.readUTF();
        System.out.println("客户端发来的消息是"+str);
        //5.关闭流
        inputStream.close();
        dataInputStream.close();
        accept.close();
        serverSocket.close();
    }
}

功能分解2—双向通信

• 功能：客户端发送信息后服务器返回数据

实现

• 客户端

package com.ruan.test02;

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

public class TestClient {
    public static void main(String[] args) throws IOException {
        System.out.println("请输入信息");
        Scanner scanner = new Scanner(System.in);
        String next = scanner.nextLine();
        //1.创建套接字：指定服务器的ip和端口
        Socket socket = new Socket("192.168.15.1", 8888);
        //2.对于程序员来说，向外发送数据直接使用输出流
        OutputStream outputStream = socket.getOutputStream();
        DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
        dataOutputStream.writeUTF(next);
        //同样，从客户端接收消息同样使用输入流
        InputStream inputStream = socket.getInputStream();
        DataInputStream dataInputStream = new DataInputStream(inputStream);
        String str = dataInputStream.readUTF();
        System.out.println("客户端返回的消息--"+str);
        //3.关闭流关闭网络资源
        inputStream.close();
        dataInputStream.close();
        dataOutputStream.close();
        outputStream.close();
        socket.close();
    }
}

• 服务器

package com.ruan.test02;

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

public class TestService {
    public static void main(String[] args) throws IOException {
        //1.创建套接字，指定服务端口
        ServerSocket serverSocket = new ServerSocket(8888);
        //2.等待客户端发送信息
        Socket accept = serverSocket.accept();//阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。返回值为socket
        //3.对于程序员来说最直观的感受是输入流
        InputStream inputStream = accept.getInputStream();
        DataInputStream dataInputStream = new DataInputStream(inputStream);
        //4.读取客户端发来的信息
        String str = dataInputStream.readUTF();
        System.out.println("客户端发来的消息---"+str);
        //向客户端返回信息，同样通过输出流进行操作
        OutputStream outputStream = accept.getOutputStream();
        DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
        dataOutputStream.writeUTF("你好，我是服务端，我接收到你的请求了！");
        //5.关闭流
        outputStream.close();
        dataOutputStream.close();
        inputStream.close();
        dataInputStream.close();
        accept.close();
        serverSocket.close();
    }
}

功能分解3—对象传输

• 功能：完成用户登录操作

实现

• 封装User类

package com.ruan.test03;

import java.io.Serializable;

public class User implements Serializable {
    private static final long serialVersionUID = 1l;
    private String userName;
    private String pwd;

    public String getUsername() {
        return userName;
    }

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

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public User(String userName, String pwd) {
        this.userName = userName;
        this.pwd = pwd;
    }
}

• 客户端

package com.ruan.test03;

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

public class Client {
    public static void main(String[] args) throws IOException {
        //创建套接字
        Socket socket = new Socket("192.168.15.1", 8888);
        //等待用户输入账号密码
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入用户名");
        String userName = scanner.next();
        System.out.println("请输入密码");
        String pwd = scanner.next();
        //组装用户对象
        User user = new User(userName, pwd);
        //使用对象流进行包装
        OutputStream outputStream = socket.getOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(user);
        //接收客户端返回的信息
        InputStream inputStream = socket.getInputStream();
        DataInputStream dataInputStream = new DataInputStream(inputStream);
        boolean flag = dataInputStream.readBoolean();
        if (flag){
            System.out.println("登录成功");
        }else {
            System.out.println("登录失败");
        }
        //关闭流
        outputStream.close();
        objectOutputStream.close();
        inputStream.close();
        dataInputStream.close();
        socket.close();
    }
}

• 服务端

package com.ruan.test03;

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

public class Service {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建套接字
        ServerSocket serverSocket = new ServerSocket(8888);
        //等待接收数据
        Socket accept = serverSocket.accept();
        //获取客户端发送的信息
        InputStream inputStream = accept.getInputStream();
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
        User user = (User) objectInputStream.readObject();
        //进行数据校验
        boolean flag = false;
        if (user.getUsername().equals("小天才") && user.getPwd().equals("123456")){
            flag = true;
        }
        //向客户端返回信息
        OutputStream outputStream = accept.getOutputStream();
        DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
        dataOutputStream.writeBoolean(flag);
        //关闭流
        inputStream.close();
        objectInputStream.close();
        outputStream.close();
        dataOutputStream.close();
        accept.close();
        serverSocket.close();

    }
}

功能分解4—加入完整的异常处理

实现

• 客户端

package com.ruan.test03;

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

public class Client {
    public static void main(String[] args) {
        //创建套接字
        Socket socket = null;
        OutputStream outputStream = null;
        ObjectOutputStream objectOutputStream = null;
        InputStream inputStream = null;
        DataInputStream dataInputStream = null;
        try {
            socket = new Socket("192.168.15.1", 8888);
            //等待用户输入账号密码
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入用户名");
            String userName = scanner.next();
            System.out.println("请输入密码");
            String pwd = scanner.next();
            //组装用户对象
            User user = new User(userName, pwd);
            //使用对象流进行包装
            outputStream = socket.getOutputStream();
            objectOutputStream = new ObjectOutputStream(outputStream);
            objectOutputStream.writeObject(user);
            //接收客户端返回的信息
            inputStream = socket.getInputStream();
            dataInputStream = new DataInputStream(inputStream);
            boolean flag = dataInputStream.readBoolean();
            if (flag){
                System.out.println("登录成功");
            }else {
                System.out.println("登录失败");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            try {
                if (outputStream != null){
                    outputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (objectOutputStream != null) {
                    objectOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (dataInputStream != null) {
                    dataInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

• 服务端

package com.ruan.test03;

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

public class Service {
    public static void main(String[] args) {
        //创建套接字
        ServerSocket serverSocket = null;
        Socket accept = null;
        InputStream inputStream = null;
        ObjectInputStream objectInputStream = null;
        OutputStream outputStream = null;
        DataOutputStream dataOutputStream = null;
        try {
            serverSocket = new ServerSocket(8888);
            //等待接收数据
            accept = serverSocket.accept();
            //获取客户端发送的信息
            inputStream = accept.getInputStream();
            objectInputStream = new ObjectInputStream(inputStream);
            User user = (User) objectInputStream.readObject();
            //进行数据校验
            boolean flag = false;
            if (user.getUsername().equals("小天才") && user.getPwd().equals("123456")){
                flag = true;
            }
            //向客户端返回信息
            outputStream = accept.getOutputStream();
            dataOutputStream = new DataOutputStream(outputStream);
            dataOutputStream.writeBoolean(flag);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
            if (objectInputStream != null) {
                    objectInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (outputStream != null) {
                    outputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (dataOutputStream != null) {
                    dataOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (accept != null){
                    accept.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (serverSocket != null) {
                    serverSocket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

功能分解5：多线程接收用户请求

• 遗留问题：服务器针对一个请求服务，之后服务器就关闭了（程序自然结束了）
• 现在需要解决：服务器必须一直在监听 ，一直开着，等待客户端的请求
• 在当前代码中，客户端不用动了

更改服务器代码

package com.ruan.test03;

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


public class Service {
    public static void main(String[] args) {
        //创建套接字
        ServerSocket serverSocket = null;
        Socket accept = null;
        int count = 0;//计数器
        try {
            serverSocket = new ServerSocket(8888);
            //等待接收数据
            while (true){
                accept = serverSocket.accept(); //服务器一直监听客户端
                new ServerThread(accept).start();
                count++;
                System.out.println("当前第"+count+"个用户正在访问，用户对象为"+serverSocket.accept().getInetAddress());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package com.ruan.test03;

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

public class ServerThread extends Thread {
    InputStream inputStream = null;
    ObjectInputStream objectInputStream = null;
    OutputStream outputStream = null;
    DataOutputStream dataOutputStream = null;
    Socket socket = null;
    public ServerThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            //获取客户端发送的信息
            inputStream = socket.getInputStream();
            objectInputStream = new ObjectInputStream(inputStream);
            User user = (User) objectInputStream.readObject();
            //进行数据校验
            boolean flag = false;
            if (user.getUsername().equals("小天才") && user.getPwd().equals("123456")){
                flag = true;
            }
            //向客户端返回信息
            outputStream = socket.getOutputStream();
            dataOutputStream = new DataOutputStream(outputStream);
            dataOutputStream.writeBoolean(flag);
        }catch (IOException | ClassNotFoundException  e ) {
            e.printStackTrace();
        } finally {
            try {
                if (dataOutputStream != null) {
                    dataOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (outputStream != null) {
                    outputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            try {
                if (objectInputStream != null) {
                    objectInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            try {
                if (inputStream != null) {
                    inputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}