java web购物车功能实现原理及代码编写

目前常见的web购物车实现方法主要是三种：1.用cookie实现购物车；2.用session实现购物车；3.用cookie和数据库(购物车信息持久化)实现购物车；

=========================================================================

分析一下这三种方法的优缺点：

1.单纯有cookie实现购物车，这样的购物车不是很理想，设想一下，如果客户端的浏览器把cookie给禁用了，

这种方法就会在这里流产...

2.session中保存购物车的信息，这个只是在一个会话中可用，如果用户没有登录，或者说登录了以后，添加购物车，在关闭浏览器

或者登出后，之前所添加的购物车通通都流产啦...

3.我这里要说就是这种方法啦.....

主要的流程：

A.用户登录前的数据流：用户在没有登录系统的时候，对喜欢的商品进行添加购物车，那么这个时候，我们可以把购物车信息保存

到cookie中，这里会涉及到cookie的添加，修改操作；也即如果之前在cookie中不存对应的cookie，则就对cookie进行添加操作。

如果在cookie中存在对应的cookie，那么，这时候，就要对cookie进行修改操作了(这里涉及到用户对同一个商品进行多次添加购物车的情况)。

B.用户登录后的数据流：用户在登录后，系统首先做的第一件事就是去获取对应的cookies，如果存在相关的购物车cookies，那么就对该购物车

信息进行相应用户User的持久化操作，要么添加，要么修改。（添加操作:该用户所对应的购物车如果没有相应的信息进行添加操作；修改操作：类似的，

如果存在对应用户的购物车信息，就进行修改操作）。用户登录后，也可以进行购物车的添加操作，不过，这里不是添加到cookie中，而是直接持久化到

数据库中。注：用户登录后的数据都是和数据库打交道。

=========================================================================

代码部分：

=========================================================================

注：

1 Conf.IDUONA_CASHTICKET_COOKIE_STARTNAME = "iduona_cashTicket_";

/**
 * 用户登录
 * 
 * @author hongten
 */
public void login() {
    //用户登录的时候，去读取cookies，并且进行持久话操作，更多的登录操作这里省略啦....
    peristShoppingCartWhenUserLogin(newUser);
    }
/**
 * 加入购物车

 * ============================================

 * 用户登录前：

 * 用户在选择现金券的时候，点击现金券的加入购物车的时候，会把该现金券的信息(现金券的id，购买数量)

 * 传递到这里，这时候，后台要做的就是从cookie中查询出是否有相同的记录，如果有相同的记录

 * 则把相应的记录更新；否则，就添加新的记录

 * 用户登录后：

 * 用户在登录后，如果有添加购物车操作，则不用保存到cookie中，而是直接持久化购物车信息

 * 
 * @throws Exception
 */
public void addToShoppingCart() throws Exception {
    if (cashTicket == null || cashTicket.getId() == null || cashTicket.getId() < 1) {
        write("nullId");
    } else if (q == null || q == "") {
        // 购买数量，默认情况下面为1
        q = String.valueOf(1);
    } else {
        // 读取所有的cookie
        Cookie cookies[] = ServletActionContext.getRequest().getCookies();
        if (cookies == null || cookies.length < 0) {
            // 没有cookie
            System.out.println("there is no any cookie ..");
        } else {
            // 判断用户是否登录
            if (getUserInSession() == null) {
                boolean flag = true;
                for (Cookie c : cookies) {
                    if (c.getName().equals(Conf.IDUONA_CASHTICKET_COOKIE_STARTNAME + cashTicket.getId())) {
                        // 说明已有的cookies中有相应的cookie，就进行更新操作
                        Integer oldValue = Integer.valueOf(c.getValue());
                        Integer newValue = Integer.valueOf(oldValue + Integer.valueOf(q));
                        fixCookie(c, newValue.toString().trim());
                        flag = false;
                    }
                }
                // 说明已有的cookies中没有相应的cookie，就进行添加操作
                if (flag) {
                    addCookie(Conf.IDUONA_CASHTICKET_COOKIE_STARTNAME + cashTicket.getId(), q.trim());
                }
                // ==================================================
                // 测试用，读取所有的cookies
                readShoppingCartFromCookie();
                // ==================================================
                write("success");
            } else {
                // 如果用户登录，说明session存在user,这时就持久化购物车信息
                CashTicket cashTicketTemp = cashTicketService.get(cashTicket.getId());
                if (shoppingCartService.isExistUserAndCashTicket(getUserInSession(), cashTicketTemp)) {
                    ShoppingCart oldShoppingCart = shoppingCartService.getByUserAndCashTicket(getUserInSession(), cashTicketTemp);
                    oldShoppingCart.setAmount(oldShoppingCart.getAmount() + Integer.valueOf(q));
                    if (shoppingCartService.update(oldShoppingCart)) {
                        write("success");
                    }
                } else {
                    ShoppingCart shoppingCartTemp = new ShoppingCart();
                    shoppingCartTemp.setAmount(Integer.valueOf(q));
                    shoppingCartTemp.setUser(getUserInSession());
                    shoppingCartTemp.setCashTicket(cashTicketTemp);
                    shoppingCartTemp.setCreateTime(new Date());
                    shoppingCartTemp.setStatusType(StatusType.POSITIVE);
                    shoppingCartTemp.setUuid(UUID.randomUUID().toString());
                    if (shoppingCartService.save(shoppingCartTemp)) {
                        write("success");
                    }
                }
            }
        }
    }
}
/**
 * 从cookie中读取购物车信息
 * 
 * @throws Exception
 * @return
 */
public void readShoppingCartFromCookie() throws Exception {
    System.out.println("======================================================");
    Cookie cookies[] = ServletActionContext.getRequest().getCookies();
    if (cookies == null || cookies.length < 0) {
        // System.out.println("there is no any cookie ..");
        // 没有cookie
    } else {
        for (Cookie c : cookies) {
            System.out.println("haha there are many cookies :" + c.getName() + "    " + c.getValue());
        }
    }
}
/**
 * 添加cookie操作
 * 
 * @param name
 *            cookie的name
 * @param value
 *            cookie的value
 */
public void addCookie(String name, String value) {
    Cookie cookie = new Cookie(name.trim(), value.trim());
    cookie.setMaxAge(2 * 60 * 60 * 1000);// 设置为2个钟
    ServletActionContext.getResponse().addCookie(cookie);
}
/**
 * 更新cookie操作
 * 
 * @param c
 *            要修改的cookie
 * @param value
 *            修改的cookie的值
 */
public void fixCookie(Cookie c, String value) {
    c.setValue(value.trim());
    c.setMaxAge(2 * 60 * 60 * 1000);// 设置为2个钟
    ServletActionContext.getResponse().addCookie(c);
}
/**
 * 当用户登录的时候，持久化cookie中的购物车信息，更新为本用户的购物车信息
 */
public void peristShoppingCartWhenUserLogin(User user) {
    if (null != user) {
        Cookie cookies[] = ServletActionContext.getRequest().getCookies();
        if (cookies != null) {
            for (Cookie c : cookies) {
                if (c.getName().startsWith(Conf.IDUONA_CASHTICKET_COOKIE_STARTNAME)) {
                    // 获取cookie的名称："iduona_cashTicket_45" 和 cookie的值： "21"
                    String name = c.getName();
                    Integer amount = Integer.valueOf(Integer.valueOf(c.getValue())+Integer.valueOf(q));
                    Integer ct_id = Integer.valueOf(name.substring(name.lastIndexOf("_") + 1));
                    CashTicket temp = cashTicketService.get(ct_id);
                    ShoppingCart shoppingCartTemp = new ShoppingCart();
                    if (null != temp) {
                        if (shoppingCartService.isExistUserAndCashTicket(user, temp)) {
                            // 进行更新操作
                            ShoppingCart oldShoppingCart = shoppingCartService.getByUserAndCashTicket(user, temp);
                            oldShoppingCart.setAmount(amount);
                            shoppingCartService.update(oldShoppingCart);
                        } else {
                            // 否则进行保存记录
                            shoppingCartTemp.setAmount(amount);
                            shoppingCartTemp.setUser(user);
                            shoppingCartTemp.setCashTicket(temp);
                            shoppingCartTemp.setCreateTime(new Date());
                            shoppingCartTemp.setStatusType(StatusType.POSITIVE);
                            shoppingCartTemp.setUuid(UUID.randomUUID().toString());
                            shoppingCartService.save(shoppingCartTemp);
                        }
                    }
                }
            }
            // 移除所有的现金券cookies
            removeAllCookies();
        }
    }
}
/**
 * 移除所有的现金券cookies操作
 */
public void removeAllCookies() {
    Cookie cookies[] = ServletActionContext.getRequest().getCookies();
    if (cookies == null || cookies.length < 0) {
        // 没有cookie
        System.out.println("there is no any cookie ..");
    } else {
        System.out.println("开始删除cookies..");
        for (Cookie c : cookies) {
            if (c.getName().startsWith(Conf.IDUONA_CASHTICKET_COOKIE_STARTNAME)) {
                c.setMaxAge(0);// 设置为0
                ServletActionContext.getResponse().addCookie(c);
            }
        }
    }
}

这是部分代码....

效果：

用户没有登录的情况下

用户登录了以后：

数据库里面的情况：

登录前数据

基于Session和Cookie的java购物车实现代码

1、首先抽象出"购物车",由商品、购物车中的项、购物车三部分组成.

package  com.pf.entity;
import  java.io.Serializable;
/**
* 商品 类(我用的Food)
*  @author  PF
*/
public class  Food  implements  Serializable{
 private int food_id ;
     private  String  food_name ;
     public int  getFood_id() {
        return food_id ;
    }
     public void  setFood_id( int  food_id) {
        this . food_id  = food_id;
    }
     public  String getFood_name() {
        return food_name ;
    }
     public void  setFood_name(String food_name) {
        this . food_name  = food_name;
    }
}
package  com.pf.entity;
import  java.io.Serializable;
/**
*  购物车项
*  @author  PF
*
*/
public class  CartItem  implements  Serializable{
     private  Food  food ;
     private int count ;
     public  Food getFood() {
        return food ;
    }
     public void  setFood(Food food) {
        this . food  = food;
    }
     public int  getCount() {
        return count ;
    }
     public void  setCount( int  count) {
        this . count  = count;
    }
}
 
package  com.pf.entity;
import  java.io.Serializable;
import  java.util.ArrayList;
import  java.util.List;
/**
*  购物车类
*  @author  PF_CQ
*
*/
public class  Cart  implements  Serializable{
    List  list = new  ArrayList();
     public  List getList() {
        return list ;
    }
     public void  setList(List list) {
        this . list  = list;
    }
     public void  addCartItem(CartItem item){
        for (CartItem it :  list ){
            if (it.getFood().getFood_id()==item.getFood().getFood_id())
               return ;
       }
        list .add(item);
    }
     public void  removeItem(CartItem item){
        list .remove(item);
    }
     public void  clearCart(){
        list .clear();
    }
}

2、购物车抽象出来了,就要创建一个Session监听器,用于每次创建一个session之后都保存进一个键值对集合中,下次可以通过session的Id获取

package  com.pf.org;
import  java.util.HashMap;
import  java.util.Map;
import  javax.servlet.http.HttpSession;
import  javax.servlet.http.HttpSessionEvent;
import  javax.servlet.http.HttpSessionListener;
/**
* Session 监听器
*  @author  PF
*
*/
public class  SessionListener  implements  HttpSessionListener {
     //Session 集合
     public static  Map  session_map = new  HashMap();
     /**
     *  创建一个 session
     */
     public void  sessionCreated(HttpSessionEvent sessionEvent) {
       String session_id=sessionEvent.getSession().getId();
       System. out .println( "====== 创建了一个 Session,id 是 :" +session_id+ "======" );
        session_map .put(session_id, sessionEvent.getSession());
    }
     /**
     *  销毁
     */
     public void  sessionDestroyed(HttpSessionEvent sessionEvent) {
        session_map .remove(sessionEvent.getSession());
    }
     /**
     *  获得 session
     *  @param  session_id
     *  @return
     */
     public static  HttpSession getSessionById(String session_id){
        return session_map .get(session_id);
    }
     /**
     *  移除 session
     *  @param  session_id
     */
     public static void  removeSessionById(String session_id){
        session_map .remove(session_id);
    }
}

3、接下来,创建一个可以操作Cookie的类

package  com.pf.org;
import  java.util.HashMap;
import  java.util.Map;
import  javax.servlet.http.Cookie;
import  javax.servlet.http.HttpServletRequest;
import  javax.servlet.http.HttpServletResponse;
/**
* Web 工具类 ( 用于操作 Cookie)
*  @author  PF
*
*/
public class  WebUtil {
     /**
     *  添加 Cookie
     *
     *  @param  response
     *  @param  name
     *            Cookie 的名字
     *  @param  value
     *            Cookie 的值
     *  @param  maxAge
     *            Cookie 的存活时间
     */
     public static void  addCookie(HttpServletResponse response, String name,
           String value,  int  maxAge) {
       Cookie cookie =  new  Cookie(name, value);
        if  (maxAge > 0)
           cookie.setMaxAge(maxAge);
        //  添加到客户端
       response.addCookie(cookie);
    }
     /**
     *  取出硬盘中所有的 Cookie
     *
     *  @param  request
     *  @return
     */    www.2cto.com
    public static  Map getAllCookies(HttpServletRequest request) {
       Map cookie_map =  new  HashMap();
       Cookie[] cookies = request.getCookies();
        // 如果存在 cookie, 就存入 Map
        if (cookies!= null ){
            for  ( int  i = 0; i < cookies. length ; i++) {
              cookie_map.put(cookies.getName(), cookies);
           }
       }
        return  cookie_map;
    }
/**
     *  在 Cookie 中通过 Cookie 名称获得Session中的 SessionId
     *  @param  request
     *  @param  name
     *  @return
     */
     public static  String getSessionIdByNameInCookie(HttpServletRequest request,String name){
       Map cookie_map=getAllCookies (request);
        if (cookie_map.containsKey(name)){
           Cookie cookie = cookie_map.get(name);
            return  cookie.getValue();
       }
        return null ;
    }
}