abu/vlog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

打通短视频系统账户和商城账户关联

Browse Source
This commit is contained in:
liliang 2025-03-11 10:39:45 +08:00
parent f207488645
commit dea2a88574
20 changed files with 1375 additions and 350 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
book-api/src/main/java/com/imooc/config/InterceptorConfig.java
View File

@ -2,31 +2,115 @@ package com.imooc.config;
import com.imooc.intercepter.PassportInterceptor;
import com.imooc.intercepter.UserTokenInterceptor;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import javax.net.ssl.SSLContext;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.ssl.SSLContexts;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpMethod;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
@Bean
public PassportInterceptor passportInterceptor() {
return new PassportInterceptor();
}
private String[] CORS_HTTP_METHODS = { HttpMethod.HEAD.name(), HttpMethod.GET.name(), HttpMethod.POST.name(),
HttpMethod.PUT.name(), HttpMethod.DELETE.name(), HttpMethod.OPTIONS.name(), HttpMethod.PATCH.name() };
@Bean
public UserTokenInterceptor userTokenInterceptor() {
return new UserTokenInterceptor();
}
private static final long CORS_MAX_AGE = 30 * 24 * 60 * 60;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(passportInterceptor())
.addPathPatterns("/passport/getSMSCode");
@Bean
public PassportInterceptor passportInterceptor() {
return new PassportInterceptor();
}
registry.addInterceptor(userTokenInterceptor())
.addPathPatterns("/userInfo/modifyUserInfo")
.addPathPatterns("/userInfo/modifyImage");
}
@Bean
public UserTokenInterceptor userTokenInterceptor() {
return new UserTokenInterceptor();
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(passportInterceptor()).addPathPatterns("/passport/getSMSCode");
registry.addInterceptor(userTokenInterceptor()).addPathPatterns("/userInfo/modifyUserInfo")
.addPathPatterns("/userInfo/modifyImage");
}
@Order(Ordered.HIGHEST_PRECEDENCE)
@Bean
public CorsFilter corsFilter() {
// 添加跨域配置信息
CorsConfiguration config = new CorsConfiguration();
// 设置访问源地址
config.addAllowedOriginPattern("*");
// 设置访问源请求头
config.addAllowedHeader("*");
// 设置是否发送Cookie信息
config.setAllowCredentials(true);
// 设置访问源请求方法
Arrays.stream(CORS_HTTP_METHODS).forEach(method -> config.addAllowedMethod(method));
// 设置请求最大有效时长
config.setMaxAge(CORS_MAX_AGE);
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
// 配置跨域
source.registerCorsConfiguration("/**", config);
return new CorsFilter(source);
}
@Primary
@Bean
public RestTemplate restTemplate() {
PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager();
// 连接池最大连接数
connManager.setMaxTotal(1000);
// 每个主机的并发
connManager.setDefaultMaxPerRoute(500);
CloseableHttpClient httpClient = HttpClients.custom()//
.setConnectionManager(connManager)// 设置HTTP连接管理器
.build();
return buildRestTemplate(httpClient);
}
@Bean
public RestTemplate restTemplateIgnoreSSL()
throws KeyManagementException, NoSuchAlgorithmException, KeyStoreException {
SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, (chain, authType) -> true).build();
SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContext,
NoopHostnameVerifier.INSTANCE);
CloseableHttpClient httpClient = HttpClients.custom()//
.setSSLSocketFactory(sslSocketFactory)//
.build();
return buildRestTemplate(httpClient);
}
private RestTemplate buildRestTemplate(CloseableHttpClient httpClient) {
HttpComponentsClientHttpRequestFactory httpRequestFactory = new HttpComponentsClientHttpRequestFactory(
httpClient);
// 获取链接超时时间
httpRequestFactory.setConnectionRequestTimeout(3000);
// 指客户端和服务器建立连接的timeout
httpRequestFactory.setConnectTimeout(3000);
// 读取数据的超时时间
httpRequestFactory.setReadTimeout(120000);
return new RestTemplate(httpRequestFactory);
}
}

30
book-api/src/main/java/com/imooc/config/SpringSecurityConfig.java Normal file
View File

@ -0,0 +1,30 @@
package com.imooc.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
/**
* spring security配置类.
*
* @author lzc
* @version 1.0
*/
@Configuration
public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests().antMatchers("/**").permitAll() // 所有请求都可以访问
.and().csrf().disable() // 跨域请求关闭
.headers().frameOptions().disable(); // 资源下载权限关闭
}
@Bean
PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}

191
book-api/src/main/java/com/imooc/controller/PassportController.java
View File

@ -5,20 +5,26 @@ import com.imooc.bo.RegistLoginBO;
import com.imooc.bo.LoginWithPasswordBO;
import com.imooc.grace.result.GraceJSONResult;
import com.imooc.grace.result.ResponseStatusEnum;
import com.imooc.mo.Token;
import com.imooc.pojo.Users;
import com.imooc.service.UserService;
import com.imooc.utils.IPUtil;
import com.imooc.utils.SMSUtils;
import com.imooc.vo.UsersVO;
import com.imooc.utils.CommonUtil;
import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.util.Map;
import java.util.UUID;
/**
@ -31,91 +37,144 @@ import java.util.UUID;
@RequestMapping("passport")
@Api(tags = "通行证，验证码登录注册")
public class PassportController extends BaseInfoProperties {
@Autowired
SMSUtils smsUtils;
@Autowired
UserService userService;
@PostMapping("getSMSCode")
public Object getSMSCode(@RequestParam String mobile, HttpServletRequest request) throws Exception {
if (StringUtils.isBlank(mobile)){
return GraceJSONResult.ok();
}
@Autowired
private SMSUtils smsUtils;
//TODO 获得用户ip 限制时间60s只能1次
String userIp=IPUtil.getRequestIp(request);
@Autowired
private UserService userService;
@Autowired
private PasswordEncoder passwordEncoder;
redis.setnx60s(MOBILE_SMSCODE+":"+userIp, userIp);
String code=(int)((Math.random()*9+1)*100000)+"";
@PostMapping("getSMSCode")
public Object getSMSCode(@RequestParam String mobile, HttpServletRequest request) throws Exception {
if (StringUtils.isBlank(mobile)) {
return GraceJSONResult.ok();
}
smsUtils.sendSMS(mobile,code);
// TODO 获得用户ip 限制时间60s只能1次
String userIp = IPUtil.getRequestIp(request);
log.info(code);
redis.set(MOBILE_SMSCODE+":"+mobile, code,30*60);
//TODO 验证码放入redis
return GraceJSONResult.ok();
}
redis.setnx60s(MOBILE_SMSCODE + ":" + userIp, userIp);
String code = (int) ((Math.random() * 9 + 1) * 100000) + "";
@PostMapping("login")
public Object login(@Valid @RequestBody RegistLoginBO registLoginBO){
smsUtils.sendSMS(mobile, code);
String rediscode = redis.get(MOBILE_SMSCODE + ":" + registLoginBO.getMobile());
log.info(code);
redis.set(MOBILE_SMSCODE + ":" + mobile, code, 30 * 60);
// TODO 验证码放入redis
return GraceJSONResult.ok();
}
if (StringUtils.isBlank(rediscode)|| !rediscode.equalsIgnoreCase(registLoginBO.getSmsCode())){
System.out.println("rediscode"+rediscode);
System.out.println("registLoginBO.getMobile()"+registLoginBO.getSmsCode());
return GraceJSONResult.errorCustom(ResponseStatusEnum.SMS_CODE_ERROR);
}
/*@PostMapping("login")
public Object login(@Valid @RequestBody RegistLoginBO registLoginBO){
String rediscode = redis.get(MOBILE_SMSCODE + ":" + registLoginBO.getMobile());
if (StringUtils.isBlank(rediscode)|| !rediscode.equalsIgnoreCase(registLoginBO.getSmsCode())){
System.out.println("rediscode"+rediscode);
System.out.println("registLoginBO.getMobile()"+registLoginBO.getSmsCode());
return GraceJSONResult.errorCustom(ResponseStatusEnum.SMS_CODE_ERROR);
}
Users user = userService.queryMobileIsExist(registLoginBO.getMobile());
if (user==null){
user = userService.createUser(registLoginBO.getMobile());
}
String uToken = UUID.randomUUID().toString();
log.info(uToken);
redis.set(REDIS_USER_TOKEN+":"+user.getId(),uToken);
//清除验证码
redis.del(MOBILE_SMSCODE+":"+user.getMobile());
//返回给前端
UsersVO usersVO = new UsersVO();
BeanUtils.copyProperties(user, usersVO);
usersVO.setUserToken(uToken);
return GraceJSONResult.ok(usersVO);
}*/
Users user = userService.queryMobileIsExist(registLoginBO.getMobile());
if (user==null){
user = userService.createUser(registLoginBO.getMobile());
}
String uToken = UUID.randomUUID().toString();
log.info(uToken);
redis.set(REDIS_USER_TOKEN+":"+user.getId(),uToken);
@PostMapping("login")
public Object login(@Valid @RequestBody RegistLoginBO registLoginBO) {
//清除验证码
redis.del(MOBILE_SMSCODE+":"+user.getMobile());
/*String rediscode = redis.get(MOBILE_SMSCODE + ":" + registLoginBO.getMobile());
if (StringUtils.isBlank(rediscode) || !rediscode.equalsIgnoreCase(registLoginBO.getSmsCode())) {
System.out.println("rediscode" + rediscode);
System.out.println("registLoginBO.getMobile()" + registLoginBO.getSmsCode());
return GraceJSONResult.errorCustom(ResponseStatusEnum.SMS_CODE_ERROR);
}*/
//返回给前端
UsersVO usersVO = new UsersVO();
BeanUtils.copyProperties(user, usersVO);
usersVO.setUserToken(uToken);
// 手机号
String mobile = registLoginBO.getMobile();
Users user = userService.queryMobileIsExist(mobile);
Token shopToken = null;
if (user == null) {
Map<String, Object> result = userService.createUserNew(mobile);
if (CommonUtil.isEmpty(result)) {
return GraceJSONResult.errorCustom(ResponseStatusEnum.FAILED);
}
user = (Users) result.get("user");
shopToken = (Token) result.get("token");
} else {
shopToken = userService.getShopToken(user.getId());
}
return GraceJSONResult.ok(usersVO);
String uToken = UUID.randomUUID().toString();
log.info(uToken);
redis.set(REDIS_USER_TOKEN + ":" + user.getId(), uToken);
}
// 清除验证码
redis.del(MOBILE_SMSCODE + ":" + user.getMobile());
@PostMapping("loginWithPassword")
public Object loginWithPassword(@Valid @RequestBody LoginWithPasswordBO loginWithPasswordBO){
String phone = loginWithPasswordBO.getMobile();
String password = loginWithPasswordBO.getPassword();
log.info(phone);
log.info(password);
Users user = userService.queryMobileIsExist(loginWithPasswordBO.getMobile());
if (user==null){
return GraceJSONResult.errorCustom(ResponseStatusEnum.USER_NOT_EXIST_ERROR);
}
String uToken = UUID.randomUUID().toString();
log.info(uToken);
redis.set(REDIS_USER_TOKEN+":"+user.getId(),uToken);
// 返回给前端
UsersVO usersVO = new UsersVO();
BeanUtils.copyProperties(user, usersVO);
usersVO.setUserToken(uToken);
usersVO.setShopToken(shopToken);
//返回给前端
UsersVO usersVO = new UsersVO();
BeanUtils.copyProperties(user, usersVO);
usersVO.setUserToken(uToken);
return GraceJSONResult.ok(usersVO);
}
return GraceJSONResult.ok(usersVO);
@PostMapping("loginWithPassword")
public Object loginWithPassword(@Valid @RequestBody LoginWithPasswordBO loginWithPasswordBO) {
String phone = loginWithPasswordBO.getMobile();
String password = loginWithPasswordBO.getPassword();
log.info(phone);
log.info(password);
Users user = userService.queryMobileIsExist(phone);
if (user == null) {
return GraceJSONResult.errorCustom(ResponseStatusEnum.USER_NOT_EXIST_ERROR);
}
if (!passwordEncoder.matches(password, user.getPassword())) {
return GraceJSONResult.errorCustom(ResponseStatusEnum.USER_PASSWORD_ERROR);
}
String uToken = UUID.randomUUID().toString();
log.info(uToken);
redis.set(REDIS_USER_TOKEN + ":" + user.getId(), uToken);
//商城token
Token shopToken = userService.getShopToken(user.getId());
// 返回给前端
UsersVO usersVO = new UsersVO();
BeanUtils.copyProperties(user, usersVO);
usersVO.setUserToken(uToken);
usersVO.setShopToken(shopToken);
}
return GraceJSONResult.ok(usersVO);
}
@PostMapping("logout")
public Object logout(@RequestParam String userId){
@PostMapping("logout")
public Object logout(@RequestParam String userId) {
redis.del(REDIS_USER_TOKEN+":"+userId);
redis.del(REDIS_USER_TOKEN + ":" + userId);
return GraceJSONResult.ok();
}
return GraceJSONResult.ok();
}
}

12
book-api/src/main/resources/application-dev.yml
View File

@ -5,9 +5,9 @@ spring:
datasource: # 数据源的相关配置
type: com.zaxxer.hikari.HikariDataSource # 数据源的类型，可以更改为其他的数据源配置，比如druid
driver-class-name: com.mysql.cj.jdbc.Driver # mysql/MariaDB 的数据库驱动类名称
url: jdbc:mysql://182.92.182.217:3306/tiktok?characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
username: tiktok
password: Bc3T5AA2pBdt2FBk
url: jdbc:mysql://82.156.121.2:23306/shop_dev?characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
username: wzj
password: A085F27A43B0
hikari:
connection-timeout: 30000 # 等待连接池分配连接的最大时间（毫秒），超过这个时长还没有可用的连接，则会抛出SQLException
minimum-idle: 5 # 最小连接数
@ -18,9 +18,9 @@ spring:
max-lifetime: 18000000 # 连接池的最大生命时长（毫秒），超时则会被释放（retired）
connection-test-query: SELECT 1
redis:
host: 182.92.182.217
port: 6379
password: '!aw5)lJf'
host: 82.156.121.2
port: 26379
password: e4ea0caebfd2
database: 1 # 使用的数据库编号
jedis:
pool:

20
book-common/pom.xml
View File

@ -35,6 +35,10 @@
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- 引入 redis 依赖 -->
<dependency>
@ -109,7 +113,21 @@
<!-- <version>2.0.23</version>-->
<!--</dependency>-->
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>4.4.0</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpmime</artifactId>
</dependency>
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.4</version>
<classifier>jdk15</classifier>
</dependency>
</dependencies>

1
book-common/src/main/java/com/imooc/grace/result/ResponseStatusEnum.java
View File

@ -32,6 +32,7 @@ public enum ResponseStatusEnum {
FILE_NOT_EXIST_ERROR(514,false,"你所查看的文件不存在！"),
USER_STATUS_ERROR(515,false,"用户状态参数出错！"),
USER_NOT_EXIST_ERROR(516,false,"用户不存在！"),
USER_PASSWORD_ERROR(517,false,"密码错误!"),
// 自定义系统级别异常 54x
SYSTEM_INDEX_OUT_OF_BOUNDS(541, false, "系统错误，数组越界！"),

442
book-common/src/main/java/com/imooc/utils/CommonUtil.java Normal file
View File

@ -0,0 +1,442 @@
package com.imooc.utils;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.multipart.MultipartFile;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
/**
* 通用工具类
*
* @version 1.0.0
* @author Leon
*
*/
public final class CommonUtil {
private CommonUtil() {
}
/**
* 判断数组是否为空
*
* @param array
* @return
*/
public static <T> boolean isEmpty(T[] array) {
return array == null || (array != null && array.length == 0);
}
/**
* 判断集合是否为空
*
* @param collection
* @return
*/
public static <T> boolean isEmpty(Collection<T> collection) {
return collection == null || collection.isEmpty();
}
/**
* 判断映射是否为空
*
* @param map
* @return
*/
public static <K, V> boolean isEmpty(Map<K, V> map) {
return map == null || map.isEmpty();
}
/**
* 判断文件是否为空
*
* @param file
* @return
*/
public static boolean isEmpty(MultipartFile file) {
return file == null || file.isEmpty();
}
/**
* 判断引用类型是否为空
*
* @param <T>
* @param value
* @return
*/
public static <T> boolean isEmpty(T val) {
return Optional.ofNullable(val).map(t -> false).orElseGet(() -> true);
}
/**
* 获得线程安全的List
*
* @return
*/
public static <T> List<T> syncList(List<T> list) {
if (isEmpty(list)) {
return Collections.synchronizedList(Lists.newArrayList());
}
return Collections.synchronizedList(list);
}
/**
* 获得线程安全的Set
*
* @return
*/
public static <T> Set<T> syncSet(Set<T> set) {
if (isEmpty(set)) {
return Collections.synchronizedSet(Sets.newHashSet());
}
return Collections.synchronizedSet(set);
}
/**
* 获得线程安全的Map
*
* @return
*/
public static <K, V> Map<K, V> syncMap(Map<K, V> map) {
if (isEmpty(map)) {
return new ConcurrentHashMap<>();
}
return Collections.synchronizedMap(map);
}
/**
* 判断与目标值是否相等
*
* @param value
* @param target
* @return
*/
public static boolean isEquals(Short val, short target) {
return Optional.ofNullable(val).map(t -> t.shortValue() == target).orElseGet(() -> false);
}
/**
* 判断与目标值是否相等
*
* @param value
* @param target
* @return
*/
public static boolean isEquals(Integer val, int target) {
return Optional.ofNullable(val).map(t -> t.intValue() == target).orElseGet(() -> false);
}
/**
* 判断与目标值是否相等
*
* @param value
* @param target
* @return
*/
public static boolean isEquals(Long val, long target) {
return Optional.ofNullable(val).map(t -> t.longValue() == target).orElseGet(() -> false);
}
/**
* 判断与目标值是否相等
*
* @param value
* @param target
* @return
*/
public static boolean isEquals(Float val, float target) {
return Optional.ofNullable(val).map(t -> t.floatValue() == target).orElseGet(() -> false);
}
/**
* 判断与目标值是否相等
*
* @param value
* @param target
* @return
*/
public static boolean isEquals(Double val, double target) {
return Optional.ofNullable(val).map(t -> t.doubleValue() == target).orElseGet(() -> false);
}
/**
* 判断与目标值是否相等
*
* @param value
* @param target
* @return
*/
public static boolean isEquals(Boolean val, boolean target) {
return Optional.ofNullable(val).map(t -> t.booleanValue() == target).orElseGet(() -> false);
}
/**
* 获取map中的值,null值转换为空字符串
*
* @param map
* @param key
* @return
*/
public static String getValue(Map<String, Object> map, String key) {
if (isEmpty(map)) {
return StringUtils.EMPTY;
}
return Optional.ofNullable(map.get(key)).map(t -> StringUtils.trim(t.toString()))
.orElseGet(() -> StringUtils.EMPTY);
}
/**
* String转int类型
*
* @param val
* @return
*/
public static int getIntValue(String val) {
if (StringUtils.isNotBlank(val)) {
return Integer.parseInt(StringUtils.trim(val));
}
throw new NumberFormatException("String转int异常");
}
/**
* Integer类型转int类型
*
* @param val
* @return
*/
public static int getIntValue(Integer val) {
return Optional.ofNullable(val).map(t -> t.intValue())
.orElseThrow(() -> new NumberFormatException("Integer类型转int异常"));
}
/**
* String转double类型
*
* @param val
* @return
*/
public static double getDoubleValue(String val) {
if (StringUtils.isNotBlank(val)) {
return Double.parseDouble(StringUtils.trim(val));
}
throw new NumberFormatException("String转double异常");
}
/**
* Double类型转double类型
*
* @param val
* @return
*/
public static double getDoubleValue(Double val) {
return Optional.ofNullable(val).map(t -> t.doubleValue())
.orElseThrow(() -> new NumberFormatException("Double类型转double异常"));
}
/**
* String转float类型
*
* @param val
* @return
*/
public static float getFloatValue(String val) {
if (StringUtils.isNotBlank(val)) {
return Float.parseFloat(StringUtils.trim(val));
}
throw new NumberFormatException("String转float异常");
}
/**
* Float类型转float类型
*
* @param val
* @return
*/
public static float getFloatValue(Float val) {
return Optional.ofNullable(val).map(t -> t.floatValue())
.orElseThrow(() -> new NumberFormatException("Float类型转float异常"));
}
/**
* String转long类型
*
* @param val
* @return
*/
public static long getLongValue(String val) {
if (StringUtils.isNotBlank(val)) {
return Long.parseLong(StringUtils.trim(val));
}
throw new NumberFormatException("String转long异常");
}
/**
* Long类型转long类型
*
* @param val
* @return
*/
public static long getLongValue(Long val) {
return Optional.ofNullable(val).map(t -> t.longValue())
.orElseThrow(() -> new NumberFormatException("Long类型转long异常"));
}
/**
* String转byte数组
*
* @param val 字符串
* @param cs
* @return
*/
public static byte[] stringToBytes(String val, Charset charset) {
if (StringUtils.isBlank(val)) {
return new byte[0];
}
return Optional.ofNullable(charset).map(t -> val.getBytes(t)).orElseGet(() -> val.getBytes());
}
/**
* byte数组转String
*
* @param bytes
* @param cs
* @return
*/
public static String bytesToString(byte[] bytes, Charset charset) {
if (bytes == null) {
return null;
}
return Optional.ofNullable(charset).map(t -> new String(bytes, t)).orElseGet(() -> new String(bytes));
}
/**
* List转数组
*
* @param list
* @param t
* @return
*/
public static <T> T[] listToArray(List<T> list, T[] t) {
if (isEmpty(list)) {
return null;
}
return list.toArray(t);
}
/**
* Set转数组
*
* @param set
* @param t
* @return
*/
public static <T> T[] setToArray(Set<T> set, T[] t) {
if (isEmpty(set)) {
return null;
}
return set.toArray(t);
}
/**
* Set转List
*
* @param set
* @return
*/
public static <T> List<T> setToList(Set<T> set) {
if (isEmpty(set)) {
return Collections.emptyList();
}
return set.stream().collect(Collectors.toList());
}
/**
* 数组转List
*
* @param array
* @return
*/
public static <T> List<T> arrayToList(T[] array) {
if (isEmpty(array)) {
return Collections.emptyList();
}
return Arrays.stream(array).collect(Collectors.toList());
}
/**
* List转Set
*
* @param list
* @return
*/
public static <T> Set<T> listToSet(List<T> list) {
if (isEmpty(list)) {
return Collections.emptySet();
}
return list.stream().collect(Collectors.toSet());
}
/**
* 数组转Set
*
* @param array
* @return
*/
public static <T> Set<T> arrayToSet(T[] array) {
if (isEmpty(array)) {
return Collections.emptySet();
}
return Arrays.stream(array).collect(Collectors.toSet());
}
/**
* 拼接字符串
*
* @param list
* @param regex
* @param parallel
* @param function
* @return
*/
public static <T> String concatString(Collection<T> list, String regex, boolean parallel, Function<T, String> fn) {
if (isEmpty(list)) {
return null;
}
if (StringUtils.isEmpty(regex)) {
regex = ",";
}
Stream<T> stream = parallel ? list.parallelStream() : list.stream();
if (fn != null) {
return stream.map(t -> fn.apply(t)).collect(Collectors.joining(regex));
}
return stream.map(String::valueOf).collect(Collectors.joining(regex));
}
/**
* 拼接url参数字符串
*
* @param paramMap
* @return
*/
public static String getUrlParamStr(Map<String, String> paramMap) {
return isEmpty(paramMap) ? "" : Joiner.on("&").withKeyValueSeparator("=").join(paramMap);
}
public static String getSimpleUUID() {
return UUID.randomUUID().toString().replaceAll("-", "");
}
}

24
book-common/src/main/java/com/imooc/utils/GsonUtil.java Normal file
View File

@ -0,0 +1,24 @@
package com.imooc.utils;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
public class GsonUtil {
private static Gson gson = null;
private GsonUtil() {
}
static {
gson = new GsonBuilder().create();
}
public static String beanToJson(Object value) {
return gson.toJson(value);
}
public static <T> T jsonToBean(String content, Class<T> valueType) {
return gson.fromJson(content, valueType);
}
}

30
book-common/src/main/java/com/imooc/utils/JWTUtils.java Normal file
View File

@ -0,0 +1,30 @@
package com.imooc.utils;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
/**
* 基于JWT创建Token.
*
* @author lzc
* @version 1.0
*/
public class JWTUtils {
public static String createJWT(String userId, String password) {
Map<String, Object> headers = new HashMap<>();
Date issureDate = new Date();
Date expireDate = new Date(issureDate.getTime() + 3600 * 24 * 1000);
headers.put("typ", "JWT");
headers.put("alg", "HS256");
return JWT.create().withHeader(headers) // 头部信息
.withIssuer("Lzc") // 签发人
.withClaim("userId", userId) // 中间部分
.withIssuedAt(issureDate) // 签发时间
.withExpiresAt(expireDate) // 过期时间
.sign(Algorithm.HMAC256(password)); // 尾部
}
}

212
book-common/src/main/java/com/imooc/utils/RestTemplateUtil.java Normal file
View File

@ -0,0 +1,212 @@
package com.imooc.utils;
import java.util.Map;
import java.util.Optional;
import java.util.function.Consumer;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;
import net.sf.json.JSONObject;
import static com.imooc.utils.CommonUtil.isEmpty;
import static com.imooc.utils.CommonUtil.getUrlParamStr;
/**
* RestTemplate工具类
*
* @version 1.0.0
* @author Leon
*
*/
@Component
public final class RestTemplateUtil {
private static RestTemplate TEMPLATE;
private static RestTemplate TEMPLATE_IGNORE_SSL;
@Resource(name = "restTemplate")
private RestTemplate restTemplate;
@Resource(name = "restTemplateIgnoreSSL")
private RestTemplate restTemplateIgnoreSSL;
private RestTemplateUtil() {
}
@PostConstruct
private void init() {
TEMPLATE = this.restTemplate;
TEMPLATE_IGNORE_SSL = this.restTemplateIgnoreSSL;
}
/**
* GET请求
*
* @param <T>
* @param mediaType
* @param headerHandler
* @param headerData
* @param url
* @param param
* @param valueType
* @param responseHandler
*/
public static <T> void get(MediaType mediaType, Consumer<HttpHeaders> headerHandler, Map<String, String> headerData,
String url, Map<String, String> param, Class<T> valueType, Consumer<ResponseEntity<T>> responseHandler) {
HttpHeaders headers = new HttpHeaders();
Optional.ofNullable(mediaType).ifPresent(t -> headers.setContentType(t));
// 请求头信息
buildHttpHeaders(headers, headerHandler, headerData);
// 构建请求
HttpEntity<T> entity = new HttpEntity<>(headers);
ResponseEntity<T> responseEntity = buildRestTemplate(url).exchange(buildUrl(url, param), HttpMethod.GET, entity,
valueType);
// 处理响应
responseHandler(responseEntity, responseHandler);
}
/**
* POST请求
*
* @param <T>
* @param mediaType
* @param headerHandler
* @param headerData
* @param url
* @param param
* @param valueType
* @param responseHandler
*/
public static <T> void post(MediaType mediaType, Consumer<HttpHeaders> headerHandler,
Map<String, String> headerData, String url, JSONObject param, Class<T> valueType,
Consumer<ResponseEntity<T>> responseHandler) {
HttpHeaders headers = new HttpHeaders();
if (mediaType == null) {
headers.setContentType(MediaType.APPLICATION_JSON);
} else {
headers.setContentType(mediaType);
}
// 请求头信息
buildHttpHeaders(headers, headerHandler, headerData);
// 构建请求
HttpEntity<JSONObject> entity = new HttpEntity<>(param, headers);
ResponseEntity<T> responseEntity = buildRestTemplate(url).exchange(url, HttpMethod.POST, entity, valueType);
// 处理响应
responseHandler(responseEntity, responseHandler);
}
/**
* POST请求
*
* @param <T>
* @param mediaType
* @param headerHandler
* @param headerData
* @param url
* @param param
* @param valueType
* @param responseHandler
*/
public static <T> void post(MediaType mediaType, Consumer<HttpHeaders> headerHandler,
Map<String, String> headerData, String url, MultiValueMap<String, Object> param, Class<T> valueType,
Consumer<ResponseEntity<T>> responseHandler) {
HttpHeaders headers = new HttpHeaders();
if (mediaType == null) {
headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
} else {
headers.setContentType(mediaType);
}
// 请求头信息
buildHttpHeaders(headers, headerHandler, headerData);
// 构建请求
HttpEntity<MultiValueMap<String, Object>> entity = new HttpEntity<>(param, headers);
ResponseEntity<T> responseEntity = buildRestTemplate(url).postForEntity(url, entity, valueType);
// 处理响应
responseHandler(responseEntity, responseHandler);
}
/**
* PUT请求
*
* @param <T>
* @param headerHandler
* @param headerData
* @param url
* @param jsonBody
* @param valueType
* @param responseHandler
*/
public static <T> void put(Consumer<HttpHeaders> headerHandler, Map<String, String> headerData, String url,
String jsonBody, Class<T> valueType, Consumer<ResponseEntity<T>> responseHandler) {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
// 请求头信息
buildHttpHeaders(headers, headerHandler, headerData);
// 构建请求
HttpEntity<String> entity = new HttpEntity<>(jsonBody, headers);
ResponseEntity<T> responseEntity = buildRestTemplate(url).exchange(url, HttpMethod.PUT, entity, valueType);
// 处理响应
responseHandler(responseEntity, responseHandler);
}
/**
* 构建请求模板
*
* @param ssl
* @return
*/
private static RestTemplate buildRestTemplate(String url) {
boolean ssl = StringUtils.startsWithIgnoreCase(url, "https");
return ssl ? TEMPLATE_IGNORE_SSL : TEMPLATE;
}
/**
* 构建请求头信息
*
* @param headers
* @param headerHandler
* @param headerData
*/
private static void buildHttpHeaders(HttpHeaders headers, Consumer<HttpHeaders> headerHandler,
Map<String, String> headerData) {
Optional.ofNullable(headerHandler).ifPresent(t -> t.accept(headers));
if (!isEmpty(headerData)) {
headerData.forEach((k, v) -> headers.add(k, v));
}
}
/**
* 构建请求url
*
* @param url
* @param param
* @return
*/
private static String buildUrl(String url, Map<String, String> param) {
if (isEmpty(param)) {
return url;
}
String paramStr = getUrlParamStr(param);
return url + "?" + paramStr;
}
/**
* 响应处理
*
* @param <T>
* @param responseEntity
* @param responseHandler
*/
private static <T> void responseHandler(ResponseEntity<T> responseEntity,
Consumer<ResponseEntity<T>> responseHandler) {
Optional.ofNullable(responseHandler).ifPresent(t -> t.accept(responseEntity));
}
}

1
book-model/src/main/java/com/imooc/mo/MessageMO.java
View File

@ -7,7 +7,6 @@ import lombok.ToString;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;
import java.util.Date;
import java.util.Map;

16
book-model/src/main/java/com/imooc/mo/Token.java Normal file
View File

@ -0,0 +1,16 @@
package com.imooc.mo;
import lombok.Data;
@Data
public class Token {
/**
* 访问token
*/
private String accessToken;
/**
* 刷新token
*/
private String refreshToken;
}

2
book-model/src/main/java/com/imooc/pojo/Comment.java
View File

@ -2,8 +2,10 @@ package com.imooc.pojo;
import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;
@Table(name="t_comment")
public class Comment {
@Id
private String id;

158
book-model/src/main/java/com/imooc/pojo/Fans.java
View File

@ -1,96 +1,98 @@
package com.imooc.pojo;
import org.springframework.data.annotation.Id;
import javax.persistence.Column;
import javax.persistence.Table;
@Table(name = "t_fans")
public class Fans {
@Id
private String id;
@Id
private String id;
/**
* 作家用户id
*/
@Column(name = "vloger_id")
private String vlogerId;
/**
* 作家用户id
*/
@Column(name = "vloger_id")
private String vlogerId;
/**
* 粉丝用户id
*/
@Column(name = "fan_id")
private String fanId;
/**
* 粉丝用户id
*/
@Column(name = "fan_id")
private String fanId;
/**
* 粉丝是否是vloger的朋友，如果成为朋友，则本表的双方此字段都需要设置为1，如果有一人取关，则两边都需要设置为0
*/
@Column(name = "is_fan_friend_of_mine")
private Integer isFanFriendOfMine;
/**
* 粉丝是否是vloger的朋友，如果成为朋友，则本表的双方此字段都需要设置为1，如果有一人取关，则两边都需要设置为0
*/
@Column(name = "is_fan_friend_of_mine")
private Integer isFanFriendOfMine;
/**
* @return id
*/
public String getId() {
return id;
}
/**
* @return id
*/
public String getId() {
return id;
}
/**
* @param id
*/
public void setId(String id) {
this.id = id;
}
/**
* @param id
*/
public void setId(String id) {
this.id = id;
}
/**
* 获取作家用户id
*
* @return vloger_id - 作家用户id
*/
public String getVlogerId() {
return vlogerId;
}
/**
* 获取作家用户id
*
* @return vloger_id - 作家用户id
*/
public String getVlogerId() {
return vlogerId;
}
/**
* 设置作家用户id
*
* @param vlogerId 作家用户id
*/
public void setVlogerId(String vlogerId) {
this.vlogerId = vlogerId;
}
/**
* 设置作家用户id
*
* @param vlogerId 作家用户id
*/
public void setVlogerId(String vlogerId) {
this.vlogerId = vlogerId;
}
/**
* 获取粉丝用户id
*
* @return fan_id - 粉丝用户id
*/
public String getFanId() {
return fanId;
}
/**
* 获取粉丝用户id
*
* @return fan_id - 粉丝用户id
*/
public String getFanId() {
return fanId;
}
/**
* 设置粉丝用户id
*
* @param fanId 粉丝用户id
*/
public void setFanId(String fanId) {
this.fanId = fanId;
}
/**
* 设置粉丝用户id
*
* @param fanId 粉丝用户id
*/
public void setFanId(String fanId) {
this.fanId = fanId;
}
/**
* 获取粉丝是否是vloger的朋友，如果成为朋友，则本表的双方此字段都需要设置为1，如果有一人取关，则两边都需要设置为0
*
* @return is_fan_friend_of_mine - 粉丝是否是vloger的朋友，如果成为朋友，则本表的双方此字段都需要设置为1，如果有一人取关，则两边都需要设置为0
*/
public Integer getIsFanFriendOfMine() {
return isFanFriendOfMine;
}
/**
* 获取粉丝是否是vloger的朋友，如果成为朋友，则本表的双方此字段都需要设置为1，如果有一人取关，则两边都需要设置为0
*
* @return is_fan_friend_of_mine -
* 粉丝是否是vloger的朋友，如果成为朋友，则本表的双方此字段都需要设置为1，如果有一人取关，则两边都需要设置为0
*/
public Integer getIsFanFriendOfMine() {
return isFanFriendOfMine;
}
/**
* 设置粉丝是否是vloger的朋友，如果成为朋友，则本表的双方此字段都需要设置为1，如果有一人取关，则两边都需要设置为0
*
* @param isFanFriendOfMine 粉丝是否是vloger的朋友，如果成为朋友，则本表的双方此字段都需要设置为1，如果有一人取关，则两边都需要设置为0
*/
public void setIsFanFriendOfMine(Integer isFanFriendOfMine) {
this.isFanFriendOfMine = isFanFriendOfMine;
}
/**
* 设置粉丝是否是vloger的朋友，如果成为朋友，则本表的双方此字段都需要设置为1，如果有一人取关，则两边都需要设置为0
*
* @param isFanFriendOfMine 粉丝是否是vloger的朋友，如果成为朋友，则本表的双方此字段都需要设置为1，如果有一人取关，则两边都需要设置为0
*/
public void setIsFanFriendOfMine(Integer isFanFriendOfMine) {
this.isFanFriendOfMine = isFanFriendOfMine;
}
}

115
book-model/src/main/java/com/imooc/pojo/MyLikedVlog.java
View File

@ -1,74 +1,73 @@
package com.imooc.pojo;
import org.springframework.data.annotation.Id;
import javax.persistence.Column;
import javax.persistence.Table;
@Table(name = "my_liked_vlog")
@Table(name = "t_my_liked_vlog")
public class MyLikedVlog {
@Id
private String id;
@Id
private String id;
/**
* 用户id
*/
@Column(name = "user_id")
private String userId;
/**
* 用户id
*/
@Column(name = "user_id")
private String userId;
/**
* 喜欢的短视频id
*/
@Column(name = "vlog_id")
private String vlogId;
/**
* 喜欢的短视频id
*/
@Column(name = "vlog_id")
private String vlogId;
/**
* @return id
*/
public String getId() {
return id;
}
/**
* @return id
*/
public String getId() {
return id;
}
/**
* @param id
*/
public void setId(String id) {
this.id = id;
}
/**
* @param id
*/
public void setId(String id) {
this.id = id;
}
/**
* 获取用户id
*
* @return user_id - 用户id
*/
public String getUserId() {
return userId;
}
/**
* 获取用户id
*
* @return user_id - 用户id
*/
public String getUserId() {
return userId;
}
/**
* 设置用户id
*
* @param userId 用户id
*/
public void setUserId(String userId) {
this.userId = userId;
}
/**
* 设置用户id
*
* @param userId 用户id
*/
public void setUserId(String userId) {
this.userId = userId;
}
/**
* 获取喜欢的短视频id
*
* @return vlog_id - 喜欢的短视频id
*/
public String getVlogId() {
return vlogId;
}
/**
* 获取喜欢的短视频id
*
* @return vlog_id - 喜欢的短视频id
*/
public String getVlogId() {
return vlogId;
}
/**
* 设置喜欢的短视频id
*
* @param vlogId 喜欢的短视频id
*/
public void setVlogId(String vlogId) {
this.vlogId = vlogId;
}
/**
* 设置喜欢的短视频id
*
* @param vlogId 喜欢的短视频id
*/
public void setVlogId(String vlogId) {
this.vlogId = vlogId;
}
}

2
book-model/src/main/java/com/imooc/pojo/Users.java
View File

@ -2,8 +2,10 @@ package com.imooc.pojo;
import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;
@Table(name="t_users")
public class Users {
@Id
private String id;

2
book-model/src/main/java/com/imooc/pojo/Vlog.java
View File

@ -2,8 +2,10 @@ package com.imooc.pojo;
import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;
@Table(name="t_vlog")
public class Vlog {
@Id
private String id;

48
book-model/src/main/java/com/imooc/vo/UsersVO.java
View File

@ -5,38 +5,38 @@ import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import javax.persistence.Column;
import javax.persistence.Id;
import javax.validation.constraints.NotBlank;
import java.util.Date;
import com.imooc.mo.Token;
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class UsersVO {
private String id;
private String mobile;
private String nickname;
private String imoocNum;
private String face;
private Integer sex;
private Date birthday;
private String country;
private String province;
private String city;
private String district;
private String description;
private String bgImg;
private Integer canImoocNumBeUpdated;
private Date createdTime;
private Date updatedTime;
private String id;
private String mobile;
private String nickname;
private String imoocNum;
private String face;
private Integer sex;
private Date birthday;
private String country;
private String province;
private String city;
private String district;
private String description;
private String bgImg;
private Integer canImoocNumBeUpdated;
private Date createdTime;
private Date updatedTime;
private String userToken; // 用户token，传递给前端
private String userToken; // 用户token，传递给前端
private Integer myFollowsCounts; //我关注的
private Integer myFansCounts; //我的粉丝数量
//private Integer myLikedVlogCounts;
private Integer totalLikeMeCounts;
private Integer myFollowsCounts; // 我关注的
private Integer myFansCounts; // 我的粉丝数量
// private Integer myLikedVlogCounts;
private Integer totalLikeMeCounts;
private Token shopToken;
}

56
book-service/src/main/java/com/imooc/service/UserService.java
View File

@ -1,6 +1,8 @@
package com.imooc.service;
import java.util.Map;
import com.imooc.bo.UpdatedUserBO;
import com.imooc.mo.Token;
import com.imooc.pojo.Users;
/**
@ -9,30 +11,44 @@ import com.imooc.pojo.Users;
* @date 2023/5/25 21:02
*/
public interface UserService {
/**
* 判断用户是否存在，如果存在则返回用户信息
*/
public Users queryMobileIsExist(String mobile);
/**
* 判断用户是否存在，如果存在则返回用户信息
*/
public Users queryMobileIsExist(String mobile);
/**
* 创建用户信息，并且返回用户对象
*/
public Users createUser(String mobile);
/**
* 创建用户信息，并且返回用户对象
*/
public Users createUser(String mobile);
/**
* 根据用户主键查询用户信息
*/
public Users getUser(String userId);
/**
* 根据用户主键查询用户信息
*/
public Users getUser(String userId);
/**
* 用户信息修改
*/
public Users updateUserInfo(UpdatedUserBO updatedUserBO);
/**
* 用户信息修改
*/
public Users updateUserInfo(UpdatedUserBO updatedUserBO);
/**
* 用户信息修改
*/
public Users updateUserInfo(UpdatedUserBO updatedUserBO, Integer type);
/**
* 用户信息修改
*/
public Users updateUserInfo(UpdatedUserBO updatedUserBO, Integer type);
/**
* 创建用户打通短视频和商城系统
*
* @param mobile
* @return
*/
Map<String, Object> createUserNew(String mobile);
/**
* 获取商城token
*
* @param userId
* @return
*/
Token getShopToken(String userId);
}

247
book-service/src/main/java/com/imooc/service/impl/UserServiceImpl.java
View File

@ -1,5 +1,6 @@
package com.imooc.service.impl;
import com.google.common.collect.Maps;
import com.imooc.bo.UpdatedUserBO;
import com.imooc.enums.Sex;
import com.imooc.enums.UserInfoModifyType;
@ -7,21 +8,27 @@ import com.imooc.enums.YesOrNo;
import com.imooc.exceptions.GraceException;
import com.imooc.grace.result.ResponseStatusEnum;
import com.imooc.mapper.UsersMapper;
import com.imooc.mo.Token;
import com.imooc.pojo.Users;
import com.imooc.service.UserService;
import com.imooc.utils.DateUtil;
import com.imooc.utils.DesensitizationUtil;
import com.imooc.utils.GsonUtil;
import com.imooc.utils.RestTemplateUtil;
import org.apache.commons.lang3.StringUtils;
import org.n3r.idworker.Sid;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import tk.mybatis.mapper.entity.Example;
import javax.annotation.Resource;
import java.util.Date;
import java.util.Map;
/**
* @author vercen
@ -30,99 +37,179 @@ import java.util.Date;
*/
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UsersMapper usersMapper;
@Autowired
private UsersMapper usersMapper;
@Resource
private PasswordEncoder passwordEncoder;
@Autowired
private Sid sid;
private static final String USER_FACE1 = "http://122.152.205.72:88/group1/M00/00/05/CpoxxF6ZUySASMbOAABBAXhjY0Y649.png";
@Autowired
private Sid sid;
private static final String USER_FACE1 = "http://122.152.205.72:88/group1/M00/00/05/CpoxxF6ZUySASMbOAABBAXhjY0Y649.png";
@Override
public Users queryMobileIsExist(String mobile) {
Example userExample = new Example(Users.class);
Example.Criteria criteria = userExample.createCriteria();
criteria.andEqualTo("mobile", mobile);
Users user = usersMapper.selectOneByExample(userExample);
return user;
}
@Override
public Users queryMobileIsExist(String mobile) {
Example userExample = new Example(Users.class);
Example.Criteria criteria = userExample.createCriteria();
criteria.andEqualTo("mobile", mobile);
Users user = usersMapper.selectOneByExample(userExample);
return user;
}
@Override
public Users createUser(String mobile) {
// 获得全局唯一主键
String userId = sid.nextShort();
@Override
public Users createUser(String mobile) {
// 获得全局唯一主键
String userId = sid.nextShort();
Users user = new Users();
user.setId(userId);
user.setPassword(mobile);
user.setMobile(mobile);
user.setNickname("用户：" + DesensitizationUtil.commonDisplay(mobile));
user.setImoocNum("用户：" + DesensitizationUtil.commonDisplay(mobile));
user.setFace(USER_FACE1);
Users user = new Users();
user.setId(userId);
user.setPassword(mobile);
user.setMobile(mobile);
user.setNickname("用户：" + DesensitizationUtil.commonDisplay(mobile));
user.setImoocNum("用户：" + DesensitizationUtil.commonDisplay(mobile));
user.setFace(USER_FACE1);
user.setBirthday(DateUtil.stringToDate("1999-01-01"));
user.setSex(Sex.secret.type);
user.setBgImg("http://82.156.121.2:29000/bucket/IMG20241212102441.jpg"); // 测试用地址
user.setCountry("中国");
user.setProvince("");
user.setCity("");
user.setDistrict("");
user.setDescription("这家伙很懒，什么都没留下~");
user.setCanImoocNumBeUpdated(YesOrNo.YES.type);
user.setCreatedTime(new Date());
user.setUpdatedTime(new Date());
user.setBirthday(DateUtil.stringToDate("1999-01-01"));
user.setSex(Sex.secret.type);
user.setBgImg("http://82.156.121.2:29000/bucket/IMG20241212102441.jpg"); // 测试用地址
user.setCountry("中国");
user.setProvince("");
user.setCity("");
user.setDistrict("");
user.setDescription("这家伙很懒，什么都没留下~");
user.setCanImoocNumBeUpdated(YesOrNo.YES.type);
user.setCreatedTime(new Date());
user.setUpdatedTime(new Date());
usersMapper.insert(user);
usersMapper.insert(user);
return user;
}
return user;
}
@Override
public Users getUser(String userId) {
Users users = usersMapper.selectByPrimaryKey(userId);
return users;
}
@Override
public Users getUser(String userId) {
Users users = usersMapper.selectByPrimaryKey(userId);
return users;
}
@Transactional
@Override
public Users updateUserInfo(UpdatedUserBO updatedUserBO) {
@Transactional
@Override
public Users updateUserInfo(UpdatedUserBO updatedUserBO) {
Users users = new Users();
BeanUtils.copyProperties(updatedUserBO, users);
usersMapper.updateByPrimaryKeySelective(users);
return getUser(updatedUserBO.getId());
}
Users users = new Users();
BeanUtils.copyProperties(updatedUserBO, users);
usersMapper.updateByPrimaryKeySelective(users);
return getUser(updatedUserBO.getId());
}
@Transactional
@Override
public Users updateUserInfo(UpdatedUserBO updatedUserBO, Integer type) {
@Transactional
@Override
public Users updateUserInfo(UpdatedUserBO updatedUserBO, Integer type) {
Example example = new Example(Users.class);
Example.Criteria criteria = example.createCriteria();
if (type == UserInfoModifyType.NICKNAME.type) {
criteria.andEqualTo("nickname", updatedUserBO.getNickname());
Users user = usersMapper.selectOneByExample(example);
if (user != null) {
GraceException.display(ResponseStatusEnum.USER_INFO_UPDATED_NICKNAME_EXIST_ERROR);
}
}
Example example = new Example(Users.class);
Example.Criteria criteria = example.createCriteria();
if (type == UserInfoModifyType.NICKNAME.type) {
criteria.andEqualTo("nickname", updatedUserBO.getNickname());
Users user = usersMapper.selectOneByExample(example);
if (user != null) {
GraceException.display(ResponseStatusEnum.USER_INFO_UPDATED_NICKNAME_EXIST_ERROR);
}
}
if (type == UserInfoModifyType.IMOOCNUM.type) {
criteria.andEqualTo("imoocNum", updatedUserBO.getImoocNum());
Users user = usersMapper.selectOneByExample(example);
if (user != null) {
GraceException.display(ResponseStatusEnum.USER_INFO_UPDATED_NICKNAME_EXIST_ERROR);
}
if (type == UserInfoModifyType.IMOOCNUM.type) {
criteria.andEqualTo("imoocNum", updatedUserBO.getImoocNum());
Users user = usersMapper.selectOneByExample(example);
if (user != null) {
GraceException.display(ResponseStatusEnum.USER_INFO_UPDATED_NICKNAME_EXIST_ERROR);
}
Users tempUser = getUser(updatedUserBO.getId());
if (tempUser.getCanImoocNumBeUpdated() == YesOrNo.NO.type) {
GraceException.display(ResponseStatusEnum.USER_INFO_CANT_UPDATED_IMOOCNUM_ERROR);
}
Users tempUser = getUser(updatedUserBO.getId());
if (tempUser.getCanImoocNumBeUpdated() == YesOrNo.NO.type) {
GraceException.display(ResponseStatusEnum.USER_INFO_CANT_UPDATED_IMOOCNUM_ERROR);
}
updatedUserBO.setCanImoocNumBeUpdated(YesOrNo.NO.type);
}
updatedUserBO.setCanImoocNumBeUpdated(YesOrNo.NO.type);
}
return updateUserInfo(updatedUserBO);
return updateUserInfo(updatedUserBO);
}
}
@Transactional(rollbackFor = RuntimeException.class)
@Override
public Map<String, Object> createUserNew(String mobile) {
// 获得全局唯一主键
String userId = sid.nextShort();
// 创建短视频系统账号
Users user = new Users();
user.setId(userId);
user.setPassword(passwordEncoder.encode(mobile));
user.setMobile(mobile);
user.setNickname("用户：" + DesensitizationUtil.commonDisplay(mobile));
user.setImoocNum("用户：" + DesensitizationUtil.commonDisplay(mobile));
user.setFace(USER_FACE1);
user.setBirthday(DateUtil.stringToDate("1999-01-01"));
user.setSex(Sex.secret.type);
user.setBgImg("http://82.156.121.2:29000/bucket/IMG20241212102441.jpg");
user.setCountry("中国");
user.setProvince("");
user.setCity("");
user.setDistrict("");
user.setDescription("这家伙很懒，什么都没留下~");
user.setBgImg("");
user.setCanImoocNumBeUpdated(YesOrNo.YES.type);
user.setCreatedTime(new Date());
user.setUpdatedTime(new Date());
int row = usersMapper.insert(user);
if (row > 0) {
Map<String, Object> result = Maps.newHashMap();
result.put("user", user);
// 创建商城系统账号,获取商城系统token
String url = "http://localhost:8888/buyer/passport/member/registerFromTik";
MultiValueMap<String, Object> param = new LinkedMultiValueMap<>();
param.add("userName", mobile);
param.add("password", mobile);
param.add("mobilePhone", mobile);
param.add("userId", user.getId());
RestTemplateUtil.post(null, null, null, url, param, String.class, t -> {
if (t.getStatusCode() == HttpStatus.OK) {
String content = t.getBody();
if (StringUtils.isNotBlank(content)) {
Token token = GsonUtil.jsonToBean(content, Token.class);
result.put("token", token);
} else {
throw new RuntimeException("账号注册异常");
}
} else {
throw new RuntimeException("账号注册异常");
}
});
return result;
}
return null;
}
@Override
public Token getShopToken(String userId) {
Token[] tokens = { null };
String url = "http://localhost:8888/buyer/passport/member/getTokenFromTik";
MultiValueMap<String, Object> param = new LinkedMultiValueMap<>();
param.add("userId", userId);
RestTemplateUtil.post(null, null, null, url, param, String.class, t -> {
if (t.getStatusCode() == HttpStatus.OK) {
String content = t.getBody();
if (StringUtils.isNotBlank(content)) {
tokens[0] = GsonUtil.jsonToBean(content, Token.class);
} else {
throw new RuntimeException("账号注册异常");
}
} else {
throw new RuntimeException("账号注册异常");
}
});
return tokens[0];
}
}