什么是网络编程？

基于网络通信协议的编程，这类编程是以网络通信协议为基础的。

网络通信的要素：

通信双方的地址：
1、ip ， 端口号
2、网络通信协议 TCP，UDP

IP：

唯一确定网络上的一台计算机
本机：127.0.0.1 或 loalhost

端口号：

所谓的端口，就好像是门牌号一样，客户端可以通过ip地址找到对应的服务器端，但是服务器端是有很多端口的，每个应用程序对应一个端口号，通过类似门牌号的端口号，客户端才能真正的访问到该服务器。为了对端口进行区分，将每个端口进行了编号，这就是端口号。
一个IP地址的端口通过16bit进行编号，最多可以有65536个端口。
其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

获取IP：InetAddress

  1. package com.smiledog.wangluobiancheng.socket;
  2. /*
  3.     @ClassName UDPDemo
  4.     @Author SmILeDog
  5.     @Date 2021/5/11
  6.     @Time 13:39
  8. */
  10. import java.net.InetAddress;
  11. import java.net.UnknownHostException;
  13. public class InetAddressDemo {
  14.     public static void main(String[] args) throws UnknownHostException {
  16. //        CSDN：InetAddress类没有构造方法，所以不能直接new出一个对象；
  17. //        可以通过InetAddress类的静态方法获得InetAddress的对象；
  18.         InetAddress localHost = InetAddress.getLocalHost();
  19.         System.out.println(localHost);//DESKTOP-IDATELU/172.16.16.107   主机名/ip地址
  21.         InetAddress address = InetAddress.getLocalHost();
  22.         System.out.println("计算机名：" + address.getHostName());
  23.         System.out.println("IP地址：" + address.getHostAddress());
  24.     }
  25. }
  26. 运行结果：
  27.     DESKTOP-IDATELU/172.16.16.107
  28.     计算机名：DESKTOP-IDATELU
  29.     IP地址：172.16.16.107

TCP和UDP：

TCP：用户传输协议 （三次握手，四次挥手）
比如：打电话 ===》需要建立连接
需要连接，较稳定
客户端，服务端
传输完成，释放连接，效率低

  1. - 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
  2. - 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
  3. - 第三次握手，客户端再次向服务器端发送确认信息，确认连接。
  5. 三次握手：
  6.     客户端：你好服务器，我要和你建立连接
  7.     服务器：好的客户端，已经答应和你建立连接并通知了服务器应用程序（单向连接建立）
  8.     客户端：好的服务器，已经通知应用程序进行连接（双向连接建立）
  10. 四次挥手：
  11.     客户端：你好服务器，我要和你断开连接
  12.     服务器：好的客户端，已经通知服务器应用程序
  13.     服务器：服务器应用程序通知我可以断开连接了（服务器断开连接）
  14.     客户端：好的服务器，已经通知应用程序断开了（客户端断开连接）

UDP：用户数据报协议
比如：发短信 ===》不需要建立连接
不需要连接，不稳定
客户端，服务端 两者没有明确的界限
不管你准没准备好接收，反正我是发给你了

TCP案例：文件的上传

  1. package com.smiledog.wangluobiancheng.socket.TCPDemo.test2;
  2. /*
  3.     @ClassName Client
  4.     @Author SmILeDog
  5.     @Date 2021/5/11
  6.     @Time 17:02
  7.     模拟客户端  进行 上传文件
  8. */
  9. import java.io.*;
  10. import java.net.InetAddress;
  11. import java.net.Socket;
  13. public class Client {
  14.     public static void main(String[] args) throws IOException {
  15.         //创建客户端     指定目标ip和端口
  16.         Socket socket = new Socket(InetAddress.getLocalHost(),12345);
  18.         //通过socket获取输出流
  19.         OutputStream os = socket.getOutputStream();
  20.         //读取文件，传给服务器
  21.         FileInputStream fis = new FileInputStream(new File("day15\\1.jpg"));    //读取指定文件
  23.         byte[] bys = new byte[1024];
  24.         int line;
  25.         while ((line = fis.read(bys)) != -1){
  26.             os.write(bys,0,line);
  27.         }
  28.         socket.shutdownOutput();   //调用停止输出流，用于停止阻塞，让程序走完
  30.         InputStream is = socket.getInputStream();   //获取输入流，读取服务器返回信息！
  31.         int read = is.read(bys);
  32.         System.out.println(new String(bys,0,read));
  34.         //关闭资源
  35.         os.close();
  36.         fis.close();
  38.     }
  39. }
  40. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  41. package com.smiledog.wangluobiancheng.socket.TCPDemo.test2;
  42. /*
  43.     @ClassName Server
  44.     @Author SmILeDog
  45.     @Date 2021/5/11
  46.     @Time 17:02
  47.     模拟服务器   进行 接收文件
  48.         ps: 添加多线程，用于多个用户上传文件的需求
  49.         ps：应该添加一个判断，获取文件类型，然后确定传进来的是什么文件，把jpg变成可变的。
  50. */
  52. import java.io.*;
  53. import java.net.ServerSocket;
  54. import java.net.Socket;
  55. import java.util.Random;
  57. public class Server {
  58.     public static void main(String[] args) throws IOException {
  59.         //创建服务器 指定IP
  60.         ServerSocket serverSocket = new ServerSocket(12345);
  61.         System.out.println("服务器已打开，等待上传。。。");
  62.         while (true) {
  63.             Socket socket = serverSocket.accept();       //创建服务器监听
  64.             new Thread(new ServerThread(socket)).start();   //传入客户端 开启线程
  65.         }
  66.     }
  67. }
  68. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  69. package com.smiledog.wangluobiancheng.socket.TCPDemo.test2;
  70. /*
  71.     @ClassName ServerThread
  72.     @Author SmILeDog
  73.     @Date 2021/5/11
  74.     @Time 17:56
  75. */
  77. import java.io.*;
  78. import java.net.ServerSocket;
  79. import java.net.Socket;
  80. import java.util.Random;
  82. public class ServerThread implements Runnable{
  84.     private Socket socket;
  86.     public ServerThread(Socket socket) {
  87.         this.socket = socket;
  88.     }
  90.     @Override
  91.     public void run() {
  93.         try {
  95.             InputStream is = socket.getInputStream();//通过客户端获取输入流
  96.             //创建个字符串用于接收的文件命名问题，避免名称重复问题      客户端的主机名+当前时间+8位的随机整数
  97.             String fileName = socket.getInetAddress().getHostName() + System.currentTimeMillis() + new Random().nextInt(99999999);
  99.             //创建文件输出流，进行写数据
  100.             FileOutputStream fos = new FileOutputStream(new File("day15\\" + fileName + ".jpg"));    //创建字节输出流
  102.             //读取数据内容
  103.             byte[] bys = new byte[1024];
  104.             int line;
  105.             while ((line = is.read(bys)) != -1) { //读取客户端传入的数据
  106.                 fos.write(bys, 0, line);      //读取的数据写入服务器
  107.             }
  109.             OutputStream os = socket.getOutputStream(); //获取输出流，写入返回客户端信息！
  110.             os.write("上传成功！".getBytes());
  112.             System.out.println("来自："+socket.getInetAddress().getHostAddress()+"上传文件成功！");
  114.             //关闭资源
  115.             fos.close();
  116.             is.close();
  117.             os.close();
  118.         } catch (IOException e) {
  119.             e.printStackTrace();
  120.         }
  121.     }
  122. }

UDP案例：公共聊天室

  1. package com.smiledog.wangluobiancheng.socket.UDPDemo.chijiuhua;
  2. /*
  3.     @ClassName SendDemo
  4.     @Author SmILeDog
  5.     @Date 2021/5/11
  6.     @Time 14:48
  7.     模拟客户端
  8. */
  10. import java.io.IOException;
  11. import java.net.DatagramPacket;
  12. import java.net.DatagramSocket;
  13. import java.net.InetAddress;
  14. import java.util.Scanner;
  16. public class SendDemo {
  17.     public static void main(String[] args) throws IOException {
  18.         //创建客户端
  19.         DatagramSocket socket = new DatagramSocket();
  20.         Scanner sc = new Scanner(System.in);
  21.         while (true){   //一直输出数据    直到输入bye，不区分大小写
  22.             System.out.println("请输入：");
  23.             String s = sc.nextLine();
  24.             if (s.equalsIgnoreCase("bye")){
  25.                 socket.close(); //客户端输入bye,关闭资源
  26.             }
  27.             byte[] bys = s.getBytes();   //将字符串转成数组
  29.            //将数据打包 :   DatagramPacket(数组，长度，目标ip地址，目标端口)
  30.            DatagramPacket packet = new DatagramPacket(bys, bys.length,InetAddress.getLocalHost() , 12306);
  32.            socket.send(packet);    //发送包
  34.            //socket.close();     //关闭资源
  35.        }
  36.     }
  37. }
  38. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  39. package com.smiledog.wangluobiancheng.socket.UDPDemo.chijiuhua;
  40. /*
  41.     @ClassName ReceiveDemo
  42.     @Author SmILeDog
  43.     @Date 2021/5/11
  44.     @Time 15:43
  45.     模拟服务器
  46. */
  47. import java.io.IOException;
  48. import java.net.DatagramPacket;
  49. import java.net.DatagramSocket;
  50. public class ReceiveDemo {
  51.     public static void main(String[] args) throws IOException {
  52.         //定义一个接收端，并指定端口号
  53.         DatagramSocket socket = new DatagramSocket(12306);
  54.         while (true) {
  55.             //接受客户端传过来的数据包
  56.             byte[] bys = new byte[1024];    //定义数组接收数据包
  58.             // 解析数据包 ,客户端传过来的数据都在这个packet里边了
  59.             DatagramPacket packet = new DatagramPacket(bys, bys.length);
  61.             socket.receive(packet); //接收数据包内容
  63.             String ip = packet.getAddress().getHostAddress();   //获取前端传过来的包中的ip地址
  64.             bys = packet.getData(); //获取包中的数据内容
  66.             int datalength = packet.getLength();    //获取文件内容的大小，如果直接打印bys的大小，打印的是初始化那个大小的值
  68.             System.out.println("packet.getData().length："+datalength);
  70.             String data = new String(bys, 0, datalength);
  72.             System.out.println("来自：" + ip + "内容为：" + data);
  73.         }
  74.     }
  75. }

URL：下载网络资源

  1. package com.smiledog.wangluobiancheng;
  2. /*
  3.     @ClassName URlDemo
  4.     @Author SmILeDog
  5.     @Date 2021/5/11
  6.     @Time 20:11
  7. */
  9. import java.io.FileOutputStream;
  10. import java.io.IOException;
  11. import java.io.InputStream;
  12. import java.net.HttpURLConnection;
  13. import java.net.URL;
  14. import java.text.SimpleDateFormat;
  15. import java.util.Date;
  17. public class URlDemo {
  18.     public static void main(String[] args) throws IOException {
  19.         //下载地址
  20.         URL url = new URL("https://m701.music.126.net/20210511205517/3f7bba4fb2bc0c1c9703573ea695fbf9/jdyyaac/525b/0f5d/060c/e1c731b12687d4fe07cc1fac64103777.m4a");//括号里是网络资源的网址
  21.         String file = url.getPath();    //获取文件路径
  22.         int i = file.lastIndexOf(".");  //返回指定字符最后一次出现的位置
  23.         String sub = file.substring(i);
  25.         //连接到资源
  26.         HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
  28.         //调用字节输入流
  29.         InputStream is = urlConnection.getInputStream();
  31.         //创建文件输出流
  32.         //避免名称重复
  33.         SimpleDateFormat sdf = new SimpleDateFormat("yyMMddHHmmss");    //格式化样式
  34.         String format = sdf.format(new Date()); //格式化
  35.         String  fileName=  format;
  36.         FileOutputStream fos = new FileOutputStream("E:\\music\\"+fileName+sub);
  38.         byte[] bys = new byte[1024];
  39.         int len;
  40.         while ((len = is.read(bys))!=-1){   //读取资源
  41.             fos.write(bys,0,len);    //把资源写入本地
  42.         }
  43.         //关闭资源
  44.         fos.close();
  45.         is.close();
  46.         urlConnection.disconnect();
  48.     }
  49. }

控制台公共聊天室：

  1. package com.yunhe.socket;
  2. /*
  3.     @ClassName Client
  4.     @Author SmILeDog
  5.     @Date 2021/6/8
  6.     @Time 16:33
  7.     模拟客户端
  8. */
  10. import java.io.*;
  11. import java.net.Socket;
  12. import java.util.Scanner;
  14. public class Client {
  15.     public static void main(String[] args) {
  16.         Scanner sc = new Scanner(System.in);
  17. //        String ip = "172.16.16.100";
  18.         String ip = "127.0.0.1";
  19.         int  port = 12306;
  20.         String line = null;
  22.         Socket socket = null;
  23.         InputStream is = null;
  24.         OutputStream os = null;
  25.         BufferedReader br = null;
  26.         BufferedWriter bw = null;
  27.         try {
  28.         while (true){
  29.             //监听端口
  30.             socket = new Socket(ip,port);
  31.             //获取字节输入流
  32.             is = socket.getInputStream();
  33.             //获取字节输出流
  34.             os = socket.getOutputStream();
  35.             //获取字符缓冲输入流
  36.             br = new BufferedReader(new InputStreamReader(is));
  37.             //获取字符缓冲输出流
  38.             bw = new BufferedWriter(new OutputStreamWriter(os));
  40.                 //客户端发送数据
  41.                 System.out.println("请输入需要发送给服务器的内容：");
  42.                 String str = sc.nextLine();
  43.                 bw.write(str);//发送数据
  44.                 bw.flush(); //刷新流
  45.             socket.shutdownOutput();
  46.                 //接受服务器端的相应数据
  47.                 while ((line = br.readLine()) !=null){
  48.                     System.out.println("收到服务器端的响应内容："+line);   //打印相应内容
  49.                 }
  50.             socket.shutdownInput();
  51.             }
  53.         } catch (IOException e) {
  54.             e.printStackTrace();
  55.         }finally {
  56.             if (bw!=null){
  57.                 try {
  58.                     bw.close();
  59.                 } catch (IOException e) {
  60.                     e.printStackTrace();
  61.                 }
  62.             }
  63.             if (br!=null){
  64.                 try {
  65.                     br.close();
  66.                 } catch (IOException e) {
  67.                     e.printStackTrace();
  68.                 }
  69.             }
  70.             if (os!=null){
  71.                 try {
  72.                     os.close();
  73.                 } catch (IOException e) {
  74.                     e.printStackTrace();
  75.                 }
  76.             }
  77.             if (is!=null){
  78.                 try {
  79.                     is.close();
  80.                 } catch (IOException e) {
  81.                     e.printStackTrace();
  82.                 }
  83.             }
  84.             if (socket!=null){
  85.                 try {
  86.                     socket.close();
  87.                 } catch (IOException e) {
  88.                     e.printStackTrace();
  89.                 }
  90.             }
  91.         }
  92.     }
  93. }
  1. package com.yunhe.socket;
  2. /*
  3.     @ClassName server
  4.     @Author SmILeDog
  5.     @Date 2021/6/8
  6.     @Time 16:54
  7.     模拟服务器端
  8. */
  10. import java.io.*;
  11. import java.net.ServerSocket;
  12. import java.net.Socket;
  13. import java.util.Scanner;
  15. public class server {
  16.     public static void main(String[] args) throws IOException {
  17.         Scanner sc = new Scanner(System.in);
  18.         int port = 12306;
  19.         String line = null;
  20.         String str = null;
  21.         Socket socket = null;
  22.         ServerSocket serverSocket = null;
  23.         InputStream is = null;
  24.         OutputStream os = null;
  25.         BufferedReader br = null;
  26.         BufferedWriter bw = null;
  27.         serverSocket = new ServerSocket(port);
  28.         try {
  29.         while (true) {
  30.         System.out.println("======服务器端正在接收数据======");
  31.         socket = serverSocket.accept();
  32.         //获取字节输入流
  33.         is = socket.getInputStream();
  34.         //获取字节输出流
  35.         os = socket.getOutputStream();
  36.         //获取字符缓冲输入流
  37.         br = new BufferedReader(new InputStreamReader(is));
  38.         //获取字符缓冲输出流
  39.         bw = new BufferedWriter(new OutputStreamWriter(os));
  42.             //接受服务器端的相应数据
  43.             while ((line = br.readLine()) != null) {
  44.                 System.out.println("收到客户端"+socket.getInetAddress().getHostAddress()+"发来的消息：" + line);   //打印相应内容
  45.             }
  46.             socket.shutdownInput();
  47.             //服务器端响应数据
  48.             System.out.println("请回复需要响应的内容：");
  49.             str = sc.nextLine();
  50.             bw.write(str);//发送数据
  51.             bw.flush(); //刷新流
  52.             socket.shutdownOutput();
  53.         }
  55.         } catch (IOException e) {
  56.             e.printStackTrace();
  57.         }finally {
  58.             if (bw!=null){
  59.                 try {
  60.                     bw.close();
  61.                 } catch (IOException e) {
  62.                     e.printStackTrace();
  63.                 }
  64.             }
  65.             if (br!=null){
  66.                 try {
  67.                     br.close();
  68.                 } catch (IOException e) {
  69.                     e.printStackTrace();
  70.                 }
  71.             }
  72.             if (os!=null){
  73.                 try {
  74.                     os.close();
  75.                 } catch (IOException e) {
  76.                     e.printStackTrace();
  77.                 }
  78.             }
  79.             if (is!=null){
  80.                 try {
  81.                     is.close();
  82.                 } catch (IOException e) {
  83.                     e.printStackTrace();
  84.                 }
  85.             }
  86.             if (serverSocket!=null){
  87.                 try {
  88.                     serverSocket.close();
  89.                 } catch (IOException e) {
  90.                     e.printStackTrace();
  91.                 }
  92.             }
  93.             if (socket!=null){
  94.                 try {
  95.                     socket.close();
  96.                 } catch (IOException e) {
  97.                     e.printStackTrace();
  98.                 }
  99.             }
  100.         }
  102.     }
  103. }