Página inicial do autor: Bússola de Programação
Sobre o autor: Criador de alta qualidade no campo Java, especialista em blog CSDN, parceiro de conteúdo CSDN, autor convidado de Nuggets, especialista em blog Alibaba Cloud, autor convidado 51CTO, muitos anos de experiência em design de arquiteto, palestrante residente da sala de aula Tencent
Conteúdo principal: projeto Java, projeto Python, projeto front-end, inteligência artificial e big data, modelo de currículo, materiais didáticos, banco de perguntas para entrevistas, assistência técnica mútua
Favoritos, curtidas, não se perca, é bom seguir o autor
Obtenha o código-fonte no final do artigo
Número do item: BS-PT-090
1. Introdução ambiental
Localidade: Java: jdk1.8
Banco de dados: Mysql: mysql5.7
Servidor de aplicativos: Tomcat: tomcat8.5.31
Ferramentas de desenvolvimento: IDEA ou eclipse
Tecnologia de desenvolvimento: Springboot+Mybatis+Vue+ElmentUI
2. Introdução do projeto
Existem muitos amantes de romances online na China, alguns deles são leitores leais de pequenos romances online, e alguns deles consideram isso uma forma de lazer e entretenimento de lazer, mas agora o desenvolvimento da Internet também trouxe um crescimento explosivo de informações. Isso causou muitos obstáculos aos leitores na busca de romances on-line adequados. Como encontrar romances adequados em uma plataforma de romance é um problema que vale a pena estudar.
A fim de ajudar os usuários a encontrar rapidamente seus romances favoritos e adequados na plataforma de romances Fengluo, este projeto é baseado principalmente no algoritmo de filtragem colaborativa para fazer recomendações personalizadas, recomendando ativamente romances que os usuários da plataforma gostam ou que atendem às características de personalidade do usuário para os usuários, então que os usuários não precisem se preocupar em encontrar informações úteis em grandes quantidades de informações.
O design e o desenvolvimento do sistema de recomendação de romances on-line personalizados com base no algoritmo de filtragem colaborativa usa principalmente o algoritmo de filtragem colaborativa para recomendar os romances correspondentes aos usuários. Os algoritmos de filtragem colaborativa geralmente têm três modos comuns. Um deles é baseado na similaridade de itens, ou seja, baseado em itens. Ele recomenda procurando itens semelhantes. Por exemplo, se você comprar um telefone celular, itens adicionais, como filme de celular será recomendado. O segundo é baseado na similaridade dos usuários, ou seja, baseado no usuário, procurando usuários semelhantes para encontrar as preferências de usuários semelhantes e, em seguida, fazer recomendações. O terceiro é baseado no modo misto, ou seja, baseado em modo, que realiza principalmente a recomendação por meio do comportamento de operação do usuário no item. Por exemplo, o usuário geralmente navega em um determinado tipo de romance ou gosta e coleciona o romance, então o sistema os usará como base para recomendar romances online para os usuários.
Este projeto centra-se principalmente na leitura online, gestão e recomendação de informação de romances online, para que os utilizadores possam encontrar rapidamente os seus romances online favoritos ou úteis nesta plataforma. Todo o sistema é desenvolvido e implementado com base na ferramenta de desenvolvimento integrado IDEA, usando o framework Springboot na linguagem JAVA para construir a interface de serviço em segundo plano, usando VUE para construir a página front-end do sistema e usando MYSQL para dados básicos de negócios armazenar.
Este projeto é um sistema personalizado de recomendação de web novels com base nas características do usuário. Sua principal função é recomendar web novels adequadas para os usuários. Comportamentos operacionais são usados para realizar uma pontuação abrangente e fazer recomendações relevantes. Portanto, a função do sistema de design não é apenas recomendação, mas também algumas fontes básicas de dados, assim como o gerenciamento de informações de romances online, as operações dos usuários, como navegar, curtir e coletar romances online também são essenciais. Após a investigação e observação de sites semelhantes relacionados, os módulos de função de negócios relevantes do sistema são projetados.
As principais funções dos usuários front-end incluem: registro online e login de usuários, navegação de informações de romances online lançados pela plataforma, funções de interação do usuário, incluindo operações de curtidas, coleta e comentários, postagem e troca em fóruns da plataforma, visualização de anúncios do sistema, e informações relacionadas à leitura, sistema de recomendação de romances personalizados e gerenciamento de centro pessoal. O diagrama específico da estrutura da função do sistema é mostrado na Figura 1 abaixo:
As principais funções dos usuários de gerenciamento de segundo plano incluem: módulo de gerenciamento de informações do usuário, módulo de gerenciamento de informações pessoais, gerenciamento de dados do fórum de comunicação, gerenciamento de novas informações, gerenciamento de novas informações, gerenciamento de novas classificações, gerenciamento de novas informações, gerenciamento de anúncios, etc.
Três, exibição do sistema
Cadastro e login do usuário
Os usuários de front-end podem se registrar online após entrar na plataforma de romance online, preencher as informações relevantes e enviá-las para a plataforma do servidor. O sistema é desenvolvido e implementado com base na separação de front-end e back-end. Os dados de front-end -end users é transmitido ao servidor no formato de dados JSON por meio de solicitações assíncronas e o servidor aceita os dados. Em seguida, analise-os e use o método de salvamento da estrutura Mybatis-plus para salvar os dados na tabela do usuário da tabela do banco de dados. A seguir é apresentada a interface básica de cadastro do usuário, conforme Figura 1:
Exibição de recomendação de romance
Quando o usuário fizer login na página inicial do front-end do sistema, ele verá as novas informações recomendadas pelo sistema para o usuário atual. O algoritmo recomendado é o atualmente popular algoritmo de filtragem colaborativa, que usa o modo CF híbrido, que julga o interesse do usuário no romance com base na operação do usuário no romance. Que tipo de dados é interessante, de modo a fazer recomendações de dados correspondentes.
Troca de Fóruns de Usuários
A plataforma fornece aos usuários uma pequena função de fórum para comunicação online. Após o login, os usuários podem postar e se comunicar no fórum, e os usuários podem responder a postagens, navegar e outras operações relacionadas. A comunicação específica do fórum é mostrada na figura abaixo:
Navegação de informações novas
As novas informações são principalmente algumas notícias relevantes do setor divulgadas pela plataforma. Os usuários podem navegar e visualizá-las online e, ao mesmo tempo, podem realizar pesquisas difusas com base em palavras-chave relevantes e também podem filtrar de acordo com os tipos relacionados. Classificação, como operações descendentes ou ascendentes com base na popularidade (visualizações), tempo de atualização, etc.
centro pessoal
Centro pessoal é a função de operação de gerenciamento de informações pessoais fornecida pelo sistema para usuários atuais. Ele pode gerenciar informações básicas pessoais, alterar senhas e visualizar suas informações de registro favoritas, etc. As funções específicas de gerenciamento do centro pessoal são mostradas na figura a seguir
Gerenciamento de usuários em segundo plano
O módulo de gerenciamento de usuários em segundo plano é principalmente um módulo de gerenciamento projetado para gerenciar usuários da plataforma. Nesta interface de operação, as informações do usuário podem ser consultadas de acordo com o nome do usuário e o método de correspondência de consulta difusa pode ser usado para adicionar informações do usuário online , modificando as informações do usuário e Excluir e outras operações
gerenciamento de ficção
O administrador da plataforma realiza operações de gerenciamento relevantes nas novas informações em segundo plano, realizando principalmente a adição, modificação, consulta e exclusão de novas informações. Ao mesmo tempo, você pode visualizar a introdução detalhada da novela e as informações de avaliação do usuário em o romance. O texto do romance pode ser carregado ou carregado. Adicione as informações de hiperlink do romance, para que os usuários front-end possam baixar o romance online,
gerenciamento de informações
O administrador da plataforma realiza operações de gerenciamento relevantes nas novas informações em segundo plano, principalmente para realizar a adição, modificação, consulta e exclusão de novas informações. Ao mesmo tempo, você pode visualizar a introdução detalhada das novas informações e a avaliação do usuário informações sobre as novas informações. A exibição específica é a seguinte: Conforme mostrado na figura
Gerenciamento de anúncios
O administrador da plataforma executa operações de gerenciamento relevantes nas informações do anúncio da plataforma em segundo plano, principalmente para realizar a adição, modificação, consulta e exclusão das informações do anúncio e, ao mesmo tempo, você pode visualizar os detalhes do anúncio. exibição é como mostrado na figura:
Em quarto lugar, a exibição do código principal
package com.project.demo.controller.base;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.project.demo.service.base.BaseService;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;
import javax.persistence.Query;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*/
@Slf4j
public class BaseController<E, S extends BaseService<E>> {
@Setter
protected S service;
@PostMapping("/add")
@Transactional
public Map<String, Object> add(HttpServletRequest request) throws IOException {
service.insert(service.readBody(request.getReader()));
return success(1);
}
@Transactional
public Map<String, Object> addMap(Map<String,Object> map){
service.insert(map);
return success(1);
}
@PostMapping("/set")
@Transactional
public Map<String, Object> set(HttpServletRequest request) throws IOException {
service.update(service.readQuery(request), service.readConfig(request), service.readBody(request.getReader()));
return success(1);
}
@RequestMapping(value = "/del")
@Transactional
public Map<String, Object> del(HttpServletRequest request) {
service.delete(service.readQuery(request), service.readConfig(request));
return success(1);
}
@RequestMapping("/get_obj")
public Map<String, Object> obj(HttpServletRequest request) {
Query select = service.select(service.readQuery(request), service.readConfig(request));
List resultList = select.getResultList();
if (resultList.size() > 0) {
JSONObject jsonObject = new JSONObject();
jsonObject.put("obj",resultList.get(0));
return success(jsonObject);
} else {
return success(null);
}
}
@RequestMapping("/get_list")
public Map<String, Object> getList(HttpServletRequest request) {
Map<String, Object> map = service.selectToPage(service.readQuery(request), service.readConfig(request));
return success(map);
}
@RequestMapping("/list_group")
public Map<String, Object> listGroup(HttpServletRequest request) {
Map<String, Object> map = service.selectToList(service.readQuery(request), service.readConfig(request));
return success(map);
}
@RequestMapping("/bar_group")
public Map<String, Object> barGroup(HttpServletRequest request) {
Map<String, Object> map = service.selectBarGroup(service.readQuery(request), service.readConfig(request));
return success(map);
}
@RequestMapping(value = {"/count_group", "/count"})
public Map<String, Object> count(HttpServletRequest request) {
Query count = service.count(service.readQuery(request), service.readConfig(request));
return success(count.getResultList());
}
@RequestMapping(value = {"/sum_group", "/sum"})
public Map<String, Object> sum(HttpServletRequest request) {
Query count = service.sum(service.readQuery(request), service.readConfig(request));
return success(count.getResultList());
}
@RequestMapping(value = {"/avg_group", "/avg"})
public Map<String, Object> avg(HttpServletRequest request) {
Query count = service.avg(service.readQuery(request), service.readConfig(request));
return success(count.getResultList());
}
@PostMapping("/upload")
public Map<String, Object> upload(@RequestParam("file") MultipartFile file) {
log.info("进入方法");
if (file.isEmpty()) {
return error(30000, "没有选择文件");
}
try {
//判断有没路径，没有则创建
String filePath = System.getProperty("user.dir") + "\\target\\classes\\static\\upload\\";
File targetDir = new File(filePath);
if (!targetDir.exists() && !targetDir.isDirectory()) {
if (targetDir.mkdirs()) {
log.info("创建目录成功");
} else {
log.error("创建目录失败");
}
}
// String path = ResourceUtils.getURL("classpath:").getPath() + "static/upload/";
// String filePath = path.replace('/', '\\').substring(1, path.length());
String fileName = file.getOriginalFilename();
File dest = new File(filePath + fileName);
log.info("文件路径:{}", dest.getPath());
log.info("文件名:{}", dest.getName());
file.transferTo(dest);
JSONObject jsonObject = new JSONObject();
jsonObject.put("url", "/api/upload/" + fileName);
return success(jsonObject);
} catch (IOException e) {
log.info("上传失败：{}", e.getMessage());
}
return error(30000, "上传失败");
}
@PostMapping("/import_db")
public Map<String, Object> importDb(@RequestParam("file") MultipartFile file) throws IOException {
service.importDb(file);
return success(1);
}
@RequestMapping("/export_db")
public void exportDb(HttpServletRequest request, HttpServletResponse response) throws IOException {
HSSFWorkbook sheets = service.exportDb(service.readQuery(request), service.readConfig(request));
response.setContentType("application/octet-stream");
response.setHeader("Content-disposition", "attachment;filename=employee.xls");
response.flushBuffer();
sheets.write(response.getOutputStream());
sheets.close();
}
public Map<String, Object> success(Object o) {
Map<String, Object> map = new HashMap<>();
if (o == null) {
map.put("result", null);
return map;
}
if (o instanceof List) {
if (((List) o).size() == 1) {
o = ((List) o).get(0);
map.put("result", o);
}else {
String jsonString = JSONObject.toJSONString(o);
JSONArray objects = service.covertArray(JSONObject.parseArray(jsonString));
map.put("result", objects);
}
} else if (o instanceof Integer || o instanceof String) {
map.put("result", o);
} else {
String jsonString = JSONObject.toJSONString(o);
JSONObject jsonObject = JSONObject.parseObject(jsonString);
JSONObject j = service.covertObject(jsonObject);
map.put("result", j);
}
return map;
}
public Map<String, Object> error(Integer code, String message) {
Map<String, Object> map = new HashMap<>();
map.put("error", new HashMap<String, Object>(4) {
{
put("code", code);
put("message", message);
}});
return map;
}
}
package com.project.demo.controller;
import com.alibaba.fastjson.JSONObject;
import com.project.demo.entity.AccessToken;
import com.project.demo.entity.User;
import com.project.demo.entity.UserGroup;
import com.project.demo.service.AccessTokenService;
import com.project.demo.service.UserGroupService;
import com.project.demo.service.UserService;
import com.project.demo.controller.base.BaseController;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;
import javax.persistence.Query;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.*;
/**
* 用户账户：用于保存用户登录信息(User)表控制层
*/
@Slf4j
@RestController
@RequestMapping("user")
public class UserController extends BaseController<User, UserService> {
/**
* 服务对象
*/
@Autowired
public UserController(UserService service) {
setService(service);
}
/**
* Token服务
*/
@Autowired
private AccessTokenService tokenService;
@Autowired
private UserGroupService userGroupService;
/**
* 注册
* @param user
* @return
*/
@PostMapping("register")
public Map<String, Object> signUp(@RequestBody User user) {
// 查询用户
Map<String, String> query = new HashMap<>();
query.put("username",user.getUsername());
List list = service.select(query, new HashMap<>()).getResultList();
if (list.size()>0){
return error(30000, "用户已存在");
}
user.setUserId(null);
user.setPassword(service.encryption(user.getPassword()));
service.save(user);
return success(1);
}
/**
* 找回密码
* @param form
* @return
*/
@PostMapping("forget_password")
public Map<String, Object> forgetPassword(@RequestBody User form,HttpServletRequest request) {
JSONObject ret = new JSONObject();
String username = form.getUsername();
String code = form.getCode();
String password = form.getPassword();
// 判断条件
if(code == null || code.length() == 0){
return error(30000, "验证码不能为空");
}
if(username == null || username.length() == 0){
return error(30000, "用户名不能为空");
}
if(password == null || password.length() == 0){
return error(30000, "密码不能为空");
}
// 查询用户
Map<String, String> query = new HashMap<>();
query.put("username",username);
Query select = service.select(query, service.readConfig(request));
List list = select.getResultList();
if (list.size() > 0) {
User o = (User) list.get(0);
JSONObject query2 = new JSONObject();
JSONObject form2 = new JSONObject();
// 修改用户密码
query2.put("user_id",o.getUserId());
form2.put("password",service.encryption(password));
service.update(query, service.readConfig(request), form2);
return success(1);
}
return error(70000,"用户不存在");
}
/**
* 登录
* @param data
* @param httpServletRequest
* @return
*/
@PostMapping("login")
public Map<String, Object> login(@RequestBody Map<String, String> data, HttpServletRequest httpServletRequest) {
log.info("[执行登录接口]");
String username = data.get("username");
String email = data.get("email");
String phone = data.get("phone");
String password = data.get("password");
List resultList = null;
Map<String, String> map = new HashMap<>();
if(username != null && "".equals(username) == false){
map.put("username", username);
resultList = service.select(map, new HashMap<>()).getResultList();
}
else if(email != null && "".equals(email) == false){
map.put("email", email);
resultList = service.select(map, new HashMap<>()).getResultList();
}
else if(phone != null && "".equals(phone) == false){
map.put("phone", phone);
resultList = service.select(map, new HashMap<>()).getResultList();
}else{
return error(30000, "账号或密码不能为空");
}
if (resultList == null || password == null) {
return error(30000, "账号或密码不能为空");
}
//判断是否有这个用户
if (resultList.size()<=0){
return error(30000,"用户不存在");
}
User byUsername = (User) resultList.get(0);
Map<String, String> groupMap = new HashMap<>();
groupMap.put("name",byUsername.getUserGroup());
List groupList = userGroupService.select(groupMap, new HashMap<>()).getResultList();
if (groupList.size()<1){
return error(30000,"用户组不存在");
}
UserGroup userGroup = (UserGroup) groupList.get(0);
//查询用户审核状态
if (!StringUtils.isEmpty(userGroup.getSourceTable())){
String sql = "select examine_state from "+ userGroup.getSourceTable() +" WHERE user_id = " + byUsername.getUserId();
String res = String.valueOf(service.runCountSql(sql).getSingleResult());
if (res==null){
return error(30000,"用户不存在");
}
if (!res.equals("已通过")){
return error(30000,"该用户审核未通过");
}
}
//查询用户状态
if (byUsername.getState()!=1){
return error(30000,"用户非可用状态，不能登录");
}
String md5password = service.encryption(password);
if (byUsername.getPassword().equals(md5password)) {
// 存储Token到数据库
AccessToken accessToken = new AccessToken();
accessToken.setToken(UUID.randomUUID().toString().replaceAll("-", ""));
accessToken.setUser_id(byUsername.getUserId());
tokenService.save(accessToken);
// 返回用户信息
JSONObject user = JSONObject.parseObject(JSONObject.toJSONString(byUsername));
user.put("token", accessToken.getToken());
JSONObject ret = new JSONObject();
ret.put("obj",user);
return success(ret);
} else {
return error(30000, "账号或密码不正确");
}
}
/**
* 修改密码
* @param data
* @param request
* @return
*/
@PostMapping("change_password")
public Map<String, Object> change_password(@RequestBody Map<String, String> data, HttpServletRequest request){
// 根据Token获取UserId
String token = request.getHeader("x-auth-token");
Integer userId = tokenGetUserId(token);
// 根据UserId和旧密码获取用户
Map<String, String> query = new HashMap<>();
String o_password = data.get("o_password");
query.put("user_id" ,String.valueOf(userId));
query.put("password" ,service.encryption(o_password));
Query ret = service.count(query, service.readConfig(request));
List list = ret.getResultList();
Object s = list.get(0);
int count = Integer.parseInt(list.get(0).toString());
if(count > 0){
// 修改密码
Map<String,Object> form = new HashMap<>();
form.put("password",service.encryption(data.get("password")));
service.update(query,service.readConfig(request),form);
return success(1);
}
return error(10000,"密码修改失败！");
}
/**
* 登录态
* @param request
* @return
*/
@GetMapping("state")
public Map<String, Object> state(HttpServletRequest request) {
JSONObject ret = new JSONObject();
// 获取状态
String token = request.getHeader("x-auth-token");
// 根据登录态获取用户ID
Integer userId = tokenGetUserId(token);
log.info("[返回userId] {}",userId);
if(userId == null || userId == 0){
return error(10000,"用户未登录!");
}
// 根据用户ID获取用户
Map<String,String> query = new HashMap<>();
query.put("user_id" ,String.valueOf(userId));
// 根据用户ID获取
Query select = service.select(query,service.readConfig(request));
List resultList = select.getResultList();
if (resultList.size() > 0) {
JSONObject user = JSONObject.parseObject(JSONObject.toJSONString(resultList.get(0)));
user.put("token",token);
ret.put("obj",user);
return success(ret);
} else {
return error(10000,"用户未登录!");
}
}
/**
* 登录态
* @param request
* @return
*/
@GetMapping("quit")
public Map<String, Object> quit(HttpServletRequest request) {
String token = request.getHeader("x-auth-token");
JSONObject ret = new JSONObject();
Map<String, String> query = new HashMap<>(16);
query.put("token", token);
try{
tokenService.delete(query,service.readConfig(request));
}catch (Exception e){
e.printStackTrace();
}
return success("退出登录成功！");
}
/**
* 获取登录用户ID
* @param token
* @return
*/
public Integer tokenGetUserId(String token) {
log.info("[获取的token] {}",token);
// 根据登录态获取用户ID
if(token == null || "".equals(token)){
return 0;
}
Map<String, String> query = new HashMap<>(16);
query.put("token", token);
AccessToken byToken = tokenService.findOne(query);
if(byToken == null){
return 0;
}
return byToken.getUser_id();
}
/**
* 重写add
* @return
*/
@PostMapping("/add")
@Transactional
public Map<String, Object> add(HttpServletRequest request) throws IOException {
Map<String,Object> map = service.readBody(request.getReader());
map.put("password",service.encryption(String.valueOf(map.get("password"))));
service.insert(map);
return success(1);
}
}
5. Exibição de trabalhos relacionados
Projetos práticos baseados em desenvolvimento Java, desenvolvimento Python, desenvolvimento PHP, desenvolvimento C# e desenvolvimento de outras linguagens relacionadas
Projetos práticos front-end desenvolvidos com base em Nodejs, Vue e outras tecnologias front-end
Trabalhos relacionados baseados no applet WeChat e desenvolvimento de aplicativos Android APP
Desenvolvimento e aplicação de IoT embarcada baseada em microcomputador de 51 chips únicos
Aplicativo inteligente de IA baseado em vários algoritmos
Vários sistemas de gerenciamento e recomendação de dados baseados em big data
