网络编程

image.png
端口号是用两个字节（16位的二进制数）表示的，它的取值范围是0~65535，其中，0~1023之间的端口号用于一些知名的网络服务和应用，用户的普通应用程序需要使用1024以上的端口号，从而避免端口号被另外一个应用或服务所占用。

  1. package com.igeek_01;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-16-10:20
  6.  */
  8. import java.net.InetAddress;
  9. import java.net.UnknownHostException;
  11. /**
  12.  * 凡是.net包下的内容都是关于网络的api
  13.  */
  14. public class IPDemo {
  15.     public static void main(String[] args) throws UnknownHostException {
  16.         //获取本地IP地址
  17.         InetAddress localhost=InetAddress.getLocalHost();
  18.         System.out.println(localhost);//Lynn/192.168.2.184
  20.         //获取字符串类型的IP
  21.         String hostname=localhost.getHostName();
  22.         System.out.println(hostname);//Lynn
  24.         String hostAddress=localhost.getHostAddress();
  25.         System.out.println(hostAddress);//192.168.2.184
  27.         //获取其他IP地址
  28.         InetAddress byName=InetAddress.getByName("Lynn");
  29.         System.out.println(byName);//Lynn/192.168.2.184
  30.     }
  31. }

UDP

image.png
发送和接收均可以使用的Socket类：

  1.     DatagramSocket

  • 数据打包的相关类：

    1.   DatagramPacket


  • 使用UDP接收数据的步骤：
    1.   1、建立接收端；
    1.       public DatagramSocket(int port):    指定程序端口号，方便发送端寻找
    1.   2、建立数据包，用于接收数据；
    1.       public DatagramPacket(byte[] buf, int length)
    1.   3、调用Socket的接收方法；
    1.   4、解析数据    ；
    1.       public byte[] getData():    获取数据报包中的数据
    1.       public int getLength()：        获取数据报包中的数据长度
    1.       public InetAddress getAddress():    获取发送方的IP
    1.       public int getPort()：        获取发送方的端口号
    1.   5、关闭Socket。

    案例1

    ```java package com.igeek_02;

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

/**

  • UDP是一个传输协议 *

  • 当前的服务器端用于接收数据 */ public class UDPService { public static void main(String[] args) throws IOException {

    1.  //建立连接
    2.  DatagramSocket ds=new DatagramSocket(123);
    4.  //建立数据包，用于接收数据
    5.  byte[] bytes=new byte[1024];
    6.  DatagramPacket dp=new DatagramPacket(bytes, bytes.length);
    8.  //调用socket方法接收数据
    9.  ds.receive(dp);
    11.  //解析数据--针对数据包进行解析
    12.  InetAddress sendAddress=dp.getAddress();
    13.  String sendIP=sendAddress.getHostAddress();
    14.  int sendPort=dp.getPort();//端口号
    16.  //获取数据包中的数据
    17.  byte[] data=dp.getData();
    18.  int length=dp.getLength();
    20.  //将字节数组转换成字符串--String的构造函数
    21.  String s = new String(data, 0, length);
    23.  //输出
    24.  System.out.println("接收到来自"+sendIP+"的，端口号为"+sendPort+"的数据"+ s);
    26.  //关闭
    27.  ds.close();

    } } java package com.igeek_02;

/**

  • @author Lynn
  • @create 2020-12-16-11:21 */

import java.net.*;

/**

  • 发送端 */ public class UDPSend { public static void main(String[] args) throws Exception, UnknownHostException {

    1.  //建立连接
    2.  DatagramSocket ds=new DatagramSocket();
    4.  //创建数据
    5.  String s="I Love Java";
    7.  //数据打包
    8.  byte[] data=s.getBytes();//将字符串转化为字节数组
    9.  int length= data.length;
    10.  InetAddress address=InetAddress.getByName("192.168.2.184");
    11.  int port=123;//必须与接收端的一致
    12.  DatagramPacket dp=new DatagramPacket(data,length,address,port);
    14.  //调用方法进行发送
    15.  ds.send(dp);
    17.  //关闭连接
    18.  ds.close();

    } } ```

    案例2

    ```java package com.igeek_03;

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

/**

  • UDP是一个传输协议 *

  • 当前的服务器端用于循环接收数据 */ public class UDPService { public static void main(String[] args) throws IOException {

    1.  //建立连接
    2.  DatagramSocket ds=new DatagramSocket(123);
    4.  //反复接收数据
    5.  while (true){
    6.      //建立数据包，用于接收数据
    7.      byte[] bytes=new byte[1024];
    8.      DatagramPacket dp=new DatagramPacket(bytes, bytes.length);
    10.      //调用socket方法接收数据
    11.      ds.receive(dp);
    13.      //解析数据--针对数据包进行解析
    14.      InetAddress sendAddress=dp.getAddress();
    15.      String sendIP=sendAddress.getHostAddress();
    16.      int sendPort=dp.getPort();//端口号
    18.      //获取数据包中的数据
    19.      byte[] data=dp.getData();
    20.      int length=dp.getLength();
    22.      //将字节数组转换成字符串--String的构造函数
    23.      String s = new String(data, 0, length);
    25.      //输出
    26.      System.out.println("接收到来自"+sendIP+"的，端口号为"+sendPort+"的数据："+ s);
    27.  }
    29.  /*//关闭
    30.  ds.close();*/

    } } java package com.igeek_03;

/**

  • @author Lynn
  • @create 2020-12-16-11:21 */

import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.UnknownHostException; import java.util.Scanner;

/**

  • 发送端 */ public class UDPSend { public static void main(String[] args) throws Exception, UnknownHostException {

    1.  //建立连接
    2.  DatagramSocket ds=new DatagramSocket();
    4.  //循环发送
    5.  while (true){
    6.      //创建数据--灵活的数据
    7.      Scanner sc=new Scanner(System.in);
    8.      System.out.println("请输入数据：");
    9.      String s=sc.next();
    11.      //数据打包
    12.      byte[] data=s.getBytes();//将字符串转化为字节数组
    13.      int length= data.length;
    14.      InetAddress address=InetAddress.getByName("192.168.2.184");
    15.      int port=123;//必须与接收端的一致
    16.      DatagramPacket dp=new DatagramPacket(data,length,address,port);
    18.      //调用方法进行发送
    19.      ds.send(dp);
    21.      /*//关闭连接
    22.      ds.close();*/
    23.  }

    } } ```

    练习

    ```java package Test01;

/**

  • @author Lynn
  • @create 2020-12-16-20:19 */

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

/**

  • 一、 项目需求：请用户完成一个UDP接收端作为模拟网络聊天室的操作。
  • 1:创建UDP传输下的聊天室发送端UDPSend类
  • 2: 创建UDP传输下的聊天室接收端 Room类
  • 1.2． 操作步骤描述
    1. 建立项目目录：day14作业_Test2_1
    1. 创建UDPSend类，并包含main()方法；
  • 在该main方法中
  • a、建立UDP的Socket服务；
  • b、将要发送的数据封装到数据包中；
  • c、通过UDP的Socket服务将数据包发送出去；
  • d、关闭Socket服务
    1. 创建Room类 使用UDP接收端实现网络聊天效果
  • 该类中写main方法 步骤如下
  • a、建立UDP的Socket服务，因为要接收数据，所以必须明确一个端口号；
  • 添加while(ture)循环，不断的循环接收内容
  • b、创建数据包，用于存储接收到的数据，方便用数据包对象的方法解析这些数据；
  • c、使用UDP的Socket服务的receive方法接收数据并存储到数据包中；

  • d、通过数据包的方法解析这些数据； */ public class UDPSend { public static void main(String[] args) throws IOException { //建立UDP的Socket服务 DatagramSocket datagramSocket=new DatagramSocket();

    //将数据存放到数据包 //循环发送 while (true){ Scanner sc=new Scanner(System.in); System.out.println(“请输入数据：”); String s=sc.next();

    //打包数据 byte[] bytes=s.getBytes();//将字符串转换为字节数组 int length= bytes.length; InetAddress inetAddress=InetAddress.getByName(“192.168.2.184”); int port=8888; DatagramPacket dp=new DatagramPacket(bytes,length,inetAddress,port);

    //发送 datagramSocket.send(dp);

    ///关闭服务 datagramSocket.close();/ }

    } } java package Test01;

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

/**

  • @author Lynn

  • @create 2020-12-16-20:38 */ public class Room { public static void main(String[] args) throws IOException {

    1.  //建立连接
    2.  DatagramSocket ds=new DatagramSocket(8888);
    4.  //不断循环接收数据
    5.  while (true){
    6.      //创建数据包接收数据
    7.      byte[] bytes=new byte[1024];
    8.      DatagramPacket dp=new DatagramPacket(bytes, bytes.length);
    10.      //接收数据包
    11.      ds.receive(dp);
    13.      //解析数据
    14.      InetAddress sendAddress=dp.getAddress();
    15.      String sendIP= sendAddress.getHostAddress();
    16.      int port=dp.getPort();
    18.      //存入
    19.      byte[] data=dp.getData();
    20.      int length= dp.getLength();
    22.      //将字节数组转换为字符串
    23.      String s=new String(data,0,length);
    25.      System.out.println("接收到来自"+sendIP+"的，端口号为："+port+"的数据："+s);
    27.  }

    } } ```

    网络模型

    网络模型是计算机网络通讯规范，一般符合以下规则：
    OSI（Open System Interconnection开放系统互连）参考模型；
    TCP/IP参考模型。
    image.png

    TCP协议

    image.png

    案例1

    ```java package com.igeek_04;

/**

  • @author Lynn
  • @create 2020-12-16-14:23 */

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

/**

  • 当前案例演示客户端发送信息，服务器端接收信息 */ public class Server { public static void main(String[] args) throws Exception {

    1.  //建立服务器端
    2.  ServerSocket serverSocket=new ServerSocket(8888);
    4.  //当前是服务器端，所以先获取IO流的同时需要等待客户端发送数据过来
    5.  Socket socket= serverSocket.accept();
    7.  //建立连接之后，通过Socket中的IO流进行数据传输
    8.  InputStream inputStream = socket.getInputStream();
    9.  //读取的是一个字节
    10.  int read = inputStream.read();
    11.  System.out.println((char)read);
    13.  //关闭--两个都要关闭
    14.  socket.close();
    15.  serverSocket.close();

    } } java package com.igeek_04;

/**

  • @author Lynn
  • @create 2020-12-16-14:29 */

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

/**

  • 客户端 *1.建立客户端
  • 2.连接后，通过socket中的流进行传输

  • 3.关闭 */ public class Client { public static void main(String[] args) throws Exception {

    1.  //建立客户端
    2.  Socket socket=new Socket("127.0.0.1",8888);
    4.  //建立连接后开始传输
    5.  OutputStream outputStream=socket.getOutputStream();
    7.  //输出数据
    8.  outputStream.write(97);
    10.  //关闭
    11.  outputStream.close();

    } } ```

    案例2—演示跟同桌的初步信息传输

    ```java package com.igeek_05;

/**

  • @author Lynn
  • @create 2020-12-16-14:23 */

import java.io.InputStream; import java.io.OutputStream; import java.net.ServerSocket; import java.net.Socket; import java.util.Scanner;

/**

  • 当前案例演示客户端发送信息，服务器端接收信息 */ public class Server { public static void main(String[] args) throws Exception {

    1.  //建立服务器端
    2.  ServerSocket serverSocket=new ServerSocket(8888);
    4.  //当前是服务器端，所以先获取IO流的同时需要等待客户端发送数据过来
    5.  Socket socket= serverSocket.accept();
    7.  //建立连接之后，通过Socket中的IO流进行数据传输
    8.  InputStream inputStream = socket.getInputStream();
    10.  //反复读取客户端发送的数据
    11.  int read=-1;
    12.  while ((read=inputStream.read())!=-1){
    13.      System.out.print((char)read);
    14.  }
    16.  //接收客户端数据后要返回一个o给客户端
    17.  while (true){
    18.      OutputStream outputStream=socket.getOutputStream();
    19.      Scanner sc=new Scanner(System.in);
    20.      System.out.println("请输入数据：");
    21.      String content=sc.next();
    22.      outputStream.write(content.getBytes());//将字符串转化为字节传输
    23.  }
  1.     /*//关闭--两个都要关闭
  2.     socket.close();
  3.     serverSocket.close();*/
  5. }

}

  1. ```java
  2. package com.igeek_05;
  4. /**
  5.  * @author Lynn
  6.  * @create 2020-12-16-14:29
  7.  */
  9. import java.io.InputStream;
  10. import java.io.OutputStream;
  11. import java.net.Socket;
  12. import java.util.Scanner;
  14. /**
  15.  * 客户端
  16.  *1.建立客户端
  17.  * 2.连接后，通过socket中的流进行传输
  18.  * 3.关闭
  19.  *
  20.  * 改进：
  21.  * 客户端发送一个字符串：I Love Java信息，接收服务器端返回的一个字母o的响应
  22.  *
  23.  * void shutdownoutput():禁止输出流，告知对方
  24.  */
  25. public class Client {
  26.     public static void main(String[] args) throws Exception {
  27.         //建立客户端
  28.         Socket socket=new Socket("192.168.2.181",8888);
  30.         //建立连接后开始传输
  31.         OutputStream outputStream=socket.getOutputStream();
  33.         //输出数据
  34.         while (true){
  35.             Scanner sc=new Scanner(System.in);
  36.             System.out.println("请输入数据：");
  37.             String content=sc.next();
  38.             outputStream.write(content.getBytes());//将字符串转换为字节数组
  40.             //告诉服务器，不需要发送数据了
  41.             socket.shutdownOutput();
  42.             //获取服务器端的响应
  43.             InputStream inputStream= socket.getInputStream();
  44.             byte[] bytes=new byte[1024];
  45.             int len=-1;
  46.             while ((len= inputStream.read(bytes))!=-1){
  47.                 String s=new String(bytes,0,len);
  48.                 System.out.print(s);
  49.             }
  52.             /*//关闭
  53.             outputStream.close();*/
  54.         }
  56.     }
  57. }

练习1

  1. package Test02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-16-20:48
  6.  */
  8. import java.io.IOException;
  9. import java.io.InputStream;
  10. import java.net.ServerSocket;
  11. import java.net.Socket;
  13. /**
  14.  * 一、    需求说明：使用TCP编写一个网络程序,设置服务器程序监听端口为8002,当于客户端建立后,向客户端发送”hello world”,客户端将信息输出
  15.  * 2.2． 操作步骤描述
  16.  * 1.    建立项目：day14作业_Test2_2
  17.  * 2.    创建TCPServer类,包含main()方法
  18.  *  使用ServerSocket创建服务器对象,监听8002端口,调用accept()方法等待客户端连接,当于客户端连接上之后,获取输出流对象,输出”hello world”
  19.  * 3.    创建TCPClient类，包含main()方法
  20.  * 使用Socket创建客户端对象,指定服务器IP和端口号,与服务器端建立连接后,获取输入流对象,读取数据,并打印.
  21.  */
  22. public class TCPServer {
  23.     public static void main(String[] args) throws IOException {
  24.         //创建服务器对象，建立连接
  25.         ServerSocket serverSocket=new ServerSocket(8002);
  27.         //调用accept方法
  28.         Socket socket= serverSocket.accept();
  30.         //获取socket的io流
  31.         InputStream in= socket.getInputStream();
  33.         //读取数据
  34.         byte[] bytes=new byte[1024];
  35.         int len=-1;
  36.         while ((len=in.read(bytes))!=-1){
  37.             String s=new String(bytes,0,len);
  38.             System.out.println(s);
  39.         }
  41. //        in.close();
  42.         socket.close();
  43.         serverSocket.close();
  44.     }
  45. }
  1. package Test02;
  3. import java.io.IOException;
  4. import java.io.OutputStream;
  5. import java.net.Socket;
  7. /**
  8.  * @author Lynn
  9.  * @create 2020-12-16-20:49
  10.  */
  11. public class TCPClient {
  12.     public static void main(String[] args) throws IOException {
  13.         //建立连接
  14.         Socket socket=new Socket("192.168.2.184",8002);
  16.         //获取流对象
  17.         OutputStream out= socket.getOutputStream();
  19.         //输入数据
  20.         String s="hello world";
  21.         byte[] bytes=s.getBytes();
  22.         out.write(bytes);
  24.         out.close();
  25.         socket.close();
  26.     }
  27. }

案例3—文件上传

  1. package com.igeek_06;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-16-15:13
  6.  */
  8. import java.io.FileOutputStream;
  9. import java.io.IOException;
  10. import java.io.InputStream;
  11. import java.io.OutputStream;
  12. import java.net.ServerSocket;
  13. import java.net.Socket;
  15. /**
  16.  * 文件上传，服务器端接收到客户端文件中的数据，向服务器端的另一个文件中写出
  17.  * 接收到文件内容，写到某个文件中
  18.  *
  19.  * 这里的数据是文件中的内容
  20.  */
  21. public class Server {
  22.     public static void main(String[] args) throws Exception {
  23.         //建立服务器端
  24.         ServerSocket serverSocket=new ServerSocket(8888);
  26.         //获取流
  27.         Socket socket = serverSocket.accept();
  29.         //建立连接以后获取socket的流
  30.         InputStream inputStream=socket.getInputStream();
  31.         //获取到上传文件的内容，要有一个文件
  32.         FileOutputStream fos=new FileOutputStream("面向对象堂测答案-copy.docx");
  33.         //反复使用一个字节读取
  34.         int len=-1;
  35.         while ((len= inputStream.read())!=-1){
  36.             //一次读取一个字节，最终这个文件接受了所有的上传数据
  37.             fos.write(len);
  38.         }
  39.         //关闭IO流
  40.         fos.close();
  42.         //给客户端返回一个响应
  43.         OutputStream out= socket.getOutputStream();
  44.         String content="o";
  45.         out.write(content.getBytes());
  47.         //关闭socket
  48.         socket.close();
  49.         serverSocket.close();
  50.     }
  51. }
  1. package com.igeek_06;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-16-15:13
  6.  */
  8. import java.io.FileInputStream;
  9. import java.io.IOException;
  10. import java.io.InputStream;
  11. import java.io.OutputStream;
  12. import java.net.Socket;
  14. /**
  15.  * 上传文件
  16.  * 读取文件内容，发送给服务器端
  17.  */
  18. public class Client {
  19.     public static void main(String[] args) throws Exception {
  20.         //建立客户端
  21.         Socket socket=new Socket("localhost",8888);
  23.         //建立连接后，获取socket的流
  24.         OutputStream out= socket.getOutputStream();
  25.         //获取文件对象
  26.         FileInputStream fis=new FileInputStream("面向对象堂测答案.docx");
  27.         //读取文件内容
  28.         int len=-1;
  29.         while ((len= fis.read())!=-1){
  30.             //输出数据给服务器
  31.             out.write(len);
  32.         }
  34.         //关闭流
  35.         fis.close();
  37.         //告知服务器，不再发送数据
  38.         socket.shutdownOutput();
  40.         //获取输入流，接收服务器端的响应
  41.         InputStream in= socket.getInputStream();
  42.         int read= in.read();
  43.         System.out.println((char)read);
  45.         socket.close();
  46.     }
  47. }

练习2

  1. /**
  2.  * @author Lynn
  3.  * @create 2020-12-16-21:08
  4.  */
  6. import java.io.*;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  10. /**
  11.  * 一、    需求说明：我们来做一个“文件上传案例”，有以下要求：
  12.  * 将项目中的一个图片,通过客户端上传至服务器
  13.  * 1.2． 操作步骤描述
  14.  *  1,创建服务器，等待客户端连接
  15.  *  2,创建客户端Socket，连接服务器
  16.  *      3,获取Socket流中的输出流，功能：用来把数据写到服务器
  17.  * 4,创建字节输入流，功能：用来读取数据源(图片)的字节
  18.  * 5,把图片数据写到Socket的输出流中(把数据传给服务器)
  19.  * 6,客户端发送数据完毕，结束Socket输出流的写入操作，告知服务器端
  20.  * 7,获取Socket的输入流
  21.  * 8,创建目的地的字节输出流
  22.  * 9,把Socket输入流中的数据，写入目的地的字节输出流中
  23.  * 10,获取Socket的输出流, 作用：写反馈信息给客户端
  24.  * 11,写反馈信息给客户端
  25.  * 12,获取Socket的输入流  作用： 读反馈信息
  26.  * 13,读反馈信息
  27.  */
  28. public class Server {
  29.     public static void main(String[] args) throws IOException {
  30.         //创建服务器，建立连接
  31.         ServerSocket serverSocket=new ServerSocket(8888);
  33.         //调用socket的接收方法
  34.         Socket socket=serverSocket.accept();
  36.         //接收socket的IO流
  37.         InputStream inputStream= socket.getInputStream();
  38.         //创建字节输出流
  39.         FileOutputStream fos=new FileOutputStream("jackson2-1.jpg");
  41.         //读取流中的内容
  42.         int len=-1;
  43.         while ((len= inputStream.read())!=-1){
  44.             fos.write(len);
  45.         }
  46.         fos.close();
  48.         //服务端接收到数据后给客户端一个响应
  49.         OutputStream out= socket.getOutputStream();
  50.         String s="over";
  51.         out.write(s.getBytes());
  53.         serverSocket.close();
  54.         socket.close();
  56.     }
  57. }
  1. import java.io.FileInputStream;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.io.OutputStream;
  5. import java.net.Socket;
  7. /**
  8.  * @author Lynn
  9.  * @create 2020-12-16-21:08
  10.  */
  11. public class Socker {
  12.     public static void main(String[] args) throws IOException {
  13.         //创建连接
  14.         Socket socket=new Socket("127.0.0.1",8888);
  16.         //获取流
  17.         OutputStream outputStream= socket.getOutputStream();
  19.         //读取文件内容
  20.         FileInputStream fis=new FileInputStream("jackson2.jpg");
  22.         int len=-1;
  23.         while ((len= fis.read())!=-1){
  24.             outputStream.write(len);
  25.         }
  26.         fis.close();
  28.         //告知服务器不再发送数据了
  29.         socket.shutdownOutput();
  31.         //客户端接收服务端的响应
  32.         InputStream inputStream= socket.getInputStream();
  33.         int length=-1;
  34.         while ((length= inputStream.read())!=-1){
  35.             System.out.print((char)length);
  36.         }
  38.         socket.close();
  39.     }
  40. }