1.计算机网络概念

计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接（有线性、无线）起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

网络编程的目的
传播交流信息
数据交换、通信。

想要达到这个效果，需要什么
1.如何准确的定位网络上的一台主机 192.168.1.100： 端口，定位到这个计算机上的某个资源。
2.找到了这个主机，如何传输数据呢？
JavaWeb ： 网页编程 B/S架构
网络编程： TCP/IP C/S架构

网络通信要素
如何实现网络的通信？
通信双方的地址：
IP、端口号。
192.168.1.100:8080

TCP/IP参考模型
image.png

小结：
1.网络编程中两个主要问题
如何准确定位到网络上的一台或多台主机
找到主机之后如何进行通信
2.网络编程中的要素
IP 和 端口号
网络通信协议
3.Java 万物皆对象

2、IP

  1. /**
  2.  * @author chenGen
  3.  * @version 1.0.0
  4.  * @ClassName TestInetAddress.java
  5.  * @Description TODO
  6.  * @createTime 2021年09月24日 09:47:00
  7.  */
  8. public class TestInetAddress {
  10.   public static void main(String[] args) throws Exception {
  11.     //查询本机的ip地址
  12.     InetAddress localhost = InetAddress.getByName("localhost");
  13.     System.out.println(localhost);
  15.     InetAddress localHost = InetAddress.getLocalHost();
  16.     System.out.println(localHost);
  18.     System.out.println("==============");
  19.     //查询网站ip地址
  20.     InetAddress taobao = InetAddress.getByName("www.taobao.com");
  21.     System.out.println(taobao);
  22.     System.out.println("==============");
  23.     //常用方法
  25.     System.out.println(taobao.getHostAddress());//获取主机ip地址
  26.     System.out.println(taobao.getHostName());//获取域名
  27.     System.out.println(taobao.getCanonicalHostName());//获取规范的ip地址
  28.   }
  30. }


3.端口

端口表示计算机上的一个程序的进程。
1.一栋楼表示一个ip ，这栋楼里面的 门牌号 就是端口号。
2.不同的进程有不同的端口号！用来区分软件的。
3.端口被规定为：0-65535
4.TCP ，UDP： 每个都有 0-65535 * 2 ，单个协议下，端口号不能冲突。
5.端口分类
公有端口：0-1023
HTTP ： 80
HTTPS ：443
FTP ： 21
Telet ： 23
程序注册端口：1024-49151，分配给用户或者程序
Tomcat：8080
Mysql：3306
Oracle：1521
动态、私有：49152-65535

  1. netstat -ano #查看所有端口
  2. netstat -ano  | findstr "5900" #查看指定的端口
  3. tasklist | findstr "8696" #查看指定端口的进程
  4. Ctrl + Shift + ESC
  1. package cn.bloghut.lesson01;
  3. import java.net.InetSocketAddress;
  5. /**
  6.  * @author by 闲言
  7.  * @classname TesyInetSocketAddress
  8.  * @description TODO
  9.  * @date 2021/8/1 18:12
  10.  */
  11. public class TesyInetSocketAddress {
  12.     public static void main(String[] args) {
  14.         InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8080);
  15.         InetSocketAddress socketAddress1 = new InetSocketAddress("localhost", 8080);
  17.         System.out.println(socketAddress);
  18.         System.out.println(socketAddress1);
  19.         System.out.println("====================");
  21.         System.out.println(socketAddress.getAddress());//ip地址
  22.         System.out.println(socketAddress.getHostName());//主机名称
  23.         System.out.println(socketAddress.getHostString());
  24.         System.out.println(socketAddress.getPort());//端口
  26.     }
  27. }

4.通信协议

协议：约定，就好比我们现在说的是普通话。大家都能听懂
网络通信协议：
1.速率
2.传输码率
3.代码结构
4.传输控制
问题：非常的复杂
TCP/IP协议簇：实际上是一组协议
重要：
TCP：用户传输协议
UDP：用户数据报协议
出名的协议：
TCP
IP
TCP和UDP 对比：
TCP：打电话
连接： 稳定
三次握手
A：你愁啥？ 我要连接了
B：瞅你咋地？ 好的，我准备好了，你可以连接了
A：干一次！ 连接正常
四次挥手
A：我要断开了 （我要走了）
B：我知道你要断开了（你真的要走了吗？）
B：你真的断开了吗？（你真的真的要走了吗？）
A：我真的断开了 （我真的要走了）
客户端，服务端
传输完成，释放连接、效率低

image.png
第一次握手：建立连接时，客户端发送syn包（syn=j）到服务器，并进入SYN_SENT状态，等待服务器确认；SYN：同步序列编号（Synchronize Sequence Numbers）。
第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；
第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1），此包发送完毕，客户端和服务器进入ESTABLISHED（TCP连接成功）状态，完成三次握手。
image.png
UDP：发短信
1.不连接，不稳定
2.客户端、服务端：没有明确的界限
3.不管有没有准备好，都可以发给你…
4.导弹
5.DDOS：洪水攻击！（饱和攻击）

客户端
1.建立连接
2.发送消息

  1. /**
  2.  * @author chenGen
  3.  * @version 1.0.0
  4.  * @ClassName TcpClienDemo01.java
  5.  * @Description TODO
  6.  * @createTime 2021年09月23日 14:30:00
  7.  */
  8. //客户端
  9. public class TcpClienDemo01 {
  11.   public static void main(String[] args) {
  12.     OutputStream os =null;
  13.     Socket  socket=null;
  14.     //设置服务端的ip和端口
  15.     try {
  16.       InetAddress address = InetAddress.getByName("127.0.0.1");
  17.       //端口
  18.       int ip=9999;
  19.       //创建一个socket连接
  20.         socket=new Socket(address,ip);
  22.       //发送
  23.        os = socket.getOutputStream();
  24.       os.write("hello!".getBytes());
  26.     } catch (UnknownHostException e) {
  27.       e.printStackTrace();
  28.     } catch (IOException e) {
  29.       e.printStackTrace();
  30.     }finally {
  31.       if (os!=null){
  32.         try {
  33.           os.close();
  34.         } catch (IOException e) {
  35.           e.printStackTrace();
  36.         }
  37.       }
  38.       if (socket!=null){
  39.         try {
  40.           socket.close();
  41.         } catch (IOException e) {
  42.           e.printStackTrace();
  43.         }
  44.       }
  45.     }
  46.   }
  47. }

服务端
1.建立服务连接的端口 ServerSocket
2.等待用户的连接 accept
3.接收用户信息

  1. //服务端
  2. public class TcpServerDemo1 {
  4.   public static void main(String[] args) {
  5.     ServerSocket socket=null;
  6.     Socket accept=null;
  7.     InputStream ios=null;
  8.     ByteArrayOutputStream bais=null;
  9.     try {
  10.       //创建一个socket服务端
  11.        socket=new ServerSocket(9999);
  12.       //等待客户端发送信息
  13.        accept = socket.accept();
  14.       //读取客户端信息
  15.        ios = accept.getInputStream();
  17.       byte [] bytes=new byte[1024];
  18.       int len;
  19.       //管道流
  20.        bais=new ByteArrayOutputStream();
  21.       while ((len=ios.read(bytes))!=-1){
  22.         bais.write(bytes,0,len);
  23.       }
  24.       System.out.println(bais.toString());
  26.     } catch (IOException e) {
  27.       e.printStackTrace();
  28.     }finally {
  29.       if (bais!=null){
  30.         try {
  31.           bais.close();
  32.         } catch (IOException e) {
  33.           e.printStackTrace();
  34.         }
  35.       }
  36.       if (ios!=null){
  37.           try {
  38.           ios.close();
  39.         } catch (IOException e) {
  40.         e.printStackTrace();
  41.       }
  42.     }
  44.       if (accept!=null){
  45.         try {
  46.           accept.close();
  47.         } catch (IOException e) {
  48.           e.printStackTrace();
  49.         }
  50.       }
  52.       if (socket!=null){
  53.         try {
  54.           socket.close();
  55.         } catch (IOException e) {
  56.           e.printStackTrace();
  57.         }
  58.       }
  59.   }
  60. }
  61. }

TCP实现文件上传

客户端

  1. //客户端发送文件
  2. public class TcpClienDemo2 {
  4.   public static void main(String[] args) throws IOException {
  6.       //创建一个socket连接
  7.       Socket socket=new Socket(InetAddress.getByName("127.0.0.1"),9999);
  8.       //创建一个输出流
  9.       OutputStream outputStream = socket.getOutputStream();
  11.       //读取文件
  12.       FileInputStream fis=new FileInputStream(new File("C:\\Users\\Administrator\\Desktop\\ed437daaf444474e9391523df81e986.jpg"));
  14.       byte[] bytes=new byte[1024];
  15.       int len;
  16.       //写出文件
  17.       while ((len=fis.read(bytes))!=-1){
  18.         outputStream.write(bytes,0,len);
  19.       }
  21.       //通知服务器我已经传输完毕
  22.     socket.shutdownOutput();
  24.       //获取服务器的信息
  25.     InputStream is = socket.getInputStream();
  26.     //管道流
  27.     ByteArrayOutputStream baos=new ByteArrayOutputStream();
  29.     byte [] bytes1=new byte[1024];
  30.     int len1;
  31.     while ((len1=is.read(bytes1))!=-1){
  32.         baos.write(bytes1,0,len1);
  33.     }
  35.     System.out.println(baos.toString());
  38.     //关闭连接
  39.     socket.close();
  40.     outputStream.close();
  41.     fis.close();
  42.     is.close();
  43.     baos.close();
  45.   }
  46. }

服务端

  1. //服务端接收文件
  2. public class TcpServerDemo2 {
  4.   public static void main(String[] args) {
  6.     try {
  7.       //创建服务的Socket端
  8.       ServerSocket serverSocket=new ServerSocket(9999);
  9.       //持续监听客户端请求
  10.       Socket accept = serverSocket.accept();//阻塞式监听 会一直等待
  11.       //获取读写流
  12.       InputStream ios = accept.getInputStream();
  14.       //文件输出
  15.       FileOutputStream fos=new FileOutputStream(new File("abcd"));
  16.       byte [] bytes=new byte[1024];
  17.       int len;
  18.       while ((len=ios.read(bytes))!=-1){
  19.         fos.write(bytes,0,len);
  20.       }
  22.       //通知客户端我已接收到文件
  23.       OutputStream os = accept.getOutputStream();
  24.       os.write("文件已收到，请关闭连接！".getBytes());
  26.       //关闭连接
  27. //      os.close();
  28.       fos.close();
  29.       ios.close();
  30.       accept.close();
  31.       serverSocket.close();
  34.     } catch (IOException e) {
  35.       e.printStackTrace();
  36.     }
  37.   }
  38. }

UDP发送端短信 需要ip地址
客户端 

  1. //UDP 不需要连接服务器
  2. public  class TestUdpClient {
  4.   public static void main(String[] args) throws Exception {
  5.     //建立一个socket
  6.     DatagramSocket socket=new DatagramSocket();
  8.     //建包
  9.     String msg="你好，我的朋友！";
  10.     InetAddress inetAddress = InetAddress.getByName("localhost");
  11.     int port=9090;
  12.     DatagramPacket packet=new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,inetAddress,port);
  14.     //发送包
  15.     socket.send(packet);
  17.     //关闭流
  18.     socket.close();
  20.   }
  21. }

服务端

  1. //服务端
  2. public class TestUdpServer {
  4.   public static void main(String[] args) throws Exception {
  5.     //开放端口
  6.     DatagramSocket socket=new DatagramSocket(9090);
  8.     //接收数据包
  9.     byte[]bytes=new byte[1024];
  10.     DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length);
  12.     socket.receive(packet);
  14.     System.out.println(new String(packet.getData(),0,packet.getLength()));
  15.     //关闭连接
  16.     socket.close();
  17.   }
  18. }
  1. //服务端
  2. public class UdpReceiveDemo1 {
  4.   public static void main(String[] args) throws Exception {
  5.     DatagramSocket socket=new DatagramSocket(6666);
  6.     while (true){
  8.       //接收
  9.       byte [] bytes=new byte[1024];
  10.       DatagramPacket packet=new DatagramPacket(bytes,0,bytes.length);
  11.       socket.receive(packet);
  13.       //判断是否结束
  14.       byte[] data = packet.getData();
  15.       String receiveData = new String(data, 0, data.length);
  16.       System.out.println(receiveData);
  19.       if (receiveData.equals("Bye")){
  20.        break;
  21.       }
  22.     }
  24.     socket.close();
  26.   }
  27. }
  29. //接收端
  30. public class UDPSend2 {
  32.   public static void main(String[] args) throws Exception {
  33.     DatagramSocket socket=new DatagramSocket(8888);
  35.     //准备数据：控制台读取 System.in
  36.     BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
  37.     //循环发送
  38.     while (true){
  39.       String data = reader.readLine();
  40.       byte[] bytes = data.getBytes();
  42.       DatagramPacket packet=new DatagramPacket(bytes,0,bytes.length,new InetSocketAddress("localhost",6666));
  44.       socket.send(packet);
  46.       if (data.equals("Bye")){
  47.         break;
  48.       }
  49.     }
  50.     socket.close();
  51.   }
  52. }