Java源码社

基于javaweb的SpringBoot水果生鲜商城系统(java+springboot+maven+mybatis+vue+mysql+redis)

更新于

运行环境

Java≥8、MySQL≥5.7、Node.js≥14

开发工具

后端：eclipse/idea/myeclipse/sts等均可配置运行
前端：WebStorm/VSCode/HBuilderX等均可

❗没学过node.js的不要搞前后端分离项目

适用

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

功能说明

170023372402

180023372402

190023372402

200023372402

210023372402

220023372402

基于javaweb的SpringBoot水果生鲜商城系统(java+springboot+maven+mybatis+vue+mysql+redis)

一、项目简述 本系统功能包括： 商品的分类展示，用户的注册登录，购物车，订单结算，购物车加减，后台商品管理，分类管理，订单管理等等功能。

二、项目运行 环境配置：

Jdk1.8 + Mysql + HBuilderX（Webstorm也行）+ Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）。

项目技术：

Springboot + Maven + mybatis+ Vue 等等组成，B/S模式 + 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



/**
 * 描述： 用户控制器
 *
 */
@RestController
public class UserController {

    @Autowired
    UserService userService;

    /**
     * 注册
     */
    @ApiOperation("注册")
    @PostMapping("register")
    public ApiRestResponse<Object> register(@RequestParam("username") String username, @RequestParam("password") String password) throws GobMallException {
        if (StringUtils.isEmpty(username)) {
            return ApiRestResponse.error(GobMallExceptionEnum.NEED_USER_NAME);
        }
        if (StringUtils.isEmpty(password)) {
            return ApiRestResponse.error(GobMallExceptionEnum.NEED_PASSWORD);
        }
        //密码长度不能少于八位
        if (password.length() < 8) {
            return ApiRestResponse.error(GobMallExceptionEnum.PASSWORD_TOO_SHORT);
        }

        userService.register(username, password);
        return ApiRestResponse.success();
    }

    /**
     * 登录
     */
    @ApiOperation("登录")
    @PostMapping("login")
    public ApiRestResponse<User> login(@RequestParam("username") String username, @RequestParam("password") String password, HttpSession session) throws GobMallException {
        if (StringUtils.isEmpty(username)) {
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

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

        User currentUser = UserHandler.checkUserLogin(request, response);

        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        if (currentUser != null) {
            UserFilter.currentUser.set(currentUser);

            chain.doFilter(request,response);
        }


    }

    @Override
    public void destroy() {

    }
}
package cn.goodboyding.mall.util;



public class UserHandler {

    public static User checkUserLogin(ServletRequest request, ServletResponse response) throws IOException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
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

/**
 * api请求日志处理切面
 */
@Aspect
@Component
public class WebLogAspect {

    private final Logger log = LoggerFactory.getLogger(WebLogAspect .class);

    @Pointcut("execution(public * cn.goodboyding.mall.controller.*.*(..))")
    public void webLog() {

    }

    /**
     * 请求前收集请求参数并记录
     */
    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) {
        //收到请求信息，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        log.info("URL : " + request.getRequestURL().toString());
        log.info("HTTP_METHOD ： " + request.getMethod());
        log.info("IP : " + request.getRemoteAddr());
        log.info("ClASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        log.info("ARGS : " + Arrays.toString(joinPoint.getArgs()));
    }

    /**
     * 请求后收集响应结果并记录
     */
    @AfterReturning(returning = "res",pointcut = "webLog()")
    public void doAfterReturning(Object res) throws JsonProcessingException {
        //处理完请求返回内容
        log.info("RESPONSE : " + new ObjectMapper().writeValueAsString(res));
    }

}
package cn.goodboyding.mall.filter;

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


/**
 * 购物车控制器
 */
@RestController
@RequestMapping("/cart")
public class CartController {

    private final CartService cartService;

    public CartController(CartService cartService) {
        this.cartService = cartService;
    }

    @ApiOperation("购物车列表")
    @GetMapping("/list")
    public ApiRestResponse list() {
        List<CartVO> list = cartService.list(UserFilter.currentUser.get().getId());
        return ApiRestResponse.success(list);
    }

    @ApiOperation("购物车中选中商品")
    @GetMapping("/list/selected")
    public ApiRestResponse listOfSelected() {
        List<CartVO> cartVOList = cartService.listOfSelected(UserFilter.currentUser.get().getId());
        return ApiRestResponse.success(cartVOList);
    }

    @ApiOperation("添加商品到购物车")
    @PostMapping("/add")
    public ApiRestResponse add(@RequestParam Integer productId, @RequestParam Integer count) {

        if (count < 0) {
            throw new GobMallException(GobMallExceptionEnum.REQUEST_PARAM_ERROR);
        }
        List<CartVO> cartVOList = cartService.add(UserFilter.currentUser.get().getId(), productId, count);
        return ApiRestResponse.success(cartVOList);
    }

    @ApiOperation("更新购物车信息")
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
    //判断订单是否存在
    if (order == null) {
        throw new GobMallException(GobMallExceptionEnum.ORDER_EXISTED);
    }
    //判断是否是该用户的订单
    Integer userId = UserFilter.currentUser.get().getId();
    if (!order.getUserId().equals(userId)) {
        throw new GobMallException(GobMallExceptionEnum.NOT_YOUR_ORDER);
    }
    return order;
}

/**
 * 订单是否未空
 * @param orderNo 订单号
 * @return 不未空返回对应订单，否则抛出异常
 */
private Order isOrderNotNull(String orderNo) {
    Order oldOrder = orderMapper.selectByOrderNO(orderNo);
    if (oldOrder == null) {
        throw new GobMallException(GobMallExceptionEnum.ORDER_EXISTED);
    }
    return oldOrder;
}

/**
 * 创建订单
 */
//数据库事务，遇到任何异常都会回滚
@Transactional(rollbackFor = Exception.class)
@Override
public String create(CreateOrderRequest createOrderRequest) {

    //拿到用户id
    Integer userId = UserFilter.currentUser.get().getId();
    //从购物车查找已勾选的商品
    List<CartVO> cartVOList = cartService.list(userId);
    cartVOList = cartVOList.stream().filter(cartVO -> cartVO.getSelected().equals(Constant.Cart.CHECKED)).collect(Collectors.toList());
    if (CollectionUtils.isEmpty(cartVOList)) {
        throw new GobMallException(GobMallExceptionEnum.CART_EMPTY);
    }
    //判断商品是否存在，上下架状态，库存
    validSaleStatusAndStock(cartVOList);
    //把购物车对象转为订单item对象
    List<OrderItem> orderItemList = cartVOListToOrderItemList(cartVOList);
    //扣库存
    for (OrderItem orderItem : orderItemList) {
        Product product = productMapper.selectByPrimaryKey(orderItem.getProductId());
        int stock = product.getStock() - orderItem.getQuantity();
        if (stock < 0) {
            throw new GobMallException(GobMallExceptionEnum.NOT_ENOUGH);
        }
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
                out.flush();
                out.close();
            }
        }

    }

    @Override
    public void destroy() {

    }
}
package cn.goodboyding.mall.filter;


public class CorsFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) {
        // TODO Auto-generated method stub
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        if (request instanceof HttpServletRequest) {
            String []  allowDomain= {"http://localhost:81","http://localhost:8081","http://192.168.43.69","http://192.168.43.69:8080"};
            Set<String> allowedOrigins= new HashSet<String>(Arrays.asList(allowDomain));
            String originHeader=((HttpServletRequest) request).getHeader("Origin");
            if (!allowedOrigins.contains(originHeader)) {
                originHeader = "http://localhost";
            }
            HttpServletResponse httpServletResponse = (HttpServletResponse) response;
            httpServletResponse.setHeader("Access-Control-Allow-Origin", originHeader);
            httpServletResponse.setHeader("Access-Control-Allow-Methods",
                    "POST, GET, PUT, OPTIONS, DELETE");
            httpServletResponse.setHeader("Access-Control-Max-Age", "3600");
            httpServletResponse.setHeader("Access-Control-Allow-Headers",
                    "Content-Type, x-requested-with, X-Custom-Header, Authorization");
            httpServletResponse.setHeader("Access-Control-Allow-Credentials", "true");
        }
        chain.doFilter(request, response);
    }

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