【SpringCloud微服务项目实战-mall4cloud项目(3)】——mall4cloud-auth

最新推荐文章于 2023-11-22 18:34:07 发布
最新推荐文章于 2023-11-22 18:34:07 发布
阅读量402 收藏 3
点赞数 5
分类专栏： mall4cloud SpringCloud 微服务 文章标签： spring cloud 微服务 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40454136/article/details/132861108
版权

mall4cloud-auth-认证与授权

目前项目登录使用的认证授权方式较为简单，认证通过token令牌方式，授权通过用户名密码方式，并且结合了captcha验证码登录。下面的介绍中会增加OAuth2的授权方式。

pom依赖

先看一下auth模块的相关依赖
在这里插入图片描述
①：common下的database模块，主要是关于分页工具、mybatis配置、分布式id等一些数据库相关内容
②：cache:主要是操作redis相关内容，像key、crud工具、redis分布式锁等
③：封装了授权过滤一些配置和过滤器实现
④：验证码相关
⑤：fegin调用的内部api接口

nacos配置

nacos配置如下内容，用于token生成。
在这里插入图片描述

令牌认证

介绍

令牌认证主要用于验证用户的身份。
通常，用户提供用户名和密码进行身份验证，服务器验证后颁发一个访问令牌（Token）给客户端。客户端可以在后续请求中使用这个令牌来证明其身份，而不需要再次提供用户名和密码。
令牌通常是一串字符，可以包含用户信息和权限信息。

项目代码

@PostMapping("/ua/login")
	@Operation(summary = "账号密码" , description = "通过账号登录，还要携带用户的类型，也就是用户所在的系统")
	public ServerResponseEntity<TokenInfoVO> login(
			@Valid @RequestBody AuthenticationDTO authenticationDTO) {

		// 这边获取了用户的用户信息，那么根据sessionid对应一个user的原则，我应该要把这个东西存起来，然后校验，那么存到哪里呢？
		// redis，redis有天然的自动过期的机制，有key value的形式
		ServerResponseEntity<UserInfoInTokenBO> userInfoInTokenResponse = authAccountService
				.getUserInfoInTokenByInputUserNameAndPassword(authenticationDTO.getPrincipal(),
						authenticationDTO.getCredentials(), authenticationDTO.getSysType());


		if (!userInfoInTokenResponse.isSuccess()) {
			return ServerResponseEntity.transform(userInfoInTokenResponse);
		}

		UserInfoInTokenBO data = userInfoInTokenResponse.getData();

		ClearUserPermissionsCacheDTO clearUserPermissionsCacheDTO = new ClearUserPermissionsCacheDTO();
		clearUserPermissionsCacheDTO.setSysType(data.getSysType());
		clearUserPermissionsCacheDTO.setUserId(data.getUserId());
		// 将以前的权限清理了,以免权限有缓存
		ServerResponseEntity<Void> clearResponseEntity = permissionFeignClient.clearUserPermissionsCache(clearUserPermissionsCacheDTO);

		if (!clearResponseEntity.isSuccess()) {
			return ServerResponseEntity.fail(ResponseEnum.UNAUTHORIZED);
		}

		// 保存token，返回token数据给前端，这里是最重要的
		return ServerResponseEntity.success(tokenStore.storeAndGetVo(data));
	}

完成登录后，获取一个token令牌返回到前端。再看一下用户名密码的校验

if (StrUtil.isBlank(inputUserName)) {
			return ServerResponseEntity.showFailMsg("用户名不能为空");
		}
		if (StrUtil.isBlank(password)) {
			return ServerResponseEntity.showFailMsg("密码不能为空");
		}

		InputUserNameEnum inputUserNameEnum = null;

		// 用户名
		if (PrincipalUtil.isUserName(inputUserName)) {
			inputUserNameEnum = InputUserNameEnum.USERNAME;
		}

		if (inputUserNameEnum == null) {
			return ServerResponseEntity.showFailMsg("请输入正确的用户名");
		}

		AuthAccountInVerifyBO authAccountInVerifyBO = authAccountMapper
				.getAuthAccountInVerifyByInputUserName(inputUserNameEnum.value(), inputUserName, sysType);

		if (authAccountInVerifyBO == null) {
			prepareTimingAttackProtection();
			// 再次进行运算，防止计时攻击
			// 计时攻击（Timing
			// attack），通过设备运算的用时来推断出所使用的运算操作，或者通过对比运算的时间推定数据位于哪个存储设备，或者利用通信的时间差进行数据窃取。
			mitigateAgainstTimingAttack(password);
			return ServerResponseEntity.showFailMsg("用户名或密码不正确");
		}

		if (Objects.equals(authAccountInVerifyBO.getStatus(), AuthAccountStatusEnum.DISABLE.value())) {
			return ServerResponseEntity.showFailMsg("用户已禁用，请联系客服");
		}

		if (!passwordEncoder.matches(password, authAccountInVerifyBO.getPassword())) {
			return ServerResponseEntity.showFailMsg("用户名或密码不正确");
		}
		return ServerResponseEntity.success(BeanUtil.map(authAccountInVerifyBO, UserInfoInTokenBO.class));

通过用户名获取用户信息，并通过passwordEncoder.matches（）校验了密码，密码如果成功返回成功状态，userInfoInTokenResponse.isSuccess()。向下进行，调用permissionFeignClient清理权限。最后获取token代码如下：

public TokenInfoVO storeAndGetVo(UserInfoInTokenBO userInfoInToken) {
		TokenInfoBO tokenInfoBO = storeAccessToken(userInfoInToken);

		TokenInfoVO tokenInfoVO = new TokenInfoVO();
		tokenInfoVO.setAccessToken(tokenInfoBO.getAccessToken());
		tokenInfoVO.setRefreshToken(tokenInfoBO.getRefreshToken());
		tokenInfoVO.setExpiresIn(tokenInfoBO.getExpiresIn());
		return tokenInfoVO;
	}

/**
	 * 将用户的部分信息存储在token中，并返回token信息
	 * @param userInfoInToken 用户在token中的信息
	 * @return token信息
	 */
	public TokenInfoBO storeAccessToken(UserInfoInTokenBO userInfoInToken) {
		TokenInfoBO tokenInfoBO = new TokenInfoBO();
		String accessToken = IdUtil.simpleUUID();
		String refreshToken = IdUtil.simpleUUID();

		tokenInfoBO.setUserInfoInToken(userInfoInToken);
		tokenInfoBO.setExpiresIn(getExpiresIn(userInfoInToken.getSysType()));

		String uidToAccessKeyStr = getUidToAccessKey(getApprovalKey(userInfoInToken));
		String accessKeyStr = getAccessKey(accessToken);
		String refreshToAccessKeyStr = getRefreshToAccessKey(refreshToken);

		// 一个用户会登陆很多次，每次登陆的token都会存在 uid_to_access里面
		// 但是每次保存都会更新这个key的时间，而key里面的token有可能会过期，过期就要移除掉
		List<String> existsAccessTokens = new ArrayList<>();
		// 新的token数据
		existsAccessTokens.add(accessToken + StrUtil.COLON + refreshToken);

		Long size = redisTemplate.opsForSet().size(uidToAccessKeyStr);
		if (size != null && size != 0) {
			List<String> tokenInfoBoList = stringRedisTemplate.opsForSet().pop(uidToAccessKeyStr, size);
			if (tokenInfoBoList != null) {
				for (String accessTokenWithRefreshToken : tokenInfoBoList) {
					String[] accessTokenWithRefreshTokenArr = accessTokenWithRefreshToken.split(StrUtil.COLON);
					String accessTokenData = accessTokenWithRefreshTokenArr[0];
					if (BooleanUtil.isTrue(stringRedisTemplate.hasKey(getAccessKey(accessTokenData)))) {
						existsAccessTokens.add(accessTokenWithRefreshToken);
					}
				}
			}
		}

		redisTemplate.executePipelined((RedisCallback<Object>) connection -> {

			long expiresIn = tokenInfoBO.getExpiresIn();

			byte[] uidKey = uidToAccessKeyStr.getBytes(StandardCharsets.UTF_8);
			byte[] refreshKey = refreshToAccessKeyStr.getBytes(StandardCharsets.UTF_8);
			byte[] accessKey = accessKeyStr.getBytes(StandardCharsets.UTF_8);

			for (String existsAccessToken : existsAccessTokens) {
				connection.sAdd(uidKey, existsAccessToken.getBytes(StandardCharsets.UTF_8));
			}

			// 通过uid + sysType 保存access_token，当需要禁用用户的时候，可以根据uid + sysType 禁用用户
			connection.expire(uidKey, expiresIn);

			// 通过refresh_token获取用户的access_token从而刷新token
			connection.setEx(refreshKey, expiresIn, accessToken.getBytes(StandardCharsets.UTF_8));

			// 通过access_token保存用户的租户id，用户id，uid
			connection.setEx(accessKey, expiresIn, Objects.requireNonNull(redisSerializer.serialize(userInfoInToken)));

			return null;
		});

		// 返回给前端是加密的token
		tokenInfoBO.setAccessToken(encryptToken(accessToken,userInfoInToken.getSysType()));
		tokenInfoBO.setRefreshToken(encryptToken(refreshToken,userInfoInToken.getSysType()));

		return tokenInfoBO;
	}

对上面的token存储代码解释：

1、创建TokenInfoBO对象：首先，方法创建了一个TokenInfoBO对象，这个对象用于存储令牌相关的信息。
2、生成Access Token和Refresh Token：使用IdUtil.simpleUUID()生成了一个随机的Access Token和Refresh Token。
3、设置Token信息：将userInfoInToken对象设置到tokenInfoBO中，并设置了令牌的过期时间（expiresIn），该过期时间是根据userInfoInToken的sysType来确定的。
4、获取相关Key：获取了与令牌相关的一些键值（Key），如uidToAccessKeyStr，accessKeyStr，和refreshToAccessKeyStr。
处理已存在的令牌：通过查询Redis中的数据，检查是否已经存在相同用户的令牌。如果存在，将新生成的Access Token和Refresh Token添加到已存在令牌的列表中。
5、使用Redis Pipelining保存数据：使用Redis的Pipelining机制来一次性执行多个Redis命令，将令牌和相关信息存储到Redis中。这些命令包括将Access Token和Refresh Token与用户关联，设置它们的过期时间，并存储用户的信息。
6、加密令牌：使用encryptToken方法对Access Token和Refresh Token进行加密，然后将加密后的令牌设置到tokenInfoBO中。
返回Token信息：最后，返回包含Access Token和Refresh Token信息的tokenInfoBO对象，供前端使用。

后续的token解密防止攻击、token刷新代码通过代码注释可以看到相关逻辑，就不做一 一解释。

过滤器校验

前端获取到token后，会在访问接口中携带这个信息，之后后端服务通过过滤器来校验，看访问的接口是否能通过认证。主要代码在这个包下。
在这里插入图片描述

@Component
public class AuthFilter implements Filter {

	private static Logger logger = LoggerFactory.getLogger(AuthFilter.class);

	@Autowired
	private AuthConfigAdapter authConfigAdapter;

	@Autowired
	private HttpHandler httpHandler;

	@Autowired
	private TokenFeignClient tokenFeignClient;

	@Autowired
	private PermissionFeignClient permissionFeignClient;

	@Autowired
	private FeignInsideAuthConfig feignInsideAuthConfig;

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		HttpServletRequest req = (HttpServletRequest) request;
		HttpServletResponse resp = (HttpServletResponse) response;

		if (!feignRequestCheck(req)) {
			httpHandler.printServerResponseToWeb(ServerResponseEntity.fail(ResponseEnum.UNAUTHORIZED));
			return;
		}

		if (Auth.CHECK_TOKEN_URI.equals(req.getRequestURI())) {
			chain.doFilter(req, resp);
			return;
		}


		List<String> excludePathPatterns = authConfigAdapter.excludePathPatterns();

		// 如果匹配不需要授权的路径，就不需要校验是否需要授权
		if (CollectionUtil.isNotEmpty(excludePathPatterns)) {
			for (String excludePathPattern : excludePathPatterns) {
				AntPathMatcher pathMatcher = new AntPathMatcher();
				if (pathMatcher.match(excludePathPattern, req.getRequestURI())) {
					chain.doFilter(req, resp);
					return;
				}
			}
		}

		String accessToken = req.getHeader("Authorization");

		if (StrUtil.isBlank(accessToken)) {
			httpHandler.printServerResponseToWeb(ServerResponseEntity.fail(ResponseEnum.UNAUTHORIZED));
			return;
		}

		// 校验token，并返回用户信息
		ServerResponseEntity<UserInfoInTokenBO> userInfoInTokenVoServerResponseEntity = tokenFeignClient
				.checkToken(accessToken);
		if (!userInfoInTokenVoServerResponseEntity.isSuccess()) {
			httpHandler.printServerResponseToWeb(ServerResponseEntity.fail(ResponseEnum.UNAUTHORIZED));
			return;
		}

		UserInfoInTokenBO userInfoInToken = userInfoInTokenVoServerResponseEntity.getData();

		// 需要用户角色权限，就去根据用户角色权限判断是否
		if (!checkRbac(userInfoInToken,req.getRequestURI(), req.getMethod())) {
			httpHandler.printServerResponseToWeb(ServerResponseEntity.fail(ResponseEnum.UNAUTHORIZED));
			return;
		}

		try {
			// 保存上下文
			AuthUserContext.set(userInfoInToken);

			chain.doFilter(req, resp);
		}
		finally {
			AuthUserContext.clean();
		}

	}

	private boolean feignRequestCheck(HttpServletRequest req) {
		// 不是feign请求，不用校验
		if (!req.getRequestURI().startsWith(FeignInsideAuthConfig.FEIGN_INSIDE_URL_PREFIX)) {
			return true;
		}
		String feignInsideSecret = req.getHeader(feignInsideAuthConfig.getKey());

		// 校验feign 请求携带的key 和 value是否正确
		if (StrUtil.isBlank(feignInsideSecret) || !Objects.equals(feignInsideSecret,feignInsideAuthConfig.getSecret())) {
			return false;
		}
		// ip白名单
		List<String> ips = feignInsideAuthConfig.getIps();
		// 移除无用的空ip
		ips.removeIf(StrUtil::isBlank);
		// 有ip白名单，且ip不在白名单内，校验失败
		if (CollectionUtil.isNotEmpty(ips)
				&& !ips.contains(IpHelper.getIpAddr())) {
			logger.error("ip not in ip White list: {}, ip, {}", ips, IpHelper.getIpAddr());
			return false;
		}
		return true;
	}

	/**
	 * 用户角色权限校验
	 * @param uri uri
	 * @return 是否校验成功
	 */
	public boolean checkRbac(UserInfoInTokenBO userInfoInToken, String uri, String method) {

		if (!Objects.equals(SysTypeEnum.PLATFORM.value(), userInfoInToken.getSysType()) && !Objects.equals(SysTypeEnum.MULTISHOP.value(), userInfoInToken.getSysType())) {
			return true;
		}

		ServerResponseEntity<Boolean> booleanServerResponseEntity = permissionFeignClient
				.checkPermission(userInfoInToken.getUserId(), userInfoInToken.getSysType(),uri,userInfoInToken.getIsAdmin(),HttpMethodEnum.valueOf(method.toUpperCase()).value() );

		if (!booleanServerResponseEntity.isSuccess()) {
			return false;
		}

		return booleanServerResponseEntity.getData();
	}

}

下面详细说明过滤逻辑
在这里插入图片描述
①：

这段代码中的 doFilter 方法是实现了 Filter 接口的一个方法，用于处理 HTTP 请求的过滤逻辑。它是一个回调方法，当有请求到达时，容器会调用这个方法来执行一些预处理和后处理的操作。
方法的参数包括：
request: 表示 HTTP 请求对象，通常是 ServletRequest 类型，可以用于获取请求的信息和数据。
response: 表示 HTTP 响应对象，通常是 ServletResponse 类型，用于生成和发送响应数据。
chain: 表示过滤器链（FilterChain），可以用于继续处理请求或将请求传递给下一个过滤器。

③：内部请求校验

private boolean feignRequestCheck(HttpServletRequest req) {
		// 不是feign请求，返回true
		if (!req.getRequestURI().startsWith(FeignInsideAuthConfig.FEIGN_INSIDE_URL_PREFIX)) {
			return true;
		}
		//获取fegin的value密钥，这个在nacos中已配置
		String feignInsideSecret = req.getHeader(feignInsideAuthConfig.getKey());

		// 校验feign 请求携带的key 和 value是否正确，不正确返回false
		if (StrUtil.isBlank(feignInsideSecret) || !Objects.equals(feignInsideSecret,feignInsideAuthConfig.getSecret())) {
			return false;
		}
		// ip白名单
		List<String> ips = feignInsideAuthConfig.getIps();
		// 移除无用的空ip
		ips.removeIf(StrUtil::isBlank);
		// 有ip白名单，且ip不在白名单内，校验失败。不为空或者获取当前用户真实ip不在白名单中，返回false
		if (CollectionUtil.isNotEmpty(ips)
				&& !ips.contains(IpHelper.getIpAddr())) {
			logger.error("ip not in ip White list: {}, ip, {}", ips, IpHelper.getIpAddr());
			return false;
		}
		return true;
	}

上面如果返回了false，是fegin请求但是不通过就走判断中的代码，意思是发送的相应为“未授权”。fegin请求校验不通过是认为失败的

if (!feignRequestCheck(req)) {
			httpHandler.printServerResponseToWeb(ServerResponseEntity.fail(ResponseEnum.UNAUTHORIZED));
			return;
		}

④：如果为token校验请求，这个过滤器就不管了，发到下一个过滤器中，这也是chain.doFilter(request, response)的作用。但是可以看到，目前系统过滤器链上只有一个过滤器。在AuthConfig中。
在这里插入图片描述

@ConditionalOnMissingBean 是一个常用于 Spring 框架应用中，特别是在 Spring Boot 中的注解，用于根据应用上下文中是否已存在相同类型的其他 Bean，有条件地配置一个 Bean。这个注解是 Spring 的基于注解的配置的一部分，用于控制 Bean 的实例化

⑤：目前这个list有下面的url需排除，然后这个是通过bean的注入实现的
还是这个config代码,第一个bean，下面的截图说明了哪些需要排除，

@Configuration
public class AuthConfig {

	@Bean
	@ConditionalOnMissingBean
	public AuthConfigAdapter authConfigAdapter() {
		return new DefaultAuthConfigAdapter();
	}

	@Bean
	@Lazy
	public FilterRegistrationBean<AuthFilter> filterRegistration(AuthConfigAdapter authConfigAdapter, AuthFilter authFilter) {
		FilterRegistrationBean<AuthFilter> registration = new FilterRegistrationBean<>();
		// 添加过滤器
		registration.setFilter(authFilter);
		// 设置过滤路径，/*所有路径
		registration.addUrlPatterns(ArrayUtil.toArray(authConfigAdapter.pathPatterns(), String.class));
		registration.setName("authFilter");
		// 设置优先级
		registration.setOrder(0);
		registration.setDispatcherTypes(DispatcherType.REQUEST);
		return registration;
	}

}

在这里插入图片描述
在这里插入图片描述
⑥之后循环这个list，做了一个正则的匹配。来排除不需要经过这个auth过滤器的url。
⑦⑧：这里终于到了正式的请求了，看他是否携带了Authorization这个内容，为空则直接返回未授权。
接下来的代码如下
在这里插入图片描述
①检查接口代码如下，是调用了OpenFegin接口，这里顺便看一下项目对fegin的实践方式。
首先是在mall4cloud-api包下建立了某个模块要提供的api接口，在fegin包下，选择其中一个接口查看

可以看到通过@FeignClient(value = “mall4cloud-auth”,contextId =“token”)注解修饰：value指定了服务的名称，contextId指定了这个接口的唯一标识。@GetMapping(value = Auth.CHECK_TOKEN_URI)指定了访问的uri
在这里插入图片描述

之后是对接口的实现

实现都是在各个模块的fegin包下，且实现是通过@RestController注解实现。这样的作法类似于@DubboService注解修饰api实现类。
在这里插入图片描述
‘’‘’‘’‘
在这里插入图片描述
而通常的feign接口是直接通过http请求调用的，当调用 checkToken() 方法时，实际上调用的是 Feign 生成的代理对象的方法。
代理对象会根据方法的定义和注解（例如 @GetMapping(value = Auth.CHECK_TOKEN_URI)）生成一个 HTTP 请求，并将请求发送到远程服务的相应路径。
远程服务响应后，代理对象会将响应解析为ServerResponseEntity< UserInfoInTokenBO > 类型，并将其返回。
但是mall4cloud-auth这个模块代码中没有“/feign/token/checkToken”这个请求uri和对应的controller
同时，“/feign/token/checkToken”这个请求也是被拦截器放行的，这个在上面已说明。

②③权限校验
这里分为了商家端、平台端、用户端，之后检查是否有某个uri的权限，主要代码如下，这个权限校验属于rbac模块，下一章节再详细介绍
在这里插入图片描述
如果校验失败，就返回未授权状态码
在这里插入图片描述
④：使用ThreadLocal保存用户信息。可以做到线程间隔离作用，以及在整个线程中传递上下文信息。

线程安全的数据隔离：ThreadLocal 可以用于在多线程环境中隔离数据，确保每个线程都有自己独立的数据副本，从而避免多个线程之间的数据共享和竞态条件。这对于一些上下文相关的数据非常有用，例如用户登录信息、会话信息等。
传递上下文信息：有些情况下，您可能需要在整个线程上下文中传递某些信息，而不必在每个方法调用中显式传递这些信息作为参数。ThreadLocal 可以用于存储和访问这些上下文信息。

之后进入下一个过滤器（可以扩展），用户信息用完以后释放即可。

总结

auth模块的代码逻辑主要流程是登录接口/ua/login->tokenStore下的storeAccessToken（）方法,令牌存储完成后，就是过滤器AuthFilter类的实现。其中的doFilter（）方法进行了访问路径（请求）授权，用户角色授权（这里主要调用了rbac模块的服务）。

这个auth模块的代码并不是主流的用户认证授权功能。更像一个单体架构的服务。下面介绍一下有疑问的地方。

  1. 首先是token的生成，这里直接使用uuid方式。这样做具有了可预测性以及只当作随机字符串不能存储任何信息。当然，这里使用了分布式redis缓存了用户信息，也是合理的。

上面的方式可以增加登录时获取随机码，然后再通过随机码加密的方式生成token
为了让token存储用户信息，或者增加用户的权限，可以使用jwt方式。这也是一种用于分布式

  1. 授权时使用的过滤器是servlet下的Filter，这个大多数的逻辑操作需要手动编写和指定，并没有使用一些流行的权限认证框架，比如SpringSecrity或者shiro等。这作为学习项目可以学习其中的授权认证逻辑，但是作为企业级项目，认证授权并不够精细化。但是总的逻辑一致。

比如过滤器中的一些放行接口，不是基于配置，而是在代码中写死的。或者对于接口的访问，如果是未授权，正常应该是跳转到指定登录页面提示，不是直接返回未授权。这些通过SpringSecrity框架可能做的更精细一些。

后续补充一个使用SpringSecrity或者shiro框架项目做用户认证授权的文章。

卡卡东~
关注
专栏目录
【SpringCloud微服务项目实战-mall4cloud项目(2)】——mall4cloud-gateway
qq_1763467007的博客
09-12 1540
从图中可以看到，在用户端和静态层通过接入层（nginx+防火墙）后就会到达后端服务中，首先要通过的便是网关层，网关层由springCloud gateway2+负载均衡去实现。微服务架构中的网关层充当了微服务体系结构的门卫，负责处理请求、管理安全性、实施过滤和转换、执行路由和负载均衡等任务。通过集中管理这些功能，网关可以简化微服务的客户端访问，并提供一些关键的非业务功能，以确保整个系统的高可用性、性能和安全性。请求路由：网关充当了所有进入微服务系统的请求的入口点。
微服务认证系列一：SpringCloud OAuth2
最新发布
wanping15825992341的博客
08-12 602
OAuth(开放授权)是一个开放协议/标准，允许用户授权第三方应用访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方应用或分享他们数据的所有内容。OAuth2.0是OAuth协议的延续版本，但不向后兼容OAuth 1.0即完全废止了OAuth1.0Spring Cloud OAuth2 是 Spring Cloud 体系对OAuth2协议的实现，可以用来做多个微服务的统一认证(验证身份合法性)授权(验证权限)。
【SpringCloud微服务项目学习-mall4cloud项目(1)】——环境部署，构建与运行
qq_1763467007的博客
09-11 2843
mall4cloud是mall4j的微服务架构。具有微服务架构，分布式部署，静态化分离，高性能高并发，支持负载均衡，支持多端开发特点 商城是基于**Spring Cloud、Nacos、Seata、Mysql、Redis、RocketMQ、canal、ElasticSearch、minio的微服务B2B2C电商商城系统**，采用主流的互联网技术架构、全新的UI设计、支持集群部署、服务注册和发现以及拥有完整的订单流程等，代码完全开源，没有任何二次封装，是一个非常适合二次开发的电商平台系统。 B2B2C
【SpringCloud微服务项目实战-mall4cloud项目(5)】——mall4cloud-leaf
qq_1763467007的博客
10-24 495
分布式ID（Distributed ID）是在分布式计算环境中生成的唯一标识符或标识号。在分布式系统中，通常需要唯一标识不同的实体或数据，以确保数据的一致性、唯一性和跟踪性。分布式ID的生成可以避免多个节点或服务生成相同的标识符，从而避免数据冲突和不一致性。分布式ID的好处包括：唯一性：分布式ID是全局唯一的，无论在系统中的哪个节点生成，都不会与其他节点的ID冲突。数据一致性：分布式ID可用于唯一标识数据库中的记录，确保不同节点的数据操作不会导致冲突或数据不一致性。
win10 docker 部署 mall4cloud 重点解决部署seata时的坑
qq_31683775的博客
09-05 1506
win10 docker 部署 mall4cloud 重点解决部署seata时的坑
spring-cloud-framework:spring cloud 微服务架构集成
05-16
SpringCloud 微服务学习使用与实践，结合相关业务进行验证等。 使用nacos作为服务注册中心， 模块版本 名称 版本 spring-boot 2.3.7.RELEASE spring-cloud Hoxton.SR9 spring-cloud-alibaba 2.2.3.RELEASE lombok ...
Mall微服务版本全面升级，支持最新版SpringCloud
SharingOfficer的博客
07-27 519
今天分享了一下mall-swarm项目的升级内容和升级过程中遇到的一些问题，基本能平滑过渡。自从改用日期作为版本号后，总感觉SpringCloud的版本号看着有点迷糊，而且目前最新稳定版是2021，2022版本估计还在路上。...
这个 SpringCloud 微服务商城值得推荐
superjava_的博客
01-06 1336
一个基于Spring Cloud、Nacos、Seata、Mysql、Redis、RocketMQ、canal、ElasticSearch、minio的微服务B2B2C电商商城系统，采用主流的互联网技术架构、全新的UI设计、支持集群部署、服务注册和发现以及拥有完整的订单流程等，代码完全开源，没有任何二次封装，是一个非常适合二次开发的电商平台系统。 前言 本商城致力于为中大型企业打造一个功能完整、易于维护的微服务B2B2C电商商城系统，采用主流微服务技术实现。后台管理系统包含平台管理，店铺管理...
OM（OPEN-MALL）电商平台源代码
10-20
OM（OPEN-MALL）电商平台是一个分布式的开源电商平台，包括前台商城平台及后台管理系统，前台商城系统包含首页门户、商品...SpringCloud：Hoxton.SR9 Mybatis-Plus：3.x 前端技术 Bootstrap：v3.3.7 Vue：v3.0 Uni-App
一个springcloud微服务商城系统的诞生
mall4j的博客
08-03 869
起因 有一天，苹果和西瓜说：“哎，市面咋没有好用的微服务商城呢？” 西瓜：“太难了呗，你看这个好像是微服务商城耶” 苹果：“这个只有后台代码，数据库都没” 西瓜：“这个呢” 苹果：“有数据库没前端” 西瓜：“这个呢” 苹果：“有前端，但是是pc的，我要移动端的” 西瓜：“这个呢” 苹果：“开不了店，不是b2b2c” 西瓜：“这个呢” 苹果：“太旧了，不维护了” 西瓜：“那我们自己写个吧“ 准备 一个微服务商城应该有啥呢？ 答：要拆分服务吧。 拆分之后用啥做服务注册发现呢？ 答：spring cloud al
Mall4j商城系统 v1.0
04-22
Mall4j是一个基于spring boot、spring oauth2.0、mybatis、redis的轻量级、前后端分离、防范xss攻击、拥有分布式锁、为生产环境多实例完全准备、数据库为b2b2c设计、拥有完整sku和下单流程的java开源商城。Mall4j致力于为中小企业打造一个完整、易于维护的开源的电商系统，采用现阶段流行技术实现。后台管理系统包含商品管理、订单管理、运费模板、规格管理、会员管理、运营管理、内容管理、统计报表、权限管理、设置等模块。演示账号密码：admin/123456Mall4j截图
Mall4cloud微服务商城系统
03-24
Mall4cloud微服务商城系统、一个基于Spring Cloud、Nacos、Seata、Mysql、Redis、RocketMQ、canal、ElasticSearch、minio的微服务B2B2C电商商城系统。
史上最全 SpringCloudAlibaba入门教程，从零开始带你深入♂学习（五）——nacos的mysql持久化
爱分享的板栗老哥
08-03 346
SpringCloudAlibaba（五）——nacos的mysql持久化 nacos 持久化 持久化：管理的配置信息持久化 注意：默认nacos存在的配置信息持久化，默认的持久化方式为内嵌数据库derby 缺点：无法展示数据 官方建议：在生产情况下推荐将配置存入mysql数据库 注意：nacos到目前为止仅仅支持mysql mysql安装 1、输入vi /etc/yum.repos.d/mysql-community.repo添加官方的yum源创建并编辑mysql-community.repo文件 vi
开源mall项目的学习问题(五)Sentinel
WAITSHESHOU的博客
09-29 345
开源mall项目学习记录
自学实践前后端项目4 MMall商城 4
weixin_40518706的博客
11-28 336
一。实现商品详情展示 1.测试获取后台当个商品的信息 2.实现通过点击商品名称和商品图片进入商品详情页面 1）查找出商品信息 2）在前端进行映射 3）设置库存选择限制 判断逻辑 $(function(){ //给type绑定点击事件 $(".type").click(function () { var index = $(".type").index(this); var obj...
mall商城系统配置文件解析
程序员
03-31 339
===================用到的所有框架======================= spring-cloud-starter-alibaba-nacos-discovery 服务注册与发现 spring-cloud-starter-alibaba-nacos-config 配置管理 spring-cloud-starter-bootstrap nacos-config依赖此包 spring-cloud-starter-alibaba-sentinel.
Mall4j商城实战 - 部署指南 (一篇文章带你玩转各种技术)
yueerba126的博客
11-22 2300
mall4jcloud 是一个很简单的分布式电商系统，虽然有些bug，但是总体的电商结构还算清晰，适合用于学习使用，商业版的肯定要找他们公司了。部署的最低要求应该是16G的电脑，肯定巨卡的，笔者是24G的电脑部署的。
nacos配置中心的使用（精通）
热门推荐
m0_72673485的博客
01-10 1万+
nacos配置中心和集群
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值