溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這期內容當中小編將會給大家帶來有關Spring Boot 中怎么使用JWT 實現用戶登錄認證，文章內容豐富且以專業的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。
JWT 是 JSON Web Token 的縮寫，是為了在網絡應用環境間傳遞聲明而執行的一種基于 JSON 的開放標準（(RFC 7519)。定義了一種簡潔的，自包含的方法用于通信雙方之間以 JSON 對象的形式安全的傳遞信息。因為數字簽名的存在，這些信息是可信的，JWT 可以使用 HMAC 算法或者是 RSA 的公私秘鑰對進行簽名。
用戶使用賬號和密碼發起 POST 請求；
服務器使用私鑰創建一個 JWT；
服務器返回這個 JWT 給瀏覽器；
瀏覽器將該 JWT 串在請求頭中像服務器發送請求；
服務器驗證該 JWT；
返回響應的資源給瀏覽器。
身份認證在這種場景下，一旦用戶完成了登錄，在接下來的每個請求中包含 JWT，可以用來驗證用戶身份以及對路由，服務和資源的訪問權限進行驗證。由于它的開銷非常小，可以輕松的在不同域名的系統中傳遞，所有目前在單點登錄（SSO）中比較廣泛的使用了該技術。 信息交換在通信的雙方之間使用 JWT 對數據進行編碼是一種非常安全的方式，由于它的信息是經過簽名的，可以確保發送者發送的信息是沒有經過偽造的。
JWT 是由三段信息構成的，將這三段信息文本用 . 連接一起就構成了 JWT 字符串。
JWT 的三個部分依次為頭部：Header，負載：Payload 和簽名：Signature。
Header 部分是一個 JSON 對象，描述 JWT 的元數據，通常是下面的樣子。
{
"alg": "HS256",
"typ": "JWT"
}上面代碼中，alg 屬性表示簽名的算法（algorithm），默認是 HMAC SHA256（寫成 HS256）；typ 屬性表示這個令牌（token）的類型（type），JWT 令牌統一寫為 JWT。
最后，將上面的 JSON 對象使用 Base64URL 算法轉成字符串。
Payload 部分也是一個 JSON 對象，用來存放實際需要傳遞的有效信息。有效信息包含三個部分：
標準中注冊的聲明
公共的聲明
私有的聲明
標準中注冊的聲明 (建議但不強制使用) ：
iss (issuer)：簽發人
exp (expiration time)：過期時間，必須要大于簽發時間
sub (subject)：主題
aud (audience)：受眾
nbf (Not Before)：生效時間
iat (Issued At)：簽發時間
jti (JWT ID)：編號，JWT 的唯一身份標識，主要用來作為一次性 token，從而回避重放攻擊。
公共的聲明 ：
公共的聲明可以添加任何的信息，一般添加用戶的相關信息或其他業務需要的必要信息。但不建議添加敏感信息，因為該部分在客戶端可解密。
私有的聲明 ：
私有聲明是提供者和消費者所共同定義的聲明，一般不建議存放敏感信息，因為 base64 是對稱解碼的，意味著該部分信息可以歸類為明文信息。
這個 JSON 對象也要使用 Base64URL 算法轉成字符串。
Signature 部分是對前兩部分的簽名，防止數據篡改。
首先，需要指定一個密鑰（secret）。這個密鑰只有服務器才知道，不能泄露給用戶。然后，使用 Header 里面指定的簽名算法（默認是 HMAC SHA256），按照下面的公式產生簽名。
HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)
算出簽名以后，把 Header、Payload、Signature 三個部分拼成一個字符串，每個部分之間用"點"（.）分隔，就可以返回給用戶。
前面提到，Header 和 Payload 串型化的算法是 Base64URL。這個算法跟 Base64 算法基本類似，但有一些小的不同。
JWT 作為一個令牌（token），有些場合可能會放到 URL（比如 api.example.com/?token=xxx）。Base64 有三個字符 +、 / 和 =，在 URL 里面有特殊含義，所以要被替換掉：= 被省略、+ 替換成 -，/ 替換成 _ 。這就是 Base64URL 算法。
客戶端收到服務器返回的 JWT 之后需要在本地做保存。此后，客戶端每次與服務器通信，都要帶上這個 JWT。一般的的做法是放在 HTTP 請求的頭信息 Authorization 字段里面。
Authorization: Bearer <token>
這樣每個請求中，服務端就可以在請求頭中拿到 JWT 進行解析與認證。
JWT 默認是不加密，但也是可以加密的。生成原始 Token 以后，可以用密鑰再加密一次。
JWT 不加密的情況下，不能將秘密數據寫入 JWT。
JWT 不僅可以用于認證，也可以用于交換信息。有效使用 JWT，可以降低服務器查詢數據庫的次數。
JWT 的最大缺點是，由于服務器不保存 session 狀態，因此無法在使用過程中廢止某個 token，或者更改 token 的權限。也就是說，一旦 JWT 簽發了，在到期之前就會始終有效，除非服務器部署額外的邏輯。
JWT 本身包含了認證信息，一旦泄露，任何人都可以獲得該令牌的所有權限。為了減少盜用，JWT 的有效期應該設置得比較短。對于一些比較重要的權限，使用時應該再次對用戶進行認證。
為了減少盜用，JWT 不應該使用 HTTP 協議明碼傳輸，要使用 HTTPS 協議傳輸。
nimbus-jose-jwt 是最受歡迎的 JWT 開源庫，基于Apache 2.0開源協議，支持所有標準的簽名(JWS)和加密(JWE)算法。nimbus-jose-jwt 支持使用對稱加密（HMAC）和非對稱加密（RSA）兩種算法來生成和解析 JWT 令牌。
下面我們對 nimbus-jose-jwt 進行簡單的封裝，提供以下功能的支持：
支持使用 HMAC 和 RSA 算法生成和解析 JWT 令牌
支持私有信息直接作為 Payload，以及標準信息+私有信息作為 Payload。內置支持后者。
提供工具類及可擴展接口，方便自定義擴展開發。
首先我們在 pom.xml 中引入 nimbus-jose-jwt 的依賴。
<dependency> <groupid>com.nimbusds</groupid> <artifactid>nimbus-jose-jwt</artifactid> <version>8.20</version> </dependency>
這個類用于統一管理相關的參數配置。
public class JwtConfig {
// JWT 在 HTTP HEADER 中默認的 KEY
private String tokenName = JwtUtils.DEFAULT_TOKEN_NAME;
// HMAC 密鑰，用于支持 HMAC 算法
private String hmacKey;
// JKS 密鑰路徑，用于支持 RSA 算法
private String jksFileName;
// JKS 密鑰密碼，用于支持 RSA 算法
private String jksPassword;
// 證書密碼，用于支持 RSA 算法
private String certPassword;
// JWT 標準信息：簽發人 - iss
private String issuer;
// JWT 標準信息：主題 - sub
private String subject;
// JWT 標準信息：受眾 - aud
private String audience;
// JWT 標準信息：生效時間 - nbf，未來多長時間內生效
private long notBeforeIn;
// JWT 標準信息：生效時間 - nbf，具體哪個時間生效
private long notBeforeAt;
// JWT 標準信息：過期時間 - exp，未來多長時間內過期
private long expiredIn;
// JWT 標準信息：過期時間 - exp，具體哪個時間過期
private long expiredAt;
}hmacKey 字段用于支持 HMAC 算法，只要該字段不為空，則使用該值作為 HMAC 的密鑰對 JWT 進行簽名與驗證。
jksFileName、jksPassword、certPassword 三個字段用于支持 RSA 算法，程序將讀取證書文件作為 RSA 密鑰對 JWT 進行簽名與驗證。
其他幾個字段用于設置 Payload 中需要攜帶的標準信息。
JwtService 是提供 JWT 簽名與驗證的接口，內置了 HMACJwtServiceImpl 提供 HMAC 算法的實現和 RSAJwtServiceImpl 提供 RSA 算法的實現。兩種算法在獲取密鑰的方式上是有差別的，這里也提出來成了接口方法。后續如果要自定義實現，只需要再寫一個具體實現類。
public interface JwtService {
/**
* 獲取 key
*
* @return
*/
Object genKey();
/**
* 對信息進行簽名
*
* @param payload
* @return
*/
String sign(String payload);
/**
* 驗證并返回信息
*
* @param token
* @return
*/
String verify(String token);
}public class HMACJwtServiceImpl implements JwtService {
private JwtConfig jwtConfig;
public HMACJwtServiceImpl(JwtConfig jwtConfig) {
this.jwtConfig = jwtConfig;
}
@Override
public String genKey() {
String key = jwtConfig.getHmacKey();
if (JwtUtils.isEmpty(key)) {
throw new KeyGenerateException(JwtUtils.KEY_GEN_ERROR, new NullPointerException("HMAC need a key"));
}
return key;
}
@Override
public String sign(String info) {
return JwtUtils.signClaimByHMAC(info, genKey(), jwtConfig);
}
@Override
public String verify(String token) {
return JwtUtils.verifyClaimByHMAC(token, genKey(), jwtConfig);
}
}public class RSAJwtServiceImpl implements JwtService {
private JwtConfig jwtConfig;
private RSAKey rsaKey;
public RSAJwtServiceImpl(JwtConfig jwtConfig) {
this.jwtConfig = jwtConfig;
}
private InputStream getCertInputStream() throws IOException {
// 讀取配置文件中的證書路徑
String jksFile = jwtConfig.getJksFileName();
if (jksFile.contains("://")) {
// 從本地文件讀取
return new FileInputStream(new File(jksFile));
} else {
// 從 classpath 讀取
return getClass().getClassLoader().getResourceAsStream(jwtConfig.getJksFileName());
}
}
@Override
public RSAKey genKey() {
if (rsaKey != null) {
return rsaKey;
}
InputStream is = null;
try {
KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
is = getCertInputStream();
keyStore.load(is, jwtConfig.getJksPassword().toCharArray());
Enumeration<string> aliases = keyStore.aliases();
String alias = null;
while (aliases.hasMoreElements()) {
alias = aliases.nextElement();
}
RSAPrivateKey privateKey = (RSAPrivateKey) keyStore.getKey(alias, jwtConfig.getCertPassword().toCharArray());
Certificate certificate = keyStore.getCertificate(alias);
RSAPublicKey publicKey = (RSAPublicKey) certificate.getPublicKey();
rsaKey = new RSAKey.Builder(publicKey).privateKey(privateKey).build();
return rsaKey;
} catch (IOException | CertificateException | UnrecoverableKeyException
| NoSuchAlgorithmException | KeyStoreException e) {
e.printStackTrace();
throw new KeyGenerateException(JwtUtils.KEY_GEN_ERROR, e);
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Override
public String sign(String payload) {
return JwtUtils.signClaimByRSA(payload, genKey(), jwtConfig);
}
@Override
public String verify(String token) {
return JwtUtils.verifyClaimByRSA(token, genKey(), jwtConfig);
}
}JwtService 的實現類中比較簡潔，因為主要的方法都在 JwtUtils 中提供了。如下是 Payload 中只包含私有信息時，兩種算法的簽名與驗證實現。可以使用這些方法方便的實現自己的擴展。
/**
* 使用 HMAC 算法簽名信息（Payload 中只包含私有信息）
*
* @param info
* @param key
* @return
*/
public static String signDirectByHMAC(String info, String key) {
try {
JWSHeader jwsHeader = new JWSHeader.Builder(JWSAlgorithm.HS256)
.type(JOSEObjectType.JWT)
.build();
// 建立一個載荷 Payload
Payload payload = new Payload(info);
// 將頭部和載荷結合在一起
JWSObject jwsObject = new JWSObject(jwsHeader, payload);
// 建立一個密匙
JWSSigner jwsSigner = new MACSigner(key);
// 簽名
jwsObject.sign(jwsSigner);
// 生成 token
return jwsObject.serialize();
} catch (JOSEException e) {
e.printStackTrace();
throw new PayloadSignException(JwtUtils.PAYLOAD_SIGN_ERROR, e);
}
}
/**
* 使用 RSA 算法簽名信息（Payload 中只包含私有信息）
*
* @param info
* @param rsaKey
* @return
*/
public static String signDirectByRSA(String info, RSAKey rsaKey) {
try {
JWSSigner signer = new RSASSASigner(rsaKey);
JWSObject jwsObject = new JWSObject(
new JWSHeader.Builder(JWSAlgorithm.RS256).keyID(rsaKey.getKeyID()).build(),
new Payload(info)
);
// 進行加密
jwsObject.sign(signer);
return jwsObject.serialize();
} catch (JOSEException e) {
e.printStackTrace();
throw new PayloadSignException(JwtUtils.PAYLOAD_SIGN_ERROR, e);
}
}
/**
* 使用 HMAC 算法驗證 token（Payload 中只包含私有信息）
*
* @param token
* @param key
* @return
*/
public static String verifyDirectByHMAC(String token, String key) {
try {
JWSObject jwsObject = JWSObject.parse(token);
// 建立一個解鎖密匙
JWSVerifier jwsVerifier = new MACVerifier(key);
if (jwsObject.verify(jwsVerifier)) {
return jwsObject.getPayload().toString();
}
throw new TokenVerifyException(JwtUtils.TOKEN_VERIFY_ERROR, new NullPointerException("Payload can not be null"));
} catch (JOSEException | ParseException e) {
e.printStackTrace();
throw new TokenVerifyException(JwtUtils.TOKEN_VERIFY_ERROR, e);
}
}
/**
* 使用 RSA 算法驗證 token（Payload 中只包含私有信息）
*
* @param token
* @param rsaKey
* @return
*/
public static String verifyDirectByRSA(String token, RSAKey rsaKey) {
try {
RSAKey publicRSAKey = rsaKey.toPublicJWK();
JWSObject jwsObject = JWSObject.parse(token);
JWSVerifier jwsVerifier = new RSASSAVerifier(publicRSAKey);
// 驗證數據
if (jwsObject.verify(jwsVerifier)) {
return jwsObject.getPayload().toString();
}
throw new TokenVerifyException(JwtUtils.TOKEN_VERIFY_ERROR, new NullPointerException("Payload can not be null"));
} catch (JOSEException | ParseException e) {
e.printStackTrace();
throw new TokenVerifyException(JwtUtils.TOKEN_VERIFY_ERROR, e);
}
}定義統一的異常類，可以屏蔽 nimbus-jose-jwt 以及其他諸如加載證書錯誤拋出的異常，并且在其他項目集成我們封裝好的庫的時候，方便的進行異常處理。
在 JwtService 實現的不同階段，我們封裝了不同的 JwtException 子類，來方便外部根據需要做對應的處理。如異常是 KeyGenerateException，則處理成服務器處理錯誤；如異常是 TokenVerifyException，則處理成 Token 驗證失敗，無權限。
JWT 用于用戶認證，經常在 Token 驗證完成后，程序中需要獲取到當前登錄的用戶信息， JwtContext 中提供了通過線程局部變量保存信息的方法。
public class JwtContext {
private static final String KEY_TOKEN = "token";
private static final String KEY_PAYLOAD = "payload";
private static ThreadLocal<map<object, object>> context = new ThreadLocal<>();
private JwtContext() {}
public static void set(Object key, Object value) {
Map<object, object> locals = context.get();
if (locals == null) {
locals = new HashMap<>();
context.set(locals);
}
locals.put(key, value);
}
public static Object get(Object key) {
Map<object, object> locals = context.get();
if (locals != null) {
return locals.get(key);
}
return null;
}
public static void remove(Object key) {
Map<object, object> locals = context.get();
if (locals != null) {
locals.remove(key);
if (locals.isEmpty()) {
context.remove();
}
}
}
public static void removeAll() {
Map<object, object> locals = context.get();
if (locals != null) {
locals.clear();
}
context.remove();
}
public static void setToken(String token) {
set(KEY_TOKEN, token);
}
public static String getToken() {
return (String) get(KEY_TOKEN);
}
public static void setPayload(Object payload) {
set(KEY_PAYLOAD, payload);
}
public static Object getPayload() {
return get(KEY_PAYLOAD);
}
}在項目實戰中，并不是所有 Controller 中的方法都必須傳 Token，通過 @AuthRequired 注解來區分方法是否需要校驗 Token。
/**
* 應用于 Controller 中的方法，標識是否攔截進行 JWT 驗證
*/
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface AuthRequired {
boolean required() default true;
}有了上面封裝好的庫，我們在 SpringBoot 項目中集成 JWT。創建好 Spring Boot 項目后，我們編寫下面主要的類。
在 Spring Boot 項目中，通過自定義 HandlerInterceptor 的實現類可以對請求和響應進行攔截，我們新建 JwtDemoInterceptor 類進行攔截。
public class JwtDemoInterceptor implements HandlerInterceptor {
private static final Logger logger = LoggerFactory.getLogger(JwtDemoInterceptor.class);
private static final String PREFIX_BEARER = "Bearer ";
@Autowired
private JwtConfig jwtConfig;
@Autowired
private JwtService jwtService;
/**
* 預處理回調方法，實現處理器的預處理（如檢查登陸），第三個參數為響應的處理器，自定義 Controller
* 返回值：
* true 表示繼續流程（如調用下一個攔截器或處理器）；
* false 表示流程中斷（如登錄檢查失敗），不會繼續調用其他的攔截器或處理器，此時我們需要通過 response 來產生響應。
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
// 如果不是映射到方法直接通過
if(!(handler instanceof HandlerMethod)){
return true;
}
HandlerMethod handlerMethod = (HandlerMethod) handler;
Method method = handlerMethod.getMethod();
// 檢查是否有 @AuthRequired 注解，有且 required() 為 false 則跳過
if (method.isAnnotationPresent(AuthRequired.class)) {
AuthRequired authRequired = method.getAnnotation(AuthRequired.class);
if (!authRequired.required()) {
return true;
}
}
String token = request.getHeader(jwtConfig.getTokenName());
logger.info("token: {}", token);
if (StringUtils.isEmpty(token) || token.trim().equals(PREFIX_BEARER.trim())) {
return true;
}
token = token.replace(PREFIX_BEARER, "");
String payload = jwtService.verify(token);
// 設置線程局部變量中的 token
JwtContext.setToken(token);
JwtContext.setPayload(payload);
return true;
}
/**
* 后處理回調方法，實現處理器的后處理（但在渲染視圖之前），此時我們可以通過 modelAndView（模型和視圖對象）對模型數據進行處理或對視圖進行處理，modelAndView 也可能為null。
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
}
/**
* 整個請求處理完畢回調方法，即在視圖渲染完畢時回調，如性能監控中我們可以在此記錄結束時間并輸出消耗時間，還可以進行一些資源清理，類似于 try-catch-finally 中的 finally
* 但僅調用處理器執行鏈中 preHandle 返回 true 的攔截器的 afterCompletion。
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
JwtContext.removeAll();
}
}preHandle、postHandle、afterCompletion 三個方法的具體作用，可以看代碼上的注釋。
preHandle 中這段代碼中的邏輯如下：
攔截被 @AuthRequired 注解的方法，只要不是 required = false 都會進行 Token 的校驗。
從請求中解析出 Token，對 Token 進行驗證。如果驗證異常，會在方法中拋出異常。
Token 驗證通過，會在線程局部變量中設置相關信息，以便后續程序獲取處理。
afterCompletion 中這段代碼對線程變量進行了清理。
定義 InterceptorConfig，通過 @Configuration 注解，Spring 會加載該類，并完成裝配。
addInterceptors 方法中設置攔截器，并攔截所有請求。
jwtDemoConfig 方法中注入 JwtConfig，并設置了 HMACKey。
jwtDemoService 方法會根據注入的 JwtConfig 配置，生成具體的 JwtService，這里是 HMACJwtServiceImpl。
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(jwtDemoInterceptor()).addPathPatterns("/**");
}
@Bean
public JwtDemoInterceptor jwtDemoInterceptor() {
return new JwtDemoInterceptor();
}
@Bean
public JwtConfig jwtDemoConfig() {
JwtConfig jwtConfig = new JwtConfig();
jwtConfig.setHmacKey("cb9915297c8b43e820afd2a90a1e36cb");
return jwtConfig;
}
@Bean
public JwtService jwtDemoService() {
return JwtUtils.obtainJwtService(jwtDemoConfig());
}
}@RestController
public class UserController {
@Autowired
private ObjectMapper objectMapper;
@Autowired
private JwtService jwtService;
@GetMapping("/sign")
@AuthRequired(required = false)
public String sign() throws JsonProcessingException {
UserDTO userDTO = new UserDTO();
userDTO.setName("fatfoo");
userDTO.setPassword("112233");
userDTO.setSex(0);
String payload = objectMapper.writeValueAsString(userDTO);
return jwtService.sign(payload);
}
@GetMapping("/verify")
public UserDTO verify() throws IOException {
String payload = (String) JwtContext.getPayload();
return objectMapper.readValue(payload, UserDTO.class);
}
}sign 方法對用戶信息進行簽名并返回 Token；由于 @AuthRequired(required = false) 攔截器將不會對其進行攔截。
verify 方法在 Token 通過驗證后，獲取解析出的信息并返回。
訪問 sign 接口，返回簽名 Token。
在 Header 中添加 Token 信息，請求 verify 接口，返回用戶信息。
上面我們只設置了 JwtConfig 的 hmacKey 參數，使用的是 HMAC 算法進行簽名和驗證。本節我們演示 RSA 算法進行簽名和驗證的實現。
使用 Java 自帶的 keytool 工具可以方便的生成證書文件。
? resources git:(master) ? keytool -genkey -alias jwt -keyalg RSA -keystore jwt.jks 輸入密鑰庫口令: 密鑰庫口令太短 - 至少必須為 6 個字符 輸入密鑰庫口令: ronjwt 再次輸入新口令: ronjwt 您的名字與姓氏是什么? [Unknown]: ron 您的組織單位名稱是什么? [Unknown]: ron 您的組織名稱是什么? [Unknown]: ron 您所在的城市或區域名稱是什么? [Unknown]: Xiamen 您所在的省/市/自治區名稱是什么? [Unknown]: Fujian 該單位的雙字母國家/地區代碼是什么? [Unknown]: CN CN=ron, OU=ron, O=ron, L=Xiamen, ST=Fujian, C=CN是否正確? [否]: 是 輸入 <jwt> 的密鑰口令 (如果和密鑰庫口令相同, 按回車): Warning: JKS 密鑰庫使用專用格式。建議使用 "keytool -importkeystore -srckeystore jwt.jks -destkeystore jwt.jks -deststoretype pkcs12" 遷移到行業標準格式 PKCS12。
文件生成后，復制到項目的 resources 目錄下。
修改上節 InterceptorConfig 中的 jwtDemoConfig 方法，這是 jksFileName、jksPassword、certPassword 3 個參數。
@Bean
public JwtConfig jwtDemoConfig() {
JwtConfig jwtConfig = new JwtConfig();
// jwtConfig.setHmacKey("cb9915297c8b43e820afd2a90a1e36cb");
jwtConfig.setJksFileName("jwt.jks");
jwtConfig.setJksPassword("ronjwt");
jwtConfig.setCertPassword("ronjwt");
return jwtConfig;
}不要設置 hmacKey 參數，否則會加載 HMACJwtServiceImpl。因為 JwtUtils#obtainJwtService 方法實現如下：
/**
* 獲取內置 JwtService 的工廠方法。
*
* 優先采用 HMAC 算法實現
*
* @param jwtConfig
* @return
*/
public static JwtService obtainJwtService(JwtConfig jwtConfig) {
if (!JwtUtils.isEmpty(jwtConfig.getHmacKey())) {
return new HMACJwtServiceImpl(jwtConfig);
}
return new RSAJwtServiceImpl(jwtConfig);
}上述就是小編為大家分享的Spring Boot 中怎么使用JWT 實現用戶登錄認證了，如果剛好有類似的疑惑，不妨參照上述分析進行理解。如果想知道更多相關知識，歡迎關注億速云行業資訊頻道。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
