• Java项目：基于jsp+mysql+Spring+mybatis的SSM在线网络图书商城

    作者主页：夜未央5788

     简介：Java领域优质创作者、Java项目、学习资料、技术互助

    文末获取源码

    项目介绍

    本项目分为前后台，有管理员与用户两种角色；
    管理员角色包含以下功能：
    管理员登录,商品分类管理,商品管理,商品属性管理,商品参数管理,订单管理,退款管理,退货管理,会员等级管理,客户信息管理,评论管理,文章分类管理,公告管理,文章管理,滚动图片管理,广告管理,热门查询管理,查询订单销售,查询商品销售,用户管理,角色管理,资源管理,修改密码,区域管理,配送方式管理,查看系统设置,缓存管理,查询到货通知等功能。

    用户角色包含以下功能：

    用户登录,查看首页,查看商品详情,查看购物车,提交订单,修改个人信息,修改密码,查看我的订单,添加配送地址,查看收藏夹等功能。

    环境需要

    1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。
    2.IDE环境：Eclipse；注:本项目目前仅支持Eclipse,暂不支持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+Mbytes

    2. 前端：Freemarker+css+javascript+bootstrap+jQuery

    使用说明

    1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件；
    2. 使用Eclipse导入项目，将项目中src目录下的conf.properties配置文件中的数据库配置改为自己的配置;
    3. 运行项目，在浏览器中输入localhost:8080/ssm_zxbookshop
    用户账号/密码： user/123456
    管理员账号/密码：admin/admin

    运行截图
    用户角色

     

     

     

     

     

     

     

    管理员角色

     

     

     

     

     

     

     

     

     

     

     

    相关代码

    BaseController

    1. package net.jeeshop.web.action;
    2.  
    3. import net.jeeshop.core.Services;
    4. import net.jeeshop.core.dao.page.PagerModel;
    5. import net.jeeshop.core.front.SystemManager;
    6. import net.jeeshop.web.util.RequestHolder;
    7. import org.slf4j.Logger;
    8. import org.slf4j.LoggerFactory;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.ui.ModelMap;
    11. import org.springframework.web.bind.annotation.ModelAttribute;
    12. import org.springframework.web.bind.annotation.RequestMapping;
    13. import org.springframework.web.bind.annotation.RequestMethod;
    14. import org.springframework.web.bind.annotation.ResponseBody;
    15. import org.springframework.web.servlet.mvc.support.RedirectAttributes;
    16.  
    17. import javax.servlet.http.HttpServletRequest;
    18.  
    19. /**
    20.  * Created by dylan on 15-2-2.
    21.  * @author dylan
    22.  */
    23. public abstract class BaseControllerextends PagerModel> {
    24.  
    25.     protected Logger logger = LoggerFactory.getLogger(getClass());
    26.     protected String page_toList = null;
    27.     protected String page_toEdit = null;
    28.     protected String page_toAdd = null;
    29.     public abstract Services getService();
    30.  
    31.     @Autowired
    32.     protected SystemManager systemManager;
    33.  
    34.     /**
    35.      * 后台左边导航菜单的初始化查询方法
    36.      */
    37.     protected void initPageSelect() {
    38.         logger.error("initPageSelect..init=n!");
    39.     }
    40.  
    41.     /**
    42.      * 初始化查询的时候，会清除所有的查询参数(所以在e中的)，但可以设置不在e中的参数，然后在此方法中进行e.setXxx(参数)的方式进行保留。
    43.      */
    44.     protected void setParamWhenInitQuery(E e) {
    45.         //BaseAction 的子类如有初始化页面的时候进行相关查询 ，则可以实现此方法。
    46.     }
    47.  
    48.     /**
    49.      * 公共的分页方法
    50.      *
    51.      * @return
    52.      * @throws Exception
    53.      */
    54.     @RequestMapping("selectList")
    55.     public String selectList(HttpServletRequest request, @ModelAttribute("e") E e) throws Exception {
    56.         /**
    57.          * 由于prepare方法不具备一致性，加此代码解决init=y查询的时候条件不被清除干净的BUG
    58.          */
    59.         this.initPageSelect();
    60.  
    61.         setParamWhenInitQuery(e);
    62.  
    63.         int offset = 0;//分页偏移量
    64.         if (request.getParameter("pager.offset") != null) {
    65.             offset = Integer.parseInt(request.getParameter("pager.offset"));
    66.         }
    67.         if (offset < 0) offset = 0;
    68.         e.setOffset(offset);
    69.         PagerModel pager = getService().selectPageList(e);
    70.         if (pager == null) {
    71.             pager = new PagerModel();
    72.         }
    73.         // 计算总页数
    74.         pager.setPagerSize((pager.getTotal() + pager.getPageSize() - 1)  / pager.getPageSize());
    75.  
    76.         selectListAfter(pager);
    77.         request.setAttribute("pager", pager);
    78.         return page_toList;
    79.     }
    80.  
    81.     @RequestMapping("toEdit")
    82.     public String toEdit(@ModelAttribute("e") E e, ModelMap model) throws Exception {
    83.         e = getService().selectOne(e);
    84. //		if(e==null || StringUtils.isBlank(e.getId())){
    85. //			throw new NullPointerException("");
    86. //		}
    87.         model.addAttribute("e", e);
    88.         return page_toEdit;
    89.     }
    90.  
    91.     @RequestMapping("toAdd")
    92.     public String toAdd(@ModelAttribute("e") E e, ModelMap model) throws Exception {
    93.         e.clear();
    94.         return page_toAdd;
    95.     }
    96.  
    97.     /**
    98.      * 子类必须要实现的方法当分页查询后.
    99.      * 解决了用户先点击新增按钮转到新增页面,然后点击返回按钮返回后,再点分页控件出错的BUG.
    100.      * 原因是分页查询后未将pageUrl重新设置为正确的URL所致
    101.      */
    102.     protected void selectListAfter(PagerModel pager) {
    103.         pager.setPagerUrl("selectList");
    104.     }
    105.  
    106.     /**
    107.      * 返回到查询页面
    108.      *
    109.      * @return
    110.      * @throws Exception
    111.      */
    112.     @RequestMapping("back")
    113.     public String back(@ModelAttribute("e") E e, ModelMap model) throws Exception {
    114.         return selectList(RequestHolder.getRequest(), e);
    115.     }
    116.  
    117.     /**
    118.      * 公共的批量删除数据的方法，子类可以通过重写此方法实现个性化的需求。
    119.      *
    120.      * @return
    121.      * @throws Exception
    122.      */
    123.     @RequestMapping(value = "deletes", method = RequestMethod.POST)
    124.     public String deletes(HttpServletRequest request, String[] ids, @ModelAttribute("e") E e, RedirectAttributes flushAttrs) throws Exception {
    125. //		User user = (User) getSession().getAttribute(Global.USER_INFO);
    126. //		if(user==null){
    127. //			throw new NullPointerException();
    128. //		}
    129. //		if(user.getDbPrivilegeMap()!=null && user.getDbPrivilegeMap().size()>0){
    130. //			if(user.getDbPrivilegeMap().get(Container.db_privilege_delete)==null){
    131. //				throw new PrivilegeException(Container.db_privilege_delete_error);
    132. //			}
    133. //		}
    134.  
    135.         getService().deletes(ids);
    136.         addMessage(flushAttrs, "操作成功！");
    137.         return "redirect:selectList";
    138.     }
    139.  
    140.     /**
    141.      * 公共的更新数据的方法，子类可以通过重写此方法实现个性化的需求。
    142.      *
    143.      * @return
    144.      * @throws Exception
    145.      */
    146.     @RequestMapping(value = "update", method = RequestMethod.POST)
    147.     public String update(HttpServletRequest request, @ModelAttribute("e") E e, RedirectAttributes flushAttrs) throws Exception {
    148. //		User user = (User) getSession().getAttribute(Global.USER_INFO);
    149. //		if(user==null){
    150. //			throw new NullPointerException();
    151. //		}
    152. //		if(user.getDbPrivilegeMap()!=null && user.getDbPrivilegeMap().size()>0){
    153. //			if(user.getDbPrivilegeMap().get(Container.db_privilege_update)==null){
    154. //				throw new PrivilegeException(Container.db_privilege_update_error);
    155. //			}
    156. //		}
    157.  
    158.         getService().update(e);
    159.         insertAfter(e);
    160.         addMessage(flushAttrs, "操作成功！");
    161.         return "redirect:selectList";
    162.     }
    163.  
    164.     /**
    165.      * insert之后，selectList之前执行的动作，一般需要清除添加的E，否则查询会按照E的条件进行查询.
    166.      * 部分情况下需要保留某些字段，可以选择不清除
    167.      *
    168.      * @param e
    169.      */
    170.     protected void insertAfter(E e){
    171.     }
    172.  
    173.     /**
    174.      * 公共的插入数据方法，子类可以通过重写此方法实现个性化的需求。
    175.      *
    176.      * @return
    177.      * @throws Exception
    178.      */
    179.     @RequestMapping(value = "insert",method = RequestMethod.POST)
    180.     public String insert(HttpServletRequest request, @ModelAttribute("e") E e, RedirectAttributes flushAttrs) throws Exception {
    181. //		User user = (User) getSession().getAttribute(Global.USER_INFO);
    182. //		if(user==null){
    183. //			throw new NullPointerException();
    184. //		}
    185. //		if(user.getDbPrivilegeMap()!=null && user.getDbPrivilegeMap().size()>0){
    186. //			if(user.getDbPrivilegeMap().get(Container.db_privilege_insert)==null){
    187. //				throw new PrivilegeException(Container.db_privilege_insert_error);
    188. //			}
    189. //		}
    190.  
    191.         getService().insert(e);
    192.         insertAfter(e);
    193.         addMessage(flushAttrs, "操作成功！");
    194.         return "redirect:selectList";
    195.     }
    196.  
    197.     /**
    198.      * 跳转到编辑页面
    199.      *
    200.      * @return
    201.      * @throws Exception
    202.      */
    203. //    @RequestMapping("toEdit")
    204. //    public String toEdit(@ModelAttribute("e") E e, ModelMap model) throws Exception {
    205. //        e = getService().selectOne(e);
    206. 		if(e==null || StringUtils.isBlank(e.getId())){
    207. 			throw new NullPointerException("");
    208. 		}
    209. //        return toEdit;
    210. //    }
    211.  
    212. //    @RequestMapping("toAdd")
    213. //    public String toAdd(@ModelAttribute("e") E e, ModelMap model) throws Exception {
    214. //        e.clear();
    215. //        return toAdd;
    216. //    }
    217.  
    218.  
    219.     @RequestMapping("loadData")
    220.     @ResponseBody
    221.     public PagerModel loadData(HttpServletRequest request, E e){
    222.         int offset = 0;
    223.         int pageSize = 10;
    224.         if (request.getParameter("start") != null) {
    225.             offset = Integer
    226.                     .parseInt(request.getParameter("start"));
    227.         }
    228.         if (request.getParameter("length") != null) {
    229.             pageSize = Integer
    230.                     .parseInt(request.getParameter("length"));
    231.         }
    232.         if (offset < 0)
    233.             offset = 0;
    234.         if(pageSize < 0){
    235.             pageSize = 10;
    236.         }
    237.         e.setOffset(offset);
    238.         e.setPageSize(pageSize);
    239.         PagerModel pager = getService().selectPageList(e);
    240.         pager.setRecordsTotal(pager.getTotal());
    241.         pager.setRecordsFiltered(pager.getTotal());
    242.         return pager;
    243.     }
    244.     protected void addMessage(ModelMap modelMap, String message) {
    245.         modelMap.addAttribute("message", message);
    246.     }
    247.     protected void addWarning(ModelMap modelMap, String warning) {
    248.         modelMap.addAttribute("warning", warning);
    249.     }
    250.     protected void addError(ModelMap modelMap, String warning) {
    251.         modelMap.addAttribute("errorMsg", warning);
    252.     }
    253.     protected void addMessage(RedirectAttributes flushAttrs, String message) {
    254.         flushAttrs.addFlashAttribute("message", message);
    255.     }
    256.     protected void addWarning(RedirectAttributes flushAttrs, String warning) {
    257.         flushAttrs.addFlashAttribute("warning", warning);
    258.     }
    259.     protected void addError(RedirectAttributes flushAttrs, String warning) {
    260.         flushAttrs.addFlashAttribute("errorMsg", warning);
    261.     }
    262. }

    CommonController

    1. package net.jeeshop.web.action;
    2.  
    3. import net.jeeshop.core.front.SystemManager;
    4. import net.jeeshop.core.util.ImageUtils;
    5. import net.jeeshop.services.common.SystemSetting;
    6. import net.sf.json.JSONObject;
    7. import org.slf4j.Logger;
    8. import org.slf4j.LoggerFactory;
    9. import org.springframework.stereotype.Controller;
    10. import org.springframework.web.bind.annotation.RequestMapping;
    11. import org.springframework.web.bind.annotation.RequestParam;
    12. import org.springframework.web.bind.annotation.ResponseBody;
    13. import org.springframework.web.multipart.MultipartFile;
    14.  
    15. import java.io.File;
    16. import java.text.SimpleDateFormat;
    17. import java.util.Arrays;
    18. import java.util.Date;
    19. import java.util.HashMap;
    20.  
    21. /**
    22.  * @author dylan
    23.  * @date 16/2/15 16:29
    24.  * Email: dinguangx@163.com
    25.  */
    26. @Controller
    27. @RequestMapping("/common")
    28. public class CommonController {
    29.     private Logger logger = LoggerFactory.getLogger(getClass());
    30.     @RequestMapping("uploadify")
    31.     @ResponseBody
    32.     public String uploadify(@RequestParam("Filedata")MultipartFile filedata,
    33.                             @RequestParam(required = false, defaultValue = "1")String thumbnail) {
    34.         boolean createThumbnail = "1".equals(thumbnail);
    35.         SystemSetting systemSetting = SystemManager.getInstance().getSystemSetting();
    36.         //文件保存目录路径
    37.         String savePath = SystemManager.getInstance().getProperty("file.upload.path");
    38.         //文件保存目录URL
    39.         String saveUrl = systemSetting.getImageRootPath();
    40.  
    41. //定义允许上传的文件扩展名
    42.         HashMap extMap = new HashMap();
    43.         extMap.put("image", "gif,jpg,jpeg,png,bmp");
    44.         extMap.put("flash", "swf,flv,mp3,wav,wma,wmv,mid,avi,mpg,asf,rm,rmvb");
    45.         extMap.put("media", "swf,flv,mp3,wav,wma,wmv,mid,avi,mpg,asf,rm,rmvb");
    46.         extMap.put("file", "doc,docx,xls,xlsx,ppt,htm,html,txt,zip,rar,gz,bz2");
    47.  
    48. //最大文件大小
    49.         long maxSize = 1000000;
    50.  
    51. //检查目录
    52.         File uploadDir = new File(savePath);
    53.         if (!uploadDir.isDirectory()) {
    54.             return (getError("上传目录不存在。"));
    55.         }
    56. //检查目录写权限
    57.         if (!uploadDir.canWrite()) {
    58.             return (getError("上传目录没有写权限。"));
    59.         }
    60.         String dirName = "image";
    61.         if (!extMap.containsKey(dirName)) {
    62.             return (getError("目录名不正确。"));
    63.         }
    64. //创建文件夹
    65.         savePath += dirName + "/";
    66.         saveUrl += dirName + "/";
    67.         String relativePath = dirName + "/";
    68.         File saveDirFile = new File(savePath);
    69.         if (!saveDirFile.exists()) {
    70.             saveDirFile.mkdirs();
    71.         }
    72.         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
    73.         String ymd = sdf.format(new Date());
    74.         savePath += ymd + "/";
    75.         saveUrl += ymd + "/";
    76.         relativePath += ymd + "/";
    77.         File dirFile = new File(savePath);
    78.         if (!dirFile.exists()) {
    79.             dirFile.mkdirs();
    80.         }
    81.  
    82.         String fileName = filedata.getOriginalFilename();
    83.         //检查扩展名
    84.         String fileExt = fileName.substring(fileName.lastIndexOf(".") + 1).toLowerCase();
    85.         if (!Arrays.asList(extMap.get(dirName).split(",")).contains(fileExt)) {
    86.             return (getError("上传文件扩展名是不允许的扩展名。\n只允许" + extMap.get(dirName) + "格式。"));
    87.         }
    88.  
    89.         String newFileName1 = null;//小图
    90.         String newFileName2 = null;//中图
    91.         String newFileName3 = null;//大图 ，也是原图
    92.         String newFileName0 = String.valueOf(System.currentTimeMillis());
    93.         logger.debug("newFileName0=" + newFileName0);
    94.         newFileName1 = newFileName0 + "_1";
    95.         newFileName2 = newFileName0 + "_2";
    96.         newFileName3 = newFileName0 + "_3." + fileExt;
    97.         logger.debug("newFileName1=" + newFileName1 + ",newFileName2=" + newFileName2 + ",newFileName3=" + newFileName3);
    98.  
    99.         File uploadedFile3 = new File(savePath, newFileName3);
    100.         try {
    101.             filedata.transferTo(uploadedFile3);
    102.             if(createThumbnail) {
    103.                 File uploadedFile1 = new File(savePath, newFileName1 + "." + fileExt);
    104.                 File uploadedFile2 = new File(savePath, newFileName2 + "." + fileExt);
    105.  
    106.                 ImageUtils.ratioZoom2(uploadedFile3, uploadedFile1, Double.valueOf(SystemManager.getInstance().getProperty("product_image_1_w")));
    107.                 ImageUtils.ratioZoom2(uploadedFile3, uploadedFile2, Double.valueOf(SystemManager.getInstance().getProperty("product_image_2_w")));
    108.             }
    109.         } catch (Exception e) {
    110.             logger.error("上传文件异常：" + e.getMessage());
    111.             return (getError("上传文件失败。"));
    112.         }
    113.  
    114.         JSONObject obj = new JSONObject();
    115.         obj.put("error", 0);
    116.         obj.put("filePath", relativePath + newFileName3);
    117.         return (obj.toString());
    118.     }
    119.  
    120.     private String getError(String msg) {
    121.  
    122.         JSONObject obj = new JSONObject();
    123.         obj.put("error", 1);
    124.         obj.put("msg", msg);
    125.         return (obj.toString());
    126.     }
    127. }

    ForwardController

    1. package net.jeeshop.web.action;
    2.  
    3. import org.apache.commons.lang.StringUtils;
    4. import org.springframework.stereotype.Controller;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6. import org.springframework.web.bind.annotation.RequestParam;
    7.  
    8. /**
    9.  * Created by dylan on 15-1-18.
    10.  */
    11. @Controller
    12. @RequestMapping("forward")
    13. public class ForwardController {
    14.     private String p = "/common/404";
    15.     @RequestMapping
    16.     public String forward(@RequestParam("p")String page){
    17.         if(StringUtils.isBlank(page)){
    18.             return p;
    19.         }
    20.         return page.trim();
    21.     }
    22. }

    购物车

    1. package net.jeeshop.web.action.front.cart;
    2.  
    3. import com.alibaba.fastjson.JSON;
    4. import net.jeeshop.core.FrontContainer;
    5. import net.jeeshop.core.Services;
    6. import net.jeeshop.core.front.SystemManager;
    7. import net.jeeshop.services.front.account.bean.Account;
    8. import net.jeeshop.services.front.address.AddressService;
    9. import net.jeeshop.services.front.product.ProductService;
    10. import net.jeeshop.services.front.product.bean.Product;
    11. import net.jeeshop.services.front.product.bean.ProductStockInfo;
    12. import net.jeeshop.services.manage.activity.bean.Activity;
    13. import net.jeeshop.services.manage.spec.SpecService;
    14. import net.jeeshop.services.manage.spec.bean.Spec;
    15. import net.jeeshop.web.action.front.FrontBaseController;
    16. import net.jeeshop.web.action.front.orders.CartInfo;
    17. import net.jeeshop.web.util.RequestHolder;
    18. import org.apache.commons.lang.StringUtils;
    19. import org.slf4j.Logger;
    20. import org.slf4j.LoggerFactory;
    21. import org.springframework.beans.factory.annotation.Autowired;
    22. import org.springframework.stereotype.Controller;
    23. import org.springframework.ui.ModelMap;
    24. import org.springframework.web.bind.annotation.RequestMapping;
    25. import org.springframework.web.bind.annotation.RequestMethod;
    26. import org.springframework.web.bind.annotation.ResponseBody;
    27.  
    28. import javax.servlet.http.HttpServletRequest;
    29. import java.io.IOException;
    30. import java.text.DecimalFormat;
    31. import java.util.ArrayList;
    32. import java.util.Iterator;
    33. import java.util.LinkedList;
    34. import java.util.List;
    35.  
    36. /**
    37.  * 购物车
    38.  * 
    39.  * @author huangf
    40.  * 
    41.  */
    42. @Controller("frontCartAction")
    43. @RequestMapping("cart")
    44. public class CartAction extends FrontBaseController {
    45. 	private static final long serialVersionUID = 1L;
    46. 	private static final Logger logger = LoggerFactory.getLogger(CartAction.class);
    47. 	@Autowired
    48. 	private ProductService productService;
    49. 	@Autowired
    50. 	private AddressService addressService;
    51. 	@Autowired
    52. 	private SpecService specService;
    53.  
    54. 	@Override
    55. 	public Services getService() {
    56. 		return null;
    57. 	}
    58.  
    59. 	/**
    60. 	 * 查看购物车
    61. 	 * @return
    62. 	 */
    63. 	@RequestMapping("cart")
    64. 	public String cart(ModelMap model){
    65. 		logger.error("AccountAction.cart查看购物车...");
    66. //		Account acc = (Account) getSession().getAttribute(FrontContainer.USER_INFO);
    67. //		if (acc == null || StringUtils.isBlank(acc.getAccount())) {
    68. //			return "toLogin";
    69. //		}
    70. 		List productList = new ArrayList();
    71. 		CartInfo cartInfo = getMyCart();
    72. 		if(cartInfo!=null){
    73. 			productList = cartInfo.getProductList();
    74. 		} else {
    75. 			cartInfo = new CartInfo();
    76. 		}
    77. 		model.addAttribute("cartInfo", cartInfo);
    78. 		model.addAttribute("productList", productList);
    79. 		return "cart";
    80. 		
    81. //		String addCart = getRequest().getParameter("addCart");
    82. //		CartInfo cartInfo = (CartInfo) getSession().getAttribute(FrontContainer.myCart);
    83. //		if(cartInfo==null){
    84. //			cartInfo = new CartInfo();
    85. //		}
    86. //		getSession().setAttribute(FrontContainer.myCart,cartInfo);
    87. //		logger.error("===addCart="+(addCart!=null && addCart.equals("1")));
    88. //		if(addCart!=null && addCart.equals("1")){
    89. //			String productID = getE().getId();
    90. //			if(StringUtils.isEmpty(productID)){
    91. //				//查询购物车
    92. //				return "cart";
    93. //			}
    94. //			
    95. //			if(cartInfo==null){
    96. //				cartInfo = new CartInfo();
    97. //				getSession().setAttribute(FrontContainer.myCart, cartInfo);
    98. //			}
    99. //			int inputBuyNum = Integer.valueOf(getRequest().getParameter("inputBuyNum"));
    100. //			if(inputBuyNum<=0){
    101. //				throw new NullPointerException();
    102. //			}
    103. //			//检查指定的产品是否已购买到购物车，购买了则数量++，否则查询后添加到购物车
    104. //			boolean exists = false;
    105. //			for(int i=0;i
    106. //				Product p = cartInfo.getProductList().get(i);
    107. //				if(p.getId().equals(productID)){
    108. //					p.setBuyCount(p.getBuyCount()+inputBuyNum);
    109. //					exists = true;
    110. //				}
    111. //			}
    112. //			if(!exists){
    113. //				//添加产品到购物车
    114. //				System.out.println("id="+productID);
    115. 				getE().clear();
    116. //				Product pp = new Product();
    117. //				pp.setId(productID);
    118. //				pp.setStatus(1);
    119. //				pp = productService.selectOne(pp);
    120. //				if(pp==null){
    121. //					throw new NullPointerException("根据商品ID="+productID+"查询不到指定的商品信息。");
    122. //				}
    123. //				pp.setBuyCount(inputBuyNum);
    124. //				
    125. //				cartInfo.getProductList().add(pp);
    126. //			}
    127. //			cartInfo.setAmount(cartInfo.cacl());
    128. //			getE().clear();
    129. //			
    130. //		}
    131. //		
    132. //		//加载配送信息
    133. //		Address add = new Address();
    134. //		add.setAccount(acc.getAccount());
    135. //		List
       addressList = addressService.selectList(add);
    136. //		cartInfo.setAddressList(addressList);
    137. //		if(addressList!=null && addressList.size()>0){
    138. 			boolean exist = false;
    139. //			for(int i=0;i
    140. //				Address addItem = addressList.get(i);
    141. //				if(StringUtils.isNotBlank(addItem.getIsdefault()) && addItem.getIsdefault().equals("y")){
    142. //					cartInfo.setDefaultAddessID(addItem.getId());
    143. //					break;
    144. //				}
    145. //			}
    146. //		}
    147. //		logger.error("cartInfo="+cartInfo);
    148. //		return "cart";
    149. 	}
    150. 	
    151. 	/**
    152. 	 * 从购物车中删除指定的产品
    153. 	 * @return
    154. 	 */
    155. 	@RequestMapping(value = "delete", method = RequestMethod.POST)
    156. 	public String delete(ModelMap model, String id){
    157. 		if(StringUtils.isBlank(id)){
    158. 			throw new NullPointerException("非法请求！");
    159. 		}
    160. 		
    161. 		CartInfo cartInfo = getMyCart();
    162. 		if(cartInfo==null){
    163. 			//会话超时，转到登陆页面
    164. 			return page_toLoginRedirect;
    165. 		}
    166. 		
    167. 		for(Iterator it = cartInfo.getProductList().iterator();it.hasNext();){
    168. 			Product p = it.next();
    169. 			if(p.getId().equals(id)){
    170. 				it.remove();
    171. 				
    172. 				//重新计算总支付金额
    173. //				cartInfo.setAmount(cartInfo.totalCacl());
    174. 				cartInfo.totalCacl();
    175. 				break;
    176. 			}
    177. 		}
    178. 		return "redirect:/cart/cart.html";
    179. 	}
    180. 	DecimalFormat df = new DecimalFormat("0.00");
    181. 	/**
    182. 	 * 加入购物车，不对金额进行任何的运算。金额的运算在方法CartAction.notifyCart
    183. 	 * @return
    184. 	 * @throws IOException 
    185. 	 */
    186. 	@RequestMapping("addToCart")
    187. 	@ResponseBody
    188. 	public String addToCart(ModelMap model) throws IOException{
    189. //		Account acc = (Account) getSession().getAttribute(FrontContainer.USER_INFO);
    190. //		if (acc == null || StringUtils.isBlank(acc.getAccount())) {
    191. //			super.write("1");//需要登录
    192. //			return null;
    193. //		}
    194. 		
    195. 		logger.info("ProductAction.cart...");
    196. 		HttpServletRequest request = RequestHolder.getRequest();
    197. 		String productID = request.getParameter("productID");//商品ID
    198. 		int buyCount = Integer.valueOf(request.getParameter("buyCount"));//购买数量
    199. 		String buySpecID = request.getParameter("buySpecID");//选中的规格ID
    200. 		if(StringUtils.isEmpty(productID) || buyCount<=0){
    201. 			throw new NullPointerException("参数错误！");
    202. 		}
    203. 		
    204. 		/**
    205. 		 * 检查内存库存是否已超卖，如果超库存不足，则提醒用户
    206. 		 */
    207. 		ProductStockInfo momeryStockInfo = SystemManager.getInstance().getProductStockMap().get(productID);
    208. 		if(momeryStockInfo==null){
    209. 			String jsonError = JSON.toJSONString(new StockErrorProduct(productID,"很抱歉，商品已下架暂时无法购买！"));
    210. 			logger.info("jsonError=" + jsonError);
    211. 			return (jsonError);
    212. 		}
    213. 		
    214. 		
    215. 		CartInfo cartInfo = getMyCart();
    216. 		if(cartInfo==null){
    217. 			cartInfo = new CartInfo();
    218. 		}
    219. 		RequestHolder.getSession().setAttribute(FrontContainer.myCart, cartInfo);
    220. 		
    221. 		//检查指定的产品是否已购买到购物车，购买了则数量++，否则查询后添加到购物车
    222. 		boolean exists = false;
    223. 		for(int i=0;i
    224. 			Product p = cartInfo.getProductList().get(i);
    225. 			if(p.getId().equals(productID)){
    226. 				p.setBuyCount(p.getBuyCount()+buyCount);
    227. 				logger.info("商品已购买，只对数量进行++，总数=" + p.getBuyCount());
    228. 				
    229. 				if(p.getExchangeScore() > 0){
    230. 					p.setTotal0("0.00");
    231. 					p.setTotalExchangeScore(p.getBuyCount() * p.getExchangeScore());
    232. 				}else{
    233. 					p.setTotal0(df.format(p.getBuyCount() * Double.valueOf(p.getNowPrice())));
    234. 				}
    235. 				exists = true;
    236. 			}
    237. 		}
    238. 		
    239. 		//如果购物车中部存在此商品，则添加到购物车
    240. 		if(!exists){
    241. 			Product product = new Product();
    242. 			product.setId(productID);
    243. //			product.setStatus(1);
    244. 			product = productService.selectOne(product);
    245. 			if(product==null){
    246. 				throw new NullPointerException();
    247. 			}
    248. 			
    249. 			/**
    250. 			 * 如果此商品为促销活动的商品，则按照活动规则计算商品金额
    251. 			 */
    252. 			if(StringUtils.isNotBlank(product.getActivityID())){
    253. 				Activity activity = SystemManager.getInstance().getActivityMap().get(product.getActivityID());
    254. 				if(activity==null){
    255. 					String jsonError = JSON.toJSONString(new StockErrorProduct(productID,"活动可能已下架！"));
    256. 					logger.error("jsonError="+jsonError);
    257. 					return (jsonError);//活动可能已下架!
    258. 				}else if(activity.checkActivity()){
    259. 					String jsonError = JSON.toJSONString(new StockErrorProduct(productID,"活动已结束！"));
    260. 					logger.error("jsonError="+jsonError);
    261. 					return (jsonError);//活动已结束！
    262. 				}
    263. 				
    264. 				//检查是否符合此活动的会员等级范围
    265. 				Account acc = getLoginAccount();
    266. 				if(acc==null){
    267. 					String jsonError = JSON.toJSONString(new StockErrorProduct(productID,"此商品为促销活动的商品，请先登陆才能购买！！"));
    268. 					logger.error("jsonError="+jsonError);
    269. 					return (jsonError);
    270. 				}
    271. 				logger.error("acc.getRank() = " + acc.getRank());
    272. 				logger.error("activity.getAccountRange() = " + activity.getAccountRange());
    273. 				
    274. 				if(activity.getAccountRange().indexOf(acc.getRank()) < 0){
    275. 					String jsonError = JSON.toJSONString(new StockErrorProduct(productID,"您的会员等级不在此活动的购买范围内！"));
    276. 					logger.error("jsonError="+jsonError);
    277. 					return (jsonError);
    278. 				}
    279. 				
    280. 				//计算活动商品的最终结算价
    281. 				product.setNowPrice(product.caclFinalPrice());
    282. 				
    283. 				//判断如果是积分商品，则计算所需的积分
    284. 				if(activity.getActivityType().equals(Activity.activity_activityType_j)){
    285. 					product.setExchangeScore(activity.getExchangeScore());
    286. 				}
    287. 			}
    288. 			
    289. 			product.setBuyCount(buyCount);
    290. 			
    291. 			/**
    292. 			 * 加载指定商品的规格信息
    293. 			 */
    294. 			if(StringUtils.isNotBlank(buySpecID)){
    295. 				Spec spec = specService.selectById(buySpecID);
    296. 				if(spec==null){
    297. 					throw new NullPointerException("根据指定的规格"+buySpecID+"查询不到任何数据!");
    298. 				}
    299. 				product.setBuySpecInfo(spec);
    300. 				
    301. 				//减少以后的逻辑判断，规格的价格等同于商品的价格
    302. 				product.setNowPrice(spec.getSpecPrice());
    303. 			}
    304. 			
    305. 			if(product.getExchangeScore()==0){
    306. 				product.setTotal0(df.format(product.getBuyCount() * Double.valueOf(product.getNowPrice())));
    307. 			}else{
    308. 				product.setTotalExchangeScore(product.getBuyCount() * product.getExchangeScore());
    309. 				product.setTotal0("0.00");
    310. 			}
    311. 			
    312. 			cartInfo.getProductList().add(product);
    313. 			logger.error("添加商品到购物车!商品ID="+product.getId());
    314. 		}
    315. 		cartInfo.totalCacl();//计算购物车中商品总金额
    316. //		e.clear();
    317. 		
    318. 		return ("0");//成功添加商品到购物车
    319. 	}
    320. 	
    321. 	/**
    322. 	 * 通知购物车+-商品，然后计算出总金额返回。
    323. 	 * @return
    324. 	 * @throws IOException 
    325. 	 */
    326. 	@RequestMapping(value = "notifyCart", method = RequestMethod.POST)
    327. 	@ResponseBody
    328. 	public String notifyCart(ModelMap model) throws IOException{
    329. 		HttpServletRequest request = RequestHolder.getRequest();
    330. 		int currentBuyNumber = Integer.valueOf(request.getParameter("currentBuyNumber"));//当前购买的商品的数量
    331. 		String productID = request.getParameter("productID");//+-的商品ID
    332. 		logger.error("currentBuyNumber="+currentBuyNumber+",productID="+productID);
    333. 		
    334. 		if (StringUtils.isBlank(productID) || currentBuyNumber<=0) {
    335. 			throw new NullPointerException("非法请求!");
    336. 		}
    337. 		
    338. 		CartInfo cartInfo = getMyCart();
    339. 		if(cartInfo==null || cartInfo.getProductList()==null || cartInfo.getProductList().size()==0){
    340. 			//购物车失效，转到登陆页面
    341. 			return page_toLoginRedirect;
    342. 		}
    343. 		
    344. //		String msg = null;
    345. 		CartProductInfo cartProductInfo = new CartProductInfo();
    346. 		
    347. 		/**
    348. 		 * 检查购买的商品是否超出库存数
    349. 		 */
    350. 		ProductStockInfo stockInfo = SystemManager.getInstance().getProductStockMap().get(productID);
    351. 		if(stockInfo==null){
    352. 			//商品已卖完或已下架，请联系站点管理员!
    353. 			logger.error("商品已卖完或已下架，请联系站点管理员或从购物车中删除!");
    354. 			cartProductInfo.code = "notThisProduct";
    355. 			cartProductInfo.msg = "商品已卖完或已下架，请联系站点管理员或从购物车中删除!";
    356. 			return (JSON.toJSONString(cartProductInfo));
    357. //			super.write("{\"code\":\"notThisProduct\",\"msg\":\"商品已卖完或已下架，请联系站点管理员或从购物车中删除!\"}");
    358. 		} else if(StringUtils.isNotBlank(stockInfo.getActivityID())){
    359. 			/**
    360. 			 * 购买的是活动促销的商品，则检查是否超出购买的最大数量
    361. 			 */
    362. 			Activity activity = SystemManager.getInstance().getActivityMap().get(stockInfo.getActivityID());
    363. 			if(activity==null || activity.getStatus().equals(Activity.activity_status_n)){
    364. 				cartProductInfo.code = "buyMore";
    365. 				cartProductInfo.msg = "此商品为促销活动的商品，最多只能购买" + activity.getMaxSellCount()+"件";
    366. 				return (JSON.toJSONString(cartProductInfo));
    367. 			}else if(activity.getMaxSellCount() != 0 && currentBuyNumber > activity.getMaxSellCount()){
    368. //				String msg0 = "此商品为促销活动的商品，最多只能购买" + activity.getMaxSellCount()+"件";
    369. //				msg = "{\"code\":\"buyMore\",\"msg\":\"" + msg0 + "\",\"maxStock\":\""+stockInfo.getStock()+"\"}";
    370. 				
    371. 				cartProductInfo.code = "buyMore";
    372. 				cartProductInfo.msg = "此商品为促销活动的商品，最多只能购买" + activity.getMaxSellCount()+"件";
    373. 				return (JSON.toJSONString(cartProductInfo));
    374. 			}
    375. 			
    376. //			if(activity.getActivityType().equals(Activity.activity_activityType_j)){
    377. 				currentBuyNumber * activity.getExchangeScore()
    378. //				activity.sete
    379. //			}
    380. 		}else{
    381. 			if(stockInfo.getStock() < currentBuyNumber){
    382. 				//购买的商品数超出库存数，则自动当最大库存数计算
    383. 				currentBuyNumber = stockInfo.getStock();
    384. 				
    385. //				String msg0 = "最多只能买"+stockInfo.getStock()+"件";
    386. //				msg = "{\"code\":\"buyMore\",\"msg\":\""+msg0+"\",\"maxStock\":\""+stockInfo.getStock()+"\"}";
    387. 				
    388. 				cartProductInfo.code = "buyMore";
    389. 				cartProductInfo.msg = "最多只能买"+stockInfo.getStock()+"件";
    390. 				return (JSON.toJSONString(cartProductInfo));
    391. 			}
    392. 		}
    393. 		
    394. 		/**
    395. 		 * 计算出点击+-的这一个商品的一些信息：小计、所需积分
    396. 		 */
    397. //		if(msg==null){
    398. 			for(int i=0;i
    399. 				Product pro = cartInfo.getProductList().get(i);
    400. 				if(pro.getId().equals(productID)){
    401. 					pro.setBuyCount(currentBuyNumber);//设置指定商品购买的数量
    402. 					
    403. 					cartInfo.totalCacl();//计算购物车中商品总金额
    404. 					
    405. //					msg = "{\"code\":\"ok\",\"amount\":\""+cartInfo.getAmount()+"\"}";
    406. 					
    407. 					if(pro.getExchangeScore()==0){
    408. 						pro.setTotal0(df.format(Double.valueOf(pro.getNowPrice()) * pro.getBuyCount()));
    409. 					}else{
    410. 						pro.setTotal0("0.00");
    411. 						pro.setTotalExchangeScore(pro.getBuyCount() * pro.getExchangeScore());
    412. 					}
    413. 					
    414. 					cartProductInfo.code = "ok";
    415. 					cartProductInfo.total0 = pro.getTotal0();
    416. 					cartProductInfo.amount = cartInfo.getAmount();
    417. 					cartProductInfo.totalExchangeScore = pro.getBuyCount() * pro.getExchangeScore();
    418. 					cartProductInfo.amountExchangeScore = cartInfo.getTotalExchangeScore();
    419. //					cartProductInfo.msg = "{\"code\":\"ok\",\"amount\":\""+cartInfo.getAmount()+"\"}";
    420. 					break;
    421. 				}
    422. 			}
    423. //		}
    424. 		return (JSON.toJSONString(cartProductInfo));
    425. 	}
    426. 	
    427. 	/**
    428. 	 * 正式转到支付之前的最后一次检查库存
    429. 	 * 此方法也可以用于批量错误消息检查，比如在购物车商品列表页面，提交到支付页面的时候进行批量检查（所有商品是否都有货、是否存在超卖、是否已下架、是否活动已结束（未在指定时间内进行支付，且活动已结束））
    430. 	 * @return
    431. 	 * @throws IOException 
    432. 	 */
    433. 	@RequestMapping("checkStockLastTime")
    434. 	@ResponseBody
    435. 	public String checkStockLastTime() throws IOException{
    436. 		
    437. 		logger.error("checkStockLastTime...");
    438. 		Account acc = getLoginAccount();
    439. 		if(acc==null){
    440. //			throw new NullPointerException("请先登陆！");
    441. 			logger.error("提示用户需要登录...");
    442. 			return ("-1");//提示用户需要登录
    443.  
    444. 		}
    445. 		
    446. 		
    447. 		StockErrorProductReturn result = new StockErrorProductReturn();
    448. 		CartInfo cartInfo = getMyCart();
    449. 		if(cartInfo==null){
    450. 			logger.error("login..");
    451. 			//session超时，转到登陆页面，让用户重新登陆下单，上次未支付的单子只能找不到了。
    452. 			result.code = "login";
    453. 			return (JSON.toJSONString(result).toString());
    454. 		}
    455. 		
    456. 		result.code = "result";
    457. 		List list = new LinkedList();
    458. 		for(int i=0;i
    459. 			Product pro = cartInfo.getProductList().get(i);
    460. 			ProductStockInfo stockInfo = SystemManager.getInstance().getProductStockMap().get(pro.getId());
    461. 			if(stockInfo!=null){
    462. 				if(StringUtils.isNotBlank(stockInfo.getActivityID())){
    463. 					/**
    464. 					 * 购买的是活动促销的商品，则检查是否超出购买的最大数量
    465. 					 */
    466. 					Activity activity = SystemManager.getInstance().getActivityMap().get(stockInfo.getActivityID());
    467. 					if(activity.getMaxSellCount() != 0 && pro.getBuyCount() > activity.getMaxSellCount()){
    468. 						String msg0 = "此商品为促销活动的商品，最多只能购买" + activity.getMaxSellCount()+"件";
    469. //						msg = "{\"code\":\"buyMore\",\"msg\":\"" + msg0 + "\",\"maxStock\":\""+stockInfo.getStock()+"\"}";
    470. 						list.add(new StockErrorProduct(pro.getId(),msg0));
    471. 					}
    472. 					
    473. 					//如果商品为需要积分兑换的，则检查用户账户上的积分是否足够
    474. 					if(false){
    475. 						acc = getLoginAccount();
    476. 						if(acc==null){
    477. 							throw new NullPointerException("请先登陆！");
    478. 						}
    479. 						
    480. 						//积分不足的错误提示
    481. 						if(acc.getScore() < activity.getExchangeScore() * pro.getBuyCount()){
    482. 							list.add(new StockErrorProduct(pro.getId(),"此商品总共所需积分："+activity.getExchangeScore() * pro.getBuyCount() + "点，可惜您目前只有"+acc.getScore()+"积分"));
    483. 						}
    484. 					}
    485. 				}else{
    486. 					if(stockInfo.getStock()
    487. 						//购物车中购买的商品超出库存数
    488. 						list.add(new StockErrorProduct(pro.getId(),"最多只能购买"+stockInfo.getStock()+"个！"));
    489. 					}
    490. 					
    491. //					if(stockInfo.getStock() < currentBuyNumber){
    492. //						//购买的商品数超出库存数，则自动当最大库存数计算
    493. //						currentBuyNumber = stockInfo.getStock();
    494. //						
    495. //						String msg0 = "最多只能买"+stockInfo.getStock()+"件";
    496. //						msg = "{\"code\":\"buyMore\",\"msg\":\""+msg0+"\",\"maxStock\":\""+stockInfo.getStock()+"\"}";
    497. //					}
    498. 				}
    499. 				
    500. 			}else{
    501. 				//商品可能已经下架或售完！
    502. 				list.add(new StockErrorProduct(pro.getId(),"商品可能已经下架或售完！"));
    503. 			}
    504. 		}
    505. 		
    506. 		//检查积分是否足够支付此订单消耗的积分
    507. 		
    508. 		//积分不足的错误提示
    509. 		if(acc.getScore() < cartInfo.getTotalExchangeScore()){
    510. 			result.error = "总共所需积分：" + cartInfo.getTotalExchangeScore() + ",可惜您仅有积分：" + acc.getScore();
    511. 		}
    512. 		
    513. 		if(list!=null && list.size()>0){
    514. 			result.list = list;
    515. 		}
    516. 		
    517. 		cartInfo.totalCacl();//计算购物车中商品总金额
    518.  
    519. //		logger.error("checkStockLastTime..."+JSON.toJSONString(result).toString());
    520. 		return (JSON.toJSONString(result).toString());
    521. 	}
    522. 	
    523. 	/**
    524. 	 * 库存检查返回的错误对象
    525. 	 * @author huangf
    526. 	 *
    527. 	 */
    528. 	class StockErrorProductReturn{
    529. 		String code;
    530. 		String error;//错误消息，显示到提交按钮边上
    531. 		List list;
    532. 		
    533. 		public String getCode() {
    534. 			return code;
    535. 		}
    536. 		public void setCode(String code) {
    537. 			this.code = code;
    538. 		}
    539. 		public List getList() {
    540. 			return list;
    541. 		}
    542. 		public void setList(List list) {
    543. 			this.list = list;
    544. 		}
    545. 		public String getError() {
    546. 			return error;
    547. 		}
    548. 		public void setError(String error) {
    549. 			this.error = error;
    550. 		}
    551. 	}
    552. 	
    553. 	/**
    554. 	 * 库存检查错误消息对象
    555. 	 */
    556. 	class StockErrorProduct{
    557. 		String id;//商品ID
    558. 		String tips;//错误消息
    559. 		
    560. 		public StockErrorProduct(){}
    561. 		
    562. 		public StockErrorProduct(String id,String tips){
    563. 			this.id = id;
    564. 			this.tips = tips;
    565. 		}
    566. 		
    567. 		public String getId() {
    568. 			return id;
    569. 		}
    570. 		
    571. 		public void setId(String id) {
    572. 			this.id = id;
    573. 		}
    574. 		
    575. 		public String getTips() {
    576. 			return tips;
    577. 		}
    578. 		
    579. 		public void setTips(String tips) {
    580. 			this.tips = tips;
    581. 		}
    582. 	}
    583. 	
    584. 	/**
    585. 	 * 购物车页面，单个商品返回的信息对象
    586. 	 */
    587. 	class CartProductInfo {
    588. 		String code;//返回代码
    589. 		String msg;//返回消息
    590. 		String total0;//小计金额
    591. 		String amount;//总计金额
    592. 		int totalExchangeScore;//兑换此商品所需总积分
    593. 		int amountExchangeScore;//积分汇总
    594. 		
    595. 		public String getCode() {
    596. 			return code;
    597. 		}
    598. 		public void setCode(String code) {
    599. 			this.code = code;
    600. 		}
    601. 		public String getMsg() {
    602. 			return msg;
    603. 		}
    604. 		public void setMsg(String msg) {
    605. 			this.msg = msg;
    606. 		}
    607. 		public String getTotal0() {
    608. 			return total0;
    609. 		}
    610. 		public void setTotal0(String total0) {
    611. 			this.total0 = total0;
    612. 		}
    613. 		public String getAmount() {
    614. 			return amount;
    615. 		}
    616. 		public void setAmount(String amount) {
    617. 			this.amount = amount;
    618. 		}
    619. 		public int getTotalExchangeScore() {
    620. 			return totalExchangeScore;
    621. 		}
    622. 		public void setTotalExchangeScore(int totalExchangeScore) {
    623. 			this.totalExchangeScore = totalExchangeScore;
    624. 		}
    625. 		public int getAmountExchangeScore() {
    626. 			return amountExchangeScore;
    627. 		}
    628. 		public void setAmountExchangeScore(int amountExchangeScore) {
    629. 			this.amountExchangeScore = amountExchangeScore;
    630. 		}
    631. 		
    632. 	}
    633. }

    如果也想学习本系统，下面领取。回复：225ssm 

  • 相关阅读:
    [译]BNF 表示法：深入了解 Python 的语法
    redis(封装jedis)-----面试
    MySQL基础十八章
    公园设施3D可视化：游园新体验，触手可及的未来
    HTML5期末考核大作业——学生网页设计作业源码HTML+CSS+JavaScript 中华美德6页面带音乐文化
    JAVA:实现Sudoku数独算法(附完整源码)
    和monkey的相处日记
    树状数组：leetcode307 区域和检索
    Google Earth Engine ——Landsat 5 和Landsat1-4影像集合
    小程序云开发笔记二
  • 原文地址：https://blog.csdn.net/hanyunlong1989/article/details/126077481