Java代码

1. <bean id="parentBoss" abstract="true"class="com.baobaotao.attr.Boss"> <--父<bean>   
2.     <property name="favorites">   
3.         <set>   
4.             <value>看报</value>   
5.             <value>赛车</value>   
6.             <value>高尔夫</value>   
7.         </set>   
8.     </property>   
9. </bean>  

<bean id="parentBoss" abstract="true"class="com.baobaotao.attr.Boss"> <--父<bean>
<property name="favorites">
<set>
<value>看报</value>
<value>赛车</value>
<value>高尔夫</value>
</set>
</property>
</bean>

Java代码

1. <util:list id="favoriteList1" list-class="java.util.LinkedList">   
2.     <value>看报</value>   
3.     <value>赛车</value>   
4.     <value>高尔夫</value>   
5. </util:list>  

<util:list id="favoriteList1" list-class="java.util.LinkedList">
<value>看报</value>
<value>赛车</value>
<value>高尔夫</value>
</util:list>

Java代码

1. <bean id="boss1" class="com.baobaotao.attr.Boss">   
2.     <property name="favorites">   
3.        <set>    
4.           <value>看报</value>   
5.           <value>赛车</value>   
6.           <value>高尔夫</value>   
7.        </set>   
8.     </property>   
9. </bean>  

<bean id="boss1" class="com.baobaotao.attr.Boss">
<property name="favorites">
<set>
<value>看报</value>
<value>赛车</value>
<value>高尔夫</value>
</set>
</property>
</bean>

Java代码

1.     
2. <util:set id="favoriteSet1">   
3.  <value>看报</value>   
4.  <value>赛车</value>   
5.   <value>高尔夫</value>   
6. </util:set>  

<util:set id="favoriteSet1">
<value>看报</value>
<value>赛车</value>
<value>高尔夫</value>
</util:set>

Java代码

1. <bean id="boss1" class="com.baobaotao.attr.Boss">   
2.     <property name="jobs">   
3.     <map>   
4.           <!--Map第一个元素-->   
5.                <entry>    
6.               <key><value>AM</value></key>   
7.               <value>会见客户</value>   
8.            </entry>   
9.           <!--Map第二个元素-->   
10.                <entry>    
11.               <key><value>PM</value></key>   
12.               <value>公司内部会议</value>   
13.           </entry>                 
14.     </map>   
15.     </property>   
16. </bean>  

<bean id="boss1" class="com.baobaotao.attr.Boss">
<property name="jobs">
<map>
<!--Map第一个元素-->
<entry>
<key><value>AM</value></key>
<value>会见客户</value>
</entry>
<!--Map第二个元素-->
<entry>
<key><value>PM</value></key>
<value>公司内部会议</value>
</entry>
</map>
</property>
</bean>

Java代码

1. <util:map id="emails1">   
2.     <entry key="AM" value="会见客户" />   
3.     <entry key="PM" value="公司内部会议" />   
4. </util:map>  

<util:map id="emails1">
<entry key="AM" value="会见客户" />
<entry key="PM" value="公司内部会议" />
</util:map>

Java代码

1. <bean id="boss1" class="com.baobaotao.attr.Boss">   
2.     <property name="mails">   
3.         <props>   
4.            <prop key="jobMail">john-office@baobaotao.com</prop>   
5.            <prop key="lifeMail">john-life@baobaotao.com</prop>   
6.         </props>   
7.     </property>   
8. </bean>  

<bean id="boss1" class="com.baobaotao.attr.Boss">
<property name="mails">
<props>
<prop key="jobMail">john-office@baobaotao.com</prop>
<prop key="lifeMail">john-life@baobaotao.com</prop>
</props>
</property>
</bean>

Java代码

1. <util:properties id="emailProps1" location="classpath:com/baobaotao/fb/mails.properties"/>  

  <util:properties id="emailProps1" location="classpath:com/baobaotao/fb/mails.properties"/>

Java代码

1.  <bean id="bbtForum"    
2. class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">   
3. <property name="transactionManager" ref="txManager" />    
4. <property name="target" ref="bbtForumTarget"/>   
5. <property name="transactionAttributes">    
6.     <props>   
7.         <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>    
8.         <prop key="*">PROPAGATION_REQUIRED</prop>    
9.     </props>   
10. </property>   
11.  </bean>  

  <bean id="bbtForum"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager" ref="txManager" />
<property name="target" ref="bbtForumTarget"/>
<property name="transactionAttributes">
<props>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>

Java代码

1. @Transactional    
2. public class BbtForumImpl implements BbtForum {   
3.     @Transactional(readOnly=true)    
4.     public Forum getForum(int forumId) {   
5.         return forumDao.getForum(forumId);   
6.     }   
7.        。。。。   
8. }  

@Transactional
public class BbtForumImpl implements BbtForum {
@Transactional(readOnly=true)
public Forum getForum(int forumId) {
return forumDao.getForum(forumId);
}
。。。。
}

Java代码

1. <bean id="txManager"  
2.         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">   
3.         <property name="dataSource" ref="dataSource" />   
4. </bean>   
5. <tx:annotation-driven transaction-manager="txManager"/>  

<bean id="txManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<tx:annotation-driven transaction-manager="txManager"/>

Java代码

1. <aop:config>    
2. t;aop:pointcut id="serviceMethod"    
3.    expression="execution(* com.baobaotao.service.*Forum.*(..))" />   
4. t;aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice" />    
5.  </aop:config>   
6. <tx:advice id="txAdvice" transaction-manager="txManager">    
7.    <tx:attributes>    
8.        <tx:method name="get*" read-only="false"/>   
9.        <tx:method name="add*" rollback-for="Exception" />   
10.        <tx:method name="update*"/>            
11.    </tx:attributes>   
12. lt;/tx:advice>   

<aop:config>
<aop:pointcut id="serviceMethod"
expression="execution(* com.baobaotao.service.*Forum.*(..))" />
<aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice" />
</aop:config>
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="get*" read-only="false"/>
<tx:method name="add*" rollback-for="Exception" />
<tx:method name="update*"/>
</tx:attributes>
</tx:advice>

Java代码

1. package com.baobaotao;   
2. public class NaiveWaiter implements Waiter {   
3.     public void greetTo(String clientName) {   
4.         System.out.println("NaiveWaiter:greet to "+clientName+"...");   
5.     }   
6.     public void serveTo(String clientName){   
7.         System.out.println("NaiveWaiter:serving "+clientName+"...");   
8.     }      
9. }  

package com.baobaotao;
public class NaiveWaiter implements Waiter {
public void greetTo(String clientName) {
System.out.println("NaiveWaiter:greet to "+clientName+"...");
}
public void serveTo(String clientName){
System.out.println("NaiveWaiter:serving "+clientName+"...");
}
}

Java代码

1. package com.baobaotao.aspectj.aspectj;   
2. import org.aspectj.lang.annotation.Aspect;   
3. import org.aspectj.lang.annotation.Before;   
4. //通过该注解将PreGreetingAspect标识为一个切面   
5. @Aspect    
6. public class PreGreetingAspect{   
7.     @Before("execution(* greetTo(..))") //<---定义切点和增强类型   
8.     public void beforeGreeting(){ //<----增强的横切逻辑   
9.         System.out.println("How are you");   
10.     }   
11. }  

package com.baobaotao.aspectj.aspectj;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
//通过该注解将PreGreetingAspect标识为一个切面
@Aspect
public class PreGreetingAspect{
@Before("execution(* greetTo(..))") //<---定义切点和增强类型
public void beforeGreeting(){ //<----增强的横切逻辑
System.out.println("How are you");
}
}

Java代码

1. <?xml version="1.0" encoding="UTF-8" ?>   
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.     xmlns:aop="http://www.springframework.org/schema/aop"    
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
6. <A href="http://www.springframework.org/schema/beans/spring-beans-2.0.xsd" target=_blank>http://www.springframework.org/schema/beans/spring-beans-2.0.xsd</A>   
7.                         http://www.springframework.org/schema/aop    
8. <A href="http://www.springframework.org/schema/aop/spring-aop-2.0.xsd" target=_blank>http://www.springframework.org/schema/aop/spring-aop-2.0.xsd</A>">   
9.     <!--基于@AspectJ切面的驱动器-->   
10.         <aop:aspectj-autoproxy />    
11.     <bean id="waiter" class="com.baobaotao.NaiveWaiter" />   
12.     <bean class="com.baobaotao.aspectj.example.PreGreetingAspect" />   
13. </beans>  

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
<!--基于@AspectJ切面的驱动器-->
<aop:aspectj-autoproxy />
<bean id="waiter" class="com.baobaotao.NaiveWaiter" />
<bean class="com.baobaotao.aspectj.example.PreGreetingAspect" />
</beans>

Java代码

1. <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">   
2.     <property name="locations">   
3.        <list>   
4.            <!--指定属性文件地址，可以在这里定义多个属性文件-->   
5.           <value>classpath:com/baobaotao/place/car.properties</value>    
6.        </list>   
7.     </property>   
8.     <property name="fileEncoding" value="utf-8"/>   
9. </bean>   
10.   
11. <!--引用外部属性的值，对car属性进行配置-->   
12. <bean id="car" class="com.baobaotao.place.Car">   
13.     <property name="brand" value="${brand}" />   
14.     <property name="maxSpeed" value="${maxSpeed}" />   
15.     <property name="price" value="${price}" />   
16. </bean>  

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<!--指定属性文件地址，可以在这里定义多个属性文件-->
<value>classpath:com/baobaotao/place/car.properties</value>
</list>
</property>
<property name="fileEncoding" value="utf-8"/>
</bean>
<!--引用外部属性的值，对car属性进行配置-->
<bean id="car" class="com.baobaotao.place.Car">
<property name="brand" value="${brand}" />
<property name="maxSpeed" value="${maxSpeed}" />
<property name="price" value="${price}" />
</bean>

Java代码

1. <context:property-placeholder location=" classpath:com/baobaotao/place/car.properties "/>  

<context:property-placeholder location=" classpath:com/baobaotao/place/car.properties "/>

3.1 基于角色的权限控制(RBAC)

    Acegi 自带的 sample 表设计很简单: users表{username,password,enabled} authorities表{username,authority},这样简单的设计无法适应复杂的权限需求,故SpringSide选用RBAC模型对 权限控制数据库表进行扩展。 RBAC引入了ROLE的概念,使User(用户)和Permission(权限)分离,一个用户拥有多个角色,一个角色拥 有有多个相应的权限,从而减少了权限管理的复杂度,可更灵活地支持安全策略。

    同时,我们也引入了resource(资源)的概念,一个资源对应多个权限，资源分为ACL,URL,和FUNTION三种。注意，URL和FUNTION的权限命名需要以AUTH_开头才会有资格参加投票, 同样的ACL权限命名需要ACL_开头。

3.2 管理和使用EhCache

3.2.1 设立缓存

在SpringSide里的 Acegi 扩展使用 EhCache 就作为一种缓存解决方案,以缓存用户和资源的信息和相对应的权限信息。

首先需要一个在classpath的 ehcache.xml 文件，用于配置 EhCache。

<ehcache>

       <defaultCache

            maxElementsInMemory="10000"

            eternal="false"

            overflowToDisk="true"

            timeToIdleSeconds="0"

            timeToLiveSeconds="0"

            diskPersistent="false"

           diskExpiryThreadIntervalSeconds= "120"/> 

    <!-- acegi cache-->

    <cache name="userCache"

           maxElementsInMemory="10000"

           eternal="true"

          overflowToDisk= "true"/>

    <!-- acegi cache-->   

    <cache name="resourceCache"

           maxElementsInMemory="10000"

           eternal="true"

           overflowToDisk="true"/>

</ehcache>

     maxElementsInMemory设定了允许在Cache中存放的数据数目，eternal设定Cache是否会过期， overflowToDisk设定内存不足的时候缓存到硬盘，timeToIdleSeconds和timeToLiveSeconds设定缓存游离时间 和生存时间，diskExpiryThreadIntervalSeconds设定缓存在硬盘上的生存时间，注意当eternal="true"时， timeToIdleSeconds，timeToLiveSeconds和diskExpiryThreadIntervalSeconds都是无效 的。

<defaultCache>是除制定的Cache外其余所有Cache的设置，针对Acegi 的情况, 专门设置了userCache和resourceCache，都设为永不过期。在applicationContext-acegi-security.xml中相应的调用是

<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="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"/>

"cacheName" 就是设定在ehcache.xml 中相应Cache的名称。

userCache使用的是Acegi 的EhCacheBasedUserCache(实现了UserCache接口), resourceCache是SpringSide的扩展类

public interface UserCache   {

    public UserDetails getUserFromCache   (String username);

    public void putUserInCache   (UserDetails user);

    public void removeUserFromCache   (String username);

}

public class ResourceCache   {

    public ResourceDetails getAuthorityFromCache   (String resString) {...   }

    public void putAuthorityInCache   (ResourceDetails resourceDetails) {...  }

    public void removeAuthorityFromCache   (String resString) {... }

    public List getUrlResStrings() {... }

    public List getFunctions() {.. }

}

UserCache 就是通过EhCache对UserDetails 进行缓存管理, 而ResourceCache 是对ResourceDetails 类进行缓存管理

public interface UserDetails   extends Serializable {

    public boolean isAccountNonExpired();

    public boolean isAccountNonLocked();

    public GrantedAuthority[] getAuthorities();

    public boolean isCredentialsNonExpired();

    public boolean isEnabled();

    public String getPassword();

    public String getUsername();

}

public interface ResourceDetails   extends Serializable {

    public String getResString();

    public String getResType();

    public GrantedAuthority[] getAuthorities();

}

UserDetails 包含用户信息和相应的权限，ResourceDetails 包含资源信息和相应的权限。

public interface GrantedAuthority     {

    public String getAuthority   ();

}

     GrantedAuthority 就是权限信息，在Acegi 的 sample 里GrantedAuthority 的信息如ROLE_USER, ROLE_SUPERVISOR, ACL_CONTACT_DELETE, ACL_CONTACT_ADMIN等等，网上也有很多例子把角色作为GrantedAuthority ，但事实上看看ACL 就知道， Acegi本身根本就没有角色这个概念，GrantedAuthority 包含的信息应该是权限，对于非ACL的权限用 AUTH_ 开头更为合理, 如SpringSide里的 AUTH_ADMIN_LOGIN, AUTH_BOOK_MANAGE 等等。

3.2.2 管理缓存

     使用AcegiCacheManager对userCache和resourceCache进行统一缓存管理。当在后台对用户信息进行修改或赋权的时候, 在更新数据库同时就会调用acegiCacheManager相应方法, 从数据库中读取数据并替换cache中相应部分,使cache与数据库同步。

public class AcegiCacheManager extends BaseService {

    private ResourceCache resourceCache   ;

    private UserCache userCache   ;

    /**

     * 修改User时更改userCache  

     */ 

    public void modifyUserInCache   (User user, String orgUsername) {...    }

    /**

     * 修改Resource时更改resourceCache  

     */ 

    public void modifyResourceInCache   (Resource resource, String orgResourcename) {...    }

    /**

     *   修改权限时同时修改userCache和resourceCache

     */ 

    public void modifyPermiInCache   (Permission permi, String orgPerminame) {...  }

    /**

     * User授予角色时更改userCache  

     */

    public void authRoleInCache   (User user) {...    }

    /**

     * Role授予权限时更改userCache和resourceCache  

     */ 

    public void authPermissionInCache   (Role role) {...  }

    /**

     * Permissioni授予资源时更改resourceCache  

     */ 

    public void authResourceInCache   (Permission permi) {...  }

    /**

     *   初始化userCache

     */ 

    public void initUserCache   () {...  }

    /**

     *   初始化resourceCache

     */ 

    public void initResourceCache   () {... }

    /**

     *  获取所有的url资源

     */ 

    public List getUrlResStrings   () {...  }

    /**

     * 获取所有的Funtion资源  

     */ 

    public List getFunctions   () {...  }

    /**

     * 根据资源串获取资源  

     */ 

    public ResourceDetails getAuthorityFromCache   (String resString) {...  }

  

 ......





}

3.3 资源权限定义扩展

     Acegi给出的sample里,资源权限对照关系是配置在xml中的,试想一下如果你的企业安全应用有500个用户,100个角色权限的时候,维护这个xml将是个繁重无比的工作,如何动态更改用户权限更是个头痛的问题。

   <bean id="contactManagerSecurity" class="org.acegisecurity.intercept.method.aopalliance.MethodSecurityInterceptor">

      <property name="authenticationManager"><ref bean="authenticationManager"/></property>

      <property name="accessDecisionManager"><ref local="businessAccessDecisionManager"/></property>

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

      <property name="objectDefinitionSource">

         <value>

            sample.contact.ContactManager.create=ROLE_USER

            sample.contact.ContactManager.getAllRecipients=ROLE_USER

            sample.contact.ContactManager.getAll=ROLE_USER,AFTER_ACL_COLLECTION_READ

            sample.contact.ContactManager.getById=ROLE_USER,AFTER_ACL_READ

            sample.contact.ContactManager.delete=ACL_CONTACT_DELETE

            sample.contact.ContactManager.deletePermission=ACL_CONTACT_ADMIN

            sample.contact.ContactManager.addPermission=ACL_CONTACT_ADMIN

         </value>

      </property>

   </bean>

  <bean id="filterInvocationInterceptor" class="org.acegisecurity.intercept.web.FilterSecurityInterceptor">

      <property name="authenticationManager"><ref bean="authenticationManager"/></property>

      <property name="accessDecisionManager"><ref local="httpRequestAccessDecisionManager"/></property>

      <property name="objectDefinitionSource">

         <value>

       CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON

       PATTERN_TYPE_APACHE_ANT

       /index.jsp=ROLE_ANONYMOUS,ROLE_USER

       /hello.htm=ROLE_ANONYMOUS,ROLE_USER

       /logoff.jsp=ROLE_ANONYMOUS,ROLE_USER

       /switchuser.jsp=ROLE_SUPERVISOR

       /j_acegi_switch_user=ROLE_SUPERVISOR

       /acegilogin.jsp*=ROLE_ANONYMOUS,ROLE_USER

       /**=ROLE_USER

         </value>

      </property>

   </bean>

 对如此不Pragmatic的做法,SpringSide进行了扩展, 让Acegi 能动态读取数据库中的权限资源关系。

3.3.1 Aop Invocation Authorization

    <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.security.service.acegi.DBMethodDefinitionSource">

        <property name="acegiCacheManager" ref="acegiCacheManager"/>

    </bean>

     研究下Aceig的源码,ObjectDefinitionSource的实际作用是返回一个ConfigAttributeDefinition对象，而Acegi Sample 的方式是用MethodDefinitionSourceEditor把xml中的文本Function资源权限对应关系信息加载到MethodDefinitionMap ( MethodDefinitionSource 的实现类 )中, 再组成ConfigAttributeDefinition，而我们的扩展目标是从缓存中读取信息来组成ConfigAttributeDefinition。

     MethodSecurityInterceptor是通过调用AbstractMethodDefinitionSource的lookupAttributes(method)方法获取ConfigAttributeDefinition。所以我们需要实现自己的ObjectDefinitionSource，继承AbstractMethodDefinitionSource并实现其lookupAttributes方法,从缓存中读取资源权限对应关系组成并返回ConfigAttributeDefinition即可。SpringSide中的DBMethodDefinitionSource类的部分实现如下 :

public class DBMethodDefinitionSource extends AbstractMethodDefinitionSource {

......

    protected ConfigAttributeDefinition lookupAttributes(Method mi) {

        Assert.notNull(mi, "lookupAttrubutes in the DBMethodDefinitionSource is null");

        String methodString = mi.getDeclaringClass().getName() + "." + mi.getName();

        if (!acegiCacheManager.isCacheInitialized()) {

            //初始化Cache

            acegiCacheManager.initResourceCache();

        }

        //获取所有的function

        List methodStrings = acegiCacheManager.getFunctions();

        Set auths = new HashSet();

        //取权限的合集

        for (Iterator iter = methodStrings.iterator(); iter.hasNext();) {

            String mappedName = (String) iter.next();

            if (methodString.equals(mappedName)

                    || isMatch(methodString, mappedName)) {

                ResourceDetails resourceDetails = acegiCacheManager.getAuthorityFromCache(mappedName);

                if (resourceDetails == null) {

                    break;

                }

                GrantedAuthority[] authorities = resourceDetails.getAuthorities();

                if (authorities == null || authorities.length == 0) {

                    break;

                }

                auths.addAll(Arrays.asList(authorities));

            }

        }

        if (auths.size() == 0)

            return null;

        ConfigAttributeEditor configAttrEditor = new ConfigAttributeEditor();

        String authoritiesStr = " ";

        for (Iterator iter = auths.iterator(); iter.hasNext();) {

            GrantedAuthority authority = (GrantedAuthority) iter.next();

            authoritiesStr += authority.getAuthority() + ",";

        }

        String authStr = authoritiesStr.substring(0, authoritiesStr.length() - 1);

        configAttrEditor.setAsText(authStr);

       //组装并返回ConfigAttributeDefinition

        return (ConfigAttributeDefinition) configAttrEditor.getValue();

    }

    ......

}

要注意几点的是:
1) 初始化Cache是比较浪费资源的，所以SpringSide中除第一次访问外的Cache的更新是针对性更新。

2) 因为method采用了匹配方式(详见 isMatch() 方法) , 即对于*Book和save*这两个资源来说，只要当前访问方法是Book结尾或以save开头都算匹配得上，所以应该取这些能匹配上的资源的相对应的权限的合集。

3) 使用ConfigAttributeEditor 能更方便地组装ConfigAttributeDefinition。

3.3.2 Filter Invocation Authorization

    <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.security.service.acegi.DBFilterInvocationDefinitionSource">

        <property name="convertUrlToLowercaseBeforeComparison" value="true"/>

        <property name="useAntPath" value="true"/>

        <property name="acegiCacheManager" ref="acegiCacheManager"/>

    </bean>

     PathBasedFilterInvocationDefinitionMap和RegExpBasedFilterInvocationDefinitionMap都是 FilterInvocationDefinitionSource的实现类,当PATTERN_TYPE_APACHE_ANT字符串匹配上时时,FilterInvocationDefinitionSourceEditor 选用PathBasedFilterInvocationDefinitionMap 把xml中的文本URL资源权限对应关系信息加载。

     FilterSecurityInterceptor通过FilterInvocationDefinitionSource的lookupAttributes(url)方法获取ConfigAttributeDefinition。 所以，我们可以通过继承FilterInvocationDefinitionSource的抽象类AbstractFilterInvocationDefinitionSource，并实现其lookupAttributes方法,从缓存中读取URL资源权限对应关系即可。SpringSide的DBFilterInvocationDefinitionSource类部分实现如下:

public class DBFilterInvocationDefinitionSource extends AbstractFilterInvocationDefinitionSource {



......

    public ConfigAttributeDefinition lookupAttributes(String url) {

        if (!acegiCacheManager.isCacheInitialized()) {

            acegiCacheManager.initResourceCache();

        }



        if (isUseAntPath()) {

            // Strip anything after a question mark symbol, as per SEC-161.

            int firstQuestionMarkIndex = url.lastIndexOf("?");

            if (firstQuestionMarkIndex != -1) {

                url = url.substring(0, firstQuestionMarkIndex);

            }

        }

        List urls = acegiCacheManager.getUrlResStrings();

        //URL资源倒叙排序

        Collections.sort(urls);

        Collections.reverse(urls);

//是否先全部转为小写再比较

        if (convertUrlToLowercaseBeforeComparison) {

            url = url.toLowerCase();

        }

        GrantedAuthority[] authorities = new GrantedAuthority[0];

        for (Iterator iterator = urls.iterator(); iterator.hasNext();) {

            String resString = (String) iterator.next();

            boolean matched = false;

              //可选择使用AntPath和Perl5两种不同匹配模式   

            if (isUseAntPath()) {

                matched = pathMatcher.match(resString, url);

            } else {

                Pattern compiledPattern;

                Perl5Compiler compiler = new Perl5Compiler();

                try {

                    compiledPattern = compiler.compile(resString,

                            Perl5Compiler.READ_ONLY_MASK);

                } catch (MalformedPatternException mpe) {

                    throw new IllegalArgumentException(

                            "Malformed regular expression: " + resString);

                }

                matched = matcher.matches(url, compiledPattern);

            }

            if (matched) {

                ResourceDetails rd = acegiCacheManager.getAuthorityFromCache(resString);

                authorities = rd.getAuthorities();

                break;

            }

        }

        if (authorities.length > 0) {

            String authoritiesStr = " ";

            for (int i = 0; i < authorities.length; i++) {

                authoritiesStr += authorities[i].getAuthority() + ",";

            }

            String authStr = authoritiesStr.substring(0, authoritiesStr

                    .length() - 1);

            ConfigAttributeEditor configAttrEditor = new ConfigAttributeEditor();

            configAttrEditor.setAsText(authStr);

            return (ConfigAttributeDefinition) configAttrEditor.getValue();

        }

        return null;

    }



......

 }

继承AbstractFilterInvocationDefinitionSource注意几点：
1)  需要先把获取回来的URL资源按倒序派序，以达到 a/b/c/d.* 在 a/.* 之前的效果(详见 Acegi sample 的applicationContext-acegi-security.xml 中的filterInvocationInterceptor的注释)，为的是更具体的URL可以先匹配上，而获取具体URL的权限，如a/b/c/d.*权限AUTH_a, AUTH_b 才可查看,  a/.* 需要权限AUTH_a 才可查看，则如果当前用户只拥有权限AUTH_b,则他只可以查看a/b/c/d.jsp 而不能察看a/d.jsp。

2) 基于上面的原因，故第一次匹配上的就是当前所需权限，而不是取权限的合集。

3) 可以选用AntPath 或 Perl5 的资源匹配方式，感觉AntPath匹配方式基本足够。

4) Filter 权限控制比较适合于较粗颗粒度的权限，如设定某个模块下的页面是否能访问等，对于具体某个操作如增删修改，是否能执行，用Method  Invocation 会更佳些，所以注意两个方面一起控制效果更好

3.4 授权操作

     RBAC模型中有不少多对多的关系，这些关系都能以一个中间表的形式来存放，而Hibernate中可以不建这中间表对应的hbm.xml , 以资源与权限的配置为例，如下:

<hibernate-mapping package="org.springside.modules.security.domain">

    <class name="Permission" table="PERMISSIONS" dynamic-insert="true" dynamic-update="true">

        <cache usage="nonstrict-read-write"/>

        <id name="id" column="ID">

            <generator class="native"/>

        </id>

        <property name="name" column="NAME" not-null="true"/>

        <property name="descn" column="DESCN"/>

        <property name="operation" column="OPERATION"/>

        <property name="status" column="STATUS"/>

        <set name="roles" table="ROLE_PERMIS" lazy="true" inverse="true" cascade="save-update" batch-size="5">

            <key>

                <column name="PERMIS_ID" not-null="true"/>

            </key>

            <many-to-many class="Role" column="ROLE_ID" outer-join="auto"/>

        </set>

        <set name="resources" table="PERMIS_RESC" lazy="true" inverse="false" cascade="save-update" batch-size="5">

            <key>

                <column name="PERMIS_ID" not-null="true"/>

            </key>

            <many-to-many class="Resource" column="RESC_ID"/>

        </set>

    </class>

</hibernate-mapping>

<hibernate-mapping package="org.springside.modules.security.domain">

    <class name="Resource" table="RESOURCES" dynamic-insert="true" dynamic-update="true">

        <cache usage="nonstrict-read-write"/>

        <id name="id" column="ID">

            <generator class="native"/>

        </id>

        <property name="name" column="NAME" not-null="true"/>

        <property name="resType" column="RES_TYPE" not-null="true"/>

        <property name="resString" column="RES_STRING" not-null="true"/>

        <property name="descn" column="DESCN"/>

        <set name="permissions" table="PERMIS_RESC" lazy="true" inverse="true" cascade="save-update" batch-size="5">

            <key>

                <column name="RESC_ID" not-null="true"/>

            </key>

            <many-to-many class="Permission" column="PERMIS_ID" outer-join="auto"/>

        </set>

    </class>

</hibernate-mapping>

配置时注意几点:

1) 因为是分配某个权限的资源，所以权限是主控方，把inverse设为false，资源是被控方inverse设为true

2) cascade是"save-update"，千万别配成delete

3) 只需要 permission.getResources().add(resource)， permission.getResources()..remove(resource) 即可很方便地完成授权和取消授权操作

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1753827

<authz:authorize>是一个流程控制标签，能够在满足特定安全需求的条件下显示它的内容体。它有三个互斥的参数：

n   ifAllGranted——是一个由逗号分隔的权限列表，用户必须拥有所有列出的权限才能渲染标签体；

n   ifAnyGranted——是一个由逗号分隔的权限列表，用户必须至少拥有其中的一个才能渲染标签体；

n   ifNotGranted——是一个由逗号分隔的权限列表，用户必须不拥有其中的任何一个才能渲染标签体。

你可以轻松地想像在JSP中如何使用< authz:authorize>标签根据用户的权限来限制他们的行为。例如，Spring培训应用有一个向用户显示课程有关信息的课程明细页面。 对管理员来说，如果能够从课程明细页面直接跳转到课程编辑页面从而可以更新课程信息是很方便的。但你不希望这个链接对除了管理员之外的其他用户可见。

使用<authz:authorize>标签，在用户没有管理员权限的情况下，你可以避免渲染到课程编辑页面的链接：

  <authz:authorize ifAllGranted="ROLE_ADMINISTRATOR">

    <a href="admin/editCourse.htm?courseId=${course.id}">

      Edit Course

    </a>

  </authz:authorize>

这里，我们使用了ifAllGranted参数，由于这里只需要检查一个授权，所以ifAllGranted标签也是可以使用的。Web应用的安全性只是Acegi功能的一个方面。现在让我们考察它的另一面——保护方法调用。

扩展acegi标签实现动态定位方法对应的权限列表

实现如下：

package com.wonder.cdc.oa.webapp.taglib;

import java.util.List;
import javax.servlet.ServletContext;
import javax.servlet.jsp.JspException;
import org.acegisecurity.GrantedAuthority;
import org.acegisecurity.taglibs.authz.AuthorizeTag;
import org.apache.commons.lang.StringUtils;
import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import com.wonder.cdc.oa.service.security.AcegiCacheManager;
import com.wonder.cdc.oa.service.security.ResourceDetails;
/**
* 根据当前指定方法名称，判断当前用户是否有权限访问该标签方法体
* @author sudi
*/
public class AuthorizeFuncTag extends AuthorizeTag {
/**
  * 扩展acegi标签，实现指定方法名称自动根据名称生成对应的权限字符序列传递给acegi对应的标签
  */
private static final long serialVersionUID = 1L;
private String funcString;
public String getFuncString() {
  return funcString;
}
public void setFuncString(String funcString) {
  this.funcString = funcString;
}

    public int doStartTag() throws JspException {
     //如果设置的funcString为空则显示标签体
     if(StringUtils.isBlank(getFuncString())){
      return EVAL_BODY_INCLUDE;
     }
  ServletContext context = pageContext.getServletContext();
        ApplicationContext ctx = WebApplicationContextUtils.getRequiredWebApplicationContext(context);
     AcegiCacheManager acegiCacheManager = (AcegiCacheManager) ctx.getBean("acegiCacheManager");
     GrantedAuthority[] authorities = new GrantedAuthority[0];
     String roles = " ";
     List functions = acegiCacheManager.getFunctions();
     String funcString;
     boolean findFlag = false;
     for(int i = 0; i < functions.size(); i++){
      funcString = ((String)functions.get(i)).trim();
      if(funcString.equals(getFuncString())){
       findFlag = true;
      }
     }
     //如果设置的funcString没有在acegi的权限控制范围内则显示标签体
     if(!findFlag){
      return EVAL_BODY_INCLUDE;
     }    
     //如果在acegi的权限控制范围则取出该资源相对应的权限设置到setIfAnyGranted()方法中
     ResourceDetails rd = acegiCacheManager.getAuthorityFromCache(getFuncString()); 
     if(rd != null){
      authorities = rd.getAuthorities();   
     }
        if (authorities.length > 0) {              
         for (int i = 0; i < authorities.length; i++) {               
          roles += authorities.getAuthority() + ",";           
         }           
         roles = roles.substring(0, roles.length() - 1);  
        }
     this.setIfAnyGranted(roles);
     return super.doStartTag();
    }
}

标签描述文件：
   <tag>
      <name>isVisualable</name>
      <tag-class>com.wonder.cdc.oa.webapp.taglib.AuthorizeFuncTag</tag-class>
     <info>
      根据当前指定方法名称，判断当前用户是否有权限访问该标签方法体
     </info>     
      <attribute>
         <name>funcString</name>
         <required>true</required>
         <rtexprvalue>false</rtexprvalue>
      </attribute>
   </tag>

其中的acegiCacheManager,是由spring来维护的，用来管理用户，角色，权限，资源的缓存管理类，
其与持久层是同步更新的，用以获得尽可能的性能提升。
acegi的url和method的访问控制都是基于数据库的，这样要比在xml中配置更灵活。

扩展前：
<authz:authorize ifAnyGranted="AUTH_ADMIN,AUTH_USER">
    <input type="button" style="margin-right: 5px"
        onclick="location.href='<c:url value="/editRole.html?method=Add&from=list"/>'"
        value="<fmt:message key="button.add"/>"/>
</authz:authorize>
扩展后：
<CDC:isVisualable funcString="RoleManager.saveRole">
    <input type="button" style="margin-right: 5px"
        onclick="location.href='<c:url value="/editRole.html?method=Add&from=list"/>'"
        value="<fmt:message key="button.add"/>"/>
                     </CDC:isVisualable>

可以看到，扩展前必须通过硬编码的方式指定当前用户是否有权限看到该按钮，而且一旦增加新的权限，就要对应修改所有的相关页面，要死人的阿...

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1752951

Spring 2.0 的重头戏之一就是AspectJ 式 AOP 配置。 但是一定要通过对比，才能看到2.0式的AOP配置是如何跳出一片新天空的。

1. 对比
先看1.0的标准事务配置:

Spring 2.0 的重头戏之一就是AspectJ 式 AOP 配置。 但是一定要通过对比，才能看到2.0式的AOP配置是如何跳出一片新天空的。

1. 对比
先看1.0的标准事务配置:

再看2.0的新配置：

2.进步
1. AOP的配置方式也AOP了。
对比1.0的配置文件，因为下面2提到的限制，事关安全acegi methodSecurityInterceptor 拦截器要配置在关于事务的TransactionProxyFactoryBean的preInterceptors属性里，这样子就一点不AOP了，而2.0使用ponintcut expression，很AOP的配置一切Aspect。

2. 1.0时，一个已经AOP过的object不能再次被AOP。
在Spring 1.0的文档里Rod说，比如<bean id="bookManager" parent="baseTxService">已经进行了一次AOP，如果想在这个Bean上再配一层AOP，比如要对方法执行结果缓存，无论以1.0 还是2.0的方式定义，cglib方式是会报错的，而基于接口的方式，结果不确定。

3. BookManager能直接定义自己，而不是像1.0那样作匿名内部target。

虽然在1.0时代的BeanNameAutoProxyCreator 达到类似作用，但只能用BeanName来匹配比较危险，没有AspectJ的pointcut语法细致。

3. 语法
满江红翻译的Spring参考文档 6.3 schema-based AOP support 提供了aspect,advisor,advide三种组装方法的解释，其中aspect是aspectJ原装，但稍复杂.

唯一有点难懂的是pointcut里的语法，其实也很好学，Spring参考文档6.2.3.4里有完整说明 ，其实一排子过去是

可见execution(* *..BookManager.save(..))

第一颗* 代表ret-type-pattern 返回值可任意，
*..BookManager 代表任意Pacakge里的BookManager类。
如果写成com.xyz.service.* 则代表com.xyz.service下的任意类
com.xyz.service..* com.xyz.service则代表com.xyz.service及其子package下的任意类
save代表save方法，也可以写save* 代表saveBook()等方法
(..) 匹配0个参数或者多个参数的，任意类型
(x,..) 第一个参数的类型必须是X
(x,,,s,..) 匹配至少4个参数，第一个参数必须是x类型，第二个和第三个参数可以任意，第四个必须是s类型。

注意name-pattern千万不要写成*..*Manager ，这样子的话会把所有第三方类库的Manager比如Spring的PlatformTranstationManager 也加入aop，非常危险。所以最好还是加上项目的package前缀，如org.springside

在spring 2.0 中，增加了自定义xml标记这一重大的功能。下面主要看一下spring 2.0实现这一功能的主要相关类：

NamespaceHandlerResolver（接口）
由DefaultBeanDefinitionDocumentReader使用，用于定位NamespaceHandler，指定特定的命名空间uri

实现类：
DefaultNamespaceHandlerResolver

通过map 保存所有的对应关系
默认使用spring.handlers文件来保存所有的handlers
可以定义其他的location 如：

String location = "org/springframework/beans/factory/xml/support/customNamespace.properties";
NamespaceHandlerResolver resolver = new DefaultNamespaceHandlerResolver(getClass().getClassLoader(), location);

NamespaceHandler（接口）

基础接口，用于DefaultBeanDefinitionDocumentReader处理自定义命名空间。
方法：
void init();
由DefaultBeanDefinitionDocumentReader调用在构造完后但在解析自定义元素前。

BeanDefinition parse(Element element, ParserContext parserContext);
解析指定的元素。

BeanDefinitionHolder decorate(Node element,
BeanDefinitionHolder definition,
ParserContext parserContext);
执行相应的修饰。

实现类：

NamespaceHandlerSupport（抽象类）

主要的三个方法：
protected final void registerBeanDefinitionDecorator(
String elementName,
BeanDefinitionDecorator decorator)
注册decorator，通过element

protected final void registerBeanDefinitionDecoratorForAttribute(
String attributeName,
BeanDefinitionDecorator decorator)
注册decorator，通过attr

protected final void registerBeanDefinitionParser(
String elementName,
BeanDefinitionParser parser)
注册BeanDefinitionParser，通过element

实际的操作由具体的BeanDefinitionDecorator 或者BeanDefinitionParser 执行

BeanDefinitionDecorator(接口)

装饰相关的自定义属性。

AbstractInterceptorDrivenBeanDefinitionDecorator
用于注册相应的Interceptor bean 定义，使用aop代理

其他类：

PluggableSchemaResolver，用于自定义相关的schema,默认的schema 保存于spring.schemas文件中

可以通过覆盖resolveEntity方法来装载相应的自定义xsd文件

主要的执行类：

XmlBeanDefinitionReader

用于处理相应的读取工作，其实主要的工作委派给BeanDefinitionDocumentReader

实际的类，就介绍到这，下一节通过实例来说明如何定义自定义xml 元素

看了spring test 用例，其实实现这一功能还算比较简单，主要分以下的步骤，具体的实例可以去参考spring 自带的testcase

首先定义相关xsd文件，用于验证相应的行为：

主要增加了4个自定义元素和1个属性：

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<xsd:schema xmlns="http://www.springframework.org/schema/beans/test"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.springframework.org/schema/beans/test"
elementFormDefault="qualified">

<xsd:element name="testBean">
<xsd:complexType>
<xsd:attribute name="id" type="xsd:string" use="required" form="unqualified"/>
<xsd:attribute name="name" type="xsd:string" use="required" form="unqualified"/>
<xsd:attribute name="age" type="xsd:integer" use="required" form="unqualified"/>
</xsd:complexType>
</xsd:element>

<xsd:element name="set">
<xsd:complexType>
<xsd:attribute name="name" type="xsd:string" use="required" form="unqualified"/>
<xsd:attribute name="age" type="xsd:integer" use="required" form="unqualified"/>
</xsd:complexType>
</xsd:element>

<xsd:element name="debug"/>
<xsd:element name="nop"/>

<xsd:attribute name="object-name" type="xsd:string"/>

</xsd:schema>

接着定义handler映射文件：customNamespace.properties

http\://www.springframework.org/schema/beans/test=org.springframework.beans.factory.xml.support.TestNamespaceHandler

定义Handler:

主要注册相应的解析类和装饰类

publicclass TestNamespaceHandler extends NamespaceHandlerSupport {

publicvoid init() {

//相对于每个xsd中定义的元素

registerBeanDefinitionParser("testBean", new TestBeanDefinitionParser());

registerBeanDefinitionDecorator("set", new PropertyModifyingBeanDefinitionDecorator());

registerBeanDefinitionDecorator("debug", new DebugBeanDefinitionDecorator());

registerBeanDefinitionDecorator("nop", new NopInterceptorBeanDefinitionDecorator());

registerBeanDefinitionDecoratorForAttribute("object-name", new ObjectNameBeanDefinitionDecorator());

}

}

定义各个解析类：

privatestaticclass TestBeanDefinitionParser implements BeanDefinitionParser {

public BeanDefinition parse(Element element, ParserContext parserContext) {

RootBeanDefinition definition = new RootBeanDefinition();

definition.setBeanClass(TestBean.class);

MutablePropertyValues mpvs = new MutablePropertyValues();

mpvs.addPropertyValue("name", element.getAttribute("name"));

mpvs.addPropertyValue("age", element.getAttribute("age"));

definition.setPropertyValues(mpvs);

parserContext.getRegistry().registerBeanDefinition(element.getAttribute("id"), definition);

returnnull;

}

}

privatestaticclassPropertyModifyingBeanDefinitionDecorator implements BeanDefinitionDecorator {

public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition,

ParserContext parserContext) {

Element element = (Element)node;

BeanDefinition def = definition.getBeanDefinition();

MutablePropertyValues mpvs = (def.getPropertyValues() == null) ?

new MutablePropertyValues() : def.getPropertyValues();

mpvs.addPropertyValue("name", element.getAttribute("name"));

mpvs.addPropertyValue("age", element.getAttribute("age"));

((AbstractBeanDefinition) def).setPropertyValues(mpvs);

return definition;

}

}

privatestaticclassDebugBeanDefinitionDecorator extends AbstractInterceptorDrivenBeanDefinitionDecorator {

protected BeanDefinition createInterceptorDefinition(Node node) {

returnnew RootBeanDefinition(DebugInterceptor.class);

}

}

privatestaticclassNopInterceptorBeanDefinitionDecorator extends

AbstractInterceptorDrivenBeanDefinitionDecorator {

protected BeanDefinition createInterceptorDefinition(Node node) {

returnnew RootBeanDefinition(NopInterceptor.class);

}

}

privatestaticclassObjectNameBeanDefinitionDecorator implements BeanDefinitionDecorator {

public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition,

ParserContext parserContext) {

Attr objectNameAttribute = (Attr)node;

definition.getBeanDefinition().setAttribute("objectName", objectNameAttribute.getValue());

return definition;

}

}

可以定义EntityResolver，用于验证相应的xsd

privateclass DummySchemaResolver extends PluggableSchemaResolver {

public DummySchemaResolver() {

super(CustomNamespaceHandlerTests.this.getClass().getClassLoader());

}

public InputSource resolveEntity(String publicId, String systemId) throws IOException {

InputSource source = super.resolveEntity(publicId, systemId);

if (source == null) {

Resource resource =
new ClassPathResource("org/springframework/beans/factory/xml/support/spring-test.xsd");

source = new InputSource(resource.getInputStream());

source.setPublicId(publicId);

source.setSystemId(systemId);

}

return source;

}

}

关键的一步，如何生效：

String location = "org/springframework/beans/factory/xml/support/customNamespace.properties";

NamespaceHandlerResolver resolver = new DefaultNamespaceHandlerResolver(
getClass().getClassLoader(), location);

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);

reader.setNamespaceHandlerResolver(resolver);

reader.setValidationMode(XmlBeanDefinitionReader.VALIDATION_XSD);

reader.setEntityResolver(new DummySchemaResolver());

reader.loadBeanDefinitions(getResource());

写一个测试xml文件：

<?xmlversion="1.0"encoding="UTF-8"?>

<beansxmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:test="http://www.springframework.org/schema/beans/test"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd

http://www.springframework.org/schema/beans/testhttp://www.springframework.org/schema/beans/factory/xml/support/spring-test.xsd">

<test:testBeanid="testBean"name="Rob Harrop"age="23"/>

<beanid="customisedTestBean"class="org.springframework.beans.TestBean">

<test:setname="Rob Harrop"age="23"/>

</bean>

<beanid="debuggingTestBean"class="org.springframework.beans.TestBean">

<test:debug/>

<propertyname="name"value="Rob Harrop"/>

<propertyname="age"value="23"/>

</bean>

<beanid="chainedTestBean"class="org.springframework.beans.TestBean">

<test:debug/>

<test:nop/>

<propertyname="name"value="Rob Harrop"/>

<propertyname="age"value="23"/>

</bean>

<beanid="decorateWithAttribute"class="org.springframework.beans.TestBean"test:object-name="foo"/>

</beans>

相关的测试方法：

publicvoid testSimpleParser() throws Exception {

TestBean bean = (TestBean) this.beanFactory.getBean("testBean");

assetTestBean(bean);

}

publicvoid testSimpleDecorator() throws Exception {

TestBean bean = (TestBean) this.beanFactory.getBean("customisedTestBean");

assetTestBean(bean);

}

publicvoid testProxyingDecorator() throws Exception {

ITestBean bean = (ITestBean) this.beanFactory.getBean("debuggingTestBean");

assetTestBean(bean);

assertTrue(AopUtils.isAopProxy(bean));

Advisor[] advisors = ((Advised) bean).getAdvisors();

assertEquals("Incorrect number of advisors", 1, advisors.length);

assertEquals("Incorrect advice class.", DebugInterceptor.class, advisors[0].getAdvice().getClass());

}

publicvoid testChainedDecorators() throws Exception {

ITestBean bean = (ITestBean) this.beanFactory.getBean("chainedTestBean");

assetTestBean(bean);

assertTrue(AopUtils.isAopProxy(bean));

Advisor[] advisors = ((Advised) bean).getAdvisors();

assertEquals("Incorrect number of advisors", 2, advisors.length);

assertEquals("Incorrect advice class.", DebugInterceptor.class, advisors[0].getAdvice().getClass());

assertEquals("Incorrect advice class.", NopInterceptor.class, advisors[1].getAdvice().getClass());

}

publicvoid testDecorationViaAttribute() throws Exception {

RootBeanDefinition beanDefinition
= (RootBeanDefinition)this.beanFactory.getBeanDefinition("decorateWithAttribute");

assertEquals("foo", beanDefinition.getAttribute("objectName"));

}

privatevoid assetTestBean(ITestBean bean) {

assertEquals("Invalid name", "Rob Harrop", bean.getName());

assertEquals("Invalid age", 23, bean.getAge());

}

二、             Spring 初始化之旅

a)         Spring 初始化的时候首先要运行的类为： org.springframework.web.context. ContextLoaderListener 或 org.springframework.web.context. ContextLoaderServlet 。

       它们在初始化函数里无一例外地实例化了 ContextLoader 类 , 然后调用了它的函数      public WebApplicationContext initWebApplicationContext(ServletContext ) 。

       接下来看一下在这个方法里干了写什么

b)        在他的方法体内，关键是“ this.context = createWebApplicationContext(servletContext, parent); ”新建了一个“ ConfigurableWebApplicationContext ”类型的对象，在这一步实例化中几乎完成了所有的 spring 初始化工作。读取了所有的 spring 配置文件。它的工作步骤如下所述。

c)        首先，在将“ ConfigurableWebApplicationContext ”类型的对象实例化以后（这个对象实际的类型是这个包内的 XmlWebApplicationContext ），然后又给这个实例设置了三个属性，“ wac.setParent(parent); ”在默认的初始化过程中这一步设置了一个 null 值，然后又设置了一个“ wac.setServletContext(servletContext); ”，将系统默认的上下文设置进来，比较重要的是下面这一段：           

       if (configLocation != null) {

       // 读取 spring 的应用配置文件

       wac.setConfigLocations(StringUtils.tokenizeToStringArray(configLocation,Configurabl       eWebApplicationContext.CONFIG_LOCATION_DELIMITERS));

       }

       它将我们的配置文件名放置到 wac 变量中，以待在后续的操作中使用。然后调用           “ wac.refresh(); ”完成主要的初始化 BeanFactory 的操作。如下。

d)        首先我们应该看一下我们实例化的对象

       org.springframework.web.context.support.XmlWebApplicationContext 的类图：

e)         “ wac.refresh(); ”从类结构里我们能找到这个方法来自它的父类： AbstractApplicationContext 在它的 refresh() 方法内我们可以看到 spring 的复杂逻辑。

       首先执行了 refreshBeanFactory(); （来自 AbstractRefreshableApplicationContext ）见 f),

f)         refreshBeanFactory(); 这个方法由负责维护变量 beanFactory 的子类 AbstractRefreshableApplicationContext 实现，默认情况下这个方法直接实例化一个新的 DefaultListableBeanFactory 类型的 BeanFacorty, 然后调用一个起缓冲作用的配置函数生成一个将 beanFacroty 包装起来的对象 beanDefinitionReader ，然后对这个对象进行属性配置，实际上该方法主要负责生成一个临时的操作对象，对应调用的函数为“ loadBeanDefinitions(beanFactory); ”该方法为初始化期间较为重要的一个。        该方法来自其子类： AbstractRefreshableWebApplicationContext 对应的函数：

protected void loadBeanDefinitions(DefaultListableBeanFactory) ，然后这里又调用了自己定义的 protected void loadBeanDefinitions(XmlBeanDefinitionReader) 方法。此时，它就使用到了在 c) 中设置了的（ wac.setConfigLocations(……)) 我们开发中密切相关的配置文件。（同时也要记住此时这个函数的参数 beanDefinitionReader ，之前已经设置了“ beanDefinitionReader.setResourceLoader(this); ”这里的 this 是我们在前面见到的 XmlWebApplicationContext （一个定义好了的上下文））。接着往下：

       “ reader.loadBeanDefinitions(configLocations[i]); ” reader 开始加载我们配置文件内的东西了，不过真正复杂的实现此时才开始，我们继续往下走，在接下来的方法内默认情况下会执行：

if (resourceLoader instanceof ResourcePatternResolver) （该判断条件为 true ） , 由于从上面我们知道： beanDefinitionReader.setResourceLoader(this); 而 this 的类型为： XmlWebApplicationContext 所以 ((ResourcePatternResolver) resourceLoader).getResources(location); 得到一个 Resource[] 数组，接下来调用：

int loadCount = loadBeanDefinitions(resources); 该函数继续调用自己子类定义的一系列临时接口最终执行到 return doLoadBeanDefinitions(inputSource, encodedResource.getResource()); 在这个函数内初始化了处理 xml 文件的一些对象并将用户的配置文件解析为一个 Document 对象。然后又执行了一系列函数直到

return parser.registerBeanDefinitions(this, doc, resource); 这个函数来自我们新建的 DefaultXmlBeanDefinitionParser ，在这个类里最终执行了对 xml 文件的解析工作和对 beanFacroty 变量执行了设置工作。

g)        终于我们从这些繁杂的逻辑中跳了出来，继续执行 AbstractApplicationContext.refresh() 下面的工作，后续的代码主要仍旧是往一些常量里面设值。

如何在struts+spring+hibernate的框架下构建低耦合高内聚的软件》。昨天和几个朋友讨论问题的时候，谈到通过DaoSupport

2

java 代码

1. package com.htxx.thps.psb.dao.imp;   
2.   
3. import com.htxx.service.dao.BasicDao;   
4. import com.htxx.service.dao.Condition;   
5. import com.htxx.service.dao.ResultSet;   
6. import com.htxx.thps.model.PsPsb;   
7. import com.htxx.thps.model.PsPsjcd;   
8. import com.htxx.thps.model.PsWtmx;   
9. import com.htxx.thps.psb.dao.PsbDao;   
10.   
11. /**  
12.  * @author FanGang  
13.  *  
14.  */  
15. public class PsbDaoImp extends BasicDao implements PsbDao {   
16.   
17.     /* (non-Javadoc)  
18.      * @see com.htxx.thps.psb.dao.PsbDao#getPsb(java.lang.String)  
19.      */  
20.     public PsPsb getPsb(String id) {   
21.         return (PsPsb)this.load(PsPsb.class, id);   
22.     }   
23.   
24.     /* (non-Javadoc)  
25.      * @see com.htxx.thps.psb.dao.PsbDao#updatePsb(com.htxx.thps.model.PsPsb)  
26.      */  
27.     public void updatePsb(PsPsb vo) {   
28.         this.update(vo);   
29.     }   
30.   
31.     /* (non-Javadoc)  
32.      * @see com.htxx.thps.psb.dao.PsbDao#getPsb(com.htxx.service.dao.Condition)  
33.      */  
34.     public ResultSet getPsb(Condition condition) {   
35.         return this.query("PsPsb", condition);   
36.     }   
37.   
38.     public PsPsjcd getPsjcd(String id) {   
39.         return (PsPsjcd)this.load(PsPsjcd.class, id);   
40.     }   
41.   
42.     public ResultSet getPsjcd(Condition condition) {   
43.         return this.query("PsPsjcd", condition);   
44.     }   
45.   
46.     public PsWtmx getWtmx(String id) {   
47.         return (PsWtmx)this.load(PsWtmx.class, id);   
48.     }   
49.   
50.     public ResultSet getWtmx(Condition condition) {   
51.         return this.query("PsWtmx", condition);   
52.     }   
53.   
54.     public void updatePsjcd(PsPsjcd vo) {   
55.         this.update(vo);   
56.     }   
57.   
58.     public void updateWtmx(PsWtmx vo) {   
59.         this.update(vo);   
60.     }   
61.   
62. }  

4 

 

如何在struts+spring+hibernate的框架下构建低耦合高内聚的软件》中已经给出了这个结构的一个实现，供大家参考。

我常常在思考一个问题，我们如何能设计出高水平、高质量的软件出来。怎样是高水平、高质量的软件？它应当是易于维护、易于适应变更、可重用性好的一个系统。如何做到这一点呢？答案当然是“低耦合、高内聚”了。低耦合就是软件在构造的时候，各个模块、各个功能、各个类都不会过度依赖于它周围的环境。只有这样，才能使我们的模块（功能、类）在周围发生变更时不受影响，做到易于维护和易于适应变更。正因为如此，也使它更易于重用到其它功能类似的环境中，提高了重用性。高内聚则使软件中的各个模块（功能、类）能够各尽其能而又充分合作，也就是对于软件问题空间中需求的各个功能，系统可以合理地把它分配给各个模块（功能、类）来共同完成，而不是一个或几个八面玲珑、包打天下的超级类一个人完成。而对于该系统中的某一个模块（功能、类），具有自己高度相关的职责，即该职责中的几个任务是高度相关的。每一个模块（功能、类）都决不去完成与自己无关职责的任务。

那么怎样能构造一个低耦合、高内聚的系统能，时下最流行的框架结构之一的struts+spring+hibernate然而我要说的是，即使我们使用了struts+spring+hibernate 

分析与决策

1.       编写DAO的时候不要直接去使用hibernate或spring对hibernate的支持。

现在我们在编写DAO以上问题，究其原因，是我们项目中的DAO

2.       编写Action的时候不要直接使用spring和spring的继承类

前面我说了应当避免DAO的继承类然后使用它的方法。如此的使用，我们的Action将依赖与spring。我们同样可以使用一个叫BasicAction的父类，然后用一个接口来隔离spring。由于ActionBasicAction中，提高系统的可维护性。

3.       当BUS需要获取别的模块的数据的时候，不要直接去使用该模块的DAO

我举一个简单的例子：我需要设计一个软件评审的管理软件，该软件分为评审组织者制订评审计划、评审者分别填写评审表后由评审组织者汇总评审表、评审组织者制作评审报告。这是一个非常简单的项目，分成了三个人来完成。但是项目进行快结束的时候却出现了问题。填写评审表需要获得评审计划中的一些数据，制作评审报告的数据来源于评审表。项目组在开始编程前先开了一次会，大家约定好了各个部分的数据格式及其规则，然后开始工作。然而数天后项目组把各个模块整合以后发现，系统根本跑不起来，为什么呢？设计评审计划的人发现，所有评审计划应当按照产品编号来进行管理而不是项目编号。由于这个变更，填写评审表模块在待评审列表中什么都无法显示；同样，设计评审表的人发现，在一个评审计划中评审表与评审者不是一对多的关系，而是一对一的关系，因而修改了这两个表的关联。因为这样，在制作评审报告时就不能正确得到评审表数据。其实一个软件项目在整个进行过程中总是不断变更。我们需要做的不是去抑制这些变更，而应当是通过软件的结构去适应这些变更，即是降低各模块间的依赖（耦合），提高内聚。

拿这个实例来说，当评审表需要调用评审计划的数据的时候，不应当是自己写一个DAO去调用评审计划的数据，而应当是调用评审计划的接口，将这个任务交给评审计划类来完成。当评审报告需要调用评审表的数据的时候，同样应当去调用评审表的接口，由评审表来实现。同时，这种调用应当是去调用BUS层的接口。为什么呢？比如在评审计划中的一个业务逻辑是只有在评审计划发布以后才能制作评审表，那么怎样才是已发布的评审计划呢？这个业务逻辑应当由谁来定义？当然是评审计划。在什么地方定义？当然是BUS而不是DAO，因为DAO仅仅是实现数据的持久化，而BUS才是实现业务逻辑的地方。既然如此，如果评审表去调用评审计划的DAO，那么已发布评审计划的业务逻辑必然包含在了评审表的业务逻辑里了。我们假设有一天，已发布评审计划的业务逻辑发生变更了（实际上这样的会在你毫不经意间就发生了），编写评审计划的人会很快就修改了评审计划的业务实现并且测试通过了。他不知道评审表里也包含了这样的业务逻辑，因而修改后的程序在运行到评审表的时候就很可能会出错。不幸的是，在实际工作中，同样一个业务逻辑可能包含在无数个你可能知道，但你也可能不知道的代码中。这样的结构就是一个不易于维护的差的结构。

总结：从技术升级和需求变更两方面适应变化

软件开发专家Alistair Cockburn相关链接：回复：《如何在struts+spring+hibernate的框架下构建低耦合高内聚的软件》。

Spring-Hibernate.rar
描述:		下载
文件名:	Spring-Hibernate.rar
文件大小:	9 KB
下载过的:	文件被下载或查看 511 次

1. 对比
先看1.0的标准事务配置:

Spring 2.0 的重头戏之一就是AspectJ 式 AOP 配置。 但是一定要通过对比，才能看到2.0式的AOP配置是如何跳出一片新天空的。

1. 对比
先看1.0的标准事务配置:

再看2.0的新配置：

2.进步
1. AOP的配置方式也AOP了。
对比1.0的配置文件，因为下面2提到的限制，事关安全acegi methodSecurityInterceptor 拦截器要配置在关于事务的TransactionProxyFactoryBean的preInterceptors属性里，这样子就一点不AOP了，而2.0使用ponintcut expression，很AOP的配置一切Aspect。

2. 1.0时，一个已经AOP过的object不能再次被AOP。
在Spring 1.0的文档里Rod说，比如<bean id="bookManager" parent="baseTxService">已经进行了一次AOP，如果想在这个Bean上再配一层AOP，比如要对方法执行结果缓存，无论以1.0 还是2.0的方式定义，cglib方式是会报错的，而基于接口的方式，结果不确定。

3. BookManager能直接定义自己，而不是像1.0那样作匿名内部target。

虽然在1.0时代的BeanNameAutoProxyCreator 达到类似作用，但只能用BeanName来匹配比较危险，没有AspectJ的pointcut语法细致。

3. 语法
满江红翻译的Spring参考文档 6.3 schema-based AOP support 提供了aspect,advisor,advide三种组装方法的解释，其中aspect是aspectJ原装，但稍复杂.

唯一有点难懂的是pointcut里的语法，其实也很好学，Spring参考文档6.2.3.4里有完整说明 ，其实一排子过去是

可见execution(* *..BookManager.save(..))

第一颗* 代表ret-type-pattern 返回值可任意，
*..BookManager 代表任意Pacakge里的BookManager类。
如果写成com.xyz.service.* 则代表com.xyz.service下的任意类
com.xyz.service..* com.xyz.service则代表com.xyz.service及其子package下的任意类
save代表save方法，也可以写save* 代表saveBook()等方法
(..) 匹配0个参数或者多个参数的，任意类型
(x,..) 第一个参数的类型必须是X
(x,,,s,..) 匹配至少4个参数，第一个参数必须是x类型，第二个和第三个参数可以任意，第四个必须是s类型。

注意name-pattern千万不要写成*..*Manager ，这样子的话会把所有第三方类库的Manager比如Spring的PlatformTranstationManager 也加入aop，非常危险。所以最好还是加上项目的package前缀，如org.springside

1其实可以

最近项目使用Acegi作为安全框架的实现,效果不错,就写了这篇文章作为总结.

对于任何一个完整的应用系统，完善的认证和授权机制是必不可少的。在基于SpringFramework的WEB应用中，
我们可以使用Acegi作为安全架构的实现。本文将介绍如何在基于Spring构架的Web应用中使用Acegi，并且详细介
绍如何配置和扩展Acegi框架以适应实际需要。

文章和代码下载:

http://www.blogjava.net/Files/youlq/Acegi.zip


注意：许多朋友在部署上遇到一些麻烦，所以我将可以部署的完整的war文件传上来，注意：java代码在acegi-sample.war\WEB-INF 目录下，例子需要Mysql，建库脚本在acegi-sample.war\db目录下。

acegi-sample.part1.rar
acegi-sample.part2.rar
acegi-sample.part3.rar
acegi-sample.part4.rar

附注：

有些朋友询问我如何部署文中的例子，在此再次说明一下（文章中已经有提到）：

Mysql的建表脚本在db目录下
为了减小体积，已经将WEB-INF\lib下的依赖包删除，请自行下载以下包，并拷贝至WEB-INF\lib下：
spring-1.2.4.jar
acegi-security-0.8.3.jar
aopalliance-1.0.jar
c3p0-0.9.0.jar
commons-logging-1.0.4.jar
ehcache-1.1.jar
log4j-1.2.8.jar
mysql-connector-java-3.1.10-bin.jar
oro-2.0.8.jar

提示：
acegi-security-0.8.3.jar
aopalliance-1.0.jar
c3p0-0.9.0.jar
commons-logging-1.0.4.jar
ehcache-1.1.jar
log4j-1.2.8.jar
oro-2.0.8.jar
可以在acegi-security-0.8.3.zip所带的acegi-security-sample-contacts-filter.war中找到。
spring-1.2.4.jar
mysql-connector-java-3.1.10-bin.jar
要分别到springframework和mysql网站下载。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=245954

    本文档反映的是SpringSide 团队的编码规范，同时推荐所有使用SpringSide框架的开发人员遵循。

    本文档基本遵循Sun's Coding Conventions，补充了其中没有说明或者有所改动的地方。

版权声明   

    本规范由springside团队维护，相关评论与意见请发至springside@gmail.com，转载请注明出处。

规范等级说明

• 级别I:   默认级别，要求所有项目中的所有成员遵守。
• 级别II:  建议所有项目中的所有成员遵守。
• 级别III: 鼓励各个项目根据实际情况执行。

1.格式与命名规范(Formating and Naming Conventions)

1.1  缩进

  使用Tab缩进，而不是空格键--将缩进2，4，8字符的选择权留给阅读者。

1.2 换行

   每行120字符--因为已是1024*768的年代。

   if,for,while语句只有单句时，如果该句可能引起阅读混淆，需要用" {"和"}"括起来，否则可以省略。

//错误，需要使用花括号{}括起来
if (condition)
if(condition) doSomething();
else
doSomething();

1.3 命名规则 

• 不允许使用汉语拼音命名 
• 遇到缩写如XML时，仅首字母大写，即loadXmlDocument()而不是loadXMLDocument()
• Package名必须全部小写，尽量使用单个单词
• Interface名可以是一个名词或形容词(加上'able','ible', or 'er'后缀)，如Runnable，Accessible。
  为了基于接口编程，不采用首字母为I或加上IF后缀的命名方式，如IBookDao,BookDaoIF。
• 页面部件名建议命名为：btnOK、lblName或okBtn、nameLbl。(II)
  其中btn、lbl缩写代表按钮(Button)、标签(Label)。
• 局部变量及输入参数不要与类成员变量同名(get/set方法与构造函数除外)

1.4 声明

• 修饰符应该按照如下顺序排列：public, protected, private, abstract, static, final, transient, volatile, synchronized, native, strictfp。
• 类与接口的声明顺序(可用Eclipse的source->sort members功能自动排列): 
  1. 静态成员变量 / Static Fields
  2. 静态初始化块 / Static Initializers
  3. 成员变量 / Fields
  4. 初始化块 / Initializers
  5. 构造器 / Constructors
  6. 静态成员方法 / Static Methods
  7. 成员方法 / Methods
  8. 重载自Object的方法如toString(), hashCode() 和main方法
  9. 类型(内部类) / Types(Inner Classes)

     同等的类型，按public, protected, private的顺序排列。

2.注释规范(Document Convertions)

2.1 注释类型

2.1.1 JavaDoc注释

  略。

2.1.2 失效代码注释

  由/*...*/界定，标准的C-Style的注释。专用于注释已失效的代码。

/*
 * Comment out the code
 * String s = "hello";
* System.out.println(s);
 */

2.1.3 代码细节注释

  由//界定，专用于注释代码细节，即使有多行注释也仍然使用//，以便与用/**/注释的失效代码分开

  除了私有变量外，不推荐使用行末注释。

class MyClass {
private int myField; // An end-line comment.

public void myMethod {
//a very very long
       //comment.
       if (condition1) {
//condition1 comment
          ...
} else {
//elses condition comment
          ...
}
}
}

2.2 注释的格式

• 注释中的第一个句子要以（英文）句号、问号或者感叹号结束。Javadoc生成工具会将注释中的第一个句子放在方法汇总表和索引中。
• 为了在JavaDoc和IDE中能快速链接跳转到相关联的类与方法，尽量多的使用@see xxx.MyClass，@see xx.MyClass#find(String)。
• Class必须以@author 作者名声明作者，不需要声明@version与@date，由版本管理系统保留此信息。(II)
• 如果注释中有超过一个段落，用<p>分隔。(II)
• 示例代码以<pre></pre>包裹。(II)
• 标识(java keyword, class/method/field/argument名，Constants) 以<code></code>包裹。(II)
• 标识在第一次出现时以{@linkxxx.Myclass}注解以便JavaDoc与IDE中可以链接。(II)

2.3 注释的内容

2.3.1 可精简的注释内容

    注释中的每一个单词都要有其不可缺少的意义，注释里不写"@param name -名字"这样的废话。
    如果该注释是废话，连同标签删掉它，而不是自动生成一堆空的标签，如空的@param name，空的@return。

2.3.2 推荐的注释内容

• 对于API函数如果存在契约，必须写明它的前置条件(precondition)，后置条件(postcondition)，及不变式(invariant)。(II)
• 对于调用复杂的API尽量提供代码示例。(II)
• 对于已知的Bug需要声明。(II)
• 在本函数中抛出的unchecked exception尽量用@throws说明。(II)

2.3.3 Null规约

   如果方法允许Null作为参数，或者允许返回值为Null，必须在JavaDoc中说明。
   如果没有说明，方法的调用者不允许使用Null作为参数，并认为返回值是Null Safe的。

/**
 * 获取对象.
 *
 * @ return the object to found or null if not found.
 */
Object get(Integer id){
...
}

2.3.4 特殊代码注释

• 代码质量不好但能正常运行，或者还没有实现的代码用//TODO: 或 //XXX:声明 
• 存在错误隐患的代码用//FIXME:声明

3.编程规范(Programming Conventions)

3.1基本规范

1. 当面对不可知的调用者时，方法需要对输入参数进行校验，如不符合抛出IllegalArgumentException，建议使用Spring的Assert系列函数。 
2. 隐藏工具类的构造器，确保只有static方法和变量的类不能被构造实例。
3. 变量，参数和返回值定义尽量基于接口而不是具体实现类，如Map map = new HashMap();
4. 代码中不能使用System.out.println()，e.printStackTrace()，必须使用logger打印信息。

3.2 异常处理

1. 重新抛出的异常必须保留原来的异常，即throw new NewException("message", e); 而不能写成throw new NewException("message")。
2. 在所有异常被捕获且没有重新抛出的地方必须写日志。 
3. 如果属于正常异常的空异常处理块必须注释说明原因，否则不允许空的catch块。
4. 框架尽量捕获低级异常，并封装成高级异常重新抛出，隐藏低级异常的细节。(III)

3.3 代码度量

3.3.1 耦合度度量

• DAC度量值不要不大于7 ( III )
  解释：DAC(Data Abstraction Coupling)数据抽象耦合度是描述对象之间的耦合度的一种代码度量。DAC度量值表示一个类中有实例化的其它类的个数。
• CFO度量值不要不大于20 ( III )
  解释：CFO(Class Fan Out)类扇出是描述类之间的耦合度的一种代码度量。CFO度量值表示一个类依赖的其他类的个数。

3.3.2 方法度量

• 方法（构造器）参数在5个以内 ( II )
  太多的方法（构造器）参数影响代码可读性。考虑用值对象代替这些参数或重新设计。
• 方法长度150行以内 ( II )
• CC 度量值不大于10(III )
  解释：CC(CyclomaticComplexity)圈复杂度指一个方法的独立路径的数量，可以用一个方法内if,while,do,for,catch,switch,case,?:语句与&&,||操作符的总个数来度量。
• NPath度量值不大于200 ( III )
  解释：NPath度量值表示一个方法内可能的执行路径的条数。

3.3.3 其他度量

• 布尔表达式中的布尔运算符(&&,||)的个数不超过3个(III) 
• if语句的嵌套层数3层以内(II)
• 文件长度2000行以内(II)
• 匿名内部类20行以内 ( II )
  太长的匿名内部类影响代码可读性，建议重构为命名的（普通）内部类。

3.4 JDK5.0

1. 重载方法必须使用@Override，可避免父类方法改变时导致重载函数失效。
2. 不需要关心的warning信息用@SuppressWarnings("unused"), @SuppressWarnings("unchecked"), @SuppressWarnings("serial") 注释。

4.自动代码检查

   使用Eclipse与 Inellij IDEA的代码校验功能已经排除了很多问题。

   再配合使用Checkstyle，PMD，FindBugs三重检查，总共五层的校验涵盖了Java编码大部分的Guide Line。

   如果要求不苛刻，可以只使用Eclipse或IDEA 搭配 Checkstyle的两重保湿效果。

1. Eclipse：在Windows->Preferences->Java-Compiler->Errors/Warnings中，按本文档将一些原来Ignore的规则打开。
   也可以将springside团队预设在/tools/codereviewer/eclipse.check.prefs的内容拷贝到项目的.setting/org.eclipse.jdt.core.prefs 文件中。
2. IDEA：在Setting->Errors中设定规则，调用Analyzer->Inspece Code进行校验。
3. CheckStyle：安装CheckStyle的Eclipse插件，在Windows->Preferences->CheckStyle导入springside团队预设在/tools/codereviewer/springside_check.xml的规则。
4. PMD：安装PMD的Eclipse插件，Windows->Preferences->PMD清除原来所有规则，导入springside团队预设在/tools/codereviewer/springside_pmd.xml的规则。
5. FindBugs：安装FindBugs的Eclipse插件，在项目属性->FindBugs中，取消下列警告MS/EI/EI2/ ， SnVI/SE/WS/RS ，ST/NP/UwF/SS/UuF|UrF|SIC。

5.参考资料

1. Sun's Coding Conventions Sun MicroSystem；
2. The Elements of Java Style  Scott W. Ambler 等著；
3. 代码检测工具的规则： checkstyle，pmd ，findbugs

      随着光阴推移，Annotation 慢慢在开源框架中推广，泛型渐渐被程序员们用熟，加上AutoBoxing的小糖，SpringSide终于离不开JDK5.0。

1.AutoBoxing 与 For Each 循环

    本来int的非Object性就很无聊，在JDK5.0终于提供了autoboxing功能。这个语法简化糖，被用在了每一个地方。

    for each 循环也改善了原本总要愣一下的collection遍历。不过对于非JDK基本类型，collection必须用泛型声明，如List<Book>。

2. 泛型

    泛型大量用于SpringSide Core中的基类，使子类更简洁，基类更强大。当然，基类是难读了，所以才需要社区花上这么长的时间来把<T>看到顺眼。

    泛型使用的有两个定式：

2.1 避免强制类型转换

   如果函数输入参数里含Class类型，而返回值又是该Class的实体，应该将该函数设为泛型函数。最典型的例子是HibernateGenericDao的get() 函数

public <T> T get(Class<T> entityClass, Serializable id) {
return (T) getHibernateTemplate().get(entityClass, id);
}

  其中眼花缭乱的第一个<T>声明这是一个泛型函数，第2个T声明返回值为T，第三个Class<T>代表 T.class。基类写的辛苦，但子类用得爽快 

   Book book = (Book)manager.get(Book.class,1) 简化成了 Book book = manager.get(Book.class,1);

2. 2 泛型配合反射API从T获得 T.class。

   最典型的例子HibernateEntityDao，子类只需以下定义，即获得要管理的Entity的Class。

BookManager extends HibernateEntityDao<Book>

    此时子类只要声明一次T，上面的Book book = (Book)manager(Book.class,1) 就能简化成Book book = manager.get(1);

    一举两得地既避免了强制类型转换，又声明了T.class 供框架使用，无须再在Manager的构造函数或getEntityClass()函数定义entityClass，。

    反射的API 详见GenricsUtils ，精简的对上面BookManager的定义反射代码如下:

Type genType = clazz.getGenericSuperclass();
Type [] params = ((ParameterizedType) genType).getActualTypeArguments();
return (Class) params[0];

   泛型反射的关键是获取ParameterizedType，再调用它的getActualTypeArguments()方法获得实际绑定的类型。但注意public class BookManager<Book>是不能被反射的，因为擦拭法的缘故。只有在Superclass 或者成员变量(Field.getGenericType())等有函数返回ParameterizedType的时候才能成功反射，，

比如 

public class BookManager extends Manager<Book>{} public class BookAction {    private BookManager<Book> manager;}

 2.3 其他应用

   1. 在XFire中，List getBooksByCategory()函数返回的结果，需要用aegis.xml 文件声明List中的元素为Book.

   而如果定义函数为 List<Book> getBooksByCategory()，就不再需要声明，省掉XMl配置文件。

3.Annotation

     Annotation 大幅提升了Java的编程模式，SpringSide 目前运用的Annotation 有以下三个地方，幸运的是前两者同时也提供JDK1.4的JAVADoc式配置，只是麻烦一点点而已

     3.1. Hibernate Annotation

         使用Hibernate Annotation 代替hbm文件，因为annotation高度的默认性，典型的POJO基本上不需要定义什么，代码的简约性和可管理性大幅提高，直追ROR。

         另外，经过测试，annotation 完全能胜任一些比较复杂的Mapping定义，如Product-Book的父子继承关系，Order-OrderItem-Product的经典三角关系。

     2. XFire JSR181 Annotation

         JSR181声明的Web Service，比原本用xml定义的模式节约了XML文件和配置代码的数量。

     3. 声明Entity类型的Annotation

         使用Annotation 声明Entity的类型，比如Udeletable，Auditable 等，比用接口声明的方式有更少的侵入性，详见 侵入，非侵入？Interface vs Annotation。

4. 三种内置Annotation

JDK5.0 有SuppressWarnings，Deprecated和Override 三种内置的annotation：

  @Override

   此标签一方面提醒用户这是个重载函数，另一方面保证了父类函数的参数或者名字改变时，子类如果没有跟着变化，就会编译不过。

   虽然有点占地方，但用处的确很大，不会哪天子类被人卖了都不知道。

  所以我设置了让IDEA6检查所有重载函数必须加上@Override标识。

  @SuppressWarnings("unchecked")

    此标签可以让编译器忽略某种warning信息，比如减少JDK5.0的集合操作引入范型后无处不在的warning。

    因为有些非JDK5.0的开源库如hibernate, 函数返回的一定是List，而不会是List<User>，这时候IDE就会爆出很多warning。用SuppressWarning("unchecked")可以让IDE安静一些。

    其他常用warning还包括 @SuppressWarnings("unused") 和 SuppressWarnings("serial")

  @Deprecated

   此标签以前写在JavaDoc里，现在提到annotation，注释已废弃的函数。用户使用该函数的话，编译时会得到"你用了废弃"的提示。

5.可变参数

用于HibernateGenericDao中，简化函数接口。

比如 一个public List find(String hql, Object... values)，就支持了如下四种调用，避免了以前的煞费苦心的定义多种接口，然后把参数转成统一模式的大量重复定义。

dao.find(hql);
dao.find(hql,arg0);
dao.find(hql,arg0,arg1);
dao.find(hql,new Object[arg0,arg1])

1)  FilterToBeanProxy
　　Acegi通过实现了Filter接口的FilterToBeanProxy提供一种特殊的使用Servlet Filter的方式，它委托Spring中的Bean -- FilterChainProxy来完成过滤功能，这好处是简化了web.xml的配置，并且充分利用了Spring IOC的优势。FilterChainProxy包含了处理认证过程的filter列表，每个filter都有各自的功能。

    <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>

2) filter-mapping
　　<filter-mapping>限定了FilterToBeanProxy的URL匹配模式,只有*.do和*.jsp和/j_acegi_security_check 的请求才会受到权限控制，对javascript,css等不限制。

   <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>

3) HttpSessionEventPublisher
　　<listener>的HttpSessionEventPublisher用于发布HttpSessionApplicationEvents和HttpSessionDestroyedEvent事件给spring的applicationcontext。

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

2.2 在applicationContext-acegi-security.xml中

2.2.1 FILTER CHAIN

　　FilterChainProxy会按顺序来调用这些filter,使这些filter能享用Spring ioc的功能, CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON定义了url比较前先转为小写， PATTERN_TYPE_APACHE_ANT定义了使用Apache ant的匹配模式

    <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>

2.2.2 基础认证

1) authenticationManager
　　起到认证管理的作用，它将验证的功能委托给多个Provider，并通过遍历Providers, 以保证获取不同来源的身份认证，若某个Provider能成功确认当前用户的身份，authenticate()方法会返回一个完整的包含用户授权信息的Authentication对象，否则会抛出一个AuthenticationException。
Acegi提供了不同的AuthenticationProvider的实现,如：
        DaoAuthenticationProvider 从数据库中读取用户信息验证身份
        AnonymousAuthenticationProvider 匿名用户身份认证
        RememberMeAuthenticationProvider 已存cookie中的用户信息身份认证
        AuthByAdapterProvider 使用容器的适配器验证身份
        CasAuthenticationProvider 根据Yale中心认证服务验证身份, 用于实现单点登陆
        JaasAuthenticationProvider 从JASS登陆配置中获取用户信息验证身份
        RemoteAuthenticationProvider 根据远程服务验证用户身份
        RunAsImplAuthenticationProvider 对身份已被管理器替换的用户进行验证
        X509AuthenticationProvider 从X509认证中获取用户信息验证身份
        TestingAuthenticationProvider 单元测试时使用

        每个认证者会对自己指定的证明信息进行认证，如DaoAuthenticationProvider仅对UsernamePasswordAuthenticationToken这个证明信息进行认证。

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

2) daoAuthenticationProvider
　　进行简单的基于数据库的身份验证。DaoAuthenticationProvider获取数据库中的账号密码并进行匹配，若成功则在通过用户身份的同时返回一个包含授权信息的Authentication对象，否则身份验证失败，抛出一个AuthenticatiionException。

    <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>

3) passwordEncoder
　　使用加密器对用户输入的明文进行加密。Acegi提供了三种加密器:
PlaintextPasswordEncoder—默认，不加密，返回明文.
ShaPasswordEncoder—哈希算法(SHA)加密
Md5PasswordEncoder—消息摘要(MD5)加密

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

4) jdbcDaoImpl
　　用于在数据中获取用户信息。 acegi提供了用户及授权的表结构，但是您也可以自己来实现。通过usersByUsernameQuery这个SQL得到你的(用户ID,密码,状态信息);通过authoritiesByUsernameQuery这个SQL得到你的(用户ID,授权信息)

 <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>

5) userCache　&  resourceCache
　　缓存用户和资源相对应的权限信息。每当请求一个受保护资源时，daoAuthenticationProvider就会被调用以获取用户授权信息。如果每次都从数据库获取的话，那代价很高，对于不常改变的用户和资源信息来说，最好是把相关授权信息缓存起来。(详见 2.6.3 资源权限定义扩展 )
userCache提供了两种实现: NullUserCache和EhCacheBasedUserCache, NullUserCache实际上就是不进行任何缓存，EhCacheBasedUserCache是使用Ehcache来实现缓功能。

    <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>

6) basicProcessingFilter
　　用于处理HTTP头的认证信息，如从Spring远程协议(如Hessian和Burlap)或普通的浏览器如IE,Navigator的HTTP头中获取用户信息，将他们转交给通过authenticationManager属性装配的认证管理器。如果认证成功，会将一个Authentication对象放到会话中，否则，如果认证失败，会将控制转交给认证入口点(通过authenticationEntryPoint属性装配)

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

7) basicProcessingFilterEntryPoint
　　通过向浏览器发送一个HTTP401(未授权)消息，提示用户登录。
处理基于HTTP的授权过程， 在当验证过程出现异常后的"去向"，通常实现转向、在response里加入error信息等功能。

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

8) authenticationProcessingFilterEntryPoint
　　当抛出AccessDeniedException时，将用户重定向到登录界面。属性loginFormUrl配置了一个登录表单的URL,当需要用户登录时，authenticationProcessingFilterEntryPoint会将用户重定向到该URL

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

2.2.3 HTTP安全请求

1) httpSessionContextIntegrationFilter
　　每次request前 HttpSessionContextIntegrationFilter从Session中获取Authentication对象，在request完后, 又把Authentication对象保存到Session中供下次request使用,此filter必须其他Acegi filter前使用，使之能跨越多个请求。

<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>

2) httpRequestAccessDecisionManager
　　经过投票机制来决定是否可以访问某一资源(URL或方法)。allowIfAllAbstainDecisions为false时如果有一个或以上的decisionVoters投票通过,则授权通过。可选的决策机制有ConsensusBased和UnanimousBased

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

3) roleVoter
 　　必须是以rolePrefix设定的value开头的权限才能进行投票,如AUTH_ , ROLE_

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

4）exceptionTranslationFilter
　　异常转换过滤器，主要是处理AccessDeniedException和AuthenticationException，将给每个异常找到合适的"去向" 

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

5) authenticationProcessingFilter
　　和servlet spec差不多,处理登陆请求.当身份验证成功时，AuthenticationProcessingFilter会在会话中放置一个Authentication对象，并且重定向到登录成功页面
         authenticationFailureUrl定义登陆失败时转向的页面
         defaultTargetUrl定义登陆成功时转向的页面
         filterProcessesUrl定义登陆请求的页面
         rememberMeServices用于在验证成功后添加cookie信息

    <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>

6) filterInvocationInterceptor
　　在执行转向url前检查objectDefinitionSource中设定的用户权限信息。首先，objectDefinitionSource中定义了访问URL需要的属性信息(这里的属性信息仅仅是标志，告诉accessDecisionManager要用哪些voter来投票)。然后，authenticationManager掉用自己的provider来对用户的认证信息进行校验。最后，有投票者根据用户持有认证和访问url需要的属性，调用自己的voter来投票，决定是否允许访问。

    <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>

7) filterDefinitionSource (详见 2.6.3 资源权限定义扩展)
　　自定义DBFilterInvocationDefinitionSource从数据库和cache中读取保护资源及其需要的访问权限信息 

<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>

2.2.4 方法调用安全控制

(详见 2.6.3 资源权限定义扩展)

1) methodSecurityInterceptor
　　在执行方法前进行拦截，检查用户权限信息
2) methodDefinitionSource
　　自定义MethodDefinitionSource从cache中读取权限

   <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>

2.3 Jcaptcha验证码

采用 http://jcaptcha.sourceforge.net 作为通用的验证码方案，请参考SpringSide中的例子，或网上的：
http://www.coachthrasher.com/page/blog?entry=jcaptcha_with_appfuse。

差沙在此过程中又发现acegi logout filter的错误，进行了修正。

另外它默认提供的图片比较难认，我们custom了一个美观一点的版本。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=54881

       Acegi安全系统，是一个用于Spring Framework的安全框架，能够和目前流行的Web容器无缝集成。它使用了Spring的方式提供了安全和认证安全服务，包括使用Bean Context，拦截器和面向接口的编程方式。因此，Acegi安全系统能够轻松地适用于复杂的安全需求。
       安全涉及到两个不同的概念，认证和授权。前者是关于确认用户是否确实是他们所宣称的身份。授权则是关于确认用户是否有允许执行一个特定的操作。
       在Acegi安全系统中，需要被认证的用户，系统或代理称为"Principal"。Acegi安全系统和其他的安全系统不同，它并没有角色和用户组的概念。

Acegi系统设计

  关键组件

      Acegi安全系统包含以下七个关键的功能组件：
         l Authentication对象，包含了Principal，Credential和Principal的授权信息。同时还可以包含关于发起认证请求的客户的其他信息，如IP地址。
        2 ContextHolder对象，使用ThreadLocal储存Authentication对象的地方。
        3 AuthenticationManager，用于认证ContextHolder中的Authentication对象。
        4 AccessDecissionManager，用于授权一个特定的操作。
        5 RunAsManager，当执行特定的操作时，用于选择性地替换Authentication对象。
        6 Secure Object拦截器，用于协调AuthenticationManager，AccessDecissionManager，RunAsManager和特定操作的执行。
        7 ObjectDefinitionSource，包含了特定操作的授权定义。

      这七个关键的功能组件的关系如下图所示（图中灰色部分是关键组件）：

  安全管理对象

       Acegi安全系统目前支持两类安全管理对象。
       第一类的安全管理对象管理AOP Alliance的MethodInvocation，开发人员可以用它来保护Spring容器中的业务对象。为了使Spring管理的Bean可以作为MethodInvocation来使用，Bean可以通过ProxyFactoryBean和BeanNameAutoProxyCreator来管理，就像在Spring的事务管理一样使用。
       第二类是FilterInvocation。它用过滤器（Filter）来创建，并简单地包装了HTTP的ServletRequest，ServletResponse和FilterChain。FilterInvocation可以用来保护HTTP资源。通常，开发人员并不需要了解它的工作机制，因为他们只需要将Filter加入web.xml，Acegi安全系统就可以工作了。

  安全配置参数

       每个安全管理对象都可以描述数量不限的各种安全认证请求。例如，MethodInvocation对象可以描述带有任意参数的任意方法的调用，而FilterInvocation可以描述任意的HTTP URL。
       Acegi安全系统需要记录应用于每个认证请求的安全配置参数。例如，对于BankManager.getBalance（int accountNumber）方法和BankManager.approveLoan（int applicationNumber）方法，它们需要的认证请求的安全配置很不相同。
       为了保存不同的认证请求的安全配置，需要使用配置参数。从实现的视角来看，配置参数使用ConfigAttribute接口来表示。Acegi安全系统提供了ConfigAttribute接口的一个实现，SecurityConfig，它把配置参数保存为一个字符串。
       ConfigAttributeDefinition类是ConfigAttribute对象的一个简单的容器，它保存了和特定请求相关的ConfigAttribute的集合。
       当安全拦截器收到一个安全认证请求时，需要决定应用哪一个配置参数。换句话说，它需要找出应用于这个请求的ConfigAttributeDefinition对象。这个查找的过程是由ObjectDefinitionSource接口来处理的。这个接口的主要方法是public ConfigAttributeDefinition getAttributes(Object object)，其中Object参数是一个安全管理对象。因为安全管理对象包含有认证请求的详细信息，所以ObjectDefinitionSource接口的实现类可以从中获得所需的详细信息，以查找相关的ConfigAttributeDefiniton对象。

  Acegi如何工作

       为了说明Acegi安全系统如何工作，我们设想一个使用Acegi的例子。通常，一个安全系统需要发挥作用，它必须完成以下的工作：
       l 首先，系统从客户端请求中获得Principal和Credential；
      2 然后系统认证Principal和Credential信息；
      3 如果认证通过，系统取出Principal的授权信息；
      4 接下来，客户端发起操作请求；
      5 系统根据预先配置的参数检查Principal对于该操作的授权；
      6 如果授权检查通过则执行操作，否则拒绝。

      那么，Acegi安全系统是如何完成这些工作的呢？首先，我们来看看Acegi安全系统的认证和授权的相关类图：

       图中绿色部分是安全拦截器的抽象基类，它包含有两个管理类，AuthenticationManager和AccessDecisionManager，如图中灰色部分。AuthenticationManager用于认证ContextHolder中的Authentication对象（包含了Principal，Credential和Principal的授权信息）；AccessDecissionManager则用于授权一个特定的操作。
      下面来看一个MethodSecurityInterceptor的例子：
      <bean id="bankManagerSecurity"
                     class="net.sf.acegisecurity.intercept.method.MethodSecurityInterceptor">
             <property name="validateConfigAttributes">
                    <value>true</value>
            </property>
            <property name="authenticationManager">
                   <ref bean="authenticationManager"/>
            </property>
            <property name="accessDecisionManager">
                  <ref bean="accessDecisionManager"/>
            </property>
            <property name="objectDefinitionSource">
                  <value>
                     net.sf.acegisecurity.context.BankManager.delete*=
                             ROLE_SUPERVISOR,RUN_AS_SERVER
                     net.sf.acegisecurity.context.BankManager.getBalance=
                             ROLE_TELLER,ROLE_SUPERVISOR,BANKSECURITY_CUSTOMER,RUN_
                  </value>
            </property>
      </bean>

      上面的配置文件中，MethodSecurityInterceptor是AbstractSecurityInterceptor的一个实现类。它包含了两个管理器，authenticationManager和accessDecisionManager。这两者的配置如下：

      <bean id="authenticationDao" class="net.sf.acegisecurity.providers.dao.jdbc.JdbcDaoImpl">
               <property name="dataSource"><ref bean="dataSource"/></property>
      </bean>
      <bean id="daoAuthenticationProvider"
                     class="net.sf.acegisecurity.providers.dao.DaoAuthenticationProvider">
               <property name="authenticationDao"><ref bean="authenticationDao"/></property>
      </bean>
      <bean id="authenticationManager" class="net.sf.acegisecurity.providers.ProviderManager">
               <property name="providers">
                      <list><ref bean="daoAuthenticationProvider"/></list>
               </property>
      </bean>

      <bean id="roleVoter" class="net.sf.acegisecurity.vote.RoleVoter"/>
      <bean id="accessDecisionManager" class="net.sf.acegisecurity.vote.AffirmativeBased">
               <property name="allowIfAllAbstainDecisions"><value>false</value></property>
               <property name="decisionVoters">
                      <list><ref bean="roleVoter"/></list>
               </property>
      </bean>

       准备工作做好了，现在我们来看看Acegi安全系统是如何实现认证和授权机制的。以使用HTTP BASIC认证的应用为例子，它包括下面的步骤：
       1. 用户登录系统，Acegi从acegisecurity.ui子系统的安全拦截器（如BasicProcessingFilter）中得到用户的登录信息（包括Principal和Credential）并放入Authentication对象，并保存在ContextHolder对象中；
       2. 安全拦截器将Authentication对象交给AuthenticationManager进行身份认证，如果认证通过，返回带有Principal授权信息的Authentication对象。此时ContextHolder对象的Authentication对象已拥有Principal的详细信息；
       3. 用户登录成功后，继续进行业务操作；
       4. 安全拦截器（bankManagerSecurity）收到客户端操作请求后，将操作请求的数据包装成安全管理对象（FilterInvocation或MethodInvocation对象）；
       5. 然后，从配置文件（ObjectDefinitionSource）中读出相关的安全配置参数ConfigAttributeDefinition；
       6. 接着，安全拦截器取出ContextHolder中的Authentication对象，把它传递给AuthenticationManager进行身份认证，并用返回值更新ContextHolder的Authentication对象；
       7. 将Authentication对象，ConfigAttributeDefinition对象和安全管理对象（secure Object）交给AccessDecisionManager，检查Principal的操作授权；
       8. 如果授权检查通过则执行客户端请求的操作，否则拒绝；

  AccessDecisionVoter

       注意上节的accessDecisionManager是一个AffirmativeBased类，它对于用户授权的投票策略是，只要通过其中的一个授权投票检查，即可通过；它的allowIfAllAbstainDecisions属性值是false，意思是如果所有的授权投票是都是弃权，则通不过授权检查。
       Acegi安全系统包括了几个基于投票策略的AccessDecisionManager，上节的RoleVoter就是其中的一个投票策略实现，它是AccessDecisionVoter的一个子类。AccessDecisionVoter的具体实现类通过投票来进行授权决策，AccessDecisionManager则根据投票结果来决定是通过授权检查，还是抛出AccessDeniedException例外。
       AccessDecisionVoter接口共有三个方法：
public int vote(Authentication authentication, Object object, ConfigAttributeDefinition config);
public boolean supports(ConfigAttribute attribute);
public boolean supports(Class clazz);
       其中的vote方法返回int返回值，它们是AccessDecisionVoter的三个静态成员属性：ACCESS_ABSTAIN,，ACCESS_DENIED和ACCESS_GRANTED，它们分别是弃权，否决和赞成。
       Acegi安全系统中，使用投票策略的AccessDecisionManager共有三个具体实现类：AffirmativeBased、ConsensusBased和UnanimousBased。它们的投票策略是，AffirmativeBased类只需有一个投票赞成即可通过；ConsensusBased类需要大多数投票赞成即可通过；而UnanimousBased类需要所有的投票赞成才能通过。
       RoleVoter类是一个Acegi安全系统AccessDecisionVoter接口的实现。如果ConfigAttribute以ROLE_开头，RoleVoter则进行投票。如果GrantedAuthority的getAutority方法的String返回值匹配一个或多个以ROLE_开头的ConfigAttribute，则投票通过，否则不通过。如果没有以ROLE_开头的ConfigAttribute，RoleVoter则弃权。

安全拦截器

  拦截器如何工作
  MethodInvocation拦截器
  FilterInvocation拦截器

认证

  认证请求
  认证管理器
  Authentication Provider

授权

  Access Decision Manager
  Voting Decision Manager
  授权管理推荐

ContextHolder的用户接口

  用户接口目标
  HTTP会话认证
  HTTP Basic认证

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1356799

      <bean id="bankManagerSecurity" 
                     class="net.sf.acegisecurity.intercept.method.MethodSecurityInterceptor">
             <property name="validateConfigAttributes">
                    <value>true</value>
            </property>
            <property name="authenticationManager">
                   <ref bean="authenticationManager"/>
            </property>
            <property name="accessDecisionManager">
                  <ref bean="accessDecisionManager"/>
            </property>
            <property name="objectDefinitionSource">
                  <value>
                     net.sf.acegisecurity.context.BankManager.delete*=
                             ROLE_SUPERVISOR,RUN_AS_SERVER
                     net.sf.acegisecurity.context.BankManager.getBalance=
                             ROLE_TELLER,ROLE_SUPERVISOR,BANKSECURITY_CUSTOMER,RUN_
                  </value>
            </property>
      </bean> 

<bean id="authenticationDao" class="net.sf.acegisecurity.providers.dao.jdbc.JdbcDaoImpl">
               <property name="dataSource"><ref bean="dataSource"/></property>
      </bean>
      <bean id="daoAuthenticationProvider" 
                     class="net.sf.acegisecurity.providers.dao.DaoAuthenticationProvider">
               <property name="authenticationDao"><ref bean="authenticationDao"/></property>
      </bean>
      <bean id="authenticationManager" class="net.sf.acegisecurity.providers.ProviderManager">
               <property name="providers">
                      <list><ref bean="daoAuthenticationProvider"/></list>
               </property>
      </bean>
      <bean id="roleVoter" class="net.sf.acegisecurity.vote.RoleVoter"/>
      <bean id="accessDecisionManager" class="net.sf.acegisecurity.vote.AffirmativeBased">
               <property name="allowIfAllAbstainDecisions"><value>false</value></property>
               <property name="decisionVoters">
                      <list><ref bean="roleVoter"/></list>
               </property>
      </bean>

 log4j.rootLogger=debug, stdout, R
  log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

  # Pattern to output the caller's file name and line number.
  log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

  log4j.appender.R=org.apache.log4j.RollingFileAppender
  log4j.appender.R.File=example.log
  log4j.appender.R.MaxFileSize=100KB

  # Keep one backup file
  log4j.appender.R.MaxBackupIndex=1

  log4j.appender.R.layout=org.apache.log4j.PatternLayout
  log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

 import com.foo.Bar;
  import org.apache.log4j.Logger;
  import org.apache.log4j.PropertyConfigurator;
  public class MyApp {
    static Logger logger = Logger.getLogger(MyApp.class.getName());
    public static void main(String[] args) {
      // BasicConfigurator replaced with PropertyConfigurator.
      PropertyConfigurator.configure(args[0]);
      logger.info("Entering application.");
      Bar bar = new Bar();
      bar.doIt();
      logger.info("Exiting application.");
    }
  }

<filter>
  <filter-name>Acegi Channel Processing Filter</filter-name>
  <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class>
  <init-param>
    <param-name>targetClass</param-name>
    <param-value>net.sf.acegisecurity.securechannel.ChannelProcessingFilter</param-value>
  </init-param>
</filter>
<filter>
  <filter-name>Acegi Authentication Processing Filter</filter-name>
  <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class>
  <init-param>
    <param-name>targetClass</param-name>
    <param-value>net.sf.acegisecurity.ui.webapp.AuthenticationProcessingFilter</param-value>
  </init-param>
</filter>
<filter>
  <filter-name>Acegi HTTP BASIC Authorization Filter</filter-name>
  <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class>
  <init-param>
    <param-name>targetClass</param-name>
    <param-value>net.sf.acegisecurity.ui.basicauth.BasicProcessingFilter</param-value>
  </init-param>
</filter>
<filter>
  <filter-name>Acegi Security System for Spring Auto Integration Filter</filter-name>
  <filter-class>net.sf.acegisecurity.ui.AutoIntegrationFilter</filter-class>
</filter>
<filter>
  <filter-name>Acegi HTTP Request Security Filter</filter-name>
  <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class>
  <init-param>
    <param-name>targetClass</param-name>
    <param-value>net.sf.acegisecurity.intercept.web.SecurityEnforcementFilter</param-value>
  </init-param>
</filter>

<filter-mapping>
  <filter-name>Acegi Channel Processing Filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
  <filter-name>Acegi Authentication Processing Filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
  <filter-name>Acegi HTTP BASIC Authorization Filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
  <filter-name>Acegi Security System for Spring Auto Integration Filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
  <filter-name>Acegi HTTP Request Security Filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

CREATE TABLE users (
    username VARCHAR(50) NOT NULL PRIMARY KEY,
    password VARCHAR(50) NOT NULL,
    enabled BIT NOT NULL
);
CREATE TABLE authorities (
    username VARCHAR(50) NOT NULL,
    authority VARCHAR(50) NOT NULL
);
CREATE UNIQUE INDEX ix_auth_username ON authorities ( username, authority );
ALTER TABLE authorities ADD CONSTRAINT fk_authorities_users foreign key (username) REFERENCES users
(username);

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  <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>
<bean id="jdbcDaoImpl" class="net.sf.acegisecurity.providers.dao.jdbc.JdbcDaoImpl">
  <property name="dataSource"><ref bean="dataSource"/></property>
</bean>

<bean id="daoAuthenticationProvider" class="net.sf.acegisecurity.providers.dao.DaoAuthenticationProvider">
  <property name="authenticationDao"><ref bean="authenticationDao"/></property>
  <property name="userCache"><ref bean="userCache"/></property>
</bean>

<bean id="userCache" class="net.sf.acegisecurity.providers.dao.cache.EhCacheBasedUserCache">
  <property name="minutesToIdle"><value>5</value></property>
</bean>

<bean id="authenticationManager" class="net.sf.acegisecurity.providers.ProviderManager">
  <property name="providers">
    <list>
      <ref bean="daoAuthenticationProvider"/>
    </list>
   </property>
</bean>

<bean id="accessDecisionManager" class="net.sf.acegisecurity.vote.AffirmativeBased">
  <property name="allowIfAllAbstainDecisions">
    <value>false</value>
  </property>
  <property name="decisionVoters">
    <list><ref bean="roleVoter"/></list>
  </property>
</bean>
<bean id="roleVoter" class="net.sf.acegisecurity.vote.RoleVoter"/>

<bean id="authenticationProcessingFilterEntryPoint" 
class="net.sf.acegisecurity.ui.webapp.AuthenticationProcessingFilterEntryPoint">
  <property name="loginFormUrl"><value>/acegilogin.jsp</value></property>
  <property name="forceHttps"><value>false</value></property>
</bean>

<%@ taglib prefix='c' uri='http://java.sun.com/jstl/core' %>
<%@ page import="net.sf.acegisecurity.ui.AbstractProcessingFilter" %>
<%@ page import="net.sf.acegisecurity.AuthenticationException" %>
<html>
  <head>
    <title>Login</title>
  </head>

  <body>
    <h1>Login</h1>
    <form action="<c:url value='j_acegi_security_check'/>" method="POST">
      <table>
        <tr><td>User:</td><td><input type='text' name='j_username'></td></tr>
        <tr><td>Password:</td><td><input type='password' name='j_password'></td></tr>
        <tr><td colspan='2'><input name="submit" type="submit"></td></tr>
        <tr><td colspan='2'><input name="reset" type="reset"></td></tr>
      </table>
    </form>
  </body>
</html>

<bean id="filterInvocationInterceptor" 
class="net.sf.acegisecurity.intercept.web.FilterSecurityInterceptor">
  <property name="authenticationManager">
    <ref bean="authenticationManager"/>
  </property>
  <property name="accessDecisionManager">
    <ref bean="accessDecisionManager"/>
  </property>
  <property name="objectDefinitionSource">
    <value>
      CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
      \A/sec/administrator.*\Z=ROLE_SUPERVISOR
      \A/sec/user.*\Z=ROLE_TELLER
    </value>
  </property>
</bean>

<bean id="securityEnforcementFilter" class="net.sf.acegisecurity.intercept.web.SecurityEnforcementFilter">
  <property name="filterSecurityInterceptor">
    <ref bean="filterInvocationInterceptor"/>
  </property>
  <property name="authenticationEntryPoint">
    <ref bean="authenticationProcessingFilterEntryPoint"/>
  </property>
</bean>

<bean id="authenticationProcessingFilter" 
class="net.sf.acegisecurity.ui.webapp.AuthenticationProcessingFilter">
  <property name="authenticationManager">
    <ref bean="authenticationManager"/>
  </property>
  <property name="authenticationFailureUrl">
    <value>/loginerror.jsp</value>
  </property>
  <property name="defaultTargetUrl">
    <value>/</value>
  </property>
  <property name="filterProcessesUrl">
    <value>/j_acegi_security_check</value>
  </property>
</bean>

<bean id="channelProcessingFilter" class="net.sf.acegisecurity.securechannel.ChannelProcessingFilter">
  <property name="channelDecisionManager">
    <ref bean="channelDecisionManager"/>
  </property>
  <property name="filterInvocationDefinitionSource">
    <value>
      CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
      \A/sec/administrator.*\Z=REQUIRES_SECURE_CHANNEL
      \A/acegilogin.jsp.*\Z=REQUIRES_SECURE_CHANNEL
      \A/j_acegi_security_check.*\Z=REQUIRES_SECURE_CHANNEL
      \A.*\Z=REQUIRES_INSECURE_CHANNEL
    </value>
  </property>
</bean>

<bean id="channelDecisionManager" class="net.sf.acegisecurity.securechannel.ChannelDecisionManagerImpl">
  <property name="channelProcessors">
    <list>
      <ref bean="secureChannelProcessor"/>
      <ref bean="insecureChannelProcessor"/>
    </list>
  </property>
</bean>
<bean id="secureChannelProcessor" class="net.sf.acegisecurity.securechannel.SecureChannelProcessor"/>
<bean id="insecureChannelProcessor" class="net.sf.acegisecurity.securechannel.InsecureChannelProcessor"/>

<bean name="/shop/newAccount.do" class="org.springframework.samples.jpetstore.web.spring.AccountFormController">
    <property name="petStore"><ref bean="petStore"/></property>
    <property name="validator"><ref bean="accountValidator"/></property>
    <property name="successView"><value>index</value></property>
  </bean>

<bean name="/shop/signon.do" class="org.springframework.samples.jpetstore.web.spring.SignonController">
    <property name="petStore"><ref bean="petStore"/></property>
  </bean>
  <bean name="/shop/signonForm.do" class="org.springframework.web.servlet.mvc.ParameterizableViewController">
    <property name="viewName"><value>SignonForm</value></property>
  </bean>

<bean id="secureHandlerMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="interceptors">
      <list>
        <ref bean="signonInterceptor"/>
      </list>
    </property>
    <property name="urlMap">
      <map>
        <entry key="/shop/editAccount.do"><ref local="secure_editAccount"/></entry>
        <entry key="/shop/listOrders.do"><ref local="secure_listOrders"/></entry>
        <entry key="/shop/newOrder.do"><ref local="secure_newOrder"/></entry>
        <entry key="/shop/viewOrder.do"><ref local="secure_viewOrder"/></entry>
      </map>
    </property>
  </bean>

  原来，上面的signonInterceptor实现了preHandle，因此在请求上面的map页面时，首先要经过这个Interceptor，看看 SignonInterceptor的源码，原来在其中为signon.jsp赋予一个signonForwardAction对象，呵呵，总算明白了。
3). 接下来去学习一下SignonController，其主体部分中可以看出，首先取出用户输入的username和password，然后到数据库中验证 有没有这个用户，如果没有这个用户，返回各错误页面；如果成功，首先生成一个UserSession对象，在request的session加入这个 userSession，注意这部分代码中给出了PagedListHolder分页的简单使用方法，关于分页显示，以后再学习吧。
3、登录成功后，就可以根据不同的用户设施不同的行为了，取得用户信息，无非就是从session取出userSession即可。

链接：http://www.matrix.org.cn/resource/article/1/1730_Acegi.html

    本文档反映的是SpringSide 团队的编码规范，同时推荐所有使用SpringSide框架的开发人员遵循。

    本文档基本遵循Sun's Coding Conventions，补充了其中没有说明或者有所改动的地方。

版权声明   

    本规范由springside团队维护，相关评论与意见请发至springside@gmail.com，转载请注明出处。

规范等级说明

• 级别I:   默认级别，要求所有项目中的所有成员遵守。
• 级别II:  建议所有项目中的所有成员遵守。
• 级别III: 鼓励各个项目根据实际情况执行。

1.格式与命名规范(Formating and Naming Conventions)

1.1  缩进

  使用Tab缩进，而不是空格键--将缩进2，4，8字符的选择权留给阅读者。

1.2 换行

   每行120字符--因为已是1024*768的年代。

   if,for,while语句只有单句时，如果该句可能引起阅读混淆，需要用" {"和"}"括起来，否则可以省略。

//错误，需要使用花括号{}括起来
if (condition)
if(condition) doSomething();
else
doSomething();

1.3 命名规则 

• 不允许使用汉语拼音命名 
• 遇到缩写如XML时，仅首字母大写，即loadXmlDocument()而不是loadXMLDocument()
• Package名必须全部小写，尽量使用单个单词
• Interface名可以是一个名词或形容词(加上'able','ible', or 'er'后缀)，如Runnable，Accessible。
  为了基于接口编程，不采用首字母为I或加上IF后缀的命名方式，如IBookDao,BookDaoIF。
• 页面部件名建议命名为：btnOK、lblName或okBtn、nameLbl。(II)
  其中btn、lbl缩写代表按钮(Button)、标签(Label)。
• 局部变量及输入参数不要与类成员变量同名(get/set方法与构造函数除外)

1.4 声明

• 修饰符应该按照如下顺序排列：public, protected, private, abstract, static, final, transient, volatile, synchronized, native, strictfp。
• 类与接口的声明顺序(可用Eclipse的source->sort members功能自动排列): 
  1. 静态成员变量 / Static Fields
  2. 静态初始化块 / Static Initializers
  3. 成员变量 / Fields
  4. 初始化块 / Initializers
  5. 构造器 / Constructors
  6. 静态成员方法 / Static Methods
  7. 成员方法 / Methods
  8. 重载自Object的方法如toString(), hashCode() 和main方法
  9. 类型(内部类) / Types(Inner Classes)

     同等的类型，按public, protected, private的顺序排列。

2.注释规范(Document Convertions)

2.1 注释类型

2.1.1 JavaDoc注释

  略。

2.1.2 失效代码注释

  由/*...*/界定，标准的C-Style的注释。专用于注释已失效的代码。

/*
 * Comment out the code
 * String s = "hello";
* System.out.println(s);
 */

2.1.3 代码细节注释

  由//界定，专用于注释代码细节，即使有多行注释也仍然使用//，以便与用/**/注释的失效代码分开

  除了私有变量外，不推荐使用行末注释。

class MyClass {
private int myField; // An end-line comment.

public void myMethod {
//a very very long
       //comment.
       if (condition1) {
//condition1 comment
          ...
} else {
//elses condition comment
          ...
}
}
}

2.2 注释的格式

• 注释中的第一个句子要以（英文）句号、问号或者感叹号结束。Javadoc生成工具会将注释中的第一个句子放在方法汇总表和索引中。
• 为了在JavaDoc和IDE中能快速链接跳转到相关联的类与方法，尽量多的使用@see xxx.MyClass，@see xx.MyClass#find(String)。
• Class必须以@author 作者名声明作者，不需要声明@version与@date，由版本管理系统保留此信息。(II)
• 如果注释中有超过一个段落，用<p>分隔。(II)
• 示例代码以<pre></pre>包裹。(II)
• 标识(java keyword, class/method/field/argument名，Constants) 以<code></code>包裹。(II)
• 标识在第一次出现时以{@linkxxx.Myclass}注解以便JavaDoc与IDE中可以链接。(II)

2.3 注释的内容

2.3.1 可精简的注释内容

    注释中的每一个单词都要有其不可缺少的意义，注释里不写"@param name -名字"这样的废话。
    如果该注释是废话，连同标签删掉它，而不是自动生成一堆空的标签，如空的@param name，空的@return。

2.3.2 推荐的注释内容

• 对于API函数如果存在契约，必须写明它的前置条件(precondition)，后置条件(postcondition)，及不变式(invariant)。(II)
• 对于调用复杂的API尽量提供代码示例。(II)
• 对于已知的Bug需要声明。(II)
• 在本函数中抛出的unchecked exception尽量用@throws说明。(II)

2.3.3 Null规约

   如果方法允许Null作为参数，或者允许返回值为Null，必须在JavaDoc中说明。
   如果没有说明，方法的调用者不允许使用Null作为参数，并认为返回值是Null Safe的。

/**
 * 获取对象.
 *
 * @ return the object to found or null if not found.
 */
Object get(Integer id){
...
}

2.3.4 特殊代码注释

• 代码质量不好但能正常运行，或者还没有实现的代码用//TODO: 或 //XXX:声明 
• 存在错误隐患的代码用//FIXME:声明

3.编程规范(Programming Conventions)

3.1基本规范

1. 当面对不可知的调用者时，方法需要对输入参数进行校验，如不符合抛出IllegalArgumentException，建议使用Spring的Assert系列函数。 
2. 隐藏工具类的构造器，确保只有static方法和变量的类不能被构造实例。
3. 变量，参数和返回值定义尽量基于接口而不是具体实现类，如Map map = new HashMap();
4. 代码中不能使用System.out.println()，e.printStackTrace()，必须使用logger打印信息。

3.2 异常处理

1. 重新抛出的异常必须保留原来的异常，即throw new NewException("message", e); 而不能写成throw new NewException("message")。
2. 在所有异常被捕获且没有重新抛出的地方必须写日志。 
3. 如果属于正常异常的空异常处理块必须注释说明原因，否则不允许空的catch块。
4. 框架尽量捕获低级异常，并封装成高级异常重新抛出，隐藏低级异常的细节。(III)

3.3 代码度量

3.3.1 耦合度度量

• DAC度量值不要不大于7 ( III )
  解释：DAC(Data Abstraction Coupling)数据抽象耦合度是描述对象之间的耦合度的一种代码度量。DAC度量值表示一个类中有实例化的其它类的个数。
• CFO度量值不要不大于20 ( III )
  解释：CFO(Class Fan Out)类扇出是描述类之间的耦合度的一种代码度量。CFO度量值表示一个类依赖的其他类的个数。

3.3.2 方法度量

• 方法（构造器）参数在5个以内 ( II )
  太多的方法（构造器）参数影响代码可读性。考虑用值对象代替这些参数或重新设计。
• 方法长度150行以内 ( II )
• CC 度量值不大于10(III )
  解释：CC(CyclomaticComplexity)圈复杂度指一个方法的独立路径的数量，可以用一个方法内if,while,do,for,catch,switch,case,?:语句与&&,||操作符的总个数来度量。
• NPath度量值不大于200 ( III )
  解释：NPath度量值表示一个方法内可能的执行路径的条数。

3.3.3 其他度量

• 布尔表达式中的布尔运算符(&&,||)的个数不超过3个(III) 
• if语句的嵌套层数3层以内(II)
• 文件长度2000行以内(II)
• 匿名内部类20行以内 ( II )
  太长的匿名内部类影响代码可读性，建议重构为命名的（普通）内部类。

3.4 JDK5.0

1. 重载方法必须使用@Override，可避免父类方法改变时导致重载函数失效。
2. 不需要关心的warning信息用@SuppressWarnings("unused"), @SuppressWarnings("unchecked"), @SuppressWarnings("serial") 注释。

4.自动代码检查

   使用Eclipse与 Inellij IDEA的代码校验功能已经排除了很多问题。

   再配合使用Checkstyle，PMD，FindBugs三重检查，总共五层的校验涵盖了Java编码大部分的Guide Line。

   如果要求不苛刻，可以只使用Eclipse或IDEA 搭配 Checkstyle的两重保湿效果。

1. Eclipse：在Windows->Preferences->Java-Compiler->Errors/Warnings中，按本文档将一些原来Ignore的规则打开。
   也可以将springside团队预设在/tools/codereviewer/eclipse.check.prefs的内容拷贝到项目的.setting/org.eclipse.jdt.core.prefs 文件中。
2. IDEA：在Setting->Errors中设定规则，调用Analyzer->Inspece Code进行校验。
3. CheckStyle：安装CheckStyle的Eclipse插件，在Windows->Preferences->CheckStyle导入springside团队预设在/tools/codereviewer/springside_check.xml的规则。
4. PMD：安装PMD的Eclipse插件，Windows->Preferences->PMD清除原来所有规则，导入springside团队预设在/tools/codereviewer/springside_pmd.xml的规则。
5. FindBugs：安装FindBugs的Eclipse插件，在项目属性->FindBugs中，取消下列警告MS/EI/EI2/ ， SnVI/SE/WS/RS ，ST/NP/UwF/SS/UuF|UrF|SIC。

5.参考资料

1. Sun's Coding Conventions Sun MicroSystem；
2. The Elements of Java Style  Scott W. Ambler 等著；
3. 代码检测工具的规则： checkstyle，pmd ，findbugs

本文是我在SpringFramework中文论坛上看到的一篇文章，感觉不错，所以就收藏到Blog上

原文地址：http://spring.jactiongroup.net/viewtopic.php?t=389

其实，就算用Java建造一个不是很烦琐的web应用，也不是件轻松的事情。 在构架的一开始就有很多事情要考虑。 从高处看，摆在开发者面前有很多问题：要考虑是怎样建立用户接口？在哪里处理业务逻辑？ 怎样持久化的数据。 而这三层构架中，每一层都有他们要仔细考虑的。 各个层该使用什么技术？ 怎样的设计能松散耦合还能灵活改变？ 怎样替换某个层而不影响整体构架？应用程序如何做各种级别的业务处理（比如事务处理）？



构架一个Web应用需要弄明白好多问题。 幸运的是，已经有不少开发者已经遇到过这类问题，并且建立了处理这类问题的框架。 一个好框架具备以下几点： 减轻开发者处理复杂的问题的负担（“不重复发明轮子”）； 内部有良好的扩展； 并且有一个支持它的强大的用户团体。 好的构架一般有针对性的处理某一类问题，并且能将它做好（Do One Thing well）。 然而，你的程序中有几个层可能需要使用特定的框架，已经完成的UI(用户接口) 并不代表你也可以把你的业务逻辑和持久逻辑偶合到你的UI部分。 举个例子， 你不该在一个Controller(控制器)里面写JDBC代码作为你的业务逻辑， 这不是控制器应该提供的。 一个UI 控制器应该委派给其它给在UI范围之外的轻量级组件。 好的框架应该能指导代码如何分布。 更重要的是，框架能把开发者从编码中解放出来，使他们能专心于应用程序的逻辑（这对客户来说很重要）。



这篇文章将讨论怎样结合几种著名的框架来使得你的应用程序做到松弛耦合。

如何建立你的架构，并且怎样让你的各个应用层保持一致。？如何整合框架以便让每个层在以一种松散偶合的方式彼此作用而不用管低层的技术细节？这对我们来说真是一种挑战。 这里讨论一个整合框架的策略( 使用3 种受欢迎的开源框架) ：表示层我们用Struts； 业务层我们用Spring；而持久层则用Hibernate。 你也可以用其他FrameWork替换只要能得到同样的效果。 见图1 （框架组合示意图）



应用程序的分层

大部分的Web应用在职责上至少能被分成4层。 这四层是：presentation（描述），persistence（持久），business（业务）和domain model（域模块）。每个层在处理程序上都应该有一项明确的责任, 而不应该在功能上与其它层混合，并且每个层要与其它层分开的，但要给他们之间放一个通信接口。 我们就从介绍各个层开始，讨论一下这些层应该提供什么，不应该提供什么。



表示层(The Presentation Layer)

一般来讲，一个典型的Web应用的的末端应该是表示层。 很多Java发者也理解Struts所提供的。 象业务逻辑之类的被打包到org.apache.struts.Action.， 因此，我们很赞成使用Struts这样的框架。



下面是Struts所负责的：

* 管理用户的请求,做出相应的响应。

* 提供一个Controller ,委派调用业务逻辑和其它上层处理。

* 处理异常，抛给Struts Action

* 为显示提供一个模型

* UI验证。



以下条款，不该在Struts显示层的编码中经常出现。 它们与显示层无关的。

* 直接的与数据库通信，例如JDBC调用。

* 与你应用程序相关联的业务逻辑以及校验。

* 事物管理。

在表示层引入这些代码，则会带来高偶合和麻烦的维护。





持久层(The Persistence Layer)

典型的Web应用的另一个末端是持久层。这里通常是程序最容易失控的地方。开发者总是低估构建他们自己的持久框架的挑战性。系统内部的持续层不但需要大量调试时间，而且还经常缺少功能使之变得难以控制，这是持久层的通病。 还好有几个ORM开源框架很好的解决了这类问题。尤其是Hibernate。 Hibernate为java提供了OR持久化机制和查询服务, 它还给已经熟悉SQL和JDBC API 的Java开发者一个学习桥梁，他们学习起来很方便。 Hibernate的持久对象是基于POJO和Java collections。此外，使用Hibernate并不妨碍你正在使用的IDE。



请看下面的条目，你在持久层编码中需要了解的。

* 查询对象的相关信息的语句。 Hibernate通过一个OO查询语言（HQL）或者正则表达的API来完成查询。 HQL非常类似于SQL-- 只是把SQL里的table和columns用Object和它的fields代替。 你需要学习一些新的HQL语言； 不管怎样，他们容易理解而文档也做的很好。 HQL是一种对象查询的自然语言，花很小的代价就能学习它。

* 如何存储，更新，删除数据库记录。

* 象Hibernate这类的高级ORM框架支持大部分主流数据库，并且他们支持 Parent/child关系，事物处理，继承和多态。



业务层（The Business Layer）

一个典型Web应用的中间部分是业务层或者服务层。 从编码的视角来看，这层是最容易被忽视的一层。 而我们却往往在UI层或持久层周围看到这些业务处理的代码，这其实是不正确的，因为它导致了程序代码的紧密偶合，这样一来，随着时间推移这些代码很难维护。幸好，针对这一问题有好几种Frameworks存在。 最受欢迎的两个框架是Spring和PicoContainer。 这些为也被称为microcontainers，他们能让你很好的把对象搭配起来。 这两个框架都着手于‘依赖注射’(dependency injection)(还有我们知道的‘控制反转’Inversion of Control=IoC)这样的简单概念。 这篇文章将关注于Spring的注射（译注：通过一个给定参数的Setter方法来构造Bean,有所不同于Factory）, Spring还提供了Setter Injection(type2)，Constructor Injection(type3)等方式供我们选择。 Spring把程序中所涉及到包含业务逻辑和Dao的Objects——例如transaction management handler（事物管理控制）、Object Factoris(对象工厂)、service objects（服务组件）——都通过XML来配置联系起来。



后面我们会举个例子来揭示一下Spring 是怎样运用这些概念。

业务层所负责的如下：

* 处理应用程序的 业务逻辑和业务校验

* 管理事物

* 允许与其它层相互作用的接口

* 管理业务层级别的对象的依赖。

* 在显示层和持久层之间增加了一个灵活的机制，使得他们不直接的联系在一起。

* 通过揭示 从显示层到业务层之间的Context来得到business services。

* 管理程序的执行（从业务层到持久层）。





域模块层（The Domain Model Layer ）
既然我们致力于的是一个不是很复杂的Web的应用， 我们需要一个对象集合，让它在不同层之间移动的。 域模块层由实际需求中的业务对象组成 比如, OrderLineItem , Product等等。 开发者在这层 不用管那些DTOs，仅关注domain object即可。 例如，Hibernate允许你将数据库中的信息存放入对象（domain objects），这样你可以在连接断开的情况下把这些数据显示到UI层。 而那些对象也可以返回给持续层，从而在数据库里更新。 而且，你不必把对象转化成DTOs（这可能似的它在不同层之间的在传输过程中丢失），这个模型使得Java开发者能很自然运用OO，而不需要附加的编码。

一个简单例子



既然我们已经从全局上理解这些组件。 现在就让我们开始实践吧。 我们还是用 Struts，Spring 和Hibernate。这三个框架已经被描述够多了，这里就不重复介绍了。 这篇文章举例指导你如何使用这三个框架整合开发, 并向你揭示 一个请求是如何贯穿于各个层的。（从用户的加入一个Order到数据库，显示；进而更新、删除）。



从这里可以下载到程序程序原代码（download）

既然每个层是互相作用的，我们就先来创建domain objects。首先，我们要在这些Object中要确定那些是需要持久化的，哪些是提供给business logic，那些是显示接口的设计。 下一步，我们将配置我们的持久层并且定义好Hibernate的OR mappings。然后定义好Business Objects。有了这些组成部分之后，我们将 使用Spring把这些连接起来。 最后，我们提供给Spring一个持久层，从这个持久层里我们可以知道它是如何与业务逻辑层（business service layer）通信的，以及它是怎样处理其他层抛出的异常的。。



域对象层（Domain Object Layer）


这层是编码的着手点，我们的编码就从这层开始。 例子中Order 与OrderItem 是一个One—To—Many的关系。 下面就是Domain Object Layer的两个对象：



· com.meagle.bo.Order.java: 包含了一个Order的概要信息

· com.meagle.bo.OrderLineItem.java: 包含了Order的详细信息

好好考虑怎你的package命名,这反应出了你是怎样分层的。 例如 domain objects在程序中可能打包在com.meagle.bo内。 更详细一点将打包在com. meagle.bo的子目录下面。business logic应该从com.meagle.serice开始打包，而DAO 对象应该位于com.meagle.service.dao.hibernate。反应Forms和Actions的 持久对象（presentation classes） 应该分别放在 com.meagle.action和com.meagle.forms包。 准确的给包命名使得你的classes很好分割并且易于维护，并且在你添加新的classes时，能使得程序结构上保持上下一致。

持久层的配置（Persistence Layer Configuration）

建立Hibernate的持久层 需要好几个步骤。 第一步让我们把BO持久化。 既然Hibernate是通过POJO工作的， 因此Order和 OrderLineItem对象需要给所有的fileds 加上getter,setter方法。 Hibernate通过XML文件来映射(OR)对象，以下两个xml文件分别映射了Order 和OrderItem对象。（这里有个叫XDoclet工具可以自动生成你的XML影射文件）

- Order.hbm.xml
- OrderLineItem.hbm.xml

你可以在WebContent/WEB-INF/classes/com/meagle/bo目录下找到这些xml文件。Hibernate的 [urlhttp://www.hibernate.org/hib_docs/api/net/sf/hibernate/SessionFactory.html]SessionFactory [/url]是用来告诉程序 应该与哪个数据库通信，该使用哪个连接池或使用了DataSource， 应该加载哪些持久对象。而Session接口是用来完成Selecting，Saving，Delete和Updating这些操作。 后面的我们将讲述SessionFactory和Session是怎样设置的。

业务层的配置（Business Layer Configuration）

既然我们已经有了domain objects，接下来我们就要business service objects了，用他们来执行程序的logic,调用持久层，得到UI层的requests,处理transactions，并且控制exceptions。 为了将这些连接起来并且易于管理，我们将使用面向方面的 SpringFramework。 Spring 提供了 控制倒置（inversion of control 0==IoC)和注射依赖设置（setter dependency injection）这些方式（可供选择），用XML文件将对象连接起来。 IoC是一个简单概念（它允许一个对象在上层接受其他对象的创建），用IoC这种方式让你的对象从创建中释放了出来，降低了偶合度。




这里是一个没有使用IoC的对象创建的例子，它有很高偶合度。




图 2.没有使用 IoC. A 创建了 B 和 C

而这里是一个使用IoC的例子，这种方式允许对象在高层可以创建并进入另外一个对象，所以这样可以直接被执行。


图 3. 对象使用了 IoC。 A 包含了接受B,C的 setter方法 , 这同样达到了 由A创建B,C的目的。

建立我们的业务服务对象（Building Our Business Service Objects）


Business Object中的Setter方法接受的是接口，这样我们可以很松散的定义对象实现，然后注入。 在我们的案例中，我们将用一个business service object接收一个DAO,用它来控制domain objects的持久化。 由于在这个例子中使用了Hibernate，我们可以很方便的用其他持久框架实现 同时通知Spring 有新的DAO可以使用了。

在面向接口的编程中，你会明白 “注射依赖”模式是怎样松散耦合你的业务逻辑和持久机制的：）。



下面是一个接口business service object，DAO代码片段：

图4 是我们对象搭建的一个提纲。 从中可以看出，每个对象都联系着Spring，并且能通过Spring注入到其他对象。把它与Spring的配置文件比较，观察他们之间的关系



图 4. Spring就是这样基于配置文件，将各个Bean搭建在一起。

这个例子使用一个TransactionProxyFactoryBean，它定义了一个setTransactionManager()。 这对象很有用，他能很方便的处理你申明的事物还有Service Object。 你可以通过transactionAttributes属性来定义怎样处理。 想知道更多还是参考TransactionAttributeEditor吧。

TransactionProxyFactoryBean 还有个setter. 这会被我们 Business service object（orderTarget）引用， orderTarget定义了 业务服务层，并且它还有个属性，由setOrderDAO()引用。这个属性



Spring 和Bean 的还有一点要注意的： bean可以以用两种方式创造。 这些都在单例模式（Sington）和原型模式（propotype）中定义了。 默认的方式是singleton,这意味着共享的实例将被束缚。 而原形模式是在Spring用到bean的时候允许新建实例的。当每个用户需要得到他们自己Bean的Copy时，你应该仅使用prototype模式。（更多的请参考设计模式中的单例模式和原形模式）

提供一个服务定位器（Providing a Service Locator）
既然我们已经将我们的Serices和DAO搭配起来了。我们需要把我们的Service显示到其他层。 这个通常是在Struts或者Swing这层里编码。一个简单方法就是用 服务定位器返回给Spring context 。当然，可以通过直接调用Spring中的Bean来做。

下面是一个Struts Actin 中的服务定位器的一个例子。