ssh2项目之自己想的购物网站

想着把零碎的整理一下，合成一个完整的，虽然做完还是很简陋的项目

哎呀，这样一个小练手的项目，我居然做了七天，天哪，先大概回想一下有哪些需求

工具：tomcat /weblogic  myeclipse  mysql

数据库里有用户表，用户权限表，商品表，商品分类表，留言表，订单表，订单明细表，还应该在加一个购物车的表，偷懒，购物车信息就放在session里了

大概要实现的功能：

用户：查询商品，分类查询商品（菜单栏上的顶级分类），根据商品的名字模糊查询商品，注册（默认用户等级），登陆后添加购物车，批量添加到购物车，购物车里的商品选中全部或部分提交订单，下订单，模拟付款，催店家发货，取消订单，批量删除自己的订单，对商品留言（评价），删除自己的留言

管理员：新增用户（指定用户的等级），删除用户，修改用户的信息;；新增用户的权限信息，删除用户的权限（删除之前必须先删掉具有该权限的用户），增加商品（商品的图片上传，可以选择分类），修改商品，删除商品，增加商品的分类，删除商品的分类（删除之前必须先删掉该分类下的所有的商品），对用户的留言管理（删除），对商品的订单管理（发货，删除订单）

使用拦截器，未登录不可以进行下面的操作，转到登陆页面(管理员去管理员的登陆界面，用户去用户的登陆界面)

先在做完了，但是离一个真正的产品 还有很远的距离，只是自己练手用的

一开始使用weblogic 做服务器，哎呀，服务器配好数据源，爽的不行，但是启动太慢，加之自己不太会使用，不适合调试使用，所以又配了tomcat ,

ssh2的框架的搭建参考：http://blog.csdn.net/i_do_can/article/details/50378275

搭好框架就可以开始了我是先写后台，上面的那些需要实现的功能也是我边写边修改的，目录结构

先设计实体类

其中pagebean 是为了分页显示使用的 get/set方法都要有，我只贴出数据字段间的关系，比如主键啦，一对多啦

public class PageBean {

	    private List<?> list; //通过hql从数据库分页查询出来的list集合
	    
	    private int allRows; //总记录数
	    
	    private int totalPage; //总页数
	    
	    private int currentPage; //当前页
}

user里的字段

package com.cl.shopping.bean;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name="tbl_user")
public class User {
	private Integer id;
	private String username;
	private String password;
	private UserRole role;
	private String realname;
	private String tel;
	private String email;
	private String address;
	@Id
	@GeneratedValue
	public Integer getId() {
		return id;
	}
	@ManyToOne
	@JoinColumn(name="role")
	public UserRole getRole() {
		return role;
	}

	
}

商品里的字段

package com.cl.shopping.bean;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = "tbl_goods")
public class Goods{
	private Integer id;
	private String goodsname;
	private GoodTypes goodtypes;
	private Integer count;
	private Float price;
	private String goodspic;
	private String goodsdesc;

	
	@Id
	@GeneratedValue
	public Integer getId() {
		return this.id;
	}

	//商品对商品种类：多个商品对一个分类
	@ManyToOne
	@JoinColumn(name="goodstype")
	public GoodTypes getGoodtypes() {
		return goodtypes;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((id == null) ? 0 : id.hashCode());
		return result;
	}
//只比较 id  在com.cl.shopping.action.OrderAction.ordersubmitformsession() 里可能会使用
	@Override
	public boolean equals(Object obj) {

		Goods other = (Goods) obj;
		
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		
		return true;
	}
	
}

商品分类

package com.cl.shopping.bean;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "tbl_goods_type")
public class GoodTypes {

	private Integer id;
	private Integer pid;
	private String typename;
	private String note;

	@Id
	@GeneratedValue
	public Integer getId() {
		return this.id;
	}

}

用户对商品留言类

package com.cl.shopping.bean;

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;

/*商品留言列表*/
@Entity
@Table(name="tbl_goods_board")
public class GoodBoards {
	
	private int id;
	private User user;
	private Goods good;
	private String message;
	private Date date;
	
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	//一条留言只可以由一个用户发表，一个用户可以发表多条留言
	//现在是相对留言而言，多个留言对应于一个用户
	@ManyToOne
	@JoinColumn(name="userId")
	public User getUser() {
		return user;
	}
	//一个留言对应一个商品，一个商品可以有多个留言
	//现在是相对留言而言，多个留言对应于一个商品
	@ManyToOne
	@JoinColumn(name="goodsId")
	public Goods getGood() {
		return good;
	}

}

订单类

package com.cl.shopping.bean;

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = "tbl_order")
public class Order {
	
	/*
	 * 这几个参数的关系：如果用户取消了订单，页面显示已取消
	 * 			如果用户未付款，显示 付款，取消订单
	 * 			如果用户已付款，但是还没有发货，显示，已付款，等待发货，提醒发货
	 * 			如果用户已付款，但是还没有发货，显示 订单已发货
	 * */
	private Integer id;
	//费用
	private Float cost;

	//下订单的用户
	private User userid;
	//订单的生成时间
	private Date createtime;
	//订单对否有效 ,用户可以取消订单，不是删除， 0有效  1 无效   未付款直接取消，已付款的涉及退款问题
	private int valid; 
	//是否付款 ： 0 未付款    1：已付款
	private int pay;
	//是否发货 ： 0 未发货    1：已发货
	private int deliver;
	//订单的发货时间
	private Date delivertime;
	
	@Id
	@GeneratedValue
	public Integer getId() {
		return id;
	}
	//对订单而言，多个订单由一个用户产生
	@ManyToOne
	@JoinColumn(name="userid")
	public User getUserid() {
		return userid;
	}
}

订单明细类

package com.cl.shopping.bean;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@Entity
@Table(name = "tbl_order_detail")
public class OrderDetail {
	
	private Integer id;
	//对应哪个订单
	private Order orderid;
	//对应哪个商品
	private Goods goodsid;
	private String goodsname;
	//单价
	private Float baseprice;
	private Integer num;
	@Id
	@GeneratedValue
	public Integer getId() {
		return id;
	}
	//一条订单详情 对应一个订单
	@OneToOne
	@JoinColumn(name="orderid")
	public Order getOrderid() {
		return orderid;
	}
	
	//一条订单详情 对应一个商品
	@OneToOne
	@JoinColumn(name="goodsid")
	public Goods getGoodsid() {
		return goodsid;
	}
	
}

以及购物车类

package com.cl.shopping.bean;

public class Cart {
	
	private Integer goodsid;
	private String goodsName;
	//单价
	private Float baseprice;
	//数量
	private Integer count;
	//小计
	private Float amount;

}

然后写dao层，我大概分了几个模块，由于每个界面都想做分页，所有就把分页单独写在一个dao里

BaseDao extends HibernateDaoSupport   ，以后每个dao直接继承就好了，这样我在spring里配数据源时也更加方面一些，里面就两个方法：一个获取要查询的语句的结果的总记录数，一个进行分页，分页就是使用hibernate里提供好的

package com.cl.shopping.dao;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Transaction;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class BaseDao extends HibernateDaoSupport {

	public int getAllRowCount(String hql)
    {

        int allRows = 0;
            
        List<?> list = getHibernateTemplate().find(hql);
        
        allRows = list.size();
        
        return allRows;
    }
	//通过名字模糊查询
	public int getAllRowCount(String hql,String name)
    {

        int allRows = 0;
            
        List<?> list = getHibernateTemplate().find(hql,name);
        
        allRows = list.size();
        
        return allRows;
    }
    /**
     * 使用hibernate提供的分页功能，得到分页显示的数据
     * 
     */
    public List<?> queryByPage(String hql, int offset, int pageSize)
    {
    	
    	Query query = getSession().createQuery(hql).setFirstResult(offset).setMaxResults(pageSize);
	    
	    List<?>  list = query.list();
        
        return list;
    }
    
}

关于分页很多人有不同的做法，我偷懒，就直接使用 

getSession().createQuery(hql).setFirstResult(offset).setMaxResults(pageSize);

接着写关于用户的dao，我写成了接口

package com.cl.shopping.dao;

import java.util.List;

import com.cl.shopping.bean.User;
import com.cl.shopping.bean.UserRole;

public interface UserDao {

	void saveUser(User user);
	
	void deleteUser(int id);
	//根据对象直接删除
	void deleteUser(User user);
	
	List<?> findUserByName(String name);
	//找到所有是该权限的用户
	List<?> findUserByRoleId(int roleid);

	
	User findUserById(int id);
	
//role
	List<?> findAllRole();
	
	void saveRole(UserRole role);
	
	void deleteRole(int id);

	
}

实现类：

package com.cl.shopping.dao.impl;

import java.util.List;

import com.cl.shopping.bean.User;
import com.cl.shopping.bean.UserRole;
import com.cl.shopping.dao.BaseDao;
import com.cl.shopping.dao.UserDao;


public class UserDaoImpl extends BaseDao implements UserDao{

	
	public void deleteUser(int id) {
		
		//先加载特定实例
	    Object p = getHibernateTemplate().get(User.class, new Integer(id));
	    //删除特定实例
	    getHibernateTemplate().delete(p);
	}
	
	public void deleteUser(User user) {

		 getHibernateTemplate().delete(user);
		
	}

	public List<?> findUserByRoleId(int roleid) {
		
		List<?> list = null;
		list = this.getHibernateTemplate().findByNamedParam("from User u where u.role.id=:roleid","roleid",roleid);
		return list;
	}

	public void saveUser(User user) {
		
		getHibernateTemplate().saveOrUpdate(user);
	}
	
	//这里不是做的搜索，是确定知道名字的， 所以没有做模糊查询
	public  List<?> findUserByName(String name) {
		
//		Query query = getSession().createQuery("from User u where u.username = :username");
//		query.setParameter("username", name);
//		List<?> list = query.list();
//		User user = null;
//		if(list.size() > 0){
//			user = (User) list.get(0);
//		}
//		return user;
		//   http://blog.csdn.net/yaorongzhen123/article/details/8556484
		List<?> list = null;
		list = this.getHibernateTemplate().findByNamedParam("from User u where u.username=:name","name",name);
		return list;
		
	}


	public List<?> findAllUser() {
//		//以前的写法
//		Query query = getSession().createQuery("from User");
//		return query.list();
		
		return this.getHibernateTemplate().find("from User");
	}


	public List<?> findAllRole() {
		return this.getHibernateTemplate().find("from UserRole order by id");
	}

	public void saveRole(UserRole role) {
		getHibernateTemplate().saveOrUpdate(role);
		
	}

	public void deleteRole(int id) {
		
		Object p = getHibernateTemplate().get(UserRole.class, new Integer(id));
	    //删除特定实例
	    getHibernateTemplate().delete(p);
		
	}

	public User findUserById(int id) {
		//先加载特定实例
	    User p = getHibernateTemplate().get(User.class, new Integer(id));
		return p;
	}

	
}

关于商品的 

package com.cl.shopping.dao;

import java.util.List;

import com.cl.shopping.bean.GoodTypes;
import com.cl.shopping.bean.Goods;


public interface GoodsDao {
	
	/*Goods*/
	void saveGoods(Goods goods);
	
	void deleteGoods(int id);
	
	void deleteGoods(Goods goods);
	
	List<?> findGoodsByTypeId(int typeid);
	
	List<?> findGoodsByName(String name);
	
	Goods findGoodsById(int id);
	
	/*GoodTypes*/
	void saveGoodTypes(GoodTypes goodTypes);
	
	void deleteGoodTypes(int id);
	
	List<?> findAllGoodTypes();

}

商品的删除写了两个，一个是id 删除（先根据id查出来，再把对象删除），一个是直接对象删除（减少查的过程，用于删除分类时，直接传递对象）

实现类：

package com.cl.shopping.dao.impl;

import java.util.List;

import com.cl.shopping.bean.GoodTypes;
import com.cl.shopping.bean.Goods;
import com.cl.shopping.dao.BaseDao;
import com.cl.shopping.dao.GoodsDao;

public class GoodsDaoImpl extends BaseDao implements GoodsDao{

	public void saveGoods(Goods goods) {
	
		getHibernateTemplate().saveOrUpdate(goods);
		
	}

     //需要删除实例的主键
	public void deleteGoods(int id) {
		//get()可以取空的数据集,但load()不行
		//先加载特定实例
	    Object p = getHibernateTemplate().get(Goods.class, new Integer(id));
	    //删除特定实例
	    getHibernateTemplate().delete(p);
		
	}
	public void deleteGoods(Goods goods) {
		// TODO Auto-generated method stub
		 getHibernateTemplate().delete(goods);
		
	}

	public List<?> findGoodsByTypeId(int typeid) {
		List<?> list = null;
		//
		list = this.getHibernateTemplate().find("from Goods g where g.goodtypes.id = ?",typeid);
		return list;
	}
	public Goods findGoodsById(int id) {
		Goods goods = getHibernateTemplate().get(Goods.class, new Integer(id));
		return goods;
	}

	
	public List<?> findGoodsByName(String name) {
		List<?> list = null;
	//
		list = this.getHibernateTemplate().find("from Goods g where g.goodsname like ?","%" + name + "%");
		return list;
	}

	public void saveGoodTypes(GoodTypes goodTypes) {
		
		getHibernateTemplate().saveOrUpdate(goodTypes);
		
	}

	public void deleteGoodTypes(int id) {
		Object p = getHibernateTemplate().get(GoodTypes.class, new Integer(id));
	    //删除特定实例
	    getHibernateTemplate().delete(p);
		
	}

	public List<?> findAllGoodTypes() {
		// TODO Auto-generated method stub
		return this.getHibernateTemplate().find("from GoodTypes");
	}

}

关于订单的

package com.cl.shopping.dao;

import java.util.List;

import com.cl.shopping.bean.Order;
import com.cl.shopping.bean.OrderDetail;

public interface OrderDao {
	
	/*order*/
	//增加订单,返回最新增加的id 
	int saveOrder(Order order);
	
	//管理员删除 订单
	void deleteOrder(int id);
	
//	//管理员发货
//	void deliverOrder(Order order);
//	
//	//用户 取消 订单  其实就是更新订单，只是修改一个字段而已
//	void removeOrder(Order order);
//	
//	//用户 付款  其实就是更新订单，只是修改一个字段而已
//	void payOrder(Order order);
	
	//根据订单id 查找订单  显示订单详情时，上面是订单信息，下面是订单详细
	Order findOrderById(int id);
	
	//分页的使用basedao 里的
	
	/*orderdetail*/
	//增加订单详情
	void saveOrderdetail(OrderDetail orderdetail);
	
	//管理员，用户删除 
	void deleteOrderdetail(int id);
	
	//直接根据对象删除 
	void deleteOrderdetail(OrderDetail orderdetail);
	
	List<OrderDetail> findAllOrderdetailByOrderId(int id);
	

}

为何保存订单会有一个返回值，兄弟呀，我是使用的mysql的逐渐自增，但是在保存订单时，我需要获取刚生成的订单在数据库的id作为订单明细的外键，所以这里有个返回值，就是返回刚生成的id 

<span style="white-space:pre">		</span>getHibernateTemplate().saveOrUpdate(order);
		
		getHibernateTemplate().flush(); 
		// 为何要返回呢，是因为有些主键类型是自增的，插入成功后才能得到该主键值，所以需要返回PO给调用者  ;

		int last_insert_id =  order.getId();
		
		return last_insert_id;

实现类

package com.cl.shopping.dao.impl;

import java.util.List;

import com.cl.shopping.bean.Order;
import com.cl.shopping.bean.OrderDetail;
import com.cl.shopping.dao.BaseDao;
import com.cl.shopping.dao.OrderDao;

public class OrderDaoImpl extends BaseDao implements OrderDao{

	public int saveOrder(Order order) {
		
		getHibernateTemplate().saveOrUpdate(order);
		
		getHibernateTemplate().flush(); 
		// 为何要返回呢，是因为有些主键类型是自增的，插入成功后才能得到该主键值，所以需要返回PO给调用者  ;

		int last_insert_id =  order.getId();
		
		return last_insert_id;
		
	}

	public void deleteOrder(int id) {

		 Object p = getHibernateTemplate().get(Order.class, new Integer(id));
		
		 getHibernateTemplate().delete(p);
		
	}

//	public void deliverOrder(Order order) {
//
//		getHibernateTemplate().saveOrUpdate(order);
//		
//	}
//
//	public void removeOrder(Order order) {
//
//		getHibernateTemplate().saveOrUpdate(order);
//		
//	}
//
//	public void payOrder(Order order) {
//
//		getHibernateTemplate().saveOrUpdate(order);
//		
//	}

	public Order findOrderById(int id) {

		Order order = getHibernateTemplate().get(Order.class, new Integer(id));
		return order;
	}

	public void saveOrderdetail(OrderDetail orderdetail) {

		getHibernateTemplate().saveOrUpdate(orderdetail);
		
	}

	public void deleteOrderdetail(int id) {

		 OrderDetail p = getHibernateTemplate().get(OrderDetail.class, new Integer(id));
			
		 getHibernateTemplate().delete(p);
		
	}
	
	public void deleteOrderdetail(OrderDetail orderdetail) {

		 getHibernateTemplate().delete(orderdetail);
		
	}


	@SuppressWarnings("unchecked")
	public List<OrderDetail> findAllOrderdetailByOrderId(int id) {

		List<OrderDetail> list = null;
		list = this.getHibernateTemplate().findByNamedParam("from OrderDetail o where o.orderid.id=:orderid","orderid",id);
		return list;
		
	}

	
}

关于用户对商品的留言：

package com.cl.shopping.dao;

import com.cl.shopping.bean.GoodBoards;

/*留言就做一个用户新增的，然后分页显示，管理员删除的功能，不可更改*/
public interface GoodBoardsDao {
	
	void saveGoodBoards(GoodBoards goodBoards);
	
	void deleteGoodBoards(int id);
	
}

实现类

package com.cl.shopping.dao.impl;

import com.cl.shopping.bean.GoodBoards;
import com.cl.shopping.dao.BaseDao;
import com.cl.shopping.dao.GoodBoardsDao;

public class GoodBoardsDaoImpl extends BaseDao implements GoodBoardsDao{

	public void saveGoodBoards(GoodBoards goodBoards) {
		
		getHibernateTemplate().saveOrUpdate(goodBoards);
		
	}

	public void deleteGoodBoards(int id) {

		Object p = getHibernateTemplate().get(GoodBoards.class, new Integer(id));
	    
	    getHibernateTemplate().delete(p);
		
	}

}

写完dao 开始service层

抽象方法跟dao差不多，多个分页查询的

先是user相关的

package com.cl.shopping.service;

import java.util.List;

import com.cl.shopping.bean.PageBean;
import com.cl.shopping.bean.User;
import com.cl.shopping.bean.UserRole;


public interface UserService {

	void saveUser(User user);
	
	void deleteUser(int id);
	
	//这个只是登陆是查新使用。
	User findUserByName(String name);
	
	User findUserById(int id);
	
	PageBean findUserBypage(int pageSize, int page);
	
	//role
	List<?> findAllRole();
	
	void saveRole(UserRole role);
	
	void deleteRole(int id);
	
}

实现类

package com.cl.shopping.service.impl;

import java.util.List;

import com.cl.shopping.bean.PageBean;
import com.cl.shopping.bean.User;
import com.cl.shopping.bean.UserRole;
import com.cl.shopping.dao.impl.UserDaoImpl;
import com.cl.shopping.service.UserService;

public class UserServiceImpl implements UserService{

	private UserDaoImpl userdao;
	public UserServiceImpl(){
//		session = GetSession.getSession();
		userdao = new UserDaoImpl();
	}
	

	public void setUserdao(UserDaoImpl userdao) {
		this.userdao = userdao;
	}

	public void saveUser(User user) {

		userdao.saveUser(user);
	}

	public void deleteUser(int id) {
		userdao.deleteUser(id);
	}

	public User findUserByName(String name) {
		List<?> list = userdao.findUserByName(name);
		if(list.size() > 0){ 
			return (User)list.get(0);
		}
		return null;
	}
	

	public List<?> findAllUser() {
		
		return userdao.findAllUser();
	}

	public User findUserById(int id) {
		// TODO Auto-generated method stub
		return userdao.findUserById(id);
	}


	public PageBean findUserBypage(int pageSize, int page) {
		
		PageBean pageBean = new PageBean();
        
        String hql = "from User";
        
        int allRows = userdao.getAllRowCount(hql);
        
        int totalPage = pageBean.getTotalPages(pageSize, allRows);
        
        int currentPage = pageBean.getCurPage(page);
        
        int offset = pageBean.getCurrentPageOffset(pageSize, currentPage);
        
        List<?> list = userdao.queryByPage(hql, offset, pageSize);
        
        pageBean.setList(list);
        pageBean.setAllRows(allRows);
        pageBean.setCurrentPage(currentPage);
        pageBean.setTotalPage(totalPage);
        
        return pageBean;
	}
	
	
	public List<?> findAllRole() {
		return userdao.findAllRole();
	}


	public void saveRole(UserRole role) {
		userdao.saveRole(role);
		
	}

//删除权限时，要删除所以是该权限的用户
	public void deleteRole(int id) {
		
		List<User> list = (List<User>) userdao.findUserByRoleId(id);
		for(int i= 0;i<list.size();i++){
			userdao.deleteUser(list.get(i));
		}
		
		userdao.deleteRole(id);
		
	}	

}

关于商品的：

package com.cl.shopping.service;

import java.util.ArrayList;
import java.util.List;

import com.cl.shopping.bean.GoodTypes;
import com.cl.shopping.bean.Goods;
import com.cl.shopping.bean.PageBean;

public interface GoodsService {

	/*Goods*/
	void saveGoods(Goods goods);
	
	void deleteGoods(int id);
	
	Goods findGoodsById(int id);
	
	List<?> findGoodsByName(String name);
	
	PageBean findGoodsByName(String name,int pageSize, int page);
	
	PageBean findGoodsBypage(int pageSize, int page);
	
	PageBean findGoodsBypage(int pageSize, int page,List<GoodTypes> lists);
	
	/*GoodTypes*/
	void saveGoodTypes(GoodTypes goodTypes);
	
	void deleteGoodTypes(int id);
	
	PageBean findGoodTypesByPage(int pageSize, int page);
	
	List<?> findAllGoodTypes();
}

实现类

package com.cl.shopping.service.impl;

import java.util.List;
import com.cl.shopping.bean.GoodTypes;
import com.cl.shopping.bean.Goods;
import com.cl.shopping.bean.PageBean;
import com.cl.shopping.dao.impl.GoodsDaoImpl;
import com.cl.shopping.service.GoodsService;

public class GoodServiceImpl implements GoodsService {
	
	private GoodsDaoImpl goodsDaoImpl;

	public void saveGoods(Goods goods) {
		goodsDaoImpl.saveGoods(goods);

	}

	public void deleteGoods(int id) {
		goodsDaoImpl.deleteGoods(id);

	}

	public Goods findGoodsById(int id) {
		Goods goods = goodsDaoImpl.findGoodsById(id);
		return goods;
	}

	public List<?> findGoodsByName(String name) {
		List<?> list = goodsDaoImpl.findGoodsByName(name);
		return list;
	}
	
	public PageBean findGoodsByName(String name,int pageSize, int page) {
		
		PageBean pageBean = new PageBean();
        
       /* String hql = "from Goods g where g.goodsname like ?" ;
        
        int allRows = goodsDaoImpl.getAllRowCount(hql,"%" + name + "%");
        
        int totalPage = pageBean.getTotalPages(pageSize, allRows);
        
        int currentPage = pageBean.getCurPage(page);
        
        int offset = pageBean.getCurrentPageOffset(pageSize, currentPage);
        
        hql = "from Goods g where g.goodsname like '%" + name + "%'";
        
        //这句话纯测试看看  ，是可以使用的，原来就是  %  要加  '  呀
        allRows = goodsDaoImpl.getAllRowCount(hql);*/
		
		 //原来就是  %  要加  '  呀
		String  hql = "from Goods g where g.goodsname like '%" + name + "%'";
	        
        int allRows = goodsDaoImpl.getAllRowCount(hql);
        
        int totalPage = pageBean.getTotalPages(pageSize, allRows);
        
        int currentPage = pageBean.getCurPage(page);
        
        int offset = pageBean.getCurrentPageOffset(pageSize, currentPage);
        
        List<?> list = goodsDaoImpl.queryByPage(hql, offset, pageSize);
        
        pageBean.setList(list);
        pageBean.setAllRows(allRows);
        pageBean.setCurrentPage(currentPage);
        pageBean.setTotalPage(totalPage);
        
        return pageBean;
	}
	
	/**
	 * pageSize为每页显示的记录数
	 * page为当前显示的网页
	 */
	public PageBean findGoodsBypage(int pageSize, int page) {
		
		PageBean pageBean = new PageBean();
        
        String hql = "from Goods";
        
        int allRows = goodsDaoImpl.getAllRowCount(hql);
        
        int totalPage = pageBean.getTotalPages(pageSize, allRows);
        
        int currentPage = pageBean.getCurPage(page);
        
        int offset = pageBean.getCurrentPageOffset(pageSize, currentPage);
        
        List<?> list = goodsDaoImpl.queryByPage(hql, offset, pageSize);
        
        pageBean.setList(list);
        pageBean.setAllRows(allRows);
        pageBean.setCurrentPage(currentPage);
        pageBean.setTotalPage(totalPage);
        
        return pageBean;
	}
	//分类查询，lists里放的是需要查询的分类的 id ，其实这里lists存的直接是分类对象
	public PageBean findGoodsBypage(int pageSize, int page,
			List<GoodTypes> lists) {
		
		PageBean pageBean = new PageBean();
        
		String  hql = "from Goods g where g.goodtypes.id in (";
		for(int i = 0;i<lists.size();i++){
			hql = hql + lists.get(i).getId() + ",";
		}
		hql=hql.substring(0,(hql.length()-1));
		hql += ")";
	    //数据库 SELECT * FROM tbl_goods g where g.id in (10,6,7)   
        int allRows = goodsDaoImpl.getAllRowCount(hql);
        
        int totalPage = pageBean.getTotalPages(pageSize, allRows);
        
        int currentPage = pageBean.getCurPage(page);
        
        int offset = pageBean.getCurrentPageOffset(pageSize, currentPage);
        
        List<?> list = goodsDaoImpl.queryByPage(hql, offset, pageSize);
        
        pageBean.setList(list);
        pageBean.setAllRows(allRows);
        pageBean.setCurrentPage(currentPage);
        pageBean.setTotalPage(totalPage);
        
        return pageBean;
	}
	
	public void saveGoodTypes(GoodTypes goodTypes) {
		
		goodsDaoImpl.saveGoodTypes(goodTypes);

	}

	public void deleteGoodTypes(int id) {
		
		List<Goods> list = (List<Goods>) goodsDaoImpl.findGoodsByTypeId(id);
		for(int i = 0;i<list.size();i++){
			goodsDaoImpl.deleteGoods(list.get(i));
		}
		goodsDaoImpl.deleteGoodTypes(id);
	}
	
	public List<?> findAllGoodTypes() {
		// TODO Auto-generated method stub
		return goodsDaoImpl.findAllGoodTypes();
	}
	public PageBean findGoodTypesByPage(int pageSize, int page) {
		
		PageBean pageBean = new PageBean();
        
        String hql = "from GoodTypes";
        
        int allRows = goodsDaoImpl.getAllRowCount(hql);
        
        int totalPage = pageBean.getTotalPages(pageSize, allRows);
        
        int currentPage = pageBean.getCurPage(page);
        
        int offset = pageBean.getCurrentPageOffset(pageSize, currentPage);
        
        List<?> list = goodsDaoImpl.queryByPage(hql, offset, pageSize);
        
        pageBean.setList(list);
        pageBean.setAllRows(allRows);
        pageBean.setCurrentPage(currentPage);
        pageBean.setTotalPage(totalPage);
        
        return pageBean;
	}


	public void setGoodsDaoImpl(GoodsDaoImpl goodsDaoImpl) {
		this.goodsDaoImpl = goodsDaoImpl;
	}

}

这里有几个要注意的就是，一个是使用“like”模糊查询时，需要加上单引号，这个问题，困扰了好久说实话，

首页没有做js效果，类似那种鼠标一上去，二级菜单出现这种的，我虽界面没有写，但是我把查询的代码写出来了，

public PageBean findGoodsBypage(int pageSize, int page, List<GoodTypes> lists)  看代码完全可以看懂

还有删除商品分类时，一般删除我们都是传一个 id 过来，这里需要先查询出使用了此分类的商品，依次删除，这里为了提高效率，直接是传的对象过去

关于留言的：

package com.cl.shopping.service;

import com.cl.shopping.bean.GoodBoards;
import com.cl.shopping.bean.PageBean;

public interface GoodBoardsService {

	void saveGoodBoards(GoodBoards goodBoards);
	
	void deleteGoodBoards(int id);
	
	PageBean findGoodsBypage(int pageSize, int page,int goodid);
}

实现类

package com.cl.shopping.service.impl;

import java.util.List;

import com.cl.shopping.bean.GoodBoards;
import com.cl.shopping.bean.PageBean;
import com.cl.shopping.dao.GoodBoardsDao;
import com.cl.shopping.dao.impl.GoodBoardsDaoImpl;
import com.cl.shopping.service.GoodBoardsService;

public class GoodBoardsServiceImpl implements GoodBoardsService {
	
	private GoodBoardsDaoImpl goodBoardsDaoImpl;

	public void saveGoodBoards(GoodBoards goodBoards) {
		
		goodBoardsDaoImpl.saveGoodBoards(goodBoards);
	}

	public void deleteGoodBoards(int id) {

		goodBoardsDaoImpl.deleteGoodBoards(id);
	}

	public PageBean findGoodsBypage(int pageSize, int page,int goodid) {
		
		PageBean pageBean = new PageBean();
        
		String hql ;
		if(goodid != 0){
			//用户查该商品
			hql = "from GoodBoards g where g.good.id=" + goodid;
		}else{
			//管理员查全部
			hql = "from GoodBoards";
		}
        
        
        int allRows = goodBoardsDaoImpl.getAllRowCount(hql);
        
        int totalPage = pageBean.getTotalPages(pageSize, allRows);
        
        int currentPage = pageBean.getCurPage(page);
        
        int offset = pageBean.getCurrentPageOffset(pageSize, currentPage);
        
        List<?> list = goodBoardsDaoImpl.queryByPage(hql, offset, pageSize);
        
        pageBean.setList(list);
        pageBean.setAllRows(allRows);
        pageBean.setCurrentPage(currentPage);
        pageBean.setTotalPage(totalPage);
        
        return pageBean;
	}

	public void setGoodBoardsDaoImpl(GoodBoardsDaoImpl goodBoardsDaoImpl) {
		this.goodBoardsDaoImpl = goodBoardsDaoImpl;
	}
	

}

这里由于用户的留言是针对单个商品的，即在单个商品里留言，所以在查询时，写了两个方法，一个管理员分页显示所有的留言，一个是用户的根据商品的id分页显示该商品的留言

关于订单的

package com.cl.shopping.service;

import java.util.List;

import com.cl.shopping.bean.Order;
import com.cl.shopping.bean.OrderDetail;
import com.cl.shopping.bean.PageBean;

public interface OrderService {
	
	/*order*/
	//增加订单,连订单明细一起增加的
	void saveOrder(Order order,List<OrderDetail> orderdetaillist);
	
	//管理员删除 订单 ,连订单明细一起删除
	void deleteOrder(int id);
	
	//管理员发货
	void deliverOrder(Order order);
	
	//用户 取消 订单  其实就是更新订单，只是修改一个字段而已
	void removeOrder(Order order);
	
	//用户 付款  其实就是更新订单，只是修改一个字段而已
	void payOrder(Order order);
	
	//根据订单id 查找订单  显示订单详情时，上面是订单信息，下面是订单详细
	Order findOrderById(int id);
	
	//管理员查询所有的订单
	PageBean findAllOrderBypage(int pageSize, int page);
	
	//用户查询自己的所有的订单  其他什么用户根据时间啦，订单编号啦，订单里的某一个商品名来模糊查找订单啦，就暂时先不做了
	PageBean userFindOrderBypage(int userid ,int pageSize, int page);
	

	//查询订单 的 明细 管理员和用户都可以查询
	PageBean findAllOrderDetailBypage(int orderid,int pageSize, int page);

}

功能就见注释吧，实现类

package com.cl.shopping.service.impl;

import java.util.List;

import com.cl.shopping.bean.Order;
import com.cl.shopping.bean.OrderDetail;
import com.cl.shopping.bean.PageBean;
import com.cl.shopping.dao.impl.OrderDaoImpl;
import com.cl.shopping.service.OrderService;

public class OrderServiceImpl implements OrderService{
	
	private OrderDaoImpl orderDaoImpl;


	public void deleteOrder(int id) {
		// 先删除订单明细，再删除订单
		
		//根据商品的id找出所有的订单明细
		List<OrderDetail> list = orderDaoImpl.findAllOrderdetailByOrderId(id);
		//这里根据 id 删是可以的，但是效率不高，这里先查了一次，删除前又要查一次，所以直接根据 对象删
		for(int i =0; i < list.size(); i++){
//			orderDaoImpl.deleteOrderdetail(list.get(i).getId());
			orderDaoImpl.deleteOrderdetail(list.get(i));
		}	
		orderDaoImpl.deleteOrder(id);
	
	}

	public void deliverOrder(Order order) {
		// TODO Auto-generated method stub
		orderDaoImpl.saveOrder(order);
	}

	public void removeOrder(Order order) {
		// TODO Auto-generated method stub
		orderDaoImpl.saveOrder(order);
		
	}

	public void payOrder(Order order) {
		// TODO Auto-generated method stub
		orderDaoImpl.saveOrder(order);
		
	}

	public Order findOrderById(int id) {
		Order order = orderDaoImpl.findOrderById(id);
		return order;
	}

	public PageBean findAllOrderBypage(int pageSize, int page) {
		
		PageBean pageBean = new PageBean();
		
		String  hql = "from Order";
        
        int allRows = orderDaoImpl.getAllRowCount(hql);
        
        int totalPage = pageBean.getTotalPages(pageSize, allRows);
        
        int currentPage = pageBean.getCurPage(page);
        
        int offset = pageBean.getCurrentPageOffset(pageSize, currentPage);
        
        List<?> list = orderDaoImpl.queryByPage(hql, offset, pageSize);
        
        pageBean.setList(list);
        pageBean.setAllRows(allRows);
        pageBean.setCurrentPage(currentPage);
        pageBean.setTotalPage(totalPage);
        
        return pageBean;
	}

	public PageBean userFindOrderBypage(int userid, int pageSize, int page) {
		
			PageBean pageBean = new PageBean();
        
			String  hql = "from Order o where o.userid.id = " + userid;
		        
	        int allRows = orderDaoImpl.getAllRowCount(hql);
	        
	        int totalPage = pageBean.getTotalPages(pageSize, allRows);
	        
	        int currentPage = pageBean.getCurPage(page);
	        
	        int offset = pageBean.getCurrentPageOffset(pageSize, currentPage);
	        
	        List<?> list = orderDaoImpl.queryByPage(hql, offset, pageSize);
	        
	        pageBean.setList(list);
	        pageBean.setAllRows(allRows);
	        pageBean.setCurrentPage(currentPage);
	        pageBean.setTotalPage(totalPage);
	        
	        return pageBean;
	}


	public PageBean findAllOrderDetailBypage(int orderid, int pageSize, int page) {
		
		PageBean pageBean = new PageBean();
        
		String  hql = "from OrderDetail o where o.orderid.id = " + orderid;
	        
        int allRows = orderDaoImpl.getAllRowCount(hql);
        
        int totalPage = pageBean.getTotalPages(pageSize, allRows);
        
        int currentPage = pageBean.getCurPage(page);
        
        int offset = pageBean.getCurrentPageOffset(pageSize, currentPage);
        
        List<?> list = orderDaoImpl.queryByPage(hql, offset, pageSize);
        
        pageBean.setList(list);
        pageBean.setAllRows(allRows);
        pageBean.setCurrentPage(currentPage);
        pageBean.setTotalPage(totalPage);
        
        return pageBean;
	}

	public void setOrderDaoImpl(OrderDaoImpl orderDaoImpl) {
		this.orderDaoImpl = orderDaoImpl;
	}

	public void saveOrder(Order order, List<OrderDetail> orderdetaillist) {
		
		int id = orderDaoImpl.saveOrder(order);
		//上一次被插入的  id 
		order.setId(id);
		for(int i = 0 ; i < orderdetaillist.size(); i++){
			
			OrderDetail orderdetail = orderdetaillist.get(i);
			//设置订单id 
			orderdetail.setOrderid(order);
			orderDaoImpl.saveOrderdetail(orderdetail);
		}
			
	}
	
}

保存订单明细时，使用了刚刚生成的订单id 作为外键，其他查询什么的比如根据订单id查询订单明细，就看具体方法吧

剩下的就是开始写action 里，不过在这之前，先搞定几个问题，一个是登陆是的验证码

我一开始使用的用不了，说是struts2的缘故，参考 http://blog.csdn.net/shiyuezhong/article/details/8246958

然后在管理员进行商品添加时，我需要获得商品的分类列表，还有就是在用户进行分类查询时，我要根据用户查到那个分类，找到所有的子孙类，然后分页显示，哈哈，查询的代码是上面说的分类查询里

com.cl.shopping.service.impl.GoodServiceImpl.findGoodsBypage(int, int, List<GoodTypes>)

hql 语句的处理

<span style="white-space:pre">		</span>String  hql = "from Goods g where g.goodtypes.id in (";
		for(int i = 0;i<lists.size();i++){
			hql = hql + lists.get(i).getId() + ",";
		}
		hql=hql.substring(0,(hql.length()-1));
		hql += ")";

上面都有，查询子分类使用了递归，对了先看一下我的分类数据库怎么存的吧

实现的递归方法，一个显示时很明显，一个没有做处理，其实是一样，看代码啦

//遍历数据库的type 无级菜单 递归      原数据                               遍历的父id   填充物           处理后的数据
	public static void parse(List<GoodTypes> list,int pid,String s,List<GoodTypes> lists){
		//对list进行一次循环遍历
		for(int i = 0; i <list.size();i++){
			GoodTypes types = (GoodTypes) list.get(i);
			//如果该商品分类的父id == 当前遍历的商品分类的id -->该商品分类是当前遍历商品分类的下一级目录
			if(types.getPid() == pid){
//					System.out.println(s+types.getTypename());
				//把空格填充进去
				types.setTypename(s+types.getTypename());
				lists.add(types);
				//继续找该商品分类的下一级目录
				parse(list,types.getId(),s+"——",lists);
				
			}
		}
	}
	//这个只是分类，但是不加任何字符
	public static void parse(List<GoodTypes> list,int pid,List<GoodTypes> lists){
		//对list进行一次循环遍历
		for(int i = 0; i <list.size();i++){
			GoodTypes types = (GoodTypes) list.get(i);
			//如果该商品分类的父id == 当前遍历的商品分类的id -->该商品分类是当前遍历商品分类的下一级目录
			if(types.getPid() == pid){
//					System.out.println(s+types.getTypename());
				//把空格填充进去
				types.setTypename(types.getTypename());
				lists.add(types);
				//继续找该商品分类的下一级目录
				parse(list,types.getId(),lists);
				
			}
		}
	}

框架的架子配好后，直接在上面修改就好，看看spring文件注册的bean，算了，全部贴上吧

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
			http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/context            
           http://www.springframework.org/schema/context/spring-context-3.0.xsd
           http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
           http://www.springframework.org/schema/tx 
           http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

    
     <!-- weblogic 数据源   参考 http://blog.csdn.net/jacklee_6297/article/details/5347439 -->
    <!-- <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">   
		 <property name="jndiName"> 
		  	<value>mysql</value>
		 </property> 
		
	</bean>  -->
	
	<!-- spring proxool -->
	 <bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName">
			<value>org.logicalcobwebs.proxool.ProxoolDriver</value>
		</property>
		<property name="url">
			<value>proxool.shopping</value>
		</property>
	</bean> 
	
	<!-- spring hibernate -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />

		<!-- 注解类  bean 需要连数据库的 -->
		<property name="annotatedClasses">
			<list>
				<value>com.cl.shopping.bean.User</value>
				<value>com.cl.shopping.bean.UserRole</value>
				<value>com.cl.shopping.bean.Goods</value>
				<value>com.cl.shopping.bean.GoodTypes</value>
				<value>com.cl.shopping.bean.GoodBoards</value>
				<value>com.cl.shopping.bean.Order</value>
				<value>com.cl.shopping.bean.OrderDetail</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">true</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
			</props>
		</property>
		<!-- <property name="schemaUpdate">  
		    <value>true</value>  
		</property>  -->
	</bean>
	
    <!-- DAO -->
    <bean id="baseDao" class="com.cl.shopping.dao.BaseDao">
    	<property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <bean id="UserDaoImpl" class="com.cl.shopping.dao.impl.UserDaoImpl" parent="baseDao"></bean>
    <bean id="GoodsDaoImpl" class="com.cl.shopping.dao.impl.GoodsDaoImpl" parent="baseDao"></bean>
    <bean id="GoodBoardsDaoImpl" class="com.cl.shopping.dao.impl.GoodBoardsDaoImpl" parent="baseDao"></bean>
    <bean id="OrderDaoImpl" class="com.cl.shopping.dao.impl.OrderDaoImpl" parent="baseDao"></bean>
    
    <!-- Service -->
    <bean id="UserServiceImpl" class="com.cl.shopping.service.impl.UserServiceImpl">
    	<property name="userdao" ref="UserDaoImpl"></property>
    </bean>
    <bean id="GoodServiceImpl" class="com.cl.shopping.service.impl.GoodServiceImpl">
    	<property name="goodsDaoImpl" ref="GoodsDaoImpl"></property>
    </bean>
    <bean id="GoodBoardsServiceImpl" class="com.cl.shopping.service.impl.GoodBoardsServiceImpl">
    	<property name="goodBoardsDaoImpl" ref="GoodBoardsDaoImpl"></property>
    </bean>
    <bean id="OrderServiceImpl" class="com.cl.shopping.service.impl.OrderServiceImpl">
    	<property name="orderDaoImpl" ref="OrderDaoImpl"></property>
    </bean>
    
    <!-- Action -->
    <!-- 生成验证码 -->
    <bean id="securityCodeImageAction" name="securityCodeImageAction" class="com.cl.shopping.action.SecurityCodeImageAction"></bean>
    <!-- struts2 对应ben的 name 名 -->
    <bean id="UserAction" name="userAction" class="com.cl.shopping.action.UserAction">
    	 <property name="userservice" ref="UserServiceImpl"></property> 
    </bean>
    <bean id="GoodsAction" name="goodsAction" class="com.cl.shopping.action.GoodsAction">
    	 <property name="goodService" ref="GoodServiceImpl"></property> 
    </bean>
    <bean id="GoodTypesAction" name="goodTypesAction" class="com.cl.shopping.action.GoodTypesAction">
    	 <property name="goodService" ref="GoodServiceImpl"></property> 
    </bean>
    <!-- 菜单的分类查询 -->
	<bean name="classificGoodsAction" class="com.cl.shopping.action.ClassificGoodsAction">
		<property name="goodsService" ref="GoodServiceImpl"></property>
	</bean>
    <!-- 添加商品：图片上传 -->
	<bean name="addgoodsAction" class="com.cl.shopping.action.AddgoodsAction">
		<property name="goodsService" ref="GoodServiceImpl"></property>
	</bean>
	<!-- 用户权限 -->
	<bean name="roleAction" class="com.cl.shopping.action.RoleAction">
		<property name="userservice" ref="UserServiceImpl"></property> 
	</bean>
	<!-- 用户查询商品-->
	<bean name="userGoodsAction" class="com.cl.shopping.action.UserGoodsAction">
		<property name="goodService" ref="GoodServiceImpl"></property>
		<property name="goodBoardsService" ref="GoodBoardsServiceImpl"></property>
	</bean>
	<!-- 用户的留言-->
	<bean name="goodBoardsAction" class="com.cl.shopping.action.GoodBoardsAction">
		<property name="goodBoardsService" ref="GoodBoardsServiceImpl"></property>
	</bean>
	<!-- 购物车-->
	<bean name="carAction" class="com.cl.shopping.action.CarAction">
		<property name="goodService" ref="GoodServiceImpl"></property>
	</bean>
	<!-- 订单 -->
	<bean name="orderAction" class="com.cl.shopping.action.OrderAction">
		<property name="orderService" ref="OrderServiceImpl"></property>
		<property name="goodService" ref="GoodServiceImpl"></property>
	</bean>
	<!-- 订单明细 -->
	<bean name="orderDetailAction" class="com.cl.shopping.action.OrderDetailAction">
		<property name="orderService" ref="OrderServiceImpl"></property>
	</bean>
	
	
	
	<!-- 声明式事物配置 -->
	<!-- 配置事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory">
			<ref bean="sessionFactory" />
		</property>
	</bean>
	<!-- 配置事务传播特性 -->
	<tx:advice id="TestAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="save*" propagation="REQUIRED" />
			<tx:method name="del*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="add*" propagation="REQUIRED" />
			<tx:method name="find*" propagation="REQUIRED" />
			<tx:method name="get*" propagation="REQUIRED" />
			<tx:method name="apply*" propagation="REQUIRED" />
			<tx:method name="remove*" propagation="REQUIRED" />
			<tx:method name="insert*" propagation="REQUIRED" />
		</tx:attributes>
	</tx:advice>
	<!-- 配置参与事务的类 -->
	<aop:config>
		<!-- 正则表达式 com.cl.spring.service 下所有的类的所有的方法 -->
		<aop:pointcut id="allTestServiceMethod"

			expression="execution(* com.cl.shopping.service.*.*(..))" />
		<aop:advisor pointcut-ref="allTestServiceMethod"
			advice-ref="TestAdvice" />
	</aop:config>
	
    </beans>

连接池的proxool.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE proxool-config>
<proxool-config>
  <proxool>
    <alias>shopping</alias>
    <driver-url>
			jdbc:mysql://localhost:3306/nxf_shopping?characterEncoding=UTF8
    </driver-url>
    <driver-class>com.mysql.jdbc.Driver</driver-class>
    <driver-properties>
      <property name="user" value="root"/>
      <property name="password" value=""/>
    </driver-properties>
    <maximum-connection-count>30</maximum-connection-count>
    <minimum-connection-count>10</minimum-connection-count>
    <house-keeping-sleep-time>90000</house-keeping-sleep-time>
    <prototype-count>5</prototype-count>
    <house-keeping-test-sql>select CURRENT_DATE</house-keeping-test-sql>
  </proxool>
</proxool-config>

struts 的配置文件主要是各种action

里面有些是跳转，有些是重定向实现的，拦截器就把注释去掉，把下一句配上就好了

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE struts PUBLIC
	"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
	"http://struts.apache.org/dtds/struts-2.3.dtd">

<struts>

	<constant name="struts.i18n.encoding" value="UTF-8"/>
<!-- 定义权限控制拦截器 -->
	 <package name="struts-shop" extends="struts-default">
		    <interceptors>
			       <interceptor name="login"  class="com.cl.shopping.intecepeter.intecepeter"/>
		            <interceptor-stack name="myStack">
		                <interceptor-ref name="login"/>
		                <interceptor-ref name="defaultStack"/>
		            </interceptor-stack>
		    </interceptors>
		    <!-- （这句是设置所有Action自动调用的拦截器堆栈） -->
		    <default-interceptor-ref name="myStack"/>
	  </package>
	<constant name="struts.objectFactory" value="spring" />
<!-- 	<package name="default" namespace="/" extends="struts-shop"> -->
	<package name="default" namespace="/" extends="struts-default">
	 	
		<!-- 定义全局处理结果 -->
		<global-results>
			<!-- 逻辑名为login的结果，映射到/login.jsp页面 -->
			<result name="login">/admin/login.jsp</result>
			<result name="userlogin">/user/login.jsp</result>
				
		</global-results>
		<!-- user -->
		<action name="checklogin"  class="userAction" method="checklogin">
			<result name="admin">/admin/index.jsp</result>
			<result name="user" >/user/index.jsp</result>
		</action>
		
		<!-- 退出登陆 -->
		<action name="loginout"  class="userAction" method="loginout">
			<result name="admin">admin/index.jsp</result>
			<result name="user" >/user/index.jsp</result>
		</action>
		<!-- 管理员添加用户之前，先获取所有的权限信息 -->
		<!-- 试试添加和修改使用同一个界面 ,发现修改玩用户再点击新增用户时，是修改用户界面，原因是action 里user是有值的，所以还是分开写吧-->
		<action name="preuseradd"  class="roleAction">
			<result>usermanager/adduser.jsp</result>
		</action>
		<action name="preuseruptade"  class="userAction" method="preuseradd">
			<result>usermanager/updateuser.jsp</result>
		</action>
		<action name="useradd"  class="userAction" method="useradd">
			<result name="admin" type="redirectAction">userlist</result>
			<result name="user">user/index.jsp</result>
		</action>
		<action name="userlist"  class="userAction" method="userlist">
			<result>usermanager/userlist.jsp</result>
		</action>
		<action name="deluser"  class="userAction" method="deluser">
			<result type="redirectAction">userlist</result>
		</action>
		
		
		<!-- role -->
		<!-- 获取所有的权限信息 -->
		<action name="rolelist"  class="roleAction">
			<result>usermanager/rolelist.jsp</result>
		</action>
		<action name="saverole"  class="roleAction" method="saverole">
			<result type="redirectAction">rolelist</result>
		</action>
		<action name="delrole"  class="roleAction" method="delrole">
			<result type="redirectAction">rolelist</result>
		</action>
		
		
		<!-- goods -->
		<!-- 添加商品之前先获取所有已有的商品分类 -->
		<action name="pregoodsadd" class="goodTypesAction" method="goodtypesname">
			<result>/goods/addgoods.jsp</result>
		</action>
		<action name="goodslist" class="goodsAction" method="goodslist">
			<result>/goods/goodslist.jsp</result>
		</action>
		<!-- 新建一个action 处理商品 问题 图片 -->
		<action name="goodsadd" class="addgoodsAction" >
			<!-- <result type="redirectAction">goodslist</result> -->
			 <result  type="redirectAction">
				<param name="actionName">goodslist</param>   
				<param name="curPage">1</param> 
			</result>
		</action>
		<action name="delgoods" class="goodsAction" method="delgoods">
			<result type="redirectAction">goodslist</result>
		</action>
		<action name="preupdategoods" class="goodsAction" method="preupdategoods">
			<result >/goods/updategoods.jsp</result>
		</action>
		<action name="updategoods" class="goodsAction" method="updategoods">
			<result type="redirectAction">goodslist</result>
		</action>
		
		<!-- goodtypes -->
		<!-- 添加商品分类之前先获取所有已有的商品分类 -->
		<action name="pregoodtypesadd" class="goodTypesAction" method="goodtypesname">
			<result>/goods/addgoodtypes.jsp</result>
		</action>
		<!-- 添加分类完成后重定向到分类列表页面-->
		<action name="goodtypesadd" class="goodTypesAction" method="goodtypesadd">
			<result  type="redirectAction">
				<param name="actionName">goodtypeslist</param>   
				<param name="curPage">1</param> 
			</result>
		</action>
		<!-- 商品的分类查询  -->
		<action name="usergoodsclassific" class="classificGoodsAction" method="usergoodsclassific">
			<result>user/classificgoodslist.jsp</result>
		</action>
		<action name="goodtypeslist" class="goodTypesAction" method="goodtypeslist">
			<result>/goods/goodtypeslist.jsp</result>
		</action>
		<action name="delgoodtypes" class="goodTypesAction" method="delgoodtypes">
			<result type="redirectAction">goodtypeslist</result>
		</action>
		<!-- 使用ajax异步更新，不需要返回值 -->
		<action name="updategoodtypes" class="goodTypesAction" method="updategoodtypes"></action>
		
		<!-- 管理员对商品的留言 查看与删除 -->
		<action name="goodboardslist" class="goodBoardsAction" method="goodboardslist">
			<result>/goods/goodboardslist.jsp</result>
		</action>
		<action name="delgoodboards" class="goodBoardsAction" method="delgoodboards">
			<result type="redirectAction">goodboardslist</result>
		</action>
		
		
		<!-- 用户的操作 -->
		<!-- 商品 -->
		<action name="usergoodslist" class="userGoodsAction" method="usergoodslist">
			<result>/user/goodslist.jsp</result>
		</action>
		<!-- 用户查看单个商品时可以查看其他用户对于该商品的留言 -->
		<action name="userviewgood" class="userGoodsAction" method="userviewgood">
			<result>/user/viewgood.jsp</result>
		</action>
		<!-- 用户查询商品 -->
		<action name="usergoodlistbyname" class="userGoodsAction" method="usergoodlistbyname">
			<result>/user/goodslist.jsp</result>
		</action>
		<!-- 留言 -->
		<!-- 用户新增留言，跳回商品首页好了，调到单个商品查询页面是需要数据的 -->
		<action name="usergoodboardsadd" class="goodBoardsAction" method="usergoodboardsadd">
			<!-- <result type="redirectAction">usergoodslist</result> -->
			<result  type="redirectAction">
				<param name="actionName">userviewgood</param>   
				<param name="goodid">${goodBoards.good.id}</param> 
			</result>
		</action>
		<!-- 用户只可以删除自己的留言 ，在页面里判断当前登录用户的id与该条留言的id是否相同 -->
		<action name="userdelgoodboards" class="goodBoardsAction" method="delgoodboards">
			<!-- <result type="redirectAction">usergoodslist</result> -->
			<!-- 删除留言后 重定向到单个商品查询页面 -->
			<result  type="redirectAction">
				<param name="actionName">userviewgood</param> 
				<!-- ${goodBoards.good.id} 为 goodBoardsAction 里的数据 ，  goodid 是userGoodsAction里参数-->  
				<param name="goodid">${goodBoards.good.id}</param> 
			</result>
		</action>
		<!-- 购物车 -->
		<action name="addcart" class="carAction" method="addcart">
			<result>/user/cart.jsp</result>
		</action>
		<action name="showcart" class="carAction" >
			<result>/user/cart.jsp</result>
		</action>
		<!-- 批量添加 购物车 -->
		<action name="addcartlist" class="carAction" method="addcartlist">
			<result>/user/cart.jsp</result>
		</action>
		<action name="removeorclearcart" class="carAction" method="removeorclearcart">
			<result>/user/cart.jsp</result>
		</action>
		<action name="updatecart" class="carAction" method="updatecart">
			<result>/user/cart.jsp</result>
		</action>
		<!-- 订单 -->
		<!-- 管理员查询所有的订单 -->
		<action name="orderlist" class="orderAction" method="orderlist">
			<result>/goods/orderlist.jsp</result>
		</action>
		<!-- 管理员发货 -->
		<action name="deliverorder" class="orderAction" method="deliverorder">
			<result type="redirectAction">orderlist</result>
		</action> 
		<!-- 用户查询自己的订单 ,需要当前登录用户的id-->
		<action name="userorderlist" class="orderAction" method="userorderlist">
			<result>user/orderlist.jsp</result>
		</action>
		<!-- 用户查询自己的订单明细 ,一是订单信息，二是订单明细-->
		<action name="uservieworder" class="orderDetailAction" method="uservieworder">
			<result>/user/vieworderdetail.jsp</result>
		</action>
		<!-- 从购物车提交订单  ，不写在商品查询页面直接购买了，用户必须先加购物车在下订单-->
		<action name="ordersubmitformsession" class="orderAction" method="ordersubmitformsession">
			<result type="redirectAction">userorderlist</result>
		</action>
		<!-- 在单个商品详情页面直接购买单个商品 -->
		<action name="orderinone" class="orderAction" method="orderinone">
			<result type="redirectAction">userorderlist</result>
		</action> 
		<!-- 删除选中的订单 -->
		<action name="deleteorders" class="orderAction" method="deleteorders">
			<result type="redirectAction">userorderlist</result>
		</action> 
		<!-- 删除单个订单 -->
		<action name="deleteorder" class="orderAction" method="deleteorder">
			<result type="redirectAction">userorderlist</result>
		</action> 
		<!-- 用户付款 -->
		<action name="userpayorder" class="orderAction" method="userpayorder">
			<result type="redirectAction">userorderlist</result>
		</action> 
		<!-- 用户取消订单 -->
		<action name="usercancelorder" class="orderAction" method="usercancelorder">
			<result type="redirectAction">userorderlist</result>
		</action>
		
		
		
		
		<!-- 获取验证码 -->
		<action name="verifycode" class="securityCodeImageAction">
			<result name="success" type="stream">  
                <param name="contentType">image/jpeg</param>  
               <param name="inputName">imageStream</param>  
               <param name="bufferSize">2048</param>    
            </result> 
		</action>
		
	</package>

</struts>

拦截器的主要代码

// 取得请求相关的ActionContext实例  
		Map<String,Object> session = invocation.getInvocationContext().getSession();
		Object user = session.get("loginuser");
		// 如果没有登陆，返回重新登陆 
		if(user != null ){
			invocation.invoke();
		}
		//获取action名 此处action名为 struts2 文件里定义的名字 好机智用户的操作都添加了user前缀
		String actionName = invocation.getInvocationContext().getName();
//		System.err.println(actionName);
		//把验证码放行  checklogin也需要放行
		if("verifycode".equals(actionName) || "checklogin".equals(actionName)){
			invocation.invoke();
		}
		//管理员跳管理员登陆页面，用户条用户登陆页面
		if(actionName.indexOf("user") >= 0){
//			System.err.println("userlogin");
			return "userlogin";
		}else{
//			System.err.println("login");
			return "login";
		}

其实代码有很多要修改的地方，用户的操作都加上user开始，这样配拦截器就方便多了

最复杂的就是action 和jsp 里的逻辑了，需要各种逻辑判断，其实说实话我现在一个都想不起来，只能慢慢回忆

就看着struts 文件回忆吧，拦截器说完了，全局的处理结果不需要说了，就是所有的 action 都可以使用，再就是用户的登陆，没有什么，看一下验证码是否正确，检查一下数据库是否存在，

/*用户登陆*/
	public String checklogin(){
		//判断验证码和用户名以及密码是否为空，放在js里判断 error
		if(session == null){
			session=(Map)ActionContext.getContext().getSession();
		}
		//Struts2中获取request对象
		String s = session.get("VerifyCode").toString();
		if(!s.equalsIgnoreCase(verifyCode)){
			this.addFieldError("username", "VerifyCode is error");
			return "login";
		}

		if(checkUser(user)){
			if( loginuser.getRole().getRolename().equals("manager")){
				return "admin";
			}
			return "user";
		}
		addFieldError("username", "username or password is error");
		return "login";
	}
	/*查看数据库是否存在该用户*/
	public Boolean checkUser(User user){
		loginuser = userservice.findUserByName(user.getUsername());
		if(loginuser == null){
			return false;
		}

		session.put("loginuser", loginuser);
		return true;
	}

登出嘛，由于当前登陆用户的信息是存在session里的，清空就好了嘛  session.clear();

写struts是发现这个框架好笨呀，有些action，尤其是用到同一个变量，需要从页面取值或发送给页面时，最好分开写，要不会出现实体类被占用的情况，就像我在进行用户修改时，第一次点总是空，后面的就好了，但是点其他的，有一定的几率显示上一个的信息，对这我也是无语了，不过你分开写，多建几个action就解决了

用户增加之前需要获取用户的全部权限信息，用户修改之前，除了要获取数据库里的权限信息已下拉菜单显示，还需要获得要修改的用户的当前信息 看看jsp里struts提供的select

<!-- 使用这个时，value 里的值不可以是空。，如果为空，就会报错，value里是选中的值  value="user1.role.id"这样就没问题啦 -->
			<s:select list="rolelist"  listValue="rolename" listKey="id"  name="id"  
           				headerKey="0" headerValue="请选择权限" value="user1.role.id" >  
			</s:select>

list里是要遍历的数据，我是从数据库获取的。liatvalue是下拉菜单显示的内容，显示哪个属性的内容，listkey是通过哪个属性遍历，headerkey是第一个显示什么，headervalue是显示的值，vuale里是默认显示的数据

下面是用户的增加，分两个，一个是用户注册，一个是管理员新增用户，再有就是管理员对所有的用户的查询以及删除

接着是权限的的操作，管理员的：显示所有的权限，新增权限，修改权限，删除权限，没有修改的是因为我是当管理员点击要修改的信息时，显示的信息变成输入框，值还是原来的值，管理员直接在输入框里修改，然后通过ajax传到服务器，页面我就没有做刷新

jsp:

<span style="white-space:pre">			</span><s:iterator value="pageBean.list">
				<tr class="trtd">
					<td align="center"><font color="#DBDBDB"><s:property value="id"/></font></td>
					<td align="center" class="edittext"><s:property value="pid"/></td>
					<td align="center" class="edittext"><s:property value="typename"/></td>
					<td align="center" class="edittext"><s:property value="note"/></td>
					<td align="center">
					<!-- struts2 的支持真好，写个id 就映射到goodtypes.id啦  -->
						<a href="javascript:if( confirm('确实要删除<--<s:property value="typename"/>-->吗?'))
						location='delgoodtypes?id=<s:property value="id"/>' ">删除</a>
						||编辑请直接点击</td>
				</tr>
			</s:iterator>

js:

$(function() { 
	//获取class为edittext的元素 
	$(".edittext").click(function() { 
		var td = $(this); 
		var txt = td.text(); 
		var input = $("<input type='text'value='" + txt + "'/>"); 
		td.html(input); 
		input.click(function() { return false; }); 
		//获取焦点 
		input.trigger("focus"); 
		//文本框失去焦点后提交内容，重新变为文本 
		input.blur(function() { 
			var newtxt = $(this).val(); 
			//判断文本有没有修改 
			if (newtxt != txt) { 
				td.html(newtxt); 
				//不需要使用数据库的这段可以不需要 
				 
				//ajax异步更改数据库,加参数date是解决缓存问题 ，这里我要接收对象的全部属性值，不会
				http://q.cnblogs.com/q/69488/
				var childs = td.parent().children();
				//去掉最后一个 “基本操作”
				var item_length = childs.length-1;
		        var item_value = new Array(item_length);
		             
	            for(i = 0; i < item_length; i++){
//	                item_value[i] = childs[i].innerHTML;
	            	item_value[i] = childs[i].innerText;
	            }
	           
//				var url = "updategoodtypes?id=" + item_value[0]+"&pid="+item_value[1]+"&typename="+item_value[2]+"¬e="+item_value[3]; 
				//使用get()方法打开一个一般处理程序，data接受返回的参数（在一般处理程序中返回参数的方法 context.Response.Write("要返回的参数");） 
				//数据库的修改就在一般处理程序中完成  get 需要在服务器里编码防止乱码
//				$.get(url, function(data) { 
					if(data=="1") 
					{ 
						alert("该类别已存在！"); 
						td.html(txt); 
						return; 
					} 
//					alert(data); 
					td.html(newtxt); 
//				}); 
	            //http://www.w3school.com.cn/jquery/ajax_post.asp
				$.post("updategoodtypes",{id:item_value[0], pid:item_value[1], typename:item_value[2], note:item_value[3] });
				
			} 
			else 
			{ 
				td.html(newtxt);
				
			} 
		}); 
	}); 
}); 

使用post不需要修改编码，如果是使用get方式，需要修改一下编码

 good.setGoodsname(new String(good.getGoodsname().getBytes("ISO-8859-1"),"UTF-8"));

接着是商品的，商品添加之前，同样的需要获得商品的分类信息，显示所有的商品，商品的添加时，我一开始就是全部放在一个action 里，可郁闷了，获取的图片的值是空，好无语呀，然后分开写，就OK 了

public String execute()
	{
		//获取服务器路径   D:\ JavaWeb \  apache-tomcat-7.0.30 \  webapps \s sh2shoping \ upload
		String path = ServletActionContext.getServletContext().getRealPath("/upload");
		//这个方式确实可以获得
//		HttpServletRequest request = ServletActionContext.getRequest();
//		String roles = request.getParameter("goodtypes");
		//商品的分类还是获取 null 
		
//		goods.setGoodtypes();
		if(pic != null){
			String name = System.currentTimeMillis() + picFileName.substring(picFileName.lastIndexOf("."));
			File savefile = new File(path,name);
			try {
				FileUtils.copyFile(pic, savefile);
				goods.setGoodspic("upload/"+name);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}else{
			//设置默认的图片
			goods.setGoodspic("upload/0000.jpg");
		}
		
		goodsService.saveGoods(goods);
		return "success";
	}

添加商品后重定向到商品查询页面，设置为显示第一页

<action name="goodsadd" class="addgoodsAction" >
			<!-- <result type="redirectAction">goodslist</result> -->
			 <result  type="redirectAction">
				<param name="actionName">goodslist</param>   
				<param name="curPage">1</param> 
			</result>
		</action>

删除商品，没有什么好说的，更新商品，这里也是需要获取商品分类的，我没有再使用struts的，而是判断，需要标签

<%@taglib uri="/struts-tags" prefix="s" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

<select name="goodtypes.id" >
	<s:iterator value="lists" var="g">
		<c:choose>
			<c:when test="${g.typename == goods1.goodtypes.typename}">
				<option value="${g.id}" selected="selected">
					<s:property value="typename"/>
				</option>
			</c:when>
			<c:otherwise>		
				<option value="${g.id}" >
					<s:property value="typename"/>
				</option>
			</c:otherwise>
		</c:choose>							
	</s:iterator>
</select>

更新商品时如果没有上传新图片，还要保存为原来的图片，这个我是判断上传的图片是需要预览的

<!-- 如果没有更新图片，还是使用原来的 -->
						<input type="hidden" name="goodspic" value="<s:property value="goods1.goodspic"/>">

struts 自动转型为对象的属性了，上传的预览
jsp:

<tr>
					<td></td>
					<td align="center" valign="middle" >
						<div>
							<img id="preview" width="100px" height="100px"  src="<s:property value="goods1.goodspic"/>" />
						</div>
					</td>
				</tr>
				<tr>
					<td align="center">商品图片</td>
					<td align="center">
						<!-- 如果没有更新图片，还是使用原来的 -->
						<input type="hidden" name="goodspic" value="<s:property value="goods1.goodspic"/>">
						<input type="file" id="pic" name="pic" οnchange="javascript:setImagePreview();" />
					</td>
				</tr>

js:

	//下面用于图片上传预览功能
	function setImagePreview(avalue) {
		var docObj=document.getElementById("pic");
		var imgObjPreview=document.getElementById("preview");
		var AllImgExt=".jpg|.jpeg|.gif|.bmp|.png|"//全部图片格式类型
		var FileExt=docObj.value.substr(docObj.value.lastIndexOf(".")).toLowerCase(); 
		//console.log(docObj.value.substr(docObj.value.indexOf(".") + 1));
		//console.log(FileExt);
		if(AllImgExt.indexOf(FileExt+"|")!=-1)//如果图片文件，则进行图片信息处理 
		{
			if(docObj.files &&docObj.files[0])
			{
				//火狐下，直接设img属性
				imgObjPreview.style.display = 'block';
				imgObjPreview.style.width = '150px';
				imgObjPreview.style.height = '150px'; 
				//imgObjPreview.src = docObj.files[0].getAsDataURL();
				
				//火狐7以上版本不能用上面的getAsDataURL()方式获取，需要一下方式
				imgObjPreview.src = window.URL.createObjectURL(docObj.files[0]);
			}
			else
			{
				//IE下，使用滤镜
				docObj.select();
				var imgSrc = document.selection.createRange().text;
				var localImagId = document.getElementById("localImag");
				//必须设置初始大小
				localImagId.style.width = "150px";
				localImagId.style.height = "150px";
				//图片异常的捕捉，防止用户修改后缀来伪造图片
				try{
					localImagId.style.filter="progid:DXImageTransform.Microsoft.AlphaImageLoader(sizingMethod=scale)";
					localImagId.filters.item("DXImageTransform.Microsoft.AlphaImageLoader").src = imgSrc;
				}
				catch(e)
				{
					alert("您上传的图片格式不正确，请重新选择!");
					return false;
				}
				imgObjPreview.style.display = 'none';
				document.selection.empty();
			}
		
		}else{
			alert("上传'.jpg、.jpeg、.gif、.bmp、.png'格式的图片，请重新选择!");
			docObj.value="";
			return false;
		}
		return true;
	}

然后是商品的分类，新增，删除 ，更新（ajax异步更新）啦，查询啦，然后是一个分类显示商品，jsp:

	 	 <a href="usergoodsclassific?typeid=1">服装类</a>   
	 	 <a href="usergoodsclassific?typeid=2">电子类</a>   
	 	 <a href="usergoodsclassific?typeid=3">家具类</a>   
	 	 <a href="usergoodsclassific?typeid=4">食品类</a>   

action:

<span style="white-space:pre">	</span>public String usergoodsclassific(){
		
		List<GoodTypes> list = (List<GoodTypes>) goodsService.findAllGoodTypes();
		ArrayList<GoodTypes> lists = new ArrayList<GoodTypes>();
		TypeMenue.parse(list, typeid, lists);
		//把当前的父级id也添加到lists里
		GoodTypes goodtype = new GoodTypes();
		goodtype.setId(typeid);
		lists.add(goodtype);
		
		//根据列表里的id查询商品
		
		pageBean = goodsService.findGoodsBypage(pagesize, curPage,lists);
		
		return "success";
	}

接着就是留言了，管理员对所有的留言查看与删除

哈哈，到用户的操作啦

用户查看商品，分类查看商品，点击某个商品时，可以查看商品的详细信息，还有其他用户对该商品的留言，用户可以自己留言，也可以删除自己的留言，删除自己的留言，我做了两种，个人喜欢第二种（未注释那个，判断一下该用户可以删除，显示删除按钮），而第一种是所有的留言后都有删除按钮，等用户删除时，再来判断

<script type="text/javascript">
    	
    	function deleteboard(goodid,boardid,userid,loginuserid){
    		if(loginuserid == userid){
    			if( confirm("确实要删除这条留言吗?")){
    				var uri = "userdelgoodboards?goodBoards.good.id=" + goodid + "&goodBoards.id=" + boardid;
    				location.href = uri;
    			}
						 
    		}else{
    			alert("亲，只可以删除自己的留言哦");
    		}
    		
    	}
       
	</script>
	
  <fieldset>
    <legend>商品留言列表</legend>
	<div class="main" align="center">
	
	
		<table width="1000" cellpadding="1" border="0" cellspacing="1">

			<s:iterator value="pageBeanboard.list">
				<tr class="trtd">
					<td align="center"><s:property value="user.username"/></td>
					<td align="center"><s:property value="user.role.rolename"/></td>
					<td align="center"><s:property value="date"/></td>
					<td align="center">
						<textarea name="goodsdesc" 
							style="width:200px; color: #666464; height:50px; 
							border:0; background-color:transparent;overflow : hidden ;
							resize:none " 
							disabled="disabled">
					<s:property value="message"/></textarea>
						</td>
					
					<td align="center">
					<!-- struts2 的支持真好，写个id 就映射到goodtypes.id啦  -->
						<%-- <a href="javascript:void(0)" οnclick="deleteboard(<s:property value="good.id"/>,<s:property value="id"/>,<s:property value="user.id"/>,${loginuser.id})">删除</a> --%>
						<%-- ${loginuser.id} --%>
						<!-- 用户只可以删除自己的留言， -->
						<c:if test="${user.id == loginuser.id}">
							<a href="javascript:if( confirm('确实要删除你的这条留言吗?'))
							location='userdelgoodboards?goodBoards.good.id=<s:property value="good.id"/>&goodBoards.id=<s:property value="id"/>' ">删除</a>
						</c:if>
				</tr>
			</s:iterator>
			</table>

上面的代码使用了 <fieldset> ，textarea也是处理过的， textarea无边框文本透明背景文本样式, hidden:不显示超过对象尺寸的内容   取消chrome下textarea可拖动放大resize:none

点击链接时，弹出confirm提示框

还做了一个搜索框，用户可以根据商品名称进行模糊查询

用户新增完留言后，要跳回原页面，需要一个参数，就是商品的id，根据这个参数查询商品的信息，用户的留言信息，看看分页的代码，用户删除自己的留言情况是一样的

<script type="text/javascript" src="js/selectall.js"></script>

<%@taglib uri="/struts-tags" prefix="s" %>
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

	<script type="text/javascript">
    
        function validate()
        {
            var page = document.getElementsByName("curPage")[0].value;
            var rui = "usergoodslist";    
            if(page > <s:property value="pageBean.totalPage"/>)
            {
                alert("你输入的页数大于最大页数，页面将跳转到首页！");
                rui += "?curPage=1";
                window.document.location.href = rui ;
                
            }
            rui += "?curPage=" + page;
            window.document.location.href = rui ;
            return true;
        }
    	
    	function pagesize(){
    		var pagesize = document.getElementsByName("pagesize")[0].value;
            var rui = "usergoodslist?curPage=1&pagesize=" + pagesize; 
            window.document.location.href = rui ;
    	}
    	
    	
    	
    	//把选中的加入购物车
    	function selectAddCar(){
    		var allCheckBoxs = document.getElementsByName("checkall"); 
    		var selectOrUnselect = false; 
			var mycars = new Array();
			console.log(mycars.length);	
			var j = 0;
			for(var i = 0; i < allCheckBoxs.length; i ++ ) 
			{ 
				if(allCheckBoxs[i].checked){ 
					console.log(allCheckBoxs[i].value);
					mycars[j++] = allCheckBoxs[i].value; 
					selectOrUnselect=true; 
				} 
			}
			//判断一下，有选择才提交 
			if(selectOrUnselect){
				
				if(confirm("确实添加购物车吗?")){
					var url = "addcartlist?goodsidlist=" + mycars;
					location.href = url;
				}
				
			}else{
				alert("请先选择商品");
			}
    	}
       
	</script>
/分页显示的内容///
	<center>    
        	共<font color="red"><s:property value="pageBean.totalPage"/></font>页   
        	共<font color="red"><s:property value="pageBean.allRows"/></font>条记录   
        
        <s:if test="pageBean.currentPage == 1">
           	 首页 上一页
        </s:if>
        
        <s:else>
            <a href="usergoodslist?curPage=1">首页</a>
             
            <a href="usergoodslist?curPage=<s:property value="pageBean.currentPage - 1"/>">上一页</a>
        </s:else>
          
        <s:if test="pageBean.currentPage != pageBean.totalPage">
            <a href="usergoodslist?curPage=<s:property value="pageBean.currentPage + 1"/>">下一页</a>
              
            <a href="usergoodslist?curPage=<s:property value="pageBean.totalPage"/>">尾页</a>
        </s:if>
        
        <s:else>
           	 下一页  尾页
        </s:else> 
          
        	每页显示
        <input type="text" size="2" name="pagesize" οnblur="pagesize();" value="<s:property value="pagesize"/>">条  
        
          
        	跳转至
        <input type="text" size="2" name="curPage" οnblur="validate();" value="<s:property value="curPage"/>">页
       
        
    </center>

可以上一页，下一页，跳转到哪一页，每页显示几条记录

然后就到订单这边了，先是购物车，这些信息我都是放在sesion 里的，购物车里的操作都是对session的操作，

添加到购物车，显示购物车，使用全选按钮批量添加到购物车，修改购物车里商品的数量信息，删除里面某个商品，

package com.cl.shopping.action;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import com.cl.shopping.bean.Cart;
import com.cl.shopping.bean.Goods;
import com.cl.shopping.service.GoodsService;
import com.opensymphony.xwork2.ActionContext;

public class CarAction {
	
	private GoodsService goodService;
	
	/*购物车是对session操作*/
	private Map session;
	//商品数量，需要从页面取值
	private int count;
	//在carlist里的序号  需要从页面取值
	private int number = -1;
	//总价
	private Float sum = 0f;
	//商品的id
	private int goodsid;
	
	List<Cart> cartList ;
	
	//批量添加购物车  需要从页面取值
	List goodsidlist;
	
	public String execute(){
		return "success";
	}
	public String addcart(){

		//查出货品的信息
		Goods good = goodService.findGoodsById(goodsid);
		
		if(session == null){
			session = ActionContext.getContext().getSession();
		}
		//未登录时，不可以操作购物车
		if(session.get("loginuser")==null) {
			return "userlogin";
		}else {
			cartList = (List<Cart>)session.get("cartList");
			Cart cart = new Cart();
			cart.setGoodsid(goodsid);
			cart.setGoodsName(good.getGoodsname());
			cart.setBaseprice(good.getPrice());
			//数量、总价
			if(cartList==null) {
				//购物车为空
				cart.setCount(1);
				cart.setAmount(cart.getBaseprice() * cart.getCount());
				cartList = new ArrayList<Cart>();
				cartList.add(cart);
			}else {
				//flag标记是否在购物车里出现
				boolean flag = true;
				for(int i=0;i<cartList.size();i++) {
					Cart c = cartList.get(i);
					//判断商品是否在购物车里
					if(c.getGoodsid() == goodsid) {
						flag = false;
						//购物车里商品数量 +1
						c.setCount(c.getCount() + 1);
						c.setAmount(c.getBaseprice() * c.getCount());
					}
				}
				if(flag) {
					cart.setCount(1);
					cart.setAmount(cart.getBaseprice() * cart.getCount());
					cartList.add(cart);
				}
			}

			for(int i=0;i<cartList.size();i++) {
				Cart c = cartList.get(i);
				sum = sum + c.getAmount();
			}
			session.put("sum", sum);
			session.put("cartList", cartList);
			return "success";
		}
	}
	//批量添加购物车
	public String addcartlist(){
		
		if(session == null){
			session = ActionContext.getContext().getSession();
		}
		//未登录时，不可以操作购物车
		if(session.get("loginuser")==null) {
			return "userlogin";
		}else {
			
			cartList = (List<Cart>)session.get("cartList");
			
			//goodsidlist   页面传过来的数组，只能使用list接收，直接使用数组接收不到
			String[] goodsids = goodsidlist.get(0).toString().split(",");
			
			for(int i = 0; i <goodsids.length ; i++){
				//查出货品的信息
				Goods good = goodService.findGoodsById(Integer.parseInt(goodsids[i]));
				
				Cart cart = new Cart();
				cart.setGoodsid(good.getId());
				cart.setGoodsName(good.getGoodsname());
				cart.setBaseprice(good.getPrice());
				//数量、总价
				if(cartList==null) {
					//购物车为空
					cart.setCount(1);
					cart.setAmount(cart.getBaseprice() * cart.getCount());
					cartList = new ArrayList<Cart>();
					cartList.add(cart);
				}else {
					//flag标记是否在购物车里出现
					boolean flag = true;
					for(int j=0;j<cartList.size();j++) {
						Cart c = cartList.get(j);
						//判断商品是否在购物车里
						if(c.getGoodsid() == Integer.parseInt(goodsids[i])) {
							flag = false;
							//购物车里商品数量 +1
							c.setCount(c.getCount() + 1);
							c.setAmount(c.getBaseprice() * c.getCount());
						}
					}
					if(flag) {
						cart.setCount(1);
						cart.setAmount(cart.getBaseprice() * cart.getCount());
						cartList.add(cart);
					}
				}
	
			}
			for(int j=0;j<cartList.size();j++) {
				Cart c = cartList.get(j);
				sum = sum + c.getAmount();
			}
			session.put("sum", sum);
			session.put("cartList", cartList);
			return "success";
		}
	}
	
	@SuppressWarnings("unchecked")
	public String updatecart(){

		List<Cart> cartList = (List<Cart>)session.get("cartList");
		Cart cart = cartList.get(number - 1);
		cart.setCount(count);
		cart.setAmount(cart.getBaseprice() * cart.getCount());
		double sum = 0;
		for(int i=0;i<cartList.size();i++) {
			Cart c = cartList.get(i);
			sum = sum + c.getAmount();
		}
		session.put("sum", sum);
		session.put("cartList", cartList);
		
		return "success";
	}

	public String removeorclearcart(){
	
		if(number != -1) {
			//count 为 该商品在list里的 id（序号）
			List<Cart> cartList = (List<Cart>) session.get("cartList");
			//从购物车中删除 ， 下标是从0 开始，但是 页面计数是从1 开始
			cartList.remove(number - 1);
			double sum = 0;
			for(int i=0;i<cartList.size();i++) {
				Cart c = cartList.get(i);
				sum = sum + c.getAmount();
			}
			session.put("sum", sum);
			session.put("cartList", cartList);
		}else {
			//清空
			session.remove("cartList");
			session.remove("sum");
		}
		
		return "success";
	}


	public Map getSession() {
		return session;
	}

	public void setSession(Map session) {
		this.session = session;
	}

	public int getCount() {
		return count;
	}

	public void setCount(int count) {
		this.count = count;
	}

	public int getNumber() {
		return number;
	}

	public void setNumber(int number) {
		this.number = number;
	}


	public int getGoodsid() {
		return goodsid;
	}

	public void setGoodsid(int goodsid) {
		this.goodsid = goodsid;
	}

	public void setGoodService(GoodsService goodService) {
		this.goodService = goodService;
	}
	public List getGoodsidlist() {
		return goodsidlist;
	}
	public void setGoodsidlist(List goodsidlist) {
		this.goodsidlist = goodsidlist;
	}


}

需要发送到页面，从页面获取的变量需要get/set方法，由spring注入的service,只要用set方法就好，看代码啦

全选的实现

jsp页面

<td align="center">
	<input type="checkbox" name="checkall" value="<s:property value="id"/>">
</td>

<!-- 全选按钮 -->
			<tr>
				<td colspan="8">
					<input type="button" id="allChecked" value="全选/取消全选" onClick="selectAllDels()">      
					<input type="button" id="checkedAddCar" value="选中的加入购物车" onClick="selectAddCar()">
				</td>
			</tr>

js:

//全选
    	function selectAllDels() 
		{ 
			var allCheckBoxs = document.getElementsByName("checkall"); 
			var desc = document.getElementById("allChecked"); 
			var selectOrUnselect = false; 
			for(var i = 0; i < allCheckBoxs.length; i ++ ) 
			{ 
				if(allCheckBoxs[i].checked){ 
					selectOrUnselect=true; 
					break; 
				} 
			} 
			if (selectOrUnselect) 
			{ //只要有一个被选中，本次点击按钮就是取消全选
				_allUnchecked(allCheckBoxs); 
			}else 
			{ // 当前一个都没有被选中，则全部选中
				_allchecked(allCheckBoxs); 
			} 
		} 
		function _allchecked(allCheckBoxs){ 
			for(var i = 0; i < allCheckBoxs.length; i ++ ) 
			{ 
				allCheckBoxs[i].checked = true; 
			} 
		} 
		function _allUnchecked(allCheckBoxs){ 
			for(var i = 0; i < allCheckBoxs.length; i ++ ) 
			{ 
				allCheckBoxs[i].checked = false; 
			} 
		} 

订单啦：管理员查询所有的订单，管理员发货（就是新增一个发货时间，把状态改为已发货）

用户可以查看自己的订单信息，点击某个订单时查看两个信息，一个订单的信息，一个商品订单的明细，在订单明细里可以点击名字链接到商品单个查询页面，用户可以在单个商品查询页面里（有详情有留言那个）购买单个商品，也可以在购物车里选中部分提交订单

用户可以选中删除单个订单，也可以批量删除自己的订单，还有就是用户的付款与取消订单

界面很丑，自己画的，没有使用界面，后台使用了

附件：源码：http://download.csdn.net/detail/i_do_can/9405881