网络编程

最新推荐文章于 2024-05-20 20:42:03 发布

API工程师@

最新推荐文章于 2024-05-20 20:42:03 发布

阅读量164

点赞数

文章标签：网络 java

本文链接：https://blog.csdn.net/ghjgjhyfht/article/details/114870817

版权

网络编程

1.1、概述

打电话—>连接---->接了----->通话：TCP

发短信---->发送了就完事了---->接受：UDP

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

网络编程的目的：数据交换、通信。

想到达到什么效果：

1、如何准确的定位一台电脑：127.0.0.1:端口这个计算机上的某个资源

2、找到了这个主机，如何传输数据。

javaweb：网页编程 B/S

网络编程：TCP/IP C/S

1.2、网络通信的要素

1、通信双方的地址：ip 端口号

2、规则：网络通信的协议 TCP/IP模型

小结：
1、网络编程两个问题：

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

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

2、网络编程中的要素

IP和端口号 IP

网络通信协议 UDP TCP

3、万物皆对象

1.3、ip地址

ip地址：InetAddress

唯一定位一台网络上的计算机
127.0.0.1：本机localhost
IP地址的分类
- IPv4/IPv6
  - IPv4：127.0.0.1，4个字节组成，0~255 42亿
  - IPv6： 128位，8个无符号整数！
```
2001:0bb2:aaaa:0015:0000:0000:1236:1256
```
- 公网-私网
  - 公网：互联网
  - 私网：局域网：192.168.xx.xx 某个组织

域名：记忆IP问题！

package com.xu.lesson1;

import java.net.InetAddress;
import java.net.UnknownHostException;
//查看ip地址
public class TestInetAddress {
    public static void main(String[] args) {
        try {
            //查询网站地址
            InetAddress inetAddress = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress);
            InetAddress inetAddress1 = InetAddress.getByName("localhost");
            System.out.println(inetAddress1);
            InetAddress inetAddress2 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress2);
            //常用方法
            System.out.println(inetAddress.getCanonicalHostName());
            System.out.println(inetAddress.getHostAddress());
            System.out.println(inetAddress.getHostName());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

1.4、端口

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

不同的进程有不同的端口号！用来区分软件
被规定：0~65535
TCP/UDP:65535*2 tcp:80,udp:80,单个写一下，端口号不能冲突
端口分类：
- 动态、私有端口：49125~65535
```
netstat -ano//查看所有的端口
netstat -ano|findstr 端口
tasklist|findstr "8696"
```
- 程序注册端口：1024~49151，分配用户端口
  - Tomcat:8080
  - MySQL:3306
  - Oracle:1521
- 公网端口：0~1023
  - HTTP:80
  - HTTPS:443
  - FTP:21
  - SSH:22
  - TELENT:23

package com.xu.lesson1;

import java.net.InetSocketAddress;

public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1",80);
        System.out.println(socketAddress);
        System.out.println(socketAddress.getAddress());
        System.out.println(socketAddress.getHostName());
        System.out.println(socketAddress.getPort());
    }
}

1.5、通信协议

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

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

大事化小：分层！

TCP/IP协议：一组协议

TCP:用户传输协议
UDP:用户数据报协议

出名：

TCP:
IP:网络互连协议

TCP和UDP的对比：
TCP:打电话

连接稳定

三次握手，四次挥手

最少遇到三次，保证连接
A:你瞅啥
B:瞅你咋的
A:来干
最少四次，保证断开
A:我要睡了
B:你真的睡了吗
B:你真的真的睡了吗
A:我真的睡了

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

UDP:发短信

不连接，不稳定
客户端和服务端：没有明确的界限
不管有没有，都可以发给你。

1.6、TCP

客户端：

1、连接服务器Socket

2、发送消息

package com.xu.lesson1;

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

public class TCPClient {
    public static void main(String[] args) {
        Socket socket=null;
        OutputStream outputStream=null;
        try {
            //要知道服务器地址
            InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
            //端口号
            int port=9999;
            //创建一个socket连接
            socket = new Socket(inetAddress,port);
            //发送消息IO流
            outputStream = socket.getOutputStream();
            outputStream.write("hello".getBytes());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务器：

1、建立服务的端口 ServerSocket

2、等待用户的连接 accept

3、接受用户的消息

package com.xu.lesson1;


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

public class TCPServer {
    public static void main(String[] args) {
        ServerSocket serverSocket=null;
        Socket accept=null;
        InputStream inputStream=null;
        ByteArrayOutputStream byteArrayOutputStream=null;
        try {
            //需要一个服务器地址
             serverSocket = new ServerSocket(9999);
            //等待客户端连接
             accept = serverSocket.accept();
            //读取客户端消息
             inputStream = accept.getInputStream();
            //管道流
            byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] aByte = new byte[1024];
            int len;
            while ((len=inputStream.read(aByte))!=-1){
                byteArrayOutputStream.write(aByte,0,len);
            }
            System.out.println(byteArrayOutputStream.toString());

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭

            try {
                byteArrayOutputStream.close();
                inputStream.close();
                accept.close();
                serverSocket.close();
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
}

文件上传：

服务端

package com.xu.lesson1;

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

public class TCPclient02 {
    public static void main(String[] args) throws IOException {

        //建立连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9900);

        //建立输出流
        OutputStream os =socket.getOutputStream();
        //文件输入
        FileInputStream fis = new FileInputStream(new File("JavaKuangStudy/network programming/src/ImageData/Test.png"));
        //缓冲区之后
        //需要转换格式
        //写出文件
        byte[] buff = new byte[1024];//划定空间
        int len;
        while((len= fis.read(buff))!=-1){
            os.write(buff,0,len);
        }

        //确定服务器接收完毕才能断开连接。
        //发送成功后关闭输出流
        //通知服务器我已经输出结束了
        socket.shutdownOutput();
        //接收来自服务端的消息，用数组流来输出
        InputStream is = socket.getInputStream();
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        int len1;
        byte[] buff1 = new byte[1024];//初始内存空间大小
        while((len1=is.read(buff1))!=-1){
            bos.write(buff1,0,len1);
        }
        System.out.println(bos.toString());
        //关闭资源
        bos.close();
        is.close();
        fis.close();
        os.close();
        socket.close();
    }
}
 /*
 1、抛出异常
 2、套接字的get输入输出流
 3、通知服务器，我已经输出结束了：socket.shutdownOutput();
 4、while（（len=is.read(buff)）!=-1）{
     bos.write(buff,0,len);
 5、while和0-长度
 }
  */

服务端：

package com.xu.lesson1;

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

public class TCPserver02 {
    public static void main(String[] args) throws IOException {

        //建立连接，创建服务
        ServerSocket serverSocket= new ServerSocket(9900);
        // 监听客户端的连接
        Socket socket = serverSocket.accept();
        //创立输入流
        InputStream is = socket.getInputStream();
        // 文件输出
        FileOutputStream fos = new FileOutputStream(new File("JTest3.png"));
        //创立缓冲区和写
        byte[] buff=new byte[1024];
        int len;
        while((len=is.read(buff))!=-1){
            fos.write(buff,0,len);
        }
        //与客户端说我已经收到了
        OutputStream os =socket.getOutputStream();
        os.write("我已接收".getBytes());
        //关闭资源
        os.close();
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}
 /*
 1、接收要read，所以要用inputStream
 2、要把文件写给大家看，所以要fileoutputstream
  */

1.7、Tomcat

调试：consolehandler:GBK

服务端

自定义（S）
Tomcat服务器(S)：Java后台开发用别人的服务器！

客户端

自定义（C）
浏览器(B)

1.8、UDP消息发送

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

发送消息

发送端

 package Udp01;
 
 import java.net.*;
 //不需要连接服务器
 public class UdpTest02 {
 public static void main(String[] args) throws Exception {
     //建立一个socket
     DatagramSocket socket=new DatagramSocket();
     //建个包
     InetAddress inetAddress=InetAddress.getByName("localhost");
     byte[] Str= "你好".getBytes();
     int port=9999;
     //数据，数据的长度起始，要发送给谁
     DatagramPacket datagramPacket=new DatagramPacket(Str,0,Str.length,inetAddress,port);
     //发送包
     socket.send(datagramPacket);
     //关闭流
     socket.close();
 }
 }

接收端：

 package Udp01;
 
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.SocketException;
 
 //还是要等待客户端的链接
 public class UdpTest01 {
 public static void main(String[] args) throws Exception {
     //开放端口
     DatagramSocket socket=new DatagramSocket(9999);
 while (true) {
     //接收数据包
     byte[] Strin = new byte[1024];
     DatagramPacket datagramPacket = new DatagramPacket(Strin, 0, Strin.length);
     //阻塞接收
     socket.receive(datagramPacket);
     System.out.println(new String(datagramPacket.getData(), 0, datagramPacket.getLength()));
     //关闭链接
     socket.close();
 }
 }
 }

咨询

循环发送消息

发送方：

package UDP.Udp02;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

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

    while (true){
        //准备数据，控制台读取System.in
        BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));

        //读取控制台输入的一行并把它转化为字符
        String Buf=buf.readLine();

    InetAddress inetAddress=InetAddress.getByName("localhost");
    DatagramPacket datagramPacket=new DatagramPacket(Buf.getBytes(),0,Buf.length(),inetAddress,9999 );

    datagramSocket.send(datagramPacket);

    if(Buf.equals("bye"))
       datagramSocket.close();
    }
    
}
}
/*
1、BuffReader读取控制台字符时用readLine来读取一行
 */

接收方：

package UDP.Udp02;

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

public class UdpSin01 {
public static void main(String[] args) throws Exception{
    //建立链接
    DatagramSocket datagramSocket = new DatagramSocket(9999);
    byte[] bufin = new byte[1024];
    while (true) {

        //准备接收包裹
        DatagramPacket datagramPacket = new DatagramPacket(bufin, 0, bufin.length);

        datagramSocket.receive(datagramPacket);//阻塞时接收包裹

        byte[] data=datagramPacket.getData();
        String msg=new String(data,0,data.length);
        System.out.println(msg);

        if(msg.equals("bye")){
             datagramSocket.close();
        }

       
    }
}
}
/*
1、创建对象 while之外
2、接收包裹.getData
 */

在线咨询：两个人都可以发送

发送端线程：

package UDP.Run;

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

public class Sent implements Runnable{
    DatagramSocket datagramSocket;
    DatagramPacket datagramPacket;
    private int fromPort;
    private String toIP;
    private int Toport;
    BufferedReader bufferedReader;
    String buf;

public Sent(int fromPort, String toIP, int Toport) {
    this.fromPort = fromPort;
    this.toIP = toIP;
    this.Toport = Toport;
    try {
        this.datagramSocket = new DatagramSocket(fromPort);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Override
public void run() {
    while(true){
        try {
            bufferedReader=new BufferedReader(new InputStreamReader(System.in));
            buf=bufferedReader.readLine();
            byte[] buff=buf.getBytes();
            datagramPacket= new DatagramPacket(buff,0,buff.length,new                     InetSocketAddress(this.toIP,this.Toport));

            datagramSocket.send(datagramPacket);

            if (buf.equals("bye")){
               datagramSocket.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
}
}
/*今日日记
1、IP:String
2、DatagramSocket(端口)
2、BuffReader（输入流）；
3、发送要把String变成数组
 */

接收端线程：

package UDP.Run;

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

public class Receive implements Runnable{
    DatagramSocket datagramSocket;
DatagramPacket datagramPacket;
private String FromID;
    private int Port;

public Receive(String fromID, int port) {
    this.FromID = fromID;
    this.Port = port;

    try {
        datagramSocket=new DatagramSocket(port);
    } catch (SocketException e) {
        e.printStackTrace();
    }
}

@Override
public void run() {
    while (true) {
        try {
            byte[] buff = new byte[1024];
           datagramPacket = new DatagramPacket(buff, 0, buff.length);
            datagramSocket.receive(datagramPacket);

            byte[] data=datagramPacket.getData();
            String msg=new String(data,0,data.length);

            System.out.println(FromID + ":" +msg);

            if (datagramPacket.equals("bye")) {
              datagramSocket.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
}
}
//重新定义数组

学生端：

package UDP.Run;

import UDP.Run.Receive;
import UDP.Run.Sent;

public class Student {
public static void main(String[] args) {
    new Thread(new Sent(7754,"localhost",9999)).start();
    new Thread(new Receive("老师：",7787)).start();
}

}
//线程要启动

老师端：

package UDP.Run;

import UDP.Run.Receive;
import UDP.Run.Sent;

public class Teacher {
public static void main(String[] args) {
    new Thread(new Sent(7755,"localhost",7787)).start();
    new Thread(new Receive("学生：",9999)).start();
}
}

1.9、URL

https://www.baidu.com/

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

DNS域名解析 WWW.baidu

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

public class Url {
public static void main(String[] args) throws IOException {
    URL url=new URL("https://m801.music.126.net/20201123231609/7a60a829f966abbdfc75ee0756ed0ff9/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/4916388353/e2fe/8be5/e1e6/c7614d21f4afc33120723d86e09d330d.m4a");
    HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

    InputStream in=urlConnection.getInputStream();
    FileOutputStream Fout=new FileOutputStream("d.m4a");

    byte[] buff=new byte[1024];
    int len;
    while ((len=in.read(buff))!=-1){
        Fout.write(buff,0,len);
    }

    Fout.close();
    in.close();
    urlConnection.disconnect();
}
}

API工程师@

关注

0
点赞
踩
0

收藏

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

网络编程1.1、概述打电话—>连接---->接了----->通话：TCP发短信---->发送了就完事了---->接受：UDP计算机网络：将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议(HTTP)的管理和协调下，实现资源共享和信息传递的计算机系统。网络编程的目的：数据交换、通信。想到达到什么效果：1、如何准确的定位一台电脑：127.0.0.1:端口这个计算机上的某个资源2、找到了这个主机，如
复制链接

扫一扫