Socket套接字之TCP网络编程单向双向对象流异常处理多线程

Socket套接字之TCP网络编程单向双向对象流异常处理

套接字(Socket)

用来描述IP地址和端口，是通信链的句柄，应用程序通过Socket向网络发送请求或者应答网络请求
是支持TCP/IP协议的网络通信的基本操作单元，
是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象，内含五种信息：连接使用的协议，本机IP即进程接口PORT，远程主机IP及进程接口PORT。
一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。
从所处的地位来讲，套接字上联应用进程，下联网络协议栈，是应用程序通过网络协议进行通信的接口，是应用程序与网络协议根进行交互的接口。

Socket示意图

Socket通讯模型

TCP网络编程

TCP有客户端可服务端，且地位不平等

客户端： Socket 程序感受到的使用流–>输出流
服务器端： ServerrSocket —>Socket 程序感受到的使用流<–输入流

接下来基于模拟通信，为了代码简便不处理异常而是直接抛出甩锅

单向通信

注意要先开服务器，再开启客户端

服务端

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

public class Server {
    public static void main(String[] args) throws IOException {
        //1.创建套接字： 指定服务的端口号
        ServerrSocket ss = new ServerrSocket(8888);
        //2.等着客户端发来的信息：
        /*阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。
        accept()返回值为一个Socket，这个Socket其实就是客户端的Socket
        接到这个Socket以后，客户端和服务器才真正产生了连接，才真正可以通信了*/
        Socket s = ss.accept();

        //3.感受到的操作流：
        InputStream is = s.getInputStream();
        DataInputStream dis = new DataInputStream(is);

        //4.读取客户端发来的数据：
        String str = dis.readUTF();
        System.out.println("客户端发来："+str);

        //5.关闭流 关闭网络资源：
        dis.close();
        is.close();
        s.close();
        ss.close();
    }
}

客户端

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

public class Client {
    public static void main(String[] args) throws IOException {
        //1.创建Socket：指定服务器的IP和端口号：
        Socket s = new Socket("localhost",8888);

        //2.利用输出流向外发送数据
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        //利用这个OutputStream就可以向外发送数据了，但是没有直接发送String的方法
        //所以我们又在OutputStream外面套了一个处理流：DataOutputStream
        dos.writeUTF("Hello World");

        //3.关闭流 关闭网络资源：
        dos.close();
        os.close();
        s.close();
    }
}

通信情况

Server:
客户端发来的数据为：Hello World

双向通信

服务端

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

public class Server {
    public static void main(String[] args) throws IOException {
        //1.创建套接字： 指定服务器的端口号
        ServerrSocket ss = new ServerrSocket(8888);

        //2.等着客户端发来的信息，建立连接通信
        Socket s = ss.accept();

        //3.感受到的操作流：
        InputStream is = s.getInputStream();
        DataInputStream dis = new DataInputStream(is);

        //4.读取客户端发来的数据：
        String str = dis.readUTF();
        System.out.println("客户端发来："+str);
        //向客户端回复一句话：-->操作流-->输出流
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        dos.writeUTF("Hello, I'm Server!");

        //5.关闭流 关闭网络资源：
        dos.close();
        os.close();
        dis.close();
        is.close();
        s.close();
        ss.close();
    }
}

客户端

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

public class Client {
    public static void main(String[] args) throws IOException {
        //1.创建套接字：指定服务器的IP和端口号：
        Socket s = new Socket("localhost",8888);
        
        //2.利用输出流向外发送数据：
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        dos.writeUTF("Hello World");
        //利用输入流接收服务器端的回话
        InputStream is = s.getInputStream();
        DataInputStream dis = new DataInputStream(is);
        String str = dis.readUTF();
        System.out.println("服务端发来："+str);

        //3.关闭流 闭网络资源：
        dis.close();
        is.close();
        dos.close();
        os.close();
        s.close();
    }
}

通信情况

Client:
客户端发来：Hello World

Server:
服务端发来：Hello, I'm Server!

对象流传送

对象类

User类，注意要有Serializable接口，否则通信时无法连接，抛出NotSerializableException异常

import java.io.Serializable;

public class User implements Serializable {
    private static final long serialVersionUID = 9050861343368322560L;
    private String name;
    private String password;

    public User() {
    }

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

服务端

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

public class Server {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        //1.创建套接字： 指定服务器的端口号
        ServerrSocket ss = new ServerrSocket(8888);

        //2.等着客户端发来的信息，建立连接通信
        Socket s = ss.accept();

        //3.感受到的操作流：
        InputStream is = s.getInputStream();
        ObjectInputStream ois = new ObjectInputStream(is);

        //4.读取客户端发来的数据：
        User user = (User)(ois.readObject());
        //对对象进行验证：
        boolean flag = false;
        if(user.getName().equals("fyz")&&user.getPassword().equals("123456")){
            System.out.println("验证成功");
            flag = true;
        }
        //向客户端输出结果  -->操作流-->输出流
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        dos.writeBoolean(flag);

        //5.关闭流 关闭网络资源：
        dos.close();
        os.close();
        ois.close();
        is.close();
        s.close();
        ss.close();
    }
}

客户端

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

public class Client {
    public static void main(String[] args) throws IOException {
        //1.创建套接字：指定服务器的ip和端口号：
        Socket s = new Socket("localhost",8888);
        //录入用户的账号和密码：
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入您的账号：");
        String name = sc.next();
        System.out.println("请录入您的密码：");
        String pwd = sc.next();
        //将账号和密码封装为一个User的对象：
        User user = new User(name,pwd);

        //2.对于程序员来说，向外发送数据 感受 --》利用输出流：
        OutputStream os = s.getOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(os);
        oos.writeObject(user);
        //接收服务器端的回话--》利用输入流：
        InputStream is = s.getInputStream();
        DataInputStream dis = new DataInputStream(is);
        boolean b = dis.readBoolean();
        if(b){
            System.out.println("恭喜，登录成功");
        }else{
            System.out.println("对不起，登录失败");
        }

        //3.关闭流  +  关闭网络资源：
        dis.close();
        is.close();
        oos.close();
        os.close();
        s.close();
    }
}

通信情况

Client:
请录入您的账号：
fyz
请录入您的密码：
123456
恭喜，登录成功
    
Server:
验证成功

异常处理

以单向通讯举例

try-catch-finally

由于try个代码块互不相认，故而还需将各资源提出单独定义，并将关闭资源代码放入finally中

服务端

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

public class Server {
    public static void main(String[] args){
        //1.创建套接字： 指定服务器的端口号
        ServerrSocket ss = null;
        Socket s = null;
        InputStream is = null;
        DataInputStream dis = null;
        try {
            ss = new ServerrSocket(8888);
            //2.等着客户端发来的信息：
            s = ss.accept();

            //3.感受到的操作流：
            is = s.getInputStream();
            dis = new DataInputStream(is);

            //4.读取客户端发来的数据：
            String str = dis.readUTF();
            System.out.println("客户端发来的数据为："+str);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {//5.关闭流 关闭网络资源：
            try {
                assert ss != null;
                ss.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                assert s != null;
                s.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                assert dis != null;
                dis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                assert is != null;
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端

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

public class Client {
    public static void main(String[] args){
        //1.创建Socket：指定服务器的ip和端口号：
        Socket s = null;
        OutputStream os = null;
        DataOutputStream dos = null;
        try {
            s = new Socket("localhost",8888);
            //2.利用输出流向外发送数据
            os = s.getOutputStream();
            dos = new DataOutputStream(os);
            /*利用这个OutputStream就可以向外发送数据了，但是没有直接发送String的方法
            所以我们又在OutputStream外面套了一个处理流：DataOutputStream*/
            dos.writeUTF("Hello World");
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {//3.关闭流 关闭网络资源：
                assert s != null;
                s.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                assert dos != null;
                dos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                assert os != null;
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

try-with-resouce

JDK1.7之后有了try-with-resource处理机制。写法为try(){}catch(){}，将需要关闭的资源在try()中创建，catch()捕获处理异常。执行后自动关闭文件。但要注意，能被自动关闭的资源需要实现Closeable或者AutoCloseable接口，try()中创建的资源被final修饰不可更改。

服务端

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

public class Server {
    public static void main(String[] args){
        //1.创建套接字： 指定服务器的端口号
        try(ServerrSocket ss = new ServerrSocket(8888);
            Socket s = ss.accept();
            InputStream is = s.getInputStream();
            DataInputStream dis = new DataInputStream(is);){
            String str = dis.readUTF();
            System.out.println("客户端发来的数据为："+str);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端

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

public class Client {
    public static void main(String[] args){
        try(Socket s = new Socket("localhost",8888);
            OutputStream os = s.getOutputStream();
            DataOutputStream dos = new DataOutputStream(os);) {
            dos.writeUTF("Hello World");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

多线程

之前的程序服务器针对一个请求服务，之后服务器就关闭了（程序自然结束了）现在要使服务器一直在监听等待客户端的请求

以对象流传输为基础

线程服务

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

public class ServerThread extends Thread {//线程：专门处理客户端的请求
    Socket s = null;
    public ServerThread(Socket s){
        this.s = s;
    }
    @Override
    public void run() {
        try(     InputStream is = s.getInputStream();//客户端发来的信息：
                 ObjectInputStream ois = new ObjectInputStream(is);
                 OutputStream os = s.getOutputStream();
                 DataOutputStream dos = new DataOutputStream(os);){
            //读取客户端发来的数据：
            User user = (User)(ois.readObject());
            //对对象进行验证：
            boolean flag = false;
            if(user.getName().equals("fyz")&&user.getPassword().equals("123456")){
                flag = true;
            }
            //向客户端输出结果：操作流-->输出流
            dos.writeBoolean(flag);
        }catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

服务端

public class Server {
    public static void main(String[] args) {
        System.out.println("服务器启动了");
        Socket s = null;
        int count = 0;//定义一个计数器，用来计数  客户端的请求
        try(
                ServerSocket ss = new ServerSocket(8888);) {
            while(true){//加入死循环，服务器一直监听客户端是否发送数据
                s = ss.accept();
                //阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。
                //每次过来的客户端的请求 靠 线程处理：
                new ServerThread(s).start();
                count++;
                //输入请求的客户端的信息：
                System.out.println("当前是第"+count+"个用户访问我们的服务器,对应的用户是："+s.getInetAddress());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                assert s != null;
                s.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

对象类

import java.io.Serializable;

public class User implements Serializable {
    private static final long serialVersionUID = 9050861343368322560L;
    private String name;
    private String password;

    public User() {
    }

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

客户端

public class Client {
    public static void main(String[] args){
        //创建Socket及相应资源
        try(
                Socket s = new Socket("localhost",8888);
                OutputStream os = s.getOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(os);
                InputStream is = s.getInputStream();
                DataInputStream dis = new DataInputStream(is);
                ) {
            //录入用户的账号和密码：
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入您的账号：");
            String name = sc.next();
            System.out.println("请录入您的密码：");
            String pwd = sc.next();
            //将账号和密码封装为一个User的对象：
            User user = new User(name,pwd);
            //向外发送数据 输出流：
            oos.writeObject(user);
            //接收服务器端的回话 输入流：
            boolean b = dis.readBoolean();
            if(b){
                System.out.println("恭喜，登录成功");
            }else{
                System.out.println("对不起，登录失败");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

通信情况

Client:
请录入您的账号：
fyz
请录入您的密码：
12345
对不起，登录失败

请录入您的账号：
fyz
请录入您的密码：
123456
恭喜，登录成功

Server:
服务器启动了
当前是第1个用户访问我们的服务器,对应的用户是：/127.0.0.1
当前是第2个用户访问我们的服务器,对应的用户是：/127.0.0.1

posted @ 2021-08-12 10:59 SKPrimin 阅读(107) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

笠逸

青箬笠，绿蓑衣，斜风细雨不须归

Socket套接字之TCP网络编程单向双向对象流异常处理多线程

Socket套接字之TCP网络编程单向双向对象流异常处理

TCP网络编程

单向通信

服务端

客户端

通信情况

双向通信

服务端

客户端

通信情况

对象流传送

对象类

服务端

客户端

通信情况

异常处理

try-catch-finally

服务端

客户端

try-with-resouce

服务端

客户端

多线程

线程服务

服务端

对象类

客户端

通信情况

公告

笠逸

青箬笠，绿蓑衣，斜风细雨不须归

Socket套接字之TCP网络编程 单向 双向 对象流 异常处理 多线程

Socket套接字之TCP网络编程 单向 双向 对象流 异常处理

TCP网络编程

单向通信

服务端

客户端

通信情况

双向通信

服务端

客户端

通信情况

对象流传送

对象类

服务端

客户端

通信情况

异常处理

try-catch-finally

服务端

客户端

try-with-resouce

服务端

客户端

多线程

线程服务

服务端

对象类

客户端

通信情况

公告

Socket套接字之TCP网络编程单向双向对象流异常处理多线程

Socket套接字之TCP网络编程单向双向对象流异常处理