java探路者 http://xianglg.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 struts2+prototype.js实现ajax的无刷新crud操作 xianglg 作者: xianglg  链接：http://xianglg.javaeye.com/blog/154806  发表时间: 2008年01月10日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

CRUD是Create（创建）、Read（读取）、Update（更新）和Delete（删除）的缩写，除了R，其它每次操作都是对数据库进行了改动，所以，无可避免的要重新对数据库取一遍数据，然后在JSP页面进行显示。如果是无刷新，最笨的方法就是将html代码写到java类里，但如果这样做，你肯定要被扔鸡蛋，下面介绍一种比较容易上手的操作。
首先，我们看一下，仅仅使用struts2，怎么实现CRUD操作。这里，拿删除做例子，其它都雷同。
看一下action类的的内容 
public class CRUDAction extends ActionSupport {
	private CRUDEntity crudEntity;//实体Bean

	private List<CRUDEntity> entityList;

	private CRUDService crudService;//实体业务类

	private int cpage = 1;//默认当前页是1

	private static final int pageSize = 10;//每页显示10条

	public void setCrudEntity(CRUDEntity curdEntity){
		this.crudEntity = curdEntity;
	}

	public CRUDEntity getCrudEntity(){
		return this.crudEntity
	}

	public void setCrudService(CRUDService crudService){
		this.crudService = crudService;
	}

	public CURDService getCRUDService(){
		return this.crudService;
	}
	....//其它set,get方法

	/**
	* 分页显示实体信息
	*
	**/
	public 
	public String list(){
		entityList = crudService.pagedQuery(cpage,pageSize);
		return SUCCESS;
	}

	/**
	* 删除实体记录
	*
	**/
	public String delete(){
		if(crudEntity!=null && crudEntity.getId() !=null){//首先判断不为空
			crudService.deleteById(crudEntity.getId());//id是主键
		}
		return SUCCESS;
	}
}

这里service层，使用了spring 的IOC进行了注入。
再看一下，struts.xml配置文件如何写 
<action name="list" method="list" class="crudAction">
	<result>/entityManage.jsp</result>
</action>
<action name="delete" method="delete" class="crudAction">
	<result type="redirect-action">list</result>
</action>

配置文件的class也把action类交给了spring管理，但是action类在spring千万不能singleton，否则当多人访问这个action时，你的action就成了有状态的类。举个例子，这里的删除主健id就有可能不是你提交的id。
注意这里的result的type是redirect-action,它表明当删除成功后，直接转向list.action操作，去数据库重新取一遍数据，其实就是response.sendRedirect()。 
<%@page language="java" contentType="text/html; charset=utf-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
	<head>
		<title>资源来源管理</title>
		<meta http-equiv="pragma" content="no-cache">
		<meta http-equiv="cache-control" content="no-cache">
	</head>
<body>
	<table width="100%" cellspacing="0" cellpadding="0" align="center">
		<tr>
			<th>
				序号
			</th>
			<th>
				名称
			</th>
			...
			<th>
				删除
			</th>
		</tr>
		<s:iterator value="entityList" status="stats">
			<tr>
				<td>
					<s:property value="#stats.count"/>
				</td>
				<td>
					<s:property value="name"/>
				</td>
				...
				<td>
					<s:url action="delete" id="delete">
						<s:param name="crudEntity.id" value="%{id}"/>
					</s:url>
					<s:a href="%{deelte}">
						删除
					</s:a>
				</td>
			</tr>
		</s:iterator>
	</table>
</body>
</html>


到这里，应该很清楚整个流程了吧。如果不使用ajax，则每次点击删除时，重新刷一下页面。如果不想让它刷新呢？怎么办？
其实实现也是很简单的，我们对上面的例子做一点小小的感动。
类文件不用改动，XML配置文件只需改动一点 

<action name="list" method="list" class="crudAction">
	<result>/entityManage.jsp</result>
</action>
<action name="show" method="list" class="crudAction">
	<result>/entityManage_main.jsp</result>
</action>
<action name="delete" method="delete" class="crudAction">
	<result type="redirect-action">show</result>
</action>


细心的读者可能比较快发现了已经修改了两处，第一：增加了一个action，原来的list是实体管理显示列表的，而在list之后又增加了一个show.action，但其实是用得Action类的一个方法，目的还是在删除后，重新到数据库里取数据。第二，将原来的delete.action的result改为show,有什么用处，往下看。
主要的改动是jsp和js
通过配置文件，可以观察到多了一个jsp文件，这个jsp文件里面是什么，代码奉上：
entityManage.jsp 
<%@page language="java" contentType="text/html; charset=utf-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
	<head>
		<title>资源来源管理</title>
		<meta http-equiv="pragma" content="no-cache">
		<meta http-equiv="cache-control" content="no-cache">
		<script type="text/javascript"
			src="${pageContext.request.contextPath}/js/prototype.js"></script>
		<script type="text/javascript"
			src="${pageContext.request.contextPath}/js/application.js"></script>
	</head>
<body>
	<div id="div_entityManage_main">
		<s:include value="entityManage_main.jsp"/>
	</div>
</body>
</html>

与原来的jsp文件比，只是少了显示信息的表格，我已经将这部分代码放到了entityManage_main.jsp中，另外，页面引用了prototype.js文件，我们要在后面的application.js写ajax用到。
entityManage_main.jsp： 
<%@page language="java" contentType="text/html; charset=utf-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<table width="100%" cellspacing="0" cellpadding="0" align="center">
	<tr>
		<th>
			序号
		</th>
		<th>
			名称
		</th>
		...
		<th>
			删除
		</th>
	</tr>
	<s:iterator value="entityList" status="stats">
		<tr>
			<td>
				<s:property value="#stats.count" />
			</td>
			<td>
				<s:property value="name" />
			</td>
			...
			<td>
				<s:a href="javascript:delete(%{id})">
						删除
				</s:a>
			</td>
		</tr>
	</s:iterator>
</table>

代码与原来只是修改了删除的链接，原来是链接action，现在是js。
application.js 
 function delete(id) {
 		var url = "delete.action?crudEntity.id="+id;
		new Ajax.Updater (
			'div_entityManage_main',
			url, 
			{
				onLoading:function (){
				},
				onSuccess:function (request) {
					alert('删除成功');
				}, 
				onFailure:function (request) {
					alert("服务器故障，请稍候重试");
				}
			}
		);
 }


所有代码全部写好了，整个流程是这样子的
1.用户使用list.action到管理页面
2.用户点击"删除"，触发js的delete方法，delete方法将使用ajax提交delete.action
3.action类删除成功后，将转向show.action去数据库重新提取数据，取到的数据在entityManage_main.jsp显示
4.prototype.js将entityManage_main.jsp的代码又写到enttityManage.jsp的ID为"div_entityManage_main"的DIV中
整个过程，是无刷新的，同样，其它操作同理
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 10 Jan 2008 17:00:32 +0800 http://xianglg.javaeye.com/blog/154806 http://xianglg.javaeye.com/blog/154806 使用DWR，hibernate的annotation的lazy属性失效，为何? xianglg 作者: xianglg  链接：http://xianglg.javaeye.com/blog/115644  发表时间: 2007年08月23日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

我先说用了几个框架吧，spring,hibernate,dwr，然后bean用的是annotation标记的：
其中商品和订单表，我用的是一对多
Product bean
  1. @OneToMany(targetEntity = Order.class, cascade = CascadeType.REMOVE, fetch = FetchType.LAZY)   
  2.     @JoinColumn(name = "PRODUCTID")   
  3.     public List<Order> getOrders() {   
  4.         return orders;   
  5.     }  


在DAO层里，我用了spring的hibernateDaoSupport，其中有个分页查询方法：

java 代码
  1. /**  
  2.  * 根据页码和每页的长度返回对象集合  
  3.  *   
  4.  * @param pageNo  
  5.  *            页码  
  6.  * @param pageSize  
  7.  *            每页的长度  
  8.  * @return  
  9.  */    
  10. public Page<T> PageQuery(int pageNo,int pageSize){   
  11.     Criteria criteria = this.createCriteria();   
  12.     return this.pagedQuery(criteria, pageNo, pageSize);   
  13. }  

方法返回的page,我自己定义的一个封装了页面属性和内容的bean。

然后定义了一个service层的方法，调用DAO层的这个分页函数。

java 代码

 

  1. public List<Product> getProducts(int pageNo,int pageSize){         
  2.         return productDAO.PageQuery(pageNo, pageSize).getResult();   
  3.     }  

 JSP页面使用DWR调用service层的getProducts

xml 代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE dwr PUBLIC "-//GetAhead Limited//DTD Direct Web Remoting 2.0//EN" "http://getahead.org/dwr//dwr20.dtd">  
  3. <dwr>  
  4.     <allow>  
  5.         <create javascript="ProductService" creator="spring">  
  6.             <param name="beanName" value="productService"></param>  
  7.             <include method="loadProduct" />  
  8.             <include method="getProducts" />  
  9.         </create>  
  10.     </allow>  
  11. </dwr>  

再定义了JS函数

js 代码
  1. window.onload = function(){   
  2.     ProductService.getProducts(1,10,displayProducts);   
  3. }   
  4. function displayProducts(products){   
  5.     DWRUtil.removeAllRows("items");   
  6.     if (items.length == 0) {   
  7.         alert("No matching products found");   
  8.         $("products").style.visibility = "hidden";   
  9.     } else {   
  10.         DWRUtil.addRows("items",products,cellFunctions);   
  11.         $("products").style.visibility = "visible";   
  12.     }   
  13.        
  14. }   
  15. /*  
  16.  * Array of functions to populate a row of the items table  
  17.  * using DWRUtil's addRows function  
  18.  */  
  19. var cellFunctions =[   
  20.     function(product){return product.productname},   
  21.     function(product){return product.productdetail},   
  22.     function(product){return product.price},   
  23.     function(product) {    
  24.     var btn = document.createElement("button");   
  25.     btn.innerHTML = "Add to cart";   
  26.     btn.productId = product.id;   
  27.     btn.onclick = addToCartButtonHandler;   
  28.     return btn;   
  29.   }   
  30. ];  
所有的源码基本上就是这些，我使用单元测试时，lazy效果已经有了！但是我访问页面，通过dwr调用service层方法，好像却失效了，通查询查看hibernate日志，看到与之相关的所有select语句，全部打印了出来！
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 23 Aug 2007 14:09:49 +0800 http://xianglg.javaeye.com/blog/115644 http://xianglg.javaeye.com/blog/115644 struts2+hibernate+spring配置管理（三）——DAO层（二） xianglg 作者: xianglg  链接：http://xianglg.javaeye.com/blog/112902  发表时间: 2007年08月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

接上篇所说，如果懂得这个思想，其实很简单了，况且有spring的HibernateDaoSupport坐阵，你的代码会更精简，会更优化。话不多说，贴上代码先看一下吧：

java 代码
  1. /**  
  2.  * 负责为单个Entity对象提供CRUD操作的Hibernate DAO基类. 

     子类只要在类定义时指定所管理Entity的Class,

     
  3.  * 即拥有对单个Entity对象的CRUD操作.  
  4.  *   
  5.  *   
  6.  */  
  7. @SuppressWarnings("unchecked")   
  8. abstract public class HibernateBaseDao extends HibernateDaoSupport {   
  9.   
  10.     protected Class entityClass;// DAO所管理的Entity类型.   
  11.   
  12.     /**  
  13.      * 在构造函数中将泛型T.class赋给entityClass.  
  14.      */  
  15.     public HibernateBaseDao() {   
  16.         entityClass = GenericsUtils.getSuperClassGenricType(getClass());   
  17.     }   
  18.   
  19.     /**  
  20.      * 取得entityClass.JDK1.4不支持泛型的子类可以抛开Class entityClass,重载此函数达到相同效果。  
  21.      */  
  22.     protected Class getEntityClass() {   
  23.         return entityClass;   
  24.     }   
  25.   
  26.     /**  
  27.      * 根据ID获取对象.  
  28.      *   
  29.      * @see HibernateGenericDao#getId(Class,Object)  
  30.      */  
  31.     public T load(Serializable id) {   
  32.         return (T) getHibernateTemplate().load(getEntityClass(), id);   
  33.     }   
  34.   
  35.     /**  
  36.      * 根据ID获取对象,使用hinbernate get().  
  37.      *   
  38.      * @see HibernateGenericDao#getId(Class,Object)  
  39.      */  
  40.     public T get(Serializable id) {   
  41.         return (T) getHibernateTemplate().get(getEntityClass(), id);   
  42.     }   
  43.   
  44.     /**  
  45.      * 获取全部对象  
  46.      *   
  47.      * @see HibernateGenericDao#getAll(Class)  
  48.      */  
  49.     public List getAll() {   
  50.         return getHibernateTemplate().loadAll(getEntityClass());   
  51.     }   
  52.   
  53.     /**  
  54.      * 获取全部对象,带排序参数.  
  55.      *   
  56.      */  
  57.     public List getAll(String orderBy, boolean isAsc) {   
  58.         Assert.hasText(orderBy);   
  59.         if (isAsc)   
  60.             return getHibernateTemplate().findByCriteria(   
  61.                     DetachedCriteria.forClass(getEntityClass()).addOrder(   
  62.                             Order.asc(orderBy)));   
  63.         else  
  64.             return getHibernateTemplate().findByCriteria(   
  65.                     DetachedCriteria.forClass(getEntityClass()).addOrder(   
  66.                             Order.desc(orderBy)));   
  67.     }   
  68.   
  69.     /**  
  70.      * 保存对象.  
  71.      */  
  72.     public Serializable save(Object o) {   
  73.         return getHibernateTemplate().save(o);   
  74.     }   
  75.   
  76.     /**  
  77.      * 更新对象  
  78.      *   
  79.      * @param o  
  80.      */  
  81.     public void update(Object o) {   
  82.         getHibernateTemplate().update(o);   
  83.     }   
  84.   
  85.     /**  
  86.      * 保存或更新对象  
  87.      *   
  88.      * @param o  
  89.      */  
  90.     public void saveOrUpdate(Object o) {   
  91.         getHibernateTemplate().saveOrUpdate(o);   
  92.     }   
  93.   
  94.     /**  
  95.      * 删除对象.  
  96.      */  
  97.     public void remove(Object o) {   
  98.         getHibernateTemplate().delete(o);   
  99.     }   
  100.   
  101.     /**  
  102.      * 根据ID移除对象.  
  103.      *   
  104.      * @see HibernateGenericDao#removeById(Class,Serializable)  
  105.      */  
  106.     public void removeById(Serializable id) {   
  107.         remove(load(id));   
  108.     }   
  109.   
  110.     public void flush() {   
  111.         getHibernateTemplate().flush();   
  112.     }   
  113.   
  114.     public void clear() {   
  115.         getHibernateTemplate().clear();   
  116.     }   
  117.   
  118.     /**  
  119.      * 创建Query对象.  
  120.      * 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.  
  121.      * 留意可以连续设置,如下：  
  122.      *   
  123.      * @param values  
  124.      *            可变参数.  
  125.      */  
  126.     public Query createQuery(String hql, Object... values) {   
  127.         Assert.hasText(hql);   
  128.         Query query = getSession().createQuery(hql);   
  129.         for (int i = 0; i < values.length; i++) {   
  130.             query.setParameter(i, values[i]);   
  131.         }   
  132.         return query;   
  133.     }   
  134.   
  135.     /**  
  136.      * 取得Entity的Criteria.  
  137.      *   
  138.      */  
  139.     public Criteria createCriteria() {   
  140.         return getSession().createCriteria(getEntityClass());   
  141.     }   
  142.   
  143.     /**  
  144.      * 取得Entity的Criteria.  
  145.      *   
  146.      */  
  147.     public Criteria createCriteria(Criterion... criterions) {   
  148.         Criteria criteria = createCriteria();   
  149.         for (Criterion c : criterions) {   
  150.             criteria.add(c);   
  151.         }   
  152.         return criteria;   
  153.     }   
  154.   
  155.     /**  
  156.      * 取得Entity的Criteria,带排序参数.  
  157.      *   
  158.      */  
  159.     public Criteria createCriteria(String orderBy, boolean isAsc,   
  160.             Criterion... criterions) {   
  161.         Assert.hasText(orderBy);   
  162.   
  163.         Criteria criteria = createCriteria(criterions);   
  164.   
  165.         if (isAsc)   
  166.             criteria.addOrder(Order.asc(orderBy));   
  167.         else  
  168.             criteria.addOrder(Order.desc(orderBy));   
  169.   
  170.         return criteria;   
  171.     }   
  172.   
  173.     /**  
  174.      * 根据hql查询,直接使用HibernateTemplate的find函数.  
  175.      *   
  176.      * @param values  
  177.      *            可变参数,见{@link #createQuery(String,Object...)}  
  178.      */  
  179.     public List find(String hql, Object... values) {   
  180.         Assert.hasText(hql);   
  181.         return getHibernateTemplate().find(hql, values);   
  182.     }   
  183.   
  184.     /**  
  185.      * 根据属性名和属性值查询对象.  
  186.      *   
  187.      * @return 符合条件的对象列表  
  188.      */  
  189.     public List findBy(String propertyName, Object value) {   
  190.         Assert.hasText(propertyName);   
  191.         return createCriteria(Restrictions.eq(propertyName, value)).list();   
  192.     }   
  193.   
  194.     /**  
  195.      * 根据属性名和属性值查询对象,带排序参数.  
  196.      */  
  197.     public List findBy(Class entityClass, String propertyName,   
  198.             Object value, String orderBy, boolean isAsc) {   
  199.         Assert.hasText(propertyName);   
  200.         Assert.hasText(orderBy);   
  201.         return createCriteria(orderBy, isAsc,   
  202.                 Restrictions.eq(propertyName, value)).list();   
  203.     }   
  204.   
  205.     /**  
  206.      * 根据属性名和属性值查询对象,带排序参数.  
  207.      *   
  208.      * @return 符合条件的对象列表  
  209.      */  
  210.     public List findBy(String propertyName, Object value, String orderBy,   
  211.             boolean isAsc) {   
  212.         return findBy(getEntityClass(), propertyName, value, orderBy, isAsc);   
  213.     }   
  214.   
  215.     /**  
  216.      * 根据属性名和属性值查询单个对象.  
  217.      *   
  218.      * @return 符合条件的唯一对象 or null  
  219.      */  
  220.     public T findUniqueBy(String propertyName, Object value) {   
  221.         Assert.hasText(propertyName);   
  222.         return (T) createCriteria(Restrictions.eq(propertyName, value))   
  223.                 .uniqueResult();   
  224.     }   
  225.   
  226.     /**  
  227.      * 分页查询函数，使用hql.  
  228.      *   
  229.      * @param pageNo  
  230.      *            页号,从1开始.  
  231.      */  
  232.     public Page pagedQuery(String hql, int pageNo, int pageSize,   
  233.             Object... values) {   
  234.         Assert.hasText(hql);   
  235.         Assert.isTrue(pageNo >= 1, "pageNo should start from 1");   
  236.         // Count查询   
  237.         String countQueryString = " select count (*) "  
  238.                 + removeSelect(removeOrders(hql));   
  239.         List countlist = getHibernateTemplate().find(countQueryString, values);   
  240.         long totalCount = (Long) countlist.get(0);   
  241.   
  242.         if (totalCount < 1)   
  243.             return new Page();   
  244.         // 实际查询返回分页对象   
  245.         int startIndex = Page.getStartOfPage(pageNo, pageSize);   
  246.         Query query = createQuery(hql, values);   
  247.         List list = query.setFirstResult(startIndex).setMaxResults(pageSize)   
  248.                 .list();   
  249.   
  250.         return new Page(startIndex, totalCount, pageSize, list);   
  251.     }   
  252.   
  253.     /**  
  254.      * 分页查询函数，使用已设好查询条件与排序的Criteria.  
  255.      *   
  256.      * @param pageNo  
  257.      *            页号,从1开始.  
  258.      * @return 含总记录数和当前页数据的Page对象.  
  259.      */  
  260.     public Page pagedQuery(Criteria criteria, int pageNo, int pageSize) {   
  261.         Assert.notNull(criteria);   
  262.         Assert.isTrue(pageNo >= 1, "pageNo should start from 1");   
  263.         CriteriaImpl impl = (CriteriaImpl) criteria;   
  264.   
  265.         // 先把Projection和OrderBy条件取出来,清空两者来执行Count操作   
  266.         Projection projection = impl.getProjection();   
  267.         List orderEntries;   
  268.         try {   
  269.             orderEntries = (List) BeanUtils.forceGetProperty(impl,   
  270.                     "orderEntries");   
  271.             BeanUtils.forceSetProperty(impl, "orderEntries", new ArrayList());   
  272.         } catch (Exception e) {   
  273.             throw new InternalError(" Runtime Exception impossibility throw ");   
  274.         }   
  275.   
  276.         // 执行查询   
  277.         int totalCount = (Integer) criteria.setProjection(   
  278.                 Projections.rowCount()).uniqueResult();   
  279.   
  280.         // 将之前的Projection和OrderBy条件重新设回去   
  281.         criteria.setProjection(projection);   
  282.         if (projection == null) {   
  283.             criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);   
  284.         }   
  285.   
  286.         try {   
  287.             BeanUtils.forceSetProperty(impl, "orderEntries", orderEntries);   
  288.         } catch (Exception e) {   
  289.             throw new InternalError(" Runtime Exception impossibility throw ");   
  290.         }   
  291.   
  292.         // 返回分页对象   
  293.         if (totalCount < 1)   
  294.             return new Page();   
  295.   
  296.         int startIndex = Page.getStartOfPage(pageNo, pageSize);   
  297.         List list = criteria.setFirstResult(startIndex).setMaxResults(   
  298.                 pageSize).list();   
  299.         return new Page(startIndex, totalCount, pageSize, list);   
  300.     }   
  301.   
  302.     /**  
  303.      * 分页查询函数，根据entityClass和查询条件参数创建默认的Criteria.  
  304.      *   
  305.      * @param pageNo  
  306.      *            页号,从1开始.  
  307.      * @return 含总记录数和当前页数据的Page对象.  
  308.      */  
  309.     public Page pagedQuery(int pageNo, int pageSize, Criterion... criterions) {   
  310.         Criteria criteria = createCriteria(criterions);   
  311.         return pagedQuery(criteria, pageNo, pageSize);   
  312.     }   
  313.   
  314.     /**  
  315.      * 分页查询函数，根据entityClass和查询条件参数,排序参数创建默认的Criteria.  
  316.      *   
  317.      * @param pageNo  
  318.      *            页号,从1开始.  
  319.      * @return 含总记录数和当前页数据的Page对象.  
  320.      */  
  321.     public Page pagedQuery(int pageNo, int pageSize, String orderBy,   
  322.             boolean isAsc, Criterion... criterions) {   
  323.         Criteria criteria = createCriteria(orderBy, isAsc, criterions);   
  324.         return pagedQuery(criteria, pageNo, pageSize);   
  325.     }   
  326.   
  327.     /**  
  328.      * 判断对象某些属性的值在数据库中是否唯一.  
  329.      *   
  330.      * @param uniquePropertyNames  
  331.      *            在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password"  
  332.      */  
  333.     public boolean isUnique(Object entity, String uniquePropertyNames) {   
  334.         Assert.hasText(uniquePropertyNames);   
  335.         Criteria criteria = createCriteria().setProjection(   
  336.                 Projections.rowCount());   
  337.         String[] nameList = uniquePropertyNames.split(",");   
  338.         try {   
  339.             // 循环加入唯一列   
  340.             for (String name : nameList) {   
  341.                 criteria.add(Restrictions.eq(name, PropertyUtils.getProperty(   
  342.                         entity, name)));   
  343.             }   
  344.   
  345.             // 以下代码为了如果是update的情况,排除entity自身.   
  346.   
  347.             String idName = getIdName(getEntityClass());   
  348.   
  349.             // 取得entity的主键值   
  350.             Serializable id = getId(entity);   
  351.   
  352.             // 如果id!=null,说明对象已存在,该操作为update,加入排除自身的判断   
  353.             if (id != null)   
  354.                 criteria.add(Restrictions.not(Restrictions.eq(idName, id)));   
  355.         } catch (Exception e) {   
  356.             ReflectionUtils.handleReflectionException(e);   
  357.         }   
  358.         return (Integer) criteria.uniqueResult() == 0;   
  359.     }   
  360.   
  361.     /**  
  362.      * 取得对象的主键值,辅助函数.  
  363.      */  
  364.     public Serializable getId(Object entity) throws NoSuchMethodException,   
  365.             IllegalAccessException, InvocationTargetException {   
  366.         Assert.notNull(entity);   
  367.         Assert.notNull(getEntityClass());   
  368.         return (Serializable) PropertyUtils.getProperty(entity,   
  369.                 getIdName(getEntityClass()));   
  370.     }   
  371.   
  372.     /**  
  373.      * 取得对象的主键名,辅助函数.  
  374.      */  
  375.     public String getIdName(Class clazz) {   
  376.         Assert.notNull(clazz);   
  377.         ClassMetadata meta = getSessionFactory().getClassMetadata(clazz);   
  378.         Assert.notNull(meta, "Class " + clazz   
  379.                 + " not define in hibernate session factory.");   
  380.         String idName = meta.getIdentifierPropertyName();   
  381.         Assert.hasText(idName, clazz.getSimpleName()   
  382.                 + " has no identifier property define.");   
  383.         return idName;   
  384.     }   
  385.   
  386.     /**  
  387.      * 去除hql的select 子句，未考虑union的情况,用于pagedQuery.  
  388.      *   
  389.      * @see #pagedQuery(String,int,int,Object[])  
  390.      */  
  391.     private static String removeSelect(String hql) {   
  392.         Assert.hasText(hql);   
  393.         int beginPos = hql.toLowerCase().indexOf("from");   
  394.         Assert.isTrue(beginPos != -1, " hql : " + hql   
  395.                 + " must has a keyword 'from'");   
  396.         return hql.substring(beginPos);   
  397.     }   
  398.   
  399.     /**  
  400.      * 去除hql的orderby 子句，用于pagedQuery.  
  401.      *   
  402.      * @see #pagedQuery(String,int,int,Object[])  
  403.      */  
  404.     private static String removeOrders(String hql) {   
  405.         Assert.hasText(hql);   
  406.         Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*",   
  407.                 Pattern.CASE_INSENSITIVE);   
  408.         Matcher m = p.matcher(hql);   
  409.         StringBuffer sb = new StringBuffer();   
  410.         while (m.find()) {   
  411.             m.appendReplacement(sb, "");   
  412.         }   
  413.         m.appendTail(sb);   
  414.         return sb.toString();   
  415.     }   
  416.   
  417.     /**  
  418.      * 根据页码和每页的长度返回对象集合  
  419.      *   
  420.      * @param pageNo  
  421.      *            页码  
  422.      * @param pageSize  
  423.      *            每页的长度  
  424.      * @return  
  425.      */  
  426.     public List getObjects(int pageNo, int pageSize) {   
  427.         Criteria criteria = this.createCriteria();   
  428.         return this.pagedQuery(criteria, pageNo, pageSize).getResult();   
  429.     }   
  430. }   

有了这个DAO后，你再让其它的实体DAO继承这个BASEDAO，比如：

java 代码
  1. public class ProductDAO extends HibernateBaseDao {   
  2.     //public void otherMethod(){...}   
  3. }  

就大功告成，所谓的OO，就让泛型帮你完成，烦人的对象转换就此终结。

有兴趣的朋友可以参考springside的源码，它更详细。


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 16 Aug 2007 09:18:00 +0800 http://xianglg.javaeye.com/blog/112902 http://xianglg.javaeye.com/blog/112902 struts2+hibernate+spring配置管理（二）——DAO层（一） xianglg 作者: xianglg  链接：http://xianglg.javaeye.com/blog/112622  发表时间: 2007年08月15日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

前面时间一直忙于赶项目，忽略了Struts2+hibernate+spring这个系列只是开了个头，所以赶紧把以前的代码翻出来，整理了一下，就接着讲DAO层吧。

首先我们一起讨论一下DAO层的设计，一般来说，有这样两种设计：

java 代码
  1. public class ADAO(){   
  2.     public void create(A a){   
  3.        ....   
  4.     }   
  5.   
  6.     public void add(A a){   
  7.        ....   
  8.     }   
  9.   
  10.     public void delete(A a){   
  11.        ....   
  12.     }   
  14. }   
  15.   
  16. public class BDAO(){   
  17.     public void create(B b){   
  18.        ....   
  19.     }   
  20.   
  21.     public void add(B b){   
  22.        ....   
  23.     }   
  24.   
  25.     public void delete(B b){   
  26.        ....   
  27.     }   
  28.   
  29.     public void find(B b){   
  30.        ....   
  31.     }   
  32. }   
  33.   
  34. public class CDAO(C c){   
  35.     public void create(){   
  36.        ....   
  37.     }   
  38.   
  39.     public void add(C c){   
  40.        ....   
  41.     }   
  42.   
  43.     public void delete(C c){   
  44.        ....   
  45.     }   
  46.   
  47.     public void find(C c){   
  48.        ....   
  49.     }   
  50. }  

这里一共设计了三个实体DAO，分别为A，B，C，这样的好处是对象的封装思想比较好，每个实体DAO都有自己独立的接口方法，但缺点也显而易见，就是重复代码太多太多。

再看第二种设计思想，以解决前面的缺点：

java 代码
  1. abstract public class BaseDAO{   
  2.     public void create(Object o){      
  3.        ....      
  4.     }      
  5.      
  6.     public void add(Object o){      
  7.        ....      
  8.     }      
  9.      
  10.     public void delete(Object o){      
  11.        ....      
  12.     }   
  13.      
  14.   
  15. }   
  16.   
  17. public class ADAO entends BaseDAO{   
  18.     public void otherMethod(A a){   
  19.         .....   
  20.     }   
  21. }   
  22.   
  23. //other EntityDAO   
  24. .....   

使用这种设计思想，很好的解决了前面的瓶颈，但它也有缺点，破坏了面向对象的封装性。

两个设计思想，我们该如何取舍呢？其实如果了解泛型的话，就迎刃而解了，于是，就有了第三种解决方案如下：

java 代码
  1. abstract public class DAO {      
  2.     public void create (T t)){
  3.        ...
  4.     }    
  5.       
  6.     public void delete (T t)){
  7.        ...
  8.     }    
  9.       
  10.     public void update (T t)){
  11.        ...
  12.     }    
  13.       
  14.     ...   
  15. }      
  16.      
  17. public class ADAO extends BaseDAO {      
  18.     public void otherMethod (A a){
  19.        ...
  20.     }    
  21. }   

注：关于泛型的知识，不是本文所要讲的，如有不解，可查找有关文档寻求帮助。

应该说，我个人比较喜欢第三种解决方案，由于这个项目使用了spring，于是大家应该又能想到让它继承于Spring的HibernateDaoSupport,提供分页函数和若干便捷查询方法，并对返回值作了泛型类型转换。

经过讨论后，大家应该有了比较好的思路了，具体代码碍于篇幅，下一篇贴出。


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 15 Aug 2007 17:53:00 +0800 http://xianglg.javaeye.com/blog/112622 http://xianglg.javaeye.com/blog/112622 修改Struts2默认的模板配置 xianglg 作者: xianglg  链接：http://xianglg.javaeye.com/blog/88171  发表时间: 2007年06月08日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

在用struts2开发项目的时候发现它总是会添加一些html标签在最终生成的html代码中，比如说使用<s:form></s:form>标签，此时生成的html代码如下：

<form ...><table class="wwFormTable"></table></form>

其中蓝色高亮部分是struts自动产生的，对于这些自动产生的东西有时候有用，但是对于有些项目确是不合适的，比如说我们的页面全部不允许加入table标签，或者需要用别的样式单等等，此时我们就希望不要产生这些多余的标签。

那么怎样才能让struts2不要生成这些标签呢？
其实在struts-core-2.06.jar的包中包含了一些默认的模版文件，它们位于$ {struts-core-2.06.jar}/template下，其中有ajax，simple，xhtml等。


查看一下struts.properties,如果没有可以查看$ {struts-core-2.06.jar}/org/apache/struts2/default.properties文件，其中有如下配置：
struts.ui.theme=xhtml
struts.ui.templateDir=template
struts.ui.templateSuffix=ftl

这一段就是关于struts2模版的配置信息，我们可以修改struts.properties文件，将其改成
struts.ui.theme=simple
struts.ui.templateDir=template
struts.ui.templateSuffix=ftl

如果没有struts.properties文件，可以修改struts.xml文件，在其中加入如下行

<constant name="struts.ui.theme" value="simple" />
<constant name="struts.ui.templateDir" value="template" />
<constant name="struts.ui.templateSuffix" value="ftl" />
此时<s:form></s:form>标签生成的html代码将会是<form ...></form>。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 08 Jun 2007 16:13:34 +0800 http://xianglg.javaeye.com/blog/88171 http://xianglg.javaeye.com/blog/88171 struts2+hibernate+spring配置管理（一）——配置文件 xianglg 作者: xianglg  链接：http://xianglg.javaeye.com/blog/87407  发表时间: 2007年06月06日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

虽然是简单的用户登录，但东西一点不少，基于MVC原理实现，共分DAO层，SERVICE层，ACTION层和WEB层，其中DAO和SERVICE层都有各自的接口。

今天主要讲解配置文件的代码，我学习实例，喜欢从控制层出发，然后用到了哪些类或者JSP，再一一扯“蛋”扯出来。

当然，还是先看web.xml

xml 代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4"  
  3.          xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  
  4.     <!-- Spring ApplicationContext配置文件的路径�,可使用通配符，多个路径用�1,号分隔,此参数用于后面的Spring-Context loader -->  
  5.     <context-param>  
  6.         <param-name>contextConfigLocation</param-name>  
  7.         <param-value>classpath*:spring/*.xml</param-value>  
  8.     </context-param>  
  9.   
  10.        
  11.     <!-- 著名 Character Encoding filter -->  
  12.     <filter>  
  13.         <filter-name>encodingFilter</filter-name>  
  14.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
  15.         <init-param>  
  16.             <param-name>encoding</param-name>  
  17.             <param-value>UTF-8</param-value>  
  18.         </init-param>  
  19.     </filter>  
  20.     <!--Hibernate Open Session in View Filter-->  
  21.     <filter>  
  22.         <filter-name>hibernateFilter</filter-name>  
  23.         <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>  
  24.     </filter>  
  25.     <!-- ExtremeTable 导出Excel和Pdf的Filter -->  
  26.     <filter>  
  27.         <filter-name>eXtremeExport</filter-name>  
  28.         <filter-class>org.extremecomponents.table.filter.ExportFilter</filter-class>  
  29.     </filter>  
  30.     <filter-mapping>  
  31.         <filter-name>encodingFilter</filter-name>  
  32.         <url-pattern>*.do</url-pattern>  
  33.     </filter-mapping>  
  34.     <filter-mapping>  
  35.         <filter-name>encodingFilter</filter-name>  
  36.         <url-pattern>*.jsp</url-pattern>  
  37.     </filter-mapping>  
  38.     <filter-mapping>  
  39.         <filter-name>hibernateFilter</filter-name>  
  40.         <url-pattern>*.do</url-pattern>  
  41.     </filter-mapping>  
  42.   
  43.   
  44.     <!--Spring ApplicationContext 载入 -->  
  45.     <listener>  
  46.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  47.     </listener>  
  48.   
  49.     <!-- Spring 刷新Introspector防止内存泄露 -->  
  50.     <listener>  
  51.         <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>  
  52.     </listener>  
  53.   
  54.        
  55.     <!-- session超时定义,单位为分钟 -->  
  56.     <session-config>  
  57.         <session-timeout>10</session-timeout>  
  58.     </session-config>  
  59.   
  60. </web-app>  
  61.   

 

东西很简单，无非是配置一些过滤器呀，监听器的。主要讲一下openSessionInViewFilter吧，假设在你的应用中Hibernate是通过spring 来管理它的session.如果在你的应用中没有使用OpenSessionInViewFilter或者OpenSessionInViewInterceptor。session会在transaction结束后关闭，此时会抛出session is close 的异常。关于这方面的知识，值得大家去找一下相关资料仔细阅读。

strut2.xml

xml 代码
  2.         "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"   
  3.         "http://struts.apache.org/dtds/struts-2.0.dtd">    
  4. <struts >    
  5.     <include file ="struts-default.xml"/>       
  6.        
  7.     <package name ="default" extends ="struts-default">    
  8.         <action name="login" method="login" class="userAction">  
  9.             <result>/login_success.jspresult>  
  10.             <result name="input">/login.jspresult>  
  11.         action>  
  12. package>  
  13.        
  14. struts>  

可能注意到了，这里的Action交给SPRING来管理了。所以我们看一下application.xml的代码吧

xml 代码
  1. xml version=&quo