这一次来一个项目改造的项目实战，基于很久之前的一个demo项目，来实现一个改造优化和部署上线的项目实战。（就当是接手*山项目并且加以改造的一个实战吧。）
之前是一个关于运动的一个项目（其实之前连名字都没想好hhhh）。
那么先来梳理一下后端的项目已有的东西吧
很经典的项目结构，这个项目主要包括了运动的文章和文章分类，以及用户模块三个。（比较简单的一种）
那么现在来规划一下需求（需要填充的模块）：
1.视频的上传，查看，点赞，评论，收藏
2.用户的个人模块的完善（包括常见的权限，增删改查这样几个）
3.手机号，邮箱的登录注册。
4.动态关注，消息提醒这些
5.使用爬虫技术，加上定时任务长期获取数据源
6.匹配系统，匹配相似度高的用户
emmmm，目前就实现这些吧，先把基本的功能完善一下吧：
(让大家能够更快融入，我尽量按照模块来讲解，并且会放上初始项目代码（其实感觉都差不多，估计改完也跟原来没啥相似度了）)
1.用户模块改善
先从有基础的用户模块开始吧。
先来改良一下用户User的实体类吧
//原来的实体类属性
@NotNull
private Integer id;//主键ID
private String username;//用户名
@JsonIgnore
private String password;//密码
@NotEmpty
@Pattern(regexp = "^\\S{1,10}$")
private String nickname;//昵称
@NotEmpty
@Email
private String email;//邮箱
private String userPic;//用户头像地址
private LocalDateTime createTime;//创建时间
private LocalDateTime updateTime;//更新时间之前的算是比较简单的一个，那么现在来分析一下
功能实现：快速开发操作：使用MybatisX进行快速生成
这边建议是速度开发的话可以使用MybatisX进行快速开发（简化一些不必要的操作）
这样的话就只需要关注目前的数据库表的字段情况了
开始修改user表
目前来看只有最基础的几个，那么现在来添加一些业务必要的字段：
在数据库中添加字段，然后右击使用MybatisX进行代码自动生成就可以了（这里不建议使用lombok，之前出过错）
好，先来来梳理一下我们要设计的接口有哪些：
1.用户根据账号密码登录
2.用户根据邮箱实现登录
3.用户根据手机号实现登录
4.用户注册
5.获取当前用户信息
6.根据用户名查询用户信息
7.修改当前用户的信息
8.判断当前用户是否拥有权限
9.修改用户密码目前就是这些了。
1.注册的原始代码：
@PostMapping("/register")
public Result register(@Pattern(regexp = "^\\S{5,16}$") String username, @Pattern(regexp = "^\\S{5,16}$") String password) {
//查询用户
User u = userService.findByUserName(username);
if (u == null) {
//没有占用
//注册
userService.register(username, password);
return Result.success();
} else {
//占用
return Result.error("用户名已被占用");
}
}
@Override
public void register(String username, String password) {
//加密
String md5String = Md5Util.getMD5String(password);
//添加
userMapper.add(username,md5String);
}
@Override
public User findByUserName(String username) {
User u = userMapper.findByUserName(username);
return u;
}emmmm，确实简陋。
那么现在来改造一下
这边尽量就在controller层接收请求，逻辑处理的都放在service层。
注册的代码比较简单总体来说也就是格式校验，查看数据库中是否有此人已经注册，然后创建新的用户，给用户的一些属性赋初值存储数据库。
@PostMapping("/register")
public Result register(@Validated UserRegisterByEmail userRegister, HttpServletRequest request) {
return userService.register(userRegister,request);
}
@Override
public Result register(UserRegisterByEmail userRegister, HttpServletRequest request) {
String registerIp = getIpAddr(request);
String username = userRegister.getUsername();
String password = userRegister.getPassword();
String email = userRegister.getEmail();
//校验邮箱和用户名是否已经被注册
if (userMapper.findByUserName(username) != null) {
return Result.error("用户名已被注册");
}
if (userMapper.findByEmail(email) != null) {
return Result.error("邮箱已被注册");
}
//校验通过
User user = new User();
user.setEmail(email);
user.setUsername(username);
user.setPassword(Md5Util.getMD5String(password));
user.setNickname(USER_REGISTER_NAME + UUID.randomUUID());
user.setUserPic(USER_REGISTER_PIC);
user.setIsActivated(1);
user.setLastLoginIp(registerIp);
int insert = userMapper.save(user);
if (insert > 0) {
return Result.success();
} else {
return Result.error("注册失败");
}
}然后实现以下QQ邮箱的登录方案：（这个之前说过）
1.引入依赖
<dependency>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
<version>1.4</version>
</dependency>2.创建EmailUtils编写发送邮件的工具方法
package com.sportback.utils;
import java.security.Security;
import java.util.Properties;
import javax.mail.Authenticator;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class EmailUtils {
public static void sendEmail(String to, String subject, String content) {
try {
final String SSL_FACTORY = "javax.net.ssl.SSLSocketFactory";
//配置邮箱信息
Properties props = System.getProperties();
//邮件服务器
props.setProperty("mail.smtp.host", "smtp.qq.com");
props.setProperty("mail.smtp.socketFactory.class", SSL_FACTORY);
props.setProperty("mail.smtp.socketFactory.fallback", "false");
//邮件服务器端口
props.setProperty("mail.smtp.port", "465");
props.setProperty("mail.smtp.socketFactory.port", "465");
//鉴权信息
props.setProperty("mail.smtp.auth", "true");
//建立邮件会话
Session session = Session.getDefaultInstance(props, new Authenticator() {
//身份认证
protected PasswordAuthentication getPasswordAuthentication() {
//1.账户 授权码
return new PasswordAuthentication("xxxxxxx@qq.com", "xxxx");
}
});
//建立邮件对象
MimeMessage message = new MimeMessage(session);
//设置邮件的发件人
message.setFrom(new InternetAddress("xxxxxxx@qq.com"));
//2.设置邮件的收件人
message.setRecipients(Message.RecipientType.TO, to);
//设置邮件的主题
message.setSubject(subject);
//文本部分
message.setContent(content, "text/html;charset=UTF-8");
message.saveChanges();
//发送邮件
Transport.send(message);
} catch (Exception e) {
e.printStackTrace();
}
}
}return new PasswordAuthentication("xxxxxxx@qq.com", "xxxx");
message.setFrom(new InternetAddress("xxxxxxx@qq.com"));
这两个需要设置以下（详细可以参考以下我之前的文章，其实就是QQ邮件的授权码和QQ邮箱）
然后就可以编写接口代码了，一个是接收前端的邮箱进行获取验证码，一个是获取邮箱和验证码进行验证（这里其实还可以进行一个判断是否有这个用户，然后进行快速注册）
这些过于简单的就不细说了，前面的文章也写过。
功能实现：进行定时的一周总结。
之前在使用coding的时候，它会定时推送一个一周总结的东西，总结一周下来的总代码量，完成的需求，修复的bug这些。
那么今天就在用户模块这里模仿出一个这样的功能。
根本上来说是要用定时任务框架，定时自动执行某行Java代码，这里可以使用SpringTask
在原来的包结构下创建一个job包，并创建WeekSummary类
1.引入依赖
//导入Spring-context的jar包
<!-- spring-context-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>2.启动类添加注解@EnableScheduling开启任务调度
3.自定义定时任务类（编写一个简单类）
package com.sportback.job;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.Date;
@Component
public class WeekSummary {
@Scheduled(cron = "0/5 * * * * ?")//执行时间间隔
public void executeTask(){
System.out.println("定时任务开始"+new Date());
}
}
然后就可以根据时间进行筛选：
@Scheduled(cron = "0/5 * * * * ?")
public void executeTask(){
LocalDateTime time = LocalDateTime.now();
LocalDateTime lastTime = time.minusDays(7);
List<UserLog> userLogs = logService.getUserLogsByTime(time,lastTime);
System.out.println(userLogs);
}这里做测试的时候时间间隔就短一些，这里就获取用户在最近七天的登录注册的日志信息吧，获取当前的时间信息，然后调用logService，对近期的数据进行筛查就好了（这里输出出来，就不放到前端了，如果要将这种定时信息放到前端的话，可以使用轮询，websocket这些方式。）
@Override
public List<UserLog> getUserLogsByTime(LocalDateTime time, LocalDateTime lastTime) {
DateTimeFormatter outputFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
return logMapper.getUserLogsByTime(outputFormatter.format(time), outputFormatter.format(lastTime));
}
@Select("select * from user_logs where timestamp between #{lastTime} and #{time}")
List<UserLog> getUserLogsByTime(String time, String lastTime);
这里写的比较简易，可以结合其他的业务进行总结和数据处理。
功能实现：网站定时获取数据源（爬虫技巧）
对于初始的系统来说需要导入一些数据，这里用一些爬虫的方法，在每日凌晨获取到其他网站的信息试试。
1.分析目的网站的字段，然后根据字段创建实体类。
public class Post implements Serializable {
/**
* id
*/
private Long id;
/**
* 标题
*/
private String title;
/**
* 内容
*/
private String content;
/**
* 标签列表 json
*/
private String tags;
/**
* 点赞数
*/
private Integer thumbNum;
/**
* 收藏数
*/
private Integer favourNum;
/**
* 创建用户 id
*/
private Integer userId;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新时间
*/
private Date updateTime;
/**
* 是否删除
*/
private Integer isDelete;
@Override
public String toString() {
return "Post{" +
"id=" + id +
", title='" + title + '\'' +
", content='" + content + '\'' +
", tags='" + tags + '\'' +
", thumbNum=" + thumbNum +
", favourNum=" + favourNum +
", userId=" + userId +
", createTime=" + createTime +
", updateTime=" + updateTime +
", isDelete=" + isDelete +
'}';
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getTags() {
return tags;
}
public void setTags(String tags) {
this.tags = tags;
}
public Integer getThumbNum() {
return thumbNum;
}
public void setThumbNum(Integer thumbNum) {
this.thumbNum = thumbNum;
}
public Integer getFavourNum() {
return favourNum;
}
public void setFavourNum(Integer favourNum) {
this.favourNum = favourNum;
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
public Integer getIsDelete() {
return isDelete;
}
public void setIsDelete(Integer isDelete) {
this.isDelete = isDelete;
}
2.使用相关的发起网络请求的技术进行爬虫，比如jsoup，hutool工具包，httpClient这些都可以，可以看看之前发的文章，了解一下。
@Scheduled(cron = "0/5 * * * * ?")
public void executeTask(){
//1.获取数据
String json = "{\n" +
" \"current\": 1,\n" +
" \"pageSize\": 8,\n" +
" \"sortField\": \"createTime\",\n" +
" \"sortOrder\": \"descend\",\n" +
" \"category\": \"文章\",\n" +
" \"tags\": [],\n" +
" \"reviewStatus\": 1\n" +
"}";
String url = "https:xxxxxxxxxxxx";
String result2 = HttpRequest.post(url)
.body(json)
.execute().body();
//2.JSON转对象
Map<String, Object> map = JSONUtil.toBean(result2, Map.class);
JSONObject data = (JSONObject)map.get("data");
JSONArray records = (JSONArray)data.get("records");
List<Post> postList = new ArrayList<>();
for(Object record : records){
JSONObject tmpObject = (JSONObject)record;
Post post = new Post();
List<String> list = tags.toList(String.class);
post.setTags(JSONUtil.toJsonStr(list));
post.setCreateTime(new Date());
post.setUpdateTime(new Date());
postList.add(post);
}
postService.saveAll(postList);
System.out.println(result2);
}这样就能实现每天进行一次数据的更新了。
功能实现：腾讯云对象存储
引入依赖
<dependency>
<groupId>com.qcloud</groupId>
<artifactId>cos_api</artifactId>
<version>5.6.227</version>
</dependency>引入上传对象代码
// 1 传入获取到的临时密钥 (tmpSecretId, tmpSecretKey, sessionToken)
static String tmpSecretId = "";
static String tmpSecretKey = "";
static String sessionToken = "TOKEN";
static BasicSessionCredentials cred = new BasicSessionCredentials(tmpSecretId, tmpSecretKey, sessionToken);
// 2 设置 bucket 的地域
// clientConfig 中包含了设置 region, https(默认 http), 超时, 代理等 set 方法, 使用可参见源码或者常见问题 Java SDK 部分
static Region region = new Region(""); //COS_REGION 参数：配置成存储桶 bucket 的实际地域，例如 ap-beijing，更多 COS 地域的简称请参见 https://cloud.tencent.com/document/product/436/6224
static ClientConfig clientConfig = new ClientConfig(region);
// 3 生成 cos 客户端
static COSClient cosClient = new COSClient(cred, clientConfig);
public static String uploadFile(MultipartFile file, String fileName) throws CosClientException, IOException {
// 指定文件将要存放的存储桶
String bucketName = "";
// 创建 PutObjectRequest 对象
InputStream inputStream = file.getInputStream();
PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, fileName, inputStream, null);
// 执行上传操作
PutObjectResult putObjectResult = cosClient.putObject(putObjectRequest);
// 获取文件的 URL
URL objectUrl = cosClient.getObjectUrl(bucketName, fileName);
// 关闭客户端(关闭后台线程)
cosClient.shutdown();
return objectUrl.toString();
}这样就可以了。
定义删除对象的操作
public static boolean deleteFile(String fileName) {
try {
// 指定要删除的存储桶名称和文件
String bucketName = "";
// 指定要删除的存储桶名称和文件
cosClient.deleteObject(bucketName, fileName);
// 关闭客户端(关闭后台线程)
cosClient.shutdown();
return true;
} catch (CosClientException cce) {
cce.printStackTrace();
return false;
}
}这样就可以实现腾讯云的对象存储了。（注意可以把secretid和key放在配置文件或者数据库中进行存储）
改造一下上传接口
@RestController
public class FileUploadController {
@PostMapping("/upload")
public Result<String> upload(@RequestPart MultipartFile file) throws Exception {
// 生成文件名
String originalFilename = file.getOriginalFilename();
String filename = null;
if (originalFilename != null) {
filename = UUID.randomUUID() + originalFilename.substring(originalFilename.lastIndexOf("."));
}
// 上传文件
String publicUrl = CosUtils.uploadFile(file, filename);
return Result.success(publicUrl);
}
}
此时通过postman进行测试就没有问题了
理论上这里需要把publicurl返回回来，但是实际上这样是不好的，不建议将自身对象存储的url暴露给前端的，这里后面需要再修改一下（先把功能实现了吧）
功能实现：用户匹配机制
编写工具类进行使用
public static int minDistance(List<String> tagList1, List<String> tagList2) {
int n = tagList1.size();
int m = tagList2.size();
if (n * m == 0) {
return n + m;
}
int[][] d = new int[n + 1][m + 1];
for (int i = 0; i < n + 1; i++) {
d[i][0] = i;
}
for (int j = 0; j < m + 1; j++) {
d[0][j] = j;
}
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < m + 1; j++) {
int left = d[i - 1][j] + 1;
int down = d[i][j - 1] + 1;
int left_down = d[i - 1][j - 1];
if (!Objects.equals(tagList1.get(i - 1), tagList2.get(j - 1))) {
left_down += 1;
}
d[i][j] = Math.min(left, Math.min(down, left_down));
}
}
return d[n][m];
}然后在UserController类中使用。
在逻辑处理处进行匹配即可
public List<User> matchUsers(long num, User loginUser) {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("id", "tags");
queryWrapper.isNotNull("tags");
List<User> userList = this.list(queryWrapper);
String tags = loginUser.getTags();
Gson gson = new Gson();
List<String> tagList = gson.fromJson(tags, new TypeToken<List<String>>() {}.getType());
// 用户列表的下标 => 相似度
List<Pair<User, Long>> list = new ArrayList<>();
// 依次计算所有用户和当前用户的相似度
for (int i = 0; i < userList.size(); i++) {
User user = userList.get(i);
String userTags = user.getTags();
// 无标签或者为当前用户自己
if (StringUtils.isBlank(userTags) || Objects.equals(user.getId(), loginUser.getId())) {
continue;
}
List<String> userTagList = gson.fromJson(userTags, new TypeToken<List<String>>() {}.getType());
// 计算分数
long distance = AlgorithmUtils.minDistance(tagList, userTagList);
list.add(new Pair<>(user, distance));
}
// 按编辑距离由小到大排序
List<Pair<User, Long>> topUserPairList = list.stream()
.sorted((a, b) -> (int) (a.getValue() - b.getValue()))
.limit(num)
.collect(Collectors.toList());
// 原本顺序的 userId 列表
List<Integer> userIdList = topUserPairList.stream()
.map(pair -> pair.getKey().getId())
.collect(Collectors.toList());
Collections.reverse(userIdList); // 使用 Collections.reverse() 方法反转列表
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.in("id", userIdList);
// 1, 3, 2
// User1、User2、User3
// 1 => User1, 2 => User2, 3 => User3
Map<Integer, List<User>> userIdUserListMap = this.list(userQueryWrapper)
.stream()
.collect(Collectors.groupingBy(User::getId));
List<User> finalUserList = new ArrayList<>();
for (Integer userId : userIdList) {
finalUserList.add(userIdUserListMap.get(userId).get(0));
}
return finalUserList;
}这样其实就可以实现了。
1.视频的上传，查看，点赞，评论，收藏
2.用户的个人模块的完善（包括常见的权限，增删改查这样几个）
3.手机号，邮箱的登录注册。
4.动态关注，消息提醒这些
5.使用爬虫技术，加上定时任务长期获取数据源
6.匹配系统，匹配相似度高的用户
那么今天其实已经实现了：
1.用户模块的完善（其实还差一些）
2.邮箱的登录
3.使用爬虫技术实现了数据的定时更新。
4.使用定时模块实现了相关功能
5.利用算法实现了用户之间的匹配机制
