电商项目总结

最新推荐文章于 2024-07-05 12:15:29 发布

hello-java-maker

最新推荐文章于 2024-07-05 12:15:29 发布

阅读量5.6k

点赞数 7

分类专栏： √ java ee √ webService 文章标签：电商商城

本文链接：https://blog.csdn.net/sihai12345/article/details/64439683

版权

√ java ee 同时被 2 个专栏收录

5 篇文章 1 订阅

订阅专栏

√ webService

3 篇文章 0 订阅

订阅专栏

最近一段时间刚刚学习了一些新的知识，就想拿个项目练练手，然后就在网上找了一个培训的电商项目练习了一下，做了之后学到了很多，学到了项目的很多流程，在这里总结一下。

一、项目介绍：
网上商城项目，用于建立网上终端、营销案在线销售及相关辅助功能，后台包含商品管理、订单管理、类目管理、客户管理、合作商管理、客服管理、支付平台、内容管理等，很大程度上分担了人工的压力，前台包括个人中心，购物车，商城首页，频道页，商品详情页，提交订单页，支付页面等页面构成，对提高客户服务效率和客户满意度能够起到较好的作用。

二、项目所用技术：
1、Jsp,freemarker,jquery,css+div,jstl标签，fckEditor, struts-menu
2、Springmvc,spring,mybatis
3、Webservice框架cxf
4、Jersey搭建图片服务器
5、Maven,svn,hudson
6、Oracle

三、开发环境：
1、Eclipse4.3
2、Tomcat7.0
3、Jdk1.7
4、Oracle10g
5、Maven3.1.5
6、Svn
7、hudson

四、系统架构：
这里使用maven进行依赖管理
这里写图片描述

接下来，我把这里面比较核心的模块分析一下，进行总结，里面包括：

后台：

1、品牌管理：包括简单的增删改查
2、商品管理：里面有一个比较核心的商品添加到前台的功能，主要的业务包括操作商品表、商品大字段表、商品属性表、商品的特殊属性表
3、订单管理：订单的增删改查，商品的上架，商品的发布（通过webService）。

前台：
1、商品的首页展示：通过多表查询进行分页查询显示
2、商品的单品页展示：利用freemaker技术对页面进行静态化处理，在后台进行静态化的发布，这样的好处是查询的时候只需查询一次数据库，静态化之后不需要再查询，大大的提高了系统的效率。
3、购物车：使用cookie技术，好处:用户不需要登录即可操作购物车。
4、订单流程：这里使用工作流activiti，这里对工作流的使用进行了加强。

五、核心模块的总结：

6.1、商品的添加：

操作商品表、商品大字段表、商品属性表、商品的特殊属性表

aaction层：

@RequestMapping("/addItem.do")
	public String addItem(EbItem item, EbItemClob itemClob, HttpServletRequest request,Integer divNum){
		item.setItemNo(new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date()));
		List<EbFeature> commList = featureService.selectCommFeature();
		List<EbParaValue> paraList = new ArrayList<EbParaValue>();
		for(EbFeature feature: commList){
			//获得属性的id也就是普通属性在页面上的name
			Long featureId = feature.getFeatureId();
			if(feature.getInputType() == 3){
				String [] paraArr = request.getParameterValues(featureId+"");
				if(paraArr != null && paraArr.length > 0){
					String paraVals = "";
					for(String val : paraArr){
						paraVals = paraVals + val + ",";
					}
					paraVals = paraVals.substring(0, paraVals.length() - 1);
					EbParaValue pv = new EbParaValue();
					pv.setFeatureId(featureId);
					pv.setParaValue(paraVals);
					paraList.add(pv);
				}
				
			}else{
				String paraVal = request.getParameter(featureId+"");
				if(StringUtils.isNotBlank(paraVal)){
					EbParaValue pv = new EbParaValue();
					pv.setFeatureId(featureId);
					pv.setParaValue(paraVal);
					paraList.add(pv);
				}
			}
		}
		List<EbSku> skuList = new ArrayList<EbSku>();
		List<EbFeature> specList = featureService.selectSpecFeature();
		//skuType1   showStatus1   sort1     skuPrice1  marketPrice1  stockInventory1  skuUpperLimit1  sku1  location1
		//遍历div数量
		for(int i = 1; i <= divNum; i++){
			//获得商城价和库存，他们是必填的字段
			String skuPrice = request.getParameter("skuPrice"+i);
			String stock = request.getParameter("stockInventory"+i);
			//如果上面的必填字段不是空说明数据有效
			if(StringUtils.isNotBlank(skuPrice) && StringUtils.isNotBlank(stock)){
				String skuType = request.getParameter("skuType"+i);
				String showStatus = request.getParameter("showStatus"+i);
				String sort = request.getParameter("sort"+i);
				String marketPrice = request.getParameter("marketPrice"+i);
				String skuUpperLimit = request.getParameter("skuUpperLimit"+i);
				String sku = request.getParameter("sku"+i);
				String location = request.getParameter("location"+i);
				//创建最小销售单元的对象，并且赋值
				EbSku skuObj = new EbSku();
				skuObj.setSkuPrice(new BigDecimal(skuPrice));
				skuObj.setStockInventory(new Integer(stock));
				if(StringUtils.isNotBlank(skuType) && !StringUtils.equals(skuType, "")){
					skuObj.setSkuType(new Short(skuType));
				}
				if(StringUtils.isNotBlank(showStatus) && !StringUtils.equals(showStatus, "")){
					skuObj.setShowStatus(new Short(showStatus));
				}
				if(StringUtils.isNotBlank(sort) && !StringUtils.equals(sort, "")){
					skuObj.setSkuSort(new Integer(sort));
				}
				if(StringUtils.isNotBlank(marketPrice) && !StringUtils.equals(marketPrice, "")){
					skuObj.setMarketPrice(new BigDecimal(marketPrice));
				}
				if(StringUtils.isNotBlank(skuUpperLimit) && !StringUtils.equals(skuUpperLimit, "")){
					skuObj.setSkuUpperLimit(new Integer(skuUpperLimit));
				}
				skuObj.setSku(sku);
				skuObj.setLocation(location);
				
				List<EbSpecValue> specValList = new ArrayList<EbSpecValue>();
				//获得每个最小销售单元所拥有的规格属性值，
				//遍历规格属性
				for(EbFeature feature : specList){
					Long featureId = feature.getFeatureId();
					//获得所选规格属性的值
					String specVal = request.getParameter(featureId+"specradio"+i);
					//创建规格对象
					EbSpecValue spec = new EbSpecValue();
					spec.setFeatureId(featureId);
					spec.setSpecValue(specVal);
					specValList.add(spec);
				}
				skuObj.setSpecList(specValList);
				skuList.add(skuObj);
			}
			
		}
		itemService.saveItem(item, itemClob, paraList, skuList);
		return "redirect:listItem.do?showStatus=1&auditStatus=1";
	}

service层：

public void saveItem(EbItem item, EbItemClob itemClob,
			List<EbParaValue> paraList, List<EbSku> skuList) {
		itemDao.saveItem(item);
		paraValueDao.saveParaValue(paraList, item.getItemId());
		itemClobDao.saveItemClob(itemClob, item.getItemId());
		skuDao.saveSku(skuList, item.getItemId());
		
	}

6.2、商品分页sql

<!-- 

  	分页查询的结果集

   -->

  <select id="selectItemByCondition" parameterType="com.rl.ecps.model.QueryCondition" resultMap="BaseResultMap">

  select *

  from (select rownum rw, a.*

          from (

          select * from eb_item t

          <where>

          	<if test="brandId != null">

          		t.brand_id = #{brandId}

          	</if>

          	<if test="auditStatus != null">

          		and t.audit_status = #{auditStatus}

          	</if>

          	<if test="showStatus != null">

          		and t.show_status = #{showStatus}

          	</if>

          	<if test="itemName != null">

          		and t.item_name like '%${itemName}%'

          	</if>

          </where>

          order by t.item_id desc

          <![CDATA[

          ) a

         where rownum < #{endNum}) b

 where b.rw > #{startNum}

 ]]>

  </select>

6.3、商品的首页查询筛选

6.3.1、sql

<!-- 

  	map.put("minPrice", 4000);

  	map.put("maxPrice", 4999);

  	map.put("brandId", 1003);

  	map.put("paraList", String[] paraList)

   -->

  <select id="listItem" parameterType="map" resultMap="listItemRM">

  	select min(es.sku_price) sku_price, ei.*

  from eb_item ei, eb_sku es

  <where>

  	ei.item_id = es.item_id

  	<if test="minPrice != null">

  		and es.sku_price between #{minPrice} and #{maxPrice}

  	</if>

  	<if test="brandId != null">

  		 and ei.brand_id = #{brandId}

  	</if>

  	<if test="paraList != null">

  		<foreach collection="paraList" item="paraValue">

	  		and exists (select *

	          from eb_para_value t

	         where ei.item_id = t.item_id

	           and t.para_value = #{paraValue})

  		</foreach>

  	</if>

  </where>

 group by ei.ITEM_ID,

          ei.ITEM_NAME,

          ei.ITEM_NO,

          ei.BRAND_ID,

          ei.CAT_ID,

          ei.TAG_IMG_ID,

          ei.TAG_IMG,

          ei.IS_NEW,

          ei.IS_GOOD,

          ei.IS_HOT,

          ei.PROMOTION,

          ei.AUDIT_STATUS,

          ei.SHOW_STATUS,

          ei.IMGS,

          ei.KEYWORDS,

          ei.PAGE_DESC,

          ei.ITEM_RECYCLE,

          ei.ON_SALE_TIME,

          ei.CHECK_TIME,

          ei.UPDATE_TIME,

          ei.UPDATE_USER_ID,

          ei.CREATE_TIME,

          ei.CHECKER_USER_ID,

          ei.FULL_PATH_DEPLOY,

         ei.FULL_PATH_DEPLOY_OFFER,

          ei.ORIGINAL_ITEM_ID,

          ei.LAST_STATUS,

          ei.MERCHANT_ID,

          ei.ITEM_SORT,

          ei.SALES,

          ei.CREATE_USER_ID,

          ei.SIM_LEVEL,

          ei.GIFT_DESC,

          ei.GIFT_IMG,

          ei.GIFT_SHOW_TYPE,

          ei.IMG_SIZE1

          order by ei.item_id desc

  </select>

7、商品页静态化
主要将jsp改为静态的html页面，利用freemaker语法。

8、购物车
购物车利用cookie存储在浏览器，在后台拿到cookie进行数据操作。

购物车模块：
接口:

/**
	 * 查询购物车所有商品
	 * @param request 
	 * @param response
	 * @return
	 */
	public List<EbCart> listCart(HttpServletRequest request, HttpServletResponse response);
	
	/**
	 * 添加购物车
	 * @param request
	 * @param response
	 * @param skuId 最小销售单元id
	 * @param quantity 商品数量
	 */
	public void addCart(HttpServletRequest request, HttpServletResponse response, Long skuId, Integer quantity);
	
	/**
	 * 根据商品id商品数量加一
	 * @param request
	 * @param response
	 * @param skuId 最小销售单元id
	 */
	public void addNum(HttpServletRequest request, HttpServletResponse response, Long skuId);
	
	/**
	 * 根据商品id商品数量减一
	 * @param request
	 * @param response
	 * @param skuId 最小销售单元id
	 */
	public void reduceNum(HttpServletRequest request, HttpServletResponse response, Long skuId);
	
	public void deleteCart(HttpServletRequest request, HttpServletResponse response, Long skuId);
	
	public void clearCart(HttpServletRequest request, HttpServletResponse response);
	
	public String validCookie(HttpServletRequest request, HttpServletResponse response);
	
	public String validCar(HttpServletRequest request, HttpServletResponse response);

实现类：

public List<EbCart> listCart(HttpServletRequest request,
			HttpServletResponse response) {
		List<EbCart> cartList = new ArrayList<EbCart>();
		//获取浏览器所有cookie
		Cookie[] cookies = request.getCookies();
		//[{skuId:1,quantity:2},{}]
		if(cookies != null && cookies.length > 0){
			for (Cookie cookie : cookies) {
				String code = ECPSUtils.readProp("cookie_ecps_code");
				String name = cookie.getName();
				if(StringUtils.equals(name, code)){
					String result = cookie.getValue();
					//对其进行解码，防止中文乱码
					result = URLDecoder.decode(result);
					JSONArray ja = JSONArray.fromObject(result);
					JsonConfig jc = new JsonConfig();
					//设置要转换的类
					jc.setRootClass(EbCart.class);
					//排除类里面的属性
					jc.setExcludes(new String[]{"sku"});
					cartList = (List<EbCart>) JSONSerializer.toJava(ja, jc);
					//根据skuid设置购物车对象的EbSku对象
					for (EbCart cart : cartList) {
						EbSku sku = skuDao.getSkuDetailById(cart.getSkuId());
						cart.setSku(sku);
					}
				}
			}
		}
		
		return cartList;
	}

	public void addCart(HttpServletRequest request,
			HttpServletResponse response, Long skuId, Integer quantity) {
		List<EbCart> cartList = new ArrayList<EbCart>();
		
		//json的配置对象
		JsonConfig jc = new JsonConfig();
		//设置要转换的类
		jc.setRootClass(EbCart.class);
		//设置不需要转换的属性
		jc.setExcludes(new String[]{"sku"});
		Cookie[] cookies = request.getCookies();
		if(cookies != null&&cookies.length > 0){
			for(Cookie cookie : cookies){
				String name = cookie.getName();
				String cookieKey = ECPSUtils.readProp("cookie_ecps_code");
				if(StringUtils.equals(name, cookieKey)){
					//获得cookie的值
					String result = cookie.getValue();
					//[{skuId:1002, quantity:2}, {skuId:1003, quantity:3},....]
					result = URLDecoder.decode(result);
					//把json格式的字符串转换成json数组对象
					JSONArray ja = JSONArray.fromObject(result);
					//把json的数组转换成java集合
					cartList = (List<EbCart>) JSONSerializer.toJava(ja, jc);
					
					boolean isExsits = false;
					//1.如果存在对应商品，则在基础上数量加一
					for(EbCart cart: cartList){
						if(cart.getSkuId().longValue() == skuId.longValue()){
							cart.setQuantity(cart.getQuantity() + quantity);
							isExsits = true;
						}
					}
					//2.如果不存在，则创建新的对象
					if(!isExsits){
						EbCart cartObj = new EbCart();
						cartObj.setSkuId(skuId);
						cartObj.setQuantity(quantity);
						cartList.add(cartObj);
					}
					
				}
			}
		}
		//3.如果没有创建过cookie对象，则创建
		if(cartList.size() == 0){
			EbCart cartObj = new EbCart();
			cartObj.setSkuId(skuId);
			cartObj.setQuantity(quantity);
			cartList.add(cartObj);
		}
		//将java对象再次转换为字符串存到cookie中
		JSONArray ja = JSONArray.fromObject(cartList, jc);
		String result = ja.toString();
		result = URLEncoder.encode(result);
		Cookie cookie = new Cookie("cookie_ecps_code", result);
		cookie.setMaxAge(Integer.MAX_VALUE);
		cookie.setPath("/");
		response.addCookie(cookie);
	}

	public void addNum(HttpServletRequest request,
			HttpServletResponse response, Long skuId) {
		List<EbCart> cartList = new ArrayList<EbCart>();
		
		//json的配置对象
		JsonConfig jc = new JsonConfig();
		//设置要转换的类
		jc.setRootClass(EbCart.class);
		//设置不需要转换的属性
		jc.setExcludes(new String[]{"sku"});
		Cookie[] cookies = request.getCookies();
		if(cookies != null&&cookies.length > 0){
			for(Cookie cookie : cookies){
				String name = cookie.getName();
				String cookieKey = ECPSUtils.readProp("cookie_ecps_code");
				if(StringUtils.equals(name, cookieKey)){
					//获得cookie的值
					String result = cookie.getValue();
					//[{skuId:1002, quantity:2}, {skuId:1003, quantity:3},....]
					result = URLDecoder.decode(result);
					//把json格式的字符串转换成json数组对象
					JSONArray ja = JSONArray.fromObject(result);
					//把json的数组转换成java集合
					cartList = (List<EbCart>) JSONSerializer.toJava(ja, jc);
					
					for(EbCart cart: cartList){
						if(cart.getSkuId().longValue() == skuId.longValue()){
							cart.setQuantity(cart.getQuantity() + 1);
						}
					}
					
				}
			}
		}
		//将java对象再次转换为字符串存到cookie中
		JSONArray ja = JSONArray.fromObject(cartList, jc);
		String result = ja.toString();
		result = URLEncoder.encode(result);
		Cookie cookie = new Cookie("cookie_ecps_code", result);
		cookie.setMaxAge(Integer.MAX_VALUE);
		cookie.setPath("/");
		response.addCookie(cookie);
	}

	@SuppressWarnings("deprecation")
	public void reduceNum(HttpServletRequest request,
			HttpServletResponse response, Long skuId) {
		List<EbCart> cartList = new ArrayList<EbCart>();
		Cookie[] cookies = request.getCookies();
		JsonConfig jc = new JsonConfig();
		jc.setRootClass(EbCart.class);
		jc.setExcludes(new String[]{"sku"});
		if(cookies != null && cookies.length > 0){
			for (Cookie cookie : cookies) {
				String name = cookie.getName();
				String code = ECPSUtils.readProp("cookie_ecps_code");
				if(StringUtils.equals(name, code)){
					String result = cookie.getValue();
					//将html编码解码
					result = URLDecoder.decode(result);
					JSONArray ja = JSONArray.fromObject(result);
					cartList = (List<EbCart>) JSONSerializer.toJava(ja, jc);
					for(EbCart cart : cartList){
						if(cart.getSkuId().longValue() == skuId.longValue()){
							cart.setQuantity(cart.getQuantity() - 1);
						}
					}
				}
			}
		}
		//将java对象再次转换为字符串存到cookie中
		JSONArray ja = JSONArray.fromObject(cartList, jc);
		String result = ja.toString();
		result = URLEncoder.encode(result);
		Cookie cookie = new Cookie("cookie_ecps_code", result);
		cookie.setMaxAge(Integer.MAX_VALUE);
		cookie.setPath("/");
		response.addCookie(cookie);
	}

	public void deleteCart(HttpServletRequest request,
			HttpServletResponse response, Long skuId) {
		List<EbCart> cartList = new ArrayList<EbCart>();
		
		//json的配置对象
		JsonConfig jc = new JsonConfig();
		//设置要转换的类
		jc.setRootClass(EbCart.class);
		//设置不需要转换的属性
		jc.setExcludes(new String[]{"sku"});
		Cookie[] cookies = request.getCookies();
		if(cookies != null&&cookies.length > 0){
			for(Cookie cookie : cookies){
				String name = cookie.getName();
				String cookieKey = ECPSUtils.readProp("cookie_ecps_code");
				if(StringUtils.equals(name, cookieKey)){
					//获得cookie的值
					String result = cookie.getValue();
					//[{skuId:1002, quantity:2}, {skuId:1003, quantity:3},....]
					result = URLDecoder.decode(result);
					//把json格式的字符串转换成json数组对象
					JSONArray ja = JSONArray.fromObject(result);
					//把json的数组转换成java集合
					cartList = (List<EbCart>) JSONSerializer.toJava(ja, jc);
					
					for(EbCart cart: cartList){
						if(cart.getSkuId().longValue() == skuId.longValue()){
							cartList.remove(cart);
						}
					}
					
				}
			}
		}
		//将java对象再次转换为字符串存到cookie中
		JSONArray ja = JSONArray.fromObject(cartList, jc);
		String result = ja.toString();
		result = URLEncoder.encode(result);
		Cookie cookie = new Cookie("cookie_ecps_code", result);
		cookie.setMaxAge(Integer.MAX_VALUE);
		cookie.setPath("/");
		response.addCookie(cookie);
	}

	public void clearCart(HttpServletRequest request,
			HttpServletResponse response) {
		List<EbCart> cartList = new ArrayList<EbCart>();
		
		//json的配置对象
		JsonConfig jc = new JsonConfig();
		//设置要转换的类
		jc.setRootClass(EbCart.class);
		//设置不需要转换的属性
		jc.setExcludes(new String[]{"sku"});
		Cookie[] cookies = request.getCookies();
		if(cookies != null&&cookies.length > 0){
			for(Cookie cookie : cookies){
				String name = cookie.getName();
				String cookieKey = ECPSUtils.readProp("cookie_ecps_code");
				if(StringUtils.equals(name, cookieKey)){
					//获得cookie的值
					String result = cookie.getValue();
					//[{skuId:1002, quantity:2}, {skuId:1003, quantity:3},....]
					result = URLDecoder.decode(result);
					//把json格式的字符串转换成json数组对象
					JSONArray ja = JSONArray.fromObject(result);
					//把json的数组转换成java集合
					cartList = (List<EbCart>) JSONSerializer.toJava(ja, jc);
					cartList.clear();
				}
			}
		}
		
		JSONArray ja = JSONArray.fromObject(cartList, jc);
		String result = ja.toString();
		result = URLEncoder.encode(result);
		Cookie cookie = new Cookie("cookie_ecps_code", result);
		cookie.setMaxAge(Integer.MAX_VALUE);
		cookie.setPath("/");
		response.addCookie(cookie);
	}

	public String validCookie(HttpServletRequest request,
			HttpServletResponse response) {
		/**
		 * 1.创建cookie设置到浏览器
		 * 2.取cookie，看是否能拿到，如果拿到，说明浏览器cookie正常，否则，关闭了
		 */
		Cookie cookie = new Cookie("test", "test");
		response.addCookie(cookie);
		Cookie[] cookies = request.getCookies();
		String result = "yes";//默认为cookie可用
		if(cookies != null && cookies.length > 0){
			for (Cookie cookie2 : cookies) {
				String name = cookie2.getName();
				String value = cookie2.getValue();
				System.out.println(name+"="+value);
				if((StringUtils.equals("test", name) && StringUtils.equals("test", value))){
					result = "no";
				}
			}
		}
		System.out.println(result);
		return "yes";
	}

	public String validCar(HttpServletRequest request,
			HttpServletResponse response) {
		String result1 = "success";
		List<EbCart> cartList = new ArrayList<EbCart>();
		//获得当前网站的cookie
		Cookie[] cookies = request.getCookies();
		if(cookies != null&&cookies.length > 0){
			for(Cookie cookie : cookies){
				String name = cookie.getName();
				String cookieKey = ECPSUtils.readProp("cart_key");
				if(StringUtils.equals(name, cookieKey)){
					//获得cookie的值
					String result = cookie.getValue();
					//[{skuId:1002, quantity:2}, {skuId:1003, quantity:3},....]
					result = URLDecoder.decode(result);
					//把json格式的字符串转换成json数组对象
					JSONArray ja = JSONArray.fromObject(result);
					//json的配置对象
					JsonConfig jc = new JsonConfig();
					//设置要转换的类
					jc.setRootClass(EbCart.class);
					//设置不需要转换的属性
					jc.setExcludes(new String[]{"sku"});
					//把json的数组转换成java集合
					cartList = (List<EbCart>) JSONSerializer.toJava(ja, jc);
					for (EbCart cart : cartList) {
						//判断库存商品数量是否大于购买数量
						EbSku sku = skuDao.getSkuDetailById(cart.getSkuId());
						if(sku.getStockInventory().intValue() < cart.getQuantity().intValue()){
							//提示信息：哪个商品什么规格不足多少
							result1 = sku.getItem().getItemName();//哪个商品
							for(EbSpecValue spec : sku.getSpecList()){
								result1 = result1 + spec.getSpecValue();//哪个规格
							}
							result1 = result1 + "不足" + cart.getQuantity();//不足多少
							break;//循环到库存不足的商品就跳出
						}
					}
				}
			}
		}
		return result1;
	}

9、订单提交
订单提交的时候，注意每一次提交都要验证库存是否足够

页面：

//订单提交
function trueBuy(){
	$.ajax({
		url:"${path}/user/getUser.do",
		type:"post",
		dataType:"text",
		success:function(responseText){
			var userObj  = $.parseJSON(responseText);
			if(userObj.user != null){
				var result = validCar();
				if(result == "success"){
					window.location.href = "${path}/order/toSubmitOrder.do";
				}else{
					alert(result);
				}
			}else{
				tipShow("#loginAlert");
			}
		},
		error:function(){
			alert("系统错误");
		}
	})
}

//购买数量减一
function reduceNum(skuId, quantity){
	
	var jsonObj = validStock(skuId, quantity);
	
	if(jsonObj.result == "no"){
		var newQuantity = quantity - 1;
		alert("当前的库存数量不足"+newQuantity+"个,仅有"+jsonObj.stock+"个");
		return;
	}
	if(quantity == 1){
		if(confirm("是否把该商品从购物车中删除?")){
			window.location.href = "${path}/cart/deleteCart.do?skuId="+skuId;
		}
	}else{
		window.location.href = "${path}/cart/reduceNum.do?skuId="+skuId;
	}
}

//验证库存数量
function validStock(skuId, quantity){
	quantity--;
	var jsonObj = null;
	$.ajax({
		url:"${path}/cart/validStockCar.do",
		type:"post",
		dataType:"text",
		async:false,
		data:{
			skuId:skuId,
			quantity:quantity
		},
		success:function(responseText){
			jsonObj = $.parseJSON(responseText);
		},
		error:function(){
			alert("系统错误");
		}
		
	})
	return jsonObj;
}
function changeImage(){
	var path = "${path}/user/getImage.do?date="+new Date();
	$("#captchaImage").attr("src", path);
}

//提交订单异步登录
function loginAjax(){
	var username = $("#username").val();
	var password = $("#password").val();
	var captcha = $("#captcha").val();
	$.ajax({
		url:"${path}/user/loginAjax.do",
		type:"post",
		dataType:"text",
		data:{
			username:username,
			password:password,
			captcha:captcha
		},
		success:function(responseText){
			if(responseText == "caperror"){
				$("#errorName").html("验证码错误");
				$("#errorName").show(500);
			}else if(responseText == "userpasserror"){
				$("#errorName").html("用户名或者密码错误");
				$("#errorName").show(500);
			}else if(responseText == "success"){
				$("#loginAlertIs").html(username);
				tipHide("#loginAlert");
				//校验库存
				var result = validCar();
				if(result == "success"){
					window.location.href = "${path}/order/toSubmitOrder.do";
				}else{
					alert(result);
				}
			}
		},
		error:function(){
			alert("系统错误");
		}
		
	})
}

//验证库存是否足够
function validCar(){
	var result = "success";
	$.ajax({
		url:"${path}/cart/validCar.do",
		type:"post",
		dataType:"text",
		async:false,
		success:function(responseText){
			result = responseText;
		},
		error:function(){
			alert("系统错误");
		}
		
	})
	return result;
}

action：

//订单提交
	@RequestMapping("/submitOrder.do")
	public String submitOrder(HttpServletResponse response, HttpServletRequest request,EbOrder order,
			HttpSession session, String address, Model model) throws Exception{
		TsPtlUser user = (TsPtlUser) session.getAttribute("user");
		if(user != null){
			order.setPtlUserId(user.getPtlUserId());
			order.setUsername(user.getUsername());
		}
		order.setOrderNum(new SimpleDateFormat("yyyyMMddHHmmss").format(new Date()));
		//1.如果不是新添加的地址，則通過地址的id查詢當前的地址
		//2.新添加的地址，會自動的賦值給order對象
		if(!StringUtils.equals("add", address)){
			EbShipAddr addr = shipAddrService.selectAddrByShipAddrId(new Long(address));
			BeanUtils.copyProperties(order, addr);
		}
		List<EbCart> cartList = cartService.listCart(request, response);
		List<EbOrderDetail> detailList = new ArrayList<EbOrderDetail>();
		for(EbCart cart:cartList){
			EbOrderDetail detail = new EbOrderDetail();
			detail.setItemId(cart.getSku().getItem().getItemId());
			detail.setItemName(cart.getSku().getItem().getItemName());
			detail.setItemNo(cart.getSku().getItem().getItemNo());
			detail.setSkuId(cart.getSkuId());
			String specVal = "";
			List<EbSpecValue> specList = cart.getSku().getSpecList();
			for(EbSpecValue spec : specList){
				specVal = specVal + spec.getSpecValue()+",";
			}
			specVal = specVal.substring(0, specVal.length() - 1);
			detail.setSkuSpec(specVal);
			detail.setQuantity(cart.getQuantity());
			detail.setSkuPrice(cart.getSku().getSkuPrice());
			detail.setMarketPrice(cart.getSku().getMarketPrice());
			detailList.add(detail);
		}
		try {
			String processInstanceId = orderService.saveOrder(response, request, order, detailList);
			model.addAttribute("order", order);
			model.addAttribute("processInstanceId", processInstanceId);
		} catch (Exception e) {
			if(e instanceof EbStockException){
				model.addAttribute("tip", "stock_error");
			}
		}
		return "shop/confirmProductCase2";
	}
	
	/**
	 * 订单支付
	 */
	@RequestMapping("/pay.do")
	public void pay(String processInstanceId, Long orderId, PrintWriter out){
		orderService.pay(processInstanceId, orderId);
		out.write("success");
	}

service：

public String saveOrder(HttpServletResponse response, HttpServletRequest request,
			EbOrder order, List<EbOrderDetail> detailList)throws EbStockException {
		orderDao.saveOrder(order);
		Map<String,Object> map = new HashMap<String,Object>();
		for(EbOrderDetail detail : detailList){
			//給訂單詳情設置訂單id
			detail.setOrderId(order.getOrderId());
			detailDao.saveOrderDetail(detail);
			
			/*EbSku sku = skuDao.getSkuById(detail.getSkuId());
			
			sku.setStockInventory(sku.getStockInventory() - detail.getQuantity());
			skuDao.update(sku);*/
			map.put("skuId", detail.getSkuId());
			map.put("quantity", detail.getQuantity());
			//為了防止并发问题，这里可以使用：
			//1.悲观锁：对查询语句进行锁，即for update
			//2.乐观锁：对修改语句进行锁，即条件加判断条件：会返回影响数量
			int flag = skuDao.updateStock(map);
			if(flag == 0){
				throw new EbStockException("库存不足");
			}
			
		}
		//保存订单时，开启一个流程实例
		String processInstanceId = flowService.startProcess(order.getOrderId());
		cartService.clearCart(request, response);
		return processInstanceId;
	}
	
	public void pay(String processInstanceId, Long orderId){
		//修改订单支付状态
		EbOrder order = new EbOrder();
		order.setOrderId(orderId);
		order.setIsPaid((short)1);
		orderDao.updateOrder(order);
		//完成订单支付节点
		flowService.completeTaskByPId(processInstanceId, "支付");
	}

	public List<TaskBean> listNoPayOrder(Short isCall, String assignee) {
		/**
		 * 1.根据办理人查询到task和businesskey
		 * 2.根据businesskey查询订单
		 * 3.根据iscall查询未支付的订单
		 */
		List<TaskBean> tbList1 = new ArrayList<TaskBean>();
		List<TaskBean> tbList = flowService.selectTaskBeanByAssignee(assignee);
		for (TaskBean tb : tbList) {
			EbOrder order = orderDao.selectOrderById(tb.getBusinessKey());
			//查询没有付款的订单
			if(order.getIsCall().shortValue() == isCall.shortValue()){
				tb.setOrder(order);
				tbList1.add(tb);
			}
		}
		return tbList1;
	}

	public EbOrder selectOrderAndDetailById(Long orderId) {
		return orderDao.selectOrderAndDetailById(orderId);
	}

	public void updateOrder(Long orderId) {
		EbOrder order = new EbOrder();
		order.setOrderId(orderId);
		order.setIsCall((short)1);
		orderDao.updateOrder(order);
	}

	public List<TaskBean> listPaidOrder(String assignee) {
		/**
		 * 1.根据办理人查询到task和businesskey
		 * 2.根据businesskey查询订单
		 * 3.根据iscall查询未支付的订单
		 */
		List<TaskBean> tbList = flowService.selectTaskBeanByAssignee(assignee);
		for (TaskBean tb : tbList) {
			EbOrder order = orderDao.selectOrderById(tb.getBusinessKey());
			//查询没有付款的订单
			tb.setOrder(order);
		}
		return tbList;
	}
	
	public TaskBean selectTaskBeanByOrderIdAndTaskId(Long orderId, String taskId) {
		EbOrder order = orderDao.selectOrderAndDetailById(orderId);
		TaskBean tb = flowService.selectTaskBeanByTaskId(taskId);
		tb.setOrder(order);
		return tb;
	}

	public void compeleTask(String taskId, String outcome, Long orderId) {
		EbOrder order = new EbOrder();
		order.setOrderId(orderId);
		order.setUpdateTime(new Date());
		flowService.compeleTaskByTaskId(taskId, outcome);
	}

10、订单流程

这里采用工作流activiti整合ssm

10.1、业务流程图

10.3、service层

public void deployFlow() {
		DeploymentBuilder db = repositoryService.createDeployment();
		db.addClasspathResource("com/sihai/ecps/diagrams/OrderFlow.bpmn")
		  .addClasspathResource("com/sihai/ecps/diagrams/OrderFlow.png");
		db.deploy();
	}

	public String startProcess(Long orderId) {
		ProcessInstance pi = runtimeService.startProcessInstanceByKey("OrderFlow", orderId+"");
		return pi.getId();
	}

	public void completeTaskByPId(String processInstanceId, String outcome) {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("outcome", outcome);
		Task task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
		taskService.complete(task.getId(), map);
	}

	public List<TaskBean> selectTaskBeanByAssignee(String assignee) {
		//根据办理人查询任务列表
		List<Task> tList = taskService.createTaskQuery()
		.processDefinitionKey("OrderFlow")
		.taskAssignee(assignee)
		.orderByTaskCreateTime()
		.desc()
		.list();
		List<TaskBean> tbList = new ArrayList<TaskBean>();
		for (Task task : tList) {
			//设置任务和businesskey
			TaskBean tb = new TaskBean();
			tb.setTask(task);
			ProcessInstance pi = runtimeService.createProcessInstanceQuery()
					.processDefinitionKey("OrderFlow")
					.processInstanceId(task.getProcessInstanceId())
					.singleResult();
			String businessKey = pi.getBusinessKey();
			tb.setBusinessKey(businessKey);
			tbList.add(tb);
		}
		return tbList;
	}
	
	public TaskBean selectTaskBeanByTaskId(String taskId) {
		Task task = taskService.createTaskQuery().processDefinitionKey("OrderFlow").taskId(taskId).singleResult();
		TaskBean tb = new TaskBean();
		tb.setTask(task);
		List<String> outcomes = this.getOutcomes(task);
		tb.setOutcomes(outcomes);
		return tb;
	}
	
	public List<String> getOutcomes(Task task){
		List<String> outcomes = new ArrayList<String>();
		//获得流程定义的对象
		ProcessDefinitionEntity pe = (ProcessDefinitionEntity) repositoryService.getProcessDefinition(task.getProcessDefinitionId());
		//获得流程实例对象
		ProcessInstance pi = runtimeService.createProcessInstanceQuery().processDefinitionKey("OrderFlow")
		.processInstanceId(task.getProcessInstanceId()).singleResult();
		ActivityImpl ai = pe.findActivity(pi.getActivityId());
		//获得往外面走的线路的对象
		List<PvmTransition> ptList = ai.getOutgoingTransitions();
	
		for(PvmTransition pt : ptList){
			String name = (String) pt.getProperty("name");
			outcomes.add(name);
		}
		return outcomes;
	}


	public void compeleTaskByTaskId(String taskId, String outcome) {
		Map<String,Object> map = new HashMap<String,Object>();
		map.put("outcome", outcome);
		Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
		taskService.complete(task.getId(), map);
	}

最后，写了好久，就把这些核心的写出来，总结总结一下，以后好看看