Java 复习整理day10
2024-09-06 19:02:37
package com.it.demo01_quickstart; /*
案例: 讲解网络编程相关概念. 网络编程简介:
概述:
网络编程也叫: 套接字编程, Socket编程, 就是用来实现 网络互联的 不同计算机上 运行的程序间 可以进行数据交互.
大白话翻译: 就是用来实现 不同电脑间 进行数据传输的. 三大要素:
IP地址:
概述:
设备在网络中的唯一标识. 192.168.37.56
组成:
网络(关)号码 + 主机地址
分类:
城域网: 1 + 3 第一段是网关号码, 后三段是主机地址.
广域网: 2 + 2 一般应用于校园网
局域网: 3 + 1
两个DOS指令:
ipconfig /all 查看IP
ping ip地址/网址 -t 测试网络连接
两个特殊的IP:
127.0.0.1 本地回环(回路)地址, 即: 代表本机.
255.255.255.255 广播地址 InetAddress类: IP地址的包装类
String形式的IP -> InetAddress类型的 IP地址对象.
public static InetAddress getByName(String ip地址/主机名); 根据字符串形式的ip(或者主机名), 获取其对应的 IP地址对象. InetAddress类型的 IP地址对象 -> String形式的IP
public String getHostAddress(); 根据IP地址对象, 获取字符串形式的IP
public String getHostName(); 根据IP地址对象, 获取字符串形式的 主机名
端口号:
概述:
程序在设备上的唯一标识.
范围:
0-65535
注意事项:
0-1023之间的端口号不要用, 因为已经被系统占用了或者用作保留端口.
协议:
概述:
就是设备间传输数据时, 需要遵守的规则, 约定.
分类:
UDP协议: //类似于: 群聊
1. 面向无连接.
2. 采用数据报包(DatagramPacket)的形式发送数据, 每个包的大小不能超过64KB.
3. 不安全(不可靠)协议.
4. 效率相对较高.
5. 不区分客户端和服务器端, 叫发送端和接收端. TCP协议: //类似于: 打电话
1. 面向有连接(三次握手)
2. 采用IO流的形式发送数据, 理论上来讲无数据大小限制.
3. 安全(可靠)协议.
4. 效率相对较低.
5. 区分客户端和服务器端. 软件结构:
常用的软件主要分为: CS结构 和 BS结构
CS结构: Client(客户端) 和 Server(服务器端)
例如: QQ, 微信, LOL 特点:
需求安装客户端, 服务器端升级的时候, 客户端同步也要升级. 好处:
1. 降低服务器压力, 因为可以把一些必要的 大的文件, 提前让用户安装.
2. 用户体验较好. 因为一些必要文件已经提前下载好了, 所以此类产品界面一般做的比较好看. 弊端:
当服务器端升级的时候, 客户端同步也要升级. BS结构: Browser(浏览器端) 和 Server(服务器端)
例如: 天猫, 京东 特点:
无需安装特定软件, 只要有一个浏览器就可以访问. 好处:
1. 更灵活, 用户无需安装特定软件, 只要有一个浏览器就可以访问.
2. 用户体验较好, 只要有一个浏览器, 就可以访问了, 无需安装其他软件,
也无需定时更新指定的客户端.
弊端:
1. 服务器压力过大, 因为浏览器端所需的所有的数据都会从 服务器端下载.
2. 需要用户记忆大量的网址...
*/
public class Demo01 {
public static void main(String[] args) { }
}
package com.it.demo02_inetaddress; import java.net.InetAddress;
import java.net.UnknownHostException; /*
案例: 演示InetAddress IP地址包装类. InetAddress类的成员方法: IP地址的包装类
String形式的IP -> InetAddress类型的 IP地址对象.
public static InetAddress getByName(String ip地址/主机名); 根据字符串形式的ip(或者主机名), 获取其对应的 IP地址对象. InetAddress类型的 IP地址对象 -> String形式的IP
public String getHostAddress(); 根据IP地址对象, 获取字符串形式的IP
public String getHostName(); 根据IP地址对象, 获取字符串形式的 主机名
*/
public class Demo01 {
public static void main(String[] args) throws UnknownHostException {
//需求1: String -> InetAddress
//根据ip地址获取, 推荐方式.
String ip = "192.168.88.5";
InetAddress inet1 = InetAddress.getByName(ip);
System.out.println(inet1); //如果是通过ip获取的 IP对象, 打印的时候只有: ip地址
System.out.println("---------------------"); //根据主机名获取, 了解.
String hostName = "HangGe";
InetAddress inet2 = InetAddress.getByName(hostName);
System.out.println(inet2); //如果是通过 主机名获取的, 打印的时候是: 主机名, ip地址.
System.out.println("---------------------"); //需求2: InetAddress -> String
System.out.println(inet1.getHostAddress()); //192.168.88.5
System.out.println(inet1.getHostName()); //HangGe }
}
package com.it.demo03_udp; import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Socket; /*
案例: 演示UDP协议发送和接收数据
*/
//接收端.
public class ReceiveDemo {
public static void main(String[] args) throws Exception {
//1. 创建接收端的Socket对象, 指定端口号.
DatagramSocket ds = new DatagramSocket(12345); //2. 创建DatagramPacket对象, 用来接收 发送端发过来的数据.
// 要装数据的数组 数组的可用长度
//使用这个构造方法: DatagramPacket(byte[] buf, int length)
byte[] bys = new byte[1024];
DatagramPacket dp = new DatagramPacket(bys, bys.length); //3. 通过接收端的Socket对象, 接收发送端发过来的数据, 并存储到 数据报包对象中.
ds.receive(dp); //4. 从数据报包对象中获取数据.
byte[] data = dp.getData(); //从数据报包对象中获取数据.
int len = dp.getLength(); //从数据报包对象中获取 具体的有效字节数.
String s = new String(data, 0, len); //5. 打印数据.
System.out.println(s); //6. 关闭接收端的Socket对象.
ds.close();
}
}
package com.it.demo03_udp; import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress; /*
案例: 演示UDP协议发送和接收数据. 补充: 网络通信的原理
网络通信也叫Socket通信, 数据在两个Socket之间通过 数据报包 或者 IO流的形式进行传输.
*/
//发送端.
public class SendDemo {
public static void main(String[] args) throws Exception {
//1. 创建发送端的Socket对象.
DatagramSocket ds = new DatagramSocket();
//2. 定义要发送的数据.
String s = "恭喜发财, 红包拿来";
byte[] bys = s.getBytes(); //3. 将要发送的数据封装到 数据报包中(DatagramPacket)中.
// 要发送的数据 数据长度 接收端的IP地址 端口号
//使用这个构造方法: DatagramPacket(byte[] buf, int length, InetAddress address, int port)
DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("127.0.0.1"), 12345); //4. 通过Socket对象, 发送数据报包
ds.send(dp); //5. 关闭Socket对象.
ds.close();
}
}
package com.it.demo04_tcp_quickstart; import java.io.OutputStream;
import java.net.Socket; /*
案例: 演示TCP协议之发送数据. 步骤:
1. 创建客户端Socket对象, 指定服务器端的ip, 端口号.
2. 通过 Socket#getOutputStream()方法, 获取输出流, 可以往服务器端写数据.
3. 通过输出流, 给服务器端写数据.
4. 关闭Socket对象.
*/ //客户端
public class ClientDemo {
public static void main(String[] args) throws Exception {
//1. 创建客户端Socket对象, 指定服务器端的ip, 端口号.
Socket socket = new Socket("192.168.88.5", 10087);
//2. 通过 Socket#getOutputStream()方法, 获取输出流, 可以往服务器端写数据.
OutputStream os = socket.getOutputStream();
//3. 通过输出流, 给服务器端写数据.
os.write("Hello, TCP , 我来了!".getBytes());
//4. 关闭Socket对象.
socket.close();
}
}
package com.it.demo04_tcp_quickstart; import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket; /*
案例: 演示TCP协议之接收数据. 步骤:
1. 创建服务器端端Socket对象(ServerSocket), 指定端口号.
2. 通过ServerSocket#accept()方法监听客户端连接, 如果有客户端申请建立连接,
服务器端在审核完数据之后, 回自动创建一个Socket对象, 负责和此客户端的交互.
3. 通过Socket#getInnputStream()获取输入流, 可以读取客户端发过来的数据.
4. 具体接收数据的动作.
5. 打印接收到的数据.
6. 关闭Socket对象, 关闭的是与客户端Socket交互的对象, 而不是ServerSocket.
*/
//服务器端
public class ServerDemo {
public static void main(String[] args) throws Exception {
//1. 创建服务器端端Socket对象(ServerSocket), 指定端口号.
ServerSocket server = new ServerSocket(10087);
//2. 通过ServerSocket#accept()方法监听客户端连接, 如果有客户端申请建立连接,
//服务器端在审核完数据之后, 回自动创建一个Socket对象, 负责和此客户端的交互.
System.out.println(1);
Socket accept = server.accept();
System.out.println(2);
//3. 通过Socket#getInnputStream()获取输入流, 可以读取客户端发过来的数据.
InputStream is = accept.getInputStream();
//4. 具体接收数据的动作.
byte[] bys = new byte[1024];
int len = is.read(bys);
String s = new String(bys, 0, len);
//5. 打印接收到的数据.
System.out.println(s);
//6. 关闭Socket对象, 关闭的是与客户端Socket交互的对象, 而不是ServerSocket.
accept.close();
//server.close(); 服务器端Socket对象一般不关闭.
}
}
package com.it.demo05_tcp_exercise; import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket; /*
案例: 演示TCP协议之发送数据. 步骤:
1. 创建客户端Socket对象, 指定服务器端的ip, 端口号.
2. 通过 Socket#getOutputStream()方法, 获取输出流, 可以往服务器端写数据.
3. 通过输出流, 给服务器端写数据.
4. 关闭Socket对象.
*/ //客户端
public class ClientDemo {
public static void main(String[] args) throws Exception {
//1. 创建客户端Socket对象, 指定服务器端的ip, 端口号.
Socket socket = new Socket("192.168.88.5", 10087);
//2. 通过 Socket#getOutputStream()方法, 获取输出流, 可以往服务器端写数据.
OutputStream os = socket.getOutputStream();
//3. 通过输出流, 给服务器端写数据.
os.write("Hello, TCP , 我来了!".getBytes()); //4. 获取输出流, 可以读取服务器端写过来的数据.
InputStream is = socket.getInputStream();
//5. 具体读取数据的操作.
byte[] bys = new byte[1024];
int len = is.read(bys);
String s = new String(bys, 0, len);
//6. 打印读取到的数据.
System.out.println(s); //7. 关闭Socket对象.
socket.close();
}
} package com.it.demo05_tcp_exercise; import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket; /*
案例: 演示TCP协议之接收数据. 步骤:
1. 创建服务器端端Socket对象(ServerSocket), 指定端口号.
2. 通过ServerSocket#accept()方法监听客户端连接, 如果有客户端申请建立连接,
服务器端在审核完数据之后, 回自动创建一个Socket对象, 负责和此客户端的交互.
3. 通过Socket#getInnputStream()获取输入流, 可以读取客户端发过来的数据.
4. 具体接收数据的动作.
5. 打印接收到的数据.
6. 关闭Socket对象, 关闭的是与客户端Socket交互的对象, 而不是ServerSocket.
*/
//服务器端
public class ServerDemo {
public static void main(String[] args) throws Exception {
//1. 创建服务器端端Socket对象(ServerSocket), 指定端口号.
ServerSocket server = new ServerSocket(10087);
//2. 通过ServerSocket#accept()方法监听客户端连接, 如果有客户端申请建立连接,
//服务器端在审核完数据之后, 回自动创建一个Socket对象, 负责和此客户端的交互.
System.out.println(1);
Socket accept = server.accept();
System.out.println(2);
//3. 通过Socket#getInnputStream()获取输入流, 可以读取客户端发过来的数据.
InputStream is = accept.getInputStream();
//4. 具体接收数据的动作.
byte[] bys = new byte[1024];
int len = is.read(bys);
String s = new String(bys, 0, len);
//5. 打印接收到的数据.
System.out.println(s); //6. 获取输出流, 可以往客户端写数据.
OutputStream os = accept.getOutputStream();
//7. 给客户端写的具体的数据(回执信息)
os.write("数据已收到!".getBytes()); //8. 关闭Socket对象, 关闭的是与客户端Socket交互的对象, 而不是ServerSocket.
accept.close();
//server.close(); 服务器端Socket对象一般不关闭.
}
}
package com.it.demo06_tcp_exercise_upload; import java.io.*;
import java.net.Socket; /*
案例: 客户端给服务器端上传文件. 思路:
1. 创建客户端的Socket对象, 指定服务器端的ip, 端口号.
2. 获取字符缓冲输入流对象, 管理数据源文件.
3. 通过Socket#getOutputStream()获取输出流, 可以往服务器端写数据.
4. 具体的IO流操作, 读写数据.
5. 关流, 释放资源.
*/
//客户端
public class ClientDemo {
public static void main(String[] args) throws Exception{
//1. 创建客户端的Socket对象, 指定服务器端的ip, 端口号.
Socket socket = new Socket("127.0.0.1", 10010);
//2. 获取字符缓冲输入流对象, 管理数据源文件.
BufferedReader br = new BufferedReader(new FileReader("D:\\绕口令.txt"));
//3. 通过Socket#getOutputStream()获取输出流, 可以往服务器端写数据.
//分解版
/*OutputStream os = socket.getOutputStream();
//转换流: 字节流 -> 字符流
OutputStreamWriter osw = new OutputStreamWriter(os);
//字符缓冲流: 普通的字符流 -> 高效的字符流
BufferedWriter bw = new BufferedWriter(osw);*/
//合并版
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); //4. 具体的IO流操作, 读写数据.
String line;
while((line = br.readLine()) != null) {
//把读取到的数据写给服务器端
bw.write(line);
bw.newLine();
bw.flush(); //刷新出 缓冲区中的数据.
} //5. 关流, 释放资源.
br.close();
socket.close();
}
} package com.it.demo06_tcp_exercise_upload; import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket; /*
案例: 客户端给服务器端上传文件 思路:
1. 创建服务器端Socket对象, 指定端口号.
2. 监听连接.
3. 创建字符缓冲输出流, 关联目的地文件.
4. 通过Socket#getInputStream(), 获取输入流, 读取客户端写过来的数据.
5. 具体的IO流操作, 读写数据.
6. 关流, 释放资源.
*/
//服务器端
public class ServerDemo {
public static void main(String[] args) throws Exception{
// 1. 创建服务器端Socket对象, 指定端口号.
ServerSocket server = new ServerSocket(10010);
// 2. 监听连接.
Socket accept = server.accept();
// 3. 创建字符缓冲输出流, 关联目的地文件.
BufferedWriter bw = new BufferedWriter(new FileWriter("day13_socket/data/copy1.txt"));
// 4. 通过Socket#getInputStream(), 获取输入流, 读取客户端写过来的数据.
BufferedReader br = new BufferedReader(new InputStreamReader(accept.getInputStream()));
// 5. 具体的IO流操作, 读写数据.
String line;
while((line = br.readLine()) != null) {
//把读取到的数据写给服务器端
bw.write(line);
bw.newLine();
bw.flush(); //刷新出 缓冲区中的数据.
}
// 6. 关流, 释放资源.
bw.close();
accept.close(); }
}
package com.it.demo07_tcp_exercise_upload_message; import java.io.*;
import java.net.Socket; /*
案例: 客户端给服务器端上传文件. 思路:
1. 创建客户端的Socket对象, 指定服务器端的ip, 端口号.
2. 获取字符缓冲输入流对象, 管理数据源文件.
3. 通过Socket#getOutputStream()获取输出流, 可以往服务器端写数据.
4. 具体的IO流操作, 读写数据.
5. 关流, 释放资源.
*/
//客户端
public class ClientDemo {
public static void main(String[] args) throws Exception{
//1. 创建客户端的Socket对象, 指定服务器端的ip, 端口号.
Socket socket = new Socket("127.0.0.1", 10010);
//2. 获取字符缓冲输入流对象, 管理数据源文件.
BufferedReader br = new BufferedReader(new FileReader("D:\\绕口令.txt"));
//3. 通过Socket#getOutputStream()获取输出流, 可以往服务器端写数据.
//分解版
/*OutputStream os = socket.getOutputStream();
//转换流: 字节流 -> 字符流
OutputStreamWriter osw = new OutputStreamWriter(os);
//字符缓冲流: 普通的字符流 -> 高效的字符流
BufferedWriter bw = new BufferedWriter(osw);*/
//合并版
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); //4. 具体的IO流操作, 读写数据.
System.out.println("client: 1");
String line;
while((line = br.readLine()) != null) {
//把读取到的数据写给服务器端
bw.write(line);
bw.newLine();
bw.flush(); //刷新出 缓冲区中的数据.
}
System.out.println("client: 2"); //5. 核心操作, 客户端上传文件完毕后, 需要给服务器端一个结束标记, 意思是说: 我传完了, 你该干嘛干嘛.
socket.shutdownOutput(); //给服务器端一个结束标记. //6. 获取输入流, 读取服务器端写过来的回执信息.
BufferedReader br2 = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//7. 具体接收数据的操作
System.out.println("client: 3");
String result = br2.readLine();
System.out.println("client: 4");
//8. 打印接收到的数据.
System.out.println(result);
//9. 关流, 释放资源.
br.close();
socket.close();
}
} package com.it.demo07_tcp_exercise_upload_message; import java.io.*;
import java.net.ServerSocket;
import java.net.Socket; /*
案例: 客户端给服务器端上传文件 思路:
1. 创建服务器端Socket对象, 指定端口号.
2. 监听连接.
3. 创建字符缓冲输出流, 关联目的地文件.
4. 通过Socket#getInputStream(), 获取输入流, 读取客户端写过来的数据.
5. 具体的IO流操作, 读写数据.
6. 关流, 释放资源.
*/
//服务器端
public class ServerDemo {
public static void main(String[] args) throws Exception {
// 1. 创建服务器端Socket对象, 指定端口号.
ServerSocket server = new ServerSocket(10010);
// 2. 监听连接.
System.out.println("server: 1");
Socket accept = server.accept();
System.out.println("server: 2");
// 3. 创建字符缓冲输出流, 关联目的地文件.
BufferedWriter bw = new BufferedWriter(new FileWriter("day13_socket/data/copy1.txt"));
// 4. 通过Socket#getInputStream(), 获取输入流, 读取客户端写过来的数据.
BufferedReader br = new BufferedReader(new InputStreamReader(accept.getInputStream()));
// 5. 具体的IO流操作, 读写数据.
System.out.println("server: 3");
String line;
while ((line = br.readLine()) != null) {
//把读取到的数据写给服务器端
bw.write(line);
bw.newLine();
bw.flush(); //刷新出 缓冲区中的数据.
}
System.out.println("server: 4"); //6. 获取输出流, 给客户端写回执信息.
BufferedWriter bw2 = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream())); //7. 给客户端写回执信息的具体操作.
bw2.write("文件上传成功");
bw2.flush(); //8.. 关流, 释放资源.
bw.close();
accept.close(); }
}
package com.it.demo08_tcp_upload_thread; import java.io.*;
import java.net.Socket; /*
案例: 客户端给服务器端上传文件. 思路:
1. 创建客户端的Socket对象, 指定服务器端的ip, 端口号.
2. 获取字符缓冲输入流对象, 管理数据源文件.
3. 通过Socket#getOutputStream()获取输出流, 可以往服务器端写数据.
4. 具体的IO流操作, 读写数据.
5. 关流, 释放资源.
*/
//客户端
public class ClientDemo {
public static void main(String[] args) throws Exception{
//1. 创建客户端的Socket对象, 指定服务器端的ip, 端口号.
Socket socket = new Socket("127.0.0.1", 10010);
//2. 获取字符缓冲输入流对象, 管理数据源文件.
BufferedReader br = new BufferedReader(new FileReader("D:\\代码打字练习词库.txt"));
//3. 通过Socket#getOutputStream()获取输出流, 可以往服务器端写数据.
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); //4. 具体的IO流操作, 读写数据.
String line;
while((line = br.readLine()) != null) {
//把读取到的数据写给服务器端
bw.write(line);
bw.newLine();
bw.flush(); //刷新出 缓冲区中的数据.
} //5. 核心操作, 客户端上传文件完毕后, 需要给服务器端一个结束标记, 意思是说: 我传完了, 你该干嘛干嘛.
socket.shutdownOutput(); //给服务器端一个结束标记. //6. 获取输入流, 读取服务器端写过来的回执信息.
BufferedReader br2 = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//7. 具体接收数据的操作
String result = br2.readLine();
//8. 打印接收到的数据.
System.out.println(result);
//9. 关流, 释放资源.
br.close();
socket.close();
}
} package com.it.demo08_tcp_upload_thread; import java.io.*;
import java.net.ServerSocket;
import java.net.Socket; /*
案例: 客户端给服务器端上传文件 思路:
1. 创建服务器端Socket对象, 指定端口号.
2. 监听连接.
3. 创建字符缓冲输出流, 关联目的地文件.
4. 通过Socket#getInputStream(), 获取输入流, 读取客户端写过来的数据.
5. 具体的IO流操作, 读写数据.
6. 关流, 释放资源.
*/
//服务器端
public class ServerDemo {
public static void main(String[] args) throws Exception {
// 1. 创建服务器端Socket对象, 指定端口号.
ServerSocket server = new ServerSocket(10010); //服务器端要不断的监听客户端的连接.
while(true) {
// 2. 监听连接.
Socket accept = server.accept();
//3. 如果有, 就创建一个线程, 负责和此客户端的交互.
//new Thread(Runnable接口的子类对象).start();
new Thread(new ServerThread(accept)).start();
} }
} package com.it.demo08_tcp_upload_thread; import java.io.*;
import java.net.Socket; //自定义的线程资源类, 表示具体的接收文件, 并给出回执信息的动作.
//每一个客户端的Socket对象, 都对应一个服务器端线程(即: ServerThread)
public class ServerThread implements Runnable{
//定义变量, 表示和客户单Socket通信的 Socket对象.
private Socket accept; public ServerThread(Socket accept) {
this.accept = accept;
} //具体的接收文件, 并给出回执信息的动作.
@Override
public void run() {
try {
//解决: 文件重名问题.
int count = 1;
File file = new File("day13_socket/data/copy("+ count +").txt"); //copy(1).txt
while (file.exists()) {
//走这里, 说明文件存在
count++;
file = new File("day13_socket/data/copy("+ count +").txt"); //copy(2).txt, copy(3).txt
} // 3. 创建字符缓冲输出流, 关联目的地文件.
BufferedWriter bw = new BufferedWriter(new FileWriter(file));
// 4. 通过Socket#getInputStream(), 获取输入流, 读取客户端写过来的数据.
BufferedReader br = new BufferedReader(new InputStreamReader(accept.getInputStream()));
// 5. 具体的IO流操作, 读写数据.
String line;
while ((line = br.readLine()) != null) {
//把读取到的数据写给服务器端
bw.write(line);
bw.newLine();
bw.flush(); //刷新出 缓冲区中的数据.
} //6. 获取输出流, 给客户端写回执信息.
BufferedWriter bw2 = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream())); //7. 给客户端写回执信息的具体操作.
bw2.write("文件上传成功");
bw2.flush(); //8.. 关流, 释放资源.
bw.close();
accept.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
最新文章
- cx_Oracle 报错 Reason: image not found
- DOM中的事件处理概览与原理的全面剖析
- 关于Java函数传参以及参数在函数内部改变的问题——JAVA值传递与引用最浅显的说明！
- linux和window下mkdir函数
- 解决64位win7系统IIS7[ODBC 驱动程序管理器]未发现数据源名称并且未指定默认驱动程序
- kafka介绍和集群环境搭建
- JS获取和设置光标的位置
- sql根据'/'截取最后的字符串
- Linux-kill命令(11)
- 计算器（Ext）
- js window
- python接口自动化（二十二）--unittest执行顺序隐藏的坑（详解）
- linux上如何让other用户访问没有other权限的目录
- 如果报错，使用 journalctl -f -t etcd 和 journalctl -u etcd 来定位问题。
- 关于spring事务
- JWT、OAUTH2与SSO资料补充
- java gaoji 算法
- HBase 入门
- ZOJ2401 Zipper 双塔式 DP（双塔DP）
- FUzhou 1607 Greedy division---因子个数问题。