javaSE每天练程序——day19 网络编程、udp、tcp协议、udp协议聊天室

学习目录：

网络编程
计算机网络
是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，
在网络操作系统，网络管理软件及网络通信协议的管理和协调下，
实现资源共享和信息传递的计算机系统。
网络编程
就是用来实现网络互连的不同计算机上运行的程序间可以进行数据交换

网络编程(网络模型概述和图解)(了解)

网络模型的概述：

计算机以和何种规则进行通信，就是何种网络模型

常见的网络模型：

• OSI 七层模型
  物理层：接口，比特流传输
  数据 链路层：MAC地址解封，贞传输，交换机
  网络层 ：IP地址解封，数据包传输，路由去器
  传输层：协议 TCP / UDP
  会话层：数据链路的接通
  表示层：解释 加密 连接
  应用层：终端应用
• TCP/TP 四层模型主机至网络层(物理层 , 数据链路层) , 网际层 , 传输层 , 应用层(应用层 , 表示层 , 会话层)
  
  

网络编程(网络编程三要素概述)(理解)

IP:用来标识设备的唯一性
端口：用来存放进程的逻辑地址，不同进程的标识
协议：UDP TCP

网络编程(网络编程三要素之IP概述)(了解)

• 概述：给主机分配的32位地址
• 组成：网络地址+主机地址
• A类IP：网+机+机+机 1.0.0.1—127.255.255.254
  (1)10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址)
  (2)127.X.X.X是保留地址，用做循环测试用的。
• B类IP：网+网+机+机 92.0.0.1-223.255.255.254
  2.168.x.X是私有地址
• C类IP：网+网+网+机 192.0.0.1-223.255.255.254
  192.168.x.X是私有地址
• D类 224.0.0.1—239.255.255.254
• E类 240.0.0.1—247.255.255.254
• 特殊地址
  127.0.0.1回环地址 ，用于检测本机的网络是否问题ping 127.0.0.1
  ipconfig查看本机的IP
  xxx.xxx.xxx.255广播地址
  hostname获取主机名

网络编程(InetAddress类的概述和使用)(了解)

• InteAddress类的概述：
  为了方便对IP地址的获取和操作
• InetAddress提供的方法
  public static InetAddress getByName(String host)//括号里面填写主机名或者是IP
  ​ public String getHostAddress()//获取IP
  ​ public String getHostName()//获取主机名
  ​ getLocalHost();
  案例一：
  InetAddress功能的概述
  getByName获取：知道主机名或者IP
  getLocalHost来获取不知道主机名衣蛾不知到IP

package day20190801.IP中InterAddress的功能的概述;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * @description:InterAddress功能的概述
 * @author: @李小白
 * @create: 2019-08-01 15:28
 */
public class Demo {
    public static void main(String[] args) throws UnknownHostException {
        //在知道主机名或者是IP的情况下用getByName获取
        InetAddress inetAddress = InetAddress.getByName("192.168.11.233");
        String hostAddress = inetAddress.getHostAddress();//ip
        String hostName = inetAddress.getHostName();//获取主机名
        System.out.println(hostAddress);
        System.out.println(hostName);
        //在不知道主机名或者是IP 的情况下就用getLocalHost来获取
        InetAddress localHost = InetAddress.getLocalHost();
        String hostAddress1 = localHost.getHostAddress();//获取IP
        String hostName1 = localHost.getHostName();//获取主机名字
        System.out.println(hostAddress1);
        System.out.println(hostName1);
    }
}

网络编程(网络编程三要素之端口和协议)(了解)

端口：

• 物理端口：网卡口
• 逻辑端口：
  每个网络程序都会有哟个逻辑端口
  用来标识不同的进程
  有效端口：0--------65535，其中0-------1023是系统使用个的端口

协议

• UDP：不需要建立连接，不可靠，效率高，每个数据报的大小限制在64KB
• TCP：必须建立连接，可靠，效率低，进行叫大数据的传输

网络编程(Socket通信原理图解)(理解)

• Socket=IP+端口
• Socket套接字的原理机制:
  通信的两端都有Socket
  网络通信就是Socket之间的通信
  数据在Socket之间的传输就是通过IO传输

网络编程(UDP协议发送数据)(掌握)

• Claint端：发送协议
  第一步：new DataGramaSockert 创建UDP通讯客户端对象
  第二步：send发送 创建出来一句字节话 创建数据报包 new DataGramaPackage(字节，字节的长度，主机名，端口号)
  第三步：释放 资源close

网络编程(UDP协议接收数据)(掌握)

• Server端接收协议

第一步：new DataGramaSockert(暴露端口号) 创建数据报包,作用用来接收数据
第二步：resive接收 创建一个空的数据报包 new DataGramaPackage(字节，字节的长度) 取出数据+长度+ip 把字节 [ ] 转换成字符串
第三步：释放资源close

案例一：
一般的UDP协议之间数据的传输

package day20190801.UDP之间进行简单的传输;

import java.io.IOException;
import java.net.*;

/**
 * @description: claint端进行传输
 * @author: @李小白
 * @create: 2019-08-01 16:03
 */
public class UDPClaint {
    public static void main(String[] args) throws IOException {
        //UDP
        //将数据源和目的封装成数据包中，不需要建立连接；
        //每个数据报的大小在限制在64k；
        //因无连接，是不可靠协议；
        //不需要建立连接，速度快
        //Java针对UDP协议提供了一个Socket
        //DatagramSocket 此类表示用来发送和接收数据报包的套接字。
        //DatagramSocket()
        //构造数据报套接字并将其绑定到本地主机上任何可用的端口。
        //1.创建客户端的Socket
        DatagramSocket datagramSocket = new DatagramSocket();
        
        //2.传输数据
        //创建一个数报包
        byte[] bytes = "你好，udp我把你打包发送过去了，你收到了吗".getBytes();
        InetAddress byName = InetAddress.getByName("192.168.11.239");
        DatagramPacket datagramPacket = new DatagramPacket(bytes,bytes.length,byName,9999);
        datagramSocket.send(datagramPacket);
        //字节，字节的长度，主机名字，端口号

        //3.释放资源
        datagramSocket.close();
    }
}

package day20190801.UDP之间进行简单的传输;


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

/**
 * @description: server端进行传输
 * @author: @李小白
 * @create: 2019-08-01 16:03
 */
public class UDPServer {
    public static void main(String[] args) throws IOException {
        //DatagramSocket( int port)
        //创建数据报套接字并将其绑定到本地主机上的指定端口。
        //1.创建一个数据套接字，暴露端口号
        DatagramSocket datagramSocket = new DatagramSocket(9999);

        //2.接收数据
        //创建一个空包来存放收过来的资源
        byte[] bytes = new byte[1024 * 8];
        DatagramPacket datagramPacket = new DatagramPacket(bytes,bytes.length);//数组+数组长度
        System.out.println("服务器已经开启，等待连接.........");

        datagramSocket.receive(datagramPacket);

        //从收取的资源报包里面把资源拿出来
        byte[] data = datagramPacket.getData();//数据
        int length = datagramPacket.getLength();//实际长度
        String ip = datagramPacket.getAddress().getHostAddress();//ip
        String s = new String(data, 0, length);

        System.out.println(ip+":发来消息----"+s);

        //3.释放资源
        datagramSocket.close();
    }
}

网络编程(UDP协议发送端的数据来自于键盘录入)(理解)

案例三：
键盘录入UDP发送数据的方式一：

package day20190801.UDP键盘录入的两种方式;

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

/**
 * @description: claint端进行传输
 * @author: @李小白
 * @create: 2019-08-01 16:03
 */
public class UDPClaint {
    public static void main(String[] args) throws IOException {

        //1.创建客户端的Socket
        DatagramSocket datagramSocket = new DatagramSocket();
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        while (true) {
            System.out.println("请输入你要输入的信息");
            String s = in.readLine();
            if (s.equals("886")) {
                break;
            }
            //2.传输数据
            //创建一个数报包
            byte[] bytes = s.getBytes();
            InetAddress byName = InetAddress.getByName("192.168.11.239");
            DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length, byName, 9991);//字节，字节的长度，主机名字，端口号
            datagramSocket.send(datagramPacket);
        }
        //3.释放资源
        datagramSocket.close();
    }
}

package day20190801.UDP键盘录入的两种方式;


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

/**
 * @description: server端进行传输
 * @author: @李小白
 * @create: 2019-08-01 16:03
 */
public class UDPServer {
    public static void main(String[] args) throws IOException {
        //DatagramSocket( int port)
        //创建数据报套接字并将其绑定到本地主机上的指定端口。
        //1.创建一个数据套接字，暴露端口号
        DatagramSocket datagramSocket = new DatagramSocket(9991);
        System.out.println("服务器已经开启，等待连接.........");
        while (true) {

            //2.接收数据
            //创建一个空包来存放收过来的资源
            byte[] bytes = new byte[1024 * 8];
            DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length);//数组+数组长度
            datagramSocket.receive(datagramPacket);

            //从收取的资源报包里面把资源拿出来
            byte[] data = datagramPacket.getData();//数据
            int length = datagramPacket.getLength();//实际长度
            String ip = datagramPacket.getAddress().getHostAddress();//ip
            String s = new String(data, 0, length);

            System.out.println(ip + ":发来消息----" + s);
        }
        //3.释放资源
//        datagramSocket.close();
    }
}

键盘录入：方式二

package day20190801.UDP键盘录入的两种方式2;

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

/**
 * @description: claint端进行传输
 * @author: @李小白
 * @create: 2019-08-01 16:03
 */
public class UDPClaint {
    public static void main(String[] args) throws IOException {

        //1.创建客户端的Socket
        DatagramSocket datagramSocket = new DatagramSocket();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要发送的信息");
        while (sc.hasNextLine()) {
            System.out.println("请输入你要输入的信息");
            String s = sc.nextLine();
            if (s.equals("886")) {
                break;
            }
            //2.传输数据
            //创建一个数报包
            byte[] bytes = s.getBytes();
            InetAddress byName = InetAddress.getByName("192.168.11.239");
            DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length, byName, 9992);//字节，字节的长度，主机名字，端口号
            datagramSocket.send(datagramPacket);
        }
        //3.释放资源
        datagramSocket.close();
    }
}

package day20190801.UDP键盘录入的两种方式2;


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

/**
 * @description: server端进行传输
 * @author: @李小白
 * @create: 2019-08-01 16:03
 */
public class UDPServer {
    public static void main(String[] args) throws IOException {
        //DatagramSocket( int port)
        //创建数据报套接字并将其绑定到本地主机上的指定端口。
        //1.创建一个数据套接字，暴露端口号
        DatagramSocket datagramSocket = new DatagramSocket(9992);
        System.out.println("服务器已经开启，等待连接.........");
        while (true) {
            //2.接收数据
            //创建一个空包来存放收过来的资源
            byte[] bytes = new byte[1024 * 8];
            DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length);//数组+数组长度
            datagramSocket.receive(datagramPacket);

            //从收取的资源报包里面把资源拿出来
            byte[] data = datagramPacket.getData();//数据
            int length = datagramPacket.getLength();//实际长度
            String ip = datagramPacket.getAddress().getHostAddress();//ip
            String s = new String(data, 0, length);

            System.out.println(ip + ":发来消息----" + s);
        }
        //3.释放资源
//        datagramSocket.close();
    }
}

网络编程(UDP多线程实现控制台发消息)(理解)

案例三：UDP开启两个线程

package day20190801.UDP键盘录入开启线程;

/**
 * @description:
 * @author: @李小白
 * @create: 2019-08-01 17:22
 */
public class Text {
    public static void main(String[] args) {
         new UDPClaint().start();
        new UDPServer().start();
    }
}

package day20190801.UDP键盘录入开启线程;

import sun.awt.windows.ThemeReader;

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

/**
 * @description: claint端进行传输
 * @author: @李小白
 * @create: 2019-08-01 16:03
 */
public class UDPClaint extends Thread {
    @Override
    public void run() {
        DatagramSocket datagramSocket = null;
        try {
            //1.创建客户端的Socket
            datagramSocket = new DatagramSocket();
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你要发送的信息");
            while (sc.hasNextLine()) {
                System.out.println("请输入你要输入的信息");
                String s = sc.nextLine();
                if (s.equals("886")) {
                    break;
                }
                //2.传输数据
                //创建一个数报包
                byte[] bytes = s.getBytes();
                InetAddress byName = InetAddress.getByName("192.168.11.239");
                DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length, byName, 9992);//字节，字节的长度，主机名字，端口号
                datagramSocket.send(datagramPacket);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        //3.释放资源
        datagramSocket.close();
    }
}

package day20190801.UDP键盘录入开启线程;


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

/**
 * @description: server端进行传输
 * @author: @李小白
 * @create: 2019-08-01 16:03
 */
public class UDPServer extends Thread{
    @Override
    public void run() {
        try {
            //DatagramSocket( int port)
            //创建数据报套接字并将其绑定到本地主机上的指定端口。
            //1.创建一个数据套接字，暴露端口号
            DatagramSocket datagramSocket = new DatagramSocket(9992);
            System.out.println("服务器已经开启，等待连接.........");
            while (true) {
                //2.接收数据
                //创建一个空包来存放收过来的资源
                byte[] bytes = new byte[1024 * 8];
                DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length);//数组+数组长度
                datagramSocket.receive(datagramPacket);

                //从收取的资源报包里面把资源拿出来
                byte[] data = datagramPacket.getData();//数据
                int length = datagramPacket.getLength();//实际长度
                String ip = datagramPacket.getAddress().getHostAddress();//ip
                String s = new String(data, 0, length);

                System.out.println(ip + ":发来消息----" + s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        //3.释放资源
//        datagramSocket.close();
    }
}

案例四：

UDP多线程实现聊天室程序

public class A {
    public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                //开启服务的socket
                try {
                    DatagramSocket socket = new DatagramSocket(9999);//暴露端口号
                    System.out.println("服务器已经开启，等待连接...");
                    while (true) {
                        //创建一个空的数据报包
                        DatagramPacket datagramPacket = new DatagramPacket(new byte[1024], 1024);

                        socket.receive(datagramPacket);//阻塞式的方法，等待接收客户端发来的数报包
                        //从数据报包里面去数据
                        byte[] data = datagramPacket.getData();
                        int length = datagramPacket.getLength();
                        //取出发送者ip
                        String ip = datagramPacket.getAddress().getHostAddress();

                        System.out.println(ip + "B给你发来：" + new String(data, 0, length));
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
        }.start();

        //发送消息 发给B
        sendMsg();

    }

    private static void sendMsg() {
        try {
            DatagramSocket socket = new DatagramSocket();
            //创建数据报包
            //发送的数据报包里面要放的数据 ：对方的IP和端口。以及你要发送的数据
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入你要发送给A的数据");
            while (scanner.hasNextLine()) {
                System.out.println("请输入你要发送给A的数据");
                String s = scanner.nextLine();
                if (s.equals("886")) {
                    break;
                }
                byte[] bytes = s.getBytes();
                DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("192.168.11.123"), 8888);

                socket.send(datagramPacket);
            }
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class B {
    public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                //开启服务的socket
                try {
                    DatagramSocket socket = new DatagramSocket(8888);//暴露端口号
                    System.out.println("服务器已经开启，等待连接...");
                    while (true) {
                        //创建一个空的数据报包
                        DatagramPacket datagramPacket = new DatagramPacket(new byte[1024], 1024);

                        socket.receive(datagramPacket);//阻塞式的方法，等待接收客户端发来的数报包
                        //从数据报包里面去数据
                        byte[] data = datagramPacket.getData();
                        int length = datagramPacket.getLength();
                        //取出发送者ip
                        String ip = datagramPacket.getAddress().getHostAddress();

                        System.out.println(ip + "A给你发来：" + new String(data, 0, length));
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
        }.start();

        //发送消息 发给B
        sendMsg();

    }

    private static void sendMsg() {
        try {
            DatagramSocket socket = new DatagramSocket();
            //创建数据报包
            //发送的数据报包里面要放的数据 ：对方的IP和端口。以及你要发送的数据
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入你要发送A的数据");
            while (scanner.hasNextLine()) {
                System.out.println("请输入你要发送A的数据");
                String s = scanner.nextLine();
                if (s.equals("886")) {
                    break;
                }
                byte[] bytes = s.getBytes();
                DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("192.168.11.123"), 9999);

                socket.send(datagramPacket);
            }
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }


    }
}

网络编程(TCP协议发送数据)(掌握)

客户端方法

客户端套接字 Socket
//Socket(InetAddress address, int port)
//创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
//Socket(String host, int port)
//创建一个流套接字并将其连接到指定主机上的指定端口号。

• Cilect客户端:发送端
  第一步:套接字 ServerSocket 输入IP地址+端口号
  第二步:获取通道中输出流 getOutputStream(); write一句需要输出的话—字节数组getbyte
  第三步:释放资源close

服务端方法

服务端的套接字 Socket
//ServerSocket( int port)
accept()阻塞式方法

• 服务端:接收端
  第一步:套接字 Socket 暴露端口号
  第二步:阻塞方法 accept()
  第三步:获取道中的输入流 getInputStream(): 输出接收到的字节数组len=in.read(byte),输出接收到的话(byte,0,len)
  第四步:释放资源close

案例一:

接收端和发送端的基本连接

package javaSEreview21090801.TCP协议基本连接;

import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;

/**
 * @Description:基本连接
 * @Author:@李小白
 * @Date:2019/8/1 23:18
 */
public class TCPClient {
    public static void main(String[] args) throws IOException {
        //服务端套接字
        Socket socket = new Socket("192.168.43.253",8888);

        //获取同道中的输出流
        OutputStream out = socket.getOutputStream();
        out.write("你好TCP的服务端,我来了".getBytes());

        //释放资源
        socket.close();

    }
}

package javaSEreview21090801.TCP协议基本连接;

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

/**
 * @Description:基本连接
 * @Author:@李小白
 * @Date:2019/8/1 23:19
 */
public class TCPServer {
    public static void main(String[] args) throws IOException, InterruptedException {

        //服务器的套接字+端口暴露
        ServerSocket serverSocket = new ServerSocket(8888);

        //阻塞
        Socket accept = serverSocket.accept();

        //获取通道里面的输入流
        InputStream in = accept.getInputStream();
        byte[] bytes = new byte[1024 * 8];
        int len = in.read(bytes);
        String s = new String(bytes, 0, len);

        String ip = accept.getInetAddress().getHostAddress();
        System.out.println(ip+"给你发来消息----"+s);
        //释放资源
        serverSocket.close();
    }
}

接收端和发送端的基本反馈

package javaSEreview21090801.TCP协议基本反馈;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

/**
 * @Description:基本连接
 * @Author:@李小白
 * @Date:2019/8/1 23:18
 */
public class TCPClient {
    public static void main(String[] args) throws IOException {
        //服务端套接字
        Socket socket = new Socket("192.168.43.253",8888);

        //获取同道中的输出流
        OutputStream out = socket.getOutputStream();
        out.write("你好,服务端我给您寄来了给你一个包裹".getBytes());

        //获取同道中人的输入流
        InputStream in = socket.getInputStream();
        byte[] bytes = new byte[1024 * 8];
        int len = in.read(bytes);
        String s = new String(bytes, 0, len);
        System.out.println("服务端,下来了!!!");
        //释放资源
        socket.close();

    }
}

package javaSEreview21090801.TCP协议基本反馈;

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

/**
 * @Description:基本连接
 * @Author:@李小白
 * @Date:2019/8/1 23:19
 */
public class TCPServer {
    public static void main(String[] args) throws IOException, InterruptedException {

        //服务器的套接字+端口暴露
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端已经开启,等待连接........");

        //阻塞
        Socket accept = serverSocket.accept();

        //获取通道里面的输入流
        InputStream in = accept.getInputStream();
        byte[] bytes = new byte[1024 * 8];
        int len = in.read(bytes);
        String s = new String(bytes, 0, len);


        String ip = accept.getInetAddress().getHostAddress();
        System.out.println(ip+"给你发来消息----"+s);

        //获取他通道里面的输出流,给客户端一个反馈
        OutputStream out = accept.getOutputStream();
        out.write("你好,客户端我已经收到你的包裹,谢谢".getBytes());
        //释放资源
        serverSocket.close();
    }
}