网络编程

最新推荐文章于 2023-06-24 21:33:09 发布

追寻远方的人

最新推荐文章于 2023-06-24 21:33:09 发布

阅读量146

点赞数 2

分类专栏： java基础

本文链接：https://blog.csdn.net/segegse/article/details/114765088

版权

java基础专栏收录该内容

46 篇文章 1 订阅

订阅专栏

网络编程

1.1、概述

1.2、网络通信的要素

如何实现网络的通信？

通信双方的地址：

IP
端口号
192.168.16.124

规则：网络通信的的协议

TCP/IP 参考：应用层传输层网络层数据链路层

小结:

1.网络编程中有两个主要问题

如何准确定位到网络上的一台或多台主机
找到主机之后如何进行通信

2.网络编程中的要素

IP和端口号
网络通信协议

3.万物皆对象

1.3、IP

ip地址：inetAddress

唯一定位一台网络上计算机
127.0.0.1：本机localhost
ip地址的分类

  package com.Yoona.lesson01;
  
  import java.net.InetAddress;
  import java.net.UnknownHostException;
  
  //测试IP
  public class TestInetAddress
  {
      public static void main(String[] args)
      {
          try
          {
              //查询本机地址
              InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");///127.0.0.1
              System.out.println(inetAddress1);
              InetAddress inetAddress3 = InetAddress.getByName("localhost");//localhost/127.0.0.1
              System.out.println(inetAddress3);
              InetAddress inetAddress4 = InetAddress.getLocalHost();//LAPTOP-F57O48C1/192.168.1.110
              System.out.println(inetAddress4);
  
              //查询网络地址
              InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");//www.baidu.com/182.61.200.7
              System.out.println(inetAddress2);
  
              //常用方法
              System.out.println(inetAddress2.getAddress());//[B@1b6d3586
              System.out.println(inetAddress2.getCanonicalHostName());//182.61.200.7 规范名字
              System.out.println(inetAddress2.getHostName());//www.baidu.com 主机名字
              System.out.println(inetAddress2.getHostAddress());//182.61.200.7 域名 或者自己电脑的名字
          }
          catch (UnknownHostException e)
          {
              e.printStackTrace();
          }
      }
  }

1.4、端口

端口表示计算机上的一个程序进程

不同的进程又不同的端口号用来区分软件
被规定0~65535
TCP UDP:65535*2
端口分类
1. 公有端口 0~1023
  - HTTP:80
  - HTTPS:443
  - FTP:21
  - Telent:23
2. 程序注册端口：1024~49151，分配用户或者程序
  - Tomcat: 8080
  - MySQL: 3306
  - Oracle: 1521
3. 动态私有：49152~65535

netstat -ano #查看所有窗口
netstat -ano|findstr"5900" #查看指定窗口
tasklist|findstr "8696" # 查看指定窗口的进度
Ctrl+ shift+ ESC

package com.Yoona.lesson01;

import java.net.InetSocketAddress;

public class TestInetSocketAddress
{
    public static void main(String[] args)
    {
        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress address2 = new InetSocketAddress("localhost", 8080);
        System.out.println(address);//  /127.0.0.1:8080
        System.out.println(address2);//  localhost/127.0.0.1:8080

        System.out.println(address.getAddress());// /127.0.0.1
        System.out.println(address.getHostName());// 127.0.0.1 地址
        System.out.println(address.getPort());// 8080 端口
    }
}

1.5、通信协议

协议：约定，就好比说我们现在说的是普通话

网络通信协议：速率，传输代码，代码结构，传输控制

问题：非常复杂

大事化小：分层

TCP/IP协议簇 实际上是一组协议

重要：

TCP：用户传输协议
UDP：用户数据报协议
IP: 网络互连协议

TCP UDP 对比

TCP：打电话

连接，稳定

三次握手四次挥手

最少需要三次，保证稳定连接！
A:你瞅啥？
B:瞅你咋地？
A:干一场！

A:我要断开了！
B:我知道你要断开了!
B:你真的断开了吗？
A:我真的要走了

客户端、服务端
传输完成，释放连接，效率低

UDP：发短信

不连接不稳定
客户端、服务端：没有明确的界限
不管有没有准备好，都可以发给你
导弹攻击
DDOS：洪水攻击！（饱和攻击）

1.6、TCP

聊天

客户端

连接服务器 Socket
发送消息

   package com.Yoona.lesson02;
   
   import java.io.IOException;
   import java.io.OutputStream;
   import java.net.InetAddress;
   import java.net.Socket;
   import java.net.UnknownHostException;
   
   //客户端
   public class TcpClientDemo01
   {
       public static void main(String[] args)
       {
           Socket socket = null;
           OutputStream os = null;
   
           try
           {
               //1.要知道服务器的地址 端口号
               InetAddress serverIP = InetAddress.getByName("127.0.0.1");
               int port = 9999;
               //2.创建一个socket连接
               socket = new Socket(serverIP, port);
               //3.发送消息 IO
               os = socket.getOutputStream();
               os.write("你好，Yoona".getBytes());
           }
           catch (Exception e)
           {
               e.printStackTrace();
           }
           finally
           {
   
               if(os!=null){
   
                   try
                   {
                       os.close();
                   }
                   catch (IOException e)
                   {
                       e.printStackTrace();
                   }
               }
               if (socket != null)
               {
                   try
                   {
                       socket.close();
                   }
                   catch (IOException e)
                   {
                       e.printStackTrace();
                   }
               }
           }
   
       }
   }

服务器

建立服务端口 ServerSocket
等待用户的连接 accept
接受用户消息

   package com.Yoona.lesson02;
   
   import java.io.ByteArrayOutputStream;
   import java.io.IOException;
   import java.io.InputStream;
   import java.net.ServerSocket;
   import java.net.Socket;
   
   //服务端
   public class TcpServerDemo01
   {
       public static void main(String[] args)
       {
           ServerSocket serverSocket = null;
           Socket socket = null;
           InputStream is = null;
           ByteArrayOutputStream baos = null;
   
           try
           {
               //1.我得有个地址
               serverSocket = new ServerSocket(9999);
               while (true)
               {
                   //2.等待客户端连接过来
                   socket = serverSocket.accept();
                   //3.读取客户端的消息
                   is = socket.getInputStream();
   
               /*
               byte[] buffer = new byte[1024];
               int len;
               while ((len = is.read(buffer)) != -1)
               {
                   String msg = new String(buffer, 0, len);
                   System.out.println(msg);
               }
               */
                   //管道流
                   baos = new ByteArrayOutputStream();
                   byte[] buffer = new byte[1024];
                   int len;
                   while ((len = is.read(buffer)) != -1)
                   {
                       baos.write(buffer, 0, len);
                   }
                   System.out.println(baos.toString());
               }
   
   
           }
           catch (IOException e)
           {
               e.printStackTrace();
           }
           finally
           {
               //关闭资源
               if (baos != null)
               {
                   try
                   {
                       baos.close();
                   }
                   catch (IOException e)
                   {
                       e.printStackTrace();
                   }
               }
               if (is != null)
               {
                   try
                   {
                       is.close();
                   }
                   catch (IOException e)
                   {
                       e.printStackTrace();
                   }
               }
               if (socket != null)
               {
                   try
                   {
                       socket.close();
                   }
                   catch (IOException e)
                   {
                       e.printStackTrace();
                   }
               }
               if (serverSocket != null)
               {
                   try
                   {
                       serverSocket.close();
                   }
                   catch (IOException e)
                   {
                       e.printStackTrace();
                   }
               }
   
   
           }
       }
   }

文件上传

客户端

package com.Yoona.lesson02;


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

public class TcpClientDemo02
{
    public static void main(String[] args) throws Exception
    {
        //1.创建一个socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
        //2.创建一个输出流
        OutputStream os = socket.getOutputStream();

        //3.文件流
        FileInputStream fis = new FileInputStream(new File("Yoona.jpg"));
        //4.写出文件

        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1)
        {
            os.write(buffer, 0, len);
        }
        //通知服务器，我已经结束了
        socket.shutdownOutput();//我结束了

        //确定服务器接收完毕，才能断开连接
        InputStream inputStream = socket.getInputStream();
        //String byte[]
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        byte[] buffer2 = new byte[2014];
        int len2;
        while ((len2 = inputStream.read(buffer2)) != -1)
        {
            baos.write(buffer2, 0, len2);
        }

        System.out.println(baos.toString());

        //5.关闭资源
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();

    }
}

服务器端

package com.Yoona.lesson02;

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

public class TcpServerDemo02
{
    public static void main(String[] args) throws IOException
    {
        //1.创建端口
        ServerSocket serverSocket = new ServerSocket(9000);
        //监听客户端的连接
        Socket socket = serverSocket.accept();//阻塞式监听，会一直等待客户端进度
        //3.获取输入流
        InputStream is = socket.getInputStream();

        //4.文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len = is.read(buffer)) != -1)
        {
            fos.write(buffer, 0, len);
        }

        //通知客户端我接收完毕了
        OutputStream os = socket.getOutputStream();
        os.write("done".getBytes());


        //5.关闭资源
        fos.close();;
        is.close();;
        socket.close();
        serverSocket.close();

    }
}

Tomcat

服务端

自定义 S
Tomcat 服务器 S

客户端

自定义 C
浏览器 B

1.7 UDP

发送信息

发短信：不用连接，需要知道对方的地址

发送端

package com.Yoona.lesson03;

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

//不需要连接服务器
public class UdpClientDemo01
{
    public static void main(String[] args) throws Exception
    {
        //1.建立一个Socket **
        DatagramSocket socket = new DatagramSocket();

        //2.建个包
        String msg = "你好啊，服务器！";
        //发送给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;
        //数据，数据的长度起始，要发送给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

        //3.发送包 **
        socket.send(packet);

        //4.关闭流
        socket.close();
    }
}

接收端

package com.Yoona.lesson03;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

//还是要等待客户端的链接！
public class UdpServerDemo01
{
    public static void main(String[] args) throws Exception
    {
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        
        //接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);//接收

        socket.receive(packet);//阻塞接收

        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(), 0, packet.getLength()));
        //关闭连接
        socket.close();
    }
}

循环发送接收消息

package com.Yoona.chat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class UdpSenderDemo01
{
    public static void main(String[] args) throws Exception
    {
        DatagramSocket socket = new DatagramSocket(8888);

        //准备数据：控制台读取System.in

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while (true)
        {
            String data = reader.readLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 6666));
            socket.send(packet);
            if (data.equals("bye"))
            {
                break;
            }
        }
        socket.close();
    }

}

package com.Yoona.chat;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UdpReceiveDemo01
{
    public static void main(String[] args) throws Exception
    {
        DatagramSocket socket = new DatagramSocket(6666);

        while (true)
        {
            //准备被接受包裹
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            socket.receive(packet);//阻塞式接收包裹

            //断开连接 bye
            byte[] data = packet.getData();
            String receiveData = new String(data, 0, data.length);

            System.out.println(receiveData);

            if (receiveData.equals("bye"))
            {
                break;
            }

        }
        socket.close();

    }

}

在线咨询

package com.Yoona.chat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class TalkSend implements Runnable
{
    DatagramSocket socket = null;
    BufferedReader reader = null;

    private int fromPort;
    private String toIP;
    private int toPort;

    public TalkSend(int fromPort, String toIP, int toPort)
    {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;

        try
        {
            socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        }
        catch (SocketException e)
        {
            e.printStackTrace();
        }

    }

    @Override
    public void run()
    {
        while (true)
        {

            try
            {
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress(this.toIP, this.toPort));
                socket.send(packet);
                if (data.equals("bye"))
                {
                    break;
                }
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }

        }

        socket.close();
    }
}

package com.Yoona.chat;

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

public class TalkReceive implements Runnable
{
    DatagramSocket socket = null;
    private  int port;
    private  String msgFrom;

    public TalkReceive(int port,String msgFrom)
    {
        this.port = port;
        this.msgFrom = msgFrom;
        try
        {
            socket = new DatagramSocket(port);
        }
        catch (SocketException e)
        {
            e.printStackTrace();
        }
    }

    @Override
    public void run()
    {

        while (true)
        {

            try
            {
                //准备被接受包裹
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                socket.receive(packet);//阻塞式接收包裹

                //断开连接 bye
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, data.length);

                System.out.println(msgFrom + "发送过来" + receiveData);

                if (receiveData.equals("bye"))
                {
                    break;
                }
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }


        }
        socket.close();
    }
}

package com.Yoona.chat;

public class TalkStudent
{
    public static void main(String[] args)
    {
        //开启两个线程
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

package com.Yoona.chat;

public class TalkTeacher
{
    public static void main(String[] args)
    {
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

1.8、URL

https://www.baidu.com

统一资源定位符：定位资源的，定位互联网上的某一个资源

DNS 域名解析 www.baidu.com

协议：//ip地址： 端口号/项目名/资源

追寻远方的人

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
2
评论
网络编程

网络编程1.1、概述1.2、网络通信的要素如何实现网络的通信？通信双方的地址：IP端口号192.168.16.124规则：网络通信的的协议TCP/IP 参考：应用层传输层网络层数据链路层小结:1.网络编程中有两个主要问题如何准确定位到网络上的一台或多台主机找到主机之后如何进行通信2.网络编程中的要素IP和端口号网络通信协议3.万物皆对象1.3、IPip地址：inetAddress唯一定位一台网络上计算机127.0.0.1：本机localho
复制链接

扫一扫