`
sarin
  • 浏览: 1756729 次
  • 性别: Icon_minigender_1
  • 来自: 大连
博客专栏
E3b14d1f-4cc5-37dd-b820-b6af951740bc
Spring数据库访问系列...
浏览量：173642
C2083dc5-6474-39e2-993e-263652d27795
Android学习笔记
浏览量：368089
5f40a095-b33c-3e8e-8891-606fcf3b8d27
iBatis开发详解
浏览量：189239
B272a31d-e7bd-3eff-8cc4-c0624ee75fee
Objective-C学习...
浏览量：99815
社区版块
存档分类
最新评论

基于Struts2的Hibernate分页实现（FreeMarker进行视图解析）

HibernatefreemarkerYUIYahooAjax 
阅读更多
    在进行Web开发时，很多地方要使用到分页这个技术。.NET框架中是直接集成好的控件，可以直接使用了。而Java中没有，需要程序员自己来编写实现过程。虽然分页过程并不复杂，但是要完美的实现是需要时间来考验的。
    先说说分页的基本原理，分页显示就是在数据量大时页面上可以只显示所有数据的一部分，然后点击页面连接可以跳到所需的位置继续查看。需求很明确，实现方法大致分为两种：一种是物理分页，也就是真分页，这种方法是在SQL语句上写获取数据量的关键字然后进行数据库检索，只取出那一部分结果，需要查看其他页时再次进行数据库检索。二是全部结果一次提出，然后再浏览器页面上进行分页，这种方式一般借助JS来完成，当前不少前端框架都自行实现了分页，效果很不错，比如YUI，那么我们先看一个YUI的示例。效果图如下： 

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>State of Vehicle</title>
</head>
<body  class="yui-skin-sam" style="background-color:#e6ecf4">
	<div id="resultShow" class="sharp color2" style="margin-top:10px;width: 998px;display: none;">
		<b class="b1"></b><b class="b2"></b><b class="b3"></b><b class="b4"></b> 
		<div class="content">  
			  <h3 align="center">State of Vehicle</h3>
			  <div style="margin:10px;">
			  	<div align="center" id="resultSet"></div>
			  </div>
		</div>
		<b class="b5"></b><b class="b6"></b><b class="b7"></b><b class="b8"></b>
	</div>
	<script>
		initStatusResultTable();
		queryStatus();
	</script>
</body>
</html>

    页面很简单，但是这里省略了YUI类库的引用，页面效果也是YUI的CSS，这里主要是JS的编写，方法为initStatusResultTable();和queryStatus();，页面里很容易看出。
下面来看方法initStatusResultTable()： 
YAHOO.example.Data = {
	areacodes : []
};
function initStatusResultTable(){	
	var myColumn=[
		{key:"owner",label:"车主",width:160,resizeable:true,sortable:true},
		{key:"plate",label:"车牌号",width:160,resizeable:true,sortable:true},
		{key:"title",label:"当前状态",width:190,resizeable:true,sortable:true}
];
	var myDataSource=new YAHOO.util.DataSource(YAHOO.example.Data.areacodes);
	myDataSource.responseType = YAHOO.util.DataSource.TYPE_JSARRAY;
	myDataSource.responseSchema = {
		fields: ["owner","plate","title","newTime"]
	};
	var myConfigs = { 
		paginator: new YAHOO.widget.Paginator({
		rowsPerPage: 10,
		template: YAHOO.widget.Paginator.TEMPLATE_ROWS_PER_PAGE,
		rowsPerPageOptions: [10,25,50,100],
		pageLinks: 5
	}),
		draggableColumns:true
	}
	var myDataTable = new YAHOO.widget.DataTable("resultSet", myColumn, myDataSource, myConfigs);
}

这里面设计了表头和分页的信息，指定了列表内容的显示位置resultSet。下面来看queryStatus()方法，这里面用到了YUI的Ajax组件，YUI的Ajax组件使用起来也很顺手，值得一看。 
function queryStatus(){
	var callback={
		success:function(o){
			var clist = YAHOO.lang.JSON.parse(o.responseText);
			var list = clist.resList;//获取返回的List
			var shows = "";
			if (list.length > 0) {
				for (var i = 0; i < list.length; i++) {
					shows += "YAHOO.example.Data.areacodes[YAHOO.example.Data.areacodes.length]={ owner:\""
							+ list[i].owner
							+ "\","
							+ "plate:\""
							+ list[i].plate
							+ "\","
							+ "title:\""
							+ list[i].title
							+ "\"};";
				}
			} else {
				shows = "YAHOO.example.Data.areacodes.length=0;";
			}
			eval("YAHOO.example.Data.areacodes.length=0;");
			eval(shows.toString() + " " + "initStatusResultTable();");
			Dom.get('resultShow').style.display = 'block';
		},
		failure:function(o){
			alert('ajax请求失败，请检查网络!');
		}
	};
	var surl = 'xxx.action';
	var postData ='';
	YAHOO.util.Connect.asyncRequest('post',surl,callback,postData);
}

    这样就实现了JS分页的过程，是完全在客户端实现的，所有数据是一次发送的，那么缺点也是显而易见的：数据量太大时首次相应速度会很慢，甚至溢出。
    下面来说说物理分页的实现，这就需要设计分页类了，我结合Hibernate的特点自行设计了一个分页类并和Struts2框架集成，视图层解析使用FreeMarker的宏来实现。首先来看分页类，目前仅仅支持HQL方式，其他的方式正在思考中： 
package xxx.core.common;
import java.util.*;
import xxx.core.Constants;
import org.hibernate.Hibernate;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
/**
 * Hibernate分页查询辅助类(目前仅支持HQL方式)
 * 
 * @author Sarin
 * 
 */
public class PagingListHt extends HibernateDaoSupport {
	private int rowCount = 0; // 记录总数
	private int pageCount = 1; // 分页总数
	private int pageSize = Constants.DEFAULT_PAGE_SIZE; // 每页记录数
	private int pageNum = 1; // 当前页数
	private int startIndex = 1; // 起始记录数
	private int endIndex = 1; // 结束记录数
	private List list = new ArrayList();// 记录列表
	/**
	 * 获得对象列表
	 */
	public List getList() {
		return list;
	}
	/* 获得起始记录数 */
	public int getStartIndex() {
		return startIndex;
	}

	public Integer getStartIndexInteger() {
		return new Integer(startIndex);
	}
	/* 获得结束记录数 */
	public int getEndIndex() {
		return endIndex;
	}
	public Integer getEndIndexInteger() {
		return new Integer(endIndex);
	}
	/* 获得分页其它信息 */
	public int getPageCount() {
		return pageCount;
	}
	public int getPageNum() {
		return pageNum;
	}
	public int getPageSize() {
		return pageSize;
	}
	public int getRowCount() {
		return rowCount;
	}
	/**
	 * 构造方法，HQL无参数，单对象
	 * 
	 * @param hibernateTemplate ht对象
	 * @param pageNum 第几页
	 * @param pageSize 每页显示数目
	 * @param hql HQL语句
	 * @param clazz 对象类型
	 */
	public PagingListHt(HibernateTemplate hibernateTemplate, int pageNum,
			int pageSize, String hql, Class clazz) {
		preProcessParams(pageNum, pageSize);
		execute(hibernateTemplate, pageNum, pageSize, hql, clazz);
	}

	/**
	 * 构造方法，HQL无参数，多对象
	 * 
	 * @param hibernateTemplate
	 * @param pageNum
	 * @param pageSize
	 * @param hql
	 */
	public PagingListHt(HibernateTemplate hibernateTemplate, int pageNum,
			int pageSize, String hql) {
		preProcessParams(pageNum, pageSize);
		execute(hibernateTemplate, pageNum, pageSize, hql);
	}

	/**
	 * 构造方法，HQL有参数，单对象
	 * 
	 * @param hibernateTemplate ht对象
	 * @param pageNum 第几页
	 * @param pageSize 每页显示数目
	 * @param hql HQL语句
	 * @param parameters Object[]类型的参数
	 * @param clazz 对象类型
	 */
	public PagingListHt(HibernateTemplate hibernateTemplate, int pageNum,
			int pageSize, String hql, Object[] parameters, Class clazz) {
		preProcessParams(pageNum, pageSize);
		execute(hibernateTemplate, pageNum, pageSize, hql, parameters, clazz);
	}

	/**
	 * 构造方法，HQL有参数，多对象
	 * 
	 * @param hibernateTemplate
	 * @param pageNum
	 * @param pageSize
	 * @param hql
	 * @param parameters
	 */
	public PagingListHt(HibernateTemplate hibernateTemplate, int pageNum,
			int pageSize, String hql, Object[] parameters) {
		preProcessParams(pageNum, pageSize);
		execute(hibernateTemplate, pageNum, pageSize, hql, parameters);
	}
	/**
	 * 预处理页面参数
	 */
	private void preProcessParams(int pageNum, int pageSize) {
		if (pageNum > 0) {
			this.pageNum = pageNum;
		}
		if (pageSize > 0) {
			this.pageSize = pageSize;
		}
		if (pageSize > Constants.MAX_PAGE_SIZE) {
			this.pageSize = Constants.MAX_PAGE_SIZE;
		}
	}
	/**
	 * 根据给定的数据计算相关分页信息，多对象HQL
	 * 
	 * @param hibernateTemplate
	 * @param pageNum
	 * @param pageSize
	 * @param hql
	 */
	private void execute(HibernateTemplate hibernateTemplate, int pageNum,
			int pageSize, String hql) {
		// 获取Hibernate当前的Session
		Session session = hibernateTemplate.getSessionFactory()
				.getCurrentSession();
		// 获取记录总数
		this.rowCount = hibernateTemplate.find(hql).size();
		// 计算分页数及起止记录
		countPage();
		// 获取List
		list = session.createQuery(hql)
				.setFirstResult((pageNum - 1) * pageSize).setMaxResults(
						pageSize).list();
	}
	/**
	 * 根据给定的数据计算相关分页信息，单对象HQL，且无where限制条件
	 * 
	 * @param hibernateTemplate
	 * @param pageNum
	 * @param pageSize
	 * @param hql
	 * @param clazz
	 */
	private void execute(HibernateTemplate hibernateTemplate, int pageNum,
			int pageSize, String hql, Class clazz) {
		// 获取Hibernate当前的Session
		Session session = hibernateTemplate.getSessionFactory()
				.getCurrentSession();
		// 获取记录总数
		this.rowCount = Integer.parseInt(String.valueOf(session.createQuery(
				"select count(*) from " + clazz.getName()).uniqueResult()));
		// 计算分页数及起止记录
		countPage();
		// 获取List
		list = session.createQuery(hql)
				.setFirstResult((pageNum - 1) * pageSize).setMaxResults(
						pageSize).list();
	}
	/**
	 * 重载的分页方法，接受预编译HQL语句，HQL单对象且无where限制条件
	 * 
	 * @param hibernateTemplate
	 * @param pageNum
	 * @param pageSize
	 * @param hql
	 * @param parameters
	 * @param clazz
	 */
	private void execute(HibernateTemplate hibernateTemplate, int pageNum,
			int pageSize, String hql, Object[] parameters, Class clazz) {
		// 获取Hibernate当前的Session
		Session session = hibernateTemplate.getSessionFactory()
				.getCurrentSession();
		// 获取记录总数
		this.rowCount = Integer.parseInt(String.valueOf(session.createQuery(
				"select count(*) from " + clazz.getName()).uniqueResult()));
		// 计算分页数及起止记录
		countPage();
		// 预编译HQL语句
		Query query = session.createQuery(hql);
		// 为预编译HQL语句设置参数
		for (int i = 0; i < parameters.length; i++) {
			query.setParameter(i, String.valueOf(parameters[i]),
					Hibernate.STRING);
		}
		// 获取List
		list = query.setFirstResult((pageNum - 1) * pageSize).setMaxResults(
				pageSize).list();
	}
	/**
	 * 重载的分页方法，接受预编译HQL语句，HQL多对象
	 * 
	 * @param hibernateTemplate
	 * @param pageNum
	 * @param pageSize
	 * @param hql
	 * @param parameters
	 */
	private void execute(HibernateTemplate hibernateTemplate, int pageNum,
			int pageSize, String hql, Object[] parameters) {
		// 获取Hibernate当前的Session
		Session session = hibernateTemplate.getSessionFactory()
				.getCurrentSession();
		// 获取记录总数
		this.rowCount = hibernateTemplate.find(hql, parameters).size();
		// 计算分页数及起止记录
		countPage();
		// 预编译HQL语句
		Query query = session.createQuery(hql);
		// 为预编译HQL语句设置参数
		for (int i = 0; i < parameters.length; i++) {
			query.setParameter(i, String.valueOf(parameters[i]),
					Hibernate.STRING);
		}
		// 获取List
		list = query.setFirstResult((pageNum - 1) * pageSize).setMaxResults(
				pageSize).list();
	}

	/**
	 * 计算分页数及起止记录
	 */
	private void countPage() {
		// 计算分页总数
		if ((rowCount % pageSize) == 0) {
			pageCount = rowCount / pageSize;
		} else {
			pageCount = rowCount / pageSize + 1;
		}
		if (pageCount == 0) {
			pageCount = 1;
		}
		// 判断pageNum是否过界
		if (pageNum > pageCount && rowCount != 0) {
			pageNum = pageCount;
		}
		// 计算起止记录
		startIndex = (pageNum - 1) * pageSize + 1;
		endIndex = (pageNum) * pageSize;
	}
}

    常量值这里给出： 
/* 默认分页尺寸及分页标记 */
public static final int DEFAULT_PAGE_SIZE = 10;
public static final int MAX_PAGE_SIZE = 1000;
public static final String NORMAL_MARK = "?";
public static final String START_MARK = ":_START_INDEX_";
public static final String END_MARK = ":_END_INDEX_";
/* 默认编码方式 */
public static final String ENCODING = "UTF-8";

    分页类写好了，然后我们先看页面解析的FreeMarker宏： 
<#-- 处理分页参数 -->
<#function getPageUrl pageNum>
<#local pageUrl=base+fullUrlWithoutPageInfo>
<#if pageUrl?ends_with("?")>
<#return pageUrl + "pageSize=" + pageSize + "&pageNum=" + pageNum>
<#else>
<#return pageUrl + "&pageSize=" + pageSize + "&pageNum=" + pageNum>
</#if>
</#function>

<#-- 全部或分页显示 -->
<#function getPageUrlResize size>
<#local pageUrl=base+fullUrlWithoutPageInfo>
<#if pageUrl?ends_with("?")>
<#return pageUrl + "pageNum=1&pageSize=" + size>
<#else>
<#return pageUrl + "&pageNum=1&pageSize=" + size>
</#if>
</#function>

<#-- 分页信息 -->
<#macro paging pagingListHt>
<#local pageCount=pagingListHt.pageCount>
<#local rowCount=pagingListHt.rowCount>
<#local pageNum=pagingListHt.pageNum>
<#local pageSize=pagingListHt.pageSize>
<#if rowCount == 0>
	<#if useFlag?exists>
	<div style="border:1px solid #666;padding:2 5 2 5;background:#efefef;color:#333">没有相关记录</div>
	<#else>
	<#assign useFlag = 1>
	</#if>
<#else>
<table>
<tr>
	<td style="line-height:150%">
	共 ${rowCount} 条记录 ${pageCount} 页 
	<#if pageCount gt 1 && pageSize!=maxPageSize>
		<span class="selectedPage" style="padding:2px 3px 0 3px"><a class="page" href="${getPageUrlResize(maxPageSize)}">全部显示</a></span>
	<#elseif pageSize==maxPageSize>
		<span class="selectedPage" style="padding:2px 3px 0 3px"><a class="page" href="${getPageUrlResize(defaultPageSize)}">分页显示</a></span>
	</#if>
	<#if (pageCount <= 11)>
		<#local startPage = 1>
		<#local endPage = pageCount>
	<#elseif (pageNum + 5 > pageCount)>
		<#local startPage = pageCount - 10>
		<#local endPage = pageCount>
	<#elseif (pageNum - 5 < 1)>
		<#local startPage = 1>
		<#local endPage = 11>
	<#else>
		<#local startPage = pageNum - 5>
		<#local endPage = pageNum + 5>
	</#if>
	<#if (pageCount > 1)>
		<#if (pageNum != 1)>
			<#if (pageCount > 11)>
				<a class="page" href="${getPageUrl(1)}" style="font-family:Webdings" title="首页">9</a>
			</#if>
			<a class="page" href="${getPageUrl(pageNum-1)}" style="font-family:Webdings" title="上页">3</a>
		<#else>
			<#if (pageCount > 11)>
				<span style="font-family:Webdings;color:#999">9</span>
			</#if>
			<span style="font-family:Webdings;color:#999">3</span>
		</#if>
		<#list startPage..endPage as x><#if x=pageNum>
			<span class="selectedPage">${x}</span>
	<#else>
		<span class="noSelectedPage"><a class="page" href="${getPageUrl(x)}">${x}</a></span>
	</#if>
	</#list>
		<#if (pageCount != pageNum)>
			<a class="page" href="${getPageUrl(pageNum+1)}" style="font-family:Webdings" title="下页">4</a>
			<#if (pageCount > 11)>
				<a class="page" href="${getPageUrl(pageCount)}" style="font-family:Webdings" title="尾页">:</a>
			</#if>
		<#else>
			<span style="font-family:Webdings;color:#999">4</span>
			<#if (pageCount > 11)>
				<span style="font-family:Webdings;color:#999">:</span>
			</#if>
		</#if>
	</#if>
	</#if>
	</td>
</tr>
</table>
</#macro>

    需要定义的部分都写完了，下面来看怎么使用分页组件，首先需要抽象出一些公共的东西，写在基类Action中，如下： 
/* 分页信息 */
protected int pageNum = 1;
protected int pageSize = Constants.DEFAULT_PAGE_SIZE;
public int getPageNum() {
	return pageNum;
}
public void setPageNum(int pageNum) {
	this.pageNum = pageNum;
}
public int getPageSize() {
	return pageSize;
}
public void setPageSize(int pageSize) {
	this.pageSize = pageSize;
}
public int getMaxPageSize() {
	return Constants.MAX_PAGE_SIZE;
}
public int getDefaultPageSize() {
	return Constants.DEFAULT_PAGE_SIZE;
}
public String getQueryStringWithoutPageNum() {
	Map m = getParameters();
	m.remove("pageNum");
	return QueryUtil.getQueryString(m);
}
public String getFullUrlWithoutPageNum() {
	return getRequest().getServletPath() + "?"
			+ getQueryStringWithoutPageNum();
}
public String getQueryStringWithoutPageInfo() {
	Map m = getParameters();
	m.remove("pageNum");
	m.remove("pageSize");
	return QueryUtil.getQueryString(m);
}
public String getFullUrlWithoutPageInfo() {
	return getRequest().getServletPath() + "?"
			+ getQueryStringWithoutPageInfo();
}

    使用到的QueryUtil工具类为： 
package xxx.core.util;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Iterator;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import xxx.core.Constants;
public class QueryUtil {
	/**
	 * 将请求参数还原为key=value的形式
	 * 
	 * @param params
	 * @return
	 */
	public static String getQueryString(Map<String, Object> params) {
		StringBuffer queryString = new StringBuffer(256);
		Iterator it = params.keySet().iterator();
		int count = 0;
		while (it.hasNext()) {
			String key = (String) it.next();
			String[] param = (String[]) params.get(key);
			for (int i = 0; i < param.length; i++) {
				if (count == 0) {
					count++;
				} else {
					queryString.append("&");
				}
				queryString.append(key);
				queryString.append("=");
				try {
					queryString.append(URLEncoder.encode((String) param[i],
							Constants.ENCODING));
				} catch (UnsupportedEncodingException e) {
				}
			}
		}
		return queryString.toString();
	}
}

    分层设计中Action只负责业务逻辑的跳转执行，而真正的逻辑处理是在Service层进行的，那么还需要配置Service基类，其中的ht是HibernateTemplate对象，这是用过Spring进行的依赖注入，剩下的代码就是包装一下PagingListHt中的构造方法： 
	/**
	 * 获取ValueStack
	 * 
	 * @return
	 */
	public ValueStack getValueStack() {
		return ActionContext.getContext().getValueStack();
	}
	/**
	 * 获取分页的List
	 * 
	 * @param hql
	 * @return
	 */
	public PagingListHt getPagingListHt(String hql) {
		int pageNum = ((Integer) getValueStack().findValue("pageNum"))
				.intValue();
		int pageSize = ((Integer) getValueStack().findValue("pageSize"))
				.intValue();
		return new PagingListHt(ht, pageNum, pageSize, hql);
	}
	/**
	 * 获取分页的List
	 * 
	 * @param hql
	 * @param clazz
	 * @return
	 */
	public PagingListHt getPagingListHt(String hql, Class clazz) {
		int pageNum = ((Integer) getValueStack().findValue("pageNum"))
				.intValue();
		int pageSize = ((Integer) getValueStack().findValue("pageSize"))
				.intValue();
		return new PagingListHt(ht, pageNum, pageSize, hql, clazz);
	}
	/**
	 * 获取分页的List，预编译HQL语句
	 * 
	 * @param hql
	 * @param parameters
	 * @return
	 */
	public PagingListHt getPagingListHt(String hql, Object[] parameters) {
		int pageNum = ((Integer) getValueStack().findValue("pageNum"))
				.intValue();
		int pageSize = ((Integer) getValueStack().findValue("pageSize"))
				.intValue();
		return new PagingListHt(ht, pageNum, pageSize, hql, parameters);
	}
	/**
	 * 获取分页的List，预编译HQL语句
	 * 
	 * @param hql
	 * @param parameters
	 * @param clazz
	 * @return
	 */
	public PagingListHt getPagingListHt(String hql, Object[] parameters,
			Class clazz) {
		int pageNum = ((Integer) getValueStack().findValue("pageNum"))
				.intValue();
		int pageSize = ((Integer) getValueStack().findValue("pageSize"))
				.intValue();
		return new PagingListHt(ht, pageNum, pageSize, hql, parameters, clazz);
	}

    东西都准备齐全了，下面来看看如何使用吧，在Service中进行查询操作： 
// 获取用户列表
private static final String HQL_GET_ALL_USERS = "from User order by u.userId asc";
public PagingListHt getAllUsers() {
	return getPagingListHt(HQL_GET_ALL_USERS);
}

    在Action中就更简单了： 
private PagingListHt userList;
public PagingListHt getUserList() {
	return userList;
}
/**
 * 用户列表
*/
public String userList() throws Exception {
	userList = getServMgr().getUserService().getAllUsers ();
	return "userList";
}

    在页面只要引入了事先写好的分页宏，一条语句就可以了： 
<div align="right"><@p.paging userList /></div>

    要注意的是使用FreeMarker的list指令来遍历PagingListHt对象时，写法和普通的list稍有区别，应该是： 
<#list userList.list as news>
</#list>

    为什么加了.List？看看PagingListHt是怎么设计的吧，其实就是getList()方法，因为这个分页的List是我们自定义的类，而不是Java类库的List，要是不写，那就是遍历PagingList类型，FreeMarker显然不能进行。
    一家之言，仅供参考，但此例为作者原创，您可以对其进行适当改造应用于您自己的系统中，如果发现问题，欢迎交流。后续将对SQL分页进行说明，当然还是这种方式的，只是分野类设计的不同罢了。
  • 大小: 18.8 KB
10
顶
1
踩
分享到：
| Hibernate持久化对象的生命周期详解
评论
1 楼 chance237 2010-07-16  
朋友,可以发个可以运行的的包发给我不啊
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    struts+hibernate做的分页显示

    在这个项目中，"struts+hibernate做的分页显示"主要是利用这两者来实现数据的分页展示，提升用户体验，降低服务器压力。 首先，Struts是一个基于MVC设计模式的Java Web框架，它简化了开发过程，提供了处理HTTP请求...

    Struts+Hibernate实现分页

    在Java Web开发中，"Struts+Hibernate 实现分页"是一个常见的需求，尤其是在处理大量数据展示时。这个主题涉及到两个关键的技术栈：Struts作为MVC（模型-视图-控制器）框架，用于处理用户请求和业务逻辑，以及...

    Struts+Hibernate分页

    2. **整合Struts与Hibernate**: 在Struts的Action类中注入SessionFactory，通过SessionFactory获取Session，进而进行数据库操作。你可以使用Spring框架的AOP代理来管理SessionFactory，这样可以确保每次请求都能得到...

    Struts2 hibernate spring分页实例

    在这个“Struts2 Hibernate Spring分页实例”中，开发者将展示如何在这些框架的集成环境中实现数据的分页显示。分页是Web应用中常见的一种功能，它能够帮助用户更好地浏览和管理大量的数据，避免一次性加载过多内容...

    Struts+Hibernate+分页

    在给定的文件名"StrutsHibernate"中，我们可以推测这是一个包含Struts和Hibernate整合示例的工程，可能包含了配置文件、Action类、DAO（数据访问对象）类以及相关的JSP页面。通过分析这个项目，开发者可以学习如何在...

    双鱼林struts2_hibernate人事工资管理系统

    【双鱼林struts2_hibernate人事工资管理系统】是一个基于Java技术栈的开源项目，主要应用于企业的人事管理和工资计算。系统集成了Struts2框架和Hibernate持久化框架，为企业的日常人力资源管理提供了便捷的数据处理...

    struts2 hibernate spring 整合、分页源码

    5. **视图渲染**：在JSP或Freemarker等模板引擎中，利用Struts2插件提供的标签库或者自定义标签，展示分页信息，如页码、总页数等。 6. **前端交互**：通过Ajax或页面重定向，用户可以无刷新地切换页面，同时，前端...

    struts2+hibernate增删改查+分页

    综上所述，"struts2+hibernate增删改查+分页"是一个基础的Java Web开发示例，它涵盖了MVC架构下，如何利用Struts2处理用户请求，通过Hibernate进行数据库操作，以及实现简单的分页功能。这种组合在实际项目中非常...

    hibernate实现分页

    ### Hibernate分页基础 1. **Criteria API**：Hibernate的Criteria API允许我们创建动态查询，同时也支持分页。通过设置`setFirstResult()`和`setMaxResults()`方法，可以实现分页效果。例如： ```java Criteria ...

    struts2+spring+hibernate分页显示

    首先，Struts2是基于Action的框架，它的分页主要通过Interceptor（拦截器）和Result（结果类型）来实现。你需要创建一个自定义的拦截器，用于处理请求参数，如当前页数和每页显示的数量。拦截器可以检查这些参数，并...

    struts2框架做的学生信息查询系统

    7. **JSP视图层**：虽然Struts2支持FreeMarker、Velocity等多种模板技术，但在这里我们假设使用的是JSP作为视图。JSP页面会利用Struts2标签库（如`s:form`、`s:textfield`、`s:submit`等）来创建表单和展示数据，...

    struts+spring+hibernate 分页

    在 Struts+Spring+Hibernate 结构中实现分页，需要结合这三大框架的特点来设计和实现。 首先，Struts 在控制器层中处理用户的请求，比如用户点击分页链接时，Struts 框架会调用相应的Action类方法。在这个方法中，...

    struts2+spring+hibernate分页，事务，自定义切面

    Struts2、Spring和Hibernate是Java Web开发中的三大框架，它们各自负责不同的职责：Struts2主要用于MVC（模型-视图-控制器）架构的实现，Spring提供了强大的依赖注入和面向切面编程功能，而Hibernate则是一个优秀的...

    基于Struts2的BBS项目

    总结来说，基于Struts2的BBS项目充分利用了Struts2框架的功能，实现了用户认证、论坛浏览、发帖、回复等一系列功能。通过合理的架构设计和组件选择，确保了系统的扩展性和可维护性。项目的具体实现细节，如数据库...

    Struts2,Hibernate

    在视图层，Struts2使用JSP或FreeMarker等模板引擎来渲染结果。开发者可以创建JSP页面，使用Struts2的标签库来显示数据，如遍历用户列表，创建链接，传递参数等。 最后，为了测试和部署，我们需要配置Struts2的...

    Hibernate+spring+struts2分页

    此外，Struts2的Result类型如`tiles`或`freemarker`等模板引擎，可以方便地在视图层展示分页信息。 **Oracle数据库** Oracle数据库是世界上最流行的关系型数据库管理系统之一，以其高性能和稳定性著称。在分页查询...

    Struts2+Hibernate3.2+spring2.0+sqlserver2000

    Struts2、Hibernate3.2、Spring2.0和SQL Server 2000是Java Web开发中的四个关键组件，它们构成了一个强大的企业级应用框架，通常被称为SSH2（Struts2、Spring2、Hibernate2）集成框架。下面将详细阐述这些技术以及...

    web方面的处理struts,struts,hibernate等

    Struts、Struts2 和 Hibernate 是Java Web开发中三个非常重要的框架，它们分别在MVC（Model-View-Controller）架构的不同层面发挥作用，为开发者提供了高效、可维护的解决方案。 Struts 是 Apache 软件基金会的一个...

    Struts+Hibernate作的BBS

    页面展示则由JSP（JavaServer Pages）或FreeMarker模板实现，结合Struts的Action和Result来完成视图的跳转。为了提升用户体验，BBS可能还会涉及到分页、权限控制、缓存优化等技术。 总的来说，这个BBS项目展示了...

    青鸟租房系统 用Hibernate+struts 实现的

    Hibernate的ORM特性减轻了数据库操作的复杂性，而Struts则帮助实现了业务逻辑和视图的解耦，使得系统更加模块化，便于开发和维护。这样的设计模式在现代Web开发中非常常见，不仅适用于租房系统，还可以应用于各种...

Magicbox
Global site tag (gtag.js) - Google Analytics