java网络编程

ChengLAA

已于 2023-03-01 10:51:47 修改

阅读量245

点赞数

文章标签：网络 udp 网络协议

于 2022-02-09 11:36:49 首次发布

本文链接：https://blog.csdn.net/weixin_63262602/article/details/122822667

版权

笔记专栏收录该内容

12 篇文章 0 订阅

订阅专栏

概述

计算机网络：

把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大，功能强的网络系统，从而使众多的计算机可以方便地互相传递信息，共享硬件，软件，数据信息等资源。

网络编程的目的：

直接或间接地通过网络协议与其他计算机实现数据交换，进行通讯。

网络编程的两个要素：

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

如何准确的定位网络上一台或多台主机；定位主机上的特定的应用

找到主机后如何可靠高效的进行数据传输

2. 网络编程中的两个要素：

ip 和端口号

提供网络通信协议。 TCP/IP参考模型（应用层，传输层，网络层，物理+数据链路层）

Inet Adderss

ip 地址： Inet Adderss

唯一的标识 internet 上的计算机 ( 通信实体 )

本地回环地址（hostAddress）：127.0.0.1 主机名 ( hostName )：localhost

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

端口号

端口号标识正在计算机上运行的进程（程序）

不同的进程有不同的端口号，用来区分软件
被规定为一个16位的整数 0~65535
TCP 和 UDP 各有 65535个端口，单个协议下端口不能冲突

端口分类：

公认端口： 0~1023。被预先定义的服务通信占用端口。
HTTP 默认端口： 80

HTTPS 默认端口：443

FTP 默认端口： 21

Telnet 默认端口：23
注册端口：1024~49151、分配给用户进程或应用程序。
tomcat 默认端口：8080

Mysql 默认端口：3306

Oracle 默认端口：1521

动态、私有端口：49152~65535

dos命令
netstat -ano #查看所有端口 
netstat -ano|findstr "6732" #查看指定端口 
tasklist|findstr "6732" #查看指定进程 # 
crtl+shift+ESC 使用任务管理器查看PID

网络通信协议

网络通信协议：

计算机网络中实现通信必须有一些约定，即通信协议，对速率，传输代码，代码结构，传输控制步骤，出错控制等制定标准。

TCP/IP 协议簇

传输层协议中有两个非常重要的协议：

用户传输协议 TCP （Transmission Control Protocol）

用户数据报协议（User Datagram Protocol）

Tcp/IP 以其两个主要协议：传输控制协议-TCP，和网络互联协议-IP，而得名，实际上是一组协

议，包括多个具有不同功能且互为关联的协议。

IP（Internet Protocol）协议是网络层的主要协议，支持网间互联的数据通信。

TCP/IP协议模型从更实用的角度出发，形成了高效的四层体系结构，即物理链路层，IP层，传输层和应用层

TCP 和 UDP 对比

TCP协议-打电话

使用TCP协议前，必须建立TCP连接，形成传输数据通道；
传输前，采用 ‘ 三次握手 ’ 方式，点对点通信，是可靠的。
TCP协议进行通信的两个应用进程：客户端，服务端。
在连接中可进行大数据量的传输
传输完毕，需要释放已建立的连接，效率低

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

UDP协议-发短信

将数据，源，目的封装成数据包，不需要建立连接
每个数据报的大小限制在64K内
发送方不管对方是否准备好，接收方收到也不确认，故事不可靠的
可以广播发送
发送数据结束时，无需释放资源，开销小，速度快。

TCP网络编程

案例一

需求：客户端发送信息给服务端，服务端将数据显示在控制台上。

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 = 8899; 

//2. 创建一个Socket 
socket = new Socket(serverIP,port); 

//3. 创建一个输出流，向外写东西 
os = socket.getOutputStream(); 
os.write("你好,欢迎学习狂神说Java".getBytes()); 
} catch (UnknownHostException e) { 
e.printStackTrace(); 
} catch (IOException e) { 
e.printStackTrace(); 
} finally { 
//4. 关闭资源 
try {
if (os!=null){ 
os.close(); 
}if (socket!=null){ 
socket.close(); 
} } catch (IOException e) { 
e.printStackTrace(); } } } }

import javax.sound.midi.Soundbank; 
import java.io.ByteArrayOutputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.net.ServerSocket; 
import java.net.Socket; 
import java.util.Base64; 

//服务端 
public class TcpServerDemo01 { 
public static void main(String[] args) {
ServerSocket serverSocket = null; 
Socket accept = null; 
InputStream is = null; 
ByteArrayOutputStream baos = null; 
try {

//1. 开放服务器端口，创建ServerSocket 
serverSocket = new ServerSocket(8899); 
//2. 等待客户端的连接 
accept = serverSocket.accept(); 
//3. 读入客户端的消息, 
is = accept.getInputStream(); 
/*回忆之前的IO流方案，弊端：存在中文，可能存在乱码。 
byte[] buffer = new byte[1024]; 
int len; 
while ((len=is.read(buffer))!=-1){ 
String str = new String(buffer,0,len); 
System.out.println(str); }**/ 

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()); 
System.out.println( "数据来源地址："+accept.getInetAddress().getHostName()); 
} catch (IOException e) { 
e.printStackTrace(); 
} finally { 
//4. 关闭资源 
try {if (baos!=null){ 
baos.close(); 
}if (is!=null){ 
is.close(); 
}if (accept!=null){ 
accept.close(); }
if (serverSocket!=null){ 
serverSocket.close(); } 
}catch (Exception e){ e.printStackTrace(); } } } }

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAaXNfa2Q=,size_14,color_FFFFFF,t_70,g_se,x_16

案例二

需求：客户端发送文件给服务器，服务端将文件保存在本地。

我们需要准备一个图片，放在项目目录下： watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

客户端：

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

服务端

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

案例三

需求：我们需要在案例二的基础上，接收成功后，返回给客户端，接收成功！然后客户端才关闭连接！

客户端

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

//客户端 
public class TcpClientDemo03 { 
public static void main(String[] args) throws Exception{ 
//1. 创建socket连接 
Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090); 
//2. 创建一个输出流 
OutputStream os = socket.getOutputStream(); 
//3. 读取文件 
FileInputStream fis = new FileInputStream(new File("qinjiang.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(); 
ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
byte[] buffer2 = new byte[1024]; 
int len2; 
while ((len2=inputStream.read(buffer2))!=-1){ 
baos.write(buffer2,0,len2); 
}System.out.println(baos.toString()); 

//5. 资源关闭,应该使用 
try-catch-finally baos.close(); 
inputStream.close(); 
fis.close(); 
os.close(); 
socket.close(); } }

服务端

 import java.io.File; 
import java.io.FileOutputStream; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.net.ServerSocket; 
import java.net.Socket; 

//服务端 
public class TcpServerDemo03 { 
public static void main(String[] args) throws Exception { 
//1. 开启 
ServerSocket ServerSocket serverSocket = new ServerSocket(9090); 
//2. 侦听 客户端 
Socket Socket socket = serverSocket.accept(); 
//3. 获取输入流 
InputStream is = socket.getInputStream(); 
//4. 读取接收的文件并保存 
FileOutputStream fos = new FileOutputStream(new File("receive2.jpg")); 
byte[] buffer = new byte[1024]; 
int len; 
while ((len=is.read(buffer))!=-1){ 
fos.write(buffer,0,len); }
//通知客户端接收成功 
OutputStream outputStream = socket.getOutputStream(); 
outputStream.write("文件已经成功收到，OK".getBytes()); 
//5.关闭资源,应该使用 
try-catch-finally outputStream.close(); 
fos.close(); 
is.close(); 
socket.close(); 
serverSocket.close(); } }

UDP网络编程

DatagramSocket 和 DatagramPacket 两个类实现了基于UDP协议的网络程序。
UDP 数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不确定什么时候可以抵达。
DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。
UDP协议中每个数据报都给出了完整的地址信息，因此无需建立发送方和接收方的连接。如同发快递包裹一样。

发短信，不需要链接服务器，需要知道对方地址

//发送方

package InetAddresss;

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

//不需要链接服务器
public class UDPText01 {
    public static void main(String[] args) throws Exception{
        //1建立一个Socket
        DatagramSocket datagramSocket = new DatagramSocket();
        //2建个包
        String msg="hello";
        //发送给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port=9090;
        //数据，数据的起始长度，要发送给谁
        DatagramPacket datagramPacket = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,localhost,port);
       //3发送包
        datagramSocket.send(datagramPacket);
        //关闭
        datagramSocket.close();

    }
}

//接收方
package InetAddresss;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
//等待客户端链接
public class UDPText02 {
    public static void main(String[] args) throws Exception{
        //开放端口
        DatagramSocket datagramSocket = new DatagramSocket(9090);
        //接收数据（包）
        byte[] bytes = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length);
        datagramSocket.receive(datagramPacket);//阻塞接收
        System.out.println(datagramPacket.getAddress().getHostAddress());
        System.out.println(new String(datagramPacket.getData(),0,datagramPacket.getLength()));
        datagramSocket.close();


    }
}

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

2循环发送

//发送
package chat;

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

public class UdpSener01 {
    public static void main(String[] args) throws  Exception{
        DatagramSocket datagramSocket = new DatagramSocket(8888);
        //准备数据，控制台读取 System.IN
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
while (true) {
    String data = bufferedReader.readLine();
    byte[] bytes = data.getBytes();


    DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length, new InetSocketAddress("localhost", 6666));

    datagramSocket.send(datagramPacket);
    if (data.equals("bye")) {
        break;
    }
}

        datagramSocket.close();

    }
}

//接收
package chat;

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

public class UdpSener01 {
    public static void main(String[] args) throws  Exception{
        DatagramSocket datagramSocket = new DatagramSocket(8888);
        //准备数据，控制台读取 System.IN
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
while (true) {
    String data = bufferedReader.readLine();
    byte[] bytes = data.getBytes();


    DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length, new InetSocketAddress("localhost", 6666));

    datagramSocket.send(datagramPacket);
    if (data.equals("bye")) {
        break;
    }
}

        datagramSocket.close();

    }
}

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16 2.2互相发送-双方都可以是发送方或者接收方-多线程实现

//发送

package 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;

public class TalkSend implements Runnable{
    DatagramSocket datagramSocket=null;
    BufferedReader bufferedReader=null;
    private int fromPort;
    private String toIP;
    private int toPort;

    public TalkSend(int fromPort, String toIP, int toPort) throws IOException {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;
        datagramSocket = new DatagramSocket(fromPort);
        bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    }

    @Override
    public void run() {


        //准备数据，控制台读取 System.IN

        while (true) {
            try {
                String data = bufferedReader.readLine();
                byte[] bytes = data.getBytes();
                DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length, new InetSocketAddress(this.toIP, this.toPort));
                datagramSocket.send(datagramPacket);
                if (data.equals("bye")) {
                    break;
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        datagramSocket.close();
    }
}

//接收

package chat;

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

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

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

    @Override
    public void run() {


        while (true) {
            try {
                //准备接收包
                byte[] bytes = new byte[1024];
                DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length);
                datagramSocket.receive(datagramPacket);//阻塞式接受包
                //断开链接
                byte[] data = datagramPacket.getData();
                int len = datagramPacket.getLength();
                String s = new String(data, 0, len);
                System.out.println(msgFrom+"->" +s);
                if (s.equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }


        }datagramSocket.close();
    }
}

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

URL编程

URL （Uniform Resource Locator）：统一资源定位符，它表示 internet 上某一资源的地址。

import java.net.MalformedURLException; 
import java.net.URL; 

public class URLDemo01 { 

public static void main(String[] args) { 
try {
URL url = new URL("http://localhost:8080/helloworld/index.jspusername=kuangshen&password=123"); System.out.println(url.getProtocol()); //获取URL的协议名 
System.out.println(url.getHost()); //获取URL的主机名 
System.out.println(url.getPort()); //获取URL的端口号 
System.out.println(url.getPath()); //获取URL的文件路径 
System.out.println(url.getFile()); //获取URL的文件名 
System.out.println(url.getQuery()); //获取URL的查询名 
} catch (MalformedURLException e) { 
.printStackTrace(); 
} } }

2.利用URL从网站下载资源

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

package URL;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class Text01 {
    public static void main(String[] args) {
        try {
            //1. 定位到服务器端的资源
           URL url = new URL("https://m10.music.126.net/20220210142127/65e84476ccf77844fea39827782bf045/yyaac/535a/5659/565c/d06d092f2da3b00fc60ba676e2c2fc5d.m4a");
            //2. 创建连接
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            //3. 获取输入流
            InputStream is = connection.getInputStream();
            //4. 写出文件
            FileOutputStream fos = new FileOutputStream("d.m4a");
            byte[] buffer = new byte[1024];
            int len;
            while ((len=is.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }
            //关闭资源
            fos.close();
            is.close();
            connection.disconnect(); //断开连接
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    }