SSH网上商城二

1、实现的功能如下

当用户登陆成功之后，在首页显示所有的一级分类

显示热门商品

显示最新商品

当用户点击某个一级分类的菜单选项的时候，显示当前一级分类菜单项下所有的二级分类，并且按照分页的形式显示该二级分类下的所有商品

第20课：首先显示一级分类

第21课：热门商品的显示

效果如下所示：

第23课：热门最新的商品

第24课：首先点击商品显示商品的详情

在首页的index.jsp中

<s:iterator var="p" value="nList">
                                    <li>
                                        <a href="${ pageContext.request.contextPath }/product_findByPid.action?pid=<s:property value="#p.pid"/>" target="_blank"><img src="${pageContext.request.contextPath}/<s:property value="#p.image"/>" data-original="http://storage.shopxx.net/demo-image/3.0/201301/4a51167a-89d5-4710-aca2-7c76edc355b8-thumbnail.jpg" style="display: block;"></a>                                    </li>
                                    </li>
                            </s:iterator>

效果如下：

第24课：首页查询一级分类商品（左侧分类显示

当点击首页的一级分类的某个菜单选项的时候，要在页面左侧显示该一级分类下的所有二级分类，并且在右侧按照分页显示当前二级分类下对应的所有的商品信息

这就涉及到hibernate中的一对多的配置

一个一级分类对应多个二级分类，一个二级分类对应多个商品

具体详情查看博客：https://www.cnblogs.com/liuling/archive/2013/01/14/231df213as32.html

昨天初次接触hibernate,仅仅弄懂了一对一关系的映射。今天学习了一天又有了新的收获，弄懂了一对多之间关系的映射。

一、一对多的关系映射

　　建立一对多关系关系的表的原则是将一的一方的主键加入到多的一方的表作为外键。这里以员工和部门为例子来演示。以前不用hibernate时建立pojo类要在员工类Emp中加入一个属性，即部门编号deptid.使用hibernate则不同了，需要在“一”的一方类中加入一个set集合，里面存放“多”的一方的对象。而在“多”的一方的类中需要加入一个“一”方的对象。也就是说在Dept类中需要加入一个set集合，存放Emp对象，因为一个部门里面对应多个员工，所以用一个集合来表示。而每一个员工只能属于一个部门，所以员工类Emp里面需要加入一个Depe类对象，表示所属部门。部门类和员工类的代码如下　

public class Dept implements Serializable {
    private int deptId;
    private String deptName;
    private Set<Emp> emps = new HashSet<Emp>();
    public int getDeptId() {
        return deptId;
    }
    public void setDeptId(int deptId) {
        this.deptId = deptId;
    }
    public String getDeptName() {
        return deptName;
    }
    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }
    public Set<Emp> getEmps() {
        return emps;
    }
    public void setEmps(Set<Emp> emps) {
        this.emps = emps;
    }
}

public class Emp implements Serializable{
    private int empNo;
    private String empName;
    private Date empBirthday;
    private Dept dept;
    public int getEmpNo() {
        return empNo;
    }
    public void setEmpNo(int empNo) {
        this.empNo = empNo;
    }
    public String getEmpName() {
        return empName;
    }
    public void setEmpName(String empName) {
        this.empName = empName;
    }
    public Date getEmpBirthday() {
        return empBirthday;
    }
    public void setEmpBirthday(Date empBirthday) {
        this.empBirthday = empBirthday;
    }
    public Dept getDept() {
        return dept;
    }
    public void setDept(Dept dept) {
        this.dept = dept;
    }
 
}

写完pojo类后就要配置这两个类和表之间的映射关系了，代码如下：

1.Dept.hbm.xml

<hibernate-mapping>
    <!-- 表和类之间的映射 -->
    <class name="com.pojo.Dept" table="dept">
        <!-- 主键映射 -->
        <id name="deptId" column="deptId">
            <generator class="native"></generator>
        </id>
        <!-- 属性映射 -->
        <property name="deptName" column="deptName" length="50"></property>
        <!-- 表之间关系映射 -->
        <set name="emps" cascade="save-update,delete">
            <key column="deptId"></key>
            <one-to-many class="com.pojo.Emp"/>
        </set>
    </class>
</hibernate-mapping>

这里面配置了一个set,里面的name="emps"表示在Dept类里的属性emps,它是一个集合，存放Emp对象的。cascade="save-update,delete"指明可以级联删除，级联插入数据。cascade有四个值：all、save-update、delete、none,默认就是none,表示不能级联操作。<one-to-many class="com.pojo.Emp"/>表示Dept与Emp是一对多的关系，他们是以deptId建立关系的，即deptId是Emp的外键。

2.Emp.hbm.xml

<hibernate-mapping>
    <!-- 表和类之间的映射 -->
    <class name="com.pojo.Emp" table="emp">
        <!-- 主键映射 -->
        <id name="empNo" column="empNo">
            <generator class="native"></generator>
        </id>
        <!-- 属性映射 -->
        <property name="empName" column="empName" length="50"></property>
        <property name="empBirthday" column="empBirthday"></property>
        <!-- 表之间关系映射 -->
        <many-to-one name="dept" column="deptId"></many-to-one>
    </class>
</hibernate-mapping>

这里加了<many-to-one></many-to-one>表示Emp与Dept是多对一的关系，name="dept"表示在Emp类里面有一个属性是Dept对对象dept,column="deptId"表示它们之间是用deptId建立联系的。

下面是级联插入数据的代码：

package com.test;
 
import java.util.Date;
 
import org.hibernate.Session;
import org.hibernate.Transaction;
 
import com.pojo.Dept;
import com.pojo.Emp;
import com.util.DBUtil;
 
public class 级联插入数据 {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        //获得session
        Session session = DBUtil.getSession();
        //新建一个dept
        Dept dept = new Dept();
        dept.setDeptName("吃饭部");
 
        //新建emp
        Emp e1 = new Emp();
        e1.setEmpName("李白");
        e1.setEmpBirthday(new Date());
 
        Emp e2 = new Emp();
        e2.setEmpName("王维");
        e2.setEmpBirthday(new Date());
 
        dept.getEmps().add(e1);
        dept.getEmps().add(e2);
 
        Transaction tr = session.beginTransaction();
        try {
            session.save(dept);
            tr.commit();
        } catch (Exception e) {
            tr.rollback();
        }finally{
            session.close();
        }
    }
 
}

先建立一个dept对象，然后建立两个emp对象，然后把这两个emp对象加入到dept对象的集合里面，然后保存dept。级联插入只要操作父表，就可以操作子表。前提是要在前面那个cascade="save-update"必须写。

我喜欢，驾驭着代码在风驰电掣中创造完美！我喜欢，操纵着代码在随必所欲中体验生活！我喜欢，书写着代码在时代浪潮中完成经典！每一段新的代码在我手中诞生对我来说就象观看刹那花开的感动！

第25课和第26课 07-SSH网上商城：首页查询一级分类商品（分类显示商品信息二，这也是本章的难点和重点，学会了这个基本就没有问题

1、首先我们来分析下，首先一级分类和二级分类是一对多的关系，二级分类和商品是一对多的关系我们要进行配置

安装hibernate一对多的关系进行配置

一级分类的mysql语句如下所示：

CREATE TABLE `category` (
  `cid` int(11) NOT NULL,
  `cname` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`cid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

二级分类的mysql如下所示

CREATE TABLE `categorysecond` (
  `csid` int(11) NOT NULL,
  `csname` varchar(255) DEFAULT NULL,
  `cid` int(11) DEFAULT NULL,
  PRIMARY KEY (`csid`),
  KEY `ww` (`cid`),
  KEY `FK936FCAF2E83BE920` (`cid`),
  CONSTRAINT `FK936FCAF2E83BE920` FOREIGN KEY (`cid`) REFERENCES `category` (`cid`),
  CONSTRAINT `ww` FOREIGN KEY (`cid`) REFERENCES `category` (`cid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

商品的mysql如下所示

CREATE TABLE `product` (
  `pid` int(11) NOT NULL,
  `pname` varchar(255) DEFAULT NULL,
  `market_price` double DEFAULT NULL,
  `shop_price` double DEFAULT NULL,
  `image` varchar(255) DEFAULT NULL,
  `pdesc` varchar(255) DEFAULT NULL,
  `is_hot` int(11) DEFAULT NULL,
  `pdate` datetime DEFAULT NULL,
  `csid` int(11) DEFAULT NULL,
  PRIMARY KEY (`pid`),
  KEY `ee` (`csid`),
  CONSTRAINT `ee` FOREIGN KEY (`csid`) REFERENCES `categorysecond` (`csid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

对应的实体bean如下

package cn.itcast.shop.category.beans;
 
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
 
import cn.itcast.shop.categorysecond.beans.CategorySecond;
 
/**
 * 一级分类的实体类对象
 * @author 传智.郭嘉
 * 昨天初次接触hibernate,仅仅弄懂了一对一关系的映射。今天学习了一天又有了新的收获，弄懂了一对多之间关系的映射。
 
一、一对多的关系映射
 
　　建立一对多关系关系的表的原则是将一的一方的主键加入到多的一方的表作为外键。这里以员工和部门为例子来演示。以前不用hibernate时建立pojo类要在员工类Emp中加入一个属性，即部门编号deptid.使用hibernate则不同了，需要在“一”的一方类中加入一个set集合，里面存放“多”的一方的对象。而在“多”的一方的类中需要加入一个“一”方的对象。也就是说在Dept类中需要加入一个set集合，存放Emp对象，因为一个部门里面对应多个员工，
所以用一个集合来表示。而每一个员工只能属于一个部门，
所以员工类Emp里面需要加入一个Depe类对象，表示所属部门。
部门类和员工类的代码如下　
 *
 */
public class Category implements Serializable{
    private Integer cid;
    private String cname;
 
    //现在当点击一级分类的时候，需要将二级分类全部查询出来，所以要在一级分类里面配置一个二级分类的集合
    // 一级分类中存放二级分类的集合:
    private Set<CategorySecond> categorySeconds = new HashSet<CategorySecond>();
 
    public Set<CategorySecond> getCategorySeconds() {
        return categorySeconds;
    }
    public void setCategorySeconds(Set<CategorySecond> categorySeconds) {
        this.categorySeconds = categorySeconds;
    }
    public Integer getCid() {
        return cid;
    }
    public void setCid(Integer cid) {
        this.cid = cid;
    }
    public String getCname() {
        return cname;
    }
    public void setCname(String cname) {
        this.cname = cname;
    }
    }

对应的Category.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.itcast.shop.category.beans.Category" table="category">
        <id name="cid">
            <generator class="native"/>
        </id>
 
        <property name="cname"/>
 
        <!-- 配置二级分类的集合 II.一对多关联级别：
 
      <set>元素中的lazy属性的可选值为:true(延迟加载),extra(增强延迟加载)和false(立即加载);-->
        <set order-by="csid" name="categorySeconds" lazy="false" cascade="delete">
            <key column="cid"/>
            <one-to-many class="cn.itcast.shop.categorysecond.beans.CategorySecond"/>
        </set>
 
    </class>
</hibernate-mapping>
 
<!-- 记得在hibernate的配置文件中引入该资源文件 -->

package cn.itcast.shop.categorysecond.beans;
 
import java.util.HashSet;
import java.util.Set;
 
import cn.itcast.shop.category.beans.Category;
import cn.itcast.shop.product.beans.Product;
 
/**
 * 二级分类的实体
 * @author 传智.郭嘉
 * CREATE TABLE `categorysecond` (
  `csid` int(11) NOT NULL,
  `csname` varchar(255) DEFAULT NULL,
  `cid` int(11) DEFAULT NULL,
  PRIMARY KEY (`csid`),
  KEY `ww` (`cid`),
  CONSTRAINT `ww` FOREIGN KEY (`cid`) REFERENCES `category` (`cid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
 *
 */
public class CategorySecond {
    private Integer csid;
    private String csname;
    // 所属一级分类.存的是一级分类的对象. 外键cid对应的是类
    private Category category;
    // 配置商品集合
        private Set<Product> products = new HashSet<Product>();
 
    public Set<Product> getProducts() {
            return products;
        }
        public void setProducts(Set<Product> products) {
            this.products = products;
        }
    public Integer getCsid() {
        return csid;
    }
    public void setCsid(Integer csid) {
        this.csid = csid;
    }
    public String getCsname() {
        return csname;
    }
    public void setCsname(String csname) {
        this.csname = csname;
    }
    public Category getCategory() {
        return category;
    }
    public void setCategory(Category category) {
        this.category = category;
    }
 
}

对应的CategorySecond.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.itcast.shop.categorysecond.beans.CategorySecond" table="categorysecond">
        <id name="csid">
            <generator class="native"/>
        </id>
 
        <property name="csname"/>
        <!-- 二级分类与一级分类的guanlian -->
        <many-to-one name="category" lazy="false" class="cn.itcast.shop.category.beans.Category" column="cid"></many-to-one>
 
       <!-- 二级分类与商品的关联 -->
        <set name="products">
            <key column="csid"/>
            <one-to-many class="cn.itcast.shop.product.beans.Product"/>
        </set>
    </class>
</hibernate-mapping>

package cn.itcast.shop.product.beans;
 
import java.util.Date;
 
import cn.itcast.shop.categorysecond.beans.CategorySecond;
 
/**
 * 商品的实体对象
 * @author 传智.郭嘉
 *
 */
public class Product {
    private Integer pid;
    private String pname;
    private Double market_price;
    private Double shop_price;
    private String image;
    private String pdesc;
    private Integer is_hot;
    private Date pdate;
    // 二级分类的外键:使用二级分类的对象.
    private CategorySecond categorySecond;
 
    //设置
 
    public CategorySecond getCategorySecond() {
        return categorySecond;
    }
    public void setCategorySecond(CategorySecond categorySecond) {
        this.categorySecond = categorySecond;
    }
    public Integer getPid() {
        return pid;
    }
    public void setPid(Integer pid) {
        this.pid = pid;
    }
    public String getPname() {
        return pname;
    }
    public void setPname(String pname) {
        this.pname = pname;
    }
    public Double getMarket_price() {
        return market_price;
    }
    public void setMarket_price(Double market_price) {
        this.market_price = market_price;
    }
    public Double getShop_price() {
        return shop_price;
    }
    public void setShop_price(Double shop_price) {
        this.shop_price = shop_price;
    }
    public String getImage() {
        return image;
    }
    public void setImage(String image) {
        this.image = image;
    }
    public String getPdesc() {
        return pdesc;
    }
    public void setPdesc(String pdesc) {
        this.pdesc = pdesc;
    }
    public Integer getIs_hot() {
        return is_hot;
    }
    public void setIs_hot(Integer is_hot) {
        this.is_hot = is_hot;
    }
    public Date getPdate() {
        return pdate;
    }
    public void setPdate(Date pdate) {
        this.pdate = pdate;
    }
 
}

Product.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.itcast.shop.product.beans.Product" table="product">
        <id name="pid">
            <generator class="native"/>
        </id>
        <property name="pname"/>
        <property name="market_price"/>
        <property name="shop_price"/>
        <property name="image"/>
        <property name="pdesc"/>
        <property name="is_hot"/>
        <property name="pdate"/>
 
        <many-to-one name="categorySecond" lazy="false" class="cn.itcast.shop.categorysecond.beans.CategorySecond" column="csid"/>
    </class>
</hibernate-mapping>

注意上面的所有的配置中lazy都设置成false，禁止hibernate的延迟加载，当查询一级分类对象的时候，就将其关联的二级对象，以及二级对象下面的所有商品显示出来

上面把一级分类，二级分类以及商品之间的关系配置成功之后，我们就可以实现下面的功能了

当用户登录成功之后，就在首页上显示出了所有的一级分类，当点击某个一级分类的菜单项的时候，在弹出的页面的左侧要显示出该对应的一级分类下所有的二级分类，并且在右侧显示出该一级分类下有多少商品，并且按照分页查询进行显示如何实现了

首先在左侧显示所有的二级分类

当用户登录成功之后，在首页就会显示所有的一级分类的名字

在menu.jsp中可以看到

<div class="span24">
    <ul class="mainNav">
        <li><a href="${ pageContext.request.contextPath }/index.action">首页</a> |</li>
        <s:iterator var="c" value="#session.cList">
            <li><a href="${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="#c.cid"/>&page=1"><s:property value="#c.cname"/></a> |</li>
        </s:iterator>
 
    </ul>
</div>

其中：session.cList就是在indexAction中查询出来的一级分类的值，存储在session中，这里就是对一级分类进行遍历，<s:property value="#c.cname"/>就是对应的显示的一级分类的名称

当用户点击一级分类的某个菜单选项的时候跳转到${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="#c.cid"/>&page=1"，跳转到product_findByCid.action这个action进行处理，并且携带当前的一级分类的cid的值，以及默认显示

当前一级分类下对应的商品，分页显示默认值为page=1传递过去

在实现分页查询之前，我们首先要定义两个实体类，该实体类能够帮助我们实现分页查询

PageBean

package cn.itcast.shop.user.utils;
 
import java.util.List;
 
/**
 * 分页类的封装
 * @author 传智.郭嘉
 *
 */
public class PageBean<T> {
    private int page;    // 当前页数
    private int totalCount; // 总记录数
    private int totalPage; // 总页数
    private int limit;    // 每页显示的记录数
    private List<T> list; // 每页显示数据的集合.
    public int getPage() {
        return page;
    }
    public void setPage(int page) {
        this.page = page;
    }
    public int getTotalCount() {
        return totalCount;
    }
    public void setTotalCount(int totalCount) {
        this.totalCount = totalCount;
    }
    public int getTotalPage() {
        return totalPage;
    }
    public void setTotalPage(int totalPage) {
        this.totalPage = totalPage;
    }
    public int getLimit() {
        return limit;
    }
    public void setLimit(int limit) {
        this.limit = limit;
    }
    public List<T> getList() {
        return list;
    }
    public void setList(List<T> list) {
        this.list = list;
    }
 
}

PageHibernateCallback

package cn.itcast.shop.user.utils;
 
import java.sql.SQLException;
import java.util.List;
 
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
 
public class PageHibernateCallback<T> implements HibernateCallback{
 
    //分页查询的hql语句
    private String hql;
    //对应的hql语句的执行参数
    private Object[] params;
    //查询的begin的位置，例如每页显示8条数据，要显示第5的数据，这里startInde等于5*8等于40
    private int startIndex;
    //当前页显示的条数,例如每页显示8条数据，这里就是8
    private int pageSize;
 
    public PageHibernateCallback(String hql, Object[] params,
            int startIndex, int pageSize) {
        super();
        this.hql = hql;
        this.params = params;
        this.startIndex = startIndex;
        this.pageSize = pageSize;
    }
 
    public List<T> doInHibernate(Session session) throws HibernateException,
            SQLException {
        //1 执行hql语句
        Query query = session.createQuery(hql);
        //2 实际参数
        if(params != null){
            for(int i = 0 ; i < params.length ; i ++){
                query.setParameter(i, params[i]);
            }
        }
        //3 分页
        query.setFirstResult(startIndex);
        query.setMaxResults(pageSize);
 
        return query.list();
    }
 
}

该类是hibernate中进行分页查询的一个关键的实现类

有了这两个类我们来看看进行查询的action

package cn.itcast.shop.product.action;
 
import java.util.List;
 
import cn.itcast.shop.category.beans.Category;
import cn.itcast.shop.category.service.CategoryService;
import cn.itcast.shop.product.beans.Product;
import cn.itcast.shop.product.service.ProductService;
import cn.itcast.shop.user.utils.PageBean;
 
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
 
public class ProductAction extends ActionSupport  implements ModelDriven<Product>{
 
    private ProductService productService;
 
    private CategoryService categoryService;
    // 注入商品的Service
 
    public ProductService getProductService() {
        return productService;
    }
    public CategoryService getCategoryService() {
        return categoryService;
    }
    public void setCategoryService(CategoryService categoryService) {
        this.categoryService = categoryService;
    }
    public void setProductService(ProductService productService) {
        this.productService = productService;
    }
    public Product getProduct() {
        return product;
    }
    public void setProduct(Product product) {
        this.product = product;
    }
    private Product product = new Product();
 
    // 接收一级分类cid
        private Integer cid;
        // 接收当前页数:
        private int page;
        // 接收二级分类id
        private Integer csid;
 
    public Integer getCsid() {
            return csid;
        }
        public void setCsid(Integer csid) {
            this.csid = csid;
        }
    public int getPage() {
            return page;
        }
        public void setPage(int page) {
            this.page = page;
        }
    public Integer getCid() {
            return cid;
        }
        public void setCid(Integer cid) {
            this.cid = cid;
        }
    @Override
    public Product getModel() {
        // TODO Auto-generated method stub
        return product;
    }
 
    // 根据商品的ID进行查询商品:执行方法:
        public String findByPid() throws Exception{
            // 调用Service的方法完成查询.
            product = productService.findByPid(product.getPid());
            return "findByPid";
        }
 
        // 根据一级分类的id查询商品:
        public String findByCid() {
            //查询出所有的一级分类
            List<Category> cList = categoryService.findAll();
            // 将cList存入到值栈中:
            ActionContext.getContext().getValueStack().set("cList", cList);
            // 根据二级分类查询商品,其中csid就是页面上传递过来的一级分类的cid，page就是页面上传递过来的第几页
            PageBean<Product> pageBean = productService.findByPageCid(cid, page);// 根据一级分类查询商品,带分页查询
            // 将PageBean存入到值栈中:
            ActionContext.getContext().getValueStack().set("pageBean", pageBean);
            return "findByCid";
        }
 
}

首先在首页点击一级菜单的选项的时候调用的是${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="#c.cid"/>&page=1"> ，调用的是findByCid这个方法，传递过来的参数是cid和page

所以：首先第一步在改action中需要定义两个成员变量

/ 接收一级分类cid
private Integer cid;
// 接收当前页数:
private int page;

来接受传递过来的参数提供对应的get和set方法

我们接下来看调用的是findByCid这个方法，在改方法中首先需要查询出所有的一级分类：调用 List<Category> cList = categoryService.findAll();这个方法，所以需要引入private CategoryService categoryService;

并且在applicationContext-action.xml中需要进行配置

    <bean id="productAction" class = "cn.itcast.shop.product.action.ProductAction" scope="prototype">
     <property name="productService" ref="productService"></property>
     <property name="categoryService" ref="categoryService"></property>
    </bean>

接下来把查询出来的一级分类存储在值栈中

接下来 PageBean<Product> pageBean = productService.findByPageCid(cid, page);// 根据一级分类查询商品,带分页查询

然后把查询出来的数据存储在值栈中

我们来看看具体的业务实现类是如何实现的

package cn.itcast.shop.product.service;
 
import java.util.List;
 
import cn.itcast.shop.product.beans.Product;
import cn.itcast.shop.product.dao.ProductDao;
import cn.itcast.shop.user.utils.PageBean;
 
public class ProductService {
    private ProductDao productDao;
 
    public ProductDao getProductDao() {
        return productDao;
    }
 
    public void setProductDao(ProductDao productDao) {
        this.productDao = productDao;
    }
 
    public List<Product> findHot() {
        // TODO Auto-generated method stub
        return productDao.findHot();
    }
    public List<Product> findNew(){
        return productDao.findNew();
    }
    public Product findByPid(Integer pid) {
        return productDao.findByPid(pid);
    }
 
    public PageBean<Product> findByPageCid(Integer cid, int page) {
        PageBean<Product> pageBean = new PageBean<Product>();
        // 设置当前页数:
        pageBean.setPage(page);
        // 设置每页显示记录数:
        int limit = 8;
        pageBean.setLimit(limit);
        // 设置总记录数:
        int totalCount = 0;
        totalCount = productDao.findCountCid(cid);
        pageBean.setTotalCount(totalCount);
        // 设置总页数:
        int totalPage = 0;
        // Math.ceil(totalCount / limit);
        if (totalCount % limit == 0) {
            totalPage = totalCount / limit;
        } else {
            totalPage = totalCount / limit + 1;
        }
        pageBean.setTotalPage(totalPage);
        // 每页显示的数据集合:
        // 从哪开始:
        int begin = (page - 1) * limit;
        List<Product> list = productDao.findByPageCid(cid, begin, limit);
        pageBean.setList(list);
        return pageBean;
    }
 
}

我们来看看具体的dao类

package cn.itcast.shop.product.dao;
 
import java.util.List;
 
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
 
import cn.itcast.shop.product.beans.Product;
import cn.itcast.shop.user.utils.PageHibernateCallback;
 
import java.sql.SQLException;
import java.util.List;
 
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
 
public class ProductDao extends HibernateDaoSupport {
 
    // 首页上热门商品查询
        public List<Product> findHot() {
            // 使用离线条件查询.
            DetachedCriteria criteria = DetachedCriteria.forClass(Product.class);
            // 查询热门的商品,条件就是is_host = 1
            criteria.add(Restrictions.eq("is_hot", 1));
            // 倒序排序输出:
            criteria.addOrder(Order.desc("pdate"));
            // 执行查询:
            List<Product> list = this.getHibernateTemplate().findByCriteria(
                    criteria, 0, 10);
            return list;
        }
 
        // 首页上最新商品的查询
        public List<Product> findNew() {
            // 使用离线条件查询:
            DetachedCriteria criteria = DetachedCriteria.forClass(Product.class);
            // 按日期进行倒序排序:
            criteria.addOrder(Order.desc("pdate"));
            // 执行查询:
            List<Product> list = this.getHibernateTemplate().findByCriteria(criteria, 0, 10);
            return list;
        }
 
        // 根据商品ID查询商品
        public Product findByPid(Integer pid) {
            return (Product) this.getHibernateTemplate().get(Product.class, pid);
        }
 
        // 根据一级分类cid查询商品的个数
        public int findCountCid(Integer cid) {
            String hql = "select count(*) from Product p where p.categorySecond.category.cid = ?";
            List<Long> list = this.getHibernateTemplate().find(hql,cid);
            if(list != null && list.size() > 0){
                return list.get(0).intValue();
            }
            return 0;
        }
 
        // 根据一级分类cid查询对应商品的集合，分页查询
        public List<Product> findByPageCid(Integer cid, int begin, int limit) {
            // select p.* from category c,categorysecond cs,product p where c.cid = cs.cid and cs.csid = p.csid and c.cid = 2
            // select p from Category c,CategorySecond cs,Product p where c.cid = cs.category.cid and cs.csid = p.categorySecond.csid and c.cid = ?
            String hql = "select p from Product p join p.categorySecond cs join cs.category c where c.cid = ?";
            // 分页另一种写法:
            List<Product> list = (List<Product>) this.getHibernateTemplate().execute(new PageHibernateCallback<Product>(hql, new Object[]{cid}, begin, limit));
            if(list != null && list.size() > 0){
                return list;
            }
            return null;
 
        }
 
}

对于dao这里要进行说明下：

要查询一级分类下所有的商品，因为涉及到三个表查询，一级分类表，一级分类下的二级分类类，二级分类下的商品表

使用的sql语句如下：

select p.* from category c,categorysecond cs,product p where c.cid = cs.cid and cs.csid = p.csid and c.cid = 2
 
但是在hibernate中使用的hql语句
转化成hql语句如下所示

select p from Category c,CategorySecond cs,Product p where c.cid = cs.category.cid and cs.csid = p.categorySecond.csid and c.cid = ?
但是上面的hql语句比较复杂，hibernate提共了下面更加方便的语句如下所示

String hql = "select p from Product p join p.categorySecond cs join cs.category c where c.cid = ?";
这个：

List<Product> list = (List<Product>) this.getHibernateTemplate().execute(new PageHibernateCallback<Product>(hql, new Object[]{cid}, begin, limit));
这里主要是为了分页查询
 
当查询到数据之后

<!-- 商品模块的Action -->
        <action name="product_*" class="productAction" method="{1}">
            <result name="findByPid">/WEB-INF/jsp/product.jsp</result>
            <result name="findByCid">/WEB-INF/jsp/productList.jsp</result>
        </action>

这里跳转到了productList.jsp页面对查询出来的数据进行显示

    <div class="hotProductCategory">
                    <s:iterator var="c" value="#session.cList">
                        <dl>
                            <dt>
                                <a href="${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="#c.cid"/>&page=1"><s:property value="#c.cname"/></a>
                            </dt>
                                <s:iterator var="cs" value="#c.categorySeconds">
                                    <dd>
                                        <a href="${ pageContext.request.contextPath }/product_findByCsid.action?csid=<s:property value="#cs.csid"/>&page=1"><s:property value="#cs.csname"/></a>
                                    </dd>
                                </s:iterator>
                        </dl>
                    </s:iterator>
            </div>

上面就分别显示每个一级分类，以及该一级分类下有哪些二级分类

<div id="result" class="result table clearfix">
                        <ul>
                            <s:iterator var="p" value="pageBean.list">
                                <li>
                                        <a href="${ pageContext.request.contextPath }/product_findByPid.action?pid=<s:property value="#p.pid"/>">
                                            <img src="${pageContext.request.contextPath}/<s:property value="#p.image"/>" width="170" height="170"  style="display: inline-block;">
 
                                            <span style='color:green'>
                                             <s:property value="#p.pname"/>
                                            </span>
 
                                            <span class="price">
                                                商城价： ￥<s:property value="#p.shop_price"/>
                                            </span>
 
                                        </a>
                                </li>
                            </s:iterator>    
 
                        </ul>

这里就是显示一级分类下有哪些商品

上面的 1 2 3 4 5 6 数字按钮在下面显示

    <div class="pagination">
            <span>第 <s:property value="pageBean.page"/>/<s:property value="pageBean.totalPage"/> 页</span>
        <s:if test="cid != null">
            <s:if test="pageBean.page != 1">
                <a href="${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="cid"/>&page=1" class="firstPage">&nbsp;</a>
                <a href="${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="cid"/>&page=<s:property value="pageBean.page-1"/>" class="previousPage">&nbsp;</a>
            </s:if>
 
            <s:iterator var="i" begin="1" end="pageBean.totalPage">
                <s:if test="pageBean.page != #i">
                    <a href="${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="cid"/>&page=<s:property value="#i"/>"><s:property value="#i"/></a>
                </s:if>
                <s:else>
                    <span class="currentPage"><s:property value="#i"/></span>
                </s:else>
            </s:iterator>
 
            <s:if test="pageBean.page != pageBean.totalPage">
                <a class="nextPage" href="${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="cid"/>&page=<s:property value="pageBean.page+1"/>">&nbsp;</a>
                <a class="lastPage" href="${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="cid"/>&page=<s:property value="pageBean.totalPage"/>">&nbsp;</a>
            </s:if>
        </s:if>
        <s:if test="csid != null">
            <s:if test="pageBean.page != 1">
                <a href="${ pageContext.request.contextPath }/product_findByCsid.action?csid=<s:property value="csid"/>&page=1" class="firstPage">&nbsp;</a>
                <a href="${ pageContext.request.contextPath }/product_findByCsid.action?csid=<s:property value="csid"/>&page=<s:property value="pageBean.page-1"/>" class="previousPage">&nbsp;</a>
            </s:if>
 
            <s:iterator var="i" begin="1" end="pageBean.totalPage">
                <s:if test="pageBean.page != #i">
                    <a href="${ pageContext.request.contextPath }/product_findByCsid.action?csid=<s:property value="csid"/>&page=<s:property value="#i"/>"><s:property value="#i"/></a>
                </s:if>
                <s:else>
                    <span class="currentPage"><s:property value="#i"/></span>
                </s:else>
            </s:iterator>
 
            <s:if test="pageBean.page != pageBean.totalPage">
                <a class="nextPage" href="${ pageContext.request.contextPath }/product_findByCsid.action?csid=<s:property value="csid"/>&page=<s:property value="pageBean.page+1"/>">&nbsp;</a>
                <a class="lastPage" href="${ pageContext.request.contextPath }/product_findByCsid.action?csid=<s:property value="csid"/>&page=<s:property value="pageBean.totalPage"/>">&nbsp;</a>
            </s:if>
        </s:if>

整个productList.jsp的代码如下所示：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="/struts-tags" prefix="s"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<!-- saved from url=(0048)http://localhost:8080/mango/product/list/1.jhtml -->
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<title>传智网上商城</title>
<link href="${pageContext.request.contextPath}/css/common.css" rel="stylesheet" type="text/css"/>
<link href="${pageContext.request.contextPath}/css/product.css" rel="stylesheet" type="text/css"/>
 
</head>
<body>
<div class="container header">
    <div class="span5">
        <div class="logo">
            <a href="http://localhost:8080/mango/">
                <img src="${pageContext.request.contextPath}/image/r___________renleipic_01/logo.gif" alt="传智播客">
            </a>
        </div>
    </div>
    <div class="span9">
<div class="headerAd">
                    <img src="${pageContext.request.contextPath}/image/header.jpg" width="320" height="50" alt="正品保障" title="正品保障">
</div>    </div>
 
    <%@ include file="menu.jsp" %>
 
</div>
<div class="container productList">
        <div class="span6">
            <div class="hotProductCategory">
                <s:iterator var="c" value="#session.cList">
                        <dl>
                            <dt>
                                <a href="${pageContext.request.contextPath}/product_findByCid.action?cid=<s:property value="#c.cid"/>&page=1"><s:property value="#c.cname"/></a>
                            </dt>
                                <s:iterator var="cs" value="#c.categorySeconds">
                                    <dd>
                                        <a href="${ pageContext.request.contextPath }/product_findByCsid.action?csid=<s:property value="#cs.csid"/>&page=1"><s:property value="#cs.csname"/></a>
                                    </dd>
                                </s:iterator>
                        </dl>
                </s:iterator>
            </div>
        </div>
        <div class="span18 last">
 
            <form id="productForm" action="${pageContext.request.contextPath}/image/蔬菜 - Powered By Mango Team.htm" method="get">
 
                <div id="result" class="result table clearfix">
                        <ul>
                            <s:iterator var="p" value="pageBean.list">
                                <li>
                                        <a href="${ pageContext.request.contextPath }/product_findByPid.action?pid=<s:property value="#p.pid"/>">
                                            <img src="${pageContext.request.contextPath}/<s:property value="#p.image"/>" width="170" height="170"  style="display: inline-block;">
 
                                            <span style='color:green'>
                                             <s:property value="#p.pname"/>
                                            </span>
 
                                            <span class="price">
                                                商城价： ￥<s:property value="#p.shop_price"/>
                                            </span>
 
                                        </a>
                                </li>
                            </s:iterator>    
 
                        </ul>
                </div>
    <div class="pagination">
            <span>第 <s:property value="pageBean.page"/>/<s:property value="pageBean.totalPage"/> 页</span>
        <s:if test="cid != null">
            <s:if test="pageBean.page != 1">
                <a href="${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="cid"/>&page=1" class="firstPage">&nbsp;</a>
                <a href="${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="cid"/>&page=<s:property value="pageBean.page-1"/>" class="previousPage">&nbsp;</a>
            </s:if>
 
            <s:iterator var="i" begin="1" end="pageBean.totalPage">
                <s:if test="pageBean.page != #i">
                    <a href="${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="cid"/>&page=<s:property value="#i"/>"><s:property value="#i"/></a>
                </s:if>
                <s:else>
                    <span class="currentPage"><s:property value="#i"/></span>
                </s:else>
            </s:iterator>
 
            <s:if test="pageBean.page != pageBean.totalPage">
                <a class="nextPage" href="${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="cid"/>&page=<s:property value="pageBean.page+1"/>">&nbsp;</a>
                <a class="lastPage" href="${ pageContext.request.contextPath }/product_findByCid.action?cid=<s:property value="cid"/>&page=<s:property value="pageBean.totalPage"/>">&nbsp;</a>
            </s:if>
        </s:if>
        <s:if test="csid != null">
            <s:if test="pageBean.page != 1">
                <a href="${ pageContext.request.contextPath }/product_findByCsid.action?csid=<s:property value="csid"/>&page=1" class="firstPage">&nbsp;</a>
                <a href="${ pageContext.request.contextPath }/product_findByCsid.action?csid=<s:property value="csid"/>&page=<s:property value="pageBean.page-1"/>" class="previousPage">&nbsp;</a>
            </s:if>
 
            <s:iterator var="i" begin="1" end="pageBean.totalPage">
                <s:if test="pageBean.page != #i">
                    <a href="${ pageContext.request.contextPath }/product_findByCsid.action?csid=<s:property value="csid"/>&page=<s:property value="#i"/>"><s:property value="#i"/></a>
                </s:if>
                <s:else>
                    <span class="currentPage"><s:property value="#i"/></span>
                </s:else>
            </s:iterator>
 
            <s:if test="pageBean.page != pageBean.totalPage">
                <a class="nextPage" href="${ pageContext.request.contextPath }/product_findByCsid.action?csid=<s:property value="csid"/>&page=<s:property value="pageBean.page+1"/>">&nbsp;</a>
                <a class="lastPage" href="${ pageContext.request.contextPath }/product_findByCsid.action?csid=<s:property value="csid"/>&page=<s:property value="pageBean.totalPage"/>">&nbsp;</a>
            </s:if>
        </s:if>
    </div>
            </form>
        </div>
    </div>
<div class="container footer">
    <div class="span24">
        <div class="footerAd">
                    <img src="${pageContext.request.contextPath}/image/footer.jpg" width="950" height="52" alt="我们的优势" title="我们的优势">
</div>    </div>
    <div class="span24">
        <ul class="bottomNav">
                    <li>
                        <a >关于我们</a>
                        |
                    </li>
                    <li>
                        <a>联系我们</a>
                        |
                    </li>
                    <li>
                        <a >诚聘英才</a>
                        |
                    </li>
                    <li>
                        <a >法律声明</a>
                        |
                    </li>
                    <li>
                        <a>友情链接</a>
                        |
                    </li>
                    <li>
                        <a target="_blank">支付方式</a>
                        |
                    </li>
                    <li>
                        <a  target="_blank">配送方式</a>
                        |
                    </li>
                    <li>
                        <a >官网</a>
                        |
                    </li>
                    <li>
                        <a >论坛</a>
 
                    </li>
        </ul>
    </div>
    <div class="span24">
        <div class="copyright">Copyright©2005-2015 网上商城 版权所有</div>
    </div>
</div>
</body></html>

相当的经典

SSH网上商城二的更多相关文章

SSH网上商城---邮件发送
注册网站账号的时候,都需要发送激活邮件,然后让注册的用户点击激活链接方可完成注册,不过话说回来,为什么注册的时候需要发送邮件呢?为什么不注册的时候直接激活呢?一定要收一封激活帐号的邮件?网站这样做的好 ...
《SSH网上商城》-视频目录--代码可以跑起来
本课程是2015年2月份的,就是14年底的. 课程第一天的代码-添加 jsp-api.jar servlet-api.jar就可以跑起来,环境 JDK1.7 和tomcat8, SSH网上商城\S ...
SSH网上商城一
Java高级项目之SSH网上商城项目实战: 1.采用目前最主流的三大框架开发即Struts2+Spring+Hibernate框架整合开发.2.通过AJAX技术提供良好的用户体验.3.提供了邮箱激活的 ...
SSH网上商城---用户激活
在前面的博客中,小编主要结合SSH网上商城这个项目,简单的介绍了如何实现邮件发送的这个功能,邮件发送了,接下来就是激活了,为什么呢?现在大多网站都要通过对账号进行激活,然后才能注册成功,这是防止恶性注 ...
SSH网上商城---使用ajax完成用户名是否存在异步校验
小伙伴在上网的时候,需要下载或者观看某些视频资料,更或者是在逛淘宝的时候,我们都需要注册一个用户,当我们填写好各种信息,点击确定的时候,提示用户名已经存在,小编就想,为什么当我们填写完用户名的时候,她 ...
SSH网上商城---需求分析+表关系分析
SSH---小编初次接触的时候傻傻的以为这个跟SHE有什么关系呢?又是哪路明星歌手,后来才知道小编又土鳖了,原来SSH是这个样子滴,百度百科对她这样阐述,SSH即 Spring + Struts +H ...
[Java]ssh网上商城总结标签： hibernatessh 2016-05-15 21:03 1099人阅读评论(32)
前几日敲完了ssh网上商城,虽然现在已经敲完了整个系统,却发现自己对于ssh,了解的一点都不多,什么是struts2,什么是spring,什么是hibernate,自己都是稀里糊涂,然后看了一下后面的 ...
【SSH网上商城项目实战01】整合Struts2、Hibernate4.3和Spring4.2
转自:https://blog.csdn.net/eson_15/article/details/51277324 今天开始做一个网上商城的项目,首先从搭建环境开始,一步步整合S2SH.这篇博文主要总 ...
【SSH网上商城项目实战30】项目总结
转自:https://blog.csdn.net/eson_15/article/details/51479994 0. 写在前面项目基本完成了,加上这个总结,与这个项目相关的博客也写了30篇了 ...

随机推荐

java方式实现基数排序
一.基数排序描述基数排序(radix sort)属于"分配式排序"(distribution sort),又称"桶子法"(bucket sort)或bin s ...
01 . Prometheus简介及安装配置Grafana
Promethus简介 Prometheus受启发于Google的Brogmon监控系统(相似的Kubernetes是从Google的Brog系统演变而来),从2012年开始由前Google工程师在S ...
被缠上了，小王问我怎么在 Spring Boot 中使用 JDBC 连接 MySQL
上次帮小王入了 Spring Boot 的门后,他觉得我这个人和蔼可亲.平易近人,于是隔天小王又微信我说:"二哥,快教教我,怎么在 Spring Boot 项目中使用 JDBC 连接 MyS ...
Golang模拟用户登陆，突破教务系统
目录一.Golang模拟用户登陆,突破教务系统 1.1 请求登陆页面 1.2 抓包分析登陆请求 1.3 golang使用js引擎合成salt 1.4 模拟表单提交,完成登陆 1.5 进入成绩查询页, ...
jchdl - GSL值的传播
https://mp.weixin.qq.com/s/jgMljoca-Cwe9x0NaTLzZg GSL的拓扑模型是线和节点连接的模型,值的传播,即是值在线和节点之间传播和转化的过程. 值的 ...
用python实现汉诺塔问题
一.用动画实现汉诺塔问题: import turtle class Stack: def __init__(self): self.items = [] def isEmpty(self): retu ...
Java实现 LeetCode 467 环绕字符串中唯一的子字符串
467. 环绕字符串中唯一的子字符串把字符串 s 看作是"abcdefghijklmnopqrstuvwxyz"的无限环绕字符串,所以 s 看起来是这样的:"-zabc ...
Java实现蓝桥杯VIP 算法训练求完数
问题描述如果一个自然数的所有小于自身的因子之和等于该数,则称为完数.设计算法,打印1-9999之间的所有完数. 样例输出与上面的样例输入对应的输出. 例: 数据规模和约定 1-9999 publi ...
Java实现 LeetCode 162 寻找峰值
162. 寻找峰值峰值元素是指其值大于左右相邻值的元素. 给定一个输入数组 nums,其中 nums[i] ≠ nums[i+1],找到峰值元素并返回其索引. 数组可能包含多个峰值,在这种情况下,返 ...
java实现海盗比酒量
** 海盗比酒量** 有一群海盗(不多于20人),在船上比拼酒量.过程如下:打开一瓶酒,所有在场的人平分喝下,有几个人倒下了.再打开一瓶酒平分,又有倒下的,再次重复- 直到开了第4瓶酒,坐着的已经所剩 ...

SSH网上商城二

SSH网上商城二的更多相关文章

随机推荐

热门专题