基于javaweb+mysql的springboot网上家具商城平台设计和实现(java+springboot+mysql+ssm+thymeleaf+html+maven)

最新推荐文章于 2024-08-10 12:01:06 发布

Java源码jdk

最新推荐文章于 2024-08-10 12:01:06 发布

阅读量643

点赞数 7

文章标签： java mysql spring boot

本文链接：https://blog.csdn.net/2301_81060432/article/details/136048658

版权

基于javaweb+mysql的springboot网上家具商城平台设计和实现(java+springboot+mysql+ssm+thymeleaf+html+maven)

私信源码获取及调试交流

运行环境

Java≥8、MySQL≥5.7

开发工具

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

适用

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

功能说明

基于javaweb的SpringBoot网上家具商城平台设计和实现(java+springboot+mysql+ssm+thymeleaf+html+maven)

主要技术：springmvc springboot mybatis mysql jquery layui 等技术

具体功能模块：

(1) 用户注册和登录登录功能：

①用户的注册功能 : 访问网站的人根据网站的提示注册自己的账户

②用户的登录功能 : 用户可以输入用户名和密码进行登录操作，当没有该账户的时候，提示错误，用户必须通过注册完成或者从数据库中获取才能进行会员权限级别的操作。登录成功之后可以购买商品，查询订单的详细信息

(2) 、个人信息的管理：

①用户信息的修改操作，其中包括会员名、密码、性别、联系方式 e-mail 和个人介绍等用户信息的修改操作。但是会员邮箱是绑定账号的，会员邮箱不能进行更改操作。

②订单管理操作：订单只能查询和删除操作，不能有修改操作，修改操作是属于管理员的权限。

③用户退出操作：当点击用户退出时，就会退出当前用户的登录状态，恢复到游客状态。

(3) 、商品的操作：

①搜索商品操作：当在 Search 栏输入想搜索的家居用品时，会使用模糊查询，搜索出客户想到查询的家居用品。

②商品列表展示：

③商品详细信息展示：

(4) 、购物车的管理操作：

①显示商品信息：当我们一进入购物车页面，就会显示出商品的详细信息，以及购物车界面的功能信息。

②修改商品的数量：用户可以自己输入不同数量的商品，当商品的数量变动时，商品的库存就会相应的减少，也会根据商品的数量得到购买这一种商品的金额小计。

③删除购物车中的商品：

④购物流程变动：

(5) 、订单管理操作：

①订单生成：进入结算中心，会提示用户已经登录成功并来到结算中心，然后在提交订单的时候生成了一份订单，会显示在确认订单页面。

②确认订单：当点击确认订单的时候会进入支付页面，那里会真正的付款操作。

③订单查询：在我的订单页面会显示订单的详细信息，我们可以查询我们想要的订单信息。

④订单管理：在我的订单页面会显示所有订单的信息，可以在那里删除订单，查询订单等。

后台管理员主要设计:

系统的后台是专门为管理家居商城系统的人员设计的，功能如下：

(1) 、超级管理员：拥有管理该系统的最大权限，他有两个特有的功能

①数据字典：可以对后台的不同分类的分类列表具有增删改查的操作。

②角色管理：将拥有不同权限的管理员分成不同的角色，每个不同角色有自己的权限，不能执行越权操作

(2) 、商品分类的管理：

①添加编辑分类：点击添加按钮，会跳转到分类添加页面，需要编写分类名称，分类描述信息。

2.删除分类：当点击删除按钮时，会弹出一个提醒框，当点击确定，删除分类，点击取消，保持原来不变。

(3) 、商品管理功能：

①查询商品 : 查询所有商品列表，还有通过商品的名称、商品的类别和价格区间查询

②添加修改商品 : 点击添加商品会转到添加商品页面，需要提供商品名称、商品图片、商 5 6 品类别、商品价格、库存数量、商品描述等内容。

④删除商品：删除商品。

给大家截一部分效果图吧

系统客户端首页:

登录注册以及后台用户管理:

后台商品信息管理:

功能选择:

用户信息管理修改:

    public void webLog() {
    }

    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        startTime.set(System.currentTimeMillis());

        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        // 记录下请求内容
        LOGGER.info("**************Start API Request**************");
        LOGGER.info("URL : " + request.getRequestURI().toString());
        LOGGER.info("HTTP_METHOD : " + request.getMethod());
        LOGGER.info("IP : " + request.getRemoteAddr());
        LOGGER.info("CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        LOGGER.info("ARGS : " + Arrays.toString(joinPoint.getArgs()));
    }

    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable {
        // 处理完请求，返回内容
        LOGGER.info("RESPONSE : " + ret);
        LOGGER.info("SPEND TIME : " + (System.currentTimeMillis() - startTime.get()));
        LOGGER.info("***************End API Request***************");
    }

}

public interface OrderService {

    /**

        return orderDao.findAll(pageable);
    }

    @Override
    public List<Order> findAllExample(Example<Order> example) {
        return orderDao.findAll(example);
    }

    @Override
    public void update(Order order) {
        orderDao.save(order);
    }

    @Override
    public int create(Order order) {
        Order order1 = orderDao.save(order);
        return order1.getId();
    }

    @Override
    public void delById(int id) {
        orderDao.delete(id);
    }

    /**
     * 查询订单项详情
     * @param orderId
     * @return
     */
    @Override
    public List<OrderItem> findItems(int orderId) {
        List<OrderItem> list = orderItemDao.findByOrderId(orderId);
        for (OrderItem orderItem : list) {
            Product product = productDao.findOne(orderItem.getProductId());
            orderItem.setProduct(product);
        }
        return list;
    }

    /**
     * 更改订单状态
     *
     * @param id
     * @param status
     */
    @Override
    public void updateStatus(int id, int status) {
        Order order = orderDao.findOne(id);
        order.setState(status);
        orderDao.save(order);

@RequestMapping("/admin/user")
public class AdminUserController {
    @Autowired
    private UserService userService;

    /**
     * 打开用户列表页面
     * @return
     */
    @RequestMapping("/toList.html")
    public String toList() {
        return "admin/user/list";
    }

    /**
     * 打开编辑页面
     * @param id
     * @param map
     * @return
     */
    @RequestMapping("/toEdit.html")
    public String toEdit(int id, Map<String, Object> map) {
        User user = userService.findById(id);
        map.put("user", user);
        return "admin/user/edit";
    }

    /**
     * 获取所有用户列表
     *
     * @param pageindex
     * @return
     */
    @ResponseBody
    @RequestMapping("/list.do")
    public ResultBean<List<User>> findAllUser(int pageindex,
                                              @RequestParam(value = "pageSize", defaultValue = "15") int pageSize) {
        Pageable pageable = new PageRequest(pageindex, pageSize, null);
        List<User> users = userService.findAll(pageable).getContent();
        return new ResultBean<>(users);
    }

    @ResponseBody
    @RequestMapping("/getTotal.do")
    public ResultBean<Integer> geTotal() {
        Pageable pageable = new PageRequest(1, 15, null);
        int total = (int) userService.findAll(pageable).getTotalElements();
        return new ResultBean<>(total);
    }

     * @return
     */
    Order findById(int id);

    /**
     * 分页查询所有
     *
     * @param pageable
     * @return
     */
    Page<Order> findAll(Pageable pageable);

    /**
     * 按条件查询
     *
     * @param example
     * @return
     */
    List<Order> findAllExample(Example<Order> example);

    /**
     * 更新
     *
     * @param order
     * @return
     */
    void update(Order order);

    /**
     * 创建
     *
     * @param order
     * @return
     */
    int create(Order order);

    /**
     * 根据Id删除
     *
     * @param id
     * @return
     */
    void delById(int id);

     *
     * @param id
     * @param status
     */
    void updateStatus(int id, int status);

    /**
     * 查找用户的订单列表
     *
     * @param request
     * @return
     */
    List<Order> findUserOrder(HttpServletRequest request);

    /**
     * 支付
     * @param orderId
     */
    void pay(int orderId);

    /**
     * 提交订单
     * @param name
     * @param phone
     * @param addr
     * @param request
     * @param response
     */
    void submit(String name, String phone, String addr, HttpServletRequest request, HttpServletResponse response) throws Exception;

    /**
     * 确认收货
     * @param orderId
     */
    void receive(int orderId);
}

        orderDao.updateState(STATE_WAITE_SEND,order.getId());
    }

    /**
     * 提交订单
     *
     * @param name
     * @param phone
     * @param addr
     * @param request
     * @param response
     */
    @Override
    @Transactional
    public void submit(String name, String phone, String addr, HttpServletRequest request, HttpServletResponse response) throws Exception {
        Object user = request.getSession().getAttribute("user");
        if (user == null)
            throw new LoginException("请登录！");
        User loginUser = (User) user;
        Order order = new Order();
        order.setName(name);
        order.setPhone(phone);
        order.setAddr(addr);
        order.setOrderTime(new Date());
        order.setUserId(loginUser.getId());
        order.setState(STATE_NO_PAY);
        List<OrderItem> orderItems = shopCartService.listCart(request);
        Double total = 0.0;
        order.setTotal(total);
        order = orderDao.save(order);
        for (OrderItem orderItem : orderItems) {
            orderItem.setOrderId(order.getId());
            total += orderItem.getSubTotal();
            orderItemDao.save(orderItem);
        }
        order.setTotal(total);
        orderDao.save(order);
        //重定向到订单列表页面
        response.sendRedirect("/mall/order/toList.html");
    }

    /**
     * 确认收货
     *
     * @param orderId
     */
    @Override
    public void receive(int orderId) {
        Order order = orderDao.findOne(orderId);
        if (order == null)
            throw new RuntimeException("订单不存在");
        orderDao.updateState(STATE_COMPLETE,order.getId());

     *
     * @param order
     * @return
     */
    void update(Order order);

    /**
     * 创建
     *
     * @param order
     * @return
     */
    int create(Order order);

    /**
     * 根据Id删除
     *
     * @param id
     * @return
     */
    void delById(int id);

    /**
     * 查询订单的订单项
     *
     * @param orderId
     * @return
     */
    List<OrderItem> findItems(int orderId);

    /**
     * 更改订单状态
     *
     * @param id
     * @param status
     */
    void updateStatus(int id, int status);

    /**
     * 查找用户的订单列表
     *
     * @param request
     * @return
     */
    List<Order> findUserOrder(HttpServletRequest request);

    /**
     * 支付

     * @return
     */
    @ResponseBody
    @RequestMapping("/checkUsername.do")
    public ResultBean<Boolean> checkUsername(String username){
        List<User> users = userService.findByUsername(username);
        if (users==null||users.isEmpty()){
            return new ResultBean<>(true);
        }
        return new ResultBean<>(false);
    }

    /**
     * 如发生错误 转发到这页面
     *
     * @param response
     * @param request
     * @return
     */
    @RequestMapping("/error.html")
    public String error(HttpServletResponse response, HttpServletRequest request) {
        return "error";
    }
}

/**
 * 统一异常处理
 * 在Controller中抛出的异常，GlobalExceptionHandler中定义的处理方法可以起作用
 * 其他的业务层异常也可以单独处理
 *
 */
@ControllerAdvice
public class GlobalExceptionHandler implements Serializable{

        return new ResultBean<>(products);
    }

    /**
     * 根据一级分类查询它所有的二级分类
     *
     * @param cid
     * @return
     */
    @ResponseBody
    @RequestMapping("/getCategorySec.do")
    public ResultBean<List<Classification>> getCategorySec(int cid) {
        List<Classification> list = classificationService.findByParentId(cid);
        return new ResultBean<>(list);
    }

    /**
     * 加购物车
     *
     * @param productId
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping("/addCart.do")
    public ResultBean<Boolean> addToCart(int productId, HttpServletRequest request) throws Exception {
        shopCartService.addCart(productId, request);
        return new ResultBean<>(true);
    }

    /**
     * 移除购物车
     *
     * @param productId
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping("/delCart.do")
    public ResultBean<Boolean> delToCart(int productId, HttpServletRequest request) throws Exception {
        shopCartService.remove(productId, request);
        return new ResultBean<>(true);
    }

    /**
     * 查看购物车商品
     *


@Controller
@RequestMapping("/product")
public class ProductController {
    @Autowired
    private ProductService productService;
    @Autowired
    private ClassificationService classificationService;
    @Autowired
    private ShopCartService shopCartService;

    /**
     * 获取商品信息
     *
     * @param id
     * @return
     */
    @RequestMapping("/get.do")
    public ResultBean<Product> getProduct(int id) {
        Product product = productService.findById(id);
        return new ResultBean<>(product);
    }

    /**
     * 打开商品详情页面
     *
     * @param id
     * @param map
     * @return
     */
    @RequestMapping("/get.html")
    public String toProductPage(int id, Map<String, Object> map) {
        Product product = productService.findById(id);
        map.put("product", product);


    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;
        // 支持跨域访问
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept,X-Custom-Header");
        response.setHeader("X-Powered-By", "SpringBoot");
        if ("option".equalsIgnoreCase(request.getMethod())) {
            responseJSON(response, new HashMap<>());
            return;
        }
        //除了拦截login.html 其他html都拦截
        StringBuffer url = request.getRequestURL();
        //System.out.println(url);
        String path = url.toString();
        // 只拦截这些类型请求
        if (path.endsWith(".do") || path.endsWith(".html")) {
            // 登录，图片不拦截
            if (path.endsWith("toLogin.html")
                    || path.endsWith("toRegister.html")
                    || path.endsWith("register.do")
                    || path.endsWith("login.do")
                    || path.endsWith("logout.do")
                    || path.endsWith("error.html")
                    || path.endsWith("checkUsername.do")
                    || path.indexOf("/mall/admin/product/img/") != -1
                    || path.endsWith("index.html")
                    || path.endsWith("classification/list.do")
                    || path.indexOf("product") != -1) {
                chain.doFilter(request, response);
            } else {
                processAccessControl(request, response, chain);
            }

        } else {
            //其他静态资源都不拦截
            chain.doFilter(request, response);
        }
    }

    /**
     * @param request

        String jsonStr = mapper.writeValueAsString(object);
        OutputStream out = response.getOutputStream();
        out.write(jsonStr.getBytes("UTF-8"));
        out.flush();
    }
}

@Controller
@RequestMapping("/admin/classification")
public class AdminClassificationController {
    @Autowired
    private ClassificationService classificationService;

    /**
     * 返回列表页面
     *
     * @param type
     * @return
     */
    @RequestMapping("/toList.html")
    public String toList(int type) {
        if (type == 1) {// 一级分类页面
            return "admin/category/list";
        } else if (type == 2) {// 二级分类页面
            return "admin/categorysec/list";
        } else {
            return "";
        }
    }

        Pageable pageable = new PageRequest(1, 15, null);
        int count = (int) classificationService.findAll(type, pageable).getTotalElements();
        return new ResultBean<>(count);
    }
}

/**
 */
@Service
public class ShopCartServiceImpl implements ShopCartService {

    @Autowired
    private ProductService productService;

    /**
     * 加购物车
     * 将商品id保存到Session中List<Integer>中
     *
     * @param productId
     * @param request
     */
    @Override
    public void addCart(int productId, HttpServletRequest request) throws Exception {
        User loginUser = (User) request.getSession().getAttribute("user");
        if (loginUser == null)
            throw new Exception("未登录！请重新登录");
        List<Integer> productIds = (List<Integer>) request.getSession().getAttribute(NAME_PREFIX + loginUser.getId());
        if (productIds == null) {
            productIds = new ArrayList<>();
            request.getSession().setAttribute(NAME_PREFIX + loginUser.getId(), productIds);
        }
        productIds.add(productId);
    }

    /**

                response.sendRedirect("/mall/user/toLogin.html");
            }else {
                chain.doFilter(request, response);
            }
        }
    }

    @Override
    public void destroy() {

    }

    /**
     * 返回JOSN数据格式
     *
     * @param response
     * @param object
     * @throws IOException
     */
    public static void responseJSON(HttpServletResponse response, Object object) throws IOException {
        response.setContentType("application/json;charset=utf-8");
        response.setCharacterEncoding("UTF-8");
        ObjectMapper mapper = new ObjectMapper();
        if (object == null)
            return;
        String jsonStr = mapper.writeValueAsString(object);
        OutputStream out = response.getOutputStream();
        out.write(jsonStr.getBytes("UTF-8"));
        out.flush();
    }
}

@Controller

            //其他静态资源都不拦截
            chain.doFilter(request, response);
        }
    }

    /**
     * @param request
     * @param response
     * @param chain
     * @throws IOException
     * @throws ServletException
     */
    private void processAccessControl(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        Object adminUser = request.getSession().getAttribute("login_user");
        Object user = request.getSession().getAttribute("user");
        String url = request.getRequestURL().toString();
        if (url.indexOf("admin") != -1){
            if (adminUser == null) {
                response.sendRedirect("/mall/admin/toLogin.html");
            }else {
                chain.doFilter(request, response);
            }
        }else {
            if (user == null) {
                response.sendRedirect("/mall/user/toLogin.html");
            }else {
                chain.doFilter(request, response);
            }
        }
    }

    @Override
    public void destroy() {

    }

    /**
     * 返回JOSN数据格式
     *
     * @param response
     * @param object
     * @throws IOException
     */
    public static void responseJSON(HttpServletResponse response, Object object) throws IOException {
        response.setContentType("application/json;charset=utf-8");
        response.setCharacterEncoding("UTF-8");

    /**
     * 按二级分类查找商品
     *
     * @param csId
     * @param pageNo
     * @param pageSize
     * @return
     */
    @ResponseBody
    @RequestMapping("/categorySec.do")
    public ResultBean<List<Product>> getCategorySecProduct(int csId, int pageNo, int pageSize) {
        Pageable pageable = new PageRequest(pageNo, pageSize);
        List<Product> products = productService.findByCsid(csId, pageable);
        return new ResultBean<>(products);
    }

    /**
     * 根据一级分类查询它所有的二级分类
     *
     * @param cid
     * @return
     */
    @ResponseBody
    @RequestMapping("/getCategorySec.do")
    public ResultBean<List<Classification>> getCategorySec(int cid) {
        List<Classification> list = classificationService.findByParentId(cid);
        return new ResultBean<>(list);
    }

    /**
     * 加购物车
     *
     * @param productId
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping("/addCart.do")
    public ResultBean<Boolean> addToCart(int productId, HttpServletRequest request) throws Exception {
        shopCartService.addCart(productId, request);
        return new ResultBean<>(true);
    }

    /**
     * 移除购物车
     *
     * @param productId


@Controller
@RequestMapping("/admin/order")
public class AdminOrderController {
    @Autowired
    private OrderService orderService;

    /**
     * 打开订单列表页面
     * @return
     */
    @RequestMapping("/toList.html")
    public String toList() {
        return "admin/order/list";
    }

    /**
     * 获取所有订单的总数
     * @return
     */
    @ResponseBody
    @RequestMapping("/getTotal.do")
    public ResultBean<Integer> getTotal() {
        Pageable pageable = new PageRequest(1, 15, null);
        int total = (int) orderService.findAll(pageable).getTotalElements();
        return new ResultBean<>(total);
    }

    /**
     * 获取所有订单
     * @param pageindex
     * @param pageSize
     * @return
     */
    @ResponseBody
    @RequestMapping("/list.do")

请添加图片描述

Java源码jdk

关注

7
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫