首页 > 其他 > 详细

网络编程

时间：2021-02-18 23:23:56      阅读：24      评论：0      收藏：0      [点我收藏+]

概述

计算机网络:计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，[网

络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

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

达到的效果是：

1.如何准确的定位网络上的一台主机 192.168.16.124:端口，定位到这个计算机上的某个资源

2.找到了这个主机，如何传输数据呢?

javaweb: 网页编程 B/S

网络编程: TCP/IP C/S

网络通信的要素

如何实现网络通信？

通信双方地址：ip 端口号

规则：网络通信的协议

TCP/IP参考模型

技术分享图片

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

如何准确的定位到网络上的一台或者多台主机。

找到主机之后如何进行通信

2.网络编程中的要素：

知道IP和端口号 IP类

网络通信协议 udp,tcp类

IP

ip地址：InetAddress

  1. 唯一定位一台网络计算机

  2. 127.0.0.1 本机localhost

  3. ip地址分类

    ipv4: 127.0.0.1 4个字节组成，

    ipv6： 128位，8个无符号整数

公网（互联网）-私网（局域网）

ABCD类地址

192.168.xx.xx,专门给组织内部使用

  1. 域名：记忆IP问题

    import java.net.InetAddress;
    import java.net.UnknownHostException;
    ?
    //测试IP
    public class TestInternet {
        public static void main(String[] args) {
            try {
                //查询本地地址
                InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
                System.out.println(inetAddress1);
                InetAddress inetAddress3 = InetAddress.getByName("localhost");
                System.out.println(inetAddress3);
                InetAddress inetAddress4 = InetAddress.getLocalHost();
                System.out.println(inetAddress4);
                //查询ip网站地址
                InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
                System.out.println(inetAddress2);
                //常用方法
                System.out.println(inetAddress2.getAddress());
                System.out.println(inetAddress2.getCanonicalHostName());//规范的名字
                System.out.println(inetAddress2.getHostAddress());//ip
                System.out.println(inetAddress2.getHostName());//域名，或者自己电脑的名字
            } catch (UnknownHostException e) {
                e.printStackTrace();
            }
        }
    }

端口

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

  • 不同进程有不同端口号，用来区分软件

  • 被规定0-65535

  • TCP,UDP：65535*2 单个协议，端口不能冲突

  • 端口分类:

    • 公有端口 0-1023

      • HTTP : 80

      • HTTPS : 443

      • FTP : 21

      • Telent : 23

    • 程序注册端口：2014-49151 分配用户或者程序

      • Tomcat : 8080

      • MySQL : 3306

      • Oracle : 1521

    • 动态、私有:49152 - 65535

      netstat -ano #查看所有端口
      netstat -ano|findstr "" #查看指定端口
      tasklist|findstr "" #查看指定端口的进程
      import java.net.InetSocketAddress;
      ?
      public class TestsocketAddress {
          public static void main(String[] args) {
              InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1",8080);
              InetSocketAddress socketAddress1 = new InetSocketAddress("localhost",8080);
              System.out.println(socketAddress);
              System.out.println(socketAddress1);
      ?
      ?
              System.out.println(socketAddress.getAddress());
              System.out.println(socketAddress.getHostName());//地址
              System.out.println(socketAddress.getPort());//端口
          }
      }

通信协议

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

TCP/IP协议簇

重要

  • TCP：用户传输协议（打电话）

  • UDP：用户数据报协议(发短信)

重要协议：

  • TCP：

  • IP：网络互联协议

技术分享图片

TCP UDP 对比

TCP：相当于打电话

  • 连接稳定

  • 三次握手，四次挥手

    三次握手：最少需要三次，保证稳定连接
    A：你好
    B：你好
    A：很高兴认识你
    ?
        
        
        
    四次挥手：
        A:我要断开连接了。
        B:你真要断开连接吗？
        B:你真的真要断开连接吗？
        A:我真的断开连接了

     

  • 客户端，服务端

  • 传输完成，释放连接，效率低

UDP：相当于发短信

  • 不连接，不稳定

  • 客户端，服务端：没有明确的界限

  • 不管有没有准备好，都可以发给你

  • DDOS：洪水攻击(饱和攻击)

TCP

客户端

  1. 连接服务器 Socket

  2. 发送消息

    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.Socket;
    ?
    //客户端
    public class TestTcpClient {
        public static void main(String[] args) {
            Socket socket =null;
            OutputStream OS = null;
            try {
                //1. 要知道服务器地址,端口号
                InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
                int port = 8888;
                //2.创建一个socket连接
                 socket = new Socket(inetAddress,port);
                //3.发送消息IO流
                 OS = socket.getOutputStream();
                OS.write("你好，欢迎光临".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();
                        }
                }
            }
        }
    }

服务端

  1. 建立服务的端口 ServerSocket

  2. 等待用户连接 accept

  3. 接受用户的消息

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
?
//服务端
public class TestTcpServer {
    public static void main(String[] args) {
        ServerSocket serverSocket =null;
        Socket socket =null;
        InputStream is = null;
        ByteArrayOutputStream baos =null;
        //我得有个地址
        try {
             serverSocket = new ServerSocket(8888);
        while(true){
            //等待客户端连接过来
             socket = serverSocket.accept();
            //读取客户端消息
             is = socket.getInputStream();
            //管道流
           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();
                }
            }
?
        }
    }
}

文件上传

服务器端

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
?
?
public class TestTcpClient1 {
    public static void main(String[] args) throws Exception {
        //创建一个Socket连接,端口号
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9999);
       //创建输出流
        OutputStream os = socket.getOutputStream();
        //读取文件
        FileInputStream fis = new FileInputStream(new File("1.jpg"));
        //写出文件
         byte[] buffer = new byte[1024];
         int len;
         while ((len= fis.read(buffer))!=-1){
             os.write(buffer,0,len);
         }
         //通知服务器，我已经结束了
        socket.shutdownOutput();//我已经传输完了
?
         //确定服务器接受完毕，断开连接
        InputStream inputStream = socket.getInputStream();
         //字符管道流
        ByteArrayOutputStream byo = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int len2 = 0;
        while ((inputStream.read(buffer2))!=-1){
            byo.write(buffer2,0,len2);
        }
        System.out.println(byo.toString());
        //关闭资源
        byo.close();
        inputStream.close();
        socket.close();
         os.close();
         fis.close();
    }
}

客户端

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
?
public class TestTcpServer1 {
    public static void main(String[] args) throws Exception {
        //创建服务
        ServerSocket serverSocket = new ServerSocket(9999);
        //监听客户端连接
        Socket socket = serverSocket.accept();
        //获取输入流
        InputStream is = socket.getInputStream();
       //文件输出  文件管道流
        FileOutputStream fio = new FileOutputStream(new File("receive.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len= is.read(buffer))!=-1){
            fio.write(buffer,0,len);
        }
        //通知客户端接受完毕
        OutputStream os = socket.getOutputStream();
        os.write("我已经接受完毕，请断开连接".getBytes());
?
?
        //关闭资源
        fio.close();
        is.close();
        socket.close();
        serverSocket.close();
?
?
?
    }
}

Tomcat

服务端

  • 自定义 S

  • Tomcat服务器 S

客户端

  • 自定义 C

  • 浏览器 B

UDP

不需要连接服务器，但是得知道对方地址。

发送消息

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
?
?
public class UdpClient {
    public static void main(String[] args) throws Exception {
         //1.建立Socket
        DatagramSocket datagramSocket = new DatagramSocket();
        //建个包
        String msg = "你好，世界";
        //发送给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;
        //数据，数据得长度起始，发送给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);
        //发送包
        datagramSocket.send(packet);
        //关闭资源
        datagramSocket.close();
    }
}

接受消息

import java.net.DatagramPacket;
import java.net.DatagramSocket;
?
?
public class UdpServer {
    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());
        System.out.println(new String(packet.getData(),0,packet.getLength()));
        //关闭资源
        socket.close();
    }
}

咨询

循环发送消息

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.*;
?
public class TestSender {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(9999);
         //准备数据 控制台读取System.in
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        while (true){
        String data = reader.readLine();
        byte[] bytes = data.getBytes();
        DatagramPacket packet = new DatagramPacket(bytes,0,bytes.length,new InetSocketAddress("localhost",6666));
        socket.send(packet);
        if (data.equals("bye")){
            break;
        }
        }
        //关闭
        socket.close();
    }
}
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class TestReceive {
    public static void main(String[] args) throws Exception {
?
        DatagramSocket socket = new DatagramSocket(6666);
?
       while (true){
           //准备接受包裹
           byte[] buffer = new byte[1024];
           DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
           socket.receive(packet);//阻塞式接受数据
           // 断开连接
           byte[] data = packet.getData();
           String receiveData = new String(data,0, data.length);
           if (receiveData.equals("bye")){
               break;
           }
       }
      socket.close();
    }
}

需求:在线咨询，两个人都可以是发送方，也都可以是接受方

TalkSend类

import java.io.BufferedReader;
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[] bytes = data.getBytes();
                DatagramPacket packet = new DatagramPacket(bytes,0,bytes.length,new InetSocketAddress(this.toIP,this.toPort));
                socket.send(packet);
                if (data.equals("bye")){
                    break;
                }
?
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

TalkReceive类

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[] buffer = new byte[1024];
                DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
                socket.receive(packet);//阻塞式接受包裹
                // 断开连接
                byte[] data = packet.getData();
                String receiveData = new String(data,0, data.length);
                System.out.println(msgFrom+":"+receiveData);
                if (receiveData.equals("bye")){
                    break;
                }
            }catch (Exception e){
                e.printStackTrace();
            }
?
        }
      socket.close();
    }
    }

Student类

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

Teacher类

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

URL

https://www.baidu.com/

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

DNS域名解析： www.baidu.com xxx.x..x..x

协议://ip地址:端口/项目名

下载资源

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
?
import java.net.URL;
?
public class TestDown {
    public static void main(String[] args) throws Exception {
       //1.下载地址
        URL url = new URL("");
        //2.连接到这个资源HTTP
        HttpURLConnection http = (HttpURLConnection) url.openConnection();
        InputStream inputStream = http.getInputStream();
        FileOutputStream fio = new FileOutputStream("");
        byte[] buffer = new byte[1024];
        int len;
        while ((len= inputStream.read(buffer))!=-1){
            fio.write(buffer,0,len);//写出这个数据
        }
        fio.close();
        inputStream.close();
        http.disconnect();//断开连接
    }
}

网络编程

原文：https://www.cnblogs.com/MTTRYING/p/14413364.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！