• spring security 用户认证原理

    目录

    一、从过滤器链开始

    二、获取用户信息

    三、用户名和密码认证流程

    四、构建成功的认证对象

    五、认证信息放入SecurityContext

    一、从过滤器链开始

    当我们执行认证逻辑，在获取用户信息时，可打一个断点，跟踪程序的调用链

    在程序的调用链中，找到一个 StandardWrapperValve 的记录，StandardWrapperValve.class 类位于 tomcat 核心包中，跟踪到这个调用位置（StandardWrapperValve#invoke），可以看到过滤器链的调用

    二、获取用户信息

    在调用链的一系列过滤器中，找到 UsernamePasswordAuthenticationFilter.calss（用户名和密码认证过滤器）

    用户名和密码认证过滤器继承了 AbstractAuthenticationProcessingFilter.calss，该过滤器的 #doFilter 方法中，调用了用户名和密码认证过滤器中用户认证的逻辑

    1. public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
    2. 			throws IOException, ServletException {
    3.  
    4. 		HttpServletRequest request = (HttpServletRequest) req;
    5. 		HttpServletResponse response = (HttpServletResponse) res;
    6.  
    7. 		if (!requiresAuthentication(request, response)) {
    8.             // 返回点 -> 需要关注
    9. 			chain.doFilter(request, response);
    10.  
    11. 			return;
    12. 		}
    13.  
    14. 		if (logger.isDebugEnabled()) {
    15. 			logger.debug("Request is to process authentication");
    16. 		}
    17.  
    18. 		Authentication authResult;
    19.  
    20. 		try {
    21.             // 调用认证逻辑-> 返回认证结果
    22. 			authResult = attemptAuthentication(request, response);
    23. 			if (authResult == null) {
    24. 				// return immediately as subclass has indicated that it hasn't completed
    25. 				// authentication
    26. 				return;
    27. 			}
    28. 			sessionStrategy.onAuthentication(authResult, request, response);
    29. 		}
    30. 		catch (InternalAuthenticationServiceException failed) {
    31. 			logger.error(
    32. 					"An internal error occurred while trying to authenticate the user.",
    33. 					failed);
    34.             // 扩展点
    35. 			unsuccessfulAuthentication(request, response, failed);
    36.  
    37. 			return;
    38. 		}
    39. 		catch (AuthenticationException failed) {
    40. 			// 扩展点 Authentication failed 认证失败
    41. 			unsuccessfulAuthentication(request, response, failed);
    42.  
    43. 			return;
    44. 		}
    45.  
    46. 		// Authentication success 认证成功
    47. 		if (continueChainBeforeSuccessfulAuthentication) {
    48. 			chain.doFilter(request, response);
    49. 		}
    50.         // 扩展点 -> AuthenticationSuccessHandler
    51. 		successfulAuthentication(request, response, chain, authResult);
    52. 	}

    调用 attemptAuthentication(request, response) 抽象方法

    UsernamePasswordAuthenticationFilter#attemptAuthentication 实现了该抽象方法

    1. public Authentication attemptAuthentication(HttpServletRequest request,
    2. 			HttpServletResponse response) throws AuthenticationException {
    3. 		// 1-必须为 post 方法
    4.         if (postOnly && !request.getMethod().equals("POST")) {
    5. 			throw new AuthenticationServiceException(
    6. 					"Authentication method not supported: " + request.getMethod());
    7. 		}
    8.         // 2-解析用户名和密码 -> 固定解析参数名称 'username','password'
    9. 		String username = obtainUsername(request);
    10. 		String password = obtainPassword(request);
    11.  
    12. 		if (username == null) {
    13. 			username = "";
    14. 		}
    15.  
    16. 		if (password == null) {
    17. 			password = "";
    18. 		}
    19.  
    20. 		username = username.trim();
    21.         // 3-封装到认证的token,此时认证状态为 false -> setAuthenticated(false); 
    22. 		UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(
    23. 				username, password);
    24.  
    25. 		// Allow subclasses to set the "details" property
    26. 		setDetails(request, authRequest);
    27.         // 4-调用认证管理器进行认证 -> 认证核心逻辑
    28. 		return this.getAuthenticationManager().authenticate(authRequest);
    29. 	}

    方法 this.getAuthenticationManager().authenticate(authRequest); 调用认证管理器的具体实现进行权限验证

    具体认证管理器的实现逻辑为 ProviderManager.class#authenticate

    1. public Authentication authenticate(Authentication authentication)
    2. 			throws AuthenticationException {
    3. 		Class<? extends Authentication> toTest = authentication.getClass();
    4. 		AuthenticationException lastException = null;
    5. 		AuthenticationException parentException = null;
    6. 		Authentication result = null;
    7. 		Authentication parentResult = null;
    8. 		boolean debug = logger.isDebugEnabled();
    9.         // providers 列表循环
    10. 		for (AuthenticationProvider provider : getProviders()) {
    11. 			if (!provider.supports(toTest)) {
    12. 				continue;
    13. 			}
    14.  
    15. 			if (debug) {
    16. 				logger.debug("Authentication attempt using "
    17. 						+ provider.getClass().getName());
    18. 			}
    19.  
    20. 			try {
    21.                 // 具体的provider -> 结果返回，关键的认证方法
    22. 				result = provider.authenticate(authentication);
    23.  
    24. 				if (result != null) {
    25. 					copyDetails(authentication, result);
    26. 					break;
    27. 				}
    28. 			}
    29. 			catch (AccountStatusException e) {
    30. 				prepareException(e, authentication);
    31. 				// SEC-546: Avoid polling additional providers if auth failure is due to
    32. 				// invalid account status
    33. 				throw e;
    34. 			}
    35. 			catch (InternalAuthenticationServiceException e) {
    36. 				prepareException(e, authentication);
    37. 				throw e;
    38. 			}
    39. 			catch (AuthenticationException e) {
    40. 				lastException = e;
    41. 			}
    42. 		}
    43.  
    44. 		if (result == null && parent != null) {
    45. 			// Allow the parent to try.
    46. 			try {
    47. 				result = parentResult = parent.authenticate(authentication);
    48. 			}
    49. 			catch (ProviderNotFoundException e) {
    50. 				// ignore as we will throw below if no other exception occurred prior to
    51. 				// calling parent and the parent
    52. 				// may throw ProviderNotFound even though a provider in the child already
    53. 				// handled the request
    54. 			}
    55. 			catch (AuthenticationException e) {
    56. 				lastException = parentException = e;
    57. 			}
    58. 		}
    59.  
    60. 		if (result != null) {
    61. 			if (eraseCredentialsAfterAuthentication
    62. 					&& (result instanceof CredentialsContainer)) {
    63. 				// Authentication is complete. Remove credentials and other secret data
    64. 				// from authentication
    65. 				((CredentialsContainer) result).eraseCredentials();
    66. 			}
    67.  
    68. 			// If the parent AuthenticationManager was attempted and successful than it will publish an AuthenticationSuccessEvent
    69. 			// This check prevents a duplicate AuthenticationSuccessEvent if the parent AuthenticationManager already published it
    70. 			if (parentResult == null) {
    71. 				eventPublisher.publishAuthenticationSuccess(result);
    72. 			}
    73. 			return result;
    74. 		}
    75.  
    76. 		// Parent was null, or didn't authenticate (or throw an exception).
    78. 		if (lastException == null) {
    79. 			lastException = new ProviderNotFoundException(messages.getMessage(
    80. 					"ProviderManager.providerNotFound",
    81. 					new Object[] { toTest.getName() },
    82. 					"No AuthenticationProvider found for {0}"));
    83. 		}
    85. 		// If the parent AuthenticationManager was attempted and failed than it will publish an AbstractAuthenticationFailureEvent
    86. 		// This check prevents a duplicate AbstractAuthenticationFailureEvent if the parent AuthenticationManager already published it
    87. 		if (parentException == null) {
    88. 			prepareException(lastException, authentication);
    89. 		}
    91. 		throw lastException;
    92. 	}

    具体调用到哪一个 ProviderManager#authenticate 的实现，我们可以通过断点来定位

    此时，我们回到原来断点的调用链，可以看到代码的调用层次如下

    1. -> ProviderManager#authenticate
    2. -> AbstractUserDetailsAuthenticationProvider#authenticate 认证
    3. -> DaoAuthenticationProvider#retrieveUser // 获取用户信息

    执行逻辑调用到了 AbstractUserDetailsAuthenticationProvider#authenticate 方法中，该方法中有多个获取用户信息的扩展点，支持用户进行自定义

    1. public Authentication authenticate(Authentication authentication)
    2. 			throws AuthenticationException {
    3. 		Assert.isInstanceOf(UsernamePasswordAuthenticationToken.class, authentication,
    4. 				() -> messages.getMessage(
    5. 						"AbstractUserDetailsAuthenticationProvider.onlySupports",
    6. 						"Only UsernamePasswordAuthenticationToken is supported"));
    7.  
    8. 		// Determine username
    9. 		String username = (authentication.getPrincipal() == null) ? "NONE_PROVIDED"
    10. 				: authentication.getName();
    11.  
    12. 		boolean cacheWasUsed = true;
    13.         // 1-从cache中获取用户信息 -> 可是实现 UserCache 接口自定义、redis等
    14. 		UserDetails user = this.userCache.getUserFromCache(username);
    15.  
    16. 		if (user == null) {
    17. 			cacheWasUsed = false;
    18.  
    19. 			try {
    20.                 // 2-从定义的方法中获取用户信息（实现接口自定义）
    21. 				user = retrieveUser(username,
    22. 						(UsernamePasswordAuthenticationToken) authentication);
    23. 			}
    24. 			catch (UsernameNotFoundException notFound) {
    25. 				logger.debug("User '" + username + "' not found");
    26.  
    27. 				if (hideUserNotFoundExceptions) {
    28. 					throw new BadCredentialsException(messages.getMessage(
    29. 							"AbstractUserDetailsAuthenticationProvider.badCredentials",
    30. 							"Bad credentials"));
    31. 				}
    32. 				else {
    33. 					throw notFound;
    34. 				}
    35. 			}
    36.  
    37. 			Assert.notNull(user,
    38. 					"retrieveUser returned null - a violation of the interface contract");
    39. 		}
    40.  
    41. 		try {
    42.             // 3-检验用户是否被锁、是否可用、过期等 -> UserDetails 属性（可以自定义逻辑）
    43. 			preAuthenticationChecks.check(user);
    44.             // 4-密码认证逻辑 -> 该类中的additionalAuthenticationChecks实现
    45. 			additionalAuthenticationChecks(user,
    46. 					(UsernamePasswordAuthenticationToken) authentication);
    47. 		}
    48. 		catch (AuthenticationException exception) {
    49. 			if (cacheWasUsed) {
    50. 				// There was a problem, so try again after checking
    51. 				// we're using latest data (i.e. not from the cache)
    52. 				cacheWasUsed = false;
    53. 				user = retrieveUser(username,
    54. 						(UsernamePasswordAuthenticationToken) authentication);
    55. 				preAuthenticationChecks.check(user);
    56. 				additionalAuthenticationChecks(user,
    57. 						(UsernamePasswordAuthenticationToken) authentication);
    58. 			}
    59. 			else {
    60. 				throw exception;
    61. 			}
    62. 		}
    64. 		postAuthenticationChecks.check(user);
    66. 		if (!cacheWasUsed) {
    67.             // 设置用户缓存
    68. 			this.userCache.putUserInCache(user);
    69. 		}
    71. 		Object principalToReturn = user;
    73. 		if (forcePrincipalAsString) {
    74. 			principalToReturn = user.getUsername();
    75. 		}
    76.         // 5-创建成功的权限验证结果 -> 构建成功的认证对象
    77. 		return createSuccessAuthentication(principalToReturn, authentication, user);
    78. 	}

    因为我们使用的是从数据库获取用户信息，所以程序最终会执行到下边的方法中来

    user = retrieveUser(username,
                            (UsernamePasswordAuthenticationToken) authentication);

    最终进入  DaoAuthenticationProvider.class#retrieveUser 方法，此方法中会去获取用户信息 -> 会调用我们自己实现的获取用户信息的方法

    1. protected final UserDetails retrieveUser(String username,
    2. 			UsernamePasswordAuthenticationToken authentication)
    3. 			throws AuthenticationException {
    4. 		prepareTimingAttackProtection();
    5. 		try {
    6.             // 获取用户信息->调用我们自己实现的获取用户信息的方法
    7. 			UserDetails loadedUser = this.getUserDetailsService().loadUserByUsername(username);
    8. 			if (loadedUser == null) {
    9. 				throw new InternalAuthenticationServiceException(
    10. 						"UserDetailsService returned null, which is an interface contract violation");
    11. 			}
    12. 			return loadedUser;
    13. 		}
    14. 		catch (UsernameNotFoundException ex) {
    15. 			mitigateAgainstTimingAttack(authentication);
    16. 			throw ex;
    17. 		}
    18. 		catch (InternalAuthenticationServiceException ex) {
    19. 			throw ex;
    20. 		}
    21. 		catch (Exception ex) {
    22. 			throw new InternalAuthenticationServiceException(ex.getMessage(), ex);
    23. 		}
    24. 	}

    调用我们自己实现的 loadUserByUsername() 方法

    三、用户名和密码认证流程

    获取用户信息后，回到 AbstractUserDetailsAuthenticationProvider#authenticate 方法中，该方法后边代码具体实现了密码验证的逻辑

    1. public Authentication authenticate(Authentication authentication)
    2. 			throws AuthenticationException {
    3. 		Assert.isInstanceOf(UsernamePasswordAuthenticationToken.class, authentication,
    4. 				() -> messages.getMessage(
    5. 						"AbstractUserDetailsAuthenticationProvider.onlySupports",
    6. 						"Only UsernamePasswordAuthenticationToken is supported"));
    7.  
    8. 		// Determine username
    9. 		String username = (authentication.getPrincipal() == null) ? "NONE_PROVIDED"
    10. 				: authentication.getName();
    11.  
    12. 		boolean cacheWasUsed = true;
    13.         // 1-从cache中获取用户信息 -> 可是实现 UserCache 接口自定义、redis等
    14. 		UserDetails user = this.userCache.getUserFromCache(username);
    15.  
    16. 		if (user == null) {
    17. 			cacheWasUsed = false;
    18.  
    19. 			try {
    20.                 // 2-从定义的方法中获取用户信息（实现接口自定义）
    21. 				user = retrieveUser(username,
    22. 						(UsernamePasswordAuthenticationToken) authentication);
    23. 			}
    24. 			catch (UsernameNotFoundException notFound) {
    25. 				logger.debug("User '" + username + "' not found");
    26.  
    27. 				if (hideUserNotFoundExceptions) {
    28. 					throw new BadCredentialsException(messages.getMessage(
    29. 							"AbstractUserDetailsAuthenticationProvider.badCredentials",
    30. 							"Bad credentials"));
    31. 				}
    32. 				else {
    33. 					throw notFound;
    34. 				}
    35. 			}
    36.  
    37. 			Assert.notNull(user,
    38. 					"retrieveUser returned null - a violation of the interface contract");
    39. 		}
    40.  
    41. 		try {
    42.             // 3-检验用户是否被锁、是否可用、过期等 -> UserDetails 属性（可以自定义逻辑）
    43. 			preAuthenticationChecks.check(user);
    44.             // 4-密码认证逻辑 -> 该类中的additionalAuthenticationChecks实现
    45. 			additionalAuthenticationChecks(user,
    46. 					(UsernamePasswordAuthenticationToken) authentication);
    47. 		}
    48. 		catch (AuthenticationException exception) {
    49. 			if (cacheWasUsed) {
    50. 				// There was a problem, so try again after checking
    51. 				// we're using latest data (i.e. not from the cache)
    52. 				cacheWasUsed = false;
    53. 				user = retrieveUser(username,
    54. 						(UsernamePasswordAuthenticationToken) authentication);
    55. 				preAuthenticationChecks.check(user);
    56. 				additionalAuthenticationChecks(user,
    57. 						(UsernamePasswordAuthenticationToken) authentication);
    58. 			}
    59. 			else {
    60. 				throw exception;
    61. 			}
    62. 		}
    64. 		postAuthenticationChecks.check(user);
    66. 		if (!cacheWasUsed) {
    67.             // 设置用户缓存
    68. 			this.userCache.putUserInCache(user);
    69. 		}
    71. 		Object principalToReturn = user;
    73. 		if (forcePrincipalAsString) {
    74. 			principalToReturn = user.getUsername();
    75. 		}
    76.         // 5-创建成功的权限验证结果 -> 构建成功的认证对象
    77. 		return createSuccessAuthentication(principalToReturn, authentication, user);
    78. 	}

    密码验证的具体逻辑

    1. protected void additionalAuthenticationChecks(UserDetails userDetails,
    2. 			UsernamePasswordAuthenticationToken authentication)
    3. 			throws AuthenticationException {
    4. 		if (authentication.getCredentials() == null) {
    5. 			logger.debug("Authentication failed: no credentials provided");
    6.  
    7. 			throw new BadCredentialsException(messages.getMessage(
    8. 					"AbstractUserDetailsAuthenticationProvider.badCredentials",
    9. 					"Bad credentials"));
    10. 		}
    11.  
    12. 		String presentedPassword = authentication.getCredentials().toString();
    13.         // 对加密后的密码进行匹配
    14. 		if (!passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {
    15. 			logger.debug("Authentication failed: password does not match stored value");
    16.  
    17. 			throw new BadCredentialsException(messages.getMessage(
    18. 					"AbstractUserDetailsAuthenticationProvider.badCredentials",
    19. 					"Bad credentials"));
    20. 		}
    21. 	}

    执行断点截图

    至此用户名和密码认证完成，密码认证通过后，接着会获取用户权限，并构建成功的认证对象

    四、构建成功的认证对象

    回到 AbstractUserDetailsAuthenticationProvider#authenticate 方法中

    1. public Authentication authenticate(Authentication authentication)
    2. 			throws AuthenticationException {
    3. 		Assert.isInstanceOf(UsernamePasswordAuthenticationToken.class, authentication,
    4. 				() -> messages.getMessage(
    5. 						"AbstractUserDetailsAuthenticationProvider.onlySupports",
    6. 						"Only UsernamePasswordAuthenticationToken is supported"));
    7.  
    8. 		// Determine username
    9. 		String username = (authentication.getPrincipal() == null) ? "NONE_PROVIDED"
    10. 				: authentication.getName();
    11.  
    12. 		boolean cacheWasUsed = true;
    13.         // 1-从cache中获取用户信息 -> 可是实现 UserCache 接口自定义、redis等
    14. 		UserDetails user = this.userCache.getUserFromCache(username);
    15.  
    16. 		if (user == null) {
    17. 			cacheWasUsed = false;
    18.  
    19. 			try {
    20.                 // 2-从定义的方法中获取用户信息（实现接口自定义）
    21. 				user = retrieveUser(username,
    22. 						(UsernamePasswordAuthenticationToken) authentication);
    23. 			}
    24. 			catch (UsernameNotFoundException notFound) {
    25. 				logger.debug("User '" + username + "' not found");
    26.  
    27. 				if (hideUserNotFoundExceptions) {
    28. 					throw new BadCredentialsException(messages.getMessage(
    29. 							"AbstractUserDetailsAuthenticationProvider.badCredentials",
    30. 							"Bad credentials"));
    31. 				}
    32. 				else {
    33. 					throw notFound;
    34. 				}
    35. 			}
    36.  
    37. 			Assert.notNull(user,
    38. 					"retrieveUser returned null - a violation of the interface contract");
    39. 		}
    40.  
    41. 		try {
    42.             // 3-检验用户是否被锁、是否可用、过期等 -> UserDetails 属性（可以自定义逻辑）
    43. 			preAuthenticationChecks.check(user);
    44.             // 4-密码认证逻辑 -> 该类中的additionalAuthenticationChecks实现
    45. 			additionalAuthenticationChecks(user,
    46. 					(UsernamePasswordAuthenticationToken) authentication);
    47. 		}
    48. 		catch (AuthenticationException exception) {
    49. 			if (cacheWasUsed) {
    50. 				// There was a problem, so try again after checking
    51. 				// we're using latest data (i.e. not from the cache)
    52. 				cacheWasUsed = false;
    53. 				user = retrieveUser(username,
    54. 						(UsernamePasswordAuthenticationToken) authentication);
    55. 				preAuthenticationChecks.check(user);
    56. 				additionalAuthenticationChecks(user,
    57. 						(UsernamePasswordAuthenticationToken) authentication);
    58. 			}
    59. 			else {
    60. 				throw exception;
    61. 			}
    62. 		}
    64. 		postAuthenticationChecks.check(user);
    66. 		if (!cacheWasUsed) {
    67.             // 设置用户缓存
    68. 			this.userCache.putUserInCache(user);
    69. 		}
    71. 		Object principalToReturn = user;
    73. 		if (forcePrincipalAsString) {
    74. 			principalToReturn = user.getUsername();
    75. 		}
    76.         // 5-创建成功的权限验证结果 -> 构建成功的认证对象
    77. 		return createSuccessAuthentication(principalToReturn, authentication, user);
    78. 	}

    createSuccessAuthentication(principalToReturn, authentication, user); 构建的认证成功结果如下

    五、认证信息放入SecurityContext

    UsernamePasswordAuthenticationFilter 继承了认证过滤器 AbstractAuthenticationProcessingFilter，实现了具体的认证逻辑，用户认证时会先执行AbstractAuthenticationProcessingFilter#doFilter

    1. public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
    2. 			throws IOException, ServletException {
    3.  
    4. 		HttpServletRequest request = (HttpServletRequest) req;
    5. 		HttpServletResponse response = (HttpServletResponse) res;
    6.  
    7. 		if (!requiresAuthentication(request, response)) {
    8. 			chain.doFilter(request, response);
    9.  
    10. 			return;
    11. 		}
    12.  
    13. 		if (logger.isDebugEnabled()) {
    14. 			logger.debug("Request is to process authentication");
    15. 		}
    16.  
    17. 		Authentication authResult;
    18.  
    19. 		try {
    20.             // 认证逻辑 -> UsernamePasswordAuthenticationFilter
    21. 			authResult = attemptAuthentication(request, response);
    22. 			if (authResult == null) {
    23. 				// return immediately as subclass has indicated that it hasn't completed
    24. 				// authentication
    25. 				return;
    26. 			}
    27. 			sessionStrategy.onAuthentication(authResult, request, response);
    28. 		}
    29. 		catch (InternalAuthenticationServiceException failed) {
    30. 			logger.error(
    31. 					"An internal error occurred while trying to authenticate the user.",
    32. 					failed);
    33. 			unsuccessfulAuthentication(request, response, failed);
    34.  
    35. 			return;
    36. 		}
    37. 		catch (AuthenticationException failed) {
    38. 			// Authentication failed
    39. 			unsuccessfulAuthentication(request, response, failed);
    40.  
    41. 			return;
    42. 		}
    43.  
    44. 		// Authentication success
    45. 		if (continueChainBeforeSuccessfulAuthentication) {
    46. 			chain.doFilter(request, response);
    47. 		}
    48.         // 成功认证后的操作
    49. 		successfulAuthentication(request, response, chain, authResult);
    50. 	}

    认证通过后，doFilter 方法中调用了 以下方法

    successfulAuthentication(request, response, chain, authResult);

    该方法也在 AbstractAuthenticationProcessingFilter 过滤器中， 在AbstractAuthenticationProcessingFilter#successfulAuthentication 方法中，把认证结果存入到了 SecurityContext 中

    1. protected void successfulAuthentication(HttpServletRequest request,
    2. 			HttpServletResponse response, FilterChain chain, Authentication authResult)
    3. 			throws IOException, ServletException {
    4.  
    5. 		if (logger.isDebugEnabled()) {
    6. 			logger.debug("Authentication success. Updating SecurityContextHolder to contain: "
    7. 					+ authResult);
    8. 		}
    9.         // 把认证结果存入到 SecurityContext 中
    10. 		SecurityContextHolder.getContext().setAuthentication(authResult);
    11.  
    12. 		rememberMeServices.loginSuccess(request, response, authResult);
    13.  
    14. 		// Fire event
    15. 		if (this.eventPublisher != null) {
    16. 			eventPublisher.publishEvent(new InteractiveAuthenticationSuccessEvent(
    17. 					authResult, this.getClass()));
    18. 		}
    19.  
    20. 		successHandler.onAuthenticationSuccess(request, response, authResult);
    21. 	}

    至此，整个认证流程完成。

     补充用户认证流程。

  • 相关阅读:
    Java 线程
    Spring Boot框架
    【笔记版】cgroup大摸底
    PID控制原理基本介绍（图解）
    在CentOS下安装MySQL
    《安富莱嵌入式周报》第291期：分分钟设计数字芯片，单片机版JS，神经网络DSP，microPLC，FatFS升级至V0.15，微软Arm64 VS正式版发布
    Gartner：2024 年十大战略技术趋势
    为什么mac上有的软件删除不掉？
    在集群模式下，Redis 的 key 是如何寻址的？分布式寻址都有哪些算法？了解一致性 hash 算法吗？
    个人博客系列-后端项目-RBAC角色管理（6）
  • 原文地址：https://blog.csdn.net/swadian2008/article/details/126492531