`
lzkyo
  • 浏览: 466006 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Hibernate分页查询与泛型

    博客分类：
  • SSH
HibernateMySQLCSSDAOServlet 
阅读更多

JE有两篇文章,关于分页查询 与泛型 的，写的很好．这里收藏一下．

 

Hibernate分页查询小结

 

JDK5.0后的泛型程序设计

 

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

下面是我自己写的分页方法,同时也参考了上面两篇文章.

以下代码用在了实际的项目中.

 

Page类，计算分页数据

Java代码 复制代码
  1. package common.dao;   
  2.   
  3. /**  
  4.  * 分页功能  
  5.  */  
  6. public class Page   
  7. {   
  8.     public final int    DEFAULT_PAGESIZE    = 15;   // 每页记录数   
  9.   
  10.     public final int    DEFAULT_PAGE        = 1;    // 默认显示第几页   
  11.   
  12.     // =========================================================================================   
  13.   
  14.     protected int       count;                      // 总的记录数   
  15.   
  16.     protected int       pageSize;                   // 每页记录数   
  17.   
  18.     protected int       pageCount;                  // 总的页数   
  19.   
  20.     protected int       page;                       // 本页页号   
  21.   
  22.     protected int       start;                      // 起始记录下标(MySql从0开始)   
  23.   
  24.     // =========================================================================================   
  25.     /**  
  26.      * 构造方法  
  27.      *   
  28.      * @param nPageSize  
  29.      *            每页记录数  
  30.      * @param nPage  
  31.      *            本页页号  
  32.      */  
  33.     public Page(final int nPageSize, final int nPage)   
  34.     {   
  35.         pageSize = nPageSize; // 每页大小   
  36.         page = nPage; // 本页页号   
  37.     }   
  38.   
  39.     /**  
  40.      * 构造方法 ,默认每页20条记录  
  41.      *   
  42.      * @param nPage  
  43.      *            本页页号  
  44.      */  
  45.     public Page(final int nPage)   
  46.     {   
  47.         pageSize = DEFAULT_PAGESIZE; // 每页大小   
  48.         page = nPage; // 本页页号   
  49.     }   
  50.   
  51.     /**  
  52.      * 构造方法 ,默认每页20条记录,显示第一页  
  53.      *   
  54.      */  
  55.     public Page()   
  56.     {   
  57.         pageSize = DEFAULT_PAGESIZE; // 每页大小   
  58.         page = DEFAULT_PAGE; // 本页页号   
  59.     }   
  60.   
  61.     /**  
  62.      * 分页初始化  
  63.      *   
  64.      * @param nCount  
  65.      *            总的记录数  
  66.      */  
  67.     public void init(final int nCount)   
  68.     {   
  69.         init(nCount, pageSize, page);   
  70.     }   
  71.   
  72.     /**  
  73.      * 分页初始化；记录总记录数，每页记录数，当前页，并计算总页数、本页大小和检测当前页是否有效  
  74.      *   
  75.      * @param nCount  
  76.      *            总的记录数  
  77.      * @param nPageSize  
  78.      *            每页记录数  
  79.      * @param nPage  
  80.      *            本页页号  
  81.      */  
  82.     public void init(final int nCount, final int nPageSize, final int nPage)   
  83.     {   
  84.         count = nCount; // 总的项数   
  85.         page = nPage; // 本页页号   
  86.         pageSize = nPageSize; // 每页大小   
  87.         if (0 >= pageSize)   
  88.         {   
  89.             pageSize = DEFAULT_PAGESIZE;   
  90.         }   
  91.         pageCount = (nCount + pageSize - 1) / pageSize; // 计算总的页数   
  92.   
  93.         // 防止 Page 超范围并计算当前页大小   
  94.         if (page > pageCount)   
  95.         {   
  96.             page = pageCount;   
  97.         }   
  98.         if (page < 1)   
  99.         {   
  100.             page = DEFAULT_PAGE;   
  101.         }   
  102.   
  103.         start = min();   
  104.     }   
  105.   
  106.     /**  
  107.      * 计算起始记录下标(MySql从0开始)  
  108.      *   
  109.      * @return  
  110.      */  
  111.     public int min()   
  112.     {   
  113.         final int max = page * pageSize - 1;   
  114.         return max - pageSize + 1;   
  115.     }   
  116.   
  117.     //  public int max()   
  118.     //  {   
  119.     //      final int max = page * pageSize - 1;   
  120.     //      return max;   
  121.     //  }   
  122.   
  123.     /**  
  124.      * 计算导航页(开始页号)  
  125.      *   
  126.      * @param nPageNav  
  127.      *            导航页数  
  128.      * @return 开始页号  
  129.      */  
  130.     public final int CalcMinPage(final int nPageNav)   
  131.     {   
  132.         int min = page - (nPageNav / 2);   
  133.         int max = page + (nPageNav / 2);   
  134.         if (min < 1)   
  135.         {   
  136.             final int a = 0 - min;   
  137.             min = 1;   
  138.             max = max + a;   
  139.         }   
  140.         if (max > pageCount)   
  141.         {   
  142.             final int b = max - pageCount;   
  143.             max = pageCount;   
  144.             min = min - b < 1 ? 1 : min - b;   
  145.         }   
  146.         return min;   
  147.     }   
  148.   
  149.     /**  
  150.      * 计算导航页(结束页号)  
  151.      *   
  152.      * @param nPageNav  
  153.      *            导航页数  
  154.      * @return 结束页号  
  155.      */  
  156.     public final int CalcMaxPage(final int nPageNav)   
  157.     {   
  158.         int min = page - (nPageNav / 2);   
  159.         int max = page + (nPageNav / 2);   
  160.         if (min < 1)   
  161.         {   
  162.             final int a = 0 - min;   
  163.             min = 1;   
  164.             max = max + a;   
  165.         }   
  166.         if (max > pageCount)   
  167.         {   
  168.             final int b = max - pageCount;   
  169.             max = pageCount;   
  170.             min = min - b < 1 ? 1 : min - b;   
  171.         }   
  172.         return max;   
  173.     }   
  174.   
  175.     @Override  
  176.     public String toString()   
  177.     {   
  178.         final StringBuffer sbf = new StringBuffer();   
  179.         sbf.append(" 总的记录数:" + count);   
  180.         sbf.append(" 每页记录数:" + pageSize);   
  181.         sbf.append(" 总的页数:" + pageCount);   
  182.         sbf.append(" 本页页号:" + page);   
  183.         sbf.append(" 起始记录下标:" + start);   
  184.         return sbf.toString();   
  185.     }   
  186.   
  187.     public int getCount()   
  188.     {   
  189.         return count;   
  190.     }   
  191.   
  192.     public void setCount(final int count)   
  193.     {   
  194.         this.count = count;   
  195.     }   
  196.   
  197.     public int getPageSize()   
  198.     {   
  199.         return pageSize;   
  200.     }   
  201.   
  202.     public void setPageSize(final int pageSize)   
  203.     {   
  204.         this.pageSize = pageSize;   
  205.     }   
  206.   
  207.     public int getPageCount()   
  208.     {   
  209.         return pageCount;   
  210.     }   
  211.   
  212.     public void setPageCount(final int pageCount)   
  213.     {   
  214.         this.pageCount = pageCount;   
  215.     }   
  216.   
  217.     public int getPage()   
  218.     {   
  219.         return page;   
  220.     }   
  221.   
  222.     public void setPage(final int page)   
  223.     {   
  224.         this.page = page;   
  225.     }   
  226.   
  227.     public int getStart()   
  228.     {   
  229.         return start;   
  230.     }   
  231.   
  232.     public void setStart(final int start)   
  233.     {   
  234.         this.start = start;   
  235.     }   
  236.   
  237. }  
package common.dao;

/**
 * 分页功能
 */
public class Page
{
	public final int	DEFAULT_PAGESIZE	= 15;	// 每页记录数

	public final int	DEFAULT_PAGE		= 1;	// 默认显示第几页

	// =========================================================================================

	protected int		count;						// 总的记录数

	protected int		pageSize;					// 每页记录数

	protected int		pageCount;					// 总的页数

	protected int		page;						// 本页页号

	protected int		start;						// 起始记录下标(MySql从0开始)

	// =========================================================================================
	/**
	 * 构造方法
	 * 
	 * @param nPageSize
	 *            每页记录数
	 * @param nPage
	 *            本页页号
	 */
	public Page(final int nPageSize, final int nPage)
	{
		pageSize = nPageSize; // 每页大小
		page = nPage; // 本页页号
	}

	/**
	 * 构造方法 ,默认每页20条记录
	 * 
	 * @param nPage
	 *            本页页号
	 */
	public Page(final int nPage)
	{
		pageSize = DEFAULT_PAGESIZE; // 每页大小
		page = nPage; // 本页页号
	}

	/**
	 * 构造方法 ,默认每页20条记录,显示第一页
	 * 
	 */
	public Page()
	{
		pageSize = DEFAULT_PAGESIZE; // 每页大小
		page = DEFAULT_PAGE; // 本页页号
	}

	/**
	 * 分页初始化
	 * 
	 * @param nCount
	 *            总的记录数
	 */
	public void init(final int nCount)
	{
		init(nCount, pageSize, page);
	}

	/**
	 * 分页初始化；记录总记录数，每页记录数，当前页，并计算总页数、本页大小和检测当前页是否有效
	 * 
	 * @param nCount
	 *            总的记录数
	 * @param nPageSize
	 *            每页记录数
	 * @param nPage
	 *            本页页号
	 */
	public void init(final int nCount, final int nPageSize, final int nPage)
	{
		count = nCount; // 总的项数
		page = nPage; // 本页页号
		pageSize = nPageSize; // 每页大小
		if (0 >= pageSize)
		{
			pageSize = DEFAULT_PAGESIZE;
		}
		pageCount = (nCount + pageSize - 1) / pageSize; // 计算总的页数

		// 防止 Page 超范围并计算当前页大小
		if (page > pageCount)
		{
			page = pageCount;
		}
		if (page < 1)
		{
			page = DEFAULT_PAGE;
		}

		start = min();
	}

	/**
	 * 计算起始记录下标(MySql从0开始)
	 * 
	 * @return
	 */
	public int min()
	{
		final int max = page * pageSize - 1;
		return max - pageSize + 1;
	}

	//	public int max()
	//	{
	//		final int max = page * pageSize - 1;
	//		return max;
	//	}

	/**
	 * 计算导航页(开始页号)
	 * 
	 * @param nPageNav
	 *            导航页数
	 * @return 开始页号
	 */
	public final int CalcMinPage(final int nPageNav)
	{
		int min = page - (nPageNav / 2);
		int max = page + (nPageNav / 2);
		if (min < 1)
		{
			final int a = 0 - min;
			min = 1;
			max = max + a;
		}
		if (max > pageCount)
		{
			final int b = max - pageCount;
			max = pageCount;
			min = min - b < 1 ? 1 : min - b;
		}
		return min;
	}

	/**
	 * 计算导航页(结束页号)
	 * 
	 * @param nPageNav
	 *            导航页数
	 * @return 结束页号
	 */
	public final int CalcMaxPage(final int nPageNav)
	{
		int min = page - (nPageNav / 2);
		int max = page + (nPageNav / 2);
		if (min < 1)
		{
			final int a = 0 - min;
			min = 1;
			max = max + a;
		}
		if (max > pageCount)
		{
			final int b = max - pageCount;
			max = pageCount;
			min = min - b < 1 ? 1 : min - b;
		}
		return max;
	}

	@Override
	public String toString()
	{
		final StringBuffer sbf = new StringBuffer();
		sbf.append(" 总的记录数:" + count);
		sbf.append(" 每页记录数:" + pageSize);
		sbf.append(" 总的页数:" + pageCount);
		sbf.append(" 本页页号:" + page);
		sbf.append(" 起始记录下标:" + start);
		return sbf.toString();
	}

	public int getCount()
	{
		return count;
	}

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

	public int getPageSize()
	{
		return pageSize;
	}

	public void setPageSize(final int pageSize)
	{
		this.pageSize = pageSize;
	}

	public int getPageCount()
	{
		return pageCount;
	}

	public void setPageCount(final int pageCount)
	{
		this.pageCount = pageCount;
	}

	public int getPage()
	{
		return page;
	}

	public void setPage(final int page)
	{
		this.page = page;
	}

	public int getStart()
	{
		return start;
	}

	public void setStart(final int start)
	{
		this.start = start;
	}

}

 

WebPage （继承自Page）　扩展了在JSP页面上显示　＂上一页　１　２　３　下一页＂　的功能

Java代码 复制代码
  1. package common.web;   
  2.   
  3. import javax.servlet.http.HttpServletRequest;   
  4.   
  5. import org.apache.struts2.ServletActionContext;   
  6.   
  7. import common.dao.Page;   
  8.   
  9. public class WebPage extends Page   
  10. {   
  11.     public final int    DEFAULT_NAV_SIZE    = 20;           // 导航页数   
  12.   
  13.     private boolean     center              = true;     //默认居中   
  14.   
  15.     private String      className           = "page_css";   //默认CSS   
  16.   
  17.     /**  
  18.      * 构造方法  
  19.      *   
  20.      * @param nPageSize  
  21.      *            每页记录数  
  22.      * @param nPage  
  23.      *            本页页号  
  24.      */  
  25.     public WebPage(final int nPageSize, final int nPage, final String sPageURLParas)   
  26.     {   
  27.         super(nPageSize, nPage);   
  28.         setPageURL(sPageURLParas);   
  29.     }   
  30.   
  31.     /**  
  32.      * 构造方法  
  33.      *   
  34.      * @param nPageSize  
  35.      *            每页记录数  
  36.      * @param nPage  
  37.      *            本页页号  
  38.      */  
  39.     public WebPage(final int nPageSize, final int nPage)   
  40.     {   
  41.         super(nPageSize, nPage);   
  42.         setPageURL("");   
  43.     }   
  44.   
  45.     /**  
  46.      * 构造方法 ,默认每页20条记录  
  47.      *   
  48.      * @param nPage  
  49.      *            本页页号  
  50.      */  
  51.     public WebPage(final int nPage)   
  52.     {   
  53.         super(nPage);   
  54.         setPageURL("");   
  55.     }   
  56.   
  57.     private String  pageURL;    // 导航地址   
  58.   
  59.     private String  pageNAV;    // 导航表格   
  60.   
  61.     public void setPageURL(final String sPageURLPara)   
  62.     {   
  63.         //final HttpServletRequest request,   
  64.         final HttpServletRequest request = ServletActionContext.getRequest();   
  65.         if (sPageURLPara.length() > 0)   
  66.         {   
  67.             pageURL = "?" + sPageURLPara.substring(1) + "&";   
  68.         }   
  69.         else  
  70.         {   
  71.             pageURL = "?";   
  72.         }   
  73.         pageURL = request.getRequestURI() + pageURL + "page=";   
  74.         pageNAV = null;   
  75.     }   
  76.   
  77.     public String getPageNAV()   
  78.     {   
  79.         final int nPageNav = DEFAULT_NAV_SIZE; // 导航页数     
  80.         final int nPage = page; // 当前页号   
  81.         final int nPageMin = CalcMinPage(nPageNav); // 开始页号   
  82.         final int nPageMax = CalcMaxPage(nPageNav); // 结束页号   
  83.         final StringBuffer sPageNav = new StringBuffer(1024);   
  84.         if (nPageMin < nPageMax)   
  85.         {   
  86.   
  87.             sPageNav.append("<table class=\"" + className + "\"");   
  88.             if (center)   
  89.             {   
  90.                 //导航条居中 ,样式表   
  91.                 sPageNav.append(" align=\"center\">");   
  92.             }   
  93.             sPageNav.append("<tr>\r\n");   
  94.             if (nPageMin != nPage)   
  95.             {   
  96.   
  97.                 sPageNav.append("<td><a href=\"");   
  98.                 sPageNav.append(pageURL + (nPage - 1));   
  99.                 sPageNav.append("\">上页</a></td>\r\n");   
  100.             }   
  101.             else  
  102.             {   
  103.                 sPageNav.append("<td>上页</td>\r\n");   
  104.             }   
  105.             for (int i = nPageMin; i <= nPageMax; i++)   
  106.             {   
  107.                 sPageNav.append("<td>");   
  108.                 if (i != nPage)   
  109.                 {   
  110.                     sPageNav.append("<a style='text-decoration: underline' href=\"");   
  111.                     sPageNav.append(pageURL + (i));   
  112.                     sPageNav.append("\">");   
  113.                 }   
  114.                 if (i != nPage)   
  115.                 {   
  116.                     sPageNav.append(i);   
  117.                 }   
  118.                 else  
  119.                 {   
  120.                     sPageNav.append("<b style='color:#ff7700'>" + (i) + "</b>");   
  121.                 }   
  122.                 if (i != nPage)   
  123.                 {   
  124.                     sPageNav.append("</a>");   
  125.                 }   
  126.                 sPageNav.append("</td>\r\n");   
  127.             }   
  128.   
  129.             if (nPageMax != nPage)   
  130.             {   
  131.   
  132.                 sPageNav.append("<td><a style='text-decoration: underline' href=\"");   
  133.                 sPageNav.append(pageURL + (page + 1));   
  134.                 sPageNav.append("\">下页</a></td>\r\n");   
  135.             }   
  136.             else  
  137.             {   
  138.                 sPageNav.append("<td>下页</td>\r\n");   
  139.             }   
  140.             sPageNav.append("</tr></table>\r\n");   
  141.         }   
  142.         pageNAV = sPageNav.toString();   
  143.         return pageNAV;   
  144.     }   
  145.   
  146.     public boolean isCenter()   
  147.     {   
  148.         return center;   
  149.     }   
  150.   
  151.     public void setCenter(final boolean center)   
  152.     {   
  153.         this.center = center;   
  154.     }   
  155.   
  156.     public String getClassName()   
  157.     {   
  158.         return className;   
  159.     }   
  160.   
  161.     public void setClassName(final String className)   
  162.     {   
  163.         this.className = className;   
  164.     }   
  165. }  
package common.web;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts2.ServletActionContext;

import common.dao.Page;

public class WebPage extends Page
{
	public final int	DEFAULT_NAV_SIZE	= 20;			// 导航页数

	private boolean		center				= true;		//默认居中

	private String		className			= "page_css";	//默认CSS

	/**
	 * 构造方法
	 * 
	 * @param nPageSize
	 *            每页记录数
	 * @param nPage
	 *            本页页号
	 */
	public WebPage(final int nPageSize, final int nPage, final String sPageURLParas)
	{
		super(nPageSize, nPage);
		setPageURL(sPageURLParas);
	}

	/**
	 * 构造方法
	 * 
	 * @param nPageSize
	 *            每页记录数
	 * @param nPage
	 *            本页页号
	 */
	public WebPage(final int nPageSize, final int nPage)
	{
		super(nPageSize, nPage);
		setPageURL("");
	}

	/**
	 * 构造方法 ,默认每页20条记录
	 * 
	 * @param nPage
	 *            本页页号
	 */
	public WebPage(final int nPage)
	{
		super(nPage);
		setPageURL("");
	}

	private String	pageURL;	// 导航地址

	private String	pageNAV;	// 导航表格

	public void setPageURL(final String sPageURLPara)
	{
		//final HttpServletRequest request,
		final HttpServletRequest request = ServletActionContext.getRequest();
		if (sPageURLPara.length() > 0)
		{
			pageURL = "?" + sPageURLPara.substring(1) + "&";
		}
		else
		{
			pageURL = "?";
		}
		pageURL = request.getRequestURI() + pageURL + "page=";
		pageNAV = null;
	}

	public String getPageNAV()
	{
		final int nPageNav = DEFAULT_NAV_SIZE; // 导航页数	
		final int nPage = page; // 当前页号
		final int nPageMin = CalcMinPage(nPageNav); // 开始页号
		final int nPageMax = CalcMaxPage(nPageNav); // 结束页号
		final StringBuffer sPageNav = new StringBuffer(1024);
		if (nPageMin < nPageMax)
		{

			sPageNav.append("<table class=\"" + className + "\"");
			if (center)
			{
				//导航条居中 ,样式表
				sPageNav.append(" align=\"center\">");
			}
			sPageNav.append("<tr>\r\n");
			if (nPageMin != nPage)
			{

				sPageNav.append("<td><a href=\"");
				sPageNav.append(pageURL + (nPage - 1));
				sPageNav.append("\">上页</a></td>\r\n");
			}
			else
			{
				sPageNav.append("<td>上页</td>\r\n");
			}
			for (int i = nPageMin; i <= nPageMax; i++)
			{
				sPageNav.append("<td>");
				if (i != nPage)
				{
					sPageNav.append("<a style='text-decoration: underline' href=\"");
					sPageNav.append(pageURL + (i));
					sPageNav.append("\">");
				}
				if (i != nPage)
				{
					sPageNav.append(i);
				}
				else
				{
					sPageNav.append("<b style='color:#ff7700'>" + (i) + "</b>");
				}
				if (i != nPage)
				{
					sPageNav.app

  


  

    
    
分享到：
      
      
    

  


  

    

      
      |
      eclipse, language:java; db:db2 ; dbDrive ...
    

  

  

        
  

    
  

    
评论

    
    
    
    
  


  

    
发表评论

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

相关推荐

    Struts2 Spring3 Hibernate 注解功能 DAO 泛型 通用分页

    总的来说，"SSHWithAnnotationDemo"项目展示了如何利用现代Java技术栈的高级特性，包括Struts2、Spring3和Hibernate的注解功能，DAO层的泛型设计以及通用的分页实现，来构建一个高效、可维护的Web应用。这样的实践...

    springmvc+hibernate+spring maven案例（包含分页查询）

    - 在此案例中，可能使用了Hibernate的`Criteria`或`HQL`查询语言配合`PageRequest`或自定义分页实现，通过指定页码和每页大小来获取特定范围的数据。 6. **文件名：user** - "user"可能是数据库中的一个表名，...

    Hibernate泛型Dao

    此外，了解SQL语言也是必要的，虽然Hibernate可以自动生成SQL，但在某些复杂查询场景下，可能需要手动编写SQL。最后，熟悉Spring框架和其他与Hibernate整合的技术，如Spring Data JPA，能够进一步提升开发效率。

    基于hibernate 通用查询框架，包含查询、分页列表 功能

    通用查询页面中的查询项、查询出的分页列表都是自动生成的。开发简便、快速，附件中是一套完整的demo和使用说明 支持全部Hql语法格式 Awake 后续功能扩展 1.XML格式数据输出，保证了ajax用户也可以使用Awake框架...

    Spring/泛型Hibernate的实现

    ### 泛型Hibernate的实现与Spring集成 #### 一、泛型Hibernate概念及其实现 在Java开发领域，尤其在企业级应用开发中，Hibernate框架因其强大的对象关系映射（ORM）能力而受到广泛欢迎。泛型Hibernate是利用Java...

    hibernate不是泛型的通用DAo1

    而`PageBean`可能是一个用于分页查询的辅助类，封装了当前页、每页数量以及数据列表等信息。 这种非泛型的DAO实现方式可能会牺牲一些灵活性，但它简化了代码结构，降低了学习和使用的门槛，尤其适合小规模项目或者...

    SSH 泛型DAO分页

    在SSH框架中，可以结合Hibernate的Criteria API或HQL实现分页查询。通常需要指定每页的记录数和当前页码，返回相应的数据列表和总记录数。 在实际开发中，"SSH 泛型DAO分页"的整合可能涉及到以下步骤： - 配置SSH...

    ssh整合下的通用泛型DAO+分页

    在这个特定的讨论中，我们聚焦于SSH1中的一个关键概念：通用泛型DAO（Data Access Object）以及分页功能的实现。DAO层是模型层和数据访问层之间的桥梁，它的主要职责是处理数据库操作，为业务层提供无状态的数据访问...

    Hibernate泛型DAO及使用方法借鉴.pdf

    总结，泛型Hibernate DAO是企业级应用中常见的设计模式，它封装了数据库操作，使得业务逻辑层与数据访问层分离，提高了代码的可复用性和可测试性。在实际开发中，可以根据项目的具体需求，对这个基础实现进行扩展和...

    struts+spring+hibernate通用分页方法

    1. 创建一个泛型的DAO接口，定义分页查询的方法，参数可能包括实体类的类型、查询条件、当前页数和每页大小。 2. 实现DAO接口，使用Hibernate的Session和Query对象进行分页查询，并返回结果集。 3. 在Service层中，...

    ssh通用泛型DAO

    5. 分页查询（Paging）：提供分页查询功能，通常结合"Page"类使用。 接下来是"Page"类。在大型应用中，为了提高用户体验，通常会采用分页显示数据。Page类是用来表示分页结果的，它通常包含当前页数、总页数、每页...

    SpringSide的Hibernate封装

    4. Query和Criteria的创建与配置：返回已经设置好基本查询条件的Query和Criteria对象，方便开发者添加更多的查询参数。 5. 分页功能：提供pagedQuery()方法，除了获取分页结果外，还会计算总记录数，以满足显示分页...

    Hibernate封装dao层

    - 分页查询：封装分页查询方法，如`List&lt;T&gt; findByPage(int pageNum, int pageSize)`，以支持大数据量的场景。 7. **异常处理**： 在DAO层捕获和处理Hibernate抛出的异常，如`HibernateException`，并根据业务...

    泛型DAO，注释详细

    在实际项目中，我们通常会根据需求进一步细化泛型DAO，比如添加分页查询、按条件查询等功能。此外，为了更好地适应业务需求，我们还可以考虑使用Spring的`@Repository`注解进行组件管理，并结合`@Transactional`注解...

    Hibernate通用Dao设计。

    - **分页查询**：使用Criteria API或HQL实现分页查询，结合Page对象存储查询结果和分页信息。 3. **事务管理** - 为了保证数据的一致性，通常需要在通用DAO中处理事务。可以使用Spring的TransactionTemplate或者...

    java Pagination(分页并操作)

    Java 分页是数据库查询和网页显示大量数据时常用的一种技术，它能有效地管理大量数据，避免一次性加载所有数据导致的性能问题和用户体验下降。在Java中实现分页主要涉及两个核心概念：偏移量（Offset）和限制大小...

    如何对多对多关系获得的set集合中的记录进行分页

    在Java Web开发中，SSH（Struts2、Spring、Hibernate）框架被广泛使用，其中的分页功能是提高用户体验的重要一环。对于处理多对多关系的数据，分页显得更为复杂，因为涉及到的对象关联和集合的处理。本篇将详细阐述...

    hibernate3.2_中文参考手册.pdf

    - **分页查询**：支持对查询结果进行分页处理，避免一次性加载大量数据。 #### 六、最佳实践与常见问题 - **合理设计实体类**：遵循单一职责原则，避免实体类过于臃肿。 - **正确使用缓存**：合理配置缓存策略，...

    深入浅出分页

    - 使用HibernateDAO时，根据`Page`对象的参数设置查询的分页信息，例如`criteria.setFirstResult(page.getFirst()-1).setMaxResults(page.getPageSize()).list();`。 - 将查询结果设置到`Page`的`result`属性，并...

    JSP通用分页框架

    例如，对于一个基于Hibernate的查询，可以这样实现： ```java public List&lt;User&gt; getUsers() { int pageIndex = PageParams.PAGEINDEX.get(); int pageSize = PageParams.PAGESIZE.get(); Criteria criteria =...

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