现在让我们看看Spring AOP是如何处理通知的。

1.1. 通知的生命周期

Spring的通知可以跨越多个被通知对象共享，或者每个被通知对象有自己的通知。这分别对应 per-class或per-instance 通知。

Per-class通知使用最为广泛。它适合于通用的通知，如事务adisor。它们不依赖被代理 的对象的状态，也不添加新的状态。它们仅仅作用于方法和方法的参数。

Per-instance通知适合于导入，来支持混入（mixin）。在这种情况下，通知添加状态到 被代理的对象。

可以在同一个AOP代理中混合使用共享和per-instance通知。

1.2. Spring中通知类型

Spring提供几种现成的通知类型并可扩展提供任意的通知类型。让我们看看基本概念和标准的通知类型。

1.2.1. Interception around advice

Spring中最基本的通知类型是interception around advice .

Spring使用方法拦截器的around通知是和AOP联盟接口兼容的。实现around通知的 类需要实现接口MethodInterceptor：

public interface MethodInterceptor extends Interceptor {

    Object invoke(MethodInvocation invocation) throws Throwable;

}

invoke()方法的MethodInvocation 参数暴露将被调用的方法、目标连接点、AOP代理和传递给被调用方法的参数。 invoke()方法应该返回调用的结果：连接点的返回值。

一个简单的MethodInterceptor实现看起来如下:

public class DebugInterceptor implements MethodInterceptor {

    public Object invoke(MethodInvocation invocation) throws Throwable {

        System.out.println("Before: invocation=[" + invocation + "]");

        Object rval = invocation.proceed();

        System.out.println("Invocation returned");

        return rval;

    }

}

注意MethodInvocation的proceed()方法的调用。这个调用会应用到目标连接点的拦截器链中的每一个拦截器。大部分拦截器会调用这个方法，并返回它的返回值。但是， 一个MethodInterceptor，和任何around通知一样，可以返回不同的值或者抛出一个异常，而 不调用proceed方法。但是，没有好的原因你要这么做。

MethodInterceptor提供了和其他AOP联盟的兼容实现的交互能力。这一节下面 要讨论的其他的通知类型实现了AOP公共的概念，但是以Spring特定的方式。虽然使用特定 通知类型有很多优点，但如果你可能需要在其他的AOP框架中使用，请坚持使用MethodInterceptor around通知类型。注意目前切入点不能和其它框架交互操作，并且AOP联盟目前也没有定义切入 点接口。

1.2.2. Before通知

Before通知是一种简单的通知类型。 这个通知不需要一个MethodInvocation对象，因为它只在进入一个方法前被调用。

Before通知的主要优点是它不需要调用proceed() 方法， 因此没有无意中忘掉继续执行拦截器链的可能性。

MethodBeforeAdvice接口如下所示。 (Spring的API设计允许成员变量的before通知，虽然一般的对象都可以应用成员变量拦截，但Spring 有可能永远不会实现它）。

public interface MethodBeforeAdvice extends BeforeAdvice {

    void before(Method m, Object[] args, Object target) throws Throwable;

}

注意返回类型是void。 Before通知可以在连接点执行之前 插入自定义的行为，但是不能改变返回值。如果一个before通知抛出一个异常，这将中断拦截器 链的进一步执行。这个异常将沿着拦截器链后退着向上传播。如果这个异常是unchecked的，或者 出现在被调用的方法的签名中，它将会被直接传递给客户代码；否则，它将被AOP代理包装到一个unchecked 的异常里。

下面是Spring中一个before通知的例子，这个例子计数所有正常返回的方法：

public class CountingBeforeAdvice implements MethodBeforeAdvice {

    private int count;

    public void before(Method m, Object[] args, Object target) throws Throwable {

        ++count;

    }

    public int getCount() {

        return count;

    }

}

Before通知可以被用于任何类型的切入点。

1.2.3. Throws通知

如果连接点抛出异常，Throws通知 在连接点返回后被调用。Spring提供强类型的throws通知。注意这意味着 org.springframework.aop.ThrowsAdvice接口不包含任何方法： 它是一个标记接口，标识给定的对象实现了一个或多个强类型的throws通知方法。这些方法形式 如下：

afterThrowing([Method], [args], [target], subclassOfThrowable)

只有最后一个参数是必需的。这样从一个参数到四个参数，依赖于通知是否对方法和方法 的参数感兴趣。下面是throws通知的例子。

如果抛出RemoteException异常（包括子类）, 这个通知会被调用

public class RemoteThrowsAdvice implements ThrowsAdvice {

    public void afterThrowing(RemoteException ex) throws Throwable {

        // Do something with remote exception

    }

}

如果抛出ServletException异常， 下面的通知会被调用。和上面的通知不一样，它声明了四个参数，所以它可以访问被调用的方法，方法的参数和目标对象:

public static class ServletThrowsAdviceWithArguments implements ThrowsAdvice {

    public void afterThrowing(Method m, Object[] args, Object target, ServletException ex) {

        // Do something will all arguments

    }

}

最后一个例子演示了如何在一个类中使用两个方法来同时处理 RemoteException和ServletException 异常。任意个数的throws方法可以被组合在一个类中。

public static class CombinedThrowsAdvice implements ThrowsAdvice {

    public void afterThrowing(RemoteException ex) throws Throwable {

        // Do something with remote exception

    }

    public void afterThrowing(Method m, Object[] args, Object target, ServletException ex) {

        // Do something will all arguments

    }

}

Throws通知可被用于任何类型的切入点。

1.2.4. After Returning通知

Spring中的after returning通知必须实现 org.springframework.aop.AfterReturningAdvice 接口，如下所示：

public interface AfterReturningAdvice extends Advice {

    void afterReturning(Object returnValue, Method m, Object[] args, Object target)

            throws Throwable;

}

After returning通知可以访问返回值（不能改变）、被调用的方法、方法的参数和目标对象。

下面的after returning通知统计所有成功的没有抛出异常的方法调用：

public class CountingAfterReturningAdvice implements AfterReturningAdvice {

    private int count;

    public void afterReturning(Object returnValue, Method m, Object[] args, Object target) throws Throwable {

        ++count;

    }

    public int getCount() {

        return count;

    }

}

这方法不改变执行路径。如果它抛出一个异常，这个异常而不是返回值将被沿着拦截器链向上抛出。

After returning通知可被用于任何类型的切入点。

1.2.5. Introduction通知

Spring将introduction通知看作一种特殊类型的拦截通知。

Introduction需要实现IntroductionAdvisor, 和IntroductionInterceptor接口：

public interface IntroductionInterceptor extends MethodInterceptor {

    boolean implementsInterface(Class intf);

}

继承自AOP联盟MethodInterceptor接口的 invoke()方法必须实现导入：也就是说，如果被调用的方法是在 导入的接口中，导入拦截器负责处理这个方法调用，它不能调用proceed() 方法。

Introduction通知不能被用于任何切入点，因为它只能作用于类层次上，而不是方法。你可以只用InterceptionIntroductionAdvisor来实现导入通知，它有下面的方法：

public interface InterceptionIntroductionAdvisor extends InterceptionAdvisor {

    ClassFilter getClassFilter();

    IntroductionInterceptor getIntroductionInterceptor();

    Class[] getInterfaces();

}

这里没有MethodMatcher，因此也没有和导入通知关联的 切入点。只有类过滤是合乎逻辑的。

getInterfaces()方法返回advisor导入的接口。

让我们看看一个来自Spring测试套件中的简单例子。我们假设想要导入下面的接口到一个 或者多个对象中:

public interface Lockable {

    void lock();

    void unlock();

    boolean locked();

}

这个例子演示了一个mixin。我们想要能够 将被通知对象类型转换为Lockable，不管它们的类型，并且调用lock和unlock方法。如果我们调用 lock()方法，我们希望所有setter方法抛出LockedException异常。这样我们能添加一个方面使的对象不可变，而它们不需要知道这一点：这是一个很好的AOP例 子。

首先，我们需要一个做大量转化的IntroductionInterceptor。 在这里，我们继承 org.springframework.aop.support.DelegatingIntroductionInterceptor 实用类。我们可以直接实现IntroductionInterceptor接口，但是大多数情况下 DelegatingIntroductionInterceptor是最合适的。

DelegatingIntroductionInterceptor的设计是将导入 委托到真正实现导入接口的接口，隐藏完成这些工作的拦截器。委托可以使用构造方法参数 设置到任何对象中；默认的委托就是自己（当无参数的构造方法被使用时）。这样在下面的例子里，委托是DelegatingIntroductionInterceptor的子类 LockMixin。给定一个委托（默认是自身）的 DelegatingIntroductionInterceptor实例寻找被这个委托（而不 是IntroductionInterceptor）实现的所有接口，并支持它们中任何一个导入。子类如 LockMixin也可能调用suppressInterflace(Class intf) 方法隐藏不应暴露的接口。然而，不管IntroductionInterceptor 准备支持多少接口，IntroductionAdvisor将控制哪个接口将被实际 暴露。一个导入的接口将隐藏目标的同一个接口的所有实现。

这样，LockMixin继承DelegatingIntroductionInterceptor 并自己实现Lockable。父类自动选择支持导入的Lockable，所以我们不需要指定它。用这种方法我们可以导入任意数量的接口。

注意locked实例变量的使用。这有效地添加额外的状态到目标 对象。

public class LockMixin extends DelegatingIntroductionInterceptor

    implements Lockable {

    private boolean locked;

    public void lock() {

        this.locked = true;

    }

    public void unlock() {

        this.locked = false;

    }

    public boolean locked() {

        return this.locked;

    }

    public Object invoke(MethodInvocation invocation) throws Throwable {

        if (locked() && invocation.getMethod().getName().indexOf("set") == 0)

            throw new LockedException();

        return super.invoke(invocation);

    }

}

通常不要需要改写invoke()方法：实现 DelegatingIntroductionInterceptor就足够了，如果是导入的方法， DelegatingIntroductionInterceptor实现会调用委托方法， 否则继续沿着连接点处理。在现在的情况下，我们需要添加一个检查：在上锁状态下不能调用setter方法。

所需的导入advisor是很简单的。只有保存一个独立的 LockMixin实例，并指定导入的接口，在这里就是 Lockable。一个稍微复杂一点例子可能需要一个导入拦截器（可以 定义成prototype）的引用：在这种情况下，LockMixin没有相关配置，所以我们简单地 使用new来创建它。

public class LockMixinAdvisor extends DefaultIntroductionAdvisor {

    public LockMixinAdvisor() {

        super(new LockMixin(), Lockable.class);

    }

}

我们可以非常简单地使用这个advisor：它不需要任何配置。（但是，有一点 是必要的：就是不可能在没有IntroductionAdvisor 的情况下使用IntroductionInterceptor。） 和导入一样，通常 advisor必须是针对每个实例的，并且是有状态的。我们会有不同的的LockMixinAdvisor 每个被通知对象，会有不同的LockMixin。 advisor组成了被通知对象的状态的一部分。

和其他advisor一样，我们可以使用 Advised.addAdvisor() 方法以编程地方式使用这种advisor，或者在XML中配置（推荐这种方式）。 下面将讨论所有代理创建，包括“自动代理创建者”，选择代理创建以正确地处理导入和有状态的混入。

参考资料：

1． http://www.javaresearch.org/article/showarticle.jsp?column=23&thread=41315

2． http://tech.ccidnet.com/art/1112/20051114/371959_5.html

3． http://www.7dspace.com/doc/21/0603/20063305365394884.htm

4． http://barton131420.cnblogs.com/articles/280664.html

5． http://www.opentown.info/bbs/viewtopic.php?t=7

    它有两种配置方式OpenSessionInViewInterceptor 和OpenSessionInViewFilter(具体参看SpringSide) ，功能相同，只是一个在 web.xml 配置，另一个在 application.xml 配置而已。

    Open Session In View 在 request 把 session 绑定到当前 thread 期间一直保持 hibernate session 在 open 状态，使 session 在 request 的整个期间都可以使用，如在 View 层里 PO 也可以 lazy loading 数据，如 ${ company.employees } 。当 View 层逻辑完成后，才会通过 Filter 的 doFilter 方法或 Interceptor 的 postHandle 方法自动关闭 session 。

										
OpenSessionInViewInterceptor配置
										

												

														
<beans> 
												
												

														
  <bean name="openSessionInViewInterceptor"
												
												

														

																class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor"> 
												
												

														
    <property name="sessionFactory">
												
												

														
      <ref bean="sessionFactory"/>
												
												

														
    </property> 
												
												

														
  </bean> 
												
												

														
  <bean id="urlMapping"
												
												

														

																class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"> 
												
												

														
    <property name="interceptors"> 
												
												

														
      <list> 
												
												

														
        <ref bean="openSessionInViewInterceptor"/> 
												
												

														
      </list> 
												
												

														
    </property> 
												
												

														
    <property name="mappings"> 
												
												

														
    ... 
												
												

														
    </property> 
												
												

														
  </bean> 
												
												

														
... 
												
												

														
</beans> 
												
										
								

										
OpenSessionInViewFilter配置
										

												

														
<web-app> 
												
												

														
... 
												
												

														
  <filter> 
												
												

														
    <filter-name>hibernateFilter</filter-name> 
												
												

														
    <filter-class> 
												
												

														
      org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
												
												

														
    </filter-class> 
												
												

														
    <!-- singleSession默认为true,若设为false则等于没用OpenSessionInView -->
												
												

														
    <init-param> 
												
												

														
      <param-name>singleSession</param-name> 
												
												

														
      <param-value>true</param-value>
												
												

														
    </init-param>
												
												

														
  </filter> 
												
												

														
... 
												
												

														
  <filter-mapping> 
												
												

														
    <filter-name>hibernateFilter</filter-name> 
												
												

														
    <url-pattern>*.do</url-pattern> 
												
												

														
  </filter-mapping> 
												
												

														
... 
												
												

														
</web-app> 
												
										
								

										

												

														
org.springframework.dao.InvalidDataAccessApiUsageException: Write operations 
												
												

														
are not allowed in read-only mode (FlushMode.NEVER) - turn your Session into 
												
												

														
FlushMode.AUTO or remove 'readOnly' marker from transaction definition 
												
										
								

										

												

														

																protected
																void doFilterInternal(HttpServletRequest request, 
HttpServletResponse response,FilterChain filterChain)
throws ServletException, IOException{
　SessionFactory sessionFactory = lookupSessionFactory();
　logger.debug("Opening Hibernate Session in OpenSessionInViewFilter");
　Session session = getSession(sessionFactory);
　TransactionSynchronizationManager.bindResource(
　　sessionFactory, new SessionHolder(session));
　try{
　　filterChain.doFilter(request, response);
　}
　finally{
　TransactionSynchronizationManager.unbindResource(sessionFactory);
　logger.debug("Closing Hibernate Session in OpenSessionInViewFilter");
　closeSession(session, sessionFactory);
　}
}




 
												
												

														

																protected Session getSession(SessionFactory sessionFactory)
throws DataAccessResourceFailureException {
　Session session = SessionFactoryUtils.getSession(sessionFactory, true);
　session.setFlushMode(FlushMode.NEVER);
　return session;
}
												
												

														
																
protected
														void closeSession(Session session, SessionFactory sessionFactory)
throws CleanupFailureDataAccessException {
　SessionFactoryUtils.closeSessionIfNecessary(session, sessionFactory);
}
										
								

										

												

														

																public
																static
																void closeSessionIfNecessary(Session session, SessionFactory sessionFactory)
												
												

														

																throws CleanupFailureDataAccessException {
												
												

														

																if
																(session == null || 
TransactionSynchronizationManager.hasResource(sessionFactory)){
												
												

														

																return;
												
												

														

																}
														
												
												

														
    logger.debug("Closing Hibernate session");
												
												

														

																try
																{
														
												
												

														
      session.close();
												
												

														

																}
														
												
												

														

																catch
																(JDBCException ex){
												
												

														

																// SQLException underneath
														
												
												

														

																throw
																new CleanupFailureDataAccessException("Could not close Hibernate session", ex.getSQLException());
												
												

														

																}
														
												
												

														

																catch
																(HibernateException ex){
												
												

														

																throw
																new CleanupFailureDataAccessException("Could not close Hibernate session", ex);
												
												

														

																}
														
												
												

														

																}
														
												
										
								

										
采用spring的事务声明,使方法受transaction控制
										

												

														

																
																		  <bean id="baseTransaction" 
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" 
          abstract="true"> 
        <property name="transactionManager" ref="transactionManager"/> 
        <property name="proxyTargetClass" value="true"/> 
        <property name="transactionAttributes"> 
            <props> 
                <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop> 
                <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop> 
                <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop> 
                <prop key="save*">PROPAGATION_REQUIRED</prop> 
                <prop key="add*">PROPAGATION_REQUIRED</prop> 
                <prop key="update*">PROPAGATION_REQUIRED</prop> 
                <prop key="remove*">PROPAGATION_REQUIRED</prop> 
            </props> 
        </property> 
    </bean> 
																
																
																		
																				

																		
																
														
														
																
    <bean id="userService" parent="baseTransaction"> 
        <property name="target"> 
            <bean class="com.phopesoft.security.service.impl.UserServiceImpl"/> 
        </property> 
    </bean> 
														
												
										
								

								

										

												
 session.setFlushMode(FlushMode.AUTO); 
										
										

												
 session.save(user); 
										
										

												
 session.flush(); 
										
								
						

这里就只分享自己的唯一经验了. spring + quartz.

其实spring对quartz封装的完美无暇.哈哈

小试牛刀开始了...

java代码呢就是区区几行.

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.apache.log4j.*;

public class ContentArbitrateServiceJob extends QuartzJobBean {
 public static Logger log = Logger.getLogger(ContentArbitrateServiceJob.class);
 private int timeout;
 public void setTimeout(int timeout){
  this.timeout = timeout;
 }
 protected void executeInternal(JobExecutionContext arg0)
   throws JobExecutionException {
  // TODO Auto-generated method stub
  try{
   log.info("系统监督仲裁处理任务开始>........");
   //业务逻辑代码调用
   log.info("系统监督仲裁处理任务结束!");
  }catch(Exception e){
   log.error("系统监督仲裁处理任务出现异常",e);
  }
 }

} 

下面就是看配置文件里面的道道了.其实也不难.

<bean name="contentarbitrateservicejob"  class="org.springframework.scheduling.quartz.JobDetailBean">
    <property name="jobClass">
     <value>com.xuedu.ContentArbitrateServiceJob</value>
    </property>
    <property name="jobDataAsMap">
     <map>
      <entry key="timeout">
       <value>5</value>
      </entry>
     </map>
    </property>
   </bean>
 
  <!-- 配置触发器 -->
       <bean id="cronTriggerCA" class="org.springframework.scheduling.quartz.CronTriggerBean">

  <property name="jobDetail">
   <ref bean="contentarbitrateservicejob"/>
  </property>
  <!-- 每天的8点到21点 每50分钟触发，具体说明见附录 -->
  <property name="cronExpression">
   <value>0 50 08-21 * * ?</value>
  </property>

    </bean>
   
    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

  <!-- 添加触发器 -->
   <property name="triggers">
    <list>
   <ref local="cronTriggerCA"/>
    </list>
   </property>
    </bean>

也很简单吧.

至于cronExpresession的设定格式呢,小弟附下:

字段 允许值 允许的特殊字符
秒 0-59 , - * /
分 0-59 , - * /
小时 0-23 , - * /
日期 1-31 , - * ? / L W C
月份 1-12 或者 JAN-DEC , - * /
星期 1-7 或者 SUN-SAT , - * ? / L C #
年（可选） 留空, 1970-2099 , - * /

表达式 意义
"0 0 12 * * ?" 每天中午12点触发
"0 15 10 ? * *" 每天上午10:15触发
"0 15 10 * * ?" 每天上午10:15触发
"0 15 10 * * ? *" 每天上午10:15触发
"0 15 10 * * ? 2005" 2005年的每天上午10:15触发
"0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发
"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发
"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发
"0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发
"0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发
"0 15 10 15 * ?" 每月15日上午10:15触发
"0 15 10 L * ?" 每月最后一日的上午10:15触发
"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发

至于每个符号 看看例子就好了.很简单了.

Acegi 的配置看起来非常复杂,但事实上在实际项目的安全应用中我们并不需要那么多功能,清楚的了解Acegi配置中各项的功能，有助于我们灵活的运用Acegi于实践中。 

						    <filter>
        <filter-name>Acegi Filter Chain Proxy</filter-name>
        <filter-class>org.acegisecurity.util.FilterToBeanProxy</filter-class>
        <init-param>
            <param-name>targetClass</param-name>
            <param-value>org.acegisecurity.util.FilterChainProxy</param-value>
        </init-param>
    </filter>
				

						   <filter-mapping>
      <filter-name>Acegi Filter Chain Proxy</filter-name>
      <url-pattern>*.do</url-pattern>
    </filter-mapping>
    
    <filter-mapping>
      <filter-name>Acegi Filter Chain Proxy</filter-name>
      <url-pattern>*.jsp</url-pattern>
    </filter-mapping>
    
    <filter-mapping>
      <filter-name>Acegi Filter Chain Proxy</filter-name>
      <url-pattern>/j_acegi_security_check</url-pattern>
    </filter-mapping>
				

						    <listener>
        <listener-class>org.acegisecurity.ui.session.HttpSessionEventPublisher</listener-class>
    </listener>

				

						    <bean id="filterChainProxy" class="org.acegisecurity.util.FilterChainProxy">
        <property name="filterInvocationDefinitionSource">
            <value>
                CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
                PATTERN_TYPE_APACHE_ANT
               /**=httpSessionContextIntegrationFilter,authenticationProcessingFilter,
basicProcessingFilter,rememberMeProcessingFilter,anonymousProcessingFilter,
 exceptionTranslationFilter,filterInvocationInterceptor
            </value>
        </property>
    </bean>
				

						<bean id="authenticationManager" class="org.acegisecurity.providers.ProviderManager">
        <property name="providers">
            <list>
                <ref local="daoAuthenticationProvider"/>
                <ref local="anonymousAuthenticationProvider"/>
                <ref local="rememberMeAuthenticationProvider"/>
            </list>
        </property>
</bean>
				

						    <bean id="daoAuthenticationProvider" class="org.acegisecurity.providers.dao.DaoAuthenticationProvider">
        <property name="userDetailsService" ref="jdbcDaoImpl"/>
        <property name="userCache" ref="userCache"/>
        <property name="passwordEncoder" ref="passwordEncoder"/>
   </bean>
				

						<bean id="passwordEncoder" class="org.acegisecurity.providers.encoding.Md5PasswordEncoder"/>
				

						 
<bean id="jdbcDaoImpl" 
class="org.acegisecurity.userdetails.jdbc.JdbcDaoImpl">
        
<property name="dataSource" 
ref="dataSource"/>
        <property 
name="usersByUsernameQuery">
            
<value>select loginid,passwd,1 from users where loginid = 
?</value>
        
</property>
        <property 
name="authoritiesByUsernameQuery">
            
<value>select u.loginid,p.name from users u,roles r,permissions 
p,user_role ur,role_permis rp where u.id=ur.user_id and r.id=ur.role_id and 
p.id=rp.permis_id 
and
                
r.id=rp.role_id and p.status='1' and 
u.loginid=?</value>
        
</property>
</bean>
				

						<bean id="userCacheBackend" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
        
<property name="cacheManager" ref="cacheManager"/>
        
<property name="cacheName" value="userCache"/>
    </bean>
    <bean id="userCache" class="org.acegisecurity.providers.dao.cache.EhCacheBasedUserCache" autowire="byName">
        <property name="cache" ref="userCacheBackend"/>      
    </bean>
    <bean id="resourceCacheBackend" class="org.springframework.cache.ehcache.EhCacheFactoryBean">        
 <property name="cacheManager" ref="cacheManager"/>        
        <property name="cacheName" value="resourceCache"/>
    </bean>
    <bean id="resourceCache" class="org.springside.modules.security.service.acegi.cache.ResourceCache" autowire="byName">
        <property name="cache" ref="resourceCacheBackend"/>
    </bean>
				

						    <bean id="basicProcessingFilter" class="org.acegisecurity.ui.basicauth.BasicProcessingFilter">
        <property name="authenticationManager" ref="authenticationManager"/>
        <property name="authenticationEntryPoint" ref="basicProcessingFilterEntryPoint"/>
    </bean>
				

						<bean id="basicProcessingFilterEntryPoint" class="org.acegisecurity.ui.basicauth.BasicProcessingFilterEntryPoint">        
 <property name="realmName" value="SpringSide Realm"/>
</bean>
				

						 
<bean id="authenticationProcessingFilterEntryPoint" class="org.acegisecurity.ui.webapp.AuthenticationProcessingFilterEntryPoint">
<property name="loginFormUrl">
<value>/security/login.jsp</value>
</property>
<property name="forceHttps" value="false"/>
</bean>
				

						<bean id="httpSessionContextIntegrationFilter" class="org.acegisecurity.context.HttpSessionContextIntegrationFilter"></bean>
    <bean id="httpRequestAccessDecisionManager" class="org.acegisecurity.vote.AffirmativeBased">
        <property name="allowIfAllAbstainDecisions" value="false"/>
        <property name="decisionVoters">
            <list>
                <ref bean="roleVoter"/>
            </list>
        </property>
</bean>
				

						    <bean id="httpRequestAccessDecisionManager" class="org.acegisecurity.vote.AffirmativeBased">
        <property name="allowIfAllAbstainDecisions" value="false"/>
        <property name="decisionVoters">
            <list>
                <ref bean="roleVoter"/>
            </list>
        </property>
    </bean>
				

						    <bean id="roleVoter" class="org.acegisecurity.vote.RoleVoter">
        <property name="rolePrefix" value="AUTH_"/>
   </bean>
				

						   <bean id="exceptionTranslationFilter" class="org.acegisecurity.ui.ExceptionTranslationFilter">
        <property name="authenticationEntryPoint" ref="authenticationProcessingFilterEntryPoint"/>
    </bean>
				

						    <bean id="authenticationProcessingFilter" class="org.acegisecurity.ui.webapp.AuthenticationProcessingFilter">
        <property name="authenticationManager" ref="authenticationManager"/>
        <property name="authenticationFailureUrl">
            <value>/security/login.jsp?login_error=1</value>
        </property>
        <property name="defaultTargetUrl">
            <value>/admin/index.jsp</value>
        </property>
        <property name="filterProcessesUrl">
            <value>/j_acegi_security_check</value>
        </property>
        <property name="rememberMeServices" ref="rememberMeServices"/>
    </bean>
				

						    <bean id="filterInvocationInterceptor" class="org.acegisecurity.intercept.web.FilterSecurityInterceptor">
        <property name="authenticationManager" ref="authenticationManager"/>
        <property name="accessDecisionManager" ref="httpRequestAccessDecisionManager"/>
        <property name="objectDefinitionSource" ref="filterDefinitionSource"/>
    </bean>
				

						<bean id="filterDefinitionSource" class="org.springside.modules.security.service.acegi.DBFilterInvocationDefinitionSource">
        <property name="convertUrlToLowercaseBeforeComparison" value="true"/>
        <property name="useAntPath" value="true"/>
        <property name="acegiCacheManager" ref="acegiCacheManager"/>
</bean>
				

						   <bean id="methodSecurityInterceptor" class="org.acegisecurity.intercept.method.aopalliance.MethodSecurityInterceptor">
        <property name="authenticationManager" ref="authenticationManager"/>
        <property name="accessDecisionManager" ref="httpRequestAccessDecisionManager"/>
        <property name="objectDefinitionSource" ref="methodDefinitionSource"/>
    </bean>
    <bean id="methodDefinitionSource" class="org.springside.modules.security.service.acegi.DBMethodDefinitionSource">
        <property name="acegiCacheManager" ref="acegiCacheManager"/>
    </bean>
				

One of the sweetiest things the Spring framework gives is Hibernate support is built-in by the time it's born.

Following is a quick guide to configure Hibernate's SessionFactory in Spring. For a detailed version about Spring's Hibernate support, read http://www.springframework.org/docs/data_access.html .

With Spring, Hibernate's SessionFactory no longer needs to bind itself to JNDI; nor use Hibernate's own hibernate.cfg.xml method, which is a little bit tricky to code in Hibernate 2.x (as Hibernate2 doesn't use the once-and-only-once configure() anymore).

Instead, we use org.springframework.orm.hibernate.LocalSessionFactoryBean .

<bean id= "MySessionFactory"  class = "org.springframework.orm.hibernate.LocalSessionFactoryBean" >

    <property name= "mappingResources" >

       <list>

         <value>mappings/Book.hbm.xml</value>

         <value>mappings/Patron.hbm.xml</value>

         <value>mappings/BorrowRecord.hbm.xml</value>

       </list>

    </property>

    <property name= "hibernateProperties" >

       <props>

         <prop key= "hibernate.dialect" >net.sf.hibernate.dialect.MySQLDialect</prop>

         <prop key= "hibernate.query.substitutions" > true = 1  false = 0 </prop>

         <prop key= "hibernate.show_sql" > false </prop>

         <prop key= "hibernate.use_outer_join" > false </prop>

       </props>

    </property>

    <property name= "dataSource" ><ref bean= "MyDataSource" /></property>

</bean>

The above parameters are simple and verbose:

• mappingResources : specifies a list of Hibernate's mapping XML files. The files' search path in JARs are identical to what Hibernate do.
• hibernateProperties : specify the properties to be set for Hibernate's SessionFactory. They are identical to these: http://www.hibernate.org/hib_docs/reference/html/session-configuration.html#session-configuration-s5
• dataSource : the DataSource used by the SessionFactory.

However, we don't need to configure a transaction manager inside the SessionFactory, as we will see below.

After configuring this, we need to provide a setter method in our business objects that need to use Hibernate's SessionFactory:

import  net.sf.hibernate.SessionFactory;

....

public class  MyBusinessObjectImpl  implements  MyBusinessObject

{

    private  SessionFactory sessionFactory;

public  void  setSessionFactory(SessionFactory sessionFactory)

    {

       this .sessionFactory = sessionFactory;

    }

    public  SessionFactory getSessionFactory()

    {

       return this .sessionFactory;

    }

....

and hook it up to Spring.

<bean id= "MyBusinessObject"  class = "library.MyBusinessObjectImpl" >

    <property name= "sessionFactory" >

       <ref bean= "MySessionFactory" />

    </property>

</bean>

How about transactions support? And how do I get Hibernate's Session inside my business objects?

That's Spring framework's another power - HibernateInterceptor and TransactionInterceptor. With them, together with configurations made in Spring, methods inside business objects don't need to write a single line of code for that; instead, a Session will be bound to the business object's current thread, opened and closed automatically; and a transaction will also begin and end automatically.

The sequence is like this:

1. Transaction begins
2. Hibernate session opened and bound to the current thread
3. Actual method execution
4. Hibernate session bound to the current thread closed
5. Transaction ended

This is done with the help of Spring's AOP capability.

However, we need to configure a transaction manager first.

<bean id= "MyTransactionManager"  class = "org.springframework.transaction.jta.JtaTransactionManager" />

The above configures a transaction manager that will access an UserTransaction inside the environment, usually in a J2EE container, or a servlet container with transaction support.

Alternately you may want to have a look at org.springframework.orm.hibernate.HibernateTransactionManager .

Next, we need to define the transaction attribute for our business methods. This is done in org.springframework.transaction.interceptor.TransactionInterceptor ? .

<bean id= "MyTransactionInterceptor" 

class = "org.springframework.transaction.interceptor.TransactionInterceptor" >

    <property name= "transactionManager" ><ref bean= "MyTransactionManager" /></property>

    <property name= "transactionAttributeSource" >

   <value>

          library.MyBusinessImpl.borrowBook=PROPAGATION_REQUIRED

          library.MyBusinessImpl.returnBook=PROPAGATION_REQUIRED

          library.BookSearchImpl.*=PROPAGATION_SUPPORTS

   </value>

    </property>

</bean>

• transactionManager: refer to the transaction manager you choose.
• transactionAttributeSource: tell TransactionInterceptor each method's transaction requirement. Read http://www.springframework.org/docs/api_1.0m1/org/springframework/transaction/TransactionDefinition.html for the values allowed.

You can use a wildcard to tell every method in that business object uses the same transaction attribute. However it is not recommended, as the private methods used inside the business object will have transactions too, which you may not need to.

By the way, the TransactionInterceptor's default behaviour is to commit an transaction anyway, and rollback whenever a RuntimeException is caught - much the same as EJB's behaviour. If you want to control TransactionInterceptor's behaviour when exception is caught, you may tell it with a plus (+) or minus (-) sign, followed by the name of the exception, to commit or rollback a transaction even if an exception mentioned is caught.

An example:

library.MyBusinessImpl.addBook=PROPAGATION_REQUIRED,-SeriesNotFoundException,+CategoryNotFoundException

This means that when SeriesNotFoundException is thrown inside the addBook() method, the transaction will roll back; on the other hand when CategoryNotFoundException is thrown the transaction will be commited anyway.

In most cases you don't need to specify the exception's name with the package it belongs; you just need to specify simply the exception's name.

Then our business objects will need to define as an AOP "target". This is just a change in a name; make sure your code will not call these business objects directly. So change the above business object declaration to

<bean id= "MyBusinessObjectTarget"  class = "library.MyBusinessObjectImpl" >

    <property name= "sessionFactory" >

       <ref bean= "MySessionFactory" />

    </property>

</bean>

Final step is to expose the business object on Spring's ApplicationContext, but not the business object itself; instead we use a ProxyFactoryBean, provided by Spring.

<bean id= "MyBusinessObject"  class = "org.springframework.aop.framework.ProxyFactoryBean" >

    <property name= "proxyInterfaces" >

       <value>library.MyBusinessObject</value>

    </property>

    <property name= "interceptorNames" >

       <list>

          <value>MyTransactionInterceptor</value>

          <value>MyHibernateInterceptor</value>

          <value>MyBusinessObjectTarget</value>

       </list>

    </property>

</bean>

• proxyInterfaces: the interface implemented by your business object.
• interceptorNames: the interceptors to be applied when methods on the business interface is called. Be careful, they have to be placed in order.

Then in our business method we just need to obtain the Session instance, and ignore everything else - everything is done behind the scene.

import  net.sf.hibernate.*;

import  org.springframework.orm.hibernate.SessionFactoryUtils;

....

public  Book findBook( int  bookID)  throws  BookNotFoundException, DataAccessException

{

    //get the Session instance already bound to current thread and opened

    Session session = SessionFactoryUtils.getSession(getSessionFactory(),  false );

    try

    {

       Book book = (Book)session.load(Book.class, bookID);

       return  book;

    }

    catch (ObjectNotFoundException e)

    {

       throw new  BookNotFoundException();

    }

    catch (HibernateException e)

    {

       throw  SessionFactoryUtils.convertHibernateAccessException(e);

    }

}

Alternately you may also use HibernateTemplate and TransactionTemplate, though the above method is simpler. Read http://www.hibernate.org/110.html for details (this page seems more updated than the one in Spring?).

1 Message source 的声明，重要用于系统的信息提示。

<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">

<property name="basename"><value>messages</value></property>

</bean>

2 属性值的声明，主要为 Bean 声明文件中使用：

<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<property name="locations">

<list>

<value>WEB-INF/mail.properties</value>

<value>WEB-INF/jdbc.properties</value>

</list>

</property>

</bean>

3 Custom Editor 的注册，以下是日期的注册：

<bean id="customEditorConfigurer" class="org.springframework.beans.factory.config.CustomEditorConfigurer">

<property name="customEditors">

<map>

<entry key="java.util.Date">

<bean class="org.springframework.beans.propertyeditors.CustomDateEditor">

<constructor-arg index="0">

<bean class="java.text.SimpleDateFormat">

<constructor-arg><value>yyyy-MM-dd</value></constructor-arg>

</bean>

</constructor-arg>

<constructor-arg index="1"><value>false</value></constructor-arg>

</bean>

</entry>

</map>

</property>

</bean>

4 数据库连接池的设置：

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

<property name="driverClassName"><value>${jdbc.driverClassName}</value></property>

<property name="url"><value>${jdbc.url}</value></property>

<property name="username"><value>${jdbc.username}</value></property>

<property name="password"><value>${jdbc.password}</value></property>

</bean>

5 hibernate 的设置：

<bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">

<property name="dataSource"><ref local="dataSource"/></property>

<property name="mappingResources">

<value>mapping.xml</value>

</property>

<property name="hibernateProperties">

<props>

<prop key="hibernate.dialect">${hibernate.dialect}</prop>

</props>

</property>

</bean>

6 Jotm 的事务设置：

<bean id="jotm" class="org.springframework.transaction.jta.JotmFactoryBean"/>

<bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">

<property name="userTransaction"><ref local="jotm"/></property>

</bean>

7 Hibernate 的事务设置：

<bean id="hibernateTransactionManager" class="org.springframework.orm.hibernate.HibernateTransactionManager">

<property name="sessionFactory"><ref local="sessionFactory"/></property>

</bean>

8 Bean 的事务声明：

<bean id="clinic" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

<property name="transactionManager"><ref local="hibernateTransactionManager"/></property>

<property name="target"><ref local="clinicTarget"/></property>

<property name="transactionAttributes">

<props>

<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>

<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>

<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>

<prop key="store*">PROPAGATION_REQUIRED</prop>

</props>

</property>

</bean>

9 Email 的发送者声明：

<bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">

<property name="host"><value>${mail.host}</value></property>

</bean>

10 基本 Url Mapping 的设置：

<bean id="DemoController" class="cn.edu.bit82.DemoController"/>

<bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

<property name="mappings">

<props>

<prop key="/hello.html">DemoController</prop>

<prop key="*">SecondController</prop>

</props>

</property>

</bean>

总结： 以上是一些常用的 Bean 的声明，你一般会用到的，你可以使用 IntelliJ 的 Live Template 功能，可以设置某些参数，很快就完成了 Bean 的声明。

/*

* Created on 2004-8-25 by simba.

*

*/

package com.simba.blog.util;

import javax.servlet.ServletContext;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.context.ApplicationContext;

import org.springframework.web.context.support.WebApplicationContextUtils;

import com.opensymphony.webwork.ServletActionContext;

import com.simba.blog.service.BlogService;

/**

* @author simba

*

* email: simbasun@msn.com

*/

public class ServiceLocator

{

//the catalog service bean name

private static final String BLOG_SERVICE_BEAN_NAME = "blogService";

//the user service bean name

private static final String USER_SERVICE_BEAN_NAME = "userService";

//the logger for this class

private Log logger = LogFactory.getLog(this.getClass());

//the Spring application context

private ApplicationContext appContext;

//the cached catalog service

private BlogService blogService;

//the cached user service

//private UserService userService;

/**

* Constructor.

* <p>

* The following steps being done:

* <ul>

* <li>retrieve Spring application context from servlet context.

* <li>look up <code>CatalogService</code> from Spring application

* context.

* <li>look up <code>UserService</code> from Spring applicatino context.

* </ul>

*/

public ServiceLocator()

{

/*InputStream is = getClass().getResourceAsStream("springapp-servlet.xml");

XmlBeanFactory bf = new XmlBeanFactory(is);

blogService = (BlogService) bf.getBean("blogService");*/

ServletContext context = ServletActionContext.getServletContext();

this.appContext = WebApplicationContextUtils.getRequiredWebApplicationContext(context);

this.blogService = (BlogService)this.lookupService(BLOG_SERVICE_BEAN_NAME);

/*

* this.userService = (UserService)this.lookupService(USER_SERVICE_BEAN_NAME);

*/

this.logger.info("Service locator bean is initialized");

}

/**

* Lookup service based on service bean name.

*

* @param serviceBeanName the service bean name

* @return the service bean

*/

public Object lookupService(String serviceBeanName)

{

return appContext.getBean(serviceBeanName);

}

/**

* @return Returns the blogService.

*/

public BlogService getBlogService()

{

return blogService;

}

}

[in web.xml]

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/daoContext.xml /WEB-INF/applicationContext.xml</param-value>

</context-param>

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<!-- OR USE THE CONTEXTLOADERSERVLET INSTEAD OF THE LISTENER

<servlet>

<servlet-name>context</servlet-name>

<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

-->

By: icess blog: http://blog.matrix.org.cn/page/icess

这次来看看使用Spring的Hibernate模板来操作数据, Spring提供了Hibernate的一层包装,使Hibernate使用起来更加方便,尤其是结合Hibernate Annotation时, 配置文件更少,维护更加简单. 下面来看看吧.

下面是一个测试数据实体类TestData.java 和前一篇提到的实体类一样,只不过用了Annotation注释. 

package  test.orm.hibernate.model;

import  javax.persistence.Basic;
import  javax.persistence.Entity;
import  javax.persistence.Id;
import  javax.persistence.Table;


@Entity
@Table(name =  "test" ,schema =  "APP" )
public class  TestData {
   private int  id;
   private  String name;
   public  TestData( int  id, String name) {
     this .id = id;
     this .name = name;
   }
   public  TestData() {}
  
   @Id
   public int  getId() {
     return  id;
   }
   public void  setId( int  id) {
     this .id = id;
   }
   @Basic
   public  String getName() {
     return  name;
   }
   public void  setName(String name) {
     this .name = name;
   }
}

下面是测试Hibernate模板的类, TestHibernateTemplate.java

package  test.orm.hibernate;

import  java.sql.SQLException;

import  org.hibernate.HibernateException;
import  org.hibernate.Session;
import  org.springframework.orm.hibernate3.HibernateCallback;
import  org.springframework.orm.hibernate3.HibernateTemplate;

import  test.orm.hibernate.model.TestData;


public class  TestHibernateTemplate {
   private  HibernateTemplate hibernateTemplate;
  
   public  TestHibernateTemplate() {}

   public  HibernateTemplate getHibernateTemplate() {
     return  hibernateTemplate;
   }

   public void  setHibernateTemplate(HibernateTemplate hibernateTemplate) {
     this .hibernateTemplate = hibernateTemplate;
   }
  
   //测试使用HibernateTemplate来操作数据
   public  TestData getTestData( final int  id) {
     return  (TestData) hibernateTemplate.execute( new  HibernateCallback() {

       public  Object doInHibernate(Session s)  throws  HibernateException, SQLException {
         // TODO Auto-generated method stub
         return  s.get(TestData.class, id);
       }
      
     });
   }
//  上面查询数据的方法 使用了HibernateCallBack接口,对于这样简单的查询,可以使用下面由HibernateTemplate 提供的更简单的方法
   public  TestData getTestData2( final int  id) {
     return  (TestData) hibernateTemplate.get(TestData.class, id);
   }
   /* 如果上面的两处方法使用Load 方法的时, 抛出延迟加载属性异常, Spring管理Session的问题, 应该是Spring用完Session 然后就关闭了,
    * 所以不可以延迟加载, 也就不可以使用load 方法了,,????? 为什么????*/
  
   // 其他操作数据方法 如: 插入,修改.... 和使用Hibernate session 差不多, HibernateTemplate只是Session的包装
}

可以看到使用Hibernate模板来操作数据,是多么简单,

注意: 上面注释中,提到了在使用Load方法时候,会有问题, Session in view 时候使用load是不会出问题的, 这里Spring提供的方法应该是按照Hibernate的语义写的吧.

下面就是用来测试上面的类是否正常工作的测试类了.TestApp.java

package  test.orm.hibernate;

import  org.springframework.context.ApplicationContext;
import  org.springframework.context.support.ClassPathXmlApplicationContext;

import  test.jdbc.DatabaseUtils;
import  test.orm.hibernate.model.TestData;

public class  TestApp {

   /**
    *  @param  args
    */
   public static void  main(String[] args) {
     // TODO Auto-generated method stub
     DatabaseUtils dataUtils =  new  DatabaseUtils();
     dataUtils.connect();
     System.out.println( "Open database:!" );
     ApplicationContext context =  new  ClassPathXmlApplicationContext( "test/orm/hibernate/spring-hibernate.xml" );
    
     TestHibernateTemplate hibernateTemplate = (TestHibernateTemplate) context.getBean( "testDao" );
    
     System.out.println( "name : "  );
     TestData data = hibernateTemplate.getTestData( 9 );
     System.out.println( "name : "  + data.getName());
     data = hibernateTemplate.getTestData2( 3 );
     System.out.println( "name 2: "  + data.getName());
    
    
     dataUtils.disconnect();
    
   }

}

注意: 本测试中用到了上一篇使用到的DatabaseUtils.java 工具类来操作Derby数据库.

由 以上实例可以看出,在Spring中使用Hibernate,效率更高一些. 你不这样认为吗?

同时 Spring也提供了 JDO等其他一些数据操作框架的包装,使用上基本上 是一样的这里就不在详述了.

下一次我们来看看Spring的I18N处理,和自定义属性编辑器的实现.

  BY: icess Blog: http://blog.matrix.org.cn/page/icess 

   在Spring中处理I18N问题和使用Java里面的类基本上是一样的.使用org.springframework.context.support.ResourceBundleMessageSource

然后注入资源文件(一个名字为basename的属性),然后就可以在Context中使用资源文件了, 如下为一个配置示例: test.xml

下面为资源文件 test.properties

test_zh.properties

test_en_US.properties

下面是一个简单的测试类:

很简单,这样就可以了.

下面来看看Spring中的属性自定义编辑器,这个和Hibernate中的自定义属性差不多 的. 例如下面我们要看到了例子,映射一个电话号码,有areaCode,prefix和 number, 如果不使用自定义属性编辑器那么就要分别注入上面的3个代码,麻烦. 如果使用自定义属性编辑器,直接注入一个-分开的数字序列就可以了 如

.在下面的例子中的Contact.java类有个PhoneNumber属性,里面保存了上面的3个代码,两个类的代码如下:

package  test.propertyEditor;

public class  Contact {
   private  PhoneNumber phoneNumber;
   private  String name;
  
   public  Contact() {}
  
   public  String getName() {
     return  name;
   }

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

   public  PhoneNumber getPhoneNumber() {
     return  phoneNumber;
   }

   public void  setPhoneNumber(PhoneNumber phoneNumber) {
     this .phoneNumber = phoneNumber;
   }
  
}

PhoneNumber.java

package  test.propertyEditor;

public class  PhoneNumber {
   private  String areaCode;
   private  String prefix;
   private  String number;
   public  PhoneNumber() {
    
   }
   public  PhoneNumber(String areaCode,String prefix,String number) {
     this .areaCode = areaCode;
     this .prefix = prefix;
     this .number = number;
   }
   public  String getAreaCode() {
     return  areaCode;
   }
   public void  setAreaCode(String areaCode) {
     this .areaCode = areaCode;
   }
   public  String getNumber() {
     return  number;
   }
   public void  setNumber(String number) {
     this .number = number;
   }
   public  String getPrefix() {
     return  prefix;
   }
   public void  setPrefix(String prefix) {
     this .prefix = prefix;
   }
}

然后定义一个用来编辑PhoneNumber的编辑器PhoneEditor.java 如下:

package  test.propertyEditor;

import  java.beans.PropertyEditorSupport;

public class  PhoneEditor  extends  PropertyEditorSupport {
   public void  setAsText(String textValue) {
     String stripped = stripNonNumber(textValue);
    
     String areaCode = stripped.substring( 0 , 3 );
     String prefix = stripped.substring( 3 , 6 );
     String number = stripped.substring( 6 );
     PhoneNumber phone =  new  PhoneNumber(areaCode,prefix,number);
    
     setValue(phone);
   }
  
   private  String stripNonNumber(String original) {
     StringBuilder allNumeric =  new  StringBuilder();
    
     for ( int  i =  0 ; i < original.length(); i ++) {
       char  c = original.charAt(i);
       if (Character.isDigit(c)) {
         allNumeric.append(c);
       }
     }
     return  allNumeric.toString();
   }
}

继承java里面的属性编辑器,实现里面的一个方法就可以了, 下面就是在配置文件中注册该编辑器.如下:

testPropertyEditor.xml

最后来测试一下注册的结果是否正确:

package  test.propertyEditor;

import  org.springframework.context.ApplicationContext;
import  org.springframework.context.support.ClassPathXmlApplicationContext;

public class  TestPropertyEditor {

   /**
    *  @param  args
    */
   public static void  main(String[] args) {
     // TODO Auto-generated method stub
     ApplicationContext context =  new  ClassPathXmlApplicationContext( "test/propertyEditor/testPropertyEditor.xml" );
     Contact c = (Contact) context.getBean( "contact" );
    
     System.out.println(c.getPhoneNumber().getAreaCode());
     System.out.println(c.getPhoneNumber().getPrefix());
     System.out.println(c.getPhoneNumber().getNumber());
   }

}

ok, 很简单,下一次来看看,Spring提供的一下比较有意思的功能.如定时,发送Email等.

今天来看看使用JDBC来操作数据： 使用的是Derby（JavaDB）数据库，关于JavaDB的介绍请点击这里： http://blog.matrix.org.cn/page/icess?catname=%2FJavaDB 。 下面建立一个DatabaseUtils.java的工具类，来操作数据库 。该类在上面的连接的文章中有讲述。

package  test.jdbc;

import  java.io.File;
import  java.io.IOException;
import  java.io.InputStream;
import  java.sql.Connection;
import  java.sql.DriverManager;
import  java.sql.PreparedStatement;
import  java.sql.ResultSet;
import  java.sql.SQLException;
import  java.sql.Statement;
import  java.util.Properties;
import  java.util.logging.Logger;

public class  DatabaseUtils {
   private static final  String DB_PROPERTIES_FILE =  "jdbc.properties" ;

   private static final  String DB_OPPOSITE_LOCATION =  "/.test" ;

   static  Logger logger = Logger.getLogger(DatabaseUtils. class .getName());

   private  Connection dbConnection;

   private  Properties dbProperties;

   private boolean  isConnected;

   // database name
   private  String dbName;

   private static final  String strCreateTestClobTeble =  "CREATE TABLE APP.test (id INT, name VARCHAR(30),text CLOB(64 K))" ;

   private static final  String strInsertIntoTestTeble =  "INSERT INTO APP.test (id, name)  VALUES (?, ?)" ;
   public static final  String strGetTest =  "SELECT * FROM APP.test WHERE ID = ?" ;
   private static final  String strCreateCourseTable =  "create table APP.Course ("
       +  "    ID          INTEGER NOT NULL PRIMARY KEY GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1),"
       +  "    name    VARCHAR(30), "
       +  "    description  VARCHAR(30), "
       +  "    startDate  DATE, "  +  "    endDate     DATE "  +  ")" ;

   private static final  String strCreateStudentTable =  "create table APP.ADDRESS ("
       +  "    ID          INTEGER NOT NULL PRIMARY KEY GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1),"
       +  "    LASTNAME    VARCHAR(30), "
       +  "    FIRSTNAME   VARCHAR(30), "
       +  "    MIDDLENAME  VARCHAR(30), "
       +  "    PHONE       VARCHAR(20), "
       +  "    EMAIL       VARCHAR(30), "
       +  "    ADDRESS1    VARCHAR(30), "
       +  "    ADDRESS2    VARCHAR(30), "
       +  "    CITY        VARCHAR(30), "
       +  "    STATE       VARCHAR(30), "  +  ")" ;

   public  DatabaseUtils() {
     this ( "test" );
   }

   public  DatabaseUtils(String dbName) {
     this .dbName = dbName;

     setDBSystemDir();
     dbProperties = loadDBProperties();
     String driverName = dbProperties.getProperty( "db.driver" );
     loadDatabaseDriver(driverName);
     if  (!dbExists()) {
       createDatabase();
     }
   }

   private  Properties loadDBProperties() {
     InputStream dbPropInputStream =  null ;

     dbPropInputStream = DatabaseUtils. class
         .getResourceAsStream(DB_PROPERTIES_FILE);
     dbProperties =  new  Properties();

     try  {
       dbProperties.load(dbPropInputStream);
     }  catch  (IOException e) {
       e.printStackTrace();
     }
     return  dbProperties;
   }

   private void  setDBSystemDir() {
     String userDir = System.getProperty( "user.dir" ,  "." );
     String systemDir = userDir + DB_OPPOSITE_LOCATION;
     System.setProperty( "derby.system.home" , systemDir);

     // create the db System dir
     File fileSystemDir =  new  File(systemDir);
     fileSystemDir.mkdir();
   }

   private void  loadDatabaseDriver(String driverName) {
     try  {
       Class.forName(driverName);
     }  catch  (ClassNotFoundException e) {
       e.printStackTrace();
     }
   }

   private boolean  dbExists() {
     boolean  bExists =  false ;
     String dbLocation = getDatabaseLocation();
     File dbFileDir =  new  File(dbLocation);
     if  (dbFileDir.exists()) {
       bExists =  true ;
     }
     return  bExists;
   }

   private boolean  createDatabase() {
     boolean  bCreated =  false ;
     Connection dbConnection =  null ;

     String dbUrl = getDatabaseUrl();
     dbProperties.put( "create" ,  "true" );

     try  {
       dbConnection = DriverManager.getConnection(dbUrl, dbProperties);
       bCreated = createTables(dbConnection, strCreateTestClobTeble);
     }  catch  (SQLException e) {
       e.printStackTrace();
     }

     dbProperties.remove( "create" );
     return  bCreated;
   }

   private boolean  createTables(Connection dbConnection, String creatTableSql) {
     boolean  bCreatedTables =  false ;
     Statement statement =  null ;

     try  {
       statement = dbConnection.createStatement();
       statement.execute(creatTableSql);
       bCreatedTables =  true ;
     }  catch  (SQLException e) {
       e.printStackTrace();
     }
     return  bCreatedTables;
   }

   public  String getDatabaseUrl() {

     return  dbProperties.getProperty( "db.url" ) + dbName;
   }

   public  String getDatabaseLocation() {
     String dbLocation = System.getProperty( "derby.system.home" ) +  "/"
         + dbName;
     return  dbLocation;
   }

   public boolean  connect() {
     String dbUrl = getDatabaseUrl();
     try  {
       logger.info( "DBUrl: "  + dbUrl);
       dbConnection = DriverManager.getConnection(dbUrl, dbProperties);
       isConnected = dbConnection !=  null ;
     }  catch  (SQLException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
       isConnected =  false ;
       logger.info( "create connection if failed!" );
     }
     return  isConnected;
   }

   public  Connection getConnection() {
     return  dbConnection;
   }

   public void  disconnect() {
     if  (isConnected) {
       String dbUrl = getDatabaseUrl();
       dbProperties.put( "shutdown" ,  "true" );
       try  {
         System.out.println( "断开数据库连接????????????????" );
         DriverManager.getConnection(dbUrl, dbProperties);
         System.out.println( "????????????????" );
       }  catch  (SQLException e) {
         // e.printStackTrace();
         logger.info( "disconnect the connection Successful!" );
       }
       isConnected =  false ;
     }
   }

   /**
    *  @param  args
    */
   public static void  main(String[] args) {
     // TODO Auto-generated method stub
     DatabaseUtils testdb =  new  DatabaseUtils();
     logger.info(testdb.getDatabaseLocation());
     logger.info(testdb.getDatabaseUrl());
     testdb.connect();
     Connection c = testdb.getConnection();
     PreparedStatement ps =  null ;
     try  {
       ps = c.prepareStatement(DatabaseUtils.strInsertIntoTestTeble, Statement.RETURN_GENERATED_KEYS);
       ps.setInt( 1 ,  1 );
       ps.setString( 2 ,  "test Icerain" );
       int  i =ps.executeUpdate();
       System.out.println(i);
       ps.close();
      
       ps = c.prepareStatement(DatabaseUtils.strGetTest);
       ps.setInt( 1 ,  1 );
       ResultSet rs = ps.executeQuery();
       if (rs.next()) {
         String name = rs.getString( 2 );
         System.out.println(name);
       }
       ps.close();
     }  catch  (SQLException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
     }
     testdb.disconnect();
   }

}

下面是一个插入数据的类 InsertData.java

package  test.jdbc;

import  java.sql.Types;

import  javax.sql.DataSource;

import  org.springframework.jdbc.core.SqlParameter;
import  org.springframework.jdbc.object.SqlUpdate;

public class  InsertData  extends  SqlUpdate {
   // 需要注入一个DataSource...
   public  InsertData(DataSource ds) {
     setDataSource(ds);   // TODO 注意 设置数据源
     setSql( "INSERT INTO APP.test (id, name)  VALUES (?, ?)" );
     declareParameter( new  SqlParameter(Types.INTEGER));
     declareParameter( new  SqlParameter(Types.VARCHAR));
    
     compile(); // TODO 注意 , 要编译以后才可以使用
   }
  
   // 覆盖insert方法
   public int  insert(TestData data) {
     Object[] params =  new  Object[] {data.id,data.name};
     return  update(params);   // 执行插入操作....
   }

}

很简单, 并带有详细注释.

下面是一个查询的类 QueryDataById.java

package  test.jdbc;

import  java.sql.ResultSet;
import  java.sql.SQLException;
import  java.sql.Types;

import  javax.sql.DataSource;

import  org.springframework.jdbc.core.SqlParameter;
import  org.springframework.jdbc.object.MappingSqlQuery;

public class  QueryDataById  extends  MappingSqlQuery{
   private static final  String sql =  "SELECT * FROM APP.test WHERE ID = ?" ;
   public  QueryDataById(DataSource ds) {
     super (ds,sql);
     declareParameter( new  SqlParameter( "id" ,Types.INTEGER));
     compile();
   }
　

  // 覆盖mapRow方法
   @Override
   protected  Object mapRow(ResultSet rs,  int  index)  throws  SQLException {
     // TODO Auto-generated method stub
     TestData tdata =  new  TestData();
     tdata.id = rs.getInt( 1 );
     tdata.name = rs.getString( 2 );
    
     return  tdata;
   }
  
}

也很简单.

注意:

 以上两个类都实现了Spring简化Jdbc操作的一些接口, 关于接口的信息请查考文档, 这里不在详细讲述.

下面是一个很简单的测试(数据)实体类.TestData.java

package  test.jdbc;

public class  TestData {
   public int  id;
   public  String name;
   public  TestData( int  id, String name) {
     this .id = id;
     this .name = name;
   }
   public  TestData() {}
}

下面是一个测试数据源是否注入正确的类:TestDataSource.java

package  test.jdbc;

import  java.sql.Connection;
import  java.sql.PreparedStatement;
import  java.sql.ResultSet;

import  javax.sql.DataSource;

public class  TestDataSource {
   private  DataSource dataSource;
　

// 注入数据源
   public void  setDataSource(DataSource dataSource) {
     this .dataSource = dataSource;
   }
　

//测试数据源
   public void  testDataSource() {
     try  {
       System.out.println( "Test DataSource!!!" );
       Connection connection = dataSource.getConnection();
       if  (connection !=  null )
         System.out.println( "test ok!" );
      
       PreparedStatement ps =  null ;
       ps = connection.prepareStatement(DatabaseUtils.strGetTest);
       ps.setInt( 1 ,  1 );
       ResultSet rs = ps.executeQuery();
       if (rs.next()) {
         String name = rs.getString( 2 );
         System.out.println( "测试数据源配置:"  + name);
       }
       ps.close();
     }  catch  (Exception e) {
       e.printStackTrace();
     }
   }

}

下面是测试Spring提高的Jdbc功能的主要测试类, 测试了一些使用JDBC操作数据的常用功能, 其他没有测试的请查看其Doc,TestJdbcTemplate.java

整理一下我目前可能会用到的模块, 对于那些现在根本用不到的冬冬还是等有时间再研究吧!

第一个当然是最经典的HelloWorld 了 , 呵呵,简单,但是说明了原理.

定义一个服务接口

package  test.helloworld;

public interface  GreetingService {
   public void  sayGreeting();

}

下面是其实现:

package  test.helloworld;

public class  GreetingServiceImpl  implements  GreetingService {

   private  String greeting;
   public  GreetingServiceImpl() {}
   public  GreetingServiceImpl(String greeting) {
     this .greeting = greeting;
   }
   public void  sayGreeting() {
     //  Auto-generated method stub
     System.out.println(greeting);
   }
  
   public void  setGreeting(String greeting) {
     this .greeting = greeting;
   }

}

然后就是测试 IoC 的测试代码:

package  test.helloworld;


import  org.springframework.beans.factory.BeanFactory;
import  org.springframework.beans.factory.xml.XmlBeanFactory;
import  org.springframework.context.ApplicationContext;
import  org.springframework.context.support.ClassPathXmlApplicationContext;
import  org.springframework.core.io.FileSystemResource;

public class  HelloApp {

   /**
    *  @param  args
    */
   public static void  main(String[] args) {
     // TODO Auto-generated method stub
//    BeanFactory factory;
//    factory = new XmlBeanFactory(new FileSystemResource("src/test/helloworld/hello.xml"));
     // 使用不同的方法得到bean. (BeanFactory or ApplicationContext)
     ApplicationContext context =  new  ClassPathXmlApplicationContext( "test/helloworld/hello.xml" );
    
    
     GreetingService greetingService = (GreetingService) context.getBean( "greetingService" );
//    GreetingService greetingService = (GreetingService) factory.getBean("greetingService");
     greetingService.sayGreeting();
   }

}

还有重要的配置文件如下:hello.xml

呵呵就这么简单,实现了 greeting 属性的 Ioc.

这是Spring 两大基本支柱其一的工作原理, 关于AoP的内容,在这里不作讨论,因为现在我使用AoP的地方不是很多,简单的应用是很简单的啦.^_^.

下面一篇我们来看看 在spring包装下的jdbc访问. 详细情况也可以参考这里

回顾：
开源框架在以前的项目中用过不少， struts,webwork,hibernate,前两者属于web框架，后者属于ORM框架，这些框架基本都是侧重于应用的某个层面，不能称之为J2EE全面的框架，往往是需要和其他框架相结合，我开发的项目采用过如下组合，有的根本就没有框架，只是自己做了设计封装
a、servlet+jdbc,
b、servlet+jsp+javabean+jdbc,
c、struts+BD+DAO ,
d、webwork+ejb+hibernate

使用体会：

 a、b就不要说了，那时候的代码结构真是天马行空，我当时初学，维护公司一个项目代码，1个jsp实现一个模块所有功能，我花了好长时间才 读懂代码。
  时代总是向前发展的，慢慢的系统结构层次上是越来越清晰，开发效率也越来越高，维护也越来越容易（基于一定的培训成本）。
 
 相对而言出于设计理念来讲，个人更喜欢webwork+hibernate框架组合。 

 常有人讨论同等开发层面框架的优缺点，我所属产品的另外一个项目团队曾经为项目后续开发 应该采用struts还是webwork争论的不可开交， 其实个人认为struts,webwork都是非常好的web框架，都有自身的优缺点：
 struts开创web MVC框架之先河，2003－2004年开发的项目基本都是采用struts框架（当时招聘人的时候常问会不会struts，会基本就招了 ），实际MVC设计理念很早就提出了，在j2SE中有很多使用之处，但当时没有一个web框架开发中很好的贯彻该设计理念，直到struts 出现（可能有，只是没有apache更引人注意）。

 struts优点使用用户多，相关技术文档比较全面，开发遇到的问题相关案例也比较多、比较容易解决，框架更加稳定(这一点非常重要）。
 
 webwork相对于struts来讲，的确有不少优异之处，（也是情理之中的事，后发布的框架如果再没有优点别人也不会使用）
 个人认为在开发上主要有以下几点：

 1、页面数据封装成值对象功能比struts强大，webwork采用ognl类型转化。
 struts只能对简单类型的数据对象以及文件对象封装成值对象, 而webwork封装的值对象基本没有限制，值对象属性还可以是List,Map这些对象（这个特性在我们开发一些批量数据、复杂数据处理时非常方便），减少很多代码量，代码非常整洁。
 
 2、拦截器功能
 拦截器是webwork的一个亮点，实际上也是业界比较流行的AOP的一个体现，在实际开发中你可以配置默认的拦截器， 也可以为单独的模块指定特定的拦截器，并且可自定义拦截器，action执行前后拦截都可以。 
 
 3、单元测试比较方便
 最早使用struts框架开发测试时，相关的单元测试基本是不好做的，无法脱离web环境，测试都是只做集成测试、系统测试。
 使用webwork可以简单对action相关属性赋值，可以相关的单元测试，当然前提是在对应action中没有引用web环境相关的对象。 
 其实webwork框架核心还是xwork框架，最早框架使用在C/S结构下，webwork只是xwork的一个在web环境的实现，只是ActionContext 上下文发生了变化，所以说action能够做到脱离web环境也是情理之中的。

4、配置文件
webwork配置文件可以采用引用、继承其他配置文件方式，在团队开发一般都是分模块开发，这样比较方便，配置管理更容易，不会冲突。

5、模板技术集成
 我在实际应用项目中是采用velocity模板做视图展现，因为在对应版本的webwork框架中和velociy集成的相当好，比较方便，
 比直接写jsp代码更整洁、同时利用velocity模板特性结合每个action的配置文件，可实现比较通用的页面查询、录入等视图的展现。
 而struts是没有相关模板集成，不过struts的tag相对而言比webwork的tag好用，webwork如果视图是jsp类型，相关的tag真的比较麻烦
 虽然tag 库很丰富，这也是我为什么使用velocity做视图的原因 。 
 
6、 框架的效验功能
 老实说，两者框架的效验功能都比较麻烦，相对而言webwork更加麻烦点，配置较多，验证接口实现太麻烦，我实际项目使用中还是
 自定义了相关后台验证接口， 要验证的相关action只要实现相关接口即可，相关拦截器负责拦截验证，
 大部分的效验根据配置数据以及html对象自定义属性通过javascript通用效验，实际上现在基于XmlHttp的ajax技术应用成熟的话
 后台验证接口的用途会逐渐淡化。
 
 说明上述比较版本为 struts 1.0 /webwork 2.1.6，后续struts框架扩展很多功能，不是很了解，可能和上诉描述不一定很吻合。
 
 现在两者已经合并，希望能结合两者的优势，发展出更好web框架。
 
7、关于Hibernate还是DAO模式，个人建议采用hibernate+DAO相集合的模式，hibernate占主导地位。
 虽然DAO模式通过自动生成代码效率不会低，但如果需求变更就比较麻烦，维护修改代码较多，测试工作量也较大， 但Hibernate不是万能的，在一些必要的应用还是采用DAO模式，特别是性能相关的部分。
 
 
 废话一大堆，也算把我的工作回顾了一遍，呵呵，这两天简单了解Spring框架，个人感觉Spring更像一个全面的J2EE框架解决方案, 希望能够有时间系统的学习一把，大家有兴趣的请多多交流,我会将我的学习心得和大家分享。