javaweb图书商城设计之订单模块(5)

/**
 * 订单条目类
 */
public class orderitem {
 private string iid;
 private int count;// 数量
 private double subtotal;// 小计
 private order order;// 所属订单
 private book book;// 所要购买的图书
}

/**
 * 订单类
 */
public class order {
 private string oid;
 private date ordertime;// 下单时间
 private double total;// 合计
 private int state;// 订单状态有四种：1未付款 2已付款但未发货 3已发货但未确认收货 4已确认交易成功
 private user owner;// 订单所有者
 private string address;// 收货地址

 private list<orderitem> orderitemlist;//当前订单下所有条目 
}

public class orderdao {
 private queryrunner qr = new txqueryrunner();

 /**
  * 添加订单
  * @param order
  */
 public void addorder(order order) {
  try {
   string sql = "insert into orders values(?,?,?,?,?,?)";
   /*
    * 处理util的date转换成sql的timestamp
    */
   timestamp timestamp = new timestamp(order.getordertime().gettime());
   object[] params = {order.getoid(), timestamp, order.gettotal(),
     order.getstate(), order.getowner().getuid(),
     order.getaddress()};
   qr.update(sql, params);
  } catch(sqlexception e) {
   throw new runtimeexception(e);
  }
 }

 /**
  * 插入订单条目
  * @param orderitemlist
  */
 public void addorderitemlist(list<orderitem> orderitemlist) {
  /**
   * queryrunner类的batch(string sql, object[][] params)
   * 其中params是多个一维数组！
   * 每个一维数组都与sql在一起执行一次，多个一维数组就执行多次
   */
  try {
   string sql = "insert into orderitem values(?,?,?,?,?)";
   /*
    * 把orderitemlist转换成两维数组
    * 把一个orderitem对象转换成一个一维数组
    */
   object[][] params = new object[orderitemlist.size()][];
   // 循环遍历orderitemlist，使用每个orderitem对象为params中每个一维数组赋值
   for(int i = 0; i < orderitemlist.size(); i++) {
    orderitem item = orderitemlist.get(i);
    params[i] = new object[]{item.getiid(), item.getcount(), 
      item.getsubtotal(), item.getorder().getoid(),
      item.getbook().getbid()}; 
   }
   qr.batch(sql, params);//执行批处理
  } catch(sqlexception e) {
   throw new runtimeexception(e);
  }
 }

 /**
  * 按uid查询订单
  * @param uid
  * @return
  */
 public list<order> findbyuid(string uid) {
  /*
   * 1. 通过uid查询出当前用户的所有list<order>
   * 2. 循环遍历每个order，为其加载他的所有orderitem
   */
  try {
   /*
    * 1. 得到当前用户的所有订单
    */
   string sql = "select * from orders where uid=?";
   list<order> orderlist = qr.query(sql, new beanlisthandler<order>(order.class), uid);

   /*
    * 2. 循环遍历每个order，为其加载它自己所有的订单条目
    */
   for(order order : orderlist) {
    loadorderitems(order);//为order对象添加它的所有订单条目
   }

   /*
    * 3. 返回订单列表
    */
   return orderlist;
  } catch(sqlexception e) {
   throw new runtimeexception(e);
  }
 }

 /**
  * 加载指定的订单所有的订单条目
  * @param order
  * @throws sqlexception 
  */
 private void loadorderitems(order order) throws sqlexception {
  /*
   * 查询两张表：orderitem、book
   */
  string sql = "select * from orderitem i, book b where i.bid=b.bid and oid=?";
  /*
   * 因为一行结果集对应的不再是一个javabean，所以不能再使用beanlisthandler，而是maplisthandler
   */
  list<map<string,object>> maplist = qr.query(sql, new maplisthandler(), order.getoid());
  /*
   * maplist是多个map，每个map对应一行结果集
   * 一行：
   * {iid=c7ad5492f27d492189105fb50e55cbb6, count=2, subtotal=60.0, oid=1ae8a70354c947f8b81b80ada6783155, bid=7, bname=精通hibernate,price=30.0, author=张卫琴, image=book_img/8991366-1_l.jpg, cid=2}
   * ...
   * 
   * 我们需要使用一个map生成两个对象：orderitem、book，然后再建立两者的关系（把book设置给orderitem）
   */
  /*
   * 循环遍历每个map，使用map生成两个对象，然后建立关系（最终结果一个orderitem），把orderitem保存起来
   */
  list<orderitem> orderitemlist = toorderitemlist(maplist);
  order.setorderitemlist(orderitemlist);
 }

 /**
  * 把maplist中每个map转换成两个对象，并建立关系
  * @param maplist
  * @return
  */
 private list<orderitem> toorderitemlist(list<map<string, object>> maplist) {
  list<orderitem> orderitemlist = new arraylist<orderitem>();
  for(map<string,object> map : maplist) {
   orderitem item = toorderitem(map);
   orderitemlist.add(item);
  }
  return orderitemlist;
 }

 /**
  * 把一个map转换成一个orderitem对象
  * @param map
  * @return
  */
 private orderitem toorderitem(map<string, object> map) {
  orderitem orderitem = commonutils.tobean(map, orderitem.class);
  book book = commonutils.tobean(map, book.class);
  orderitem.setbook(book);
  return orderitem;
 }

 /**
  * 加载订单
  * @param oid
  * @return
  */
 public order load(string oid) {
  try {
   /*
    * 1. 得到当前用户的所有订单
    */
   string sql = "select * from orders where oid=?";
   order order = qr.query(sql, new beanhandler<order>(order.class), oid);

   /*
    * 2. 为order加载它的所有条目
    */
   loadorderitems(order);


   /*
    * 3. 返回订单列表
    */
   return order;
  } catch(sqlexception e) {
   throw new runtimeexception(e);
  }
 }

 /**
  * 通过oid查询订单状态
  * @param oid
  * @return
  */
 public int getstatebyoid(string oid) {
  try {
   string sql = "select state from orders where oid=?";
   return (integer)qr.query(sql, new scalarhandler(), oid);
  } catch(sqlexception e) {
   throw new runtimeexception(e);
  }
 }

 /**
  * 修改订单状态
  * @param oid
  * @param state
  * @return
  */
 public void updatestate(string oid, int state) {
  try {
   string sql = "update orders set state=? where oid=?";
   qr.update(sql, state, oid);
  } catch(sqlexception e) {
   throw new runtimeexception(e);
  }
 }
}

public class orderservice {
 private orderdao orderdao = new orderdao();

 /**
  * 支付方法
  * @param oid
  */
 public void zhifu(string oid) {
  /*
   * 1. 获取订单的状态
   * * 如果状态为1，那么执行下面代码
   * * 如果状态不为1，那么本方法什么都不做
   */
  int state = orderdao.getstatebyoid(oid);
  if(state == 1) {
   // 修改订单状态为2
   orderdao.updatestate(oid, 2);
  }
 }

 /**
  * 添加订单
  * 需要处理事务
  * @param order
  */
 public void add(order order) {
  try {
   // 开启事务
   jdbcutils.begintransaction();

   orderdao.addorder(order);//插入订单
   orderdao.addorderitemlist(order.getorderitemlist());//插入订单中的所有条目

   // 提交事务
   jdbcutils.committransaction();
  } catch(exception e) {
   // 回滚事务
   try {
    jdbcutils.rollbacktransaction();
   } catch (sqlexception e1) {
   }
   throw new runtimeexception(e);
  }
 }

 /**
  * 我的订单
  * @param uid
  * @return
  */
 public list<order> myorders(string uid) {
  return orderdao.findbyuid(uid);
 }

 /**
  * 加载订单
  * @param oid
  * @return
  */
 public order load(string oid) {
  return orderdao.load(oid);
 }

 /**
  * 确认收货
  * @param oid
  * @throws orderexception
  */
 public void confirm(string oid) throws orderexception {
  /*
   * 1. 校验订单状态，如果不是3，抛出异常
   */
  int state = orderdao.getstatebyoid(oid);//获取订单状态
  if(state != 3) throw new orderexception("订单确认失败，您不是什么好东西！");

  /*
   * 2. 修改订单状态为4，表示交易成功
   */
  orderdao.updatestate(oid, 4);
 }
}

public class orderservlet extends baseservlet {
 private orderservice orderservice = new orderservice();

 /**
  * 支付之去银行
  * 
  * @param request
  * @param response
  * @return
  * @throws servletexception
  * @throws ioexception
  */
 public string zhifu(httpservletrequest request, httpservletresponse response)
   throws servletexception, ioexception {
  properties props = new properties();
  inputstream input = this.getclass().getclassloader()
    .getresourceasstream("merchantinfo.properties");
  props.load(input);
  /*
   * 准备13参数
   */
  string p0_cmd = "buy";
  string p1_merid = props.getproperty("p1_merid");
  string p2_order = request.getparameter("oid");
  string p3_amt = "0.01";
  string p4_cur = "cny";
  string p5_pid = "";
  string p6_pcat = "";
  string p7_pdesc = "";
  string p8_url = props.getproperty("p8_url");
  string p9_saf = "";
  string pa_mp = "";
  string pd_frpid = request.getparameter("pd_frpid");
  string pr_needresponse = "1";

  /*
   * 计算hmac
   */
  string keyvalue = props.getproperty("keyvalue");
  string hmac = paymentutil.buildhmac(p0_cmd, p1_merid, p2_order, p3_amt,
    p4_cur, p5_pid, p6_pcat, p7_pdesc, p8_url, p9_saf, pa_mp,
    pd_frpid, pr_needresponse, keyvalue);

  /*
   * 连接易宝的网址和13+1个参数
   */
  stringbuilder url = new stringbuilder(props.getproperty("url"));
  url.append("?p0_cmd=").append(p0_cmd);
  url.append("&p1_merid=").append(p1_merid);
  url.append("&p2_order=").append(p2_order);
  url.append("&p3_amt=").append(p3_amt);
  url.append("&p4_cur=").append(p4_cur);
  url.append("&p5_pid=").append(p5_pid);
  url.append("&p6_pcat=").append(p6_pcat);
  url.append("&p7_pdesc=").append(p7_pdesc);
  url.append("&p8_url=").append(p8_url);
  url.append("&p9_saf=").append(p9_saf);
  url.append("&pa_mp=").append(pa_mp);
  url.append("&pd_frpid=").append(pd_frpid);
  url.append("&pr_needresponse=").append(pr_needresponse);
  url.append("&hmac=").append(hmac);

  system.out.println(url);

  /*
   * 重定向到易宝
   */
  response.sendredirect(url.tostring());

  return null;
 }

 /**
  * 这个方法是易宝回调方法 我们必须要判断调用本方法的是不是易宝！
  * 
  * @param request
  * @param response
  * @return
  * @throws servletexception
  * @throws ioexception
  */
 public string back(httpservletrequest request, httpservletresponse response)
   throws servletexception, ioexception {
  /*
   * 1. 获取11 + 1
   */
  string p1_merid = request.getparameter("p1_merid");
  string r0_cmd = request.getparameter("r0_cmd");
  string r1_code = request.getparameter("r1_code");
  string r2_trxid = request.getparameter("r2_trxid");
  string r3_amt = request.getparameter("r3_amt");
  string r4_cur = request.getparameter("r4_cur");
  string r5_pid = request.getparameter("r5_pid");
  string r6_order = request.getparameter("r6_order");
  string r7_uid = request.getparameter("r7_uid");
  string r8_mp = request.getparameter("r8_mp");
  string r9_btype = request.getparameter("r9_btype");

  string hmac = request.getparameter("hmac");

  /*
   * 2. 校验访问者是否为易宝！
   */
  properties props = new properties();
  inputstream input = this.getclass().getclassloader()
    .getresourceasstream("merchantinfo.properties");
  props.load(input);
  string keyvalue = props.getproperty("keyvalue");

  boolean bool = paymentutil.verifycallback(hmac, p1_merid, r0_cmd,
    r1_code, r2_trxid, r3_amt, r4_cur, r5_pid, r6_order, r7_uid,
    r8_mp, r9_btype, keyvalue);

  if(!bool) {//如果校验失败
   request.setattribute("msg", "您不是什么好东西！");
   return "f:/jsps/msg.jsp";
  }

  /*
   * 3. 获取状态订单，确定是否要修改订单状态，以及添加积分等业务操作
   */
  orderservice.zhifu(r6_order);//有可能对数据库进行操作，也可能不操作！

  /*
   * 4. 判断当前回调方式
   * 如果为点对点，需要回馈以success开头的字符串
   */
  if(r9_btype.equals("2")) {
   response.getwriter().print("success");
  }

  /*
   * 5. 保存成功信息，转发到msg.jsp
   */
  request.setattribute("msg", "支付成功！等待卖家发货！你慢慢等~");
  return "f:/jsps/msg.jsp";
 }

 /**
  * 确认收货
  * 
  * @param request
  * @param response
  * @return
  * @throws servletexception
  * @throws ioexception
  */
 public string confirm(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {
  /*
   * 1. 获取oid参数 2. 调用service方法 > 如果有异常，保存异常信息，转发到msg.jsp 3.
   * 保存成功信息，转发到msg.jsp
   */
  string oid = request.getparameter("oid");
  try {
   orderservice.confirm(oid);
   request.setattribute("msg", "恭喜，交易成功！");
  } catch (orderexception e) {
   request.setattribute("msg", e.getmessage());
  }
  return "f:/jsps/msg.jsp";
 }

 /**
  * 加载订单
  * 
  * @param request
  * @param response
  * @return
  * @throws servletexception
  * @throws ioexception
  */
 public string load(httpservletrequest request, httpservletresponse response)
   throws servletexception, ioexception {
  /*
   * 1. 得到oid参数 2. 使用oid调用service方法得到order 3.
   * 保存到request域，转发到/jsps/order/desc.jsp
   */
  request.setattribute("order",
    orderservice.load(request.getparameter("oid")));
  return "f:/jsps/order/desc.jsp";
 }

 /**
  * 我的订单
  * 
  * @param request
  * @param response
  * @return
  * @throws servletexception
  * @throws ioexception
  */
 public string myorders(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {
  /*
   * 1. 从session得到当前用户，再获取其uid 2.
   * 使用uid调用orderservice#myorders(uid)得到该用户的所有订单list<order> 3.
   * 把订单列表保存到request域中，转发到/jsps/order/list.jsp
   */
  user user = (user) request.getsession().getattribute("session_user");
  list<order> orderlist = orderservice.myorders(user.getuid());
  request.setattribute("orderlist", orderlist);
  return "f:/jsps/order/list.jsp";
 }

 /**
  * 添加订单 把session中的车用来生成order对象
  * 
  * @param request
  * @param response
  * @return
  * @throws servletexception
  * @throws ioexception
  */
 public string add(httpservletrequest request, httpservletresponse response)
   throws servletexception, ioexception {
  /*
   * 1. 从session中得到cart 2. 使用cart生成order对象 3. 调用service方法完成添加订单 4.
   * 保存order到request域中，转发到/jsps/order/desc.jsp
   */
  // 从session中获取cart
  cart cart = (cart) request.getsession().getattribute("cart");
  // 把cart转换成order对象
  /*
   * 创建order对象，并设置属性
   * 
   * cart --> order
   */
  order order = new order();
  order.setoid(commonutils.uuid());// 设置编号
  order.setordertime(new date());// 设置下单时间
  order.setstate(1);// 设置订单状态为1，表示未付款
  user user = (user) request.getsession().getattribute("session_user");
  order.setowner(user);// 设置订单所有者
  order.settotal(cart.gettotal());// 设置订单的合计，从cart中获取合计

  /*
   * 创建订单条目集合
   * 
   * cartitemlist --> orderitemlist
   */
  list<orderitem> orderitemlist = new arraylist<orderitem>();
  // 循环遍历cart中的所有cartitem，使用每一个cartitem对象创建orderitem对象，并添加到集合中
  for (cartitem cartitem : cart.getcartitems()) {
   orderitem oi = new orderitem();// 创建订单条目

   oi.setiid(commonutils.uuid());// 设置条目的id
   oi.setcount(cartitem.getcount());// 设置条目的数量
   oi.setbook(cartitem.getbook());// 设置条目的图书
   oi.setsubtotal(cartitem.getsubtotal());// 设置条目的小计
   oi.setorder(order);// 设置所属订单

   orderitemlist.add(oi);// 把订单条目添加到集合中
  }

  // 把所有的订单条目添加到订单中
  order.setorderitemlist(orderitemlist);

  // 清空购物车
  cart.clear();

  // ////////////////////////////////////////////

  /*
   * 3. 调用orderservice添加订单
   */
  orderservice.add(order);
  /*
   * 4. 保存order到request域，转发到/jsps/order/desc.jsp
   */
  request.setattribute("order", order);
  return "/jsps/order/desc.jsp";
 }
}