网络编程实现

1.网络编程三要素

1.IP地址：网络中设备的唯一标识
    IPv4: 由4个字节组成，点分十进制表示法
	IPv6: 由16个字节组成，冒分十六进制表示法
   	"127.0.0.1"本地主机网络地址【用于测试】
    相关命令：
    ipconfig: 查看本机在当前网络环境下的ip地址
    ping: 查看当前主机和指定的ip地址是否连通
    
2.端口号：在网络设备中应用程序的标识，用一个整数表示。
        范围：[0~65535]，[0-1023]可能被操作系统占用,建议使用1024以后的端口号
        80: 浏览器中访问服务器的默认端口号
        8080: Tomcat服务器默认的端口号
        3306: MySQL数据库的端口号

3.网络协议：网络中数据传输的规则
      UDP: 面向无连接的，不可靠的协议，一次只能传输64K的数据
      TCP: 面向有链接的，可靠的协议，对数据大小没有限制 
      对当前网络通讯质量要求不高的时候，要求网络通讯速度尽量的快，这时就使用UDP
      1.QQ语音   2.QQ视频    3.TFTP
      当对网络通信质量有要求时，比如：整个数据要准确无误的传递给对方，这往往对于一些要求可靠的应用
      1.浏览器使用的：HTTP   2.FlashFXP:FTP
      3.Outlook:POP，SMTP   4.QQ文件传输

2.InetAddress类【ip相关】

//InetAddress类
public class Demo1 {
    public static void main(String[] args) throws UnknownHostException {
        //确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
        //static InetAddress getByName (string host)
        InetAddress inetAddress = InetAddress.getByName("192.168.83.152");
        
        //获取此IP地址的主机名
        //string getHostName ()如果主机名[安全问题]隐藏,则返回ip地址
        
        System.out.println("主机名为 "+inetAddress.getHostName());
        //string getHostAddress ()返回文本显示中的IP地址字符串
        
        System.out.println("ip为 "+inetAddress.getHostAddress());
        //局域网为192.168.83.113
        //外网为10.254.3.213
    }
}

打印结果：
------------------------------------------------------------------------
主机名为 192.168.83.152
ip为 192.168.83.152

3.UDP通信【协议】

【过程与码头送包裹类似】

//发送端
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建码头
        DatagramSocket ds = new DatagramSocket();
        //打包数据
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        byte[] bytes = s.getBytes();
        InetAddress address = InetAddress.getByName("127.0.0.1");
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,10001);
        //发送包裹【sent方法发送，并将包裹传入】
        ds.send(dp);
        //释放资源
        ds.close();
    }
}

打印结果：
----------------------------------------------------------------------------------------------------
你好

【注：需要先打开接收端，再打开发送端才可测试】

//接收端[码头需要释放资源]
//注意点：
//1.要先运行接收端,再运行发送端
//2.如果接收端再启动之后,没有接收到数据,那么会死等(阻塞).
//3.在接收数据的时候,需要调用一个getLength方法,表示接收到了多少字节
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //找到码头
        DatagramSocket ds = new DatagramSocket(10001);
        //创建新包
        //DatagramPacket (byte[] buf, int length)
        byte[] bytes = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length);
        //将客户端发送的包裹放进新包里
        ds.receive(dp);
        //拆包展示
        //DatagramPacket getData(获取字节数组) getLength(获取数据的长度)
        byte[] data = dp.getData();
        int length = dp.getLength();
        System.out.println(new String(data, 0, length));
        //释放资源
        ds.close();
    }
}

打印结果：
----------------------------------------------------------------------------------------------------
/127.0.0.1 来信息
你好

4.UDP中的组播和广播

组播代码实现
组播地址:224.0.0.0~239.255.255.255
其中224.0.0.0~224.0.0.255为预留的组播地址

//UDP组播
//发送端
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //1.创建码头
        DatagramSocket ds = new DatagramSocket();
        //2.打包
        byte[] bytes = "hello组播".getBytes();
        //netsh interface ipv4 show joins查看组播地址
        InetAddress address = InetAddress.getByName("224.0.0.1");
        //int ip =10000;
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,10000);
        //发送
        ds.send(dp);
        //释放资源
        ds.close();
    }
}
打印结果：
----------------
你好组播

public class ServerDemo {
    public static void main(String[] args) throws IOException {
          //找码头的组
        MulticastSocket ms = new MulticastSocket(10000);
        //准备新箱子
        DatagramPacket dp = new DatagramPacket(new byte[1024],1024);
        //放包：把当前计算机绑定一个组播地址，表示添加到这一组中
        ms.joinGroup(InetAddress.getByName("224.0.0.1"));
        ms.receive(dp);
        //拆包
        System.out.println(new String(dp.getData(), 0, dp.getLength()));
        ms.close();
    }
}

广播代码实现
广播地址：255.255.255.255

//UDP广播[广播地址不一定全部写成255,可以网段+255]
//发送端
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //1.创建码头
        DatagramSocket ds = new DatagramSocket();
        //2.打包
        byte[] bytes = "hello广播".getBytes();
        //255.255.255.255或者自己的网段+255
        InetAddress address = InetAddress.getByName("192.168.83.255");
        //int ip =10000;
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,10000);
        //发送
        ds.send(dp);
        //释放资源
        ds.close();
    }
}
打印结果：
----------------------------
你好，广播

//接收端
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //找码头的组
        DatagramSocket ds = new DatagramSocket(10000);
        //准备新箱子
        DatagramPacket dp = new DatagramPacket(new byte[1024],1024);
        //放包：把当前计算机绑定一个组播地址，表示添加到这一组中
        ds.receive(dp);
        //拆包
        System.out.println(new String(dp.getData(), 0, dp.getLength()));
        ds.close();

    }
}

5.TCP通信【协议】

【使用Socket和ServerSocket发送一张图片】
测试也是先开启服务端，再开启客户端发送

客户端

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //1.创建客户端Socket对象
        Socket socket = new Socket("192.168.83.113", 10002);
        //2.本地输入流读取文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\Inuyasha\\Desktop\\2.jpg"));
        //网络输出流输出文件
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        //边读边写
        byte[] bytes = new byte[1024];
        int len = bis.read(bytes);
        while (len != -1) {
            bos.write(bytes, 0, len);
            len = bis.read(bytes);
        }
        //给服务端读取结束符号
        socket.shutdownOutput();
        //关闭本地流
        bis.close();
        //3.等待服务器响应并读取
        //使用网络输入流对取并打印
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String s = br.readLine();
        System.out.println(s);
        //4.释放资源
        socket.close();
    }
}

服务端

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //1.创建客户端ServerSocket对象
        ServerSocket serverSocket = new ServerSocket(10002);
        //2.监视客户端，等待请求
        Socket socket = serverSocket.accept();
        //3.网络输入流读取客户端信息
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        //本地输出流将文件写入硬盘
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day15_mySocket\\a.jpg"));
        //边读边写
        byte[] bytes = new byte[1024];
        int len = bis.read(bytes);
        while (len != -1) {
            bos.write(bytes, 0, len);
            len = bis.read(bytes);
        }
        //关闭本地流
        bos.close();
        //4.读写完毕，传递客户端
        //网络输出流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write("上传成功");
        bw.newLine();
        bw.flush();
        //释放资源
        serverSocket.close();
        socket.close();
    }
}

服务端改进【服务端的对客户端传输的信息的操作可以写成线程任务，从而创建多线程】

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //1.创建客户端ServerSocket对象
        ServerSocket serverSocket = new ServerSocket(10002);
        //2.监视客户端，等待请求
        while (true) {
            Socket socket = serverSocket.accept();
            //socket有参构造，得到一个socket的线程任务
            ThreadSocket threadSocket = new ThreadSocket(socket);
            Executors.newFixedThreadPool(10).submit(threadSocket);
            //也可自定义线程池
             new ThreadPoolExecutor(
                    5,//核心线程数
                    8,//最大线程数
                    1,//临时线程存在时间
                    TimeUnit.MINUTES,//时间单位
                    new ArrayBlockingQueue<>(8),//阻塞队列
                    Executors.defaultThreadFactory(),//线程工程
                    new ThreadPoolExecutor.AbortPolicy()//拒绝策略
            ).submit(threadSocket);
        }
    }
}

//线程任务实现类
public class ThreadSocket implements Runnable {
    private Socket socket;
    
    public ThreadSocket(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        BufferedOutputStream bos = null;
        try {
            //3.网络输入流读取客户端信息
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
            //本地输出流将文件写入硬盘
            String s = UUID.randomUUID().toString();
            bos = new BufferedOutputStream(new FileOutputStream("day15_mySocket\\src\\com\\A\\" + s + ".jpg"));
            //边读边写
            byte[] bytes = new byte[1024];
            int len = bis.read(bytes);
            while (len != -1) {
                bos.write(bytes, 0, len);
                len = bis.read(bytes);
            }
            //4.读写完毕，传递客户端
            //网络输出流
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            bw.write("上传成功");
            bw.newLine();
            bw.flush();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭本地流
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                //释放资源
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

6.TCP代码实现注意点

<1>阻塞方法

a.使用accept()【ServerSocket对象调用】来监听客户端，并返回一个Socket对象【阻塞，等待客户端请求】
——解决客户端ip地址和端口号与服务端一致，即可发送请求
b.read()【输入流读取】阻塞，等待客户端输入【结束标记】
——关闭流，或者调用socket.shutdownOutput()方法给与一个结束标记，但不会影响socket流的继续使用

<2>三次握手【建立连接】

<3>四次挥手【取消连接】