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

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

运行环境

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

开发工具

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

前端：WebStorm/VSCode/HBuilderX等均可

适用

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

功能说明

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

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

二、项目运行 环境配置：

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

项目技术：

Springboot + Maven + mybatis+ Vue 等等组成，B/S模式 + Maven管理等等。

    @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);
            }
            product.setStock(stock);
            productMapper.updateByPrimaryKeySelective(product);
        }
        //把购物车中的已勾选商品删除
        cleanCart(cartVOList);
        //生成订单
        Order order = new Order();
        //生成订单号
        String orderCode = OrderCodeFactory.getOrderCode(Long.valueOf(userId));
        order.setOrderNo(orderCode);
        order.setUserId(userId);
        order.setTotalPrice(totalPrice(orderItemList));
        order.setReceiverName(createOrderRequest.getReceiverName());
        order.setReceiverMobile(createOrderRequest.getReceiverMobile());
        order.setReceiverAddress(createOrderRequest.getReceiverAddress());
        order.setOrderStatus(Constant.OrderStatusEnum.NOT_PAID.getCode());
        order.setPostage(0);
        order.setPaymentType(1);
        //插入到Order表
        orderMapper.insertSelective(order);
        //循环保存每个商品到order_item表
        for (OrderItem orderItem : orderItemList) {
            orderItem.setOrderNo(order.getOrderNo());
            orderItemMapper.insertSelective(orderItem);
        }
        //返回结构

        File fileDirectory = new File(Constant.FILE_UPLOAD_DIR);
        File destFile = new File(Constant.FILE_UPLOAD_DIR + newFileName);

        if (!fileDirectory.exists()) {
            if (!fileDirectory.mkdir()) {
                throw new GobMallException(GobMallExceptionEnum.MKDIR_FAILED);
            }
        }

        try {
            file.transferTo(destFile);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            return ApiRestResponse.success(getHost(new URI(httpServletRequest.getRequestURL() + "")) + "/images/" + newFileName);
//            return ApiRestResponse.success(newFileName);
        } catch (Exception e) {
            return ApiRestResponse.error(GobMallExceptionEnum.UPLOAD_FAILED);
        }
    }

    private URI getHost(URI uri) {
        URI effectiveURI;
        try {
            effectiveURI = new URI(uri.getScheme(), uri.getUserInfo(), uri.getHost(), uri.getPort(), null, null, null);
        } catch (URISyntaxException e) {
            effectiveURI = null;
        }
        return effectiveURI;
    }

    @ApiOperation("后台更新商品")
    @PostMapping("/product/update")
    public ApiRestResponse updateProduct(@RequestBody @Valid UpdateProductReq updateProductReq) {
        productService.update(updateProductReq);
        return ApiRestResponse.success();
    }

    @ApiOperation("更新商品")
    @PostMapping("/product/updateState")
    public ApiRestResponse updateState(@RequestParam Integer id, @RequestParam Integer state) {
        productService.updateState(id,state);
        return ApiRestResponse.success();
    }
    @ApiOperation("后台删除商品")

        List<OrderVO> orderVOList = new ArrayList<>();
        for (Order order : orderList) {
            OrderVO orderVO = this.orderToOrderVO(order);
            orderVOList.add(orderVO);
        }
        return orderVOList;
    }

    /**
     * 判断订单是否存在且属于当前用户
     * @param orderNo 订单号
     * @return 如果订单存在且属于当前用户返回订单信息，否则抛出异常
     */
    private Order validOrder(String orderNo) {
        Order order = orderMapper.selectByOrderNO(orderNo);
        //判断订单是否存在
        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)

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

    @Override
    public void destroy() {
        // TODO Auto-generated method stub
    }
}
package cn.goodboyding.mall.controller;

/***
 * 前台商品Controller
 */
@RestController
@RequestMapping("/product")
public class ProductController {

    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;

/**
 * 管理员校验过滤器 ： 对需要管理员权限的接口进行过滤，过滤拦截没有权限的请求，并返回错误信息
 */
public class UserFilter implements Filter {

    public static ThreadLocal<User> currentUser = new ThreadLocal<>();

    @Autowired
    private UserService userService;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @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;

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

    @Override
    public void destroy() {
        // TODO Auto-generated method stub
    }
}
package cn.goodboyding.mall.controller;

/***
 * 前台商品Controller
 */
@RestController
@RequestMapping("/product")
public class ProductController {

    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    @ApiOperation("商品详情")
    @GetMapping("/detail")
    public ApiRestResponse detail(@RequestParam Integer id) {

        return "http://" + address + "/images/" + orderNo + ".png";
    }

    @Override
    public void pay(String orderNo) {
        Order oldOrder = this.isOrderNotNull(orderNo);
        if (!oldOrder.getOrderStatus().equals(Constant.OrderStatusEnum.NOT_PAID.getCode())) {
            throw new GobMallException(GobMallExceptionEnum.WRONG_ORDER_STATUS);
        }

        Order newOrder = new Order();
        newOrder.setId(oldOrder.getId());
        newOrder.setOrderStatus(Constant.OrderStatusEnum.PAID.getCode());
        newOrder.setPayTime(new Date());
        orderMapper.updateByPrimaryKeySelective(newOrder);

        File file = new File(Constant.FILE_UPLOAD_DIR + orderNo + ".png");
        if(true || file.delete()){
            log.info("订单" + orderNo + "支付二维码文件：" + Constant.FILE_UPLOAD_DIR + orderNo + ".png is delete");
        }else {
            log.error("订单" + orderNo + "支付二维码文件：" + Constant.FILE_UPLOAD_DIR + orderNo + ".png not create");
        }
    }

    @Override
    public PageInfo listForAdmin(Integer pageNum, Integer pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<Order> orderList = orderMapper.selectAll();
        List<OrderVO> orderVOList = this.orderListToOrderVOList(orderList);
        PageInfo pageInfo = new PageInfo<>(orderList);
        pageInfo.setList(orderVOList);
        return pageInfo;
    }

    @Override
    public void delivered(String orderNo) {
        Order oldOrder = this.isOrderNotNull(orderNo);
        if (!oldOrder.getOrderStatus().equals(Constant.OrderStatusEnum.PAID.getCode())) {
            throw new GobMallException(GobMallExceptionEnum.WRONG_ORDER_STATUS);
        }

        Order newOrder = new Order();
        newOrder.setId(oldOrder.getId());
        newOrder.setOrderStatus(Constant.OrderStatusEnum.DELIVERED.getCode());
        newOrder.setDeliveryTime(new Date());
        orderMapper.updateByPrimaryKeySelective(newOrder);
    }

    @Override
    public void finish(String orderNo) {

    }

    @ApiOperation("后台更新目录")
    @PostMapping("/admin/category/update")
    public ApiRestResponse<Object> updateCategory(@RequestBody @Valid UpdateCategoryReq updateCategoryReq) {
        Category category = new Category();
        BeanUtils.copyProperties(updateCategoryReq, category);
        categoryService.update(category);
        return ApiRestResponse.success();
    }

    @ApiOperation("后台删除目录")
    @PostMapping("/admin/category/delete")
    public ApiRestResponse<Object> deleteCategory(@RequestParam("id") Integer id) {
        categoryService.delete(id);
        return ApiRestResponse.success();
    }

    @ApiOperation("目录列表分页查询（管理员）")
    @GetMapping("admin/category/list")
    public ApiRestResponse<Object> listCategoryAdmin(@RequestParam("pageNum") Integer pageNum, @RequestParam("pageSize") Integer pageSize) {
        PageInfo<Category> pageInfo = categoryService.listForAdmin(pageNum, pageSize);
        return ApiRestResponse.success(pageInfo);
    }

    @ApiOperation("目录列表分页查询")
    @GetMapping("category/list")
    public ApiRestResponse<Object> listCategoryCustomer() {
        List<CategoryVO> categoryVos = categoryService.listCategoryForCustomer(0);
        return ApiRestResponse.success(categoryVos);
    }

    @GetMapping("/admin/category/listByType")
    public ApiRestResponse<Object> listByType(@RequestParam Integer type) {
        List<Category> categoryList = categoryService.listByType(type);
        return ApiRestResponse.success(categoryList);
    }

}
package cn.goodboyding.mall.controller;

    private final CartService cartService;
    private final ProductMapper productMapper;
    private final CartMapper cartMapper;
    private final OrderMapper orderMapper;
    private final OrderItemMapper orderItemMapper;

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

    public OrderServiceImpl(CartService cartService, ProductMapper productMapper, CartMapper cartMapper, OrderMapper orderMapper, OrderItemMapper orderItemMapper) {
        this.cartService = cartService;
        this.productMapper = productMapper;
        this.cartMapper = cartMapper;
        this.orderMapper = orderMapper;
        this.orderItemMapper = orderItemMapper;
    }

    /**
     * 判断商品状态是否可售且库存足够
     */
    private void validSaleStatusAndStock(List<CartVO> cartVOList) {
        for (CartVO cartVO : cartVOList) {
            Product product = productMapper.selectByPrimaryKey(cartVO.getProductId());
            if (product == null || product.getStatus().equals(Constant.SaleStatus.NOT_SALE)) {
                throw new GobMallException(GobMallExceptionEnum.NOT_SALE);
            }
            if (cartVO.getQuantity() > product.getStock()) {
                throw new GobMallException(GobMallExceptionEnum.NOT_ENOUGH);
            }
        }
    }

    /**
     * 将cartVO转换未OrderItem
     */
    private List<OrderItem> cartVOListToOrderItemList(List<CartVO> cartVOList) {
        List<OrderItem> orderItemList = new ArrayList<>();
        for (CartVO cartVO : cartVOList) {
            OrderItem orderItem = new OrderItem();
            //记录商品快照
            orderItem.setProductId(cartVO.getProductId());
            orderItem.setProductName(cartVO.getProductName());
            orderItem.setProductImg(cartVO.getProductImage());
            orderItem.setUnitPrice(cartVO.getPrice());

    }

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

    @Override
    public void destroy() {
        // TODO Auto-generated method stub
    }

    private ApiRestResponse<Object> handleBindingResult(BindingResult result) {
        //把异常处理为对外保留的提示
        List<String> list = new ArrayList<>();
        if (result.hasErrors()) {
            List<ObjectError> allErrors = result.getAllErrors();
            for (ObjectError error : allErrors) {
                String message = error.getDefaultMessage();
                list.add(message);
            }
        }

        if (list.size() == 0) {
            return ApiRestResponse.error(GobMallExceptionEnum.REQUEST_PARAM_ERROR);
        }

        return ApiRestResponse.error(GobMallExceptionEnum.REQUEST_PARAM_ERROR.getCode(), list.toString());
    }

}
package cn.goodboyding.mall.aspect;

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

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

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

    }

        order.setTotalPrice(totalPrice(orderItemList));
        order.setReceiverName(createOrderRequest.getReceiverName());
        order.setReceiverMobile(createOrderRequest.getReceiverMobile());
        order.setReceiverAddress(createOrderRequest.getReceiverAddress());
        order.setOrderStatus(Constant.OrderStatusEnum.NOT_PAID.getCode());
        order.setPostage(0);
        order.setPaymentType(1);
        //插入到Order表
        orderMapper.insertSelective(order);
        //循环保存每个商品到order_item表
        for (OrderItem orderItem : orderItemList) {
            orderItem.setOrderNo(order.getOrderNo());
            orderItemMapper.insertSelective(orderItem);
        }
        //返回结构
        return orderCode;
    }

    @Override
    public OrderVO detail(String orderNo) {
        Order order = validOrder(orderNo);
        return this.orderToOrderVO(order);
    }

    @Override
    public PageInfo listForCustomer(Integer pageNum, Integer pageSize) {
        Integer userId = UserFilter.currentUser.get().getId();
        PageHelper.startPage(pageNum, pageSize);
        List<Order> orderList = orderMapper.selectForCustomer(userId);
        List<OrderVO> orderVOList = this.orderListToOrderVOList(orderList);
        PageInfo pageInfo = new PageInfo<>(orderList);
        pageInfo.setList(orderVOList);
        return pageInfo;
    }

    @Override
    public void cancel(String orderNo) {
        Order order = validOrder(orderNo);

        if (order.getOrderStatus().equals(Constant.OrderStatusEnum.NOT_PAID.getCode())) {
            order.setOrderStatus(Constant.OrderStatusEnum.CANCELED.getCode());

            return ApiRestResponse.error(GobMallExceptionEnum.NEED_PASSWORD);
        }

        //保存用户信息时，不保存密码
        User user = userService.login(username, password);
        user.setPassword(null);

        session.setAttribute(Constant.GOB_MALL_USER, user);

        return ApiRestResponse.success(user);
    }

    /**
     * 更新个性签名
     */
    @ApiOperation("更新个性签名")
    @PostMapping("/user/update")
    public ApiRestResponse<Object> updateUserInfo(@RequestParam("signature") String signature, HttpSession session) throws GobMallException {
        User currentUser = (User) session.getAttribute(Constant.GOB_MALL_USER);
        if (currentUser == null) {
            return ApiRestResponse.error(GobMallExceptionEnum.NEED_LOGIN);
        }
        User user = new User();
        user.setId(currentUser.getId());
        user.setPersonalizedSignature(signature);

        userService.updateInformation(user);

        return ApiRestResponse.success();
    }

    /**
     * 退出登录
     */
    @ApiOperation("退出登录")
    @PostMapping("/user/logout")
    public ApiRestResponse<Object> logout(HttpSession session) {
        session.removeAttribute(Constant.GOB_MALL_USER);
        return ApiRestResponse.success();
    }

    /**
     * 管理员登录
     */
    @ApiOperation("管理员登录")
    @PostMapping("/admin/login")
    public ApiRestResponse<User> adminLogin(@RequestParam("username") String username, @RequestParam("password") String password, HttpSession session) throws GobMallException {
        if (StringUtils.isEmpty(username)) {
            return ApiRestResponse.error(GobMallExceptionEnum.NEED_USER_NAME);
        }
        if (StringUtils.isEmpty(password)) {
            return ApiRestResponse.error(GobMallExceptionEnum.NEED_PASSWORD);
        }

            orderItemVOList.add(orderItemVO);
        }
        orderVO.setOrderItemVOList(orderItemVOList);
        orderVO.setOrderStatusName(Constant.OrderStatusEnum.codeOf(order.getOrderStatus()).getValue());
        return orderVO;
    }

    /**
     * OrderList转OrderVOList
     */
    private List<OrderVO> orderListToOrderVOList(List<Order> orderList) {
        List<OrderVO> orderVOList = new ArrayList<>();
        for (Order order : orderList) {
            OrderVO orderVO = this.orderToOrderVO(order);
            orderVOList.add(orderVO);
        }
        return orderVOList;
    }

    /**
     * 判断订单是否存在且属于当前用户
     * @param orderNo 订单号
     * @return 如果订单存在且属于当前用户返回订单信息，否则抛出异常
     */
    private Order validOrder(String orderNo) {
        Order order = orderMapper.selectByOrderNO(orderNo);
        //判断订单是否存在
        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;
    }

    /**
     * 创建订单
     */

    }

    @ApiOperation("后台批量上下架")
    @PostMapping("/product/batchUpdateSellStatus")
    public ApiRestResponse batchUpdateSellStatus(@RequestParam Integer[] ids,@RequestParam Integer sellStatus) {
        productService.batchUpdateSellStatus(ids, sellStatus);
        return ApiRestResponse.success();
    }
    @ApiOperation("后台批量上下架")
    @PostMapping("/product/updateImgGuid")
    public ApiRestResponse batchUpdateSellStatus(@RequestParam String guid,@RequestParam Integer id) {
//    	productService.batchUpdateSellStatus(ids, sellStatus);
    	 productService.updateImg(id,guid);
    	return ApiRestResponse.success();
    }
    @ApiOperation("架")
    @PostMapping("/product/updateImgGuid1")
    public  ApiRestResponse updateImgGuid(@RequestParam String guid, @RequestParam int id) {
    	return ApiRestResponse.success();
    }
    @ApiOperation("后台商品列表")
    @PostMapping("/product/list")
    public ApiRestResponse list(@RequestParam Integer pageNum, @RequestParam Integer pageSize) {
        PageInfo pageInfo = productService.listForAdmin(pageNum, pageSize);
        return ApiRestResponse.success(pageInfo);
    }

}
package cn.goodboyding.mall.controller;

 *
 */
@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)) {
            return ApiRestResponse.error(GobMallExceptionEnum.NEED_USER_NAME);
        }
        if (StringUtils.isEmpty(password)) {
            return ApiRestResponse.error(GobMallExceptionEnum.NEED_PASSWORD);
        }

        //保存用户信息时，不保存密码
        User user = userService.login(username, password);
        user.setPassword(null);

/**
 * 订单service实现类
 */
@Service
public class OrderServiceImpl implements OrderService {