ojdbc14.jar

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

所谓定制化就是在已有的平台基础上根据自己的业务需要进行修改，可以改得面目全非，但核心的东西是不变的，所以说定制化还是相对比较简单的开发，改壳不改核，换汤不换药。但定制化其实也是比较麻烦的，只能称之为麻烦不能称之为难。想想，如果公司让你开发一个新系统B，而这个新系统B和半年前你曾开发过的系统A很相像，是不是要在A的基础上进行定制化来完成B的开发呢？是不是很庆幸B能如此相像于A呢？唉，软件复用？所谓定制化其实就是该补该补，但不同于系统维护，那个更低级。

工欲善其事,必先利其器！

N层深的文件夹组成的包看着都脑大，我建议包不应超过5层文件夹，一个包名而已，用得着起得那么深奥吗？WDK的包也不浅，其实就三件事，Behavior Class, JSP, XML。

WDK Eclipse Plugin, 相信这个软件会让你眼前一亮，你会很开心WDK为定制化准备了这么多可复用的组件，不仅仅是这些，你会不由感慨原来看似复杂的WDK定制化可以如此的愉快。

下面是下载地址：

http://sourceforge.net/project/showfiles.php?group_id=166123

待续................

[转]Configuring WDK Development Environment in Eclipse

Abstract

This configuration guide is for developers who want to use the Eclipse IDE for WDK development. It discusses one approach for configuring Eclipse for WDK development.

Eclipse 3.1

Note: The configuration assumes that you do not have any plugins installed and that you have a base Eclipse install.

• Click on the menu item ‘Windows->Preferences’.
  • From the tree view on the left hand side go to ‘Java->Compiler->Building’.
  • From right hand side unselect (clear) the ‘Scrub output folders…’ checkbox, which is under the ‘Output folder’ section. If this option is enabled then all standard WDK/Webtop classes will be scrubbed by Eclipse and you won’t be able to rebuild them if you don’t have the sources.
  • Click on ‘Ok’.

    

• Click on ‘File->New Project’.
• Select ‘Java Project’ and click on ‘Next’.
  
• You need to create the project in an external location. There should be a ‘Checkbox’ that allows you to select this option and a ‘Browse’ button that allows you to browse-select the external folder.
• Select the WDK/Webtop web application directory as the project folder. For example, <TOMCAT_HOME>\webapps\webtop.
  
• Click on ‘Next’
• Do not select any source folders right now. Leave the defaults.
• Ensure that the output folder has been set to WEB-INF/classes folder. If not, browse and select it explicitly.
  
• Click on ‘Finish’.
• Right click on the new WDK project from the standard tree view in the Java perspective and click on ‘New->Folder’.
  • In the ‘Folder name’ text box, name the folder (e.g wdKClasses). This folder will be added, in a later step, in the classpath of the project so that the existing WDK classes can be referenced.
  • Click on the ‘Advanced’ button (towards bottom of screen) and check (select) the ‘Link to folder in filesystem’ Checkbox. Browse and select the <virtual-root>\WEB-INF\classes folder.
  • The above procedure creates a new folder in the project space that points to the ‘\WEB-INF\classes’ folder.
    
• Right click on the new WDK project from the standard tree view in the Java perspective and click on ‘Properties’.
  • From the list on the left hand side of the ‘Properties’ window click on ‘Java Build Path’.
  • From the tabs on the right hand side select ‘Sources’. Select the PROJECT_NAME\custom\src as one of the source folders. You may add any number of additional source folders.
  • Now select the ‘Libraries’ tab and click on ‘Add External Jars’ button. Add the DFC-related jars and any other jars that you need.
    
  • In the previous step be sure to add the jars that contain the Java servlet and JSP classes. For Tomcat 4.1.30 on our machine, this jar was c:\Tomcat4130\common\lib\servlet.jar. For BEA 8.1 on our machine, this file was c:\bea\weblogic81\server\lib\weblogic.jar. For Tomcat 5.0.28 there are two jars, TOMCAT_HOME\common\lib\servlet-api.jar and TOMCAT_HOME\common\lib\jsp-api.jar
    
  • On the same tab click on the ‘Add Class Folder’ button and add the folder ‘wdkClasses’ that was created previously. This references all WDK\Webtop classes in the classpath.
  • Click on ‘Ok’

After completing this procedure, you can create your own classes and compile them. The results of compilation will directly go into the WEB-INF\classes folder just like the rest of the WDK/Webtop classes. You can also create XML configuration files and JSPs within the IDE using other Eclipse plugins for XML editing and JSP editing respectively.

[转]这样结束,我的eclipse中的webtop/src中就有这样的错误:the type comparable is not generic,it cannot be parameterized with argument.但这暂不影响工作,等用到正则表达式时,在程序中也出现这样的问题.还以为eclipse有问题,后新建工程,单独用正则表达式没问题,那很有可能是webtop中jar包的问题. 经过多次试验,只要删了fileselector1.1.jar就好了.不明白是为什么!!!

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

Use Log4J extensions for debug and error Logging
WDK uses a DFC “Log4J” extension for logging. The configuration of log4j is held in
“$Documentum/Config/log4j.properties”.
Define a “logs” directory and modify log4j.properties to use that path, not the
Documentum default.
Ensure you include your log4j.properties file in any deployment process (see later).
Create your own project log4j appenders and files and add them to the
log4j.properties. Use “debug”, “error” and “fatal” to categorize the error. On
development or problem determination run at “debug”; for production run at
“error”.
Define Coding Standards
For multi developer teams, define coding standards to cover:
• package naming
• error handling
• logging (using the log4j process described above).
Pay attention to the use of locale and resource bundling (strings) to support
internationalization.
Always extend when possible
It can be tempting to copy component definition and behaviour classes. Always
extend unless this proves impossible.
Always remove unchanged XML elements from component definitions.
Use BOF for business logic where possible
• Enables same business logic to be “shared” by multiple applications
• Reduces the changes needed when upgrading

Use WDK Folder paths
Although it is not required, it makes navigation easier to replicate the WDK folder
structure in an application’s folders. This is helpful as WDK developers become
familiar with the default WDK folder structure and can then readily navigate all
custom application structures.
Use a Source Control Repository
There are many good source control repositories, most of which integrate to
common IDEs.
Use source control to hold Java classes, JSP pages, XML component definitions,
log4j.properties, dbor.properties etc. This will also ease deployment problems (see
later).
Select an IDE for productivity
There are many good free IDEs including Netbeans and Eclipse. These greatly
increase the productivity of developers. In particular they allow developers to link to
3rd party source control systems, automate the build and deployment process using
Ant and offer the ability to debug WDK code at runtime.
Use Ant to build, package and deploy
Use Ant scripts to ensure that the application build and deploy process is automated
and consistent. Use Ant to package classes into JARS and to deploy all parts of a
WDK application (including JARs, JSP pages, XML configuration files, dbor and log4j
properties, NLS strings) to both application and content servers.
Control Documentum configuration by using available Ant extensions to install
docapps and run DQL and API scripts.

Consider Development, Integration and Test Environments
For a team of developers, it is advantageous to have individual application servers
for each developer. This allows application servers to be started and stopped
without disturbing other developers.
Having a Development Integration environment will allow regular builds to be made
from the latest code from the source control repository. Controlling the build via
Ant scripts make this quick and repeatable.
The test environment can be built after successful verification of a build on the
development integration environment.
Use WDK component definition XML to hold configuration and default values
The WDK XML component definitions allow new XML elements to be added. The
behaviour class can access this information. This provides a good way to provide
configuration and default values that give components extra flexibility.
Simplify upgrades and document modified WDK XML, JAVA classes and JSP Pages
When developing applications document all components that are extended or
modified. Then when upgrading to a new version of WDK or WebTop use this
information to access the impact of the upgrade.

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

DAO层：主要使用Hibernate实现持久化等相关操作。本着基类足够强大，最好可以包罗万象，避免重发开发Dao的原则，使用范型DAO来处理对数据库进行重复性的80%增删改查操作。
参考代码：

public interface IGenericDao<T, ID extends Serializable> {

	public void saveOrUpdate(T t);

	public T load(Serializable ID);

	public T get(Serializable ID);
	
	public Object get(Class TClass, Serializable ID, LockMode lockMode);

	public boolean contains(T t) throws DataAccessException;

	public void delete(T t, LockMode lockMode) throws DataAccessException;

	public void delete(T t) throws DataAccessException;

	public void deleteAll(Collection<T> entities) throws DataAccessException;

	public List<T> find(String queryString, Object value)
			throws DataAccessException;

	public List<T> find(String queryString, Object[] values)
			throws DataAccessException;

	public List<T> find(String queryString) throws DataAccessException;

	public List<T> findByExample(Object exampleEntity, int firstResult,
			int maxResults) throws DataAccessException;

	public List<T> findByExample(Object exampleEntity)
			throws DataAccessException;

	public List<T> findByNamedParam(String queryString, String paramName,
			Object value) throws DataAccessException;

	public List<T> findByNamedParam(String queryString, String[] paramNames,
			Object[] values) throws DataAccessException;

	public Object load(Class TClass, Serializable ID, LockMode lockMode)
			throws DataAccessException;

	public void load(T t, Serializable ID) throws DataAccessException;

	public Object load(String TName, Serializable ID, LockMode lockMode)
			throws DataAccessException;

	public Object load(String TName, Serializable ID)
			throws DataAccessException;

	public void refresh(T t, LockMode lockMode) throws DataAccessException;

	public void refresh(T t) throws DataAccessException;

	public Serializable save(T t) throws DataAccessException;

	public void saveOrUpdate(String TName, T t) throws DataAccessException;

	public void saveOrUpdateAll(Collection<T> entities)
			throws DataAccessException;

	public void update(T t, LockMode lockMode) throws DataAccessException;

	public void update(T t) throws DataAccessException;

	public void update(String TName, T t, LockMode lockMode)
			throws DataAccessException;

	public void update(String TName, T t) throws DataAccessException;

	public List<T> loadAll();
	
	public List<T> loadAll(Class TClass);

	public List<T> list();
	
	public List<T> list(Class TClass);

	public PaginationSupport findPageByCriteria(
			final DetachedCriteria detachedCriteria, final int pageSize,
			final int startIndex);

	public PaginationSupport findPageByQuery(final String hsql,
			final int pageSize, final int startIndex);

}

@SuppressWarnings("unchecked")
public class GenericDao<T, ID extends Serializable> extends HibernateDaoSupport	implements IGenericDao<T, ID> {
	protected Log logger = LogFactory.getLog(getClass());

	protected Class<T> entityClass;

	public GenericDao() {
		
	}
	protected Class getEntityClass() {
		if (entityClass == null) {
			entityClass = (Class<T>) ((ParameterizedType) getClass()
					.getGenericSuperclass()).getActualTypeArguments()[0];
			logger.debug("T class = " + entityClass.getName());
		}
		return entityClass;
	}

	public void saveOrUpdate(T t) {
		this.getHibernateTemplate().saveOrUpdate(t);
	}

	public T load(Serializable ID) {

		T load = (T) getHibernateTemplate().load(getEntityClass(), ID);
		return load;
	}

	public T get(Serializable ID) {
		T load = (T) getHibernateTemplate().get(getEntityClass(), ID);
		return load;
	}
	
	public Object get(Class TClass,Serializable ID, LockMode lockMode) {
		Object vo = getHibernateTemplate().get(TClass, ID, lockMode);
		return vo;
	}

	public boolean contains(T t) throws DataAccessException {
		return getHibernateTemplate().contains(t);
	}

	public void delete(T t, LockMode lockMode) throws DataAccessException {
		getHibernateTemplate().delete(t, lockMode);
	}

	public void delete(T t) throws DataAccessException {
		getHibernateTemplate().delete(t);
	
	}
	
	public void deleteAll(Collection<T> entities) throws DataAccessException {
		getHibernateTemplate().deleteAll(entities);
	}
	
	public List<T> find(String queryString, Object value)
			throws DataAccessException {
		List<T> find = (List<T>) getHibernateTemplate().find(queryString,
				value);
		return find;
	}

	public List<T> find(String queryString, Object[] values)
			throws DataAccessException {
		List<T> find = (List<T>) getHibernateTemplate().find(queryString,
				values);
		return find;
	}

	public List<T> find(String queryString) throws DataAccessException {
		return (List<T>) getHibernateTemplate().find(queryString);
	}

	public List<T> findByExample(Object exampleEntity, int firstResult,
			int maxResults) throws DataAccessException {
		return getHibernateTemplate().findByExample(exampleEntity, firstResult,
				maxResults);
	}

	public List<T> findByExample(Object exampleEntity) throws DataAccessException {
		return getHibernateTemplate().findByExample(exampleEntity);
	}

	public List<T> findByNamedParam(String queryString, String paramName,
			Object value) throws DataAccessException {
		return getHibernateTemplate().findByNamedParam(queryString, paramName,
				value);
	}

	public List<T> findByNamedParam(String queryString, String[] paramNames,
			Object[] values) throws DataAccessException {
		return getHibernateTemplate().findByNamedParam(queryString, paramNames,
				values);
	}

	public Object load(Class TClass, Serializable ID, LockMode lockMode)
			throws DataAccessException {
		return getHibernateTemplate().load(TClass, ID, lockMode);
	}

	public void load(T t, Serializable ID) throws DataAccessException {
		getHibernateTemplate().load(t, ID);
	}

	public Object load(String TName, Serializable ID, LockMode lockMode)
			throws DataAccessException {
		return getHibernateTemplate().load(TName, ID, lockMode);
	}

	public Object load(String TName, Serializable ID)
			throws DataAccessException {
		return getHibernateTemplate().load(TName, ID);
	}
	
	public Object load(Class TClass, Serializable ID)
			throws DataAccessException {
		return getHibernateTemplate().load(TClass, ID);
	}

	public void refresh(T t, LockMode lockMode) throws DataAccessException {
		getHibernateTemplate().refresh(t, lockMode);
	}

	public void refresh(T t) throws DataAccessException {
		getHibernateTemplate().refresh(t);
	}

	public Serializable save(T t) throws DataAccessException {
		return getHibernateTemplate().save(t);
	}

	public void saveOrUpdate(String TName, T t) throws DataAccessException {
		getHibernateTemplate().saveOrUpdate(TName, t);
	}

	public void saveOrUpdateAll(Collection<T> entities)
			throws DataAccessException {
		getHibernateTemplate().saveOrUpdateAll(entities);
	}

	public void update(T t, LockMode lockMode) throws DataAccessException {
		getHibernateTemplate().update(t, lockMode);
	}

	public void update(T t) throws DataAccessException {
		getHibernateTemplate().update(t);
	}

	public void update(String TName, T t, LockMode lockMode)
			throws DataAccessException {
		getHibernateTemplate().update(TName, t, lockMode);
	}

	public void update(String TName, T t) throws DataAccessException {
		getHibernateTemplate().update(TName, t);
	}

	public List<T> loadAll() {
		return getHibernateTemplate().loadAll(getEntityClass());
	}

	public List<T> loadAll(Class TClass) {
		return getHibernateTemplate().loadAll(TClass);
	}

	public List<T> list() {
		Criteria criteria = getSession().createCriteria(getEntityClass());
		return criteria.list();
	}

	public List<T> list(Class TClass) {
		Criteria criteria = getSession().createCriteria(TClass);
		return criteria.list();
	}

	public PaginationSupport findPageByCriteria(
			final DetachedCriteria detachedCriteria, final int pageSize,
			final int startIndex) {
		return (PaginationSupport) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException {
						Criteria criteria = detachedCriteria
								.getExecutableCriteria(session);
						int totalCount = ((Integer) criteria.setProjection(
								Projections.rowCount()).uniqueResult())
								.intValue();
						criteria.setProjection(null);
						List items = criteria.setFirstResult(startIndex)
								.setMaxResults(pageSize).list();
						PaginationSupport ps = new PaginationSupport(items,
								totalCount, pageSize, startIndex);
						return ps;
					}
				}, true);
	}

	public PaginationSupport findPageByQuery(final String hsql,
			final int pageSize, final int startIndex) {
		return (PaginationSupport) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Query query = session.createQuery(hsql);
						int totalCount = query.list().size();
						query.setFirstResult(startIndex);
						query.setMaxResults(pageSize);
						List items = query.list();
						PaginationSupport ps = new PaginationSupport(items,
								totalCount, pageSize, startIndex);
						return ps;

					}
				}, true);
	}

 VO: 主要使用hibernateSynchronizer工具自动生成，然后根据Hibernate Annotation进行修改。
样例代码：

public class WorklistSetPKVO implements Serializable {

	protected int hashCode = Integer.MIN_VALUE;

	private java.lang.Integer processstatus;
	private java.lang.Integer key;


	public WorklistSetPKVO () {}
	
	public WorklistSetPKVO (
		java.lang.Integer processstatus,
		java.lang.Integer key) {

		this.setProcessstatus(processstatus);
		this.setKey(key);
	}


	/**
	 * Return the value associated with the column: PROCESSSTATUS
	 */
	public java.lang.Integer getProcessstatus () {
		return processstatus;
	}

	/**
	 * Set the value related to the column: PROCESSSTATUS
	 * @param processstatus the PROCESSSTATUS value
	 */
	public void setProcessstatus (java.lang.Integer processstatus) {
		this.processstatus = processstatus;
	}



	/**
	 * Return the value associated with the column: KEY
	 */
	public java.lang.Integer getKey () {
		return key;
	}

	/**
	 * Set the value related to the column: KEY
	 * @param key the KEY value
	 */
	public void setKey (java.lang.Integer key) {
		this.key = key;
	}




	public boolean equals (Object obj) {
		if (null == obj) return false;
		if (!(obj instanceof WorklistSetPKVO)) return false;
		else {
			WorklistSetPKVO mObj = (WorklistSetPKVO) obj;
			if (null != this.getProcessstatus() && null != mObj.getProcessstatus()) {
				if (!this.getProcessstatus().equals(mObj.getProcessstatus())) {
					return false;
				}
			}
			else {
				return false;
			}
			if (null != this.getKey() && null != mObj.getKey()) {
				if (!this.getKey().equals(mObj.getKey())) {
					return false;
				}
			}
			else {
				return false;
			}
			return true;
		}
	}

	public int hashCode () {
		if (Integer.MIN_VALUE == this.hashCode) {
			StringBuilder sb = new StringBuilder();
			if (null != this.getProcessstatus()) {
				sb.append(this.getProcessstatus().hashCode());
				sb.append(":");
			}
			else {
				return super.hashCode();
			}
			if (null != this.getKey()) {
				sb.append(this.getKey().hashCode());
				sb.append(":");
			}
			else {
				return super.hashCode();
			}
			this.hashCode = sb.toString().hashCode();
		}
		return this.hashCode;
	}
}

@Entity
@Table(name="")
public class WorklistSetVO  implements Serializable {


	// constructors
	public WorklistSetVO () {
		initialize();
	}

	/**
	 * Constructor for primary key
	 */
	public WorklistSetVO (WorklistSetPKVO id) {
		this.setId(id);
		initialize();
	}

	protected void initialize () {}



	private int hashCode = Integer.MIN_VALUE;

	// primary key
	private WorklistSetPKVO id;

	// fields
	private java.lang.Integer re;
	private java.lang.Integer upl;
	private java.lang.Integer co;
	private java.lang.Integer lscco;
	private java.lang.Integer lscnonco;



	/**
	 * Return the unique identifier of this class
     * @hibernate.id
     */
	@EmbeddedId
	public WorklistSetPKVO getId () {
		return id;
	}

	/**
	 * Set the unique identifier of this class
	 * @param id the new ID
	 */
	public void setId (WorklistSetPKVO id) {
		this.id = id;
		this.hashCode = Integer.MIN_VALUE;
	}




	/**
	 * Return the value associated with the column: RE
	 */
	public java.lang.Integer getRe () {
		return re;
	}

	/**
	 * Set the value related to the column: RE
	 * @param re the RE value
	 */
	public void setRe (java.lang.Integer re) {
		this.re = re;
	}



	/**
	 * Return the value associated with the column: UPL
	 */
	public java.lang.Integer getUpl () {
		return upl;
	}

	/**
	 * Set the value related to the column: UPL
	 * @param upl the UPL value
	 */
	public void setUpl (java.lang.Integer upl) {
		this.upl = upl;
	}



	/**
	 * Return the value associated with the column: CO
	 */
	public java.lang.Integer getCo () {
		return co;
	}

	/**
	 * Set the value related to the column: CO
	 * @param co the CO value
	 */
	public void setCo (java.lang.Integer co) {
		this.co = co;
	}



	/**
	 * Return the value associated with the column: LSCCO
	 */
	public java.lang.Integer getLscco () {
		return lscco;
	}

	/**
	 * Set the value related to the column: LSCCO
	 * @param lscco the LSCCO value
	 */
	public void setLscco (java.lang.Integer lscco) {
		this.lscco = lscco;
	}



	/**
	 * Return the value associated with the column: LSCNONCO
	 */
	public java.lang.Integer getLscnonco () {
		return lscnonco;
	}

	/**
	 * Set the value related to the column: LSCNONCO
	 * @param lscnonco the LSCNONCO value
	 */
	public void setLscnonco (java.lang.Integer lscnonco) {
		this.lscnonco = lscnonco;
	}




	public boolean equals (Object obj) {
		if (null == obj) return false;
		if (!(obj instanceof WorklistSetVO)) return false;
		else {
			WorklistSetVO worklistSetVO = (WorklistSetVO) obj;
			if (null == this.getId() || null == worklistSetVO.getId()) return false;
			else return (this.getId().equals(worklistSetVO.getId()));
		}
	}

	public int hashCode () {
		if (Integer.MIN_VALUE == this.hashCode) {
			if (null == this.getId()) return super.hashCode();
			else {
				String hashStr = this.getClass().getName() + ":" + this.getId().hashCode();
				this.hashCode = hashStr.hashCode();
			}
		}
		return this.hashCode;
	}


	public String toString () {
		return super.toString();
	}


}

大体结构即是如此。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

基本框架采用JSF – MyFaces(version 1.2.0) + Spring (version 2.5.1)  + Hibernate (version 3.2.5) and Hibernate Annotation (Version 3.3.0) 。

设计模式：MVC。
基本思路：根据MVC模式，将系统进行分层，将开发者进行分工（主要是前台和后台根据接口衔接联调）。JSF用于实现View和Controller。前台开发者只需要关心页面数据的显示（也就是VO属性的显示），页面的跳转和对数据更新操作的成功失败代码，他们操作的也应该只有VO或VO的集合，不应该脱离VO而只操作属性，这样会使得系统很散，逻辑性不强，给后期维护带来不必要的麻烦。他们也不应该关心数据是否准确与完整，不应该对得到的VO属性进行额外的完善。简单的说， 只需要获取--〉显示+页面跳转。Controller层需要调用对应的业务逻辑接口方法（业务逻辑层的接口方法按照业务功能进行命名）。使用Spring对业务逻辑层的事务进行控制。业务逻辑层可以根据需要对Controller层传递过来的参数进行相应的处理，调用DAO层接口方法（DAO层的接口方法按照针对一个业务逻辑方法需要对数据库进行的操作步骤来命名。例如，一个业务逻辑方法需要操作3次数据库，则需要定义三个DAO层接口方法）。在业务逻辑层中，可以对N个PO进行操作，但返回给Controller层的最好只是一个VO。业务逻辑类的划分，我是采用根据业务模块进行划分的，这种分法确实不好，没能很好体现Model层的价值。DAO层分两个包dao.common和dao.individual。 common里面放的是公用的范型DAO。当然，少不了相应的配置文件(faces-config.xml,applicationContext.xml和log4j.properties等)。至此，感觉好像少了Model层，其实是Model层被细化了，Model层分为业务Model(BO,DAO)和数据Model（VO,PO）。
并发控制：对于页面信息量较少的修改，采用Hibernate的乐观锁；对于页面信息量较大的修改，当一个用户进入可修改页面时，对该页面进行锁定，并记录该用户，当其他用户进入该页面时，页面可修改项和按钮被置灰并提示“此页面正在被用户XX锁定，您只能阅览”。
View层：不是很了解，暂不提。
Controller层：主要提下异常处理：

try {   
                       
} catch (Exception e) {   
facesMessage = new FacesMessage(FacesMessage.SEVERITY_ERROR,   
        "ERROR:", ErrorMessage.getErrorString("processing_error"));   
FacesContext.getCurrentInstance().addMessage(null, facesMessage);   
logger.error(ExceptionUtils.getFullStackTrace(e));   
return SettlementConstants.FORWARD_ERROR;   
}  

业务逻辑层：
applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>  
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"   
                       "http://www.springframework.org/dtd/spring-beans.dtd">  
<beans>  
 <!--  RESOURCE DEFINITIONS  -->  
 <bean class="org.springframework.jndi.JndiObjectFactoryBean" id="dataSource">  
  <property name="jndiName" value=""/>  
 </bean>  
 <bean  
  class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean" id="sessionFactory">  
  <property name="configurationClass">  
   <value>org.hibernate.cfg.AnnotationConfiguration</value>  
  </property>  
  <property name="dataSource">  
   <ref bean="dataSource"/>  
  </property>  
  <property name="annotatedPackages">  
   <list>  
    <value></value>  
   </list>  
  </property>  
  <property name="annotatedClasses">  
   <list>  
    <value></value>  
   </list>  
  </property>  
  <property name="hibernateProperties">  
   <props>  
    <prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>  
    <prop key="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory</prop>  
    <prop key="hibernate.connection.release_mode">auto</prop>  
    <prop key="hibernate.transaction.auto_close_session">false</prop>  
    <prop key="hibernate.connection.autocommit">false</prop>  
    <prop key="hibernate.show_sql">false</prop>  
   </props>  
  </property>  
 </bean>  
 <bean  
  class="org.springframework.orm.hibernate3.HibernateTransactionManager" id="sssTxManager">  
  <property name="sessionFactory">  
   <ref bean="sessionFactory"/>  
  </property>  
 </bean>  
 <bean abstract="true"  
  class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" id="baseTxBO">  
  <property name="transactionManager" ref="sssTxManager"/>  
  <property name="proxyTargetClass" value="true"/>  
  <property name="transactionAttributes">  
   <props>  
    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>  
    <prop key="save*">PROPAGATION_REQUIRED</prop>  
    <prop key="update*">PROPAGATION_REQUIRED</prop>  
    <prop key="remove*">PROPAGATION_REQUIRED</prop>  
    <prop key="*">PROPAGATION_REQUIRED</prop>  
   </props>  
  </property>  
 </bean>  
 <!--  BO DEFINITIONS  -->  
  
 <bean id="managerMenuBO" parent="baseTxBO">  
  <property name="target">  
   <bean class="ManagerMenuBOImpl">  
    <property name="genericDao">  
     <ref bean="genericDao"/>  
    </property>  
    <property name="managerMenuDAO">  
     <ref bean="managerMenuDAO"/>  
    </property>  
    <property name="settleAppJDBCSupportDAO">  
     <ref bean="settleAppJDBCSupportDAO"/>  
    </property>  
   </bean>  
  </property>  
 </bean>  
  
 <bean id="dropdownListBO" parent="baseTxBO">  
  <property name="target">  
   <bean class="DropdownListBOImpl">  
    <property name="dropdownListDAO">  
     <ref bean="dropdownListDAO"/>  
    </property>  
   </bean>  
  </property>  
 </bean>  
 <!--  DAO DEFINITIONS  -->  
 <bean class="GenericDao" id="genericDao">  
  <property name="sessionFactory">  
   <ref bean="sessionFactory"/>  
  </property>  
 </bean>  
  
 <bean class="ManagerMenuDAOImpl" id="managerMenuDAO" parent="genericDao"/>     
 <bean class="DropdownListDAOImpl" id="dropdownListDAO" parent="genericDao"/>  
    
 <bean class="SettleAppJDBCSupportDAOImpl" id="settleAppJDBCSupportDAO">  
  <property name="dataSource">  
   <ref bean="dataSource"/>  
  </property>  
 </bean>  
</beans>  

  样例代码：

public interface ManagerMenuBO {   
    // User Authority Application Screen start   
    public List<UserAuthorityVO> getUserAuthorityList();   
    public boolean getUserInTemp(String soeid);   
    public boolean getUserInfo(String soeid);   
    public void saveUserAuthorityTemp(UserAuthorityTempVO userAuthorityTempVO);   
    // User Authority Application Screen end   
       
    // User Authority Update Review Screen start   
    public List<UserAuthorityTempVO> getUserAuthorityTempList(String appType, String updater);   
    public void updateUserAuthorityTemp(List<UserAuthorityTempVO> list, String appType, String reviewType);   
    // User Authority Update Review Screen end   
       
    // Worklist Set   
    public List<WorklistSetVO> getWorklistSet();   
    public void saveWorklistSet(List<WorklistSetVO> list);   
       
    // Contact Table Set   
    public List<ContactTableVO> getContactTableSet();   
    public void saveContactTableSet(List<ContactTableVO> list);   
       
    // Matrix Set   
    public List<MatrixSetVO> getMatrixSet();   
    public void saveMatrixSet(MatrixSetVO matrixSetVO);   
       
    // Data Extraction   
    public HashMap getDataExtraction(Date startDate, Date endDate);   
       
    // Manual Batch Last Update Date   
    public HashMap getMBLastUpdateDate();   
       
    // Manual Batch Execute   
    public String doMBExcete();   
  
}  

@SuppressWarnings("unchecked")   
public class ManagerMenuBOImpl implements ManagerMenuBO {   
       
    private IGenericDao genericDao;   
  
    public IGenericDao getGenericDao() {   
        return genericDao;   
    }   
  
    public void setGenericDao(IGenericDao genericDao) {   
        this.genericDao = genericDao;   
    }   
       
    private ManagerMenuDAO managerMenuDAO;   
           
    public ManagerMenuDAO getManagerMenuDAO() {   
        return managerMenuDAO;   
    }   
  
    public void setManagerMenuDAO(ManagerMenuDAO managerMenuDAO) {   
        this.managerMenuDAO = managerMenuDAO;   
    }   
       
    private SettleAppJDBCSupportDAO settleAppJDBCSupportDAO;   
       
    public SettleAppJDBCSupportDAO getSettleAppJDBCSupportDAO() {   
        return settleAppJDBCSupportDAO;   
    }   
  
    public void setSettleAppJDBCSupportDAO(   
            SettleAppJDBCSupportDAO settleAppJDBCSupportDAO) {   
        this.settleAppJDBCSupportDAO = settleAppJDBCSupportDAO;   
    }   
  
    // User Authority Application Screen start   
    public List<UserAuthorityVO> getUserAuthorityList(){   
        return genericDao.list(UserAuthorityVO.class);   
    }   
       
    public boolean getUserInTemp(String soeid){   
        UserAuthorityTempVO userAuthorityTempVO = (UserAuthorityTempVO)genericDao.get(UserAuthorityTempVO.class, soeid, LockMode.NONE);   
        if(userAuthorityTempVO == null){   
            return false;   
        }   
        else{   
            return true;   
        }   
    }   
       
    public boolean getUserInfo(String soeid){   
        UserAuthorityVO userAuthorityVO = (UserAuthorityVO)genericDao.get(UserAuthorityVO.class, soeid, LockMode.NONE);   
        if(userAuthorityVO == null){   
            return false;   
        }   
        else{   
            return true;   
        }   
    }   
       
    public void saveUserAuthorityTemp(UserAuthorityTempVO userAuthorityTempVO){   
        genericDao.saveOrUpdate(userAuthorityTempVO);   
    }   
    // User Authority Application Screen end   
       
    // User Authority Update Review Screen start   
    public List<UserAuthorityTempVO> getUserAuthorityTempList(String appType, String updater){   
        return managerMenuDAO.getUserAuthorityTempList(appType, updater);   
    }   
       
    public void updateUserAuthorityTemp(List<UserAuthorityTempVO> list, String appType, String reviewType){   
        managerMenuDAO.updateUserAuthorityTemp(list, appType, reviewType);     
    }   
    // User Authority Update Review Screen end   
       
    // Worklist Set   
    public List<WorklistSetVO> getWorklistSet(){     
        return genericDao.loadAll(WorklistSetVO.class);   
    }   
       
    public void saveWorklistSet(List<WorklistSetVO> list){   
        int j = list.size();   
        for(int i=0; i<j; i++){   
            WorklistSetVO worklistSetVO = list.get(i);   
            genericDao.saveOrUpdate(worklistSetVO);   
        }   
    }   
       
    //   Contact Table Set   
    public List<ContactTableVO> getContactTableSet(){   
        return genericDao.loadAll(ContactTableVO.class);   
    }   
       
    public void saveContactTableSet(List<ContactTableVO> list){   
        int j = list.size();   
        for(int i=0; i<j; i++){   
            ContactTableVO contactTableVO = list.get(i);   
            genericDao.saveOrUpdate(contactTableVO);   
        }   
    }   
       
    //   Matrix Set   
    public List<MatrixSetVO> getMatrixSet(){   
        return genericDao.loadAll(MatrixSetVO.class);   
    }   
       
    public void saveMatrixSet(MatrixSetVO matrixSetVO){   
        genericDao.saveOrUpdate(matrixSetVO);   
    }   
       
    //   Data Extraction   
    public HashMap getDataExtraction(Date startDate, Date endDate){   
        return managerMenuDAO.getDataExtraction(startDate, endDate);   
    }   
       
    // Manual Batch Last Update Date   
    public HashMap getMBLastUpdateDate(){   
        return settleAppJDBCSupportDAO.getMBLastUpdateDate();   
    }   
       
    // Manual Batch Execute   
    public String doMBExcete(){   
        return settleAppJDBCSupportDAO.doMBExcete();   
    }   
       
}  

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

1,事业永远第一
　　虽然金钱不是万能的,但没有钱是万万不能的,虽然这句话很俗,但绝对有道理,所以30岁之前,请把你大部分精力放在你的事业上.

2,别把钱看得太重
　　不要抱怨自己现在工资低,银行存款4位数以下,看不到前途,现在要做的就是努力学习,即使你文凭再高,怎么把理论运用到实践还是需要一个很长的锻炼过程,社会永远是一所最博大的大学,它让你学到的知识远比你在学校学到的重要得多,所以同样,你也别太介意学历低.30岁之前靠自己能力买车买房的人还是极少.

3,学会体谅父母
　　别嫌他们唠叨,等你为人父了你就知道可怜天下父母心,在他们眼里你还是个孩子,但他们真的老了,现在得你哄他们开心了,也许只要你的一个电话,一点小礼物,就可以让他们安心,很容易做到.

4,交上好朋友
　　朋友对你一生都影响重大,不要去结识太多酒肉朋友,至少得有一个能在关键时刻帮助你的朋友,如果遇到这么一个人,就好好把握,日后必定有用,不管他现在是富还是穷.

5,别太相信爱情
　　心中要有爱,但请别说也别相信那些琼瑶阿姨小说里面的山盟海誓,世上本无永恒,重要的是责任,但女人心海底针,心变了,一切都成枉然,你要做的就是该出手时就出手,该放手时别犹豫.30岁之前的爱情不是假的,但只是大多数人都没有能真正把握好的能力,所以学会量力而行.

6,别担心至今还保留初吻
　　爱情不在多而在精,别以为自己20多岁还没碰过女孩子就害怕自己永远找不到老婆.以后你会有很多机会认识女孩子,要知道这个社会虽然男人多于女人,但现实是女人其实比男人更担心这个问题.男人30一枝花,你在升值而不是贬值,成熟的爱情往往更美丽更长久,所以不要像疯狗一样看到女孩就想追,学会品味寂寞.

7,不要沉迷于任何东西
　　所谓玩物而丧志,网络游戏是你在出校门之前玩的,你现在没有多余的时间和精力花费到这上面,否则你透支的东西以后都得偿还.一个人要有兴趣,爱好,但请分清楚轻重.

8,年轻没有失败
　　不要遇到挫折就灰心,年轻人要时刻保持积极向上的态度.失败了,重来过;失去了，再争取别的。错过了，要分析，下次来,要把握；幼稚了，下次，成熟点。不要紧，会好的，哪怕到了极点，也不要放弃，相信一定可以挺过去。不要消极，会好的。曾经的错，过去了，总不能回味在过去。现在的，很好，累完了，很舒服。不要伤，总会有人在支撑你。

9,不要轻易崇拜或者鄙视一个人
　　人都有偶像,但请拥有你自己的个性.不要刻意去模仿一个人,因为你就是你,是唯一的,独一无二的,要有自信.也不要全盘否定一个人,每个人是有价值的,如果你不能理解他,也请学会接受.

10,要有责任心.
　　不管你曾经怎样,但请从现在开始做一个正直的人.男人要有责任心,无论是工作还是生活上,一个有责任心的人才能让别人有安全感,才能让别人觉得你是一个值得信赖的人.我们不要懦弱,但请不要伤害爱你的人和你爱的人,尤其是善良的女孩,因为这个世界善良的女孩不多了,即使不想拥有,但也请让她保持她美丽的心.

11,男人的外貌并不重要.
　　不要为自己的长相身高而过分担心,一个心地善良,为人正直的男人远比那些空有英俊相貌,挺拔身材但内心龌龊的男人要帅得多.如果有人以貌取人,请不要太在意,因为你不用去为一个低级趣味的人而难过.

12,学会保护身体
　　不要以为现在抽烟喝酒,熬夜通宵也没什么事.那是因为你的身体正处于你一生的黄金时段.30岁以后你就能明白力不从心这个词的意义了,身体是革命的本钱,没有好的身体什么也做不了,所以要尽量让自己过有规律的健康生活.

13,别觉得一事无成.
　　你现在还没有资格谈成功,当然如果你有千万资产的除外.一开始太固定的职业并不一定是好事,或许在不断的改行当中,你会学到更丰富的知识,而且可以挖掘出自己的潜能,找到最适合你的工作.

14,请认真工作
　　即使你现在的工作再怎么无聊再怎么低级,也请你认真去对待,要知道任何成功人士都是从最小的事做起,或许你现在学不到多么了不起的知识,但起码你要学会良好的工作态度和工作方法,这对以后很重要.

15,请认真对待感情.
　　不要羡慕那些换女人像换鞋一样的花花公子,逢场作戏的爱情只是让你浪费时间浪费精力,一个人最痛苦的不是找不到爱人,而是心中没有了爱,当你把我爱你 3 个字变成你最容易说的一句话时,那么你在爱情的世界里已经很难找到真正的幸福了.爱情没有公平,总有一个人比对方付出得多,即使没有结果,也别觉得不值, 因为你的付出不光是为了她,也是为了你自己的爱,为爱付出是很可贵的,赞自己一下.

16.请留一点童心
　　在内心深处,哪怕只是一个很小的角落里,请保持一份童心,不是幼稚,但有的时候单纯一点会让你很快乐.所以不要太计较得失,生活本无完美.

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

(Class<T> ) ((ParameterizedType) getClass()   
.getGenericSuperclass()).getActualTypeArguments()[0];  

只有定义的参数类型在编译时而不是运行时，反射泛型参数才会起作用，否则会抛出：

java.lang.Class cannot be cast to java.lang.reflect.ParameterizedType

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

使用Axis，要发布一个Web服务非常简单，简直不能再简单了，尽管看起来过程和相关代码有些长。我这个帖子里用到了这些软件：Axis 1.1、Eclipse 2.1和Eclipse的Tomcat插件2.2（Sysdeo Tomcat plugin）。发布的方法如下：

我要发布的服务是一个图书商店，公布的方法有添加图书addBook、列表图书listBooks、删除图书deleteBook等等，为简单起见这里就只发布一个添加图书方法，因为其他方法的发布是类似的。

1、首先在Eclipse里新建一个名为bookstore的Tomcat工程，注意要安装了前面说的Tomcat插件才有这个选项的。如果没有安装可以建立一个java工程，然后手动建立必要的目录结构（WEB-INF等），并在Tomcat的server.xml里手动增加与项目对应的<context>项。

2、接下来建立图书类（com.bookstore.model.Book），图书有名称、ISDN号和页数三个属性，这是一个Bean类，代码如下：

package com.bookstore.model;

public class Book {
    private String name;
    private String ISDN;
    private int page;

    public String getISDN() {
        return ISDN;
    }

    public String getName() {
        return name;
    }

    public int getPage() {
        return page;
    }

    public void setISDN(String string) {
        ISDN = string;
    }

    public void setName(String string) {
        name = string;
    }

    public void setPage(int i) {
        page = i;
    }

}

3、接下来建立用来提供服务的类（com.bookstore.BookSvc），这个类就是实际的功能类了，它里面只有一个public的addBook()方法，而它的参数只有一个就是要添加的图书。代码如下：

package com.bookstore;

import com.bookstore.model.Book;

public class BookSvc {
    
    public void addBook(Book book){
        //here you save a book into database
        System.out.println("Book has been added.");
    }
}

4、现在，把下载来的Axis解压缩到一个文件夹，这里假设你解到C:\axis-1_1。把C:\axis-1_1\webapps\axis\WEB-INF\lib目录下的所有.jar文件复制到你的这个web应用程序的WEB-INF\lib下，再把C:\axis-1_1\webapps\axis\WEB-INF目录下的web.xml复制到你的web应用程序的WEB-INF下。这个步骤相当于在你的web应用程序中配置了Axis。

5、为了让Axis知道你要发布哪些服务，你得在WEB-INF下建立一个名为server-config.wsdd的文件，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<deployment xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
 <globalConfiguration>
  <parameter name="adminPassword" value="admin"/>
  <parameter name="attachments.Directory" value="C:\eclipse\workspace\bookstore\WEB-INF\attachments"/>
  <parameter name="attachments.implementation" value="org.apache.axis.attachments.AttachmentsImpl"/>
  <parameter name="sendXsiTypes" value="true"/>
  <parameter name="sendMultiRefs" value="true"/>
  <parameter name="sendXMLDeclaration" value="true"/>
  <parameter name="axis.sendMinimizedElements" value="true"/>
  <requestFlow>
   <handler type="java:org.apache.axis.handlers.JWSHandler">
    <parameter name="scope" value="session"/>
   </handler>
   <handler type="java:org.apache.axis.handlers.JWSHandler">
    <parameter name="scope" value="request"/>
    <parameter name="extension" value=".jwr"/>
   </handler>
  </requestFlow>
 </globalConfiguration>
 <handler name="LocalResponder" type="java:org.apache.axis.transport.local.LocalResponder"/>
 <handler name="Authenticate" type="java:org.apache.axis.handlers.SimpleAuthenticationHandler"/>
 <handler name="URLMapper" type="java:org.apache.axis.handlers.http.URLMapper"/>
 <service name="Version" provider="java:RPC">
  <parameter name="allowedMethods" value="getVersion"/>
  <parameter name="className" value="org.apache.axis.Version"/>
 </service>
 <service name="BookSvc" provider="java:RPC">
  <parameter name="allowedMethods" value="*"/>
  <parameter name="className" value="com.bookstore.BookSvc"/>
 </service>
 <service name="AdminService" provider="java:MSG">
  <parameter name="allowedMethods" value="AdminService"/>
  <parameter name="enableRemoteAdmin" value="false"/>
  <parameter name="className" value="org.apache.axis.utils.Admin"/>
  <namespace>http://xml.apache.org/axis/wsdd/</namespace>
 </service>
 <transport name="local">
  <responseFlow>
   <handler type="LocalResponder"/>
  </responseFlow>
 </transport>
 <transport name="http">
  <requestFlow>
   <handler type="URLMapper"/>
   <handler type="java:org.apache.axis.handlers.http.HTTPAuthHandler"/>
  </requestFlow>
 </transport>
</deployment>

这个文件里发布了三个服务：Version、AdminService和我们的BookSvc。还有一个方法可以生成这个文件，好象Axis推荐使用这种生成的方法，就是在同样目录下写一个deploy.wsdd文件（如果不想看可以直接跳到下一步），内容如下：

<deployment xmlns="http://xml.apache.org/axis/wsdd/"
            xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
 <service name="BookSvc" provider="java:RPC">
  <parameter name="className" value="com.bookstore.BookSvc"/>
  <parameter name="allowedMethods" value="*"/>
 </service>
</deployment>

也就是说deploy.wsdd里只包含关于我们的服务的描述，确认Tomcat已经启动，然后在同一目录下用下面这个命令生成server-config.wsdd文件：

java org.apache.axis.client.AdminClient -lhttp://localhost:8080/bookstore/services/AdminService deploy.wsdd

其中bookstore是我这个web应用程序的虚拟路径。

6、重新启动Tomcat，访问路径http://localhost:8080/bookstore/services，就可以看到现在发布了三个Web服务，如下图。点击每个服务后的wsdl链接可以看到对应的WSDL描述。

可以看出，在Axis里书写deploy.wsdd并利用org.apache.axis.client.AdminClient发布，其主要工作就是把<service>标签中的内容添加在server-config.wsdd里，所以一般直接编辑server-config.wsdd文件会更方便一些。不过当你还没有server-config.wsdd文件时，使用deploy.wsdd的方法会更方便些，因为AdminClient会帮你生成一些额外的xml元素（<handler>等等），而这些元素是必要的。

服务发布以后，就可以在IE浏览器里看到它的WSDL，一般是服务的URL后面加一个“?wsdl”，例如添加图书的WSDL可以通过http://localhost:8080/bookstore/services/BookSvc?wsdl看到。至于Java类是以何种规则映射到WSDL的，请参考JAX-RPC规范；WSDL本身的说明见这里；为了搞清生成的WSDL中各种URL格式的名称空间，最好对XML Schema有所了解，我觉得这篇文章还不错。

我们还可以通过IE浏览器直接调用服务，方法是在服务URL后加“method=xxx”，其中xxx是要调用的方法名称。例如可以通过http://localhost:8080/bookstore/services/BookSvc?method=addBook调用添加图书方法，按照我们的服务类，在Tomcat的控制台上应该可以看到打出了“Book has been added.”的字样。

因为添加图书方法的参数是一个自定义类型，所以在IE里调用时不能指定参数值（或者是可以以其他格式指定，但我还不知道）；如果参数是简单类型，就可以指定了。例如我们可以为BookSvc增加一个echo()方法，参数是一个java.lang.String类型的值，如下所示，然后重新编译并启动Tomcat（server-config.wsdd文件不必更改）。

public void echo(String str){
    System.out.println("Hello "+str);
}

在IE里输入http://localhost:8080/bookstore/services/BookSvc?method=echo&str=Mike，就会看到Tomcat的控制台里打出了“Hello Mike”。如果有多个参数，只要把这些参数都列在URL里即可。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

现在，简单解释一下《使用Axis发布简单的Web服务》中发布的Web服务所对应WSDL文档的内容和结构。请注意，同样的Java类在不同的Web服务开发包中得到的WSDL文档不一定完全相同，这里还是以使用Axis的情况作为例子。

虽然比较长，但为了方便起见还是把完整的WSDL贴在下面，然后进行说明。由于我对Web服务的认识还很不够，所以几乎可以肯定会存在一些误解，仅作参考。