我们的思路是先写一个BaseDao，仿照HibernateTemplate，将基本功能全部实现：

public class BaseDao extends HibernateDaoSupport{

    private Log log = LogFactory.getLog(getClass());

    public Session openSession() {
        return SessionFactoryUtils.getSession(getSessionFactory(), false);
    }

    public Object get(Class entityClass, Serializable id) throws DataAccessException {
        Session session = openSession();
        try {
            return session.get(entityClass, id);
        }
        catch (HibernateException ex) {
            throw SessionFactoryUtils.convertHibernateAccessException(ex);
        }
    }

    public Serializable create(Object entity) throws DataAccessException {
        Session session = openSession();
        try {
            return session.save(entity);
        }
        catch (HibernateException ex) {
            throw SessionFactoryUtils.convertHibernateAccessException(ex);
        }
    }

...

其它的DAO，从BaseDao继承出来，这样写其他的DAO，代码就会很少。

从BaseDao继承出来EntityDao，专门负责一般实体的基本操作，会更方便。

public interface EntityDao {

    public Object get(Class entityClass, Serializable id) throws DataAccessException;

    public Object load(Class entityClass, Serializable id) throws DataAccessException;

    public Serializable create(Object entity) throws DataAccessException;
...}

/**
 * Base class for Hibernate DAOs.  This class defines common CRUD methods for
 * child classes to inherit. User Sping AOP Inteceptor
 */
public class EntityDaoImpl extends BaseDao implements EntityDao{

}

为了Transaction的控制，采用AOP的方式：

public interface EntityManager {

    public Object get(Class entityClass, Serializable id);

    public Object load(Class entityClass, Serializable id);

    public Serializable create(Object entity);
...

}

/**
 * Base class for Entity Service. User Sping AOP Inteceptor
 */
public class EntityManagerImpl implements EntityManager {

    private EntityDao entityDao;

    public void setEntityDao(EntityDao entityDao) {
        this.entityDao = entityDao;
    }

    public Object get(Class entityClass, Serializable id) {
        return entityDao.get(entityClass, id);
    }

    public Object load(Class entityClass, Serializable id) {
        return entityDao.load(entityClass, id);
    }
...

}

这样我们就有了一个通用的Hibernate实体引擎，可以对任何Hibernate实体实现基本的增加、修改、删除、查询等。

其它的BusinessService就可以继承EntityManager，快速实现业务逻辑。

具体XML配置如下：

 <!-- Oracle JNDI DataSource for J2EE environments -->
 <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
  <property name="jndiName"><value>java:comp/env/jdbc/testPool</value></property>
 </bean>

 <!-- Hibernate SessionFactory for Oracle -->
 <!-- Choose the dialect that matches your "dataSource" definition -->
 <bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
  <property name="dataSource"><ref local="dataSource"/></property>
  <property name="mappingResources">
   <value>user-hbm.xml</value>
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">net.sf.hibernate.dialect.OracleDialect</prop>
    <prop key="hibernate.cache.provider_class">net.sf.ehcache.hibernate.Provider</prop>
    <prop key="hibernate.cache.use_query_cache">true</prop>
                  <prop key="hibernate.show_sql">false</prop>
   </props>
  </property>
 </bean>

 <!-- AOP DAO Intecepter -->
        <bean id="hibernateInterceptor" class="org.springframework.orm.hibernate.HibernateInterceptor">
          <property name="sessionFactory">
            <ref bean="sessionFactory"/>
          </property>
        </bean>

        <bean id="entityDaoTarget" class="com.gpower.services.entity.dao.EntityDaoImpl">
          <property name="sessionFactory">
            <ref bean="sessionFactory"/>
          </property>
        </bean>

        <bean id="entityDao" class="org.springframework.aop.framework.ProxyFactoryBean">
          <property name="proxyInterfaces">
            <value>com.gpower.services.entity.dao.EntityDao</value>
          </property>
          <property name="interceptorNames">
            <list>
              <value>hibernateInterceptor</value>
              <value>entityDaoTarget</value>
            </list>
          </property>
        </bean>

 <!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) -->
 <bean id="transactionManager" class="org.springframework.orm.hibernate.HibernateTransactionManager">
  <property name="sessionFactory"><ref local="sessionFactory"/></property>
 </bean>

 <!-- Transaction manager that delegates to JTA (for a transactional JNDI DataSource) -->
 <!--
 <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager"/>
 -->

 <!-- Transactional proxy for the Application primary business object -->
        <bean id="entityManagerTarget" class="com.gpower.services.entity.EntityManagerImpl">
          <property name="entityDao">
            <ref bean="entityDao"/>
          </property>
        </bean>

        <bean id="entityManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
          <property name="transactionManager">
            <ref bean="transactionManager"/>
          </property>
          <property name="target">
            <ref bean="entityManagerTarget"/>
          </property>
          <property name="transactionAttributes">
     <props>
       <prop key="get*">PROPAGATION_SUPPORTS</prop>
       <prop key="*">PROPAGATION_REQUIRED</prop>
     </props>
          </property>
        </bean>

我想最重要的是，EJB让每个人都痛恨。要编写一个EJB，需要写LocalHome, RemoteHome, Bean, LocalInterface, RemoteInterface，需要一个标准描述符，一个特殊厂商描述符（Weblogic、WebSphere都不一样），如果是Entity Bean，还需要Mapping文件。如此之多，实在麻烦。但EJB最重要的是解决Transaction问题，没有Spring之前，没有其他方法能够描述式的解决它。每个人、每个公司为了解决Transaction的问题，编程的写法都不一样，百花齐放。于是，在最需要它的时候，Spring出现了。

Spring的功能非常多。但对于一个产品，最重要的是如何用好它的精华。Spring包含AOP、ORM、DAO、Context、Web、MVC几个部分组成。Web、MVC暂不用考虑，用成熟的Struts、JSP或Webwork更好。DAO由于目前Hibernate、JDO的流行，也可不考虑。因此最需要用的是AOP、ORM、Context。

Context中，最重要的是Beanfactory，它是将接口与实现分开，非常重要。以前我们写程序，如一个接口IDocument，一个实现类Document1。在写程序时，需写成IDocument doc = new Document1()，一旦我们的实现类需改变时，变为Document2，则程序需写成IDocument doc = new Document2()，所有用到的地方全需改。Beanfactory帮我们解决了这个问题，用context后，写法变为IDocument doc=(IDocument)beanFactory.getBean("doc")。如果实现类从Document1改为Document2，直接在配置文件改就可以了。Context是Bean factory的进一步抽象。很多人都喜欢用ApplicationConext，用Servlet把它Load。这样就把Bean Factory与Web绑定在一起。如果是Fat Client或Remote调用，则这些Bean factory就很难调用，实际是将表现层与业务层绑定的太紧。推荐的方法是SingletonBeanFactoryLocator。具体为：

   BeanFactoryLocator bfLocator = SingletonBeanFactoryLocator.getInstance();
   BeanFactoryReference bf = bfLocator.useBeanFactory("beanFactory");
   // now use some bean from factory
   return bf.getFactory().getBean(name);

 <beans>

     <bean id="beanFactory" class="org.springframework.context.support.ClassPathXmlApplicationContext">
     <constructor-arg>
      <list>
       <value>dataAccessContext.xml</value>
       <value>securityContext.xml</value>
       <value>...</value>
      </list>
     </constructor-arg>
    </bean>

</beans>

这样，就可随时动态扩展，实现组件式的开发。

（未完，待续）

< form-validation >
  < formset >
   < form  name ="loginForm" >
    < field  property ="username"  depends ="required" >
     < arg0  key ="prompt.username"   />
    </ field >
    < field  property ="password"  depends ="required" >
     < arg0  key ="prompt.password"   />
    </ field >
   </ form >
  </ formset >
</ form-validation >

增加以下内容

 

绿色字体部份为修改内容

这里将使用spring的代理器来对Action进行控制

 

当提交到/login.do是将控制权交给了spring，然后由spring来决定是否转回到struts的Action

 

现在来配置spring

 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

 

<beans>
 <bean name="/login" class="com.test.struts.action.LoginAction" singleton="false"></bean>

</beans>

 

绿色字体是关于转交控制权的配置内容

 

属性singleton="false"，指明了Action 的实例获取方式为每次重新创建。解决了Struts中令人诟病的线程安全问题（Struts中，由一个Action实例处理所有的请求，这就导致了类公用资源在并发请求中的线程同步问题。）（摘自spring开发指南）

 

这时如果你要进行测试也是可以的，不过为了省点时间就不进行测试了。

 

建立数据库在 这里我使用的是mysql4.1.13

 

CREATE TABLE `user` (
  `ID` int(11) NOT NULL auto_increment,
  `USERNAME` varchar(50) NOT NULL default '',
  `PASSWORD` varchar(50) NOT NULL default '',
  PRIMARY KEY  (`ID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

 

添加记录 insert into user (USERNAME,PASSWORD) values ('test','test')

 

创建Hibernate框架

在配置界面中配置数据库的连接部份，重要的是点击链接将jdbc拷贝到lib目录中

使用MyEclipse的数据Database Explorer工具创建User.hmb.xml、AbstractUser.java、User.java映射文件

创建完成后可以将自动生成的hibernate.cfg.xml删除

 

创建UserDAO.java、UserDAOImp.java

UserDAO.java

public interface UserDAO {

   public abstract boolean isValidUser(String username, String password);

}

 

UserDAOImp.java

import java.util.List;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.test.Hibernate.SessionFactory;

public class UserDAOImp extends HibernateDaoSupport implements UserDAO {

    private SessionFactory sessionFactory;

    private static String hql = "from User u where u.username=? ";

    public boolean isValidUser(String username, String password) {

       List userList = this.getHibernateTemplate().find(hql, username);

       if (userList.size() > 0) {

           return true;

       }

       return false;

    }

}

 

修改LoginAction.java文件，使用userDao的方法来进行用户验证

package com.test.struts.action;

 

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

 

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.validator.DynaValidatorForm;

 

import com.test.UserDAO;

public class LoginAction extends Action {

 private UserDAO userDAO;

 

 public UserDAO getUserDAO() {
  return userDAO;
 }

 

 public void setUserDAO(UserDAO userDAO) {
  this.userDAO = userDAO;
 }

 

 public ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  DynaValidatorForm loginForm = (DynaValidatorForm) form;
  // TODO Auto-generated method stub
  String username = (String) loginForm.get("username");
  String password = (String) loginForm.get("password");
  loginForm.set("password", null);
  if (userDAO.isValidUser(username,password)) {
   return mapping.findForward("indexGo");
  } else {
   return mapping.getInputForward();
  }
 }

}
绿色字体为修改部份

 

现在剩下最后的spring配置了

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  <property name="driverClassName">
   <value>com.mysql.jdbc.Driver</value>
  </property>
  <property name="url">
   <value>jdbc:mysql://localhost/test</value>
  </property>
  <property name="username">
   <value>root</value>
  </property>
  <property name="password">
   <value>root</value>
  </property>
 </bean>

 <!-- 配置sessionFactory, 注意这里引入的包的不同  -->
 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  <property name="dataSource">
   <ref local="dataSource" />
  </property>
  <property name="mappingResources">
   <list>
    <value>com/test/Hibernate/User.hbm.xml</value>
   </list>
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
    <prop key="hibernate.show_sql">true</prop>
   </props>
  </property>
 </bean>

 <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory">
   <ref local="sessionFactory" />
  </property>
 </bean>

 <bean id="userDAO" class="com.test.UserDAOImp">
  <property name="sessionFactory">
   <ref local="sessionFactory" />
  </property>
 </bean>

 <bean id="userDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <property name="transactionManager">
   <ref bean="transactionManager" />
  </property>
  <property name="target">
   <ref local="userDAO" />
  </property>
  <property name="transactionAttributes">
   <props>
    <prop key="insert*">PROPAGATION_REQUIRED</prop>
    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
    <prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>
   </props>
  </property>
 </bean>

 <bean name="/login" class="com.test.struts.action.LoginAction" singleton="false">
  <property name="userDAO">
   <ref bean="userDAOProxy" />
  </property>
 </bean>
</beans>

 

现在可以进行测试了！

 

在编写代码有配置内容时一定要注意 hibernate 和 hibernate3 ，这两个包的名字就只差一个字，千万不要有错，否则找错误可是很难的。

Aspect Oriented Programming(AOP)，面向切面编程，是一个比较热门的话题。AOP主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。比如我们最常见的就是日志记录了，举个例子，我们现在提供一个服务查询学生信息的，但是我们希望记录有谁进行了这个查询。如果按照传统的OOP的实现的话，那我们实现了一个查询学生信息的服务接口(StudentInfoService)和其实现类（StudentInfoServiceImpl.java），同时为了要进行记录的话，那我们在实现类(StudentInfoServiceImpl.java)中要添加其实现记录的过程。这样的话，假如我们要实现的服务有多个呢？那就要在每个实现的类都添加这些记录过程。这样做的话就会有点繁琐，而且每个实现类都与记录服务日志的行为紧耦合，违反了面向对象的规则。那么怎样才能把记录服务的行为与业务处理过程中分离出来呢？看起来好像就是查询学生的服务自己在进行，但是背后日志记录对这些行为进行记录，但是查询学生的服务不知道存在这些记录过程，这就是我们要讨论AOP的目的所在。AOP的编程，好像就是把我们在某个方面的功能提出来与一批对象进行隔离，这样与一批对象之间降低了耦合性，可以就某个功能进行编程。
    我们直接从代码入手吧，要实现以上的目标，我们可以使用一个动态代理类(Proxy)，通过拦截一个对象的行为并添加我们需要的功能来完成。Java中的java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口为我们实现动态代理类提供了一个方案，但是该方案针对的对象要实现某些接口；如果针对的目的是类的话，cglib为我们提供了另外一个实现方案。等下会说明两者的区别。
一、接口的实现方案：
1）首先编写我们的业务接口（StudentInfoService.java）：
public interface StudentInfoService{
 void findInfo(String studentName);
}
     及其实现类（StudentInfoServiceImpl.java）：
public class StudentInfoServiceImpl implements StudentInfoService{
 public void findInfo(String name){
  System.out.println("你目前输入的名字是:"+name);
 }
}
2）现在我们需要一个日志功能，在findInfo行为之前执行并记录其行为，那么我们就首先要拦截该行为。在实际执行的过程中用一个代理类来替我们完成。Java中为我们提供了实现动态代理类的方案：

1'处理拦截目的的类（MyHandler.java）
import org.apache.log4j.Logger;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Method;

public class MyHandler implements InvocationHandler{
 private Object proxyObj;
 private static Logger log=Logger.getLogger(MyHandler.class);
 
 public Object bind(Object obj){
  this.proxyObj=obj;
  return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
 }
 
 public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
  Object result=null;
  try{
   //请在这里插入代码，在方法前调用
   log.info("调用log日志方法"+method.getName());
   result=method.invoke(proxyObj,args); //原方法
   //请在这里插入代码，方法后调用
  }catch(Exception e){
   e.printStackTrace();
  }
  return result;
 }
}
2'我们实现一个工厂，为了方便我们使用该拦截类(AOPFactory.java)：
public class AOPFactory{
 private static Object getClassInstance(String clzName){
  Object obj=null;
  try{
   Class cls=Class.forName(clzName);
   obj=(Object)cls.newInstance();
  }catch(ClassNotFoundException cnfe){
   System.out.println("ClassNotFoundException:"+cnfe.getMessage());
  }catch(Exception e){
   e.printStackTrace();
  }
  return obj;
 }
 
 public static Object getAOPProxyedObject(String clzName){
  Object proxy=null;
  MyHandler handler=new MyHandler();
  Object obj=getClassInstance(clzName);
  if(obj!=null) {
   proxy=handler.bind(obj);
  }else{
   System.out.println("Can't get the proxyobj");
   //throw
  }
  return proxy;
 }
}

3)基本的拦截与其工厂我们都实现了，现在测试（ClientTest.java）：
public class ClientTest{
 public static void main(String[] args){
  StudentInfoService studentInfo=(StudentInfoService)AOPFactory.getAOPProxyedObject("StudentInfoServiceImpl");
  studentInfo.findInfo("阿飞");
 }
}
输出结果（看你的log4j设置）：
[INFO]调用log日志方法findInfo
你目前输入的名字是:阿飞
     这样我们需要的效果就出来了，业务处理自己在进行，但是我们实现了日志功能，而业务处理(StudentInfoService)根本不知道存在该行为的。但是Java中提供的动态代理类的实现是针对实现了某些接口的类，如果没有实现接口的话，不能创建代理类，看以上部分：
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
看到了没有？obj.getClass().getInterfaces()要求实现了某些接口。以下提供哪些没有实现接口的实现方案：

二、子类的实现方案。
      首先，请上网下CGLib的包，http://sourceforge.net/project/showfiles.php?group_id=56933 。设置好classpath路径，CGLib与java标准库提供的实现方案不同，cglib主要是基于实现类（如StudentInfoServiceImpl.java)扩展一个子类来实现。与Dynamic Proxy中的Proxy和InvocationHandler相对应，net.sf.cglib.proxy.Enhancer和MethodInterceptor在CGLib中负责完成代理对象创建和方法截获处理,产生的是目标类的子类而不是通过接口来实现方法拦截的，Enhancer主要是用于构造动态代理子类来实现拦截，MethodInterceptor（扩展了Callback接口）主要用于实现around advice（AOP中的概念）：
     1）我们的业务处理（StudentInfoServiceImpl.java）：
public class StudentInfoServiceImpl{
 public void findInfo(String name){
  System.out.println("你目前输入的名字是:"+name);
 }
}
     2）实行一个工具来处理日志功能（AOPInstrumenter.java）：
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
import org.apache.log4j.Logger;

public class AOPInstrumenter implements MethodInterceptor{
 private Logger log=Logger.getLogger(AOPInstrumenter.class);
 private Enhancer enhancer=new Enhancer();
 
 public Object getInstrumentedClass(Class clz){
  enhancer.setSuperclass(clz);
  enhancer.setCallback(this);
  return enhancer.create();
 }
 
 public Object intercept(Object o,Method method,Object[] args,MethodProxy proxy) throws Throwable{
  log.info("调用日志方法"+method.getName());
  Object result=proxy.invokeSuper(o,args);
  return result;
 }
 
}
     3）我们来测试一下（AOPTest.java）：
public class AOPTest{
 public static void main(String[] args){
  AOPInstrumenter instrumenter=new AOPInstrumenter();
  StudentInfoServiceImpl studentInfo=(StudentInfoServiceImpl)instrumenter.getInstrumentedClass(StudentInfoServiceImpl.class);
  studentInfo.findInfo("阿飞");
 }
}
   输出结果与以上相同。
 CGLib中为实现以上目的，主要提供的类
1)Enhancer：setCallback(Callback) ,setSuperclass(Class) ,create()返回动态子类Object
2)MethodInterceptor必须实现的接口：intercept(Object,Method,Object[],MethodProxy)返回的是原方法调用的结果。和Proxy原理一样。

三、以上的两个简单实现AOP的方案都为你准备好了，你可以自己编写测试一下，以下简单介绍一下AOP的基本概念：
1）aspect（切面）：实现了cross-cutting功能，是针对切面的模块。最常见的是logging模块，这样，程序按功能被分为好几层，如果按传统的继承的话，商业模型继承日志模块的话根本没有什么意义，而通过创建一个logging切面就可以使用AOP来实现相同的功能了。
2）jointpoint（连接点）：连接点是切面插入应用程序的地方，该点能被方法调用，而且也会被抛出意外。连接点是应用程序提供给切面插入的地方，可以添加新的方法。比如以上我们的切点可以认为是findInfo(String)方法。
3）advice（处理逻辑）：advice是我们切面功能的实现，它通知程序新的行为。如在logging里，logging advice包括logging的实现代码，比如像写日志到一个文件中。advice在jointpoint处插入到应用程序中。以上我们在MyHandler.java中实现了advice的功能
4）pointcut（切点）：pointcut可以控制你把哪些advice应用于jointpoint上去，通常你使用pointcuts通过正则表达式来把明显的名字和模式进行匹配应用。决定了那个jointpoint会获得通知。
5）introduction：允许添加新的方法和属性到类中。
6）target（目标类）：是指那些将使用advice的类，一般是指独立的那些商务模型。比如以上的StudentInfoServiceImpl.

7)proxy（代理类）：使用了proxy的模式。是指应用了advice的对象，看起来和target对象很相似。
8）weaving(插入）：是指应用aspects到一个target对象创建proxy对象的过程：complie time，classload time，runtime