1，系统技术简介

1.1 Mysql数据库

目前世界上的数据数不胜数，而且更新迭代的速度非常的快，最为世界上最出名的两款关系型数据库MySQL和Oracle，由于Oracle数据库需要付费而且安装Oracle的成本比较高，越来越多的开发人员喜欢使用MySQL数据库进行工程中数据的存储，而且MySQl是一款可以免费试用的数据库，使用它不用担心版权的问题。部署起来也非常的方便，相比较于Oracle的部署时间简直不到Oracle部署的五分之一。正是由于MySQL种种优越的特性本系统开发所选择的数据库便是MySQL数据库，MySQL数据库部署之后不会占用非常对的内存与硬盘，但是MySQL的访问速度却非常的快，在多线程访问的情况下依旧可以保证其优越的性能，充分发挥计算机的CPU性能，不会进行一点的浪费。

1.2SpringBoot框架

后台开发框架选择的是SpringBoot框架，本框架是通过Spring4.0发展而来的，使用SpringBoot框架进行后台代码的开发可以显著地提升代码的开发效率，同时使用其依赖大于配置的思想，减少了传统的Spring框架非常多的配置文件与配置依赖。使用Springboot开发让系统后台变得更加简单，比如代码运行不需要安装Tomcat便可以完成程序的启动调试；让部署变得简单，使用SpringBoot开发的工程部署只需要几jdk便可以完成程序的启动；简化配置，在开发过程中不需要配置各种依赖各种注入，让开发人员更加注重于代码的编写，SpringBoot的种种优点促使本系统使用该框架进行开发。

2，系统功能介绍

2.1 系统前台功能

（1）首页展示：用户可以在首页进行图书种类的搜索（图书名、分类等），用户也可以进行注册（账号、密码、个人基本信息）和登录（注册成功后输入账号、密码）操作。
（2）图书展示：在进入系统主页面后，用户可以浏览主页面图书信息，首页为图书资讯推荐图书等，可以查看图书分类，查看图书基本信息，比如：图书封面、图书详情等。
（3）图书搜索：经过大体浏览首页之后，用户可以根据自己的喜好和需求输入图书名称或者关键词进行图书的检索。
（4）加入购物车：用户可以将自己所需要下单的图书加入购物车，也可对购物车中的图书进行查看、修改、删除等操作。
（5）我的订单：用户购买后可以查看我的订单，待支付、待发货、待收货、已完成的订单信息。
（6）图书资讯：用户可以登陆网上书城查看资讯信息。

2.2 系统后台管理

（1）管理员注册、登录。
（2）用户管理：管理员对用户的信息进行管理。
（3）图书管理：对图书进行分类管理、对图书的基本信息（名称、价格、图片、内容）进行增加、删除、修改，查看等操作。
（4）订单管理：对下单的信息进行更新管理、订单跟踪、发货管理等。
（5）图书资讯管理：对于小程序首页图书资讯进行管理，链接图书详情。

2.3 流程图和结构功能图

业务流程图是一种描述商城内的管理信息流向，作业顺序和业务关系的流程图表。分析人员可以通过流程图分析出业务流程的不合理流向，及时发现和处理流程中的错误和潜在缺陷，调整和消除不合理的流程模块。功能结构图是对掌上书城微信小程序功能的分析，对功能列表结构进行详细描述，对其轮廓的逐步分解，从上到下绘制出来的结构图。

在这里插入图片描述

3，系统界面演示

在这里插入图片描述

4，系统核心代码演示

package com.project.demo.controller;

import com.project.demo.entity.AccessToken;
import com.project.demo.service.AccessTokenService;

import com.project.demo.controller.base.BaseController;
import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.*;

/**
 * 临时访问牌(AccessToken)表控制层
 *
 */
@RestController
@RequestMapping("access_token")
public class AccessTokenController extends BaseController<AccessToken, AccessTokenService> {
    
    
    /**
     * 服务对象
     */
    @Autowired
    public AccessTokenController(AccessTokenService service) {
    
    
        setService(service);
    }

}

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);
    }

}

package com.project.demo.controller;

import com.project.demo.entity.OrdinaryUsers;
import com.project.demo.service.OrdinaryUsersService;
import com.project.demo.controller.base.BaseController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.persistence.Query;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * 普通用户：(OrdinaryUsers)表控制层
 *
 */
@RestController
@RequestMapping("/ordinary_users")
public class OrdinaryUsersController extends BaseController<OrdinaryUsers, OrdinaryUsersService> {
    
    

    /**
     * 普通用户对象
     */
    @Autowired
    public OrdinaryUsersController(OrdinaryUsersService service) {
    
    
        setService(service);
    }

    @PostMapping("/add")
    @Transactional
    public Map<String, Object> add(HttpServletRequest request) throws IOException {
    
    
        Map<String,Object> paramMap = service.readBody(request.getReader());
        this.addMap(paramMap);
        return success(1);
    }

}

好了，整理结束，小伙伴们点赞、收藏、评论，一键三连走起呀，下期见~~

最后，我更新了大量的资料，都分享下，点击下面的，回复：项目大全

基于JavaSpringBoot+Vue+uniapp实现微信掌上图书小程序

文章目录