Java源码社

基于javaweb的SpringBoot+MyBatis网上商城项目(java+springboot+ssm+jsp+mysql+maven)

更新于

运行环境

Java≥8、MySQL≥5.7

开发工具

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

适用

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

功能说明

320023032402

330023032402

340023032402

350023032402

360023032402

370023032402

380023032402

基于javaweb的SpringBoot+MyBatis网上商城项目(java+springboot+ssm+jsp+mysql+maven)

一、项目简述

功能：网上商城系统，前台+后台管理，用户注册，登录, 上哦展示，分组展示，搜索，收货地址管理，购物车管 理，添加，购买，个人信息修改。订单查询等等，后台商 品管理，分类管理，库存管理，订单管理，用户管理，信 息、修改等等。

二、项目运行

环境配置： Jdk1.8 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持)

项目技术： JSP +SpringBoot+Spring + SpringMVC + MyBatis + html+ css + JavaScript + JQuery + Ajax + layui+ maven等等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
@RequestMapping(value = "review", method = RequestMethod.POST)
public String addReview(HttpSession session, Map<String, Object> map,
                        @RequestParam Integer orderItem_id,
                        @RequestParam String review_content) throws UnsupportedEncodingException {
    logger.info("检查用户是否登录");
    Object userId = checkUser(session);
    User user;
    if (userId != null) {
        logger.info("获取用户信息");
        user = userService.get(Integer.parseInt(userId.toString()));
        map.put("user", user);
    } else {
        return "redirect:/login";
    }
    logger.info("获取订单项信息");
    ProductOrderItem orderItem = productOrderItemService.get(orderItem_id);
    if (orderItem == null) {
        logger.warn("订单项不存在，返回订单页");
        return "redirect:/order/0/10";
    }
    if (!orderItem.getProductOrderItem_user().getUser_id().equals(userId)) {
        logger.warn("订单项与用户不匹配，返回订单页");
        return "redirect:/order/0/10";
    }
    if (orderItem.getProductOrderItem_order() == null) {
        logger.warn("订单项状态有误，返回订单页");
        return "redirect:/order/0/10";
    }
    ProductOrder order = productOrderService.get(orderItem.getProductOrderItem_order().getProductOrder_id());
    if (order == null || order.getProductOrder_status() != 3) {
        logger.warn("订单项状态有误，返回订单页");
        return "redirect:/order/0/10";
    }
    if (reviewService.getTotalByOrderItemId(orderItem_id) > 0) {
        logger.warn("订单项所属商品已被评价，返回订单页");
        return "redirect:/order/0/10";
    }
    logger.info("整合评论信息");
    Review review = new Review()
            .setReview_product(orderItem.getProductOrderItem_product())
            .setReview_content(review_content)
            .setReview_createDate(new Date())
            .setReview_user(user)
            .setReview_orderItem(orderItem);
    logger.info("添加评论");
    Boolean yn = reviewService.add(review);
    if (!yn) {
        throw new RuntimeException();
    }
    Product product = productService.get(review.getReview_product().getProduct_id());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
            user.getUser_id(), null
    );
    if (productOrderItemList != null) {
        logger.info("获取用户详情-购物车订单项对应的产品信息");
        for (ProductOrderItem productOrderItem : productOrderItemList) {
            Integer productId = productOrderItem.getProductOrderItem_product().getProduct_id();
            logger.warn("获取产品ID为{}的产品信息", productId);
            Product product = productService.get(productId);
            if (product != null) {
                logger.warn("获取产品ID为{}的第一张预览图片信息", productId);
                product.setSingleProductImageList(productImageService.getList(
                        productId, (byte) 0, new PageUtil(0, 1))
                );
            }
            productOrderItem.setProductOrderItem_product(product);
        }
    }
    user.setProductOrderItemList(productOrderItemList);

    if (user.getUser_realname() != null) {
        logger.info("用户隐私加密");
        user.setUser_realname(user.getUser_realname().substring(0, 1) + "*");
    } else {
        user.setUser_realname("未命名");
    }

    map.put("user",user);

    logger.info("转到后台管理-用户详情页-ajax方式");
    return "admin/include/userDetails";
}

//按条件查询用户-ajax
@ResponseBody
@RequestMapping(value = "admin/user/{index}/{count}", method = RequestMethod.GET, produces = "application/json;charset=UTF-8")
public String getUserBySearch(@RequestParam(required = false) String user_name/* 用户名称 */,
                              @RequestParam(required = false) Byte[] user_gender_array/* 用户性别数组 */,
                              @RequestParam(required = false) String orderBy/* 排序字段 */,
                              @RequestParam(required = false,defaultValue = "true") Boolean isDesc/* 是否倒序 */,
                              @PathVariable Integer index/* 页数 */,
                              @PathVariable Integer count/* 行数 */) throws UnsupportedEncodingException {
    //移除不必要条件
    Byte gender = null;
    if (user_gender_array != null && user_gender_array.length == 1) {
        gender = user_gender_array[0];
    }

    if (user_name != null) {
        //如果为非空字符串则解决中文乱码：URLDecoder.decode(String,"UTF-8");
        user_name = "".equals(user_name) ? null : URLDecoder.decode(user_name, "UTF-8");
    }
    if (orderBy != null && "".equals(orderBy)) {
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
       }
       category.setProductList(productList);
   }
    map.put("categoryList",categoryList);
    logger.info("获取促销产品列表");
    List<Product> specialProductList = productService.getList(
            null, new Byte[]{2}, null, new PageUtil(0, 6)
    );
    map.put("specialProductList", specialProductList);

    logger.info("转到前台主页");
    return "fore/homePage";
}

//转到前台天猫-错误页
@RequestMapping(value = "error", method = RequestMethod.GET)
public String goToErrorPage() {
    return "fore/errorPage";
}

//获取主页分类下产品信息-ajax
@ResponseBody
@RequestMapping(value = "product/nav/{category_id}", method = RequestMethod.GET, produces = "application/json;charset=utf-8")
public String getProductByNav(@PathVariable("category_id") Integer category_id) {
    JSONObject object = new JSONObject();
    if (category_id == null) {
        object.put("success", false);
        return object.toJSONString();
    }
    logger.info("获取分类ID为{}的产品标题数据", category_id);
    List<Product> productList = productService.getTitle(
            new Product().setProduct_category(new Category().setCategory_id(category_id)),
            new PageUtil(0, 40)
    );
    List<List<Product>> complexProductList = new ArrayList<>(8);
    List<Product> products = new ArrayList<>(5);
    for (int i = 0; i < productList.size(); i++) {
        //如果临时集合中产品数达到5个，加入到产品二维集合中，并重新实例化临时集合
        if (i % 5 == 0) {
            complexProductList.add(products);
            products = new ArrayList<>(5);
        }
        products.add(productList.get(i));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
        logger.warn("用户订单项与用户不匹配，回到购物车页");
        return "redirect:/cart";
    }
    if (orderItem.getProductOrderItem_order() != null) {
        logger.warn("用户订单项不属于购物车，回到购物车页");
        return "redirect:/cart";
    }
}
logger.info("验证通过，获取订单项的产品信息");
double orderTotalPrice = 0.0;
for (ProductOrderItem orderItem : orderItemList) {
    Product product = productService.get(orderItem.getProductOrderItem_product().getProduct_id());
    product.setProduct_category(categoryService.get(product.getProduct_category().getCategory_id()));
    product.setSingleProductImageList(productImageService.getList(product.getProduct_id(), (byte) 0, new PageUtil(0, 1)));
    orderItem.setProductOrderItem_product(product);
    orderTotalPrice += orderItem.getProductOrderItem_price();
}
String addressId = "110000";
String cityAddressId = "110100";
String districtAddressId = "110101";
String detailsAddress = null;
String order_post = null;
String order_receiver = null;
String order_phone = null;
Cookie[] cookies = request.getCookies();
if (cookies != null) {
    for (Cookie cookie : cookies) {
        String cookieName = cookie.getName();
        String cookieValue = cookie.getValue();
        switch (cookieName) {
            case "addressId":
                addressId = cookieValue;
                break;
            case "cityAddressId":
                cityAddressId = cookieValue;
                break;
            case "districtAddressId":
                districtAddressId = cookieValue;
                break;
            case "order_post":
                order_post = URLDecoder.decode(cookieValue, "UTF-8");
                break;
            case "order_receiver":
                order_receiver = URLDecoder.decode(cookieValue, "UTF-8");
                break;
            case "order_phone":
                order_phone = URLDecoder.decode(cookieValue, "UTF-8");
                break;
            case "detailsAddress":
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
if (cookies != null) {
    for (Cookie cookie : cookies) {
        String cookieName = cookie.getName();
        String cookieValue = cookie.getValue();
        switch (cookieName) {
            case "addressId":
                addressId = cookieValue;
                break;
            case "cityAddressId":
                cityAddressId = cookieValue;
                break;
            case "districtAddressId":
                districtAddressId = cookieValue;
                break;
            case "order_post":
                order_post = URLDecoder.decode(cookieValue, "UTF-8");
                break;
            case "order_receiver":
                order_receiver = URLDecoder.decode(cookieValue, "UTF-8");
                break;
            case "order_phone":
                order_phone = URLDecoder.decode(cookieValue, "UTF-8");
                break;
            case "detailsAddress":
                detailsAddress = URLDecoder.decode(cookieValue, "UTF-8");
                break;
        }
    }
}
logger.info("获取省份信息");
List<Address> addressList = addressService.getRoot();
logger.info("获取addressId为{}的市级地址信息", addressId);
List<Address> cityAddress = addressService.getList(null, addressId);
logger.info("获取cityAddressId为{}的区级地址信息", cityAddressId);
List<Address> districtAddress = addressService.getList(null, cityAddressId);

List<ProductOrderItem> productOrderItemList = new ArrayList<>();
productOrderItemList.add(productOrderItem);

map.put("orderItemList", productOrderItemList);
map.put("addressList", addressList);
map.put("cityList", cityAddress);
map.put("districtList", districtAddress);
map.put("orderTotalPrice", productOrderItem.getProductOrderItem_price());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
private ProductService productService;
@Resource(name = "productImageService")
private ProductImageService productImageService;
@Resource(name = "lastIDService")
private LastIDService lastIDService;

//转到后台管理-订单页-ajax
@RequestMapping(value = "admin/order", method = RequestMethod.GET)
public String goToPage(HttpSession session, Map<String, Object> map){
    logger.info("获取前10条订单列表");
    PageUtil pageUtil = new PageUtil(0, 10);
    List<ProductOrder> productOrderList =
            productOrderService.getList(
                    null,
                    null,
                    new OrderUtil("productOrder_id",
                            true), pageUtil);
    map.put("productOrderList",productOrderList);
    logger.info("获取订单总数量");
    Integer productOrderCount = productOrderService.getTotal(null, null);
    map.put("productOrderCount", productOrderCount);
    logger.info("获取分页信息");
    pageUtil.setTotal(productOrderCount);
    map.put("pageUtil", pageUtil);

    logger.info("转到后台管理-订单页-ajax方式");
    return "admin/orderManagePage";
}

//转到后台管理-订单详情页-ajax
@RequestMapping(value = "admin/order/{oid}", method = RequestMethod.GET)
public String goToDetailsPage(HttpSession session, Map<String, Object> map, @PathVariable Integer oid/* 订单ID */) {
    logger.info("获取order_id为{}的订单信息",oid);
    ProductOrder order = productOrderService.get(oid);
    logger.info("获取订单详情-地址信息");
    Address address = addressService.get(order.getProductOrder_address().getAddress_areaId());
    Stack<String> addressStack = new Stack<>();
    //详细地址
    addressStack.push(order.getProductOrder_detail_address());
    //最后一级地址

项目链接：
https://javayms.github.io?id=281422292105200fb
https://javayms.pages.dev?id=281422292105200fb