Java学习笔记 第十章 网络编程

JAVA学习笔记第十章

10.网络编程

10.1引入

TCP建立连接：

释放连接：

10.2InetAddress & InetSocketAddress

InetAddress有两个方法：

InetSocketAddress封装了ip和端口号

10.3套接字

10.4TCP通信

10.4.1客户端和服务端通信

客户端发送一句话到服务器

public class TestClient { // 客户端
    public static void main(String[] args) throws IOException {
        // 创建套接字：指定服务器ip和端口号
        Socket s = new Socket("127.0.0.1", 8888);
        //对程序员来说，向外发送数据 感受 --》 利用输出流；
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        //利用OutputStream就可以向外发送数据流，但是没有直接发送String的方法
        //所以我们又在OutputStream外面套了一个处理流：DataOutputStream
        dos.writeUTF("你好");

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

    }
}

public class TestServer { // 服务器
    public static void main(String[] args) throws IOException {
        // 1.创建套接字：指定服务器的端口
        ServerSocket ss = new ServerSocket(8888);
        // 2.等待客户端发送来的信息
        Socket s = ss.accept(); // 阻塞方法：等待客户端的数据，什么时候收到数据，什么时候程序继续向下执行
        // 3.accept返回值为Socket，这个Socket其实就是客户端的Socket
        //接到这个Socket之后，客户端和服务端才真正产生了连接，才真正可以通信了
        //感受到的操作流
        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();
    }
}

先开服务器，然后开启客户端，在服务器端可以看到控制台打印出客户端发来的数据为：你好

如果先开客户端，会报出连接被拒绝的错误

服务端也可以向客户端发送信息

public class TestServer { // 服务器
    public static void main(String[] args) throws IOException {
        // 1.创建套接字：指定服务器的端口
        ServerSocket ss = new ServerSocket(8888);
        // 2.等待客户端发送来的信息
        Socket s = ss.accept(); // 阻塞方法：等待客户端的数据，什么时候收到数据，什么时候程序继续向下执行
        // 3.accept返回值为Socket，这个Socket其实就是客户端的Socket
        //接到这个Socket之后，客户端和服务端才真正产生了连接，才真正可以通信了
        //感受到的操作流
        InputStream is = s.getInputStream();
        DataInputStream dis = new DataInputStream(is);

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

        // 6.向客户端发送数据
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        dos.writeUTF("服务器端接收到你的消息");

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

public class TestClient { // 客户端
    public static void main(String[] args) throws IOException {
        // 创建套接字：指定服务器ip和端口号
        Socket s = new Socket("127.0.0.1", 8888);
        //对程序员来说，向外发送数据 感受 --》 利用输出流；
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        //利用OutputStream就可以向外发送数据流，但是没有直接发送String的方法
        //所以我们又在OutputStream外面套了一个处理流：DataOutputStream
        dos.writeUTF("你好");

        //客户端接收服务器的数据
        InputStream is = s.getInputStream();
        DataInputStream dis = new DataInputStream(is);
        String str = dis.readUTF();
        System.out.println("服务器对我说：" + str);

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

    }
}

10.4.2登录验证

模拟登录时输入账号密码，并进行验证的过程

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

    public String getName() {
        return name;
    }

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

    public String getPwd() {
        return pwd;
    }

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

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

需要实现Serializable接口，并且通过idea创建UID

public class Client {  //客户端
    public static void main(String[] args) throws IOException {
        // 1.创建套接字
        Socket s = new Socket("127.0.0.1", 8888);

        // 2.录入账号和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("username:");
        String name = sc.next();
        System.out.println("password:");
        String pwd = sc.next();

        // 3.将账号和密码封装为一个User对象
        User user = new User(name, pwd);

        // 4.向外发送对象，利用输出流
        OutputStream os = s.getOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(os);
        oos.writeObject(user);

        // 5.接收服务端发送的结果
        InputStream is = s.getInputStream();
        DataInputStream dis = new DataInputStream(is);
        Boolean flag = dis.readBoolean();
        System.out.println(flag);

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

public class Server {  //服务端
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1.创建套接字
        ServerSocket ss = new ServerSocket(8888);

        // 2.等待客户端发来的信息
        Socket s = ss.accept();

        // 3.获取传入的数据
        InputStream is = s.getInputStream();
        ObjectInputStream ois = new ObjectInputStream(is);

        // 4.读取客户端发送的数据
        User user = (User) ois.readObject();

        // 5.对对象进行验证：
        boolean flag = false;
        if (user.getName().equals("wrr") && user.getPwd().equals("1234")){
            flag = true;
        }

        // 6.向客户端输出结果
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        dos.writeBoolean(flag);

        // 7.关闭流 + 网络资源
        dos.close();
        os.close();
        ois.close();
        is.close();
        ss.close();
    }
}

10.4.3完整的异常处理方式

Socket提出去，其他的流在外面初始化为null

关闭流和资源放到finally，再对里面的流进行异常处理

public class Client {  //客户端
    public static void main(String[] args){
        // 1.创建套接字
        Socket s = null;
        OutputStream os = null;
        ObjectOutputStream oos = null;
        InputStream is = null;
        DataInputStream dis = null;
        try {
            s = new Socket("127.0.0.1", 8888);
            // 2.录入账号和密码
            Scanner sc = new Scanner(System.in);
            System.out.println("username:");
            String name = sc.next();
            System.out.println("password:");
            String pwd = sc.next();

            // 3.将账号和密码封装为一个User对象
            User user = new User(name, pwd);

            // 4.向外发送对象，利用输出流
            os = s.getOutputStream();
            oos = new ObjectOutputStream(os);
            oos.writeObject(user);

            // 5.接收服务端发送的结果
            is = s.getInputStream();
            dis = new DataInputStream(is);
            Boolean flag = dis.readBoolean();
            System.out.println(flag);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 6.关闭流 + 网络资源
            try {
                if(dis != null) {
                    dis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(os != null) {
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(s != null) {
                    s.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
    }
}

public class Server {
    public static void main(String[] args){
        // 1.创建套接字
        ServerSocket ss = null;
        InputStream is = null;
        ObjectInputStream ois = null;
        OutputStream os = null;
        DataOutputStream dos = null;
        
        try {
            ss = new ServerSocket(8888);
            // 2.等待客户端发来的信息
            Socket s = ss.accept();

            // 3.获取传入的数据
            is = s.getInputStream();
            ois = new ObjectInputStream(is);

            // 4.读取客户端发送的数据
            User user = null;
            try {
                user = (User) ois.readObject();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }

            // 5.对对象进行验证：
            boolean flag = false;
            if (user.getName().equals("wrr") && user.getPwd().equals("1234")){
                flag = true;
            }

            // 6.向客户端输出结果
            os = s.getOutputStream();
            dos = new DataOutputStream(os);
            dos.writeBoolean(flag);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 7.关闭流 + 网络资源
            try {
                if(dos != null) {
                    dos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(os != null) {
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(ss != null) {
                    ss.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        

        
    }
}

10.4.4多个客户端和一个服务器

客户端的代码不变

public class Client {  //客户端
    public static void main(String[] args){
        // 1.创建套接字
        Socket s = null;
        OutputStream os = null;
        ObjectOutputStream oos = null;
        InputStream is = null;
        DataInputStream dis = null;
        try {
            s = new Socket("127.0.0.1", 8888);
            // 2.录入账号和密码
            Scanner sc = new Scanner(System.in);
            System.out.println("username:");
            String name = sc.next();
            System.out.println("password:");
            String pwd = sc.next();

            // 3.将账号和密码封装为一个User对象
            User user = new User(name, pwd);

            // 4.向外发送对象，利用输出流
            os = s.getOutputStream();
            oos = new ObjectOutputStream(os);
            oos.writeObject(user);

            // 5.接收服务端发送的结果
            is = s.getInputStream();
            dis = new DataInputStream(is);
            Boolean flag = dis.readBoolean();
            System.out.println(flag);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 6.关闭流 + 网络资源
            try {
                if(dis != null) {
                    dis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(os != null) {
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(s != null) {
                    s.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

服务端 Server.java

public class Server {
    public static void main(String[] args){
        // 1.创建套接字
        ServerSocket ss = null;
        Socket s = null;
        int count = 0; // 定义一个计数器，用来计数 客户端的请求
        try {
            ss = new ServerSocket(8888);
            // 2.等待客户端发来的信息
            while (true) { // 加入死循环，服务器一直监听客户端是否发送数据
                s = ss.accept();
                //每次过来的客户端的请求靠线程处理
                new ServerThread(s).start();
                count++;
                System.out.println("当前是第"+count+"个用户访问我们的服务器，对应的用户是"+s.getInetAddress());
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

新建ServerThread.java

public class ServerThread extends Thread{  // 线程：专门处理客户端的请求
    InputStream is = null;
    ObjectInputStream ois = null;
    OutputStream os = null;
    DataOutputStream dos = null;
    Socket s = null;
    public ServerThread(Socket s){
        this.s = s;
    }
    @Override
    public void run() {
        // 3.获取传入的数据
        try{
            is = s.getInputStream();
            ois = new ObjectInputStream(is);

            // 4.读取客户端发送的数据
            User user = null;
            try {
                user = (User) ois.readObject();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }

            // 5.对对象进行验证：
            boolean flag = false;
            if (user.getName().equals("wrr") && user.getPwd().equals("1234")){
                flag = true;
            }

            // 6.向客户端输出结果
            os = s.getOutputStream();
            dos = new DataOutputStream(os);
            dos.writeBoolean(flag);
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            try {
                if(dos != null) {
                    dos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(os != null) {
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

10.5UDP通信

10.5.1单向通信

public class TestSend {
    public static void main(String[] args) throws IOException { //发送方
        System.out.println("学生上线");
        // 1.准备套接字，指定发送方的端口号
        DatagramSocket ds = new DatagramSocket(8888);
        // 2.准备数据包
        String str = "你好";
        byte[] bytes = str.getBytes();
        DatagramPacket dp = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("localhost"), 9999);
        /*
        需要四个参数： 1.传送数据转为字节的数组 2.字节数组的长度 3.接收方的IP地址 4.接收方的端口号
         */

        // 3.发送
        ds.send(dp);

        // 4.关闭资源
        ds.close();

    }
}

public class TestReceive {
    public static void main(String[] args) throws IOException { //接收方
        System.out.println("接收消息");
        // 1.准备套接字
        DatagramSocket ds = new DatagramSocket(9999);

        // 2.有一个空的数据包，准备接收对方传过来的数据
        byte[] b = new byte[1024];
        DatagramPacket dp = new DatagramPacket(b, b.length);

        // 3.接收对方的数据包，然后放入到我们的dp数据包中填充
        ds.receive(dp); //接收完以后，dp里面就填充好内容了

        // 4.取出数据：
        byte[] data = dp.getData();
        String s = new String(data, 0, dp.getLength());  // dp.getLength()数组包中的有效长度
        System.out.println(s);

        // 5.关闭资源
        ds.close();

    }
}

10.5.2双向通信

public class TestReceive {
    public static void main(String[] args) throws IOException { //接收方
        System.out.println("接收消息");
        // 1.准备套接字
        DatagramSocket ds = new DatagramSocket(9999);

        // 2.有一个空的数据包，准备接收对方传过来的数据
        byte[] b = new byte[1024];
        DatagramPacket dp = new DatagramPacket(b, b.length);

        // 3.接收对方的数据包，然后放入到我们的dp数据包中填充
        ds.receive(dp); //接收完以后，dp里面就填充好内容了

        // 4.取出数据：
        byte[] data = dp.getData();
        String s = new String(data, 0, dp.getLength());  // dp.getLength()数组包中的有效长度
        System.out.println(s);

        // 5.回复
        String str = "Hello";
        byte[] bytes = str.getBytes();
        DatagramPacket dp1 = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("localhost"), 8888);

        ds.send(dp1);

        // 5.关闭资源
        ds.close();

    }
}

public class TestSend {
    public static void main(String[] args) throws IOException { //发送方
        System.out.println("学生上线");
        // 1.准备套接字，指定发送方的端口号
        DatagramSocket ds = new DatagramSocket(8888);
        // 2.准备数据包
        String str = "你好";
        byte[] bytes = str.getBytes();
        DatagramPacket dp = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("localhost"), 9999);
        /*
        需要四个参数： 1.传送数据转为字节的数组 2.字节数组的长度 3.接收方的IP地址 4.接收方的端口号
         */

        // 3.发送
        ds.send(dp);

        // 4.接收
        byte[] b = new byte[1024];
        DatagramPacket dp1 = new DatagramPacket(b, b.length);
        ds.receive(dp1);

        byte[] data = dp1.getData();
        String s = new String(data, 0, dp1.getLength());
        System.out.println(s);

        // 4.关闭资源
        ds.close();

    }
}

10.5.3完整的异常处理方式

与TCP协议的通信一致，如10.4.3