SSH综合练习-仓库管理系统-第二天

SSH综合练习-仓库管理系统-第二天

今天的主要内容：

货物入库
1. 页面信息自动补全回显功能：（学习目标：练习Ajax交互）

根据货物简记码来自动查询回显已有货物（Ajax回显）
根据货物名来自动查询补全已有货物（自动补全插件）

货物入库功能：（学习目标：练习多表插入）

保存货物信息的同时记录入库的历史记录。
更新货物信息的同时记录入库的历史记录。

库存管理功能(分页+多条件)
1. 分页数据Bean的设计
2. 要编写Pagination Bean
3. 分页后台的代码编码

QBC方案—Hibernate做法
SQL拼接方案—传统做法（选做）

分页工具条的编写（了解）
分页代码重构优化（抽取分页代码）

历史记录查询（课后作业，涉及到多表）
出库功能（课后作业，自己思考逻辑，和入库逻辑差不多）
公共代码封装打包（了解）

课程目标：

Ajax的使用和多表的插入，强化复习
jQueryUI的插件的使用方法。自动补全查询。
业务条件+分页条件的综合查询

货物入库功能
1. 根据简记码查询货物（精确匹配）

点击【入库】

业务分析：

简记码是为了方便用户快速定位已存在的货物而设计的。需要分析两个方面：

关于简记码回显的使用。

当用户输入简记码时，通过Ajax请求，将用户输入的简记码发送到服务器，服务器判断简记码是否存在。

如果存在，则说明货物也存在，则查询出货物信息，回显给表单。当点击"入库"的时候，进行更新货物的数量即可。
如果不存在，则说明数据库中没有对应的货物，这是一个新的货物，需要手动输入货物的完整信息。当点击"入库"的时候，进行保存货物的所有信息。

2. 关于同一个按钮功能是走更新还是保存，服务器端如何判断调用什么方法呢？

通过主键id来判断。因此，则需要在form表单中放置一个隐藏域id，如果货物存在，则id有值，则后台只更新货物数量即可；如果货物不存在，则id没值，则插入保存一个新的货物。

开发思路：

业务一：校验数据库简记码是否存在

改造页面表单为struts标签（因为要回显一些信息）
编写页面的Ajax请求代码（事件代码）
编写后台服务器端代码，货物的数据封装为json返回到前台（fireBug调试）
完善页面的Ajax请求代码，完善回调函数，进行页面数据的回显。

第一步：改造页面表单为struts标签，修改jsps/save/save.jsp

<s:form action="goods_instore" namespace="/" method="post" name="select">

</s:form>

save.jsp页面

<tr>

<td>

简记码：

</td>

<td>

<s:textfield name="nm" cssClass="tx"/>

<s:hidden name="id" cssClass="tx"/>

</td>

</tr>

<tr>

<td>

货物名称：

</td>

<td>

<s:textfield name="name" cssClass="tx"/>

</td>

</tr>

<tr>

<td>

计量单位：

</td>

<td>

<s:textfield name="unit" cssClass="tx"/>

</td>

</tr>

<tr>

<td>

入库数量：

</td>

<td>

<s:textfield name="amount" cssClass="tx"/>

</td>

</tr>

<tr>

<td>

选择仓库：

</td>

<td>

<select class="tx" style="width:120px;" name="store.id" id="store_id">

</select>

(此信息从数据库中加载)

</td>

</tr>

提示：注意关联属性对象的数据是如何封装的。

测试：改造完页面后，测试页面是否正常。

第二步：编写页面的Ajax请求代码（事件代码）：

用户输入简记码，使用失去焦点的事件blur（离焦事件），发起Ajax请求。验证简记码在数据库中是否存在。

//简记码绑定一个离焦事件

$("input[name='nm']").blur(function(){

//请求服务器，获取货物信息

$.post("${pageContext.request.contextPath}/goods_findByNmAjax.action",{"nm":$(this).val()},function(data){

//data：返回的json对象，一个（简记码和货物是一对一关系）

alert(data)

});

第三步：编写后台服务器端代码（Action类），货物的数据封装为json返回到前台（fireBug调试）

在服务器端接收到的简记码，进行逻辑处理，将结果转换为json返回。

创建GoodsAction.java 代码

//货物的表现层

public class GoodsAction extends BaseAction<Goods>{

//注入service

private IGoodsService goodsService;

public void setGoodsService(IGoodsService goodsService) {

this.goodsService = goodsService;

}

//根据简记码查询货物（ajax）

public String findByNmAjax(){

Goods goods = goodsService.findGoodsByNm(model.getNm());

//将goods对象转换成json字符串

//压入栈顶

pushValueStackRoot(goods);

return "json";

}

第四步：编写业务层代码

编写IGoodsService 接口

//货物的业务层接口

public interface IGoodsService {

/**

* 根据简记码查询货物

* @param nm

* @return

public Goods findGoodsByNm(String nm);

}

实现类 GoodsServiceImpl

//货物的业务层实现

public class GoodsServiceImpl extends BaseService implements IGoodsService{

//注入dao

private IGenericDao<Goods, String> goodsDao;

public void setGoodsDao(IGenericDao<Goods, String> goodsDao) {

this.goodsDao = goodsDao;

}

public Goods findGoodsByNm(String nm) {

//qbc

DetachedCriteria criteria = DetachedCriteria.forClass(Goods.class)

.add(Restrictions.eq("nm", nm));

List<Goods> list = goodsDao.findByCriteria(criteria);

return list.isEmpty()?null:list.get(0);

}

第五步：配置struts.xml

</action>

代码优化：

通过配置代码发现，返回json的结果集配置一样，那么可以将其抽取为全局的结果集配置：

<global-results>

</global-results>

</package>

提示：后面只要需要转换为json，直接返回json结果集即可。

第六步：配置applicationContext.xml

</bean>

</bean>

</bean>

第七步：测试：

在数据库中手动插入一个货物，然后使用firebug进行抓包测试。

Ajax加载出错：延迟加载错误（一对多）

Caused by: org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: cn.itcast.storemanager.domain.Goods.histories, no session or session was closed

解决方法：对于不需要转换返回的数据，用@JSON排除集合属性Histories

//排除histories历史集合中的属性转换json

@JSON(serialize=false)

public Set getHistories() {

return this.histories;

}

Ajax加载仍然出错：延迟加载错误（多对一）

由于save.jsp页面中使用：

$("#store_id").val(data.store.id);//从货物关联到仓库

所以要求货物中关联仓库。

所以报错

Caused by: org.hibernate.LazyInitializationExcep

Caused by: org.hibernate.LazyInitializationException: could not initialize proxy - no Session

解决方法：货物关联的仓库的数据是需要的，不能排除，需要加载

两种方式：

将store改为立即加载（hbm---class标签lazy属性改为false）

修改：Goods.hbm.xml文件：

<many-to-one name="store" class="cn.itcast.storemanager.domain.Store" fetch="select" lazy="false">

</many-to-one>

配置 OpenSessionInView来解决，这里注意使用OpenSessionInView过滤器一定要放置到struts2的过滤器的前面。

在web.xml容器中添加：

<filter-name>OpenSessionInView</filter-name>

<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>OpenSessionInView</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

使用火狐的firebug调试，测试结果（js对象）：

第八步：完善页面的Ajax请求代码，完善回调函数，进行页面数据的回显。

编写回调函数内容，将页面的字段元素赋值。

//简记码绑定一个离焦事件

$("input[name='nm']").blur(function(){

//请求服务器，获取货物信息

$.post("${pageContext.request.contextPath}/goods_findByNmAjax.action",{"nm":$(this).val()},function(data){

//data：返回的json对象，一个（简记码和货物是一对一关系）

if(data ==null){

//没有匹配的货物,清除表单

$("input[name='name']").val("");

$("input[name='unit']").val("");

$("#store_id").val("");

//隐藏域

$("input[name='id']").val("");//id属性很重要，用来判断是修改已有的货物还是新增一个货物

//解禁

$("input[name='name']").removeAttr("disabled");

$("input[name='unit']").removeAttr("disabled");

$("#store_id").removeAttr("disabled");

}else{

//填充

$("input[name='name']").val(data.name);

$("input[name='unit']").val(data.unit);

$("#store_id").val(data.store.id);//从货物关联到仓库

//隐藏域

$("input[name='id']").val(data.id);//id属性很重要，用来判断是修改已有的货物还是新增一个货物

//禁用表单元素

$("input[name='name']").attr("disabled",true);

$("input[name='unit']").attr("disabled",true);

$("#store_id").attr("disabled",true);

}

});

根据货物名称查询（模糊匹配，自动补全）

目标效果参考：百度

联想提示。。。

jQuery UI的autocomplete插件介绍和引入

autocomplete插件是jQuery官方提供了一些免费开源的插件集中的一个插件。

下载jquery-ui-1.9.2.custom.zip

将插件集解压到硬盘：

查看插件的功能：点击index.html，可以看到效果

下面我们开始开发实现：

第一步：引入jquery ui开发的js和css

只引用插件相关的组件js

缺点：组建js必须要很熟悉才能导入。--不推荐

另外一种方式：全部引入，推荐，我们就采用这种，具体方法见下面：

插件的引入方式（两步）：

1）导入相关文件：jQuery核心、插件的js和CSS样式

2）在页面中引入jQuery、插件js、插件的css

导入jqueryui插件的js和css

插件如何使用？

可以参考自带的示例或api文档。

该补全插件主要有两种应用：本地数据自动补全和动态数据补全。

第二步：如果开发呢？

点击：autocomplete.html文件，里面有开发案例

应用一：本地数据自动补全

方法是：对source属性绑定一个数组。

//对货物名称进行自动补全功能

//方案一：-----数据源是固定的，如果数据源非常大，那么这里要加载所有的大量数据

$( "input[name='name']" ).autocomplete({

source: [ "c++", "java", "php", "coldfusion", "javascript", "asp", "ruby" ]

});

针对货物名称的输入框：

<tr>

<td>

货物名称：

</td>

<td>

<s:textfield name="name" cssClass="tx"/>

</td>

</tr>

页面效果：

缺点：不适用于大规模数据，页面要加载全部的数据。

应用二：动态数据补全（远程数据加载实时补全）

根据用户输入内容，实时查询，实现数据的补全。

方法是：对source绑定一个function(request,response),通过request.term获取输入的值，通过response包装要显示的值。

第一步：编写save.jsp

//方案二：-----自定义数据源，从数据库中查询，动态加载数据

$( "input[name='name']" ).autocomplete({

//request.term：文本框输入的值

//response(json数组结果)

source: function( request, response ) {

$.post("${pageContext.request.contextPath}/goods_findByNameLikeAjax.action",{"name":request.term},function(data){

//data:json数组

response(data);

});

第三步：编写GoodsAction的findByNameLikeAjax方法

//根据名称模糊匹配（ajax）

public String findListByNameAjax(){

List<Goods> list = goodsService.findGoodsByNameLike(model.getName());

pushValueStackRoot(list);

return "json";

}

第四步：业务层

接口IGoodsService类

    /**

     * 根据名称模糊查询货物列表

     * @param name

     * @return

     */

    public List<Goods> findGoodsByNameLike(String name);
实现类GoodsServiceImpl类

s    public List<Goods> findGoodsByNameLike(String name) {

        //qbc

        DetachedCriteria criteria = DetachedCriteria.forClass(Goods.class)

                .add(Restrictions.like("name", "%"+name+"%"));

        return goodsDao.findByCriteria(criteria);

    }

第五步：配置struts.xml 结果集返回（略，使用全局结果集）

<package name="default" namespace="/" extends="json-default">

    

    <global-results>

        

            <result name="json" type="json">

            </result>

    </global-results>

</package>

第六步：页面测试：

问题：下拉列表中没有显示值。

查看火狐浏览器，看到返回的结果：

分析：

如果使用简单的数组数据是没有问题的：

原因：数据格式不对。我们用的是复杂的json数据格式。

复杂数据怎么办？

点击：autocomplete.html文件

选择"source"

需要在数组的元素对象中指定label或者value才能显示。如果只指定一个，那么另外一个的值默认会等于这个值，即：你指定lable:"阿司匹林"，如果没有value的话那么值也是"阿司匹林"。

那么如何指定label呢？

就让生成json的时候有这个getter属性就行了。

操作：

两种方法：

方法一：修改Goods实体类，添加getLabel方法：（采用方案）

    //增加label属性来显示下拉列表，增加label为key的getter方法

    public String getLabel(){

        return name + "("+ store.getName() +")";

    }



    public String getValue() {

        return this.name;

    }

测试页面：ok。

此时查看火狐浏览器

【继续优化一】：

根据选择的label来显示其他货物的信息。

分析：需要添加选中列表的事件。

查看API的event章节：

我们找到select事件：

说明：select是要指定更改的事件名字，ui.item是从列表中选中的js对象（我们这里是goods数据对象）。

完善save.jsp页面代码：

//方案二：-----自定义数据源，从数据库中查询，动态加载数据

        $( "input[name='name']" ).autocomplete({

            //形式参数，不是servlet的api

            //request：可以用来获取文本框输入的值，request.term，可以进行异步请求查询，返回data

            //response:用来包装返回的数据的（接受普通数组或json数组），用法将数据放入即可response(data)

//例如：

            //request.term：文本框输入的值

            //response(json数组结果)

         source: function( request, response ) {



                 $.post("${pageContext.request.contextPath}/goods_findByNameLikeAjax.action",{"name":request.term},function(data){

                     //data:json数组

                     response(data);

                 });



         },

         //选择的事件

            select:function(event,ui){

                    //填充其他字段

                    //ui.item是当前选中的js对象，这里是货物goods的js数据内容

                    $("input[name='id']").val(ui.item.id);

                    $("input[name='nm']").val(ui.item.nm);

                    //$("input[name='name']").val(ui.item.name);//可选

                    $("input[name='unit']").val(ui.item.unit);

                    $("#store_id").val(ui.item.store.id);

            },

        });

这里注意：要填充id的值。

【继续优化二】：

在查询前将要填充的字段置空。否则显示的值不对

最终完整代码：

//方案二：-----自定义数据源，从数据库中查询，动态加载数据

        $( "input[name='name']" ).autocomplete({

//形式参数，不是servlet的api

            //request：可以用来获取文本框输入的值，request.term，可以进行异步请求查询，返回data

            //response:用来包装返回的数据的（接受普通数组或json数组），用法将数据放入即可response(data)

//例如：

            //request.term：文本框输入的值

            //response(json数组结果)

         source: function( request, response ) {

                 //清除表单

                 $("input[name='nm']").val("");

                    $("input[name='unit']").val("");

                    $("#store_id").val("");

                    //隐藏域

                    $("input[name='id']").val("");



//解禁

                    $("input[name='unit']").removeAttr("disabled");

                $("#store_id").removeAttr("disabled");



                 $.post("${pageContext.request.contextPath}/goods_findByNameLikeAjax.action",{"name":request.term},function(data){

                     //data:json数组

                     response(data);

                 });



         },

         //选择的事件

            select:function(event,ui){

                    //填充其他字段

                    //ui.item是当前选中的js对象，这里是货物goods的js数据内容

                    $("input[name='id']").val(ui.item.id);

                    $("input[name='nm']").val(ui.item.nm);

                    //$("input[name='name']").val(ui.item.name);//可选

                    $("input[name='unit']").val(ui.item.unit);

                    $("#store_id").val(ui.item.store.id);



//禁用表单元素

                    $("input[name='unit']").attr("disabled",true);

                    $("#store_id").attr("disabled",true);

            },

        });
1. 货物入库功能（服务器端实现）
要点：
1. 逻辑上：到底是更新还是保存？根据隐藏域的id来判断。
2. 数据操作上：多表插入的（关联属性使用，历史记录）、快照更新
分析：提交入库表单，需要实现商品入库逻辑（更新或保存）和操作历史记录

第一步：save.jsp页面，表单提交

<s:form action="goods_instore" namespace="/" method="post" name="select">

                    <table width="100%" border="0" cellpadding="0" cellspacing="0" class="tx" align="center">

                        <colgroup>

                            <col width="20%" align="right">

                            <col width="*%" align="left">

                        </colgroup>

                        <tr>

                            <td bgcolor="a0c0c0" style="padding-left:10px;" colspan="2" align="left">

                                <b>货物入库登记：</b>

                            </td>

                        </tr>

                        <tr>

                            <td>

                                简记码：

                            </td>

                            <td>

                                <s:textfield name="nm" cssClass="tx"/>

                                

                                <s:hidden name="id" cssClass="tx"/>

                            </td>

                        </tr>

                        <tr>

                            <td>

                                货物名称：

                            </td>

                            <td>

                                <s:textfield name="name" cssClass="tx"/>

                            </td>

                        </tr>

                        <tr>

                            <td>

                                计量单位：

                            </td>

                            <td>

                                <s:textfield name="unit" cssClass="tx"/>

                            </td>

                        </tr>

                        <tr>

                            <td>

                                入库数量：

                            </td>

                            <td>

                                <s:textfield name="amount" cssClass="tx"/>

                            </td>

                        </tr>

                        <tr>

                            <td>

                                选择仓库：

                            </td>

                            <td>



                                <select class="tx" style="width:120px;" name="store.id" id="store_id">



                                </select>

                                (此信息从数据库中加载)

                            </td>

                        </tr>

                        <tr>

                            <td colspan="2" align="center" style="padding-top:10px;">

                                <input class="tx" style="width:120px;margin-right:30px;" type="button" onclick="document.forms[0].submit();" value="入库">

                                <input class="tx" style="width:120px;margin-right:30px;" type="reset" value="取消">

                            </td>

                        </tr>

                    </table>

                </s:form>

在save.jsp中，使用ajax对隐藏域id赋值，用来判断执行的是向货物表中存放数据，还是通过简记码更新货物表的数量

//简记码绑定一个离焦事件

        $("input[name='nm']").blur(function(){

            //请求服务器，获取货物信息

            $.post("${pageContext.request.contextPath}/goods_findByNmAjax.action",{"nm":$(this).val()},function(data){

                //data：返回的json对象，一个（简记码和货物是一对一关系）

                if(data ==null){

                    //没有匹配的货物,清除表单

                    $("input[name='name']").val("");

                    $("input[name='unit']").val("");

                    $("#store_id").val("");

                    //隐藏域

                    $("input[name='id']").val("");

                    //解禁

                    $("input[name='name']").removeAttr("disabled");

                    $("input[name='unit']").removeAttr("disabled");

                    $("#store_id").removeAttr("disabled");



                }else{

                    //填充

                    $("input[name='name']").val(data.name);

                    $("input[name='unit']").val(data.unit);

                    $("#store_id").val(data.store.id);//从货物关联到仓库

                    //隐藏域

                    $("input[name='id']").val(data.id);



                    //禁用表单元素

                    $("input[name='name']").attr("disabled",true);

                    $("input[name='unit']").attr("disabled",true);

                    $("#store_id").attr("disabled",true);

                }

            });

        });

第二步：在GoodsAction 添加save方法

    //入库操作

    public String instore(){

        //将数据传递给业务层

        goodsService.saveStore(model);

        //从业务角度，继续录入，跳回入库页面

        return "savejsp";

    }

第三步：业务层

（1）IGoodsService代码

/**

     * 入库

     * @param goods

     */

    public void saveStore(Goods goods);
GoodsServiceImpl类代码，操作入库的同时，操作历史，所以需要goodsDao和historyDao

//入库：有两个逻辑，一个插入，一个更新

    public void saveStore(Goods goods) {

        //货物id

        String id = goods.getId();

        //当前登录人

        Userinfo loginUser = ServletUtils.getLoginUserFromSession();

        //根据id判断是插入还是更新

        if(StringUtils.isBlank(id)){

            //插入:字段有没有都填充

            goodsDao.save(goods);//持久态oid，抢占id



            //插入历史记录（一般没有更新）:瞬时态--》持久态

            History history = new History();

            history.setAmount(goods.getAmount());//操作的数量

            history.setRemain(goods.getAmount());//操作后的剩余数量

            //将其封装常量

//            history.setType("1");//操作类型1:入库，２：出库

            history.setType(DataConstant.OPER_TYPE_IN);//操作类型1:入库，２：出库

            history.setGoods(goods);//货物外键:只要对象有oid即可

            //注意：当前用户没有登录的情况下，空指针。解决方案;登录拦截器

            history.setUser(loginUser.getName());//操作人：一般当前登陆人,

//            history.setDatetime(new Date().toLocaleString());//操作时间

            history.setDatetime(DateUtils.getCurrentDateString());//操作时间

            historyDao.save(history);



        }else{

            //更新:

            //hibernate两种方式:update方法（更新所有字段），快照更新（部分字段）

//            goodsDao.update(goods);

            //快照更新

            Goods persistGoods = goodsDao.findById(Goods.class, id);

            //更改一级缓存

            persistGoods.setAmount(persistGoods.getAmount()+goods.getAmount());

            //等待快照更新



            //插入历史记录（一般没有更新）:瞬时态--》持久态

            History history = new History();

            history.setAmount(goods.getAmount());//操作的数量

            history.setRemain(persistGoods.getAmount());//操作后的剩余数量

//            history.setType("1");//操作类型1:入库，２：出库

            history.setType(DataConstant.OPER_TYPE_IN);//操作类型1:入库，２：出库

            history.setGoods(persistGoods);//货物外键:只要对象有oid即可

            history.setUser(loginUser.getName());//操作人：一般当前登陆人

//            history.setDatetime(new Date().toLocaleString());//操作时间

            history.setDatetime(DateUtils.getCurrentDateString());//操作时间

            historyDao.save(history);

        }



    }

第四步：封装优化操作，简化代码的行数，将公用的方法提取出来：
Dataconstant.java，用来封装常量，统一维护常量

public class DataConstant {

    //入库常量

    public static final String OPER_TYPE_IN="1";

    //出库常量

    public static final String OPER_TYPE_OUT="2";



}
DateUtils.java，日期类封装，获取当前日期，将日期类型转换成String类型

//操作日期的：

//将日期转换成各种各样的字符串：日期，时间

//网上

public class DateUtils {



    //获取到当前日期的字符串表示形式

    public static String getCurrentDateString(){

        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        return df.format(new Date());

    }

}

第五步：配置struts.xml 入库后跳转的页面



        <action name="goods_*" class="goodsAction" method="{1}">

            

            

            <result name="savejsp" type="redirect">/jsps/save/save.jsp</result>

        </action>

第六步：配置applicationContex.xml 在 GoodsService注入HistoryDAO



    <bean id="historyDao" class="cn.itcast.storemanager.dao.impl.GenericDaoImpl">

        <property name="sessionFactory" ref="sessionFactory"/>

    </bean>



    

    <bean id="goodsService" class="cn.itcast.storemanager.service.impl.GoodsServiceImpl">

        <property name="goodsDao" ref="goodsDao"/>

        <property name="historyDao" ref="historyDao"></property>

    </bean>

注意：

多表的插入（对象状态，持久态对象不能关联瞬时态对象），在多的一端需要关联持久对象
保存或更新的判断（使用页面的隐藏域id）
一个Service可以多个dao的注入

库存管理功能
1. 分页数据Bean的设计思路

分析几种查询（从查询的角度来说）：

条件查询：多个条件组合查询，需要将用户输入的条件，根据判断，拼接条件（sql：where条件的SQL语句。qbc：离线条件拼装）
分页查询：需要得到要查询记录的索引和要查询的条数（mysql：limit 起始索引,最大记录数）；或者需要得到查询记录的起始和结束的行数（Oracle）。
条件查询+分页查询：需要在分页查询过程中记录原来的查询条件（url?+条件），原理见下图：

关键点（设计思想）：查询条件（业务条件和分页条件）在客户端和服务器端来回传递。--封装一个bean对象（分页bean）用于存储条件。和返回结果使用。

分页数据Bean的设计实现

第一步：库存管理，修改main.jsp

<s:a action="goods_listPage" namespace="/" target="content" id="left1002" >

[库存管理]

</s:a>

第二步：改造页面（form部分）：

jsps/store/remain.jsp

（1）修改标签

<s:form action="goods_listPage" namespace="/" method="post" name="select">

</colgroup>

<tr>

</td>

</tr>

<tr>

<td>

简记码：

</td>

<td>

<s:textfield name="nm" cssClass="tx"/>

</td>

</tr>

<tr>

<td>

货物名称：

</td>

<td>

<s:textfield name="name" cssClass="tx"/>

</td>

</tr>

<tr>

<td>

选择仓库：

</td>

<td>

<select class="tx" style="width:120px;" name="store.id" id="store_id">

<option value="">--请选择--</option>

</select>

</td>

</tr>

<tr>

</td>

</tr>

</table>

</s:form>

添加ajax



<script type="text/javascript" src="${pageContext.request.contextPath }/js/jquery-1.8.3.js"></script>

<script type="text/javascript">

    $(function(){

        //$.post(请求url，请求参数，回调函数，返回的类型);

        $.post("${pageContext.request.contextPath}/store_listAjax.action",function(data){

            //data：转换后的对象：json对象数组-dom对象

            $(data).each(function(){

                //this每一个对象json

                //this.id

                var option=$("<option value='"+this.id+"'>"+this.name+"</option>");

                //添加到下拉列表中

                $("#store_id").append(option);

            });

//回显下拉选择，手动给select列表选中一个选中的值，从隐藏域中获取选中的值。

            //alert($("#storeId").val());

            $("#store_id").val($("#storeId").val());

        });





    });

</script>

（3）通过传递store.id用来完成下拉框的回显

<table border="0" class="tx" width="100%">

        <tr>

            <td>当前位置>>首页>>货物库存</td>

            <input type="hidden" id="storeId" value="${store.id }">

        </tr>

    </table>

第三步：设计服务器分页查询数据Bean

新建一个包cn.itcast.storemanager.page，创建类Pagination.java存放数据分页Bean。

思考：

Pagination要通用，所以引入泛型。

//分页bean

//封装请求和响应的相关数据

// * 业务层：要：业务条件+分页条件

// 业务层：提供：数据列表+分页结果（总记录数）

public class Pagination<T> {

}

传递参数：客户端会传过来哪些条件？

当前页：查询第几页，比如第二页，如果第一次，默认应该是第一页。
每页最多显示的记录数：该值可以是用户自定义的，也可以是系统默认的，我们这里默认为3。
查询的业务条件：用户在页面填写的参数条件，可以是单条件，也可以是组合的多条件。

返回数据：服务端可以返回哪些数据呢？

数据列表：根据客户端传过来的组合条件和页码查询出的数据list。
总页数：给客户端显示有多少页，或者根据这个总页数来判断客户端实际要显示多少个分页数字按钮。
总的记录数：可以给客户端显示，也用来计算总页数。

// 分页bean

// 封装请求和响应的相关数据

// 业务层：要：业务条件+分页条件

// 业务层：提供：数据列表+分页结果（总记录数）

public class Pagination<T> {

//--------请求的条件

private int page = 1;//当前页码,默认第一次页码是1

private int pageSize = 3;//每页最大记录数，我们的这个业务没有，默认给出3

//业务条件

// private T t;//页面查询的业务条件，经常可能不是数据库的字段（实体类的属性）

// 获取所有参数的方法ServletActionContext.getRequest().getParameterMap()

private Map<String, String[]> parameterMap;//最灵活，可以封装任何的参数条件

//--------响应的结果

//不管用什么技术，所有的分页组合条件查询，都需要查询两次：一次总记录数，一次查询数据列表

//结果数据列表

private List<T> resultList;//数据库查询的结果集列表

private long totalCount;//总记录数，数据库查询的总记录数

private long totalPage;//总页码数（计算出来的，不是查询出来）

}

提示：需要添加getter和setter方法。

分析：

一般参数条件用map更灵活，可以放置任何条件。泛型参数类型的设计根据request.getParameterMap来设计，后台通过这个方法取到的数据直接封装到这里就行了。

代码完善：

计算总页数：

总页数=（总的记录数+每页最多显示的记录数-1）/每页最多显示的记录数。

public void setTotalCount(long totalCount) {

//计算一些东西

//计算总页码数：

totalPage=(totalCount+pageSize-1)/pageSize;

//计算页面的页码中"显示"的起始页码和结束页码

//一般显示的页码叫好的效果是最多显示10个页码

//算法是前5后4，不足补10

//计算显示的起始页码（根据当前页码计算）：当前页码-5

begin = page-5;

if(begin<1){//页码修复

begin=1;

}

//计算显示的结束页码（根据开始页码计算）：开始页码+9

end=begin+9;

if(end>totalPage){//页码修复

end=totalPage;

}

//起始页面重新计算（根据结束页码计算）：结束页码-9

begin=end-9;

if(begin<1){

begin=1;

}

System.out.println(begin +"和" +end);

this.totalCount = totalCount;

}

每页第一条记录的索引：（新增方法）

//设置两个getter属性

//起始索引

public int getFirstResult(){

//计算起始索引

return (page-1)*pageSize;

}

每页要查询的最大记录数：（新增方法）

//最大记录数

public int getMaxResults(){

return pageSize;

}

第四步：编写Action代码，准备分页参数

在GoodsAction 中添加listPage方法

//分页列表综合查询

//思路：

* 将业务条件和分页条件都封装到一个分页bean中，

* 将分页bean传递给业务层，处理逻辑（拼接sql，调用dao查询数据）

* 业务层：要：业务条件+分页条件

* 业务层：提供：数据列表+分页结果（总记录数）

* 所有数据，全部都封装分页bean中。

* 表现层：将条件装到bean，将已经有结果的bean，给页面（值栈），在页面显示

public String listPage(){

//1.将条件装到分页bean中

//实例化一个分页bean

Pagination<Goods> pagination = new Pagination<Goods>();

//封装业务条件

pagination.setParameterMap(ServletActionContext.getRequest().getParameterMap());

//封装页码和最大记录数?page=2&pageSize=3

//思路：获取这两个参数：1。可以从参数中直接获取2。使用struts值栈来封装数据

//获取值可以使用：方案一：ServletActionContext.getRequest().getParameter("page");

//获取值可以使用：方案二：struts2的属性驱动

//如果第一次查询，则会出现page为0的情况

if(page>0){

pagination.setPage(page);

}

if(pageSize>=1){

pagination.setPageSize(pageSize);

}

//2.将分页bean传递给业务层,注意：业务层查询出来的数据，再封装回分页bean

//对象引用的知识点

//pagination=goodsService.findGoodsListPage(pagination);

goodsService.findGoodsListPage(pagination);

//3.将分页bean

//放入栈顶

result =pagenation ; //action的属性

//跳转到列表页面

return "remainjsp";

}

//值栈封装属性的值，使用属性驱动获取页面传递的当前页（page）和当前页最多存放的记录数（pageSize）

//action的初始化的，struts拦截器会自动调用同名属性（page--->SetPage(2)）

private int page;//int默认是0

private int pageSize;

public void setPage(int page) {

this.page = page;

}

public void setPageSize(int pageSize) {

this.pageSize = pageSize;

}

分析：Action类使用Pagination用来传递参数和获取返回结果

引用传值Pagination

第五步：分页代码Service、Dao实现（方案一：先使用QBC查询）

分析：

任何分页查询技术在Dao层都必须查询两次：即：当前页的数据和总的记录数。

因此，我们的业务层service需要调用两次dao，dao中需要对应两个方法来满足需要（查总记录数和查当前页数据）。

（1）接口IGoodsService 代码

/**

* 分页条件综合查询

* @param pagination

public void findGoodsListPage(Pagination<Goods> pagination);

（2）实现类GoodsServiceImpl类代码

//分页条件综合查询：

//从分页bean中取出条件，拼接sql条件，调用dao查询数据库，返回结果，封装回分页bean

public void findGoodsListPage(Pagination<Goods> pagination) {

//1.....条件的取出和拼接

//QBC方案

DetachedCriteria criteria = DetachedCriteria.forClass(Goods.class);//根查询，主查询对象

//先获取业务条件

Map<String, String[]> parameterMap = pagination.getParameterMap();

//添加业务条件:每个业务都不一样

//简记码

// String nm=parameterMap.get("nm")==null?null:parameterMap.get("nm")[0];

String nm = getValueFromParameterMap(parameterMap, "nm");

if(StringUtils.isNotBlank(nm)){

criteria.add(Restrictions.eq("nm", nm));

}

//货物名称

String name = getValueFromParameterMap(parameterMap, "name");

if(StringUtils.isNotBlank(name)){

criteria.add(Restrictions.like("name","%"+name+"%"));

}

//仓库：注意参数名称,

String storeId = getValueFromParameterMap(parameterMap, "store.id");

if(StringUtils.isNotBlank(storeId)){

//外键的条件---单表

//两种方式

//1.直接指定关联对象的id--外键：底层原理是第二种方式

criteria.add(Restrictions.eq("store.id", storeId));

//2。直接传对象，自动将对象主键作为外键

// Store store = new Store();

// store.setId(storeId);

// criteria.add(Restrictions.eq("store", store));

}

findListPage(pagination, criteria,goodsDao);

}

在BaseService类中，抽出来的取参数值方法：

//业务层的父类：用来复用公用代码

//抽象类

public abstract class BaseService<T,ID extends Serializable> {

    //从参数map中获取参数值

    protected String getValueFromParameterMap(Map<String, String[]> parameterMap,String key){

        return parameterMap.get(key)==null?null:parameterMap.get(key)[0];

    }



    //分页条件查询

    protected void findListPage(Pagination<T> pagination,

            DetachedCriteria criteria,IGenericDao<T, ID> dao) {

        //2.....调用dao查询数据和结果的封装

        //2.1查询总记录数

        long totalCount = dao.findCountByCriteria(criteria);

        //直接封装到分页bean

        pagination.setTotalCount(totalCount);





        //2.2计算后，查询数据列表(分页查询)

//            int firstResult=(pagination.getPage()-1)*pagination.getPageSize();//属于分页的业务,在分页bean中计算

        //分析：结果集封装策略发生了变化，要做：重置结果集封装策略

        //将投影设置为null

        criteria.setProjection(null);

        //将封装策略手动更改为ROOT_ENTITY

        criteria.setResultTransformer(criteria.ROOT_ENTITY);



        List<T> resultList = dao.findListPageByCriteria(criteria, pagination.getFirstResult(), pagination.getMaxResults());

        //直接封装到分页bean中

        pagination.setResultList(resultList);

    }

}

第六步：分页代码Service、Dao实现（方案一：先使用QBC查询）

（1）修改IGenericDao接口：添加两个方法

/**

     * 查询记录数

     * @param criteria

     * @return

     */

    public long findCountByCriteria(DetachedCriteria criteria);



    /**

     * 条件分页查询列表

     * @param criteria

     * @param firstResult

     * @param maxResults

     * @return

     */

    public List<T> findListPageByCriteria(DetachedCriteria criteria, int firstResult, int maxResults);
实现类GenericDaoImpl类

//查询总记录数

    public long findCountByCriteria(DetachedCriteria criteria) {

        //添加记录数查询的投影

        //投影查询，会改变默认的结果集封装策略为PROJECTION，而原来默认是ROOT_ENTITY

        criteria.setProjection(Projections.rowCount());

        //只能有一个元素：记录数

        List<Long> list = getHibernateTemplate().findByCriteria(criteria);

        return list.isEmpty()?0:list.get(0);

    }

    //查询当前分页的数据集合

    public List<T> findListPageByCriteria(DetachedCriteria criteria,

            int firstResult, int maxResults) {

        return getHibernateTemplate().findByCriteria(criteria, firstResult, maxResults);

    }

第七步：struts.xml文件的配置：



        <action name="goods_*" class="goodsAction" method="{1}">

            

            

            <result name="savejsp" type="redirect">/jsps/save/save.jsp</result>

            

            <result name="remainjsp">/jsps/store/remain.jsp</result>

        </action>
1. 编写JSP显示分页查询结果数据
分两部分实现：

分页数据列表的显示
分页工具条的显示

表格分页数据显示

在remain.jsp中遍历结果集

</tr>

<s:iterator value="result.resultList" >

<tr>

<td>

</td>

</tr>

</s:iterator>

</table>

测试：数据是否能正常显示。

分页流程梳理：

页面提交请求（页码、每页记录数、查询条件）
设计分页数据Bean 接收参数 Pagination
编写Action，将Pagination传递给Service业务层，让业务层进行查询和封装Pagination（引用传递，不需要返回）。
业务层service从Pagination中拿到请求参数，封装DetachedCriteria或拼接SQL语句，进行查询出总记录数和当页的数据集合，再将结果封装回Pagination。
此时，数据层Dao对应两次查询（总记录数、当前页数据）
将查询结果传递JSP页面（表格数据显示、分页工具条显示）

分页工具条显示（了解）

页码效果分析：（前五后四）

第一步：在Pagination.java中定义分页的逻辑

（1）在Pagination 添加开始页码begin和结束页码end：

//工具条使用的结果

private long begin;//起始页码数

private long end;//结束的页码数

public long getBegin() {

return begin;

}

public void setBegin(long begin) {

this.begin = begin;

}

public long getEnd() {

return end;

}

public void setEnd(long end) {

this.end = end;

}

在Pagination.java中找个位置计算获取begin和end的值：

public void setTotalCount(long totalCount) {

        //计算一些东西

        //计算总页码数：

        totalPage=(totalCount+pageSize-1)/pageSize;



        //计算页面的页码中"显示"的起始页码和结束页码

        //一般显示的页码叫好的效果是最多显示10个页码

        //算法是前5后4，不足补10

        //计算显示的起始页码（根据当前页码计算）：当前页码-5

        begin = page-5;

        if(begin<1){//页码修复

            begin=1;

        }

        //计算显示的结束页码（根据开始页码计算）：开始页码+9

        end=begin+9;

        if(end>totalPage){//页码修复

            end=totalPage;

        }

        //起始页面重新计算（根据结束页码计算）：结束页码-9

        begin=end-9;

        if(begin<1){

            begin=1;

        }

        System.out.println(begin +"和" +end);

        this.totalCount = totalCount;

    }
在Pagination.java中添加计算页面获取查询条件参数字符串方法，点击首页、上一页、下一页、末页、具体页需要传递查询条件。

//获取条件的字符串标识形式:map解析为字符串&name=xxx&age=xxx

    public String getParameterStr(){

        String paramterStr="";

        Set<String> keySet = parameterMap.keySet();

        for (String key : keySet) {

            //排除page和pageSize参数

            if(!key.equals("page")&&!key.equals("pageSize")){

                String[] values = parameterMap.get(key);

                if(values!=null &&StringUtils.isNotBlank(values[0])){

                    paramterStr+="&"+key+"="+values[0];

                }

            }

        }



        return paramterStr;

    }

页面显示分页工具条

第二步：在remain.jsp中添加分页条，由于分页操作属于超链接，需要使用Get请求的方式传递值

<div align="right">

                        

                        

                        <s:if test="result.page>1">

                            <a href="${pageContext.request.contextPath }/goods_listPage.action?page=1${result.parameterStr}">首页</a>

                            <a href="${pageContext.request.contextPath }/goods_listPage.action?page=${result.page-1}${result.parameterStr}">上一页</a>

                        </s:if>

                        

                        <s:iterator begin="result.begin" end="result.end" var="num">

                            <a href="${pageContext.request.contextPath }/goods_listPage.action?page=${num}${result.parameterStr}">[${num}]</a>

                        </s:iterator>

                        

                        <s:if test="result.page<result.totalPage">

                            <a href="${pageContext.request.contextPath }/goods_listPage.action?page=${result.page+1}${result.parameterStr}">下一页</a>

                            <a href="${pageContext.request.contextPath }/goods_listPage.action?page=${result.totalPage}${result.parameterStr}">尾页</a>

                        </s:if>

                        <input type="text" size="2" name="page"/>

                        <input type="button" value="go" size="2" />

                    </div>

在remain.jsp中，代码完善和效果优化：中间页面的显示添加样式



                        <s:iterator begin="result.begin" end="result.end" var="num">

                            <a href="${pageContext.request.contextPath }/goods_listPage.action?page=${num}${result.parameterStr}">

                                <%--[${num}]--%>

                                <s:if test="#num==1">

                                    <span style="color:red">[${num}]</span>

                                </s:if>

                                <s:else>

                                    <span style="color:blue">[${num}]</span>

                                </s:else>

                            </a>

                        </s:iterator>

第三步：查询条件乱码问题：

输入货物名称，会产生乱码

原因：因为页码上请求参数使用？拼接，中文会使用get方式提交，参数会出现中文乱码。

解决方案：

（1）修改或新增tomcat中的server.xml 的编码为：URIEncoding="UTF-8"

原因：tomcat的编码iso8859-1，导致从tomcat获取数据的时候，编码不一致（程序用utf-8）

tomcat8：底层编码已经变成utf-8，但是我们使用的是tomcat7

（2）手动编码， GenericEncodingFilter (过滤器可参考课前资料)

GenericEncodingFilter.java 代码：

/**

* 解决get和post请求全部乱码

*

*/

public class GenericEncodingFilter implements Filter {



    public void doFilter(ServletRequest request, ServletResponse response,

            FilterChain chain) throws IOException, ServletException {

        // 转型为与协议相关对象

        HttpServletRequest httpServletRequest = (HttpServletRequest) request;

        // 对request包装增强

        HttpServletRequest myrequest = new MyRequest(httpServletRequest);

        chain.doFilter(myrequest, response);

    }

    public void init(FilterConfig filterConfig) throws ServletException {



    }

    public void destroy() {



    }

}

// 自定义request对象

class MyRequest extends HttpServletRequestWrapper {

    private HttpServletRequest request;

    private boolean hasEncode;

    public MyRequest(HttpServletRequest request) {

        super(request);// super必须写

        this.request = request;

    }

    // 对需要增强方法进行覆盖

    public Map getParameterMap() {

        // 先获得请求方式

        String method = request.getMethod();

        if (method.equalsIgnoreCase("post")) {

            // post请求

            try {

                // 处理post乱码

                request.setCharacterEncoding("utf-8");

                return request.getParameterMap();

            } catch (UnsupportedEncodingException e) {

                e.printStackTrace();

            }

        } else if (method.equalsIgnoreCase("get")) {

            // get请求

            Map<String, String[]> parameterMap = request.getParameterMap();

            if (!hasEncode) { // 确保get手动编码逻辑只运行一次

                for (String parameterName : parameterMap.keySet()) {

                    String[] values = parameterMap.get(parameterName);

                    if (values != null) {

                        for (int i = 0; i < values.length; i++) {

                            try {

                                // 处理get乱码

                                values[i] = new String(values[i]

                                        .getBytes("ISO-8859-1"), "utf-8");

                            } catch (UnsupportedEncodingException e) {

                                e.printStackTrace();

                            }

                        }

                    }

                }

                hasEncode = true;

            }

            return parameterMap;

        }

        return super.getParameterMap();

    }

    @Override

    public String getParameter(String name) {

        Map<String, String[]> parameterMap = getParameterMap();

        String[] values = parameterMap.get(name);

        if (values == null) {

            return null;

        }

        return values[0]; // 取回参数的第一个值

    }

    public String[] getParameterValues(String name) {

        Map<String, String[]> parameterMap = getParameterMap();

        String[] values = parameterMap.get(name);

        return values;

    }

}
在web.xml设置过滤器的配置



    <filter>

        <filter-name>GenericEncodingFilter</filter-name>

        <filter-class>cn.itcast.storemanager.web.filter.GenericEncodingFilter</filter-class>

    </filter>

    <filter-mapping>

        <filter-name>GenericEncodingFilter</filter-name>

        <url-pattern>/*</url-pattern>

    </filter-mapping>

注意：乱码过滤器要往前面放，放置到struts2的过滤器的前面。

注意：tomcat编码和过滤器编码两者不要同时使用。
1. 分页逻辑小结
讲解两个问题：

（1）分页逻辑梳理：

（2）服务器端分页代码逻辑
1. 使用SQL拼接方式，实现库存查询(课后)
目标：将service和dao中增加或修改sql方式的实现代码。

（1）修改：业务Service实现层：

（2）通用数据层IGenericDao接口：
通用GenericDaoImpl类的实现

【1】查询总记录数

【2】使用sql语句查询符合条件的分页记录
1. 分页代码重构优化
重构优化的思路：
1. Action封装分页相关的请求参数 PaginationBean ----> 抽取BaseAction类
2. Service 将参数封装DetachedCriter/ SQL ----> 不能优化（根据业务）
3. Service调用Dao 查询totalCount 和 pageData ----> 抽取BaseService类
4. Dao 查询totalCount和 pageData 代码就是通用代码---->GenericDaoImpl类
1. Action的数据封装
【1】BaseAction类：

//action的父类：用来存放action的重复代码的

//通用：泛型

public abstract class BaseAction<T> extends ActionSupport implements ModelDriven<T>{

    //实例化数据模型T，模型驱动必须实例化

//    private T t = new T();

    //子类可见

    protected T model;//没有初始化

    public T getModel() {

        return model;

    }



    //在默认的构造器初始化数据模型

    public BaseAction() {

        //在子类初始化的时候，默认会调用父类的构造器

        //反射机制:获取具体的类型

        //得到带有泛型的类型，如BaseAction<Userinfo>

        Type superclass = this.getClass().getGenericSuperclass();

        //转换为参数化类型

        ParameterizedType parameterizedType = (ParameterizedType) superclass;

        //获取泛型的第一个参数的类型类，如Userinfo

        Class<T> modelClass = (Class<T>) parameterizedType.getActualTypeArguments()[0];



        //实例化数据模型类型

        try {

            model = modelClass.newInstance();

        } catch (InstantiationException e) {

            e.printStackTrace();

        } catch (IllegalAccessException e) {

            e.printStackTrace();

        }

    }



    //封装值栈的操作的方法

    //root栈：栈顶map，可以通过key获取value

    protected void setToValueStackRoot(String key,Object value){

        ActionContext.getContext().getValueStack().set(key, value);

    }



    //root栈：栈顶对象（匿名）

    protected void pushToValueStackRoot(Object value){

        ActionContext.getContext().getValueStack().push(value);

    }

    //map栈：--推荐，可以通过key获取value

    protected void putToValueStackMap(String key,Object value){

        ActionContext.getContext().put(key, value);

    }



    //root栈：action的属性

    protected Object result;

    public Object getResult() {//action在root栈，因此，result也在root栈

        return result;

    }

}
1. Service 代码
将通用分页查询代码，抽取BaseService

//业务层的父类：用来复用公用代码

//抽象类

public abstract class BaseService<T,ID extends Serializable> {

    //从参数map中获取参数值

    protected String getValueFromParameterMap(Map<String, String[]> parameterMap,String key){

        return parameterMap.get(key)==null?null:parameterMap.get(key)[0];

    }



    //分页条件查询

    protected void findListPage(Pagination<T> pagination,

            DetachedCriteria criteria,IGenericDao<T, ID> dao) {

        //2.....调用dao查询数据和结果的封装

        //2.1查询总记录数

        long totalCount = dao.findCountByCriteria(criteria);

        //直接封装到分页bean

        pagination.setTotalCount(totalCount);





        //2.2计算后，查询数据列表(分页查询)

//            int firstResult=(pagination.getPage()-1)*pagination.getPageSize();//属于分页的业务,在分页bean中计算

        //分析：结果集封装策略发生了变化，要做：重置结果集封装策略

        //将投影设置为null

        criteria.setProjection(null);

        //将封装策略手动更改为ROOT_ENTITY

        criteria.setResultTransformer(criteria.ROOT_ENTITY);



        List<T> resultList = dao.findListPageByCriteria(criteria, pagination.getFirstResult(), pagination.getMaxResults());

        //直接封装到分页bean中

        pagination.setResultList(resultList);

    }

}

3：Dao代码，封装了操作数据库通用的CRUD方法

//通用dao的实现

//hibernate模版类操作，继承daosupport类

public class GenericDaoImpl<T,ID extends Serializable> extends HibernateDaoSupport implements IGenericDao<T, ID> {



    //保存对象

    public void save(Object domain) {

        getHibernateTemplate().save(domain);

    }

    //修改对象

    public void update(Object domain) {

        getHibernateTemplate().update(domain);

    }

    //删除对象

    public void delete(Object domain) {

        getHibernateTemplate().delete(domain);

    }



    //使用主键ID查询

    public T findById(Class<T> domainClass, ID id) {

        return getHibernateTemplate().get(domainClass, id);

    }



    //查询所有

    public List<T> findAll(Class<T> domainClass) {

        return getHibernateTemplate().loadAll(domainClass);

    }

    //命名查询

    public List<T> findByNamedQuery(String queryName, Object... values) {

        return getHibernateTemplate().findByNamedQuery(queryName, values);

    }

    //QBC

    public List<T> findByCriteria(DetachedCriteria criteria) {

        return getHibernateTemplate().findByCriteria(criteria);

    }



    //查询总记录数

    public long findCountByCriteria(DetachedCriteria criteria) {

        //添加记录数查询的投影

        //投影查询，会改变默认的结果集封装策略为PROJECTION，而原来默认是ROOT_ENTITY

        criteria.setProjection(Projections.rowCount());

        //只能有一个元素：记录数

        List<Long> list = getHibernateTemplate().findByCriteria(criteria);

        return list.isEmpty()?0:list.get(0);

    }

    //查询当前分页的数据集合

    public List<T> findListPageByCriteria(DetachedCriteria criteria,

            int firstResult, int maxResults) {

        return getHibernateTemplate().findByCriteria(criteria, firstResult, maxResults);

    }

}
1. 公共代码封装打包（了解）
企业开发小技巧（多学一招）：

一般，企业中会将核心的或公共代码进行打包封装，然后让其他项目去引用（保护源码）。

目标：将公共代码，生成jar包，后期直接导入去使用

准备工作：先将未打包的代码打包一份备份。

新建java项目storemanager-core，将原来项目中与业务无关的公用代码和依赖的jar都copy到这个工程中。

现在开始打包：

（1）选择项目，右键，点击Export。

（2）选择JAR file

配置JAR Export

导出的jar：在E盘目录下，发现storemanager-core.jar

原项目不需要这么多代码，只需要引用基础包

复制一个storemanager项目，命名为storemanager-new，删除公用的代码，即刚刚抽取的代码

发现报错了，我们导入storemanager-core.jar包

没有错误了，我们尝试发布一下！右键项目，点击Web，修改Web Context-root为storemanager-new，表示我们发布的项目为storemanager-new

访问页面：http://localhost:8080/storemanager-new

最后，访问页面，进行测试，一切OK。

【问题】

如何查询源代码呢？

重复刚才的步骤：导出源码包

（1）选择项目，右键，点击Export。

（2）选择JAR file

配置JAR Export（选择第三个，Export Java Source files and resources）

导出的源码jar：在E盘目录下，发现storemanager-core-resource.jar

测试，可以关联代码。

重点：
1. 第一天的所有内容（必须）
2. 第二天上午内容（必须）
3. 分页（会写即可）
4. 理解如何编程！（开发流程、代码抽取、复用、重构）