关于java:Java-网络编程详解

文章和代码曾经归档至【Github仓库：https://github.com/timerring/java-tutorial 】或者公众号【AIShareLab】回复 java 也可获取。

网络的相干概念

网络通信

概念:两台设施之间通过网络实现数据传输
网络通信:将数据通过网络从一台设施传输到另一台设施
java.net包下提供了一系列的类或接口，供程序员应用，实现网络通信

网络

概念:两台或多台设施通过肯定物理设施连接起来形成了网络
依据网络的覆盖范围不同，对网络进行分类:

局域网:覆盖范围最小,仅仅笼罩一个教室或一个机房
城域网:覆盖范围较大，能够笼罩一个城市
广域网:覆盖范围最大，能够覆盖全国,甚至寰球,万维网是广域网的代表

ip 地址

概念:用于惟一标识网络中的每台计算机/主机
查看ip地址: ipconfig
ip地址的示意模式: 点分十进制XX.XX.XX.XX
每一个十进制数的范畴:0~255
ip地址的组成=网络地址+主机地址，比方:192.168.16.69
iPv6是互联网工程工作组设计的用于代替IPv4的下一代IP协定，其地址数量号称能够为全世界的每一粒沙子编上一个地址。
因为IPv4最大的问题在于网络地址资源无限，重大制约了互联网的利用和倒退。IPv6的应用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设施连入互联网的阻碍。

ipv4 地址分类

非凡的：127.0.0.1示意本机地址

域名

www.baidu.com
益处: 为了不便记忆，解决记ip的艰难
概念: 将ip地址映射成域名，这里怎么映射上——HTTP协定

端口号

概念: 用于标识计算机上某个特定的网络程序
示意模式: 以整数模式，端口范畴0~65535 [2个字节示意端口 0\~2^16-1]
0\~1024曾经被占用, 比方ssh 22, ftp 21, smtp 25 http 80
常见的网络程序端口号
- tomcat: 8080
- mysql: 3306
- oracle: 1521
- sqlserver: 1433

网络通信协定

协定(tcp/ip)

TCP/IP (Transmission Control Protocol/Internet Protocol) 的简写,中文译名为传输控制协议/因特网互联协定,又叫网络通讯协定,这个协定是lnternet最根本的协定、Internet国际互联网络的根底,简略地说,就是由网络层的IP协定和传输层的TCP协定组成的。

TCP 和 UDP

TCP协定:传输控制协议

应用TCP协定前,须先建设TCP连贯,造成传输数据通道
传输前,采纳“三次握手”形式,是牢靠的
TCP协定进行通信的两个利用过程: 客户端、服务端
在连贯中可进行大数据量的传输
传输结束，需开释已建设的连贯, 效率低

UDP协定:用户数据协定

将数据、源、目标封装成数据包,不须要建设连贯
每个数据报的大小限度在64K内,不适宜传输大量数据
因无需连贯,故是不牢靠的
发送数据完结时无需开释资源(因为不是面向连贯的)，速度快

InetAddress 类

相干办法

获取本机InetAddress对象getLocalHost
依据指定主机名/域名获取ip地址对象getByName
获取InetAddress对象的主机名getHostName
获取InetAddress对象的地址getHostAddress

利用案例

编写代码，获取计算机的主机名和IP 地址相干API

package com.hspedu.api;
import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * 演示InetAddress 类的应用
 */
public class API_ {
    public static void main(String[] args) throws UnknownHostException {

        //1. 获取本机的InetAddress 对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);//DESKTOP-S4MP84S/192.168.12.1

        //2. 依据指定主机名 获取 InetAddress对象
        InetAddress host1 = InetAddress.getByName("DESKTOP-S4MP84S");
        System.out.println("host1=" + host1);//DESKTOP-S4MP84S/192.168.12.1

        //3. 依据域名返回 InetAddress对象, 比方 www.baidu.com 对应
        InetAddress host2 = InetAddress.getByName("www.baidu.com");
        System.out.println("host2=" + host2);//www.baidu.com / 110.242.68.4

        //4. 通过 InetAddress 对象，获取对应的地址
        String hostAddress = host2.getHostAddress();//IP 110.242.68.4
        System.out.println("host2 对应的ip = " + hostAddress);//110.242.68.4

        //5. 通过 InetAddress 对象，获取对应的主机名/或者的域名
        String hostName = host2.getHostName();
        System.out.println("host2对应的主机名/域名=" + hostName); // www.baidu.com
    }
}

Socket

根本介绍

套接字(Socket)开发网络应用程序被宽泛采纳，以至于成为事实上的规范。
通信的两端都要有Socket，是两台机器间通信的端点。
网络通信其实就是Socket间的通信。
Socket容许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
个别被动发动通信的应用程序属客户端,期待通信申请的为服务端。

示意图

TCP 网络通信编程

根本介绍

基于客户端—服务端的网络通信
底层应用的是TCP/IP协定
利用场景举例: 客户端发送数据，服务端承受并显示控制台
基于Socket的TCP编程

最初须要敞开socket，不然链接太多会呈现问题。

利用案例1(应用字节流)

编写一个服务器端,和一个客户端
服务器端在9999端口监听
客户端连贯到服务器端,发送”hello, server”，而后退出
服务器端接管到客户端发送的信息，输入，并退出

ServerSocket 能够通过 accept() 返回多个Socket[多个客户端连贯服务器的并发]

package com.hspedu.socket;

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

/**
 * 客户端，发送 "hello, server" 给服务端
 */
public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 连贯服务端 (ip , 端口）
        //解读: 连贯本机的 9999端口, 如果连贯胜利，返回Socket对象
        // 如果链接网络，第一个参数能够改为IP
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回=" + socket.getClass());
        //2. 连贯上后，生成Socket, 通过socket.getOutputStream()
        //   失去 和 socket对象关联的输入流对象
        OutputStream outputStream = socket.getOutputStream();
        //3. 通过输入流，写入数据到 数据通道
        outputStream.write("hello, server".getBytes());
        //4. 敞开流对象和socket, 必须敞开
        outputStream.close();
        socket.close();
        System.out.println("客户端退出.....");
    }
}

package com.hspedu.socket;

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

/**
 * 服务端
 */
public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 在本机 的9999端口监听, 期待连贯
        //   细节: 要求在本机没有其它服务在监听9999
        //   细节：这个 ServerSocket 能够通过 accept() 返回多个Socket[多个客户端连贯服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，期待连贯..");
        //2. 当没有客户端连贯9999端口时，程序会 阻塞, 期待连贯
        //   如果有客户端连贯，则会返回Socket对象，程序持续

        Socket socket = serverSocket.accept();

        System.out.println("服务端 socket =" + socket.getClass());
        //
        //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();
        //4. IO读取
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLen));//依据读取到的理论长度，显示内容.
        }
        //5.敞开流和socket
        inputStream.close();
        socket.close();
        serverSocket.close();// 最初也须要敞开
    }
}

利用案例2(应用字节流)

编写一个服务端,和一个客户端。
服务器端在9999端口监听。
客户端连贯到服务端,发送”hello, server”,并接管服务器端回发的”hello,client”,再退出。
服务器端接管到客户端发送的信息,输入，并发送”hello, client”.再退出。

留神：设置完结标记。确保输入完结。

package com.hspedu.socket;

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

/**
 * 服务端
 */
@SuppressWarnings({"all"})
public class SocketTCP02Server {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 在本机 的9999端口监听, 期待连贯
        //   细节: 要求在本机没有其它服务在监听9999
        //   细节：这个 ServerSocket 能够通过 accept() 返回多个Socket[多个客户端连贯服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，期待连贯..");
        //2. 当没有客户端连贯9999端口时，程序会 阻塞, 期待连贯
        //   如果有客户端连贯，则会返回Socket对象，程序持续

        Socket socket = serverSocket.accept();

        System.out.println("服务端 socket =" + socket.getClass());
        //
        //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();
        //4. IO读取
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLen));//依据读取到的理论长度，显示内容.
        }
        //5. 获取socket相关联的输入流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello, client".getBytes());
        // 设置完结标记
        socket.shutdownOutput();

        //6.敞开流和socket
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();//敞开

    }
}

package com.hspedu.socket;

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

/**
 * 客户端，发送 "hello, server" 给服务端
 */
@SuppressWarnings({"all"})
public class SocketTCP02Client {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 连贯服务端 (ip , 端口）
        //解读: 连贯本机的 9999端口, 如果连贯胜利，返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回=" + socket.getClass());
        //2. 连贯上后，生成Socket, 通过socket.getOutputStream()
        //   失去 和 socket对象关联的输入流对象
        OutputStream outputStream = socket.getOutputStream();
        //3. 通过输入流，写入数据到 数据通道
        outputStream.write("hello, server".getBytes());
        //   设置完结标记
        socket.shutdownOutput();

        //4. 获取和socket关联的输出流. 读取数据(字节)，并显示
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLen));
        }

        //5. 敞开流对象和socket, 必须敞开
        inputStream.close();
        outputStream.close();
        socket.close();
        System.out.println("客户端退出.....");
    }
}

利用案例3(应用字符流)

编写一个服务端,和一个客户端
服务端在9999端口监听
客户端连贯到服务端，发送”hello, server”,并接管服务端回发的“hello,client”,，再退出
服务端接管到客户端发送的信息，输入，并发送”hello, client”，再退出

这里完结标记也能够采纳 writer.newLine();，然而这要求对方读取必须应用 readLine() 。

package com.hspedu.socket;

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

/**
 * 客户端，发送 "hello, server" 给服务端， 应用字符流
 */
@SuppressWarnings({"all"})
public class SocketTCP03Client {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 连贯服务端 (ip , 端口）
        //解读: 连贯本机的 9999端口, 如果连贯胜利，返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回=" + socket.getClass());
        //2. 连贯上后，生成Socket, 通过socket.getOutputStream()
        //   失去 和 socket对象关联的输入流对象
        OutputStream outputStream = socket.getOutputStream();
        //3. 通过输入流，写入数据到 数据通道, 应用字符流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello, server 字符流");
        bufferedWriter.newLine();//插入一个换行符，示意写入的内容完结, 留神，要求对方应用readLine()!!!!
        bufferedWriter.flush();// 如果应用的字符流，须要手动刷新，否则数据不会写入数据通道


        //4. 获取和socket关联的输出流. 读取数据(字符)，并显示
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);

        //5. 敞开流对象和socket, 必须敞开
        bufferedReader.close();//敞开外层流
        bufferedWriter.close();
        socket.close();
        System.out.println("客户端退出.....");
    }
}

package com.hspedu.socket;

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

/**
 * 服务端, 应用字符流形式读写
 */
@SuppressWarnings({"all"})
public class SocketTCP03Server {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 在本机 的9999端口监听, 期待连贯
        //   细节: 要求在本机没有其它服务在监听9999
        //   细节：这个 ServerSocket 能够通过 accept() 返回多个Socket[多个客户端连贯服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，期待连贯..");
        //2. 当没有客户端连贯9999端口时，程序会 阻塞, 期待连贯
        //   如果有客户端连贯，则会返回Socket对象，程序持续

        Socket socket = serverSocket.accept();

        System.out.println("服务端 socket =" + socket.getClass());
        //
        //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();
        //4. IO读取, 应用字符流, 老师应用 InputStreamReader 将 inputStream 转成字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);//输入

        //5. 获取socket相关联的输入流
        OutputStream outputStream = socket.getOutputStream();
       //    应用字符输入流的形式回复信息
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello client 字符流");
        bufferedWriter.newLine();// 插入一个换行符，示意回复内容的完结
        bufferedWriter.flush();//留神须要手动的flush

        //6.敞开流和socket
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();//敞开
    }
}

利用案例4

编写一个服务端,和一个客户端
服务器端在8888端口监听
客户端连贯到服务端,发送一张图片e:llqie.png
服务器端接管到客户端发送的图片，保留到src下,发送“收到图片”再退出
客户端接管到服务端发送的“收到图片”，再退出
该程序要求应用StreamUtils.java, 咱们间接应用其中封装好的办法。

package com.hspedu.upload;

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


/**
 * 文件上传的客户端
 */
public class TCPFileUploadClient {
    public static void main(String[] args) throws Exception {

        //客户端连贯服务端 8888，失去Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //创立读取磁盘文件的输出流
        //String filePath = "e:\\qie.png";
        String filePath = "e:\\abc.mp4";
        BufferedInputStream bis  = new BufferedInputStream(new FileInputStream(filePath));

        // 把文件读到字符数组中!!!!!
        // bytes 就是filePath对应的字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        //通过socket获取到输入流, 将bytes数据发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes); //将文件对应的字节数组的内容，写入到数据通道
        bis.close();
        socket.shutdownOutput(); //设置写入数据的完结标记

        //=====接管从服务端回复的音讯=====

        InputStream inputStream = socket.getInputStream();
        //应用StreamUtils 的办法，间接将 inputStream 读取到的内容 转成字符串
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);


        //敞开相干的流
        inputStream.close();
        bos.close();
        socket.close();

    }
}

package com.hspedu.upload;

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

/**
 * 文件上传的服务端
 */
public class TCPFileUploadServer {
    public static void main(String[] args) throws Exception {

        //1. 服务端在本机监听8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端在8888端口监听....");
        //2. 期待连贯
        Socket socket = serverSocket.accept();


        //3. 读取客户端发送的数据
        //   通过Socket失去输出流
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis); // 未然读到数组中了
        //4. 将失去 bytes 数组，写入到指定的门路，就失去一个文件了
        String destFilePath = "src\\abc.mp4";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.close();

        // 向客户端回复 "收到图片"
        // 通过socket 获取到输入流(字符)
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        writer.write("收到图片");
        writer.flush();//把内容刷新到数据通道
        socket.shutdownOutput();//设置写入完结标记

        //敞开其余资源
        writer.close();
        bis.close();
        socket.close();
        serverSocket.close();
    }
}

package com.hspedu.upload;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * 此类用于演示对于流的读写办法
 *
 */
public class StreamUtils {
   /**
    * 性能：将输出流转换成byte[]
    * @param is
    * @return
    * @throws Exception
    */
   public static byte[] streamToByteArray(InputStream is) throws Exception{
      ByteArrayOutputStream bos = new ByteArrayOutputStream();//创立输入流对象
      byte[] b = new byte[1024];
      int len;
      while((len=is.read(b))!=-1){
         bos.write(b, 0, len);// 读取道德数据写入bos
      }
      byte[] array = bos.toByteArray();
      bos.close();
      return array;
   }
   /**
    * 性能：将InputStream转换成String
    * @param is
    * @return
    * @throws Exception
    */
   
   public static String streamToString(InputStream is) throws Exception{
      BufferedReader reader = new BufferedReader(new InputStreamReader(is));
      StringBuilder builder= new StringBuilder();
      String line;
      while((line=reader.readLine())!=null){ //当读取到 null时，就示意完结
         builder.append(line+"\r\n");
      }
      return builder.toString();
      
   }

}

netstat 指令

netstat -an 能够查看以后主机网络状况，包含项口监听状况和网络连接状况
netstat -an | more 能够分页显示
netstat -anb （在管理员状态下运行）能够查看是哪些利用监听该端口。
内部地址就是连贯该本地地址和端口号的客户端的IP和端口号。

阐明:

(1) Listening示意某个端口在监听 Established 示意连贯曾经建设

(2)如果有一个内部程序(客户端)连贯到该端口，就会显示一条连贯信息

TCP 网络通讯

当客户端连贯到服务端后，实际上客户端也是通过一个端口和服务端进行通信的，这个端口是TCP/IP来调配的，是不确定的，是随机的。（客户端的端口）
程序验证+netstat

UDP 网络通信编程

根本介绍

类 DatagramSocket 和 DatagramPacket[数据包/数据报]实现了基于UDP
协定网络程序。
UDP数据报通过数据报套接字DatagramSocket 发送和接管，零碎不保障UDP数据报肯定可能平安送到目的地，也不能确定什么时候能够到达。
DatagramPacket 对象封装了UDP数据报，在数据报中蕴含了发送端的IP地址和
端口号以及接收端的IP地址和端口号。
UDP协定中每个数据报都给出了残缺的地址信息，因而毋庸建设发送方和接管方
的连贯

根本流程

外围的两个类/对象 DatagramSocket与DatagramPacket
建设发送端，接收端(没有服务端和客户端概念)
发送数据前,建设数据包/报 DatagramPacket对象
调用DatagramSocket的发送、接管办法
敞开DatagramSocket

利用案例

编写一个接收端A,和一个发送端B
接收端 A在 9999端口期待接收数据(receive)
发送端B向接收端A发送数据“hello，今天吃火锅~”
接收端A接管到发送端B发送的数据，回复”好的,今天见”再退出
发送端接管回复的数据,再退出

package com.hspedu.udp;

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

/**
 * UDP接收端
 */
public class UDPReceiverA {
    public static void main(String[] args) throws IOException {
        //1. 创立一个 DatagramSocket 对象，筹备在9999接收数据
        DatagramSocket socket = new DatagramSocket(9999);
        //2. 构建一个 DatagramPacket 对象，筹备接收数据
        //   在后面解说UDP 协定时，老师说过一个数据包最大 64k
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        //3. 调用 接管办法, 将通过网络传输的 DatagramPacket 对象
        //   填充到 packet对象
        //老师提醒: 当有数据包发送到 本机的9999端口时，就会接管到数据
        //   如果没有数据包发送到 本机的9999端口, 就会阻塞期待.
        System.out.println("接收端A 期待接收数据..");
        socket.receive(packet);

        //4. 能够把packet 进行拆包，取出数据，并显示.
        int length = packet.getLength();//理论接管到的数据字节长度
        byte[] data = packet.getData();//接管到数据
        String s = new String(data, 0, length);
        System.out.println(s);


        //===回复信息给B端
        //将须要发送的数据，封装到 DatagramPacket对象
        data = "好的, 今天见".getBytes();
        //阐明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
        packet =
                new DatagramPacket(data, data.length, InetAddress.getByName("192.168.12.1"), 9998);

        socket.send(packet);//发送

        //5. 敞开资源
        socket.close();
        System.out.println("A端退出...");

    }
}

package com.hspedu.udp;

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

/**
 * 发送端B ====> 也能够接收数据
 */
@SuppressWarnings({"all"})
public class UDPSenderB {
    public static void main(String[] args) throws IOException {

        //1.创立 DatagramSocket 对象，筹备在9998端口 接收数据
        DatagramSocket socket = new DatagramSocket(9998);

        //2. 将须要发送的数据，封装到 DatagramPacket对象
        byte[] data = "hello 今天吃火锅~".getBytes(); //

        //阐明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
        DatagramPacket packet =
                new DatagramPacket(data, data.length, InetAddress.getByName("192.168.12.1"), 9999);

        socket.send(packet);

        //3.=== 接管从A端回复的信息
        //(1)   构建一个 DatagramPacket 对象，筹备接收数据
        //   在后面解说UDP 协定时，老师说过一个数据包最大 64k
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        //(2)    调用 接管办法, 将通过网络传输的 DatagramPacket 对象
        //   填充到 packet对象
        //老师提醒: 当有数据包发送到 本机的9998端口时，就会接管到数据
        //   如果没有数据包发送到 本机的9998端口, 就会阻塞期待.
        socket.receive(packet);

        //(3)  能够把packet 进行拆包，取出数据，并显示.
        int length = packet.getLength();//理论接管到的数据字节长度
        data = packet.getData();//接管到数据
        String s = new String(data, 0, length);
        System.out.println(s);

        //敞开资源
        socket.close();
        System.out.println("B端退出");
    }
}

本章作业

1.编程题

(1)应用字符流的形式,编写一个客户端程序和服务器端程序，

(2)客户端发送“name”服务器端接管到后，返回“我是nova “, nova是你本人的名字.

(3)客户端发送”hobby”，服务器端接管到后，返回“编写java程序”

(4)不是这两个问题，回复“你说啥呢”

问题:目前，咱们只能问一次，就退出了，怎么能够问屡次?->while ->聊天

package com.hspedu.homework;

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

/**
 * 客户端，发送 "hello, server" 给服务端， 应用字符流
 */
@SuppressWarnings({"all"})
public class Homework01Client {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 连贯服务端 (ip , 端口）
        //解读: 连贯本机的 9999端口, 如果连贯胜利，返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //2. 连贯上后，生成Socket, 通过socket.getOutputStream()
        //   失去 和 socket对象关联的输入流对象
        OutputStream outputStream = socket.getOutputStream();
        //3. 通过输入流，写入数据到 数据通道, 应用字符流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));

        //从键盘读取用户的问题
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输出你的问题");
        String question = scanner.next();

        bufferedWriter.write(question);
        bufferedWriter.newLine();//插入一个换行符，示意写入的内容完结, 留神，要求对方应用readLine()!!!!
        bufferedWriter.flush();// 如果应用的字符流，须要手动刷新，否则数据不会写入数据通道


        //4. 获取和socket关联的输出流. 读取数据(字符)，并显示
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);

        //5. 敞开流对象和socket, 必须敞开
        bufferedReader.close();//敞开外层流
        bufferedWriter.close();
        socket.close();
        System.out.println("客户端退出.....");
    }
}

package com.hspedu.homework;

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

/**
 * 服务端, 应用字符流形式读写
 */
@SuppressWarnings({"all"})
public class Homework01Server {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 在本机 的9999端口监听, 期待连贯
        //   细节: 要求在本机没有其它服务在监听9999
        //   细节：这个 ServerSocket 能够通过 accept() 返回多个Socket[多个客户端连贯服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，期待连贯..");
        //2. 当没有客户端连贯9999端口时，程序会 阻塞, 期待连贯
        //   如果有客户端连贯，则会返回Socket对象，程序持续

        Socket socket = serverSocket.accept();

        //
        //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();
        //4. IO读取, 应用字符流, 老师应用 InputStreamReader 将 inputStream 转成字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        String answer = "";
        if ("name".equals(s)) {
            answer = "我是韩顺平";
        } else if("hobby".equals(s)) {
            answer = "编写java程序";
        } else {
            answer = "你说的啥子";
        }


        //5. 获取socket相关联的输入流
        OutputStream outputStream = socket.getOutputStream();
        //    应用字符输入流的形式回复信息
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write(answer);
        bufferedWriter.newLine();// 插入一个换行符，示意回复内容的完结
        bufferedWriter.flush();//留神须要手动的flush


        //6.敞开流和socket
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();//敞开

    }
}

2.编程题

(1)编写一个接收端A,和一个发送端B,应用UDP协定实现

(2)接收端在8888端口期待接收数据(receive)

(3)发送端向接收端发送数据“四大名著是哪些”

(4)接收端接管到发送端发送的问题后，返回“四大名著是<<红楼梦>>.….”，否则返回what?

(5)接收端和发送端程序退出

package com.hspedu.homework;

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

/**
 * 发送端B ====> 也能够接收数据
 */
@SuppressWarnings({"all"})
public class Homework02SenderB {
    public static void main(String[] args) throws IOException {

        //1.创立 DatagramSocket 对象，筹备在9998端口 接收数据
        DatagramSocket socket = new DatagramSocket(9998);

        //2. 将须要发送的数据，封装到 DatagramPacket对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输出你的问题: ");
        String question = scanner.next();
        byte[] data = question.getBytes(); //

        //阐明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
        DatagramPacket packet =
                new DatagramPacket(data, data.length, InetAddress.getByName("192.168.12.1"), 8888);

        socket.send(packet);

        //3.=== 接管从A端回复的信息
        //(1)   构建一个 DatagramPacket 对象，筹备接收数据
        //   在后面解说UDP 协定时，老师说过一个数据包最大 64k
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        //(2)    调用 接管办法, 将通过网络传输的 DatagramPacket 对象
        //   填充到 packet对象
        //老师提醒: 当有数据包发送到 本机的9998端口时，就会接管到数据
        //   如果没有数据包发送到 本机的9998端口, 就会阻塞期待.
        socket.receive(packet);

        //(3)  能够把packet 进行拆包，取出数据，并显示.
        int length = packet.getLength();//理论接管到的数据字节长度
        data = packet.getData();//接管到数据
        String s = new String(data, 0, length);
        System.out.println(s);

        //敞开资源
        socket.close();
        System.out.println("B端退出");
    }
}

package com.hspedu.homework;

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

/**
 * UDP接收端
 */
@SuppressWarnings({"all"})
public class Homework02ReceiverA {
    public static void main(String[] args) throws IOException {
        //1. 创立一个 DatagramSocket 对象，筹备在8888接收数据
        DatagramSocket socket = new DatagramSocket(8888);
        //2. 构建一个 DatagramPacket 对象，筹备接收数据
        //   在后面解说UDP 协定时，老师说过一个数据包最大 64k
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        //3. 调用 接管办法, 将通过网络传输的 DatagramPacket 对象
        //   填充到 packet对象
        System.out.println("接收端 期待接管问题 ");
        socket.receive(packet);

        //4. 能够把packet 进行拆包，取出数据，并显示.
        int length = packet.getLength();//理论接管到的数据字节长度
        byte[] data = packet.getData();//接管到数据
        String s = new String(data, 0, length); // 将字节数组转为string!!!!
        //判断接管到的信息是什么
        String answer = "";
        if("四大名著是哪些".equals(s)) {
            answer = "四大名著 <<红楼梦>> <<三国演示>> <<西游记>> <<水浒传>>";
        } else {
            answer = "what?";
        }


        //===回复信息给B端
        //将须要发送的数据，封装到 DatagramPacket对象
        data = answer.getBytes();
        //阐明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
        packet =
                new DatagramPacket(data, data.length, InetAddress.getByName("192.168.12.1"), 9998);

        socket.send(packet);//发送

        //5. 敞开资源
        socket.close();
        System.out.println("A端退出...");

    }
}

3.编程题

(1)编写客户端程序和服务器端程序

(2)客户端能够输出一个音乐文件名，比方高山流水, 服务端收到音乐名后，能够给客户端返回这个音乐文件，如果服务器没有这个文件，返回一个默认的音乐即可。

(3)客户端收到文件后，保留到本地e:\\

(4)提醒:该程序能够应用 StreamUtils.java

package com.hspedu.homework;

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

/**
 * 文件下载的客户端
 */
public class Homework03Client {
    public static void main(String[] args) throws Exception {


        //1. 接管用户输出，指定下载文件名
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输出下载文件名");
        String downloadFileName = scanner.next();

        //2. 客户端连贯服务端，筹备发送
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        //3. 获取和Socket关联的输入流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(downloadFileName.getBytes());
        //设置写入完结的标记
        socket.shutdownOutput();

        //4. 读取服务端返回的文件(字节数据)
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //5. 失去一个输入流，筹备将 bytes 写入到磁盘文件
        //比方你下载的是 高山流水 => 下载的就是 高山流水.mp3
        //    你下载的是 无名 => 下载的就是 无名.mp3
        String filePath = "e:\\" + downloadFileName + ".mp3";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
        bos.write(bytes);

        //6. 敞开相干的资源
        bos.close();
        bis.close();
        outputStream.close();
        socket.close();

        System.out.println("客户端下载结束，正确退出..");


    }
}

package com.hspedu.homework;

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

/**
 * 先写文件下载的服务端
 */
public class Homework03Server {
    public static void main(String[] args) throws Exception {

        //1 监听 9999端口
        ServerSocket serverSocket = new ServerSocket(9999);
        //2.期待客户端连贯
        System.out.println("服务端，在9999端口监听，期待下载文件");
        Socket socket = serverSocket.accept();
        //3.读取 客户端发送要下载的文件名
        //  这里老师应用了while读取文件名，时思考未来客户端发送的数据较大的状况
        InputStream inputStream = socket.getInputStream();
        byte[] b = new byte[1024];
        int len = 0;
        String downLoadFileName = "";
        while ((len = inputStream.read(b)) != -1) {
            downLoadFileName += new String(b, 0 , len);
        }
        System.out.println("客户端心愿下载文件名=" + downLoadFileName);

        //老师在服务器上有两个文件, 无名.mp3 高山流水.mp3
        //如果客户下载的是 高山流水 咱们就返回该文件，否则一律返回 无名.mp3

        String resFileName = "";
        if("高山流水".equals(downLoadFileName)) {
            resFileName = "src\\高山流水.mp3";
        } else {
            resFileName = "src\\无名.mp3";
        }

        //4. 创立一个输出流，读取文件
        BufferedInputStream bis =
                new BufferedInputStream(new FileInputStream(resFileName));

        //5. 应用工具类StreamUtils ，读取文件到一个字节数组

        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //6. 失去Socket关联的输入流
        BufferedOutputStream bos =
                new BufferedOutputStream(socket.getOutputStream());
        //7. 写入到数据通道，返回给客户端
        bos.write(bytes);
        socket.shutdownOutput();//很要害.

        //8 敞开相干的资源
        bis.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出...");

    }
}

package com.hspedu.homework;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * 此类用于演示对于流的读写办法
 *
 */
public class StreamUtils {
   /**
    * 性能：将输出流转换成byte[]
    * @param is
    * @return
    * @throws Exception
    */
   public static byte[] streamToByteArray(InputStream is) throws Exception{
      ByteArrayOutputStream bos = new ByteArrayOutputStream();//创立输入流对象
      byte[] b = new byte[1024];
      int len;
      while((len=is.read(b))!=-1){
         bos.write(b, 0, len);  
      }
      byte[] array = bos.toByteArray();
      bos.close();
      return array;
   }
   /**
    * 性能：将InputStream转换成String
    * @param is
    * @return
    * @throws Exception
    */
   
   public static String streamToString(InputStream is) throws Exception{
      BufferedReader reader = new BufferedReader(new InputStreamReader(is));
      StringBuilder builder= new StringBuilder();
      String line;
      while((line=reader.readLine())!=null){
         builder.append(line+"\r\n");
      }
      return builder.toString();
   }
}

关于java:Java-网络编程详解

网络的相干概念

网络通信

网络

ip 地址

ipv4 地址分类

域名

网络通信协定

TCP 和 UDP

InetAddress 类

相干办法

利用案例

Socket

根本介绍

TCP 网络通信编程

根本介绍

利用案例1(应用字节流)

利用案例2(应用字节流)

利用案例3(应用字符流)

利用案例4

netstat 指令

TCP 网络通讯

UDP 网络通信编程

根本介绍

根本流程

利用案例

本章作业

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于java:Java-网络编程详解

网络的相干概念

网络通信

网络

ip 地址

ipv4 地址分类

域名

网络通信协定

TCP 和 UDP

InetAddress 类

相干办法

利用案例

Socket

根本介绍

TCP 网络通信编程

根本介绍

利用案例1(应用字节流)

利用案例2(应用字节流)

利用案例3(应用字符流)

利用案例4

netstat 指令

TCP 网络通讯

UDP 网络通信编程

根本介绍

根本流程

利用案例

本章作业

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复