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());

}