基于javaweb和mysql的ssm在线图书商城系统(java+ssm+freemarker+bootstrap+mysql)

私信源码获取及调试交流

私信源码获取及调试交流

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8

开发工具

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

适用

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

功能说明

基于javaweb的SSM在线图书商城系统(java+ssm+freemarker+bootstrap+mysql)

项目介绍

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

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

环境需要

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

    	model.addAttribute("roleList", roleService.selectList(null));
        return page_register;
    }

	/**
	 * 后台登录
	 * @return
	 * @throws Exception
	 */
    @RequestMapping(value = "login", method = RequestMethod.POST)
	public String login(HttpSession session,@ModelAttribute("e") User e, ModelMap model) throws Exception {
		String errorMsg;
		if (session.getAttribute(ManageContainer.manage_session_user_info) != null) {
			return "redirect:/manage/user/home";
		}

		if (StringUtils.isBlank(e.getUsername()) || StringUtils.isBlank(e.getPassword())){
			model.addAttribute("errorMsg", "账户和密码不能为空!");
			return page_input;
		}
		System.out.println("用户登录:" + e.getUsername());
		e.setPassword(MD5.md5(e.getPassword()));
		User u = ((UserService)getService()).login(e);
		if (u == null) {
			errorMsg = "登陆失败，账户或密码错误！";
			System.out.println("登陆失败，账户或密码错误," + e.getUsername());
			model.addAttribute("errorMsg", errorMsg);
			return page_input;
		}else if(!u.getStatus().equals(User.user_status_y)){
			errorMsg = "帐号已被禁用，请联系管理员!";
			System.out.println("帐号已被禁用，请联系管理员," + u.getUsername());
			model.addAttribute("errorMsg", errorMsg);
			return page_input;
		}
		u.setUsername(e.getUsername());
		session.setAttribute(ManageContainer.manage_session_user_info, u);
		
		//解析用户的数据库权限，以后可以进行DB权限限制
		if(StringUtils.isNotBlank(u.getRole_dbPrivilege())){
			String[] dbPriArr = u.getRole_dbPrivilege().split(",");
			if(u.getDbPrivilegeMap()==null){
				u.setDbPrivilegeMap(new HashMap<String, String>());
			}else{
				u.getDbPrivilegeMap().clear();
			}

				mm.setPid(item.getId());
				loadChildrenByPid(root.get(i), mm,url,u);
			}else{
				//addUserResourceMenusButton(item.getUrl());
			}
		}

		return root;
	}

	// 根据父ID加载子节点
	private void loadChildrenByPid(MenuItem item, Menu menu,String url,User u) {
		Map<String,String> param = new HashMap<String, String>();
		
		if(u!=null && u.getRid()!=null)
			param.put("rid", u.getRid());
		param.put("pid", menu.getPid());
		//加载菜单节点
		List<Menu> data = menuService.selectList(param);
		if(data==null || data.size()==0){
			return;
		}
		if(item.getChildren()==null)item.setChildren(new ArrayList<MenuItem>());
		//创建菜单节点
		for (int i = 0; i < data.size(); i++) {
			Menu entry = data.get(i);
			
			MenuItem addItem = new MenuItem(entry.getName(), null);
			addItem.setId(entry.getId());
			addItem.setPid(entry.getPid());
			addItem.setMenuType(entry);
			String url0 = null;
			if(url!=null){
				addItem.setUrl(url);
				url0 = url;
			}else{
				addItem.setUrl(entry.getUrl());
				url0 = entry.getUrl();
			}
//			System.out.println("entry.getType()="+entry.getType()+",MenuType.button="+MenuType.button);
			if(entry.getType().equals("button")){
				addUserResourceMenusButton(url0);
			}else{
				item.getChildren().add(addItem);
			}
		}
		//根据菜单节点进行递归加载
		for (int i = 0; i < item.getChildren().size(); i++) {
			MenuItem childItem = item.getChildren().get(i);
			if(!childItem.isButton()){

	 * @return
	 * @throws Exception 
	 */
	@RequestMapping("newsList")
	public String newsList(ModelMap model, @ModelAttribute("e")News news) throws Exception{
		News newsInfo = new News();
		newsInfo.setType(News.news_type_notice);
		
		model.addAttribute("pager", super.selectPageList(newsService, newsInfo));
		return "newsList";
	}
	
//	/**
//	 * 获取新闻详情
//	 * @return
//	 */
//	public String newsInfo() throws Exception{
//		String id = getRequest().getParameter("id");
//		String code = getRequest().getParameter("code");
//		System.out.println("ProductAction.newsInfo=== id="+id+",code="+code);
//		
//		if(StringUtils.isNotBlank(id)){
//			
//			System.out.println("newsInfo id = "+id);
//			if(StringUtils.isBlank(id)){
//				throw new NullPointerException("id is null");
//			}
//			
//			e.setNews(newsService.selectById(id));
//			
//			String url = "/jsp/notices/"+e.getId()+".jsp";
//			System.out.println("url = " + url);
//			getRequest().setAttribute("newsInfoUrl",url);
//			
//			return "newsInfo";
//			
////			if(e.getNews().getType().equals(News.news_type_help)){
////				return "help";
////			}else if(e.getNews().getType().equals(News.news_type_notice)){
////				return "newsInfo";
////			}
//		}else if(StringUtils.isNotBlank(code)){
//			
//			System.out.println("newsInfo code = "+code);
//			if(StringUtils.isBlank(code)){
//				throw new NullPointerException("code is null");
//			}
//			News news = new News();
//			news.setCode(code);
//			e.setNews(newsService.selectSimpleOne(news));
//			
//			String url = "/jsp/helps/"+e.getNews().getId()+".jsp";
//			System.out.println("url = " + url);

	 * @return
	 */
	@RequestMapping(value = "selectOrdership")
	public String selectOrdership(ModelMap model, Order e) {
		String orderid = RequestHolder.getRequest().getParameter("orderid");
		if (StringUtils.isBlank(orderid)) {
			throw new NullPointerException("非法请求！");
		}

		Ordership ordership = new Ordership();
		ordership.setOrderid(orderid);
		ordership = ordershipService.selectOne(ordership);
		if (ordership == null) {
			throw new NullPointerException("根据订单ID查询不到该订单的配送信息！");
		}
		e.setOrdership(ordership);
		// 获取区域列表
		Map<String, Area> areaMap = SystemManager.getInstance().getAreaMap();
		model.addAttribute("provinces", areaMap.values());
		if (StringUtils.isNotBlank(ordership.getProvinceCode()) && areaMap.get(ordership.getProvinceCode()) != null) {
			Area city = areaMap.get(ordership.getProvinceCode());
			model.addAttribute("cities", areaMap.get(ordership.getProvinceCode()).getChildren());
			if (city != null && city.getChildren() != null && city.getChildren().size() > 0) {
				for (int i = 0; i < city.getChildren().size(); i++) {
					Area item = city.getChildren().get(i);
					if (item.getCode().equals(ordership.getCityCode())) {
						if (item.getChildren() != null && item.getChildren().size() > 0) {
							model.addAttribute("areas", item.getChildren());
						}
					}
				}
			}
		} else {
			model.addAttribute("cities", new ArrayList<Area>());
		}
		model.addAttribute("e", e);
		return page_updateOrdership;
	}

	/**
	 * 修改订单配送地址信息
	 * 
	 * @return
	 * @throws IOException
	 */
	@RequestMapping(value = "updateOrdership", method = RequestMethod.POST)
	public String updateOrdership(ModelMap model, Order e) throws IOException {
		System.out.println("updateOrdership...");
		if (StringUtils.isBlank(e.getOrdership().getShipname())) {
			throw new NullPointerException("收货人不能为空！");
		} else if (StringUtils.isBlank(e.getOrdership().getShipaddress())) {
			throw new NullPointerException("收货人街道地址不能为空！");

	public String doRate() throws Exception{
		Account acc = getLoginAccount();
		if (acc == null) {
			return page_toLogin;
		}
		System.out.println("doRate...");
		
		int orderid = Integer.valueOf(RequestHolder.getRequest().getParameter("orderid").toString());
		Order order = orderService.selectById(String.valueOf(orderid));

		if (StringUtils.isNotBlank(order.getClosedComment())
				&& order.getClosedComment().equals(Order.order_closedComment_y)) {
			//订单的点评功能已被关闭。
			throw new RuntimeException(FrontContainer.request_illegal_error);
		}
		
		/*
		 * 用户可以对每个订单项对应的商品进行评价
		 */
		Orderdetail orderdetail = new Orderdetail();
		orderdetail.setOrderID(orderid);
		List<Orderdetail> list = orderdetailService.selectList(orderdetail);
		List<Comment> comments = new LinkedList<Comment>();
		for(int i=0;i<list.size();i++){
			Orderdetail item = list.get(i);
			//获取页面上填写的评论类容
			String content = RequestHolder.getRequest().getParameter("product_"+item.getProductID());
			if(StringUtils.isBlank(content)){
				continue;
			}
			Comment c = new Comment();
			c.setProductID(String.valueOf(item.getProductID()));
			c.setOrderdetailID(item.getId());
			c.setOrderID(String.valueOf(orderid));
			c.setContent(content);
			c.setStatus(Comment.comment_status_y);
			c.setNickname(acc.getNickname());
			c.setStar(5);
			c.setAccount(acc.getAccount());
			comments.add(c);

	private GiftService giftService;
	private static final String page_toList = "/manage/product/productList";
	private static final String page_toEdit = "/manage/product/productEdit";
	private static final String page_toAdd = "/manage/product/productEdit";
	private ProductAction() {
		super.page_toList = page_toList;
		super.page_toAdd = page_toAdd;
		super.page_toEdit = page_toEdit;
	}

	public GiftService getGiftService() {
		return giftService;
	}

	public void setGiftService(GiftService giftService) {
		this.giftService = giftService;
	}

	public SpecService getSpecService() {
		return specService;
	}

	public void setSpecService(SpecService specService) {
		this.specService = specService;
	}

	public AttributeService getAttributeService() {
		return attributeService;
	}

	public ManageCache getManageCache() {
		return manageCache;
	}

	public void setManageCache(ManageCache manageCache) {
		this.manageCache = manageCache;
	}

	public void setAttributeService(AttributeService attributeService) {
		this.attributeService = attributeService;
	}

	public Attribute_linkService getAttribute_linkService() {
		return attribute_linkService;
	}

	public void setAttribute_linkService(Attribute_linkService attribute_linkService) {
		this.attribute_linkService = attribute_linkService;
	}

	public ProductService getService() {
		return productService;

    /**
     * 公共的更新数据的方法，子类可以通过重写此方法实现个性化的需求。
     *
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "update", method = RequestMethod.POST)
    public String update(HttpServletRequest request, @ModelAttribute("e") E e, RedirectAttributes flushAttrs) throws Exception {
//		User user = (User) getSession().getAttribute(Global.USER_INFO);
//		if(user==null){
//			throw new NullPointerException();
//		}
//		if(user.getDbPrivilegeMap()!=null && user.getDbPrivilegeMap().size()>0){
//			if(user.getDbPrivilegeMap().get(Container.db_privilege_update)==null){
//				throw new PrivilegeException(Container.db_privilege_update_error);
//			}
//		}

        getService().update(e);
        insertAfter(e);
        addMessage(flushAttrs, "操作成功！");
        return "redirect:selectList";
    }

    /**
     * insert之后，selectList之前执行的动作，一般需要清除添加的E，否则查询会按照E的条件进行查询.
     * 部分情况下需要保留某些字段，可以选择不清除
     *
     * @param e
     */
    protected void insertAfter(E e){
    }

    /**
     * 公共的插入数据方法，子类可以通过重写此方法实现个性化的需求。
     *
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "insert",method = RequestMethod.POST)
    public String insert(HttpServletRequest request, @ModelAttribute("e") E e, RedirectAttributes flushAttrs) throws Exception {
//		User user = (User) getSession().getAttribute(Global.USER_INFO);

	private NewsService newsService;
	@Autowired
	private AddressService addressService;//配送地址service
	@Autowired
	private ProductService productService;
	@Autowired
	private FavoriteService favoriteService;//商品收藏夹

	// 登陆错误信息
	private static final String toLogin = "/account/login";//转到登陆界面,forword方式 地址不变
	private static final String toLoginRedirect = "redirect:/account/login";//转到登陆界面,getResponse().sendRedirect(arg0)方式 地址变化
	private static final String toIndex = "redirect:/";//转到门户首页

	@Override
	public AccountService getService() {
		return accountService;
	}

	public void setAccountService(AccountService accountService) {
		this.accountService = accountService;
	}

	public void prepare(Account e) throws Exception {
	}

	/**
	 * 用户注册
	 *
	 * @return
	 * @throws IOException
	 */
	@RequestMapping(value = "doRegister", method = RequestMethod.POST)
	public String doRegister(Account e, ModelMap model) throws IOException {
		if(StringUtils.isBlank(e.getEmail())){
			throw new NullPointerException("邮箱不能为空！");
		}

		e.setPassword(MD5.md5(e.getPassword()));
		if (StringUtils.isBlank(e.getId())) {
			// 用户注册

    @RequestMapping("toEdit")
    public String toEdit(@ModelAttribute("e") E e, ModelMap model) throws Exception {
        e = getService().selectOne(e);
//		if(e==null || StringUtils.isBlank(e.getId())){
//			throw new NullPointerException("");
//		}
        model.addAttribute("e", e);
        return page_toEdit;
    }

    @RequestMapping("toAdd")
    public String toAdd(@ModelAttribute("e") E e, ModelMap model) throws Exception {
        e.clear();
        return page_toAdd;
    }

    /**
     * 子类必须要实现的方法当分页查询后.
     * 解决了用户先点击新增按钮转到新增页面,然后点击返回按钮返回后,再点分页控件出错的BUG.
     * 原因是分页查询后未将pageUrl重新设置为正确的URL所致
     */
    protected void selectListAfter(PagerModel pager) {
        pager.setPagerUrl("selectList");
    }

    /**
     * 返回到查询页面
     *
     * @return
     * @throws Exception
     */
    @RequestMapping("back")
    public String back(@ModelAttribute("e") E e, ModelMap model) throws Exception {
        return selectList(RequestHolder.getRequest(), e);
    }

    /**
     * 公共的批量删除数据的方法，子类可以通过重写此方法实现个性化的需求。
     *
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "deletes", method = RequestMethod.POST)
    public String deletes(HttpServletRequest request, String[] ids, @ModelAttribute("e") E e, RedirectAttributes flushAttrs) throws Exception {
//		User user = (User) getSession().getAttribute(Global.USER_INFO);
//		if(user==null){
//			throw new NullPointerException();
//		}
//		if(user.getDbPrivilegeMap()!=null && user.getDbPrivilegeMap().size()>0){
//			if(user.getDbPrivilegeMap().get(Container.db_privilege_delete)==null){
//				throw new PrivilegeException(Container.db_privilege_delete_error);
//			}
//		}

//		getE().setName(null);
		
		insertOrUpdateCommon(e);
		
		if(loadReport){
			manageCache.loadOrdersReport();
		}
//		clearCache();
//		updateMsg = "更新产品成功！";
//		getSession().setAttribute("insertOrUpdateMsg", "更新产品成功！");
//		getResponse().sendRedirect(getEditUrl(id));
		return "redirect:toEdit2?id="+ e.getId();
	}
	
	/**
	 * 添加或更新商品的公共功能
	 * @throws IOException
	 */
	private void insertOrUpdateCommon(Product e) throws IOException {
		System.out.println("=insertOrUpdateCommon=");
		
		/**
		 * 同步内存商品库存数据
		 */
        Map<String, ProductStockInfo> productStockMap = systemManager.getProductStockMap();
        ProductStockInfo momeryProduct = productStockMap.get(e.getId());
		List<String> productIDs = new LinkedList<String>();
		productIDs.add(e.getId());
		Product proObject = productService.selectStockByIDs(productIDs).get(0);
		
		if(momeryProduct==null){
			ProductStockInfo p = new ProductStockInfo();
			p.setId(proObject.getId());
			p.setStock(proObject.getStock());
			p.setScore(proObject.getScore());
			productStockMap.put(proObject.getId(), p);
            //update stock map
            systemManager.setProductStockMap(productStockMap);
		}else{
			momeryProduct.setStock(proObject.getStock());
			momeryProduct.setScore(proObject.getScore());
		}
		
		//上传图片
//		uploadImages();
		

//					Product product = cartInfo.getProductList().get(i);
//					ProductStockInfo stockInfo = SystemManager.productStockMap.get(product.getId());
//					stockInfo.setStock(stockInfo.getStock() - product.getBuyCount());
//					stockInfo.setChangeStock(true);
//					SystemManager.productStockMap.put(product.getId(),stockInfo);
//				}
//			}
//		}
		
		//获取配送方式
		Express express = SystemManager.getInstance().getExpressMap().get(e.getExpressCode());
		if(express==null){
			throw new NullPointerException("没有编码为"+e.getExpressCode()+"的配送方式！本次请求视为非法！");
		}
		
		//创建订单对象
		Order order = new Order();
		order.setAccount(account.getAccount());
		order.setQuantity(cartInfo.getProductList().size());
		order.setRebate(1);
		order.setStatus(Order.order_status_init);
		order.setPaystatus(Order.order_paystatus_n);
		order.setOtherRequirement(e.getOtherRequirement());//附加要求
		
		//商品总金额
//		double ptotal = 0d;
		int score = 0;//订单积分 等于订单项中每个商品赠送的积分总和
		//创建订单明细集合
		List<Orderdetail> orderdetailList = new LinkedList<Orderdetail>();
		for (int i = 0; i < cartInfo.getProductList().size(); i++) {
			Product product = cartInfo.getProductList().get(i);
			
//			ProductStockInfo momeryProduct = SystemManager.productStockMap.get(product.getId());
//			if(StringUtils.isNotBlank(momeryProduct.getActivityID())){
//				Activity activity = SystemManager.activityMap.get(momeryProduct.getActivityID());
//				String discountType = activity.getDiscountType();
//				if(discountType.equals(Activity.activity_discountType_r)){
//					//
//					double finalPrice = Double.valueOf(product.getNowPrice()) - Double.valueOf(activity.getDiscount());
//					
//				}else if(discountType.equals(Activity.activity_discountType_d)){
//					
//				}
//			}
			
			Orderdetail orderdetail = new Orderdetail();
			orderdetail.setProductID(Integer.valueOf(product.getId()));
			orderdetail.setGiftID(product.getGiftID());//商品赠品ID
			orderdetail.setPrice(product.getNowPrice());//商品现价
			orderdetail.setNumber(product.getBuyCount());//购买数
			orderdetail.setFee("0");//配送费
			orderdetail.setProductName(product.getName());
			orderdetail.setTotal0(String.valueOf(Double.valueOf(orderdetail.getPrice()) * orderdetail.getNumber()));//订单项小计

	
	private void loginLog(User u,String log) {
		Systemlog systemlog = new Systemlog();
		systemlog.setTitle(log);
		systemlog.setContent(log);
		systemlog.setAccount(u.getUsername());
		systemlog.setType(1);
		systemlog.setLoginIP(AddressUtils.getIp(RequestHolder.getRequest()));
		
		String address = null;
		if(!systemlog.getLoginIP().equals("127.0.0.1") && !systemlog.getLoginIP().equals("localhost")){
			//获取指定IP的区域位置
			try {
				address = AddressUtils.getAddresses("ip=" + systemlog.getLoginIP(), "utf-8");
			} catch (Exception e) {
				e.printStackTrace();
			}
			systemlog.setLoginArea(address);
			
			//异地登陆的判断方法为：先比较本次登陆和上次登陆的区域位置，如果不一致，说明是异地登陆；如果获取不到区域，则比较IP地址，如果IP地址和上次的不一致，则是异地登陆
			Systemlog firstSystemlog = systemlogService.selectFirstOne(u.getUsername());
			if(firstSystemlog!=null){
				if(StringUtils.isNotBlank(address) && StringUtils.isNotBlank(firstSystemlog.getLoginArea())){
					if(!address.equals(firstSystemlog.getLoginArea())){
						systemlog.setDiffAreaLogin(Systemlog.systemlog_diffAreaLogin_y);
					}
				}else if(StringUtils.isNotBlank(systemlog.getLoginIP()) && StringUtils.isNotBlank(firstSystemlog.getLoginIP())){
					if(!systemlog.getLoginIP().equals(firstSystemlog.getLoginIP())){
						systemlog.setDiffAreaLogin(Systemlog.systemlog_diffAreaLogin_y);
					}
				}
			}
		}
		
		systemlogService.insert(systemlog);
	}
	
	/**
	 * 添加用户
	 */
    @Override
    @RequestMapping("insert")
	public String insert(HttpServletRequest request, @ModelAttribute("e") User user, RedirectAttributes flushAttrs) throws Exception {
		return save0(user, flushAttrs);
	}
    
	/**
	 * 添加用户
	 */
    @RequestMapping("register")
	public String register(HttpServletRequest request, @ModelAttribute("e") User user, RedirectAttributes flushAttrs) throws Exception {

/**
 * 资源管理
 *
 */
@Controller
@RequestMapping("/manage/menu/")
public class MenuAction extends BaseController<Menu> {
	private static final long serialVersionUID = 1L;
    @Autowired
	private MenuService menuService;
    @Autowired
	private PrivilegeService privilegeService;
//	private static final String str = "../";
private static final String page_toList = "/manage/system/menu/menuList";
    private static final String page_toEdit = "/manage/system/menu/editMenu";
    private static final String page_addOrUpdate = "/manage/system/menu/addOrUpdate";

    private MenuAction() {
        super.page_toList = page_toList;
        super.page_toEdit = page_toEdit;
        super.page_toAdd = page_toEdit;
    }
    public PrivilegeService getPrivilegeService() {
		return privilegeService;
	}

	public void setPrivilegeService(PrivilegeService privilegeService) {
		this.privilegeService = privilegeService;
	}

    @Override
    public Services<Menu> getService() {
        return menuService;
    }

    @Override
	protected void selectListAfter(PagerModel pager) {
		pager.setPagerUrl("selectList");
	}

	 * @return
	 */
    @RequestMapping("show")
	public String show(@ModelAttribute("e") User e, String account, ModelMap model){
		if(StringUtils.isBlank(account)){
			throw new NullPointerException("非法请求！");
		}
		
		e.setUsername(account);
		e = getService().selectOne(e);
		model.addAttribute("e", e);
		return page_show;
	}

	/**
	 * 用户修改密码--验证旧密码是否正确
	 * @return
	 */
    @RequestMapping("checkOldPassword")
    @ResponseBody
	public String checkOldPassword(@ModelAttribute("e")User e, HttpSession session) throws Exception{
		System.out.println("checkOldPassword.."+e.getPassword());
		if(StringUtils.isBlank(e.getPassword())){
			return "{\"error\":\"旧密码不能为空!\"}";
		}else{
			//检查旧密码输入的是否正确
			User user = (User)session.getAttribute(ManageContainer.manage_session_user_info);
			String oldPass = MD5.md5(e.getPassword());
			if(user.getPassword().equals(oldPass)){
				return "{\"ok\":\"旧密码输入正确!\"}";
			}else{
				return "{\"error\":\"旧密码输入错误!\"}";
			}
		}
	}

	/**
	 * 加载后台首页数据
	 * @return
	 */
    @RequestMapping("initManageIndex")
	public String initManageIndex(){
		//店主每次登陆后台都需要加载综合统计数据？！还是说每次都触发加载，但是到底加载不加载具体看系统的加载策略？！
		manageCache.loadOrdersReport();
		return page_initManageIndex;
	}
    @Override
    public String deletes(HttpServletRequest request, String[] ids, @ModelAttribute("e") User e, RedirectAttributes flushAttrs) throws Exception{
        throw new RuntimeException("not support");
    }

			momeryProduct.setScore(proObject.getScore());
		}
		
		//上传图片
//		uploadImages();
		
		//删除产品旧的属性列表
		Attribute_link oldAttr = new Attribute_link();
		oldAttr.setProductID(Integer.valueOf(e.getId()));
		attribute_linkService.deleteByCondition(oldAttr);
		
		//保存商品属性
//		e.setAttrSelectIds(RequestHolder.getRequest().getParameterValues("attrSelectIds"));
		System.out.println("attrSelectIds="+e.getAttrSelectIds());
		if(e.getAttrSelectIds()!=null && e.getAttrSelectIds().length>0){
			for(int i=0;i<e.getAttrSelectIds().length;i++){
				String attrID = e.getAttrSelectIds()[i];
				if(StringUtils.isBlank(attrID)){
					continue;
				}
				//插入数据到属性中间表
				Attribute_link attrLink = new Attribute_link();
				attrLink.setAttrID(Integer.valueOf(attrID));
				attrLink.setProductID(Integer.valueOf(e.getId()));
				attribute_linkService.insert(attrLink);
			}
		}
		
		//保存商品参数
//		e.setParameterIds(RequestHolder.getRequest().getParameterValues("id"));
//		e.setParameterNames(RequestHolder.getRequest().getParameterValues("parameterValue"));
		if(e.getParameterNames()!=null && e.getParameterNames().length>0){
			for(int i=0;i<e.getParameterNames().length;i++){
				String pName = e.getParameterNames()[i];
				if(StringUtils.isBlank(pName)){
					continue;
				}
				//插入数据到属性中间表
				Attribute_link attrLink = new Attribute_link();
				attrLink.setAttrID(Integer.valueOf(e.getParameterIds()[i]));
				attrLink.setValue(pName);
				attrLink.setProductID(Integer.valueOf(e.getId()));
				attribute_linkService.insert(attrLink);
			}
		}
	}
	

			e.setQueryCatalogIDs(SystemManager.getInstance().getCatalogsById(e.getCatalogID()));
			super.selectList(request, e);
			return page_toList;
		} catch (Exception ex) {
			ex.printStackTrace();
			throw ex;
		}
	}
	
	@Override
	protected void setParamWhenInitQuery(Product e) {
		super.setParamWhenInitQuery(e);
		String selectOutOfStockProduct = RequestHolder.getRequest().getParameter("selectOutOfStockProduct");
		if(StringUtils.isNotBlank(selectOutOfStockProduct)){
			//后台--首页 需要查询缺货商品
			e.setSelectOutOfStockProduct(Boolean.valueOf(selectOutOfStockProduct));
		}
	}

	/**
	 * ajax查询指定商品的图片集合
	 * @return
	 */
	@Deprecated
	@RequestMapping("ajaxLoadImgList")
	@ResponseBody
	public String ajaxLoadImgList(){
		String id = RequestHolder.getRequest().getParameter("id");
		String path = RequestHolder.getRequest().getSession().getServletContext().getRealPath("/");
		System.out.println("path=" + path);
//		path = path.substring(0, path.indexOf("WEB-INF"));
//		System.out.println("path=" + path);
		path = path+"/upload/"+id+"/";
		System.out.println("path=" + path);
		
		File dir = new File(path);
		File[] fiels = dir.listFiles();
		List<String> fileList = new LinkedList<String>();
		if(fiels!=null && fiels.length>0){
			String www_address = systemManager.getProperty("www_address");
            for (int i=0;i<fiels.length;i++){
				fileList.add(www_address + "/upload/"+id+"/"+fiels[i].getName());
			}
		}
		String json = JSON.toJSONString(fileList);
		System.out.println(json);
		try {
			return (json);
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		return null;

/**
 * 门户订单服务类
 * 
 * 
 */
@Controller("frontOrderAction")
@RequestMapping("order")
public class OrderAction extends FrontBaseController<Order> {
private static final long serialVersionUID = 1L;
	@Autowired
	private OrderService orderService;
	@Autowired
	private OrderdetailService orderdetailService;
	@Autowired
	private OrderpayService orderpayService;
	@Autowired
	private ProductService productService;
	@Autowired
	private CommentService commentService;
	@Autowired
	private OrdershipService ordershipService;