基于javaweb+mysql的springboot电商书城平台系统设计和实现(java+springboot+mysql+spring+jsp)

基于javaweb+mysql的springboot电商书城平台系统设计和实现(java+springboot+mysql+spring+jsp)

运行环境

Java≥8、MySQL≥5.7

开发工具

eclipse/idea/myeclipse/sts等均可配置运行

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb+mysql的SpringBoot电商书城平台系统设计和实现(java+springboot+mysql+spring+jsp)

JAVA springboot 电商书城平台系统(已调试) 主要实现了书城网站的浏览、加入购物车操作、订单操作、支付操作、分类查看、搜索、以及后台上传图书信息以及订单管理和一些基本操作功能

主要功能截图如下：

模拟支付宝支付：

主要技术：java springboot springbmvc shiro mybatis mysql jquery css js jsp bootstarp.js

    }

    /**
     * 确认收货
     *
     * @param orderId
     * @return
     */
    @RequestMapping("/confirm/{orderId}")
    public String confirmReceiving(@PathVariable("orderId") String orderId, Model model) {
        BSResult bsResult = orderService.confirmReceiving(orderId);

        if (bsResult.getCode() == 200) {
            return "redirect:/order/list";
        } else {
            model.addAttribute("exception", bsResult.getMessage());
            return "exception";
        }

    }
}

@Service
public class CartServiceImpl implements ICartService {

    @Override
    public BSResult addToCart(BookInfo bookInfo, Cart cart, int buyNum) {

        //购物车为空，新建一个
        if (cart == null) {
            cart = new Cart();
        }
        Map<Integer, CartItem> cartItems = cart.getCartItems();
        double total = 0;

@ControllerAdvice
public class BSExceptionHandler {

	public static final String BS_ERROR_VIEW_NAME = "exception";

	@ExceptionHandler(value = Exception.class)
	@ResponseStatus(HttpStatus.OK)
    public Object ExceptionHandler(HttpServletRequest request, Exception e) throws Exception {
    	
    	e.printStackTrace();
    	
    	if (isAjax(request)) {
    		return BSResultUtil.build(500, e.getMessage(),null);
    	} else {
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.addObject("exception", "系统繁忙，请稍后再试");
            modelAndView.addObject("url", request.getRequestURL());
            modelAndView.setViewName(BS_ERROR_VIEW_NAME);
            return modelAndView;
    	}
    }

	@ExceptionHandler(value = BSException.class)
	@ResponseStatus(HttpStatus.OK)
	public Object BSExceptionHandler(HttpServletRequest request, Exception e) throws Exception {
		e.printStackTrace();
		if (isAjax(request)) {
			return BSResultUtil.build(500, e.getMessage(),null);
		} else {
			ModelAndView modelAndView = new ModelAndView();
			modelAndView.addObject("exception", e.getMessage());
			modelAndView.addObject("url", request.getRequestURL());
			modelAndView.setViewName(BS_ERROR_VIEW_NAME);
			return modelAndView;
		}
	}
	@ExceptionHandler(value = UnauthorizedException.class)
	@ResponseStatus(HttpStatus.OK)
	public Object UnauthorizedExceptionHandler(HttpServletRequest request, Exception e) throws Exception {
		if (isAjax(request)) {
			return BSResultUtil.build(403, "对不起，您没有访问权限",null);

@RequestMapping("/admin/role")
@RequiresPermissions("role-manage")
public class RoleController {

    @Autowired
    private IRoleService roleService;

    @RequestMapping("/list")
    @RequiresPermissions("role-list")
    public String roleList(Model model){
        List<Role> allRoles = roleService.findAllRoles();
        model.addAttribute("allRoles", allRoles);
        return "admin/role/list";
    }

    @RequestMapping("/echo/{roleId}")
    @RequiresPermissions("role-edit")
    public String toEdit(@PathVariable("roleId") int roleId, Model model){

        Role role = roleService.findById(roleId);

        model.addAttribute("role", role);

        return "admin/role/edit";
    }

    @RequestMapping("/deletion/{roleId}")
    @RequiresPermissions("role-delete")
    public String deleteRole(@PathVariable("roleId")int roleId){

        roleService.deleteById(roleId);

        return "forward:../list";
    }

    @RequestMapping("/toAddition")
    @RequiresPermissions("role-add")
    public String toAdd(){
        return "admin/role/add";
    }

    @RequestMapping("/addition")
    @RequiresPermissions("role-add")
    public String addRole(Role role){
        roleService.addRole(role);
        return "forward:list";
    }

    @RequestMapping("/edit")

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private IUserService userService;

    @Autowired
    private IMailService mailService;

    @Autowired
    private IStoreService storeService;

    @Value("${mail.fromMail.addr}")
    private String from;

    @Value("${my.ip}")
    private String ip;

    private final String USERNAME_PASSWORD_NOT_MATCH = "用户名或密码错误";

    private final String USERNAME_CANNOT_NULL = "用户名不能为空";

    @RequestMapping("/login")
    public String login(@RequestParam(value = "username", required = false) String username,
                        @RequestParam(value = "password", required = false) String password,
                        HttpServletRequest request, Model model) {
        if (StringUtils.isEmpty(username) || StringUtils.isEmpty(password)) {
            return "login";
        }
        //未认证的用户
        Subject userSubject = SecurityUtils.getSubject();
        if (!userSubject.isAuthenticated()) {

     */
    @RequestMapping("/checkUserExist")
    @ResponseBody
    public BSResult checkUserExist(String username) {
        if (StringUtils.isEmpty(username)) {
            return BSResultUtil.build(200, USERNAME_CANNOT_NULL, false);
        }

        return userService.checkUserExistByUsername(username);
    }

    /**
     * 注册，发激活邮箱
     *
     * @param user
     * @return
     */
    @RequestMapping("/register")
    public String register(User user, Model model) {

        BSResult isExist = checkUserExist(user.getUsername());

        //尽管前台页面已经用ajax判断用户名是否存在，
        // 为了防止用户不是点击前台按钮提交表单造成的错误，后台也需要判断
        if ((Boolean) isExist.getData()) {
        	user.setActive("1");
            BSResult bsResult = userService.saveUser(user);
            //获得未激活的用户
            User userNotActive = (User) bsResult.getData();
          /*  try {
                mailService.sendHtmlMail(user.getEmail(), "<dd书城>---用户激活---",
                        "<html><body><a href='http://"+ip+"/user/active?activeCode=" + userNotActive.getCode() + "'>亲爱的" + user.getUsername() +
                                "，请您点击此链接前往激活</a></body></html>");
            } catch (Exception e) {
                e.printStackTrace();
                model.addAttribute("registerError", "发送邮件异常！请检查您输入的邮箱地址是否正确。");
                return "fail";
            }*/
            model.addAttribute("username", user.getUsername());
            return "register_success";
        } else {

                return "login";
            } catch (AuthenticationException ae) {
                model.addAttribute("loginMsg", "登录失败！");
                return "login";
            }

        } else {
            //用户已经登录
            return "redirect:/index";
        }

    }

    @RequestMapping("/info")
    public String personInfo(){
        return "user_info";
    }

    /* @RequestMapping("/login1")
     public String login1(@RequestParam(value = "username", required = false) String username,
                          @RequestParam(value = "password", required = false) String password,
                          Model model, HttpServletRequest request) {

         if (StringUtils.isEmpty(username)) {
             model.addAttribute("loginMsg", USERNAME_CANNOT_NULL);
             return "login";
         }

         if (StringUtils.isEmpty(password)) {
             model.addAttribute("loginMsg", "密码不能为空");
             return "login";
         }

         BSResult<User> bsResult = userService.login(username, password);
         //登录校验失败
         if (bsResult.getData() == null) {
             model.addAttribute("loginMsg", bsResult.getMessage());
             return "login";
         }

         //登录校验成功，重定向到首页
         User user = bsResult.getData();
         //置密码为空
         user.setPassword("");
         request.getSession().setAttribute("user", user);
         return "redirect:/";
     }
     */
    //shiro框架帮我们注销

    private final String USERNAME_PASSWORD_NOT_MATCH = "用户名或密码错误";

    private final String USERNAME_CANNOT_NULL = "用户名不能为空";

    @RequestMapping("/login")
    public String login(@RequestParam(value = "username", required = false) String username,
                        @RequestParam(value = "password", required = false) String password,
                        HttpServletRequest request, Model model) {
        if (StringUtils.isEmpty(username) || StringUtils.isEmpty(password)) {
            return "login";
        }
        //未认证的用户
        Subject userSubject = SecurityUtils.getSubject();
        if (!userSubject.isAuthenticated()) {
            UsernamePasswordToken token = new UsernamePasswordToken(username, password);

            token.setRememberMe(false);//禁止记住我功能
            try {

                //登录成功
                userSubject.login(token);
                User loginUser = (User) userSubject.getPrincipal();
                request.getSession().setAttribute("loginUser", loginUser);
                Store store = storeService.findStoreByUserId(loginUser.getUserId());
                request.getSession().setAttribute("loginStore", store);

                SavedRequest savedRequest = WebUtils.getSavedRequest(request);
                String url = "/";
                if (savedRequest != null) {
                    url = savedRequest.getRequestUrl();
                    if(url.contains(request.getContextPath())){
                        url = url.replace(request.getContextPath(),"");
                    }
                }
                if(StringUtils.isEmpty(url) || url.equals("/favicon.ico")){
                    url = "/";
                }

                return "redirect:" + url;

            } catch (UnknownAccountException | IncorrectCredentialsException uae) {
                model.addAttribute("loginMsg", USERNAME_PASSWORD_NOT_MATCH);
                return "login";
            } catch (LockedAccountException lae) {
                model.addAttribute("loginMsg", "账户已被冻结！");
                return "login";
            } catch (AuthenticationException ae) {

    public BSResult checkedOrNot(Cart cart, int bookId) {
        Map<Integer, CartItem> cartItems = cart.getCartItems();

        if (cartItems.containsKey(bookId)) {
            CartItem cartItem = cartItems.get(bookId);
            if (cartItem.isChecked()) {
                //如果之前是true，那就设为false
                cartItem.setChecked(false);
                cart.setTotal(cart.getTotal() - cartItem.getSubTotal());
                cartItem.setSubTotal(0.00);
            } else {
                //如果之前是false，那就设为true
                cartItem.setChecked(true);
                cartItem.setSubTotal(cartItem.getBuyNum() * cartItem.getBookInfo().getPrice().doubleValue());
                cart.setTotal(cart.getTotal() + cartItem.getSubTotal());

            }
            return BSResultUtil.success();
        } else
            return BSResultUtil.build(400, "购物车没有这本书籍!");
    }

}

@Controller
@RequestMapping("admin/order")
@RequiresPermissions("order-manage")
public class AdminOrderController {

    @Autowired

@Controller
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private IOrderService orderService;

    @Autowired
    private ICartService cartService;

    @Autowired
    private IBookInfoService bookInfoService;

    /**
     * 填写订单信息页面
     *
     * @param bookId
     * @param buyNum
     * @param request
     * @return
     */
    @GetMapping("/info")
    public String orderInfo(@RequestParam(required = false, defaultValue = "0") int bookId,
                            @RequestParam(required = false, defaultValue = "0") int buyNum,
                            HttpServletRequest request) throws BSException {

        if (bookId != 0) {
            //点了立即购买，放到request域中，也session的立即购买域中以区分购物车中的书籍
            BookInfo bookInfo = bookInfoService.findById(bookId);
            if (bookInfo != null) {
                BSResult bsResult = cartService.addToCart(bookInfo, null, buyNum);
                request.getSession().setAttribute("buyNowCart", bsResult.getData());
                request.setAttribute("cart", bsResult.getData());
                return "order_info";
            } else {
                request.setAttribute("exception", "不好意思，书籍库存不足或不存在了！");
                return "exception";
            }

        return bsResult;
    }

}

@RestController
@RequestMapping("/admin/report")
@RequiresPermissions("store-manage")
public class ReportController {

    @Autowired
    private IBookInfoService bookInfoService;

    /**
     * 商店书籍访问量排行饼图
     * @return
     */
    @RequestMapping("/views/pie")
    public List<Pie> getBookViewsPieJson(HttpSession session){
        Store loginStore = (Store) session.getAttribute("loginStore");
        if(loginStore == null){
            return new ArrayList<>();
        }
        return bookInfoService.getBookViewsPiesByStoreId(loginStore.getStoreId());
    }

    @RequestMapping("/sales/bar")
    public Bar getBookSalesBarJson(HttpSession session){
        Store loginStore = (Store) session.getAttribute("loginStore");
        if(loginStore == null){
            return null;
        }
        return bookInfoService.getBookSalesBarJson(loginStore.getStoreId());

@Controller
@RequestMapping("/admin/book")
@RequiresPermissions("book-manage")
public class AdminBookController {

    @Autowired
    private IBookInfoService bookInfoService;

    @Autowired
    private BookDescMapper bookDescMapper;

    @Autowired
    private IStoreService storeService;

    @Value("${image.url.prefix}")
    private String urlPrefix;

    @RequestMapping("toAddition")
    @RequiresPermissions("book-add")
    public String toAddition() {
        return "admin/book/add";
    }

    @RequestMapping("/addition")
    @RequiresPermissions("book-add")
    public String addBook(BookInfo bookInfo, String bookDesc, MultipartFile pictureFile, HttpServletRequest request) throws Exception {

        uploadPicture(bookInfo, pictureFile, request);
        bookInfoService.saveBook(bookInfo, bookDesc);

        return "redirect:/admin/book/list";
    }

    @RequestMapping(value = "/list")
    @RequiresPermissions("book-query")
    public String bookList(@RequestParam(defaultValue = "", required = false) String keywords,
                           @RequestParam(value = "page", defaultValue = "1", required = false) int page,
                           HttpSession session,
                           Model model) {
        keywords = keywords.trim();
        Store store = (Store) session.getAttribute("loginStore");

    @Autowired
    private ICartService cartService;

    @Autowired
    private IBookInfoService bookInfoService;

    /**
     * 填写订单信息页面
     *
     * @param bookId
     * @param buyNum
     * @param request
     * @return
     */
    @GetMapping("/info")
    public String orderInfo(@RequestParam(required = false, defaultValue = "0") int bookId,
                            @RequestParam(required = false, defaultValue = "0") int buyNum,
                            HttpServletRequest request) throws BSException {

        if (bookId != 0) {
            //点了立即购买，放到request域中，也session的立即购买域中以区分购物车中的书籍
            BookInfo bookInfo = bookInfoService.findById(bookId);
            if (bookInfo != null) {
                BSResult bsResult = cartService.addToCart(bookInfo, null, buyNum);
                request.getSession().setAttribute("buyNowCart", bsResult.getData());
                request.setAttribute("cart", bsResult.getData());
                return "order_info";
            } else {
                request.setAttribute("exception", "不好意思，书籍库存不足或不存在了！");
                return "exception";
            }
        }
        //没有点立即购买，购物车中的总金额大于0才让填写订单信息
        Cart cart = (Cart) request.getSession().getAttribute("cart");
        if (cart != null && cart.getTotal() > 0) {
            return "order_info";
        } else {
            return "cart";
        }

    }

    @GetMapping("/payPage/{orderId}")
    public String toPay(@PathVariable("orderId") String orderId, Model model) {

        BSResult bsResult = orderService.findOrderById(orderId);

@Controller
public class IndexController {

    @Autowired
    private IBookInfoService bookInfoService;

    @Autowired
    private IBookCateService cateService;

    @Autowired
    private WriteToMysql writeToMysql;

    @Value("${book.category}")
    private String BOOK_CATEGORY;

    private List<BookCategory> categoryList;

    /**
     * 第一次访问首页首页
     *
     * @return
     */
    @RequestMapping({"", "/", "/index"})
    public String index(Model model) {
        if(categoryList == null){

    @RequestMapping("/register")
    public String register(User user, Model model) {

        BSResult isExist = checkUserExist(user.getUsername());

        //尽管前台页面已经用ajax判断用户名是否存在，
        // 为了防止用户不是点击前台按钮提交表单造成的错误，后台也需要判断
        if ((Boolean) isExist.getData()) {
        	user.setActive("1");
            BSResult bsResult = userService.saveUser(user);
            //获得未激活的用户
            User userNotActive = (User) bsResult.getData();
          /*  try {
                mailService.sendHtmlMail(user.getEmail(), "<dd书城>---用户激活---",
                        "<html><body><a href='http://"+ip+"/user/active?activeCode=" + userNotActive.getCode() + "'>亲爱的" + user.getUsername() +
                                "，请您点击此链接前往激活</a></body></html>");
            } catch (Exception e) {
                e.printStackTrace();
                model.addAttribute("registerError", "发送邮件异常！请检查您输入的邮箱地址是否正确。");
                return "fail";
            }*/
            model.addAttribute("username", user.getUsername());
            return "register_success";
        } else {

            //用户名已经存在，不能注册
            model.addAttribute("registerError", isExist.getMessage());
            return "register";
        }

    }

    @RequestMapping("/active")
    public String activeUser(String activeCode, Model model) {
        BSResult bsResult = userService.activeUser(activeCode);
        if (!StringUtils.isEmpty(bsResult.getData())) {
            model.addAttribute("username", bsResult.getData());
            return "active_success";
        } else {
            model.addAttribute("failMessage", bsResult.getMessage());

    public String orderList(HttpServletRequest request){

        Store loginStore = (Store) request.getSession().getAttribute("loginStore");

        List<OrderCustom> orderCustoms = orderService.findOrdersByStoreId(loginStore.getStoreId());

        request.setAttribute("orderCustoms", orderCustoms);

        return "admin/order/list";
    }

    /**
     * 更新订单
     * @param orderId
     * @return
     */
    @RequestMapping("/toUpdate/{orderId}")
    @RequiresPermissions("order-edit")
    public String updateOrder(@PathVariable("orderId") String orderId, Model model) {

        OrderCustom orderCustom = orderService.findOrderCustomById(orderId);

        User buyer = userService.findById(orderCustom.getOrder().getUserId());
        model.addAttribute("orderCustom", orderCustom);
        model.addAttribute("buyer", buyer);
        return "admin/order/edit";
    }

    @RequestMapping("/update")
    @RequiresPermissions("order-edit")
    public String updateOrder(Orders order, OrderShipping orderShipping, Model model) {

        OrderCustom orderCustom = new OrderCustom();
        orderCustom.setOrder(order);
        orderCustom.setOrderShipping(orderShipping);
        orderService.updateOrder(orderCustom);
        model.addAttribute("saveMsg", "保存成功");
        return "forward:toUpdate/"+order.getOrderId();
    }

    @RequestMapping("/deletion/{orderId}")
    @RequiresPermissions("order-delete")
    public String deletion(@PathVariable("orderId") String orderId) {

        BSResult bsResult = orderService.deleteOrder(orderId);

        if (bsResult.getCode() == 200) {
            return "redirect:/admin/order/list";
        }
        return "exception";
    }

    @RequestMapping("/toEdit/{roleId}")
    @RequiresPermissions("privilege-edit")
    public String toEditPrivilege(@PathVariable("roleId") int roleId,Model model){
        model.addAttribute("roleId", roleId);
        return "admin/privilege/edit";
    }

    @ResponseBody
    @RequestMapping("/edit")
    @RequiresPermissions("privilege-edit")
    public BSResult editPrivilege(Privilege privilege){

        BSResult bsResult = privilegeService.updatePrivilege(privilege);

        return bsResult;
    }

    @RequestMapping("/list")
    @RequiresPermissions("privilege-list")
    public String privilegeList(){
        return "admin/privilege/list";
    }

    @RequestMapping("/addition")
    @ResponseBody
    @RequiresPermissions("privilege-add")
    public BSResult addPrivilege(Privilege privilege){
        //添加权限，仅有权限名字，之后再修改
        BSResult bsResult = privilegeService.addPrivilege(privilege);
        return bsResult;
    }

    @RequestMapping("/deletion/{privId}")
    @ResponseBody
    @RequiresPermissions("privilege-delete")
    public BSResult deletePrivilege(@PathVariable("privId") int privId){
        BSResult bsResult = privilegeService.deleteById(privId);
        return bsResult;
    }

}

@Controller
@RequestMapping("admin/order")
@RequiresPermissions("order-manage")
public class AdminOrderController {

    @Autowired
    private IOrderService orderService;

    @Autowired
    private IUserService userService;

    @RequestMapping("/list")
    @RequiresPermissions("order-list")
    public String orderList(HttpServletRequest request){

        Store loginStore = (Store) request.getSession().getAttribute("loginStore");

        List<OrderCustom> orderCustoms = orderService.findOrdersByStoreId(loginStore.getStoreId());

        request.setAttribute("orderCustoms", orderCustoms);

        return "admin/order/list";
    }

    /**
     * 更新订单