网络编程一（随笔）

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量132 收藏
点赞数
分类专栏： Java基础 文章标签： java 网络 socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45493915/article/details/104203125
版权

网络编程一

一、常用类操作

（一）ip地址

定义：
用来标识网络中一个通信实体的地址。通信实体可以是计算机、路由器等。

IP地址分类：

  • IPV4:32位地址，以点分十进制表示，如：192.168.0.2
  • IPV6:128位，写成8个16位的无符号整数，每个整数用4个16进制表示，数之间用冒号隔开，如：3ffe:3201:1401:1280:c8ff:fe4d:db39:1984

特殊IP：
127.0.0.1是本机地址
192.168.0.0–192.168.255.255私有地址，属于非注册地址，专门为组织机构内部使用。

方法InetAddress：

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * InetAddress: 多个静态方法
 * 1、getLocalHost:本机
 * 2、getByName:根据域名DNS |  IP地址 -->IP
 * 
 * 两个成员方法
 * 1、getHostAddress: 返回地址
 * 2、getHostName:返回计算机名
 */
public class IPTest {

	public static void main(String[] args) throws UnknownHostException {
		//使用getLocalHost方法创建InetAddress对象  本机
		InetAddress addr = InetAddress.getLocalHost();
		System.out.println(addr.getHostAddress());  //返回：192.168.1.110
		System.out.println(addr.getHostName());  //输出计算机名
		
		//根据域名得到InetAddress对象
		addr = InetAddress.getByName("www.shsxt.com"); 
		System.out.println(addr.getHostAddress());  //返回 shsxt服务器的ip:
		System.out.println(addr.getHostName());  //输出：www.shsxt.com
		
		//根据ip得到InetAddress对象
		addr = InetAddress.getByName("123.56.138.176"); 
		System.out.println(addr.getHostAddress());  //返回 shsxt的ip:123.56.138.176
		System.out.println(addr.getHostName());  //输出ip而不是域名。如果这个IP地 址不存在或DNS服务器不允许进行IP地址和域名的映射，				
	}
}

（二）端口

定义：
IP地址是用来标识一台计算机，但一台计算机上可能提供多个网络应用程序，如何来区分这些不同的程序呢？这就要用到端口。
端口是虚拟的，通过端口，一个主机上可以运行多个网络应用程序。
端口表示是16位的2进制，2个字节，0-65535，UDP、TCP两种协议，同一协议端口不能冲突

每个网络应用程序都有自己的端口

  • 公认端口：0-1023 如：80端口分配给http协议，21端口分配给FTP
  • 注册端口：1024-49151分配用用户进程或应用程序
  • 动态/私有端口：49152-65535
  • 查看所有端口号：netstat -ano
  • 查看指定端口号：netstat -ano|findstr “808”
  • 查看指定进程：tasklist|findstr “808”
  • 查看具体程序：使用任务管理器查看PID

方法InetSocketAddress

import java.net.InetSocketAddress;
/**
 * InetSocketAddress 
 * 1、构造器
 *   new InetSocketAddress(地址|域名,端口);
 * 2、方法
 *  getAddress​()  
 *  getPort()
 *  getHostName()
 */
public class PortTest {

	public static void main(String[] args) {
		//包含端口
		InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1",8080);
		InetSocketAddress socketAddress2 = new InetSocketAddress("localhost",9000);
		System.out.println(socketAddress.getHostName());
		System.out.println(socketAddress.getAddress());
		System.out.println(socketAddress2.getAddress());
		System.out.println(socketAddress2.getPort());
	}
}

（三）URL

定义：
同一资源定位符，由四部分组成：协议、存放资源的主机名、端口号、资源文件名。
方法URL

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

/**
 * URL: 统一资源定位器,互联网三大基石之一(html http),区分资源
 * 1、协议
 * 2、域名、计算机
 * 3、端口: 默认80
 * 4、请求资源
 *  http://www.baidu.com:80/index.html?uname=shsxt&age=18#a
 */
public class URLTest01 {

	public static void main(String[] args) throws MalformedURLException {
		URL url = new URL("http://www.baidu.com:80/index.html?uname=shsxt&age=18#a");
		//获取四个值
		System.out.println("协议:"+url.getProtocol());
		System.out.println("域名|ip:"+url.getHost());
		System.out.println("端口:"+url.getPort());
		System.out.println("请求资源1:"+url.getFile());
		System.out.println("请求资源2:"+url.getPath());
		//参数
		System.out.println("参数:"+url.getQuery());
		//锚点
		System.out.println("锚点:"+url.getRef());
	}
}

模拟网络爬虫
案例1：

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
public class SpiderTest01 {
	public static void main(String[] args) throws Exception {
		//获取URL
		URL url =new URL("https://www.jd.com");
		//下载资源
		InputStream is = url.openStream();
		BufferedReader br =new BufferedReader(new InputStreamReader(is,"UTF-8"));
		String msg =null;
		while(null!=(msg=br.readLine())) {
			System.out.println(msg);
		}
		br.close();
		//分析
		//处理。。。。
	}
}

案例2：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * 网络爬虫的原理 +模拟浏览器
 */
public class SpiderTest02 {
	public static void main(String[] args) throws Exception {
		//获取URL
		URL url =new URL("https://www.dianping.com");
		//下载资源
		HttpURLConnection  conn =(HttpURLConnection) url.openConnection();
		conn.setRequestMethod("GET");
		conn.setRequestProperty("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36");
		BufferedReader br =new BufferedReader(new InputStreamReader(conn.getInputStream(),"UTF-8"));
		String msg =null; 
		while(null!=(msg=br.readLine())) {
			System.out.println(msg);
		}
		br.close();
		//分析
		//处理。。。。
	}
}

二、TCP编程

补充套接字
我们开发的网络应用程序位于应用层，TCP和UDP属于传输层协议，在应用层如何使用传输层的服务呢？在应用层和传输层之间则是使用套接字来进行分离，它就像传输层为应用层开的一个小口

TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议。
特点：

  • 面向连接
  • 点到点的通信
  • 高可靠性
  • 占用系统资源多，效率低
  • TCP协议基于请求——响应模式
  • 在网络通讯中，第一次主动发起通讯的程序被称作客户端程序
  • 在一次通讯中等待连接的程序被称作服务器端程序
  • 利用IO流实现数据传输
    在这里插入图片描述
    详细步骤：
    在这里插入图片描述
    案例1
    服务器
import java.io.DataInputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * 熟悉流程
 * 创建服务器
 * 1.指定端口：使用ServerSocket创建服务器
 * 2.阻塞式等待连接accept
 * 3.操作：输入输出操作
 * 4.释放资源
 */
public class Server {
    public static void main(String[] args) throws IOException {
        //1.指定端口：使用ServerSocket创建服务器
        ServerSocket server=new ServerSocket(8888);
        // 2.阻塞式等待连接accept
        Socket client=server.accept();
        System.out.println("一个客户端建立了连接！");
        // 3.操作：输入输出操作
        DataInputStream dis=new DataInputStream(client.getInputStream());
        String data=dis.readUTF();
        System.out.println(data);
        // 4.释放资源
        dis.close();
        client.close();
    }
}

服务器

import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

/**
 * 熟悉流程
 * 创建客户端
 * 1.建立连接：使用Socket创建客户端+服务的地址和端口
 * 2.操作：输入输出操作
 * 3.释放资源
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //1.建立连接：使用Socket创建客户端+服务的地址和端口
        Socket client=new Socket("localhost",8888);
        //2.操作：输入输出操作
        DataOutputStream dos=new DataOutputStream(client.getOutputStream());
        String data="hello";
        dos.writeUTF(data);
        dos.flush();
        //3.释放资源
        dos.close();
        client.close();
    }
}

案例2：服务器接收多个客户端的请求，并给出反馈
服务器

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 模拟登录 多个客户端请求
 * 创建服务器
 * 1、指定端口 使用ServerSocket创建服务器
 * 2、阻塞式等待连接 accept
 * 3、操作: 输入输出流操作
 * 4、释放资源 
 */
public class LoginMultiServer {
	public static void main(String[] args) throws IOException {
		System.out.println("-----Server-----");
		// 1、指定端口 使用ServerSocket创建服务器
		ServerSocket server =new ServerSocket(8888);
		boolean isRunning =true;;
		// 2、阻塞式等待连接 accept
		while(isRunning) {
			Socket  client =server.accept(); 
			System.out.println("一个客户端建立了连接");
			new Thread(new Channel(client)).start();
		}
		server.close();
	}
	//一个channel就代表一个客户端
	static class Channel implements Runnable{
		private Socket  client;
		//输入流
		private DataInputStream dis;
		//输出流
		private DataOutputStream dos;
		public Channel(Socket  client) {
			this.client = client;
			try {
				//输入
				dis = new DataInputStream(client.getInputStream());
				//输出
				dos =new DataOutputStream(client.getOutputStream());	
			} catch (IOException e) {
				e.printStackTrace();
				release();
			}	
		}	
		//接收数据
		private String receive() {
			String datas ="";
			try {
				datas = dis.readUTF();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return datas;
		}
		//释放资源
		private void release() {
			// 4、释放资源 
			try {
				if(null != dos) {
					dos.close();					
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if(null != dis) {
					dis.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if(null != client) {
					client.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		//发送数据
		private void send(String msg) {
			try {
				dos.writeUTF(msg);
				dos.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		@Override
		public void run() {						
			// 3、操作: 输入输出流操作					
			String uname ="";
			String upwd ="";
			//分析
			String[] dataArray = receive().split("&");
			for(String info:dataArray) {
					String[] userInfo =info.split("=");
					if(userInfo[0].equals("uname")) {
						System.out.println("你的用户名为:"+userInfo[1]);
						uname = userInfo[1];
					}else if(userInfo[0].equals("upwd")) {
						System.out.println("你的密码为:"+userInfo[1]);
						upwd = userInfo[1];
					}				
			}					
			if(uname.equals("shsxt") && upwd.equals("laopei")) { //成功
				send("登录成功，欢迎回来");
			}else { //失败
				send("用户名或密码错误");
			}
			release();
		}
	}
}

客户端

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;
/**
 * 模拟登录  多个客户端请求
 * 创建客户端
 * 1、建立连接: 使用Socket创建客户端 +服务的地址和端口
 * 2、操作: 输入输出流操作
 * 3、释放资源 
 */
public class LoginMultiClient {
	public static void main(String[] args) throws UnknownHostException, IOException {		
		System.out.println("-----Client-----");
		//1、建立连接: 使用Socket创建客户端 +服务的地址和端口
		Socket client =new Socket("localhost",8888);
		//2、操作: 输入输出流操作  先请求后响应
		new Send(client).send();
		new Receive(client).receive();		
		client.close();
	}
	//发送
	static class Send{
		private Socket client;
		private DataOutputStream dos;
		private BufferedReader console ;
		private String msg;
		public Send(Socket client) {			
			console=new BufferedReader(new InputStreamReader(System.in));
			this.msg =init();
			this.client = client;
			try {
				dos=new DataOutputStream(client.getOutputStream());
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		private String init() {					
			try {
				System.out.print("请输入用户名:");
				String uname =console.readLine();
				System.out.print("请输入密码:");
				String upwd =console.readLine();
				return "uname="+uname+"&"+"upwd="+upwd;
			} catch (IOException e) {
				e.printStackTrace();
			}
			return "";			
		}
		public void send() {
			try {
				dos.writeUTF(msg);
				dos.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	//接收
	static class Receive{
		private Socket client;
		private DataInputStream dis;
		public Receive(Socket client) {
			this.client = client;
			try {
				dis=new DataInputStream(client.getInputStream());
			} catch (IOException e) {
				e.printStackTrace();
			}
		}		
		public void receive() {
			String result;
			try {
				result = dis.readUTF();
				System.out.println(result);
			} catch (IOException e) {
				e.printStackTrace();
			}				
		}
	}
}

三、UDP编程

UDP是一种无连接的传输层协议，提供面向事务的简单不可靠信息传输服务。
特点：

  • 非面向连接，传输不可靠，可能丢失
  • 发送方不管对方是否准备好，接收方收到也不确认
  • 可以广播发送
  • 非常简单的协议，开销小
    案例1：简单的发送接收
    发送端
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
/**
 * 发送端
 * 1.使用DatagramSocket 指定端口 创建发送端
 * 2.准备数据 一定转成字节数组
 * 3.封装成DatagramPacket 包裹，需要指定目的地
 * 4.发送包裹send（DatagramPacket p）
 * 5.释放资源
 */
public class UdpClient {
    public static void main(String[] args) throws Exception {
        System.out.println("发送方启动中......");
        //1.使用DatagramSocket 指定端口 创建发送端
        DatagramSocket client=new DatagramSocket(8888);
        //2.准备数据 一定转成字节数组
        String data="你今天真好看";
        byte[] datas=data.getBytes();
        //3.封装成DatagramPacket 包裹，需要指定目的地
        DatagramPacket packet=new DatagramPacket(datas,0,datas.length,
                new InetSocketAddress("localhost",9999));
        //4.发送包裹send（DatagramPacket p）
        client.send(packet);
        //5.释放资源
        client.close();
    }
}

接收端

import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
 * 接收端
 * 1.使用DatagramSocket 指定端口 创建接收端
 * 2.准备容器 封装成DatagramPacket 包裹
 * 3.阻塞式接收包裹receive（DatagramPacket p）
 * 4.分析数据
 * byte[] getData()
 *        getLength()
 * 5.释放资源
 */
public class UdpServer {
    public static void main(String[] args) throws Exception {
        System.out.println("接收方启动中......");
        //1.使用DatagramSocket 指定端口 创建接收端
        DatagramSocket server=new DatagramSocket(9999);
        //2.准备容器 封装成DatagramPacket 包裹
        byte[] container=new byte[1024*60];
        DatagramPacket packet=new DatagramPacket(container,0,container.length);
        //3.阻塞式接收包裹receive（DatagramPacket p）
        server.receive(packet);
        //4.分析数据
        // byte[] getData()
        //        getLength()
        byte[] datas=packet.getData();
        int len=packet.getLength();
        //5.释放资源
        System.out.println(new String(datas,0,len));
        server.close();
    }
}

案例2：学生和咨询师在线一对一交流
使用面向对象封装：发送端

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 {
    private DatagramSocket client;
    private BufferedReader reader;
    private String toIP;
    private int toPort;
    public TalkSend(int port,String toIP,int toPort){
        this.toIP=toIP;
        this.toPort=toPort;
        try {
            client=new DatagramSocket(port);
            reader=new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        while (true) {
            String data;
            try {
                data = reader.readLine();
                byte[] datas = data.getBytes();
                //3.封装成DatagramPacket 包裹，需要指定目的地
                DatagramPacket packet = new DatagramPacket(datas, 0, datas.length,
                        new InetSocketAddress(toIP, toPort));
                //4.发送包裹send（DatagramPacket p）
                client.send(packet);
                if (data.equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //5.释放资源
        client.close();
    }
}

使用面向对象封装：接收端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class TalkReceive implements Runnable {
    private DatagramSocket server;
    private String from;
    public TalkReceive(int port,String from){
        this.from=from;
        try {
            server=new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        while(true) {
            //2.准备容器 封装成DatagramPacket 包裹
            byte[] container = new byte[1024 * 60];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            //3.阻塞式接收包裹receive（DatagramPacket p）
            try {
                server.receive(packet);
            } catch (IOException e) {
                e.printStackTrace();
            }
            //4.分析数据
            // byte[] getData()
            //        getLength()
            byte[] datas = packet.getData();
            int len = packet.getLength();
            String data=new String(datas,0,len);
            System.out.println(from+"："+data);
            if(data.equals("bye")){
                break;
            }
        }
        //5.释放资源
        server.close();
    }
}

对象：学生

public class TalkStudent {
    public static void main(String[] args){
        new Thread(new TalkSend(6666,"localhost",9999)).start();//发送
        new Thread(new TalkReceive(8888,"老师")).start();//接收
    }
}

对象：老师

public class TalkTeacher {
    public static void main(String[] args){
        new Thread(new TalkReceive(9999,"学生")).start();//接收
        new Thread(new TalkSend(7777,"localhost",8888)).start();//发送
    }
}
菜根花小宝贝
关注
专栏目录
网络编程——模拟服务器与客户端案例
zezea的博客
01-11 677
网络编程 软件结构 C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。 B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。 网络通信协议 网络通信协议：通信协议是对计算机必须遵守的规则，只有遵守这些规则，计算机之间才能进行通信。这就 好比在道路中行驶的汽车一定要遵守交通规则一样，协议中对数据...
网络编程随笔
迷路的指南针的专栏
08-30 543
最近做一个项目，要用到http相关方面的东西，感觉有点坑。坑不坑大家随我来看看。 坑： try{ char * l_strUrl = "http://server/manger/Authorize？method=get"; CInternetSession l_cSess("GetJson"); CHttpFile *pF = (CHttpFile *
python 网络编程 速度_python网络编程随笔
weixin_39724382的博客
12-05 69
前言python实在是太方便，太易用了，三方库的支持又全，语法又简单，对开发人员来说，实在是居家旅行，XXXX的必备利器。周末研究了下python的网络支持，做一下记录，以备随后翻阅。python支持BSD的socket进行网络编程，其API跟C中的大同小异，先看看TCP方式的，说到网络编程，肯定会设计到server和client，分别来看下TCP方式server端server端的socket一般...
linux编程 网络编程篇随笔
kurikos的博客
08-25 118
网络编程篇笔记随记。
网络编程学习随笔
qq_47087422的博客
12-04 177
网络编程 1.1概述 地球村：你在西安，你一个美国的朋友！ 信件： 计算机网络： 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外面设备，通过通信路线连接起来，在网络操作系统 ，网络管理软件及网络通信协议的管理和协调之下，实现资源共享和信息传递的计算机系统。 网络编程的目的： 无限电台。。传播交流信息，数据交换，通信 想要达到这个效果需要什么： 1.如何准确的定位网络上的一台主机？IP地址:端口，定位的到这个计算机上的某个资源 2.找到了这个主机，如何传输数据你？ 加微信？… javaweb：
Java随笔（网络编程）
qq_40712959的博客
10-13 116
参考文章 今天做了个网络编程，对inputStream、inputstreamReader、BufferedReader产生了些许疑惑，后百度求解。 inputStream：所有字节流的超类，可输出字节流。 inputstreamReader：字节流与字符流的桥梁。 BufferedReader：提供通用缓冲方式文本读取，readLine读取一个文本行， 从字符输入流中读取文本，缓冲各个字符，从而...
网络随笔一
lmd1997130的博客
12-26 417
1、什么是因特网？ 我们平时使用的电脑，手机都可以称为端系统。因特网就是利用路由器（分组交换机）和链路将各个终端互联起来。 2、一些基本概念 （1）分组： 一个主机要向另外一个主机发送数据时，数据被分成很多段，每段前面还会加上特定的首部字节，这样的数据包就称为分组。 （2）因特网服务提供商（ISP）： 主机就是通过ISP连接进互联网的，。ISP是一个由多个分组交换机和段通信链路组成的网络
JAVA随笔-网络编程
qq_39356280的博客
08-07 109
JAVA随笔-网络编程UDPTCP UDP 发送端 //创建socket对象->创建数据并打包->发送->关闭 public class UdpSendDemo { public static void main(String[] args) throws IOException { //创建发送端的Socket对象 DatagramSocket ds = new DatagramSocket(); //创建数据
IPv6网络编程注意[from IPv4]随笔
帅不啦叽斯基的博客
11-09 728
IPv6网络编程注意[from IPv4]随笔
[心情随笔]秋小诗一首.pdf
12-03
很抱歉，但根据您给出的信息，这...如果您需要关于IT行业的知识，例如编程语言、软件开发、网络技术、数据科学、人工智能等方面的内容，请提供相关的文件标题、描述或标签，我将很乐意为您详细介绍和阐述相关的知识点。
JAVA网络编程菜鸟教程_Java网络编程基础(Netty预备知识)
weixin_39965673的博客
02-26 600
今天在家休息，闲来无事，写篇博客，陶冶下情操~~~=================我是分割线================最近在重新学习Java网络编程基础，以便后续进行Netty的学习。整理了一下重要的基础知识点，供大家参考。正在读这篇随笔的你是否遇到过如下问题？什么是BIO？什么是NIO？什么是AIO？什么是同步IO？什么是异步IO？什么是阻塞IO？什么是非阻塞IO？为什么我感觉异步IO和...
unix 编程随笔
alienzzt的专栏
12-20 421
该篇为本人在工作编程中的一些心得体会，愿初入此道的小生们少走些弯路，我只愿面朝大海，春暖花开。（持续更新）
Java企业面试题3
最新发布
m0_74972727的博客
09-15 252
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 563
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Gradle
xiaocaij_icai的博客
09-15 105
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 882
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
Spring AMQP给消息添加头信息
yong472727322的博客
09-10 303
【代码】Spring AMQP给消息添加头信息。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 320
spirng security中的几大组件的差异和执行顺序
探索TCP/IP协议：从基础到应用详解
TCP/IP协议随笔深入探讨了传输控制协议/网间协议（TCP...TCP/IP协议是现代网络通信的基础，理解其工作原理对于网络编程、系统架构和网络安全至关重要。通过深入研究和实践，开发者可以更好地构建高效、可靠的网络应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值