BufferedInputStream(緩沖輸入流)詳解_動力節(jié)點Java學(xué)院整理
BufferedInputStream 介紹
BufferedInputStream 是緩沖輸入流。它繼承于FilterInputStream。
BufferedInputStream 的作用是為另一個輸入流添加一些功能，例如，提供“緩沖功能”以及支持“mark()標記”和“reset()重置方法”。
BufferedInputStream 本質(zhì)上是通過一個內(nèi)部緩沖區(qū)數(shù)組實現(xiàn)的。例如，在新建某輸入流對應(yīng)的BufferedInputStream后，當(dāng)我們通過read()讀取輸入流的數(shù)據(jù)時，BufferedInputStream會將該輸入流的數(shù)據(jù)分批的填入到緩沖區(qū)中。每當(dāng)緩沖區(qū)中的數(shù)據(jù)被讀完之后，輸入流會再次填充數(shù)據(jù)緩沖區(qū)；如此反復(fù)，直到我們讀完輸入流數(shù)據(jù)位置。
BufferedInputStream 函數(shù)列表
BufferedInputStream(InputStream in) BufferedInputStream(InputStream in, int size) synchronized int available() void close() synchronized void mark(int readlimit) boolean markSupported() synchronized int read() synchronized int read(byte[] buffer, int offset, int byteCount) synchronized void reset() synchronized long skip(long byteCount)
BufferedInputStream 源碼分析(基于jdk1.7.40)
package java.io;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
public class BufferedInputStream extends FilterInputStream {
// 默認的緩沖大小是8192字節(jié)
// BufferedInputStream 會根據(jù)“緩沖區(qū)大小”來逐次的填充緩沖區(qū)；
// 即，BufferedInputStream填充緩沖區(qū)，用戶讀取緩沖區(qū)，讀完之后，BufferedInputStream會再次填充緩沖區(qū)。如此循環(huán)，直到讀完數(shù)據(jù)...
private static int defaultBufferSize = 8192;
// 緩沖數(shù)組
protected volatile byte buf[];
// 緩存數(shù)組的原子更新器。
// 該成員變量與buf數(shù)組的volatile關(guān)鍵字共同組成了buf數(shù)組的原子更新功能實現(xiàn)，
// 即，在多線程中操作BufferedInputStream對象時，buf和bufUpdater都具有原子性(不同的線程訪問到的數(shù)據(jù)都是相同的)
private static final
AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater =
AtomicReferenceFieldUpdater.newUpdater
(BufferedInputStream.class, byte[].class, "buf");
// 當(dāng)前緩沖區(qū)的有效字節(jié)數(shù)。
// 注意，這里是指緩沖區(qū)的有效字節(jié)數(shù)，而不是輸入流中的有效字節(jié)數(shù)。
protected int count;
// 當(dāng)前緩沖區(qū)的位置索引
// 注意，這里是指緩沖區(qū)的位置索引，而不是輸入流中的位置索引。
protected int pos;
// 當(dāng)前緩沖區(qū)的標記位置
// markpos和reset()配合使用才有意義。操作步驟：
// (01) 通過mark() 函數(shù)，保存pos的值到markpos中。
// (02) 通過reset() 函數(shù)，會將pos的值重置為markpos。接著通過read()讀取數(shù)據(jù)時，就會從mark()保存的位置開始讀取。
protected int markpos = -1;
// marklimit是標記的最大值。
// 關(guān)于marklimit的原理，我們在后面的fill()函數(shù)分析中會詳細說明。這對理解BufferedInputStream相當(dāng)重要。
protected int marklimit;
// 獲取輸入流
private InputStream getInIfOpen() throws IOException {
InputStream input = in;
if (input == null)
throw new IOException("Stream closed");
return input;
}
// 獲取緩沖
private byte[] getBufIfOpen() throws IOException {
byte[] buffer = buf;
if (buffer == null)
throw new IOException("Stream closed");
return buffer;
}
// 構(gòu)造函數(shù)：新建一個緩沖區(qū)大小為8192的BufferedInputStream
public BufferedInputStream(InputStream in) {
this(in, defaultBufferSize);
}
// 構(gòu)造函數(shù)：新建指定緩沖區(qū)大小的BufferedInputStream
public BufferedInputStream(InputStream in, int size) {
super(in);
if (size <= 0) {
throw new IllegalArgumentException("Buffer size <= 0");
}
buf = new byte[size];
}
// 從“輸入流”中讀取數(shù)據(jù)，并填充到緩沖區(qū)中。
// 后面會對該函數(shù)進行詳細說明！
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos < 0)
pos = 0; /* no mark: throw away the buffer */
else if (pos >= buffer.length) /* no room left in buffer */
if (markpos > 0) { /* can throw away early part of the buffer */
int sz = pos - markpos;
System.arraycopy(buffer, markpos, buffer, 0, sz);
pos = sz;
markpos = 0;
} else if (buffer.length >= marklimit) {
markpos = -1; /* buffer got too big, invalidate mark */
pos = 0; /* drop buffer contents */
} else { /* grow buffer */
int nsz = pos * 2;
if (nsz > marklimit)
nsz = marklimit;
byte nbuf[] = new byte[nsz];
System.arraycopy(buffer, 0, nbuf, 0, pos);
if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
throw new IOException("Stream closed");
}
buffer = nbuf;
}
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
// 讀取下一個字節(jié)
public synchronized int read() throws IOException {
// 若已經(jīng)讀完緩沖區(qū)中的數(shù)據(jù)，則調(diào)用fill()從輸入流讀取下一部分數(shù)據(jù)來填充緩沖區(qū)
if (pos >= count) {
fill();
if (pos >= count)
return -1;
}
// 從緩沖區(qū)中讀取指定的字節(jié)
return getBufIfOpen()[pos++] & 0xff;
}
// 將緩沖區(qū)中的數(shù)據(jù)寫入到字節(jié)數(shù)組b中。off是字節(jié)數(shù)組b的起始位置，len是寫入長度
private int read1(byte[] b, int off, int len) throws IOException {
int avail = count - pos;
if (avail <= 0) {
// 加速機制。
// 如果讀取的長度大于緩沖區(qū)的長度 并且沒有markpos，
// 則直接從原始輸入流中進行讀取，從而避免無謂的COPY（從原始輸入流至緩沖區(qū)，讀取緩沖區(qū)全部數(shù)據(jù)，清空緩沖區(qū)，
// 重新填入原始輸入流數(shù)據(jù)）
if (len >= getBufIfOpen().length && markpos < 0) {
return getInIfOpen().read(b, off, len);
}
// 若已經(jīng)讀完緩沖區(qū)中的數(shù)據(jù)，則調(diào)用fill()從輸入流讀取下一部分數(shù)據(jù)來填充緩沖區(qū)
fill();
avail = count - pos;
if (avail <= 0) return -1;
}
int cnt = (avail < len) ? avail : len;
System.arraycopy(getBufIfOpen(), pos, b, off, cnt);
pos += cnt;
return cnt;
}
// 將緩沖區(qū)中的數(shù)據(jù)寫入到字節(jié)數(shù)組b中。off是字節(jié)數(shù)組b的起始位置，len是寫入長度
public synchronized int read(byte b[], int off, int len)
throws IOException
{
getBufIfOpen(); // Check for closed stream
if ((off | len | (off + len) | (b.length - (off + len))) < 0) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return 0;
}
// 讀取到指定長度的數(shù)據(jù)才返回
int n = 0;
for (;;) {
int nread = read1(b, off + n, len - n);
if (nread <= 0)
return (n == 0) ? nread : n;
n += nread;
if (n >= len)
return n;
// if not closed but no bytes available, return
InputStream input = in;
if (input != null && input.available() <= 0)
return n;
}
}
// 忽略n個字節(jié)
public synchronized long skip(long n) throws IOException {
getBufIfOpen(); // Check for closed stream
if (n <= 0) {
return 0;
}
long avail = count - pos;
if (avail <= 0) {
// If no mark position set then don't keep in buffer
if (markpos <0)
return getInIfOpen().skip(n);
// Fill in buffer to save bytes for reset
fill();
avail = count - pos;
if (avail <= 0)
return 0;
}
long skipped = (avail < n) ? avail : n;
pos += skipped;
return skipped;
}
// 下一個字節(jié)是否存可讀
public synchronized int available() throws IOException {
int n = count - pos;
int avail = getInIfOpen().available();
return n > (Integer.MAX_VALUE - avail)
? Integer.MAX_VALUE
: n + avail;
}
// 標記“緩沖區(qū)”中當(dāng)前位置。
// readlimit是marklimit，關(guān)于marklimit的作用，參考后面的說明。
public synchronized void mark(int readlimit) {
marklimit = readlimit;
markpos = pos;
}
// 將“緩沖區(qū)”中當(dāng)前位置重置到mark()所標記的位置
public synchronized void reset() throws IOException {
getBufIfOpen(); // Cause exception if closed
if (markpos < 0)
throw new IOException("Resetting to invalid mark");
pos = markpos;
}
public boolean markSupported() {
return true;
}
// 關(guān)閉輸入流
public void close() throws IOException {
byte[] buffer;
while ( (buffer = buf) != null) {
if (bufUpdater.compareAndSet(this, buffer, null)) {
InputStream input = in;
in = null;
if (input != null)
input.close();
return;
}
// Else retry in case a new buf was CASed in fill()
}
}
}
說明：
要想讀懂BufferedInputStream的源碼，就要先理解它的思想。BufferedInputStream的作用是為其它輸入流提供緩沖功能。創(chuàng)建BufferedInputStream時，我們會通過它的構(gòu)造函數(shù)指定某個輸入流為參數(shù)。BufferedInputStream會將該輸入流數(shù)據(jù)分批讀取，每次讀取一部分到緩沖中；操作完緩沖中的這部分數(shù)據(jù)之后，再從輸入流中讀取下一部分的數(shù)據(jù)。
為什么需要緩沖呢？原因很簡單，效率問題！緩沖中的數(shù)據(jù)實際上是保存在內(nèi)存中，而原始數(shù)據(jù)可能是保存在硬盤或NandFlash等存儲介質(zhì)中；而我們知道，從內(nèi)存中讀取數(shù)據(jù)的速度比從硬盤讀取數(shù)據(jù)的速度至少快10倍以上。
那干嘛不干脆一次性將全部數(shù)據(jù)都讀取到緩沖中呢？第一，讀取全部的數(shù)據(jù)所需要的時間可能會很長。第二，內(nèi)存價格很貴，容量不像硬盤那么大。
下面，我就BufferedInputStream中最重要的函數(shù)fill()進行說明。其它的函數(shù)很容易理解，我就不詳細介紹了，大家可以參考源碼中的注釋進行理解。
fill() 源碼如下：
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos < 0)
pos = 0;
else if (pos >= buffer.length) {
if (markpos > 0) { /* can throw away early part of the buffer */
int sz = pos - markpos;
System.arraycopy(buffer, markpos, buffer, 0, sz);
pos = sz;
markpos = 0;
} else if (buffer.length >= marklimit) {
markpos = -1; /* buffer got too big, invalidate mark */
pos = 0; /* drop buffer contents */
} else { /* grow buffer */
int nsz = pos * 2;
if (nsz > marklimit)
nsz = marklimit;
byte nbuf[] = new byte[nsz];
System.arraycopy(buffer, 0, nbuf, 0, pos);
if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
// Can't replace buf if there was an async close.
// Note: This would need to be changed if fill()
// is ever made accessible to multiple threads.
// But for now, the only way CAS can fail is via close.
// assert buf == null;
throw new IOException("Stream closed");
}
buffer = nbuf;
}
}
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
根據(jù)fill()中的if...else...，下面我們將fill分為5種情況進行說明。
情況1：讀取完buffer中的數(shù)據(jù)，并且buffer沒有被標記
執(zhí)行流程如下，
(01) read() 函數(shù)中調(diào)用 fill()
(02) fill() 中的 if (markpos < 0) ...
為了方便分析，我們將這種情況下fill()執(zhí)行的操作等價于以下代碼：
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos < 0)
pos = 0;
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
說明：
這種情況發(fā)生的情況是 — — 輸入流中有很長的數(shù)據(jù)，我們每次從中讀取一部分數(shù)據(jù)到buffer中進行操作。每次當(dāng)我們讀取完buffer中的數(shù)據(jù)之后，并且此時輸入流沒有被標記；那么，就接著從輸入流中讀取下一部分的數(shù)據(jù)到buffer中。
其中，判斷是否讀完buffer中的數(shù)據(jù)，是通過 if (pos >= count) 來判斷的；
判斷輸入流有沒有被標記，是通過 if (markpos < 0) 來判斷的。
理解這個思想之后，我們再對這種情況下的fill()的代碼進行分析，就特別容易理解了。
(01) if (markpos < 0) 它的作用是判斷“輸入流是否被標記”。若被標記，則markpos大于/等于0；否則markpos等于-1。
(02) 在這種情況下：通過getInIfOpen()獲取輸入流，然后接著從輸入流中讀取buffer.length個字節(jié)到buffer中。
(03) count = n + pos; 這是根據(jù)從輸入流中讀取的實際數(shù)據(jù)的多少，來更新buffer中數(shù)據(jù)的實際大小。
情況2：讀取完buffer中的數(shù)據(jù)，buffer的標記位置>0，并且buffer中沒有多余的空間
執(zhí)行流程如下，
(01) read() 函數(shù)中調(diào)用 fill()
(02) fill() 中的 else if (pos >= buffer.length) ...
(03) fill() 中的 if (markpos > 0) ...
為了方便分析，我們將這種情況下fill()執(zhí)行的操作等價于以下代碼：
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos >= 0 && pos >= buffer.length) {
if (markpos > 0) {
int sz = pos - markpos;
System.arraycopy(buffer, markpos, buffer, 0, sz);
pos = sz;
markpos = 0;
}
}
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
說明：
這種情況發(fā)生的情況是 — — 輸入流中有很長的數(shù)據(jù)，我們每次從中讀取一部分數(shù)據(jù)到buffer中進行操作。當(dāng)我們讀取完buffer中的數(shù)據(jù)之后，并且此時輸入流存在標記時；那么，就發(fā)生情況2。此時，我們要保留“被標記位置”到“buffer末尾”的數(shù)據(jù)，然后再從輸入流中讀取下一部分的數(shù)據(jù)到buffer中。
其中，判斷是否讀完buffer中的數(shù)據(jù)，是通過 if (pos >= count) 來判斷的；
判斷輸入流有沒有被標記，是通過 if (markpos < 0) 來判斷的。
判斷buffer中沒有多余的空間，是通過 if (pos >= buffer.length) 來判斷的。
理解這個思想之后，我們再對這種情況下的fill()代碼進行分析，就特別容易理解了。
(01) int sz = pos - markpos; 作用是“獲取‘被標記位置'到‘buffer末尾'”的數(shù)據(jù)長度。
(02) System.arraycopy(buffer, markpos, buffer, 0, sz); 作用是“將buffer中從markpos開始的數(shù)據(jù)”拷貝到buffer中(從位置0開始填充，填充長度是sz)。接著，將sz賦值給pos，即pos就是“被標記位置”到“buffer末尾”的數(shù)據(jù)長度。
(03) int n = getInIfOpen().read(buffer, pos, buffer.length - pos); 從輸入流中讀取出“buffer.length - pos”的數(shù)據(jù)，然后填充到buffer中。
(04) 通過第(02)和(03)步組合起來的buffer，就是包含了“原始buffer被標記位置到buffer末尾”的數(shù)據(jù)，也包含了“從輸入流中新讀取的數(shù)據(jù)”。
注意：執(zhí)行過情況2之后，markpos的值由“大于0”變成了“等于0”！
情況3：讀取完buffer中的數(shù)據(jù)，buffer被標記位置=0，buffer中沒有多余的空間，并且buffer.length>=marklimit
執(zhí)行流程如下，
(01) read() 函數(shù)中調(diào)用 fill()
(02) fill() 中的 else if (pos >= buffer.length) ...
(03) fill() 中的 else if (buffer.length >= marklimit) ...
為了方便分析，我們將這種情況下fill()執(zhí)行的操作等價于以下代碼：
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos >= 0 && pos >= buffer.length) {
if ( (markpos <= 0) && (buffer.length >= marklimit) ) {
markpos = -1; /* buffer got too big, invalidate mark */
pos = 0; /* drop buffer contents */
}
}
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
說明：這種情況的處理非常簡單。首先，就是“取消標記”，即 markpos = -1；然后，設(shè)置初始化位置為0，即pos=0；最后，再從輸入流中讀取下一部分數(shù)據(jù)到buffer中。
情況4：讀取完buffer中的數(shù)據(jù)，buffer被標記位置=0，buffer中沒有多余的空間，并且buffer.length<marklimit
執(zhí)行流程如下，
(01) read() 函數(shù)中調(diào)用 fill()
(02) fill() 中的 else if (pos >= buffer.length) ...
(03) fill() 中的 else { int nsz = pos * 2; ... }
為了方便分析，我們將這種情況下fill()執(zhí)行的操作等價于以下代碼：
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos >= 0 && pos >= buffer.length) {
if ( (markpos <= 0) && (buffer.length < marklimit) ) {
int nsz = pos * 2;
if (nsz > marklimit)
nsz = marklimit;
byte nbuf[] = new byte[nsz];
System.arraycopy(buffer, 0, nbuf, 0, pos);
if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
throw new IOException("Stream closed");
}
buffer = nbuf;
}
}
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
說明：
這種情況的處理非常簡單。
(01) 新建一個字節(jié)數(shù)組nbuf。nbuf的大小是“pos*2”和“marklimit”中較小的那個數(shù)。
int nsz = pos * 2; if (nsz > marklimit) nsz = marklimit; byte nbuf[] = new byte[nsz];
(02) 接著，將buffer中的數(shù)據(jù)拷貝到新數(shù)組nbuf中。通過System.arraycopy(buffer, 0, nbuf, 0, pos)
(03) 最后，從輸入流讀取部分新數(shù)據(jù)到buffer中。通過getInIfOpen().read(buffer, pos, buffer.length - pos);
注意：在這里，我們思考一個問題，“為什么需要marklimit，它的存在到底有什么意義？”我們結(jié)合“情況2”、“情況3”、“情況4”的情況來分析。
假設(shè)，marklimit是無限大的，而且我們設(shè)置了markpos。當(dāng)我們從輸入流中每讀完一部分數(shù)據(jù)并讀取下一部分數(shù)據(jù)時，都需要保存markpos所標記的數(shù)據(jù)；這就意味著，我們需要不斷執(zhí)行情況4中的操作，要將buffer的容量擴大……隨著讀取次數(shù)的增多，buffer會越來越大；這會導(dǎo)致我們占據(jù)的內(nèi)存越來越大。所以，我們需要給出一個marklimit；當(dāng)buffer>=marklimit時，就不再保存markpos的值了。
情況5：除了上面4種情況之外的情況
執(zhí)行流程如下，
(01) read() 函數(shù)中調(diào)用 fill()
(02) fill() 中的 count = pos...
為了方便分析，我們將這種情況下fill()執(zhí)行的操作等價于以下代碼：
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
說明：這種情況的處理非常簡單。直接從輸入流讀取部分新數(shù)據(jù)到buffer中。
示例代碼
關(guān)于BufferedInputStream中API的詳細用法，參考示例代碼(BufferedInputStreamTest.java)：
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.FileNotFoundException;
import java.lang.SecurityException;
/**
* BufferedInputStream 測試程序
*
* @author skywang
*/
public class BufferedInputStreamTest {
private static final int LEN = 5;
public static void main(String[] args) {
testBufferedInputStream() ;
}
/**
* BufferedInputStream的API測試函數(shù)
*/
private static void testBufferedInputStream() {
// 創(chuàng)建BufferedInputStream字節(jié)流，內(nèi)容是ArrayLetters數(shù)組
try {
File file = new File("bufferedinputstream.txt");
InputStream in =
new BufferedInputStream(
new FileInputStream(file), 512);
// 從字節(jié)流中讀取5個字節(jié)?！癮bcde”，a對應(yīng)0x61，b對應(yīng)0x62，依次類推...
for (int i=0; i<LEN; i++) {
// 若能繼續(xù)讀取下一個字節(jié)，則讀取下一個字節(jié)
if (in.available() >= 0) {
// 讀取“字節(jié)流的下一個字節(jié)”
int tmp = in.read();
System.out.printf("%d : 0x%s\n", i, Integer.toHexString(tmp));
}
}
// 若“該字節(jié)流”不支持標記功能，則直接退出
if (!in.markSupported()) {
System.out.println("make not supported!");
return ;
}
// 標記“當(dāng)前索引位置”，即標記第6個位置的元素--“f”
// 1024對應(yīng)marklimit
in.mark(1024);
// 跳過22個字節(jié)。
in.skip(22);
// 讀取5個字節(jié)
byte[] buf = new byte[LEN];
in.read(buf, 0, LEN);
// 將buf轉(zhuǎn)換為String字符串。
String str1 = new String(buf);
System.out.printf("str1=%s\n", str1);
// 重置“輸入流的索引”為mark()所標記的位置，即重置到“f”處。
in.reset();
// 從“重置后的字節(jié)流”中讀取5個字節(jié)到buf中。即讀取“fghij”
in.read(buf, 0, LEN);
// 將buf轉(zhuǎn)換為String字符串。
String str2 = new String(buf);
System.out.printf("str2=%s\n", str2);
in.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
程序中讀取的bufferedinputstream.txt的內(nèi)容如下：
abcdefghijklmnopqrstuvwxyz
0123456789
ABCDEFGHIJKLMNOPQRSTUVWXYZ
運行結(jié)果：
0 : 0x61
1 : 0x62
2 : 0x63
3 : 0x64
4 : 0x65
str1=01234
str2=fghij
以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。
相關(guān)文章
這篇文章主要介紹了基于java實現(xiàn)的ECC加密算法,簡單說明了ECC算法的概念、原理,并結(jié)合實例形式分析了java實現(xiàn)ECC加密算法的定義與使用技巧,需要的朋友可以參考下2017-08-08
這篇文章主要介紹了Java線程中的interrupt方法解讀,Java中的interrupt是一種線程間通信的機制，用于請求中斷線程的執(zhí)行。當(dāng)一個線程調(diào)用另一個線程的interrupt()方法時，被調(diào)用線程會收到一個中斷信號，可以根據(jù)需要做出相應(yīng)的處理,需要的朋友可以參考下2023-10-10
SpringBoot-Admin實現(xiàn)微服務(wù)監(jiān)控+健康檢查+釘釘告警
本文主要介紹了SpringBoot-Admin實現(xiàn)微服務(wù)監(jiān)控+健康檢查+釘釘告警，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-10-10
教你如何使用google.zxing結(jié)合springboot生成二維碼功能
這篇文章主要介紹了使用google.zxing結(jié)合springboot生成二維碼功能,我們使用兩種方式，去生成二維碼，但是其實，二維碼的生成基礎(chǔ)，都是zxing包，這是Google開源的一個包，本文通過實例代碼給大家介紹的非常詳細，需要的朋友可以參考下2022-05-05
Spring Security基于HttpRequest配置權(quán)限示例詳解
這篇文章主要介紹了Spring Security基于HttpRequest配置權(quán)限示例詳解,我們在配置中配置的url被封裝成RequestMatcher,而hasRole被封裝成AuthorityAuthorizationManager,本文結(jié)合示例代碼講解的非常詳細,需要的朋友可以參考下2024-03-03
這篇文章主要介紹了Java并發(fā)編程示例(九)：本地線程變量的使用,有時,我們更希望能在線程內(nèi)單獨使用,而不和其他使用同一對象啟動的線程共享,Java并發(fā)接口提供了一種很清晰的機制來滿足此需求,該機制稱為本地線程變量,需要的朋友可以參考下2014-12-12
什么是JDBC？這篇文章就為大家詳細介紹了Java語言中用來規(guī)范客戶端程序如何來訪問數(shù)據(jù)庫的應(yīng)用程序接口，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-07-07
這篇文章主要介紹了Java實現(xiàn)的計時器【秒表】功能,結(jié)合實例形式分析了Java結(jié)合JFrame框架的計時器功能相關(guān)操作技巧,需要的朋友可以參考下2019-02-02
下面小編就為大家?guī)硪黄猨ava 獲取路徑的各種方法(總結(jié))。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2016-08-08
這篇文章主要介紹了簡單了解Spring Framework5.0新特性，涉及了核心框架修訂，核心容器更新，使用Kotlin進行函數(shù)式編程等幾個方面的介紹，具有一定參考價值，需要的朋友可以了解下。2017-11-11