笨鸟先飞 http://yzc.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 jsp 静态include和动态include yangzhichao 作者: yangzhichao  链接：http://yzc.javaeye.com/blog/177566  发表时间: 2008年03月29日

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

动态INCLUDE
用jsp:include动作实现 <jsp:include page="included.jsp" flush="true" />它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。

静态INCLUDE
用include伪码实现,不会检查所含文件的变化，适用于包含静态页面<%@ include file="included.htm" %>

===================================================================

1. 静态include的结果是把其他jsp引入当前jsp,两者合为一体
动态include的结构是两者独立,直到输出时才合并( 看看jsp生成的java文件就可以知道了)

2.正是因为这样,动态include的jsp文件独立性很强,是一个单独的jsp文件,需要使用的对象,页面设置,都必须有自己创建,当然,还好它和include它的页面的request范围是一致的.

而静态include纯粹是把代码写在外面的一种共享方法,所有的变量都是可以和include它的主文件共享,两者高度紧密结合,不能有变量同名的冲突.而页面设置也可以借用主文件的.
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sat, 29 Mar 2008 11:40:34 +0800 http://yzc.javaeye.com/blog/177566 http://yzc.javaeye.com/blog/177566 网页元素跟随BODY上下滚动JS组件 yangzhichao 作者: yangzhichao  链接：http://yzc.javaeye.com/blog/177365  发表时间: 2008年03月28日

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

UpDownRoller.prototype.uid=100;
 function UpDownRoller(objID,selfName){
   var obj=document.getElementById(objID);
   obj.style.position="relative";
   obj.style.zIndex=this.uid++;
   this.target=obj;
   this.autoRoll=false;
   this.selfName=selfName;
   this.timerID=null;
 }
 UpDownRoller.prototype.setAutoRoll=function(b){
   if(this.autoRoll==b){
      return null;
   }
   this.autoRoll=b;
   if(b){
     if(this.timerID){
        window.clearInterval(this.timerID);
     }
     this.timerID=window.setInterval(this.selfName+".roll()",10);
   }else{
     this.target.style.pixelTop=0;
   }
 }
 UpDownRoller.prototype.roll=function(){
   if(!this.autoRoll){
       return false;
   }
   var t=this.target;
   t.style.pixelTop=document.body.scrollTop;
 }
 if(document.getElementById("floater")){
   var ft=new UpDownRoller("floater","ft");
   ft.setAutoRoll(true);
 }

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


JavaEye推荐



]]> Fri, 28 Mar 2008 17:19:25 +0800 http://yzc.javaeye.com/blog/177365 http://yzc.javaeye.com/blog/177365 基于数据库的无限级树形结构后台（非递归遍历节点，通过增加维护节点PATH字段） yangzhichao 作者: yangzhichao  链接：http://yzc.javaeye.com/blog/177355  发表时间: 2008年03月28日

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

/**
 * 
 * @author yangzhichao
 *
 * @param <PK>
 * @param <T>
 */
public interface TreeNode<PK extends Number, T extends TreeNode<PK, T>> extends
		Serializable {
	public static final String DEFAULT_PATH_SEPARATOR = "-";

	/**
	 * 节点标识
	 * 
	 * @return
	 */
	PK getId();

	/**
	 * 节点名字
	 * 
	 * @return
	 */
	String getName();

	/**
	 * 获取直接父节点对象
	 * 
	 * @return 直接上级对象
	 */
	T getParent();

	/**
	 * 设置父节点
	 * 
	 * @param t
	 */
	void setParent(T t);

	/**
	 * 获取路径
	 * 
	 * @return
	 */
	String getPath();

	/**
	 * 
	 * @param path
	 * @return
	 */
	void setPath(String path);

	/**
	 * 是否为叶节点
	 * 
	 * @return 返回所有叶节点
	 */
	boolean isLeaf();

	/**
	 * 判断是否为指定节点的父节点
	 * 
	 * @param child
	 *            被判断的节点
	 * @return
	 */
	boolean isParentOf(T child);

	/**
	 * 判断是否为指定节点的子节点
	 * 
	 * @param parent
	 *            被判断的节点对象
	 * @return
	 */
	boolean isChildOf(T parent);

	/**
	 * 节点是否有效
	 * 
	 * @return
	 */
	boolean isValid();

	/**
	 * 获取子节点
	 * 
	 * @return
	 */
	Collection<T> getChildren();

	/**
	 * 节点类别
	 * 
	 * @return
	 */
	@SuppressWarnings("unchecked")
	Class getClazz();

	/**
	 * 状态
	 * 
	 * @return
	 */
	int getStatus();
}



/**
 * 树型抽象实现
 * 
 * @author yangzhichao
 * 
 */
public abstract class AbstractTreeNode<PK extends Number, T extends AbstractTreeNode<PK, T>>
		implements TreeNode<PK, T> {
	/**
	 * 标识
	 */
	private PK id;
	/**
	 * 名字
	 */
	private String name;
	/**
	 * 上级节点
	 */
	private T parent;
	/**
	 * 路径
	 */
	private String path;
	/**
	 * 直接子节点集合
	 */
	private Collection<T> children;
	/**
	 * 序号
	 */
	private int order;

	public boolean isChildOf(T parent) {
		return parent == null || this.getParent() == null ? false : this
				.getParent().equals(parent);
	}

	public boolean isParentOf(T child) {
		return child == null || child.getParent() == null ? false : this
				.equals(child.getParent());
	}

	/**
	 * 默认根据是否有子节点判断
	 */
	public boolean isLeaf() {
		return !(this.getChildren() != null && this.getChildren().size() > 0);
	}

	@SuppressWarnings("unchecked")
	public boolean equals(Object object) {
		if (!(object instanceof AbstractTreeNode)) {
			return false;
		}
		AbstractTreeNode o = (AbstractTreeNode) object;
		// 类型和ID要一致
		return new EqualsBuilder().append(this.getClazz().getName(),
				o.getClazz().getName()).append(this.getId(), o.getId())
				.isEquals();
	}

	public PK getId() {
		return id;
	}

	public void setId(PK id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPath() {
		return path;
	}

	public void setPath(String path) {
		this.path = path;
	}

	public T getParent() {
		return parent;
	}

	public void setParent(T parent) {
		this.parent = parent;
	}

	public Collection<T> getChildren() {
		return children;
	}

	public void setChildren(Collection<T> children) {
		this.children = children;
	}

	public int getOrder() {
		return order;
	}

	public void setOrder(int order) {
		this.order = order;
	}
}



/**
 * 树型DAO接口
 * 
 * @author yangzhichao
 * 
 * @param <PK>
 * @param <T>
 */
public interface TreeNodeDao<PK extends Number, T extends TreeNode<PK, T>>
		extends BaseDao<PK, T> {
	/**
	 * 获取父亲节点
	 * 
	 * @param t
	 * @return
	 */
	T getParent(T t) throws DataAccessException;

	/**
	 * 获取直接子节点
	 * 
	 * @param t
	 * @return
	 * @throws DataAccessException
	 */
	Collection<T> getDirectChildren(T t) throws DataAccessException;

	/**
	 * 获取直接子枝干
	 * 
	 * @param t
	 * @return
	 */
	Collection<T> getDirectBranches(T t) throws DataAccessException;

	/**
	 * 获取直接叶子节点
	 * 
	 * @param t
	 * @return
	 */
	Collection<T> getDirectLeaves(T t) throws DataAccessException;

	/**
	 * 获取所有孩子
	 * 
	 * @param t
	 * @return
	 * @throws DataAccessException
	 */
	Collection<T> getAllChildren(T t) throws DataAccessException;

	/**
	 * 通过PATH获取所有子节点
	 * 
	 * @param t
	 * @return
	 * @throws DataAccessException
	 */
	Collection<T> getAllChildrenByPath(T t) throws DataAccessException;

	/**
	 * 通过PATH获取所有子枝干
	 * 
	 * @param t
	 * @return
	 * @throws DataAccessException
	 */
	Collection<T> getAllBranchesByPath(T t) throws DataAccessException;

	/**
	 * 通过PATH获取所有子叶子
	 * 
	 * @param t
	 * @return
	 * @throws DataAccessException
	 */
	Collection<T> getAllLeavesByPath(T t) throws DataAccessException;

	/**
	 * 通过PATH获取所有父节点
	 * 
	 * @param t
	 * @return
	 */
	Collection<T> getAllParentByPath(T t) throws DataAccessException;

	/**
	 * 通过PATH获取到ROOT节点为止(包含ROOT)的所有父亲节点
	 * 
	 * @param t
	 * @param root
	 * @return
	 */
	Collection<T> getAllParentByPath(T t, T root) throws DataAccessException;

	/**
	 * 更新所有path属性包含oldPath子串的节点的path属性的oldPath子串为newPath
	 * 
	 * @param oldPath
	 * @param newPath
	 * @throws DataAccessException
	 */
	void updatePath(Class<T> clazz, String oldPath, String newPath)
			throws DataAccessException;
}



/**
 * 
 * @author yangzhichao
 * 
 * @param <PK>
 * @param <T>
 */
public abstract class HibernateTreeNodeDao<PK extends Number, T extends TreeNode<PK, T>>
		extends SpringHibernateDao<PK, T> implements TreeNodeDao<PK, T> {

	/**
	 * 根据ID字符串和类别获取对象
	 * 
	 * @param id
	 * @param c
	 * @return
	 */
	protected abstract T get(String id, Class<T> c);

	@SuppressWarnings("unchecked")
	public Collection<T> getAllParentByPath(T t) {
		ArrayList<T> parents = new ArrayList<T>();
		for (String parentID : t.getPath().trim().split("-")) {
			if (parentID != null && !parentID.trim().equals("")
					&& !parentID.trim().equals("-")) {
				parents.add(this.get(parentID, (Class<T>) t.getClazz()));
			}
		}
		return parents;
	}

	@SuppressWarnings("unchecked")
	public Collection<T> getAllParentByPath(T t, T root) {
		ArrayList<T> parents = new ArrayList<T>();
		for (String parentID : t.getPath().trim().split("-")) {
			if (parentID != null && !parentID.trim().equals("")
					&& !parentID.trim().equals("-")) {
				parents.add(this.get(parentID, (Class<T>) t.getClazz()));
				if (root.getId().toString().equals(parentID.trim())) {
					break;
				}
			}
		}
		return parents;
	}

	public T getParent(T t) {
		return t.getParent();
	}

	/**
	 * 路径分隔符
	 */
	public String getPathSeparator() {
		return TreeNode.DEFAULT_PATH_SEPARATOR;
	}

	/**
	 * 设置节点t的路径
	 * 
	 * @param t
	 */
	private void setPath(T t) {
		// 设置路径
		if (t.getParent() == null) {
			t.setPath("-");
		} else {
			t.setPath(t.getParent().getPath() + t.getParent().getId()
					+ this.getPathSeparator());
		}
	}

	/**
	 * 插入
	 * 
	 * @throws
	 */
	@Transactional(readOnly = false, propagation = Propagation.REQUIRED, rollbackFor = DataAccessException.class)
	public void insert(T t) throws DataAccessException {
		this.setPath(t);
		super.insert(t);
	}

	/**
	 * 更新
	 * 
	 * @throws
	 */
	@Transactional(readOnly = false, propagation = Propagation.REQUIRED, rollbackFor = DataAccessException.class)
	public void update(T t) throws DataAccessException {
		boolean parentChanged = false;
		T old = this.get(t.getId(), t.getClazz());
		T oldParent = this.getParent(old);
		if (oldParent != null && !oldParent.equals(t.getParent())
				|| (oldParent == null && t.getParent() != null)) {
			// 上级节点改变
			parentChanged = true;
		}
		// 清除旧副本，不然保存时候会找到两个同一ID的对象会报错
		this.getHibernateTemplate().evict(old);
		if (parentChanged) {
			if (t.getParent() != null
					&& t.getParent().getPath() != null
					&& t.getParent().getPath().indexOf("-"+t.getId().toString()+"-") != -1) {
				throw new DataAccessException(this.getClass(),
						"不能选择子节点作为当前节点的父节点");
			}
			if (t.getParent() != null && t.getParent().equals(t)) {
				throw new DataAccessException(this.getClass(),
						"不能选择本身作为当前节点的父节点");
			}
			// 设置路径
			this.setPath(t);
			// 重新设置所有子节点路径
			this.updatePath(t.getClazz(), old.getPath(), t.getPath());
		}
		super.update(t);
	}

	/**
	 * 更新路径，当某节点上级节点改变时候调用
	 * 
	 * @throws DataAccessException
	 */
	@Transactional(readOnly = false, propagation = Propagation.REQUIRED,rollbackFor = DataAccessException.class)
	public void updatePath(final Class<T> clazz, String oldPath, String newPath)
			throws DataAccessException {
		if (oldPath == null || oldPath.trim().length() < 1
				|| oldPath.trim().equals("-")) {
			return;
		}
		if (newPath == null || newPath.trim().length() < 1) {
			newPath = "-";
		}
		if (oldPath.charAt(0) != '-') {
			oldPath = "-" + oldPath;
		}
		if (oldPath.charAt(oldPath.length() - 1) != '-') {
			oldPath = oldPath + "-";
		}
		if (newPath.charAt(0) != '-') {
			newPath = "-" + newPath;
		}
		if (newPath.charAt(newPath.length() - 1) != '-') {
			newPath = newPath + "-";
		}
		final String newPathTemp = newPath;
		final String oldPathTemp = oldPath;
		try {
			this.getHibernateTemplate().execute(new HibernateCallback() {
				public Object doInHibernate(Session session)
						throws HibernateException, SQLException {
					StringBuilder hql = new StringBuilder();
					hql.append(" update ");
					hql.append(clazz.getName());
					hql.append(" o ");
					hql.append(" set o.path=replace(o.path,:oldPath");
					hql.append(",:newPath");
					hql.append(")");
					hql.append(" where o.path like :oldPathLike ");
					Query query = session.createQuery(hql.toString());
					query.setString("oldPath", oldPathTemp.trim()).setString(
							"newPath", newPathTemp.trim()).setString(
							"oldPathLike", "%" + oldPathTemp.trim() + "%")
							.executeUpdate();
					return null;
				}
			});
		} catch (Exception e1) {
			throw new DataAccessException(this.getClass(), "更新路径失败", e1);
		}
	}

	public Collection<T> getAllChildren(T t) throws DataAccessException {
		return this.getAllChildrenByPath(t);
	}

	public Collection<T> getAllChildrenByPath(T t) throws DataAccessException {
		HibernateCriteriaQuery query = new HibernateCriteriaQuery();
		DetachedCriteria dc = DetachedCriteria.forClass(t.getClazz());
		dc.add(Restrictions.like("path", "%-" + t.getId().toString() + "-%"));
		query.setQuery(dc);
		return this.find(query);
	}

	public Collection<T> getDirectChildren(T t) throws DataAccessException {
		HibernateCriteriaQuery query = new HibernateCriteriaQuery();
		DetachedCriteria dc = DetachedCriteria.forClass(t.getClazz());
		dc.add(Restrictions.eq("parent", t));
		query.setQuery(dc);
		return this.find(query);
	}
}

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


JavaEye推荐



]]> Fri, 28 Mar 2008 17:00:00 +0800 http://yzc.javaeye.com/blog/177355 http://yzc.javaeye.com/blog/177355 获取网页元素的绝对位置 yangzhichao 作者: yangzhichao  链接：http://yzc.javaeye.com/blog/177105  发表时间: 2008年03月28日

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

function fGetXY(obj){
var oTmp = obj;
if(!oTmp||(typeOf(oTmp.offsetLeft) == "undefined")
||(typeOf(oTmp.offsetTop) == "undefined")
||!oTmp.tagName){
return null;
}
var pt = new Point(0,0);
do{
pt.x += oTmp.offsetLeft;
pt.y += oTmp.offsetTop;
oTmp = oTmp.offsetParent;
} while(oTmp.tagName!="BODY");
return pt;
}

function Point(iX, iY){
this.x = iX;
this.y = iY;
}
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 28 Mar 2008 08:54:06 +0800 http://yzc.javaeye.com/blog/177105 http://yzc.javaeye.com/blog/177105 面向对象设计准则 yangzhichao 作者: yangzhichao  链接：http://yzc.javaeye.com/blog/177100  发表时间: 2008年03月28日

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

摘抄自《敏捷软件开发-原则、方法与实践》-Robert C. Martin


(1)SRP 单一职责原则
就一个类而言，应该仅有一个引起它变化的原因。
职责即为"变化的原因".

(2)OCP 开放封闭原则
软件实体（类、模块、函数等）应该是可以扩展的，但是不可修改。
对于扩展是开放的,对于更改是封闭的.
关键是抽象.将一个功能的通用部分和实现细节部分清晰的分离开来.
开发人员应该仅仅对程序中呈现出频繁变化的那些部分作出抽象.拒绝不成熟的抽象和抽象本身一样重要.

(3)LSP Liskov替换原则
子类型必须能替换掉他们的基本类型

(4)DIP 依赖倒置原则
抽象不应该依赖于细节。细节应该依赖于抽象。
Hollywood原则: "Don't call us, we'll call you".程序中所有的依赖关系都应该终止于抽象类和接口。针对接口而非实现编程。
任何变量都不应该持有一个指向具体类的指针或引用。
任何类都不应该从具体类派生。
任何方法都不应该覆写他的任何基类中的已经实现了的方法。

(5)ISP 接口隔离原则
不应该强迫客户依赖于他们不用的方法。接口属于客户，不属于他所在的类层次结构。
多个面向特定用户的接口胜于一个通用接口。

(6)REP 重用发布等价原则
重用的粒度就是发布的粒度.

(7)CCP 共同重用原则
一个包中的所有类应该是共同重用的。如果重用了包中的一个类，那么就要重用包中的所有类。
相互之间没有紧密联系的类不应该在同一个包中。

(8)CRP 共同封闭原则
包中的所有类对于同一类性质的变化应该是共同封闭的。一个变化若对一个包影响，则将对包中的所有类产生影响，而对其他的包不造成任何影响.

(9)ADP 无依赖原则
在包的依赖关系中不允许存在环.
细节不应该被依赖.

(10)SDP 稳定依赖原则
朝着稳定的方向进行依赖.
应该把封装系统高层设计的软件（比如抽象类）放进稳定的包中，不稳定的包中应该只包含那些很可能会改变的软件（比如具体类）。

(11)SAP 稳定抽象原则
包的抽象程度应该和其他稳定程度一致.
一个稳定的包应该也是抽象的，一个不稳定的包应该是抽象的.

(12)DAP(Default Abstraction Principle)缺省抽象原则
在接口和实现接口的类之间引入一个抽象类,这个类实现了接口的大部分操作.

(13)IDP(Interface Design Principle)接口设计原则
规划一个接口而不是实现一个接口。

(14)BBP(Black Box Principle)黑盒原则
多用类的聚合，少用类的继承。

(15)DCSP(Don't Concrete Supperclass Principle)不要构造具体的超类原则
避免维护具体的超类。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 28 Mar 2008 08:37:01 +0800 http://yzc.javaeye.com/blog/177100 http://yzc.javaeye.com/blog/177100 纯CSS的TIP实现 yangzhichao 作者: yangzhichao  链接：http://yzc.javaeye.com/blog/176938  发表时间: 2008年03月27日

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

<html>
<head>
<style>
.tipable {
position:absolute;
color: #0000cc;
text-decoration: none!important;
font-size: 12px;
}
.tipable:hover {
background: none;
}

.tipable span {
display: none;
}

.tipable:hover span {
display: block;
position:absolute;
border:1px solid #640000;
background: #FFFFCC;
color:#000;
padding:5px;
left:20px;
top:20px;
white-space:nowrap;
}
</style>
</head>
<body>
<a href="javascript:void(null)" class="tipable">查看提示
<span>这是提示!</span>
</a>
</body>
</html>
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 27 Mar 2008 16:56:32 +0800 http://yzc.javaeye.com/blog/176938 http://yzc.javaeye.com/blog/176938