Java项目:水果商城系统(java+SSM+jsp+echarts+bootstrap+Mysql)

最新推荐文章于 2024-08-24 11:45:09 发布
最新推荐文章于 2024-08-24 11:45:09 发布
阅读量293 收藏 7
点赞数 5
分类专栏： Java毕业设计项目实战篇 文章标签： bootstrap java mysql ssm jsp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuyecsdn/article/details/125202725
版权

源码获取：俺的博客首页 "资源" 里下载！

项目介绍

本项目分为前后台，前台为普通用户登录，后台为管理员登录；
管理员角色包含以下功能：
管理员登录,类目管理,用户管理,商品管理,订单管理,发货管理,提交发货,公告管理,留言管理,日志查看等功能。

用户角色包含以下功能：
用户登录,用户首页,查看公告,提交留言,查看商品详情,加入购物车,商品结算等功能。

环境需要

1.运行环境：最好是java jdk 1.8
2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA;
3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可
4.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS； 
5.数据库：MySql 5.7版本；
6.是否Maven项目：是；


技术栈

1. 后端：Spring+SpringMVC+Mybatis
2. 前端：JSP+CSS+JavaScript+jquery+bootstrap+echarts


使用说明

1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件；
2. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;
若为maven项目，导入成功后请执行maven clean;maven install命令，然后运行；
3. 将项目中db.properties配置文件中的数据库配置改为自己的配置;
4. 运行项目，在浏览器中输入http://localhost:8080/fruitshop 登录
用户账号/密码： user/123456
管理员账号/密码：admin/admin


 

 

 

 

 

用户管理控制层：

/**
 * 用户和管理员控制层
 */
@Controller
public class UserController {
    @Resource(name = "userService")
    UserService userService;
    @Resource(name = "goodsCarService")
    GoodsCarService goodsCarService;
//    @Resource(name = "goodsService")
//    GoodsService goodsService;
    @Resource(name = "orderService")
    OrderService orderService;

    /**
     * 用户注册
     */
    @RequestMapping("/userRegister")
    @ResponseBody
    public Map<String, Object> doReg(String username, String password, String email, HttpServletRequest request) {
        Map<String, Object> map = new HashMap<String, Object>();
        User u = userService.findUserByUsername(username);
        if (u != null) {
            map.put("status", 1);
            map.put("message", "注册失败,该账户名已存在");
        } else {
            String id = App.getUid();
            int dr = 0;
            User user = new User(id, username, password, dr, email);
            int result = userService.doReg(user);
            if (result == 1) {
                HttpSession session = request.getSession();
                session.setAttribute("username", username);
                session.setAttribute("email", email);
                map.put("status", 0);
                map.put("message", "注册成功");
            }
        }
        return map;
    }

    /**
     * 用户登录
     * checked 为1 代表记住用户名，为0 代表忘记用户名
     */
    @RequestMapping("/userLogin")
    @ResponseBody
    public Map<String, Object> doLogin(String username, String pwd, String checkcode, int checked, HttpServletRequest request) {
        Map<String, Object> map = new HashMap<String, Object>();
        HttpSession session = request.getSession();
        String checkcode_server = (String) session.getAttribute("CHECKCODE");
        session.removeAttribute("CHECKCODE");//为了保证验证码只能使用一次
        User u = userService.findUserByUsername(username);
        if (u == null || u.getDr() == 1) {
            map.put("status", 1);
            map.put("message", "登录失败,请检查信息是否正确");
        } else {
            if (u.getPassword().equals(pwd) && checkcode.equalsIgnoreCase(checkcode_server)) {
                String userid = u.getId();
                List<Goodscar> goodscars = goodsCarService.findGoodscarByUserId(userid);
                App.goodscarList = goodscars;
                session.setAttribute("goodscarList", App.goodscarList);
                session.setAttribute("count", App.goodscarList.size());
                session.setAttribute("username", username);
                session.setAttribute("email", u.getEmail());
                List<Ordergoods> orders = new ArrayList<Ordergoods>();
                List<Ordergoods> ordersEndList = orderService.ordersEndListById(userid);
                if (ordersEndList.size()>0){
                    session.setAttribute("ordersEndListById",ordersEndList);
                }
                List<Ordergoods> gcs = orderService.selectOrderByuserId(u.getId());
                for (Ordergoods gs : gcs) {
                    orders.add(gs);
                }
                if (orders.size() > 0) {
                    session.setAttribute("orders", orders);
                }
                if (checked == 1) {
                    App.USERNAME = username;
                } else if (checked == 0) {
                    App.USERNAME = null;
                }
                map.put("status", 0);
                map.put("message", "登录成功");
            } else {
                map.put("status", 1);
                map.put("message", "登录失败,请检查信息是否正确");
            }
        }
        return map;
    }

    /**
     * 管理员登录
     * checked 为 1 代表记住用户名和密码，为0 反之
     */
    @RequestMapping("/userAdminLogin")
    @ResponseBody
    public Map<String, Object> adminLogin(String username, String password, int checked, HttpServletRequest request) {
        HttpSession session = request.getSession();
        Map<String, Object> map = new HashMap<String, Object>();
        User u = userService.findUserByUsername(username);
        if (u == null || u.getDr() == 0) {
            map.put("status", 1);
            map.put("message", "登录失败,请检查信息是否正确");
        } else {
            if (u.getPassword().equals(password)) {
                session.setAttribute("adminUsername", username);
                session.setAttribute("adminEmail", u.getEmail());
                if (checked == 1) {
                    App.ADMIN_USERNAME = username;
                    App.ADMIN_PASSWORD = password;
                } else if (checked == 0) {
                    App.ADMIN_USERNAME = null;
                    App.ADMIN_PASSWORD = null;
                }
                map.put("status", 0);
                map.put("message", "登录成功");
            } else {
                map.put("status", 1);
                map.put("message", "登录失败,请检查信息是否正确");
            }
        }
        return map;
    }

    /**
     * 管理员修改密码
     */
    @RequestMapping("/userAdminForgetPwd")
    @ResponseBody
    public Map<String, Object> adminForgetPwd(String username, String password, String email, String checkcode, HttpServletRequest request) {
        Map<String, Object> map = new HashMap<String, Object>();
        HttpSession session = request.getSession();
        String checkcode_server = (String) session.getAttribute("CHECKCODE");
        session.removeAttribute("CHECKCODE");//为了保证验证码只能使用一次
        User u = userService.findUserByUsername(username);
        if (u != null && checkcode.equalsIgnoreCase(checkcode_server) && email.equals(u.getEmail()) && u.getDr() == 1) {
            User user = new User(username, password);
            int result = userService.updatePassword(user);
            if (result == 1) {
                map.put("status", 0);
                map.put("message", "修改成功");
            } else {
                map.put("status", 1);
                map.put("message", "修改失败,请检查信息是否正确");
            }
        } else {
            map.put("status", 1);
            map.put("message", "修改失败,请检查信息是否正确");
        }
        return map;
    }

    /**
     * 用户修改密码
     */
    @RequestMapping("/userForgetPwd")
    @ResponseBody
    public Map<String, Object> forgetPwd(String username, String password, String email, String checkcode, HttpServletRequest request) {
        Map<String, Object> map = new HashMap<String, Object>();
        HttpSession session = request.getSession();
        String checkcode_server = (String) session.getAttribute("CHECKCODE");
        session.removeAttribute("CHECKCODE");//为了保证验证码只能使用一次
        User u = userService.findUserByUsername(username);
        if (u != null && checkcode.equalsIgnoreCase(checkcode_server) && email.equals(u.getEmail()) && u.getDr() == 0) {
            User user = new User(username, password);
            int result = userService.updatePassword(user);
            if (result == 1) {
                map.put("status", 0);
                map.put("message", "修改成功");
            } else {
                map.put("status", 1);
                map.put("message", "修改失败,请检查信息是否正确");
            }
        } else {
            map.put("status", 1);
            map.put("message", "修改失败,请检查信息是否正确");
        }
        return map;
    }

    /**
     * 用户退出
     */
    @RequestMapping("/userQuit")
    public String userQuit(HttpServletRequest request){
        HttpSession session = request.getSession();
        String auname = (String) session.getAttribute("adminUsername");
        if (auname == null){
            session.invalidate();
            App.goodscarList = null;
            App.ADDRESS = null;
            HttpSession session1 = request.getSession();
            session1.setAttribute("saveUsername", App.USERNAME);
        }else {
            session.removeAttribute("username");
            session.removeAttribute("saveUsername");
            session.removeAttribute("email");
            session.removeAttribute("goodsBrowse");
            session.removeAttribute("goodscarList");
            session.removeAttribute("count");
            session.removeAttribute("goodscarCount");
            session.removeAttribute("orders");
            session.removeAttribute("ordersEndListById");
            App.goodscarList = null;
            App.ADDRESS = null;
            session.setAttribute("saveUsername", App.USERNAME);
        }
        return "redirect:toIndex";
    }

    /**
     * 管理员退出
     */
    @RequestMapping("/userAdminQuit")
    public String userAdminQuit(HttpServletRequest request){
        HttpSession session = request.getSession();
//        session.invalidate();
        session.removeAttribute("adminUsername");
        session.removeAttribute("adminEmail");
        session.removeAttribute("saveadminUsername");
        session.removeAttribute("saveadminPassword");
        session.removeAttribute("ordersList");
        session.removeAttribute("ordersWaitList");
        session.removeAttribute("ordersEndList");
        session.setAttribute("saveadminUsername", App.ADMIN_USERNAME);
        session.setAttribute("saveadminPassword", App.ADMIN_PASSWORD);
        return "redirect:toAdminLogin";
    }
}

订单商品控制层： 

@Controller
public class OrdergoodsController {
    @Resource(name = "orderService")
    OrderService orderService;
    @Resource(name = "userService")
    UserService userService;
    @Resource(name = "goodsCarService")
    GoodsCarService goodsCarService;
    @Resource(name = "goodsService")
    GoodsService goodsService;

    /**
     * 取消订单
     */
    @RequestMapping("/cancelOrder")
    @ResponseBody
    public synchronized Map<String, Object> cancelOrder(String id,String username, HttpServletRequest request) {
        Map<String, Object> map = new HashMap<String, Object>();
        User us = userService.findUserByUsername(username);
        Ordergoods ordergoods = orderService.selectGoodsId(id);
        if (us.getDr() == 1){
            //管理员确定订单
            if (ordergoods != null && ordergoods.getDr() != 1){
                int result = orderService.orderEnsure(id);
                Ordergoods og = orderService.selectOrderById(id);
                Map<String, Object> map2 = new HashMap<String, Object>();
                double count = (og.getGoods().getCount()-og.getGoodscar().getCount());
                map2.put("id",og.getGoods().getId());
                map2.put("count",count);
                int result1 = goodsService.updateGoodsCount(map2);
                if (result==1 && result1==1){
                    HttpSession session = request.getSession();
                    List<Ordergoods> ordersWaitList = orderService.ordersWaitList();
                    session.setAttribute("ordersWaitList",ordersWaitList);
                    map.put("status", 0);
                    map.put("message", "发货成功");
                }else {
                    map.put("status", 1);
                    map.put("message", "发货失败");
                }
            }else {
                map.put("status", 1);
                map.put("message", "发货失败");
            }
        }else {
            //用户确定订单
            if (ordergoods != null && ordergoods.getDr() != 3){
                int result = orderService.cancelOrder(id);
                if (result == 1) {
                    Ordergoods or = orderService.selectGoodsId(id);
                    String goodscar_id = or.getGoodscarid();
                    int info = goodsCarService.updateGoodscarDr(goodscar_id);
                    if (info == 1) {
                        HttpSession session = request.getSession();
                        String uname = (String) session.getAttribute("username");
                        User u = userService.findUserByUsername(uname);
                        List<Ordergoods> orders = new ArrayList<Ordergoods>();
                        List<Ordergoods> gcs = orderService.selectOrderByuserId(u.getId());
                        for (Ordergoods gs : gcs) {
                            orders.add(gs);
                        }
                        session.setAttribute("orders", orders);
                        List<Goodscar> goodscars = goodsCarService.findGoodscarByUserId(u.getId());
                        App.goodscarList = goodscars;
                        session.setAttribute("goodscarList", App.goodscarList);
                        session.setAttribute("count", App.goodscarList.size());
                        map.put("status", 0);
                        map.put("message", "订单取消成功");
                        return map;
                    }
                }
            }
            map.put("status", 1);
            map.put("message", "订单取消失败");
        }
        return map;
    }

    /**
     * 添加地址
     */
    @RequestMapping("/addressOver")
    @ResponseBody
    public Map<String, Object> addressOver(String address, String ids, HttpServletRequest request) {
        Map<String, Object> map = new HashMap<String, Object>();
        String[] gcids = ids.split(",");
        Map<String, Object> map1 = new HashMap<String, Object>();
        map1.put("address",address);
        map1.put("gcids",gcids);
        int result = orderService.addAddress(map1);
        if (result <= 0){
            map.put("status", 1);
            map.put("message", "添加地址失败");
        }else {
            App.ADDRESS = address;
            HttpSession session = request.getSession();
            session.setAttribute("address",App.ADDRESS);
            map.put("status", 0);
            map.put("message", "添加地址成功");
        }
        return map;
    }

    /**
     * 全部的订单列表
     */
    @RequestMapping("/ordersList")
    @ResponseBody
    public Map<String, Object> ordersList(HttpServletRequest request){
        Map<String, Object> map = new HashMap<String, Object>();
        HttpSession session = request.getSession();
        List<Ordergoods> ordersList = orderService.ordersList();
        if (ordersList.size()<=0){
            map.put("status", 1);
            map.put("message", "暂无订单");
        }else {
            session.setAttribute("ordersList",ordersList);
            map.put("status", 0);
            map.put("message", "订单查询成功");
        }
        return map;
    }

    /**
     * 待发货的订单
     */
    @RequestMapping("/ordersWaitList")
    @ResponseBody
    public Map<String, Object> ordersWaitList(HttpServletRequest request){
        Map<String, Object> map = new HashMap<String, Object>();
        HttpSession session = request.getSession();
        List<Ordergoods> ordersWaitList = orderService.ordersWaitList();
        if (ordersWaitList.size()<=0){
            session.setAttribute("ordersWaitList",ordersWaitList);
            map.put("status", 1);
            map.put("message", "暂无订单");
        }else {
            session.setAttribute("ordersWaitList",ordersWaitList);
            map.put("status", 0);
            map.put("message", "订单查询成功");
        }
        return map;
    }

    /**
     * 已发货的订单
     */
    @RequestMapping("/ordersEndList")
    @ResponseBody
    public Map<String, Object> ordersEndList(HttpServletRequest request){
        Map<String, Object> map = new HashMap<String, Object>();
        HttpSession session = request.getSession();
        List<Ordergoods> ordersEndList = orderService.ordersEndList();
        if (ordersEndList.size()<=0){
            map.put("status", 1);
            map.put("message", "暂无订单");
        }else {
            session.setAttribute("ordersEndList",ordersEndList);
            map.put("status", 0);
            map.put("message", "订单查询成功");
        }
        return map;
    }

//    /**
//     * 进行发货
//     */
//    @RequestMapping("/orderEnsure")
//    @ResponseBody
//    public Map<String, Object> orderEnsure(String id,String reserved1,HttpServletRequest request){
//        Map<String, Object> map = new HashMap<String, Object>();
//        HttpSession session = request.getSession();
//        int result = orderService.orderEnsure(id);
//        if (result == 1){
//            map.put("status", 0);
//            map.put("message", "发货成功");
//        }else {
//            map.put("status", 1);
//            map.put("message", "发货失败");
//        }
//        return map;
//    }
}

商品管理控制层：

@Controller
public class GoodsController {
    @Resource(name = "goodsService")
    GoodsService goodsService;

    List<Goods> gdsList = null;

    List<Goods> goodsBrowse;

    public GoodsController() {
        goodsBrowse = new ArrayList<Goods>();
    }

    /**
     * 分页查询商品列表信息
     */
    @RequestMapping("/goodsList")
    @ResponseBody
    public Map<String, Object> goodsList(int currentPage, String search) {
        Map<String, Object> resultMap = new HashMap<String, Object>();
        PageBean<Goods> pageBean = new PageBean<Goods>();
        int pageSize = 5;
        int start = (currentPage - 1) * pageSize;
        int size = pageSize;
        if (search == "" || search == null) {
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("start",start);
            map.put("size",size);
            List<Goods> lists = goodsService.findByPage(map);
//            List<Goods> list = goodsService.selectCount();
            int count = goodsService.selectCount();
            if (count <= 0) {
                resultMap.put("status", 1);
                resultMap.put("message", "没有数据");
                resultMap.put("result", null);
            } else {
                int totalCount = count;
                double tc = totalCount;
                int totalPage = (int) Math.ceil(tc / pageSize);
                pageBean.setCurrentage(currentPage);
                pageBean.setPageSize(pageSize);
                pageBean.setTotalCount(totalCount);
                pageBean.setTotalPage(totalPage);
                pageBean.setLists(lists);
                resultMap.put("status", 0);
                resultMap.put("message", "有数据");
                resultMap.put("result", pageBean);
            }
        } else {
//            String search1 = "";
//            search1 += ("%" + search + "%");
//            System.out.println(search1);
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("start",start);
            map.put("size",size);
            map.put("search",search);
            List<Goods> lists = goodsService.findByPageSearch(map);
//            List<Goods> list = goodsService.selectSearchCount(search1);
            int count = goodsService.selectSearchCount(search);
            if (count <= 0) {
                resultMap.put("status", 1);
                resultMap.put("message", "没有数据");
                resultMap.put("result", null);
            } else {
                int totalCount = count;
                double tc = totalCount;
                int totalPage = (int) Math.ceil(tc / pageSize);
                pageBean.setCurrentage(currentPage);
                pageBean.setPageSize(pageSize);
                pageBean.setTotalCount(totalCount);
                pageBean.setTotalPage(totalPage);
                pageBean.setLists(lists);
                resultMap.put("status", 0);
                resultMap.put("message", "有数据");
                resultMap.put("result", pageBean);
            }
        }
        return resultMap;
    }

    /**
     * 添加商品
     */
    @RequestMapping("/addGoods")
    @ResponseBody
    public Map<String, Object> addGoods(MultipartFile file, Goods goods) {
        Map<String, Object> map = new HashMap<String, Object>();
        try {
            //获取文件名
            String pname = file.getOriginalFilename();
            //获取文件格式
            String type = pname.substring(pname.lastIndexOf("."));
            //重命名
            String photo_name = App.getUid() + type;
            //将图片存到指定的位置
            //windows系统配置图片路径
            file.transferTo(new File("D:\\project\\fresh\\GoodsPhoto", photo_name));
            //mac系统配置图片路径
            //file.transferTo(new File("/Users/hanmeng/Desktop/java源码/Springboot生鲜水果商城/源码/GoodsPhoto", photo_name));
            //将图片信息存入商品对象
            goods.setPhoto(photo_name);
            //商品id
            goods.setId(App.getUid());
            //商品状态
            goods.setDr(1);
            int i = goodsService.addGoods(goods);
            if (i == 1) {
                map.put("status", 0);
                map.put("message", "添加成功");
            } else {
                map.put("status", 1);
                map.put("message", "添加失败");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return map;
    }

    /**
     * 分页查询上架或下架商品列表信息
     */
    @RequestMapping("/goodsTypeList")
    @ResponseBody
    public Map<String, Object> goodsTypeList(int currentPage, String search, int typeDr) {
        Map<String, Object> resultMap = new HashMap<String, Object>();
        PageBean<Goods> pageBean = new PageBean<Goods>();
        int pageSize = 5;
        int start = (currentPage - 1) * pageSize;
        int size = pageSize;
        if (search == "" || search == null) {
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("start",start);
            map.put("size",size);
            map.put("typeDr",typeDr);
            List<Goods> lists = goodsService.findByPageDr(map);
//            List<Goods> list = goodsService.selectCountDr(typeDr);
            int count = goodsService.selectCountDr(typeDr);
            if (count <= 0) {
                resultMap.put("status", 1);
                resultMap.put("message", "没有数据");
                resultMap.put("result", null);
            } else {
                int totalCount = count;
                double tc = totalCount;
                int totalPage = (int) Math.ceil(tc / pageSize);
                pageBean.setCurrentage(currentPage);
                pageBean.setPageSize(pageSize);
                pageBean.setTotalCount(totalCount);
                pageBean.setTotalPage(totalPage);
                pageBean.setLists(lists);
                resultMap.put("status", 0);
                resultMap.put("message", "有数据");
                resultMap.put("result", pageBean);
            }
        } else {
//            String search1 = "";
//            search1 += ("%" + search + "%");
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("start",start);
            map.put("size",size);
            map.put("typeDr",typeDr);
            map.put("search",search);
            List<Goods> lists = goodsService.findByPageSearchDr(map);
            Map<String, Object> map1 = new HashMap<String, Object>();
            map1.put("typeDr",typeDr);
            map1.put("search",search);
//            List<Goods> list = goodsService.selectSearchCountDr(map1);
            int count = goodsService.selectSearchCountDr(map1);
            if (count <= 0) {
                resultMap.put("status", 1);
                resultMap.put("message", "没有数据");
                resultMap.put("result", null);
            } else {
                int totalCount = count;
                double tc = totalCount;
                int totalPage = (int) Math.ceil(tc / pageSize);
                pageBean.setCurrentage(currentPage);
                pageBean.setPageSize(pageSize);
                pageBean.setTotalCount(totalCount);
                pageBean.setTotalPage(totalPage);
                pageBean.setLists(lists);
                resultMap.put("status", 0);
                resultMap.put("message", "有数据");
                resultMap.put("result", pageBean);
            }
        }
        return resultMap;
    }

    /**
     * 商品上架
     */
    @RequestMapping("/goodsUp")
    @ResponseBody
    public Map<String, Object> goodsUp(String id) {
        Map<String, Object> map = new HashMap<String, Object>();
        int result = goodsService.goodsUp(id);
        if (result == 1) {
            map.put("status", 0);
            map.put("message", "上架成功");
        } else {
            map.put("status", 1);
            map.put("message", "上架失败");
        }
        return map;
    }

    /**
     * 商品下架
     */
    @RequestMapping("/goodsDown")
    @ResponseBody
    public Map<String, Object> goodsDown(String id) {
        Map<String, Object> map = new HashMap<String, Object>();
        int result = goodsService.goodsDown(id);
        if (result == 1) {
            map.put("status", 0);
            map.put("message", "下架成功");
        } else {
            map.put("status", 1);
            map.put("message", "下架失败");
        }
        return map;
    }

    /**
     * 商品删除
     */
    @RequestMapping("/goodsDelete")
    @ResponseBody
    public Map<String, Object> goodsDelete(String id) {
        Map<String, Object> map = new HashMap<String, Object>();
        int result = goodsService.goodsDelete(id);
        if (result == 1) {
            map.put("status", 0);
            map.put("message", "删除成功");
        } else {
            map.put("status", 1);
            map.put("message", "删除失败");
        }
        return map;
    }

    /**
     * 商品批量删除
     */
    @RequestMapping("/deleteAll")
    @ResponseBody
    public Map<String, Object> deleteAll(String ids) {
        Map<String, Object> map = new HashMap<String, Object>();
        String[] id_s = ids.split(",");
        int result = goodsService.deleteAll(id_s);
        if (result >= 1) {
            map.put("status", 0);
            map.put("message", "删除成功");
        } else {
            map.put("status", 1);
            map.put("message", "删除失败");
        }
        return map;
    }

    /**
     * 管理员查看商品详情
     */
    @RequestMapping("/goodsDetail")
    @ResponseBody
    public Map<String, Object> goodsDetail(String photo) {
        Map<String, Object> map = new HashMap<String, Object>();
        Goods goods = goodsService.goodsDetail(photo);
        if (goods != null) {
            map.put("status", 0);
            map.put("message", "加载成功");
            map.put("result", goods);
        } else {
            map.put("status", 1);
            map.put("message", "加载失败");
            map.put("result", null);
        }
        return map;
    }

    /**
     * 加载商品信息
     */
    @RequestMapping("/loadGoods")
    @ResponseBody
    public Map<String, Object> loadGoods(String id) {
        Map<String, Object> map = new HashMap<String, Object>();
        Goods goods = goodsService.loadGoods(id);
        if (goods != null) {
            map.put("status", 0);
            map.put("message", "加载编辑成功");
            map.put("result", goods);
        } else {
            map.put("status", 1);
            map.put("message", "加载编辑失败");
            map.put("result", null);
        }
        return map;
    }

    /**
     * 商品编辑
     */
    @RequestMapping("/goodsUpdate")
    @ResponseBody
    public Map<String, Object> goodsUpdate(String id, String price, String count) {
        Map<String, Object> map = new HashMap<String, Object>();
        double price_double = Double.parseDouble(price);
        double count_double = Double.parseDouble(count);
        Map<String, Object> map1 = new HashMap<String, Object>();
        map1.put("id",id);
        map1.put("price",price_double);
        map1.put("count",count_double);
        int result = goodsService.goodsUpdate(map1);
        if (result == 1) {
            map.put("status", 0);
            map.put("message", "编辑成功");
        } else {
            map.put("status", 1);
            map.put("message", "编辑失败");
        }
        return map;
    }

    /**
     * 商品主页加载
     */
    @RequestMapping("/indexList")
    @ResponseBody
    public Map<String, Object> indexList() {
        Map<String, Object> map = new HashMap<String, Object>();
        List<Goods> goodslist = goodsService.indexList();
        if (goodslist.size() <= 0) {
            map.put("status", 1);
            map.put("message", "暂无上架商品");
            map.put("result", null);
        } else {
            map.put("status", 0);
            map.put("message", "正在加载，请稍后");
            map.put("result", goodslist);
        }
        return map;
    }

    /**
     * 查看更多
     */
//    @RequestMapping("/readMore")
//    public String readMore(String groupid, Model model) {
//        List<Goods> goodslist = goodsService.readMore(groupid);
//        if (goodslist.size() <= 0) {
//            return "redirect:toIndex";
//        } else {
//            List<Goods> goodsPart = new ArrayList<Goods>();
//            if (goodslist.size()>=2){
//                goodsPart.add(goodslist.get(goodslist.size() - 2));
//                goodsPart.add(goodslist.get(goodslist.size() - 1));
//            }else if((goodslist.size()==1)){
//                goodsPart.add(goodslist.get(goodslist.size() - 1));
//            }
//            model.addAttribute("groupid", groupid);
//            model.addAttribute("goodsPart", goodsPart);
//            model.addAttribute("goodslist", goodslist);
//        }
//        return "readmoreShop";
//    }
    @RequestMapping("/readMore")
    @ResponseBody
    public Map<String, Object> readMore(String groupid) {
        Map<String, Object> map = new HashMap<String, Object>();
        List<Goods> goodslist = goodsService.readMore(groupid);
        if (goodslist.size() <= 0) {
            map.put("status",1);
            map.put("message","抱歉没有相关的商品");
        } else {
            map.put("status",0);
            map.put("message","商品展现成功");
            gdsList = goodslist;
        }
        return map;
    }

    @GetMapping("/readMoreByMessage")
    public String readMoreByMessage(String groupid, Model model){
        List<Goods> goodslist = goodsService.readMore(groupid);
        List<Goods> goodsPart = new ArrayList<Goods>();
        if (goodslist.size()>=2){
            goodsPart.add(goodslist.get(goodslist.size() - 2));
            goodsPart.add(goodslist.get(goodslist.size() - 1));
        }else if((goodslist.size()==1)){
            goodsPart.add(goodslist.get(goodslist.size() - 1));
        }
        model.addAttribute("groupid", groupid);
        model.addAttribute("goodsPart", goodsPart);
        model.addAttribute("goodslist", goodslist);
        return "readmoreShop";
    }

    @RequestMapping("/readMoreSecond")
    public String readMoreSecond(String groupid, Model model){
        if (gdsList!=null){
            List<Goods> goodsPart = new ArrayList<Goods>();
            if (gdsList.size()>=2){
                goodsPart.add(gdsList.get(gdsList.size() - 2));
                goodsPart.add(gdsList.get(gdsList.size() - 1));
            }else if((gdsList.size()==1)){
                goodsPart.add(gdsList.get(gdsList.size() - 1));
            }
            model.addAttribute("groupid", groupid);
            model.addAttribute("goodsPart", goodsPart);
            model.addAttribute("goodslist", gdsList);
            return "readmoreShop";
        }
        return null;
    }

    /**
     * 用户查看商品详情
     */
    @RequestMapping("/shopMessage")
    public String shopMessage(String id, Model model, HttpServletRequest request) {
        HttpSession session = request.getSession();
        Goods goods = goodsService.shopMessage(id);
        if (goods == null) {
            return "redirect:toIndex";
        } else {
            if (goodsBrowse.size() >= 1) {
                for (int i = 0; i < goodsBrowse.size(); i++) {
                    if (goods.getName().equals(goodsBrowse.get(i).getName())) {
                        goodsBrowse.remove(i);
                    }
                }
            }
            goodsBrowse.add(goods);
            if (goodsBrowse.size() > 4) {
                goodsBrowse.remove(0);
            }
            session.setAttribute("goodsBrowse", goodsBrowse);
            String groupid = goods.getGroupid();
            List<Goods> goodslist = goodsService.readMore(groupid);
            List<Goods> goodsNews = new ArrayList<Goods>();
            if (goodslist.size()>=2){
                goodsNews.add(goodslist.get(goodslist.size() - 2));
                goodsNews.add(goodslist.get(goodslist.size() - 1));
            }else if(goodslist.size()==1){
                goodsNews.add(goodslist.get(goodslist.size() - 1));
            }
            model.addAttribute("goodsNews", goodsNews);
            model.addAttribute("goods", goods);
        }
        return "shop_message";
    }

    /**
     * 商品主页搜索
     */
    @RequestMapping("/goodsSearch")
    public String goodsSearch(String search, Model model) {
        if (search == "" || search == null) {
            return "redirect:toNoPage";
        }
        List<Goods> goodslist = goodsService.goodsSearch(search);
        if (goodslist.size() <= 0) {
            return "redirect:toNoPage";
        } else {
            model.addAttribute("goodslist", goodslist);
        }
        return "searchmoreShop";
    }
}

源码获取：俺的博客首页 "资源" 里下载！ 

beyondwild
关注
专栏目录
java web项目，在线水果商城
07-10
java web课程设计，在线水果商城。如果选择用户登陆，则进入商品购买系统，首页为各个商品并且在首页可以进行用户登陆和新用户的注册，用户登陆或者注册之后，进行商品的购买，点击商品可以进入一个商品详情界面，提供立即购买和加入购物车功能，点击立即购买会提示支付成功，不提供详细支付功能，点击加入购物车可以把该商品加入购物车，可以点击查看我的购物车来查看自己购物车的商品，可以对购物车内的商品进行支付和删除。 如果选择管理员登陆，需要输入命令来获取管理员权限，命令输入成功之后进入管理员界面，管理员可以对用户和商品信息进行增删改查，进入用户信息管理界面，可以看到已经注册的用户，可以对其进行修改信息，也可以增加用户，进入商品信息管理界面，可以对商品信息进行修改，也可以删除和添加。
java ssm 水果商城项目
weixin_44577346的博客
05-12 471
水果商城项目中pom.xml配置如下 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVers
SSM水果商城系统 毕业设计-附源码
最新发布
无所谓^_^博客
08-24 815
包含：源码➕数据库脚本➕万字文档➕答辩PPT 开发语言：Java 框架：ssm JDK版本：JDK1.8 服务器：tomcat 数据库：mysql 依赖管理包：Maven 代码、数据库以及文档（文档包括系统相关技术的介绍、系统的需求分析、系统的设计【有数据库设计、ER图、功能图等】、系统的实现和测试等）
基于springboot的水果商城系统
weixin_mtyeducation
10-13 1095
该水果商城系统基于springboot，数据层为MyBatis，mysql数据库。
水果商城Java
12-27
基于Java，JSP，数据库，等编写的小型水果商城网站，适合初学者
Java项目:鞋子商城系统(java+SSM+JSP+layui+bootstrap+echarts+Mysql)
06-24
项目介绍 本项目分为管理员与用户两种角色； 管理员角色包含以下功能： 管理员登录,商品管理,订单...2. 前端：JSP+css+javascript+bootstrap+jQuery+layui+echarts 使用说明 1. 使用Navicat或者其它工具，在mysql
Java项目:家具商城系统(java+SSM+JSP+bootstrap+echarts+mysql)
06-07
项目介绍 本项目分为前后台，前台为普通用户登录，后台为管理员登录；...2. 前端：JSP+CSS+JavaScript+jquery+bootstrap+echarts 使用说明 1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导
水果商城系统
04-18
水果商城系统(JSP+java+springmvc+mysql+MyBatis)
梁凯毕设程序
01-08 470
随着人们生活水平的提高和对健康饮食的追求，越来越多的人选择在网上购买水果。因此，水果商城系统应运而生。这种系统可以有效地提高消费者对水果信息的获取和管理效率，减少人为错误，提高服务质量。同时，信息技术的使用也使得系统的开发和维护变得更加简单和高效。+ Maven +mysql5.7或8.0+html+css+js等等组成，B/S模式 + Maven管理等等。用户发送请求：用户通过浏览器或其他客户端向系统发送请求，请求访问特定的页面或执行特定的操作。后端程序接收到请求后，根据请求的类型和参数进行相应的处理。
水果销售商城系统+论文+源码 jsp ssh mvc java web j2ee毕业设计
01-18
水果销售商城系统+论文+源码 jsp ssh mvc java web j2ee毕业设计
Java实战项目 - 网上商城交易系统（源码,内有详细配置文件），--- J2EE
01-13
Java实战项目 - 网上商城交易系统（源码,内有详细配置文件），--- J2EE
水果商城.rar
05-13
购物网站，功能实现代码，没有用到模板，有实现用户登录注册、商品添加删除修改、运用servlet-css-mysql-javabean,附有测试文档和需求文档
基于Java+SSM+MySQL的水果商城系统
毕业作品网站
10-30 1343
开发一个基于Web的网上商城，采用结构化设计分析方法，该系统包括前台购物和后台管理两大总的模块，后台管理模块又包括分类录入水果（以及水果的相关信息，如名称、单价、摘要、目录等）和管理前台用户，前台管理模块包括用户登录，查询、浏览水果，以及购物功能。(8) 水果网站管理员对水果进行分类管理功能，该功能包括添加水果、修改水果、删除水果、添加水果类型、修改水果类型、删除水果类型并且显示出所有的水果类型和水果信息（如编号、名称等）。(5) 查看水果相信信息功能，通过浏览到的水果，对水果进行详细信息浏览。
水果商城系统-基于SSM
WenF1998的博客
05-25 1516
项目介绍 基于SSM的水果商城系统 功能模块 项目分为用户、管理员两种角色。 用户可以在线浏览水果，加购物车，下单评论等操作，管理员可以发布水果、管理水果类别，管理用户，管理留言，管理评价，管理订单等。 项目环境 1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。 2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA; 3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可 4.硬件环境：windows.
SpringBoot+jsp实现水果商城系统（含源码+数据库+文档）
热门推荐
程序员小王的博客
06-04 1万+
这是一个基于SpringBoot+JSP+Mybatsi实现水果商城系统。
基于Java+Vue水果商城系统设计和实现(源码+LW+部署讲解)
java李阳勇的博客
05-19 1002
网络购物作为一种全新的销售方式赢得了越来越多销售者的青睐,近年来销售额更是以连年翻番的惊人速度成倍增长.网络购物已经形成了自身特有的网络销售市场和全新的网络营销模式,也使网络营销渠道应运而生.同时,伴随着水果市场的不断扩大,水果行业内的竞争日趋激烈,网络营销渠道的出现给一向以渠道致胜的水果行业带来了机遇和挑战.首先是快速更新水果商城的信息，其次是大量信息的管理，最后是高度安全，以及使用简单等特性，这使得水果商城系统的管理和运营非常方便。
基于javaweb+mysql的springboot+mybatis在线水果商城系统(springboot+spring+springmvc+mybatis+html+mysql+redis)
m0_56289293的博客
08-26 254
功能： 区分为管理员用户和普通用户，普通用户：用户注册登录，首页水果展示，商品分类展示，购物车添加，下单，订单查询，个人信息修改，管理员用户：包括水果基本信息维护增删改查，分类管理，订单管理，用户管理等等功能。基于javaweb+mysql的springboot+mybatis在线水果商城系统(springboot+spring+springmvc+mybatis+html+mysql+redis)课程设计，大作业，毕业设计，项目练习，学习演示等。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

beyondwild

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值