BlogJava-闲人野居-随笔分类-springhttp://www.blogjava.net/zyl/category/17749.html好好学习，天天向上zh-cnTue, 27 Feb 2007 19:37:30 GMTTue, 27 Feb 2007 19:37:30 GMT60关于spring 2.0自定义xml 标记 （二 如何实现）http://www.blogjava.net/zyl/archive/2006/10/27/77708.html布衣郎布衣郎Fri, 27 Oct 2006 10:18:00 GMThttp://www.blogjava.net/zyl/archive/2006/10/27/77708.htmlhttp://www.blogjava.net/zyl/comments/77708.htmlhttp://www.blogjava.net/zyl/archive/2006/10/27/77708.html#Feedback0http://www.blogjava.net/zyl/comments/commentRss/77708.htmlhttp://www.blogjava.net/zyl/services/trackbacks/77708.html阅读全文

布衣郎 2006-10-27 18:18 发表评论
]]>关于spring 2.0自定义xml 标记 （一 主要的相关类）http://www.blogjava.net/zyl/archive/2006/10/27/77707.html布衣郎布衣郎Fri, 27 Oct 2006 10:08:00 GMThttp://www.blogjava.net/zyl/archive/2006/10/27/77707.htmlhttp://www.blogjava.net/zyl/comments/77707.htmlhttp://www.blogjava.net/zyl/archive/2006/10/27/77707.html#Feedback0http://www.blogjava.net/zyl/comments/commentRss/77707.htmlhttp://www.blogjava.net/zyl/services/trackbacks/77707.html
 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 元素








布衣郎 2006-10-27 18:08 发表评论
]]>spring 2.0 关于事务的变化（主要为声明性事务）http://www.blogjava.net/zyl/archive/2006/09/18/70364.html布衣郎布衣郎Mon, 18 Sep 2006 12:13:00 GMThttp://www.blogjava.net/zyl/archive/2006/09/18/70364.htmlhttp://www.blogjava.net/zyl/comments/70364.htmlhttp://www.blogjava.net/zyl/archive/2006/09/18/70364.html#Feedback0http://www.blogjava.net/zyl/comments/commentRss/70364.htmlhttp://www.blogjava.net/zyl/services/trackbacks/70364.html在 1.x中，spring 的事务声明，一直是采用动态代理bean 实现的，也就是采用ProxyFactoryBean或者子类TransactionProxyFactoryBean来实现的

考虑下面的例子：(用1.x实现）
<bean id="myTxManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="mySessionFactory"/>
  </bean>

  <bean id="myProductService" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces" value="product.ProductService"/>
    <property name="target">
        <bean class="product.DefaultProductService">
            <property name="productDao" ref="myProductDao"/>
        </bean>
    </property>
    <property name="interceptorNames">
      <list>
        <value>myTxInterceptor</value> <!-- the transaction interceptor (configured elsewhere) -->
      </list>
    </property>
  </bean>

 <bean id="myTxInterceptor"

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

<property name="transactionManager">

   <ref bean="myTransactionManager"/>

</property>

<property name="transactionAttributeSource">

  <value>

   product.ProductService.increasePrice*=PROPAGATION_REQUIRED

  product.ProductService.someOtherBusinessMethod=PROPAGATION_MANDATORY

  </value>

</property>

</bean>

或者

<bean id="myProductService"

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

<property name="transactionManager">

<ref bean="myTransactionManager"/>

</property>

<property name="target">

<ref bean="myProductServiceTarget"/>

</property>

<property name="transactionAttributes">

<props>

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

<prop key="someOtherBusinessMethod">PROPAGATION_MANDATORY</prop>

</props>

</property>
 </bean>

当然，这需要每个服务接口都要声明一个事务bean ，这比较麻烦，当然，spring 也提供了另外一种解决方案

采用BeanNameAutoProxyCreator 自动代理声明入口来全局声明所有的事务。
<bean id="matchAllWithPropReq"
         class="org.springframework.transaction.interceptor.MatchAlwaysTransactionAttributeSource">
         <property name="transactionAttribute"><value>PROPAGATION_REQUIRED</value></property>
</bean>

<bean id="matchAllTxInterceptor"
         class="org.springframework.transaction.interceptor.TransactionInterceptor">
         <property name="transactionManager"><ref bean="transactionManager"/></property>
         <property name="transactionAttributeSource"><ref bean="matchAllWithPropReq"/></property>
</bean>
<bean id="autoProxyCreator"
         class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
         <property name="interceptorNames">
            <list>
               <idref local="matchAllTxInterceptor"/>
               <idref bean="hibInterceptor"/>
            </list>
         </property>
         <property name="beanNames">
            <list>
               <idref local="core-services-applicationControllerSevice"/>
               <idref local="core-services-deviceService"/>
               <idref local="core-services-authenticationService"/>
               <idref local="core-services-packagingMessageHandler"/>
               <idref local="core-services-sendEmail"/>
               <idref local="core-services-userService"/>
            </list>
         </property>
</bean>
list中包含了所有需要实现事务的服务bean 

 spring 2.0带来的aop变化和bean xml schema的变化，使得事务的处理变得更加的简单,同aop一样，事务也采用两种方式来处理，一种主要为xml 声明，另外的一种也就是注释的引入。
先来看第一种情况：
<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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

  <!-- SessionFactory, DataSource, etc. omitted -->

  <bean id="myTxManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="mySessionFactory"/>
  </bean>
 
  <aop:config>
   <!-- 这定义了主要的切面，也就是那些接口可以使用事务,这里只是说执行ProductService的所有方法-->
    <aop:pointcut id="productServiceMethods" expression="execution(* product.ProductService.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="productServiceMethods"/>
  </aop:config>
  <!--主要的事务 advice 声明事务的相关属性-->
  <tx:advice id="txAdvice" transaction-manager="myTxManager">
    <tx:attributes>
      <tx:method name="increasePrice*" propagation="REQUIRED"/>
      <tx:method name="someOtherBusinessMethod" propagation="REQUIRES_NEW"/>
      <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
    </tx:attributes>
  </tx:advice>

  <bean id="myProductService" class="product.SimpleProductService">
    <property name="productDao" ref="myProductDao"/>
  </bean>

</beans>

第二种方式，使用 @Transactional 注释

@Transactional

public interface FooService {

 

    Foo getFoo(String fooName);

 

    Foo getFoo(String fooName, String barName);

 

    void insertFoo(Foo foo);

 

    void updateFoo(Foo foo);

}


xml 配置

<!-- from the file 'context.xml' -->

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

       xmlns:tx="http://www.springframework.org/schema/tx"

       xsi:schemaLocation="

       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd

       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

 

  <!-- this is the service object that we want to make transactional -->

  <bean id="fooService" class="x.y.service.DefaultFooService"/>

 

  <!-- enable the configuration of transactional behavior based on annotations -->

  <tx:annotation-driven/>

 

  <!-- a PlatformTransactionManager is still required -->

  <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

    <!-- sourced from somewhere else -->

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

  </bean>

 

  <!-- other <bean/> definitions here -->

 

</beans>

public class DefaultFooService implements FooService {

 

    public Foo getFoo(String fooName) {

        // do something

    }

 

    // these settings have precedence

    @Transactional(readOnly = false, propagation = Propagation.REQUIRES_NEW)

    public void updateFoo(Foo foo) {

        // do something

    }

}



布衣郎 2006-09-18 20:13 发表评论
]]>spring aop 2.0 编程(三)http://www.blogjava.net/zyl/archive/2006/09/17/70116.html布衣郎布衣郎Sun, 17 Sep 2006 03:13:00 GMThttp://www.blogjava.net/zyl/archive/2006/09/17/70116.htmlhttp://www.blogjava.net/zyl/comments/70116.htmlhttp://www.blogjava.net/zyl/archive/2006/09/17/70116.html#Feedback4http://www.blogjava.net/zyl/comments/commentRss/70116.htmlhttp://www.blogjava.net/zyl/services/trackbacks/70116.html前面这是讲了许多的概念，下面以一个例子来说明：
一个很好理解的aop 例子，也就是日志服务。
先从aop第一种方式来实现，也就是xml配置方式
先创建基本的日志类：
public class Logger {

    private static Log log = LogFactory.getLog(Logger.class);

    public void entry(String message) {
        log.info(message);
    }
}
这里只是简单的一个方法，当然实际情况可能不同。
由于xml配置需要一个方面的实现bean
所以创建一个简单的bean ：
public class LogBean {

    private Logger logger = new Logger();

    public Object aroundLogCalls(ProceedingJoinPoint joinPoint) throws Throwable {
        logger.entry("before invoke method:"
                     + joinPoint.getSignature().getName());
        Object object = joinPoint.proceed();
        logger.entry("after invoke method:"
                     + joinPoint.getSignature().getName());
        return object;
    }
}
这里采取简单的around advice，其他类型的advice 基本上都差不多

当然有了这两个核心的日志类，需要一个测试类，用于测试。
public class TestBean {

    public void method1() {
        System.out.println("in method1");
    }

    public void method2() {
        System.out.println("in method2");
    }
}
这就是需要测试的类了，需要记录日志的方法只有两个，这里用System.out.println，只是想显示方法的调用顺序。


然后关键的在于xml的配置了

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd">
 
 <aop:config>
    <!--  expression 表示要执行的匹配表达式，这里匹配所有的public方法，但是去除logger类的所有方法，防止无限调用-->

      <aop:pointcut id="loggableCalls"
          expression="execution(public * *(..)) and !execution(* org.spring.test.aop.log.Logger.*(..))"/>


  <aop:aspect id="logAspect" ref="logBean">
   <aop:around pointcut-ref="loggableCalls" method="aroundLogCalls"/>
  </aop:aspect>
 
 </aop:config>
 <bean id="logBean" class="org.spring.test.aop.log.LogBean" />
 <bean id="testBean" class="org.spring.test.aop.log.TestBean"/>
 
</beans>

现在写一个测试类：

public class LogXmlTest extends RootTest {

    @Override
    protected String getBeanXml() {
        return "org/spring/test/aop/log/bean.xml";
    }

    public void testLog() {
        TestBean bean = (TestBean) ctx.getBean("testBean");
        bean.method1();
        bean.method2();
    }

}

public abstract class RootTest extends TestCase {

    protected ApplicationContext  ctx;

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

    protected RootTest() {
        ctx = new ClassPathXmlApplicationContext(getBeanXml());
    }

    protected abstract String getBeanXml();

}

打印的消息如下：
2006-09-17 11:08:28,203 INFO [org.spring.test.aop.log.Logger] - before invoke method:method1
in method1
2006-09-17 11:08:28,203 INFO [org.spring.test.aop.log.Logger] - after invoke method:method1
2006-09-17 11:08:28,218 INFO [org.spring.test.aop.log.Logger] - before invoke method:method2
in method2
2006-09-17 11:08:28,218 INFO [org.spring.test.aop.log.Logger] - after invoke method:method2

第二种实现方式，采用注释方式：

Logger 类不变
创建一个LogAspect类
@Aspect
public class LogAspect {

    private Logger logger = new Logger();

    @Pointcut("execution(public * *(..))")
    public void publicMethods() {

    }

    @Pointcut("execution(* org.spring.test.aop.log.Logger.*(..))")
    public void logObjectCalls() {

    }

    @Pointcut("publicMethods()&&!logObjectCalls()")
    public void loggableCalls() {

    }

    @Around("loggableCalls()")
    public Object aroundLogCalls(ProceedingJoinPoint joinPoint) throws Throwable {
        logger.entry("before invoke method:"
                     + joinPoint.getSignature().getName());
        Object object = joinPoint.proceed();
        logger.entry("after invoke method:"
                     + joinPoint.getSignature().getName());
        return object;
    }
}

配置文件就简单多了
<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd">
 
 <aop:aspectj-autoproxy/>
 
 <!-- 或者使用以下定义
 
 
 
 <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />
 
 -->
 <bean id="logAspect" class="org.spring.test.aop.log.LogAspect"/>
 <bean id="testBean" class="org.spring.test.aop.log.TestBean"/>
 
</beans>

测试类：
跟上面的差不多
把xml文件换掉就行

打印的方式差不多

个人还是比较喜欢第二种实现。



布衣郎 2006-09-17 11:13 发表评论
]]>spring aop编程(二)http://www.blogjava.net/zyl/archive/2006/09/15/69966.html布衣郎布衣郎Fri, 15 Sep 2006 11:31:00 GMThttp://www.blogjava.net/zyl/archive/2006/09/15/69966.htmlhttp://www.blogjava.net/zyl/comments/69966.htmlhttp://www.blogjava.net/zyl/archive/2006/09/15/69966.html#Feedback0http://www.blogjava.net/zyl/comments/commentRss/69966.htmlhttp://www.blogjava.net/zyl/services/trackbacks/69966.html前面主要介绍了如何通过xml实现aop编程，下面主要介绍如何通过@AspectJ来实现。
为了使@AspectJ 支持生效,
需要做以下步骤：
在xml中设置

<aop:aspectj-autoproxy/>

或者
在xml中加入
<bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />

声明 aspect

<bean id="myAspect" class="org.xyz.NotVeryUsefulAspect">

   <!-- configure properties of aspect here as normal -->

</bean>

 

package org.xyz;

import org.aspectj.lang.annotation.Aspect;

 

@Aspect

public class NotVeryUsefulAspect {

 

}

 声明 pointcut

@Pointcut("execution(* transfer(..))")

public void transfer() {}


声明 advice

Before advice:

@Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")

  public void doAccessCheck() {

    // ...

  }

After returning advice:

@AfterReturning("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")

  public void doAccessCheck() {

    // ...

  }

或者

@AfterReturning(
pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
returning="retVal")

public void doAccessCheck(Object retVal) {

    // ...

  }

After throwing advice：

@AfterThrowing("SystemArchitecture.dataAccessOperation()")

  public void doRecoveryActions() {

    // ...

  }

或者

@AfterThrowing(

    pointcut=" SystemArchitecture.dataAccessOperation()",

    throwing="ex")

  public void doRecoveryActions(DataAccessException ex) {

    // ...

  }

After (finally) advice：

@After("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")

  public void doReleaseLock() {

    // ...

  }

Around advice：

@Around("com.xyz.myapp.SystemArchitecture.businessService()")

  public Object doBasicProfiling( ProceedingJoinPoint pjp) throws Throwable {

    // start stopwatch

    Object retVal = pjp.proceed();

    // stop stopwatch

    return retVal;

  }

Advice parameters：

@Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation() &&" + "args(account,..)" )

public void validateAccount(Account account) {

  // ...

}

声明参数名称：

@Before(

   value="com.xyz.lib.Pointcuts.anyPublicMethod() && " +

         "@annotation(auditable)",

   argNames="auditable" )

public void audit(Auditable auditable) {

  AuditCode code = auditable.value();

  // ...

} 

Advice 排序：

一般以声明的方法次序为先后

不同的 Advice ，通过实现 Ordered 接口，来排序


Introductions

用于引入新的接口

@Aspect

public class UsageTracking {

 

  @DeclareParents(value="com.xzy.myapp.service.*+",

                  defaultImpl=DefaultUsageTracked.class)

  public static UsageTracked mixin;

 

  @Before("com.xyz.myapp.SystemArchitecture.businessService() &&" +

          "this(usageTracked)")

  public void recordUsage(UsageTracked usageTracked) {

    usageTracked.incrementUseCount();

  }

 

}

 



布衣郎 2006-09-15 19:31 发表评论
]]>spring 2.0 aop编程(一)http://www.blogjava.net/zyl/archive/2006/09/15/69805.html布衣郎布衣郎Fri, 15 Sep 2006 01:41:00 GMThttp://www.blogjava.net/zyl/archive/2006/09/15/69805.htmlhttp://www.blogjava.net/zyl/comments/69805.htmlhttp://www.blogjava.net/zyl/archive/2006/09/15/69805.html#Feedback0http://www.blogjava.net/zyl/comments/commentRss/69805.htmlhttp://www.blogjava.net/zyl/services/trackbacks/69805.html主要分为两大方面
1.支持简单的aop xml配置
2.支持@AspectJ的注释

先来看一看第一种情况：
申明一个aspect，在xml中的申明如下：

<aop:config>

  <aop:aspect id="myAspect" ref="aBean">

    ...

  </aop:aspect>

</aop:config>

<bean id="aBean" class="...">

  ...

</bean>


申明pointcut

<aop:config>

  <aop:pointcut id="businessService"

        expression="execution(* com.xyz.myapp.service.*.*(..))"/>

</aop:config>


申明advice

Before advice：

<aop:aspect id="beforeExample" ref="aBean">

    <aop:before

      pointcut-ref="dataAccessOperation"

      method="doAccessCheck"/>

</aop:aspect>

After returning advice:

<aop:aspect id="afterReturningExample" ref="aBean">

 

    <aop:after-returning

      pointcut-ref="dataAccessOperation"

      method="doAccessCheck"/>

         

    ...

   

</aop:aspect>

或者带有返回参数

<aop:aspect id="afterReturningExample" ref="aBean">

 

    <aop:after-returning

      pointcut-ref="dataAccessOperation"

      returning="retVal"

      method="doAccessCheck"/>

         

    ...

   

</aop:aspect>

 

After throwing advice：

<aop:aspect id="afterThrowingExample" ref="aBean">

 

    <aop:after-throwing

      pointcut-ref="dataAccessOperation"

      method="doRecoveryActions"/>

         

    ...

   

</aop:aspect>

或者带有throwing

<aop:aspect id="afterThrowingExample" ref="aBean">

 

    <aop:after-throwing

      pointcut-ref="dataAccessOperation"

      throwing="dataAccessEx"

      method="doRecoveryActions"/>

         

    ...

   

</aop:aspect>

After (finally) advice：

<aop:aspect id="afterFinallyExample" ref="aBean">

 

    <aop:after

      pointcut-ref="dataAccessOperation"

      method="doReleaseLock"/>

         

    ...

   

</aop:aspect>

Around advice：

<aop:aspect id="aroundExample" ref="aBean">

 

    <aop:around

      pointcut-ref="businessService"

      method="doBasicProfiling"/>

         

    ...

   

</aop:aspect>

Advice parameters：

<aop:before

  pointcut="Pointcuts.anyPublicMethod() and @annotation(auditable)"

  method="audit"

  arg-names="auditable"/>


对于引入接口（Introductions）：

<aop:aspect id="usageTrackerAspect" ref="usageTracking">

  <aop:declare-parents

      types-matching="com.xzy.myapp.service.*+",

      implement-interface="UsageTracked"
      default-impl=" service.tracking.DefaultUsageTracked"/>

  <aop:before

    pointcut="com.xyz.myapp.SystemArchitecture.businessService()

              and this(usageTracked)"

    method="recordUsage"/>

</aop:aspect>

 

布衣郎 2006-09-15 09:41 发表评论
]]>spring 代码分析之 beanshttp://www.blogjava.net/zyl/archive/2006/09/02/67233.html布衣郎布衣郎Sat, 02 Sep 2006 02:10:00 GMThttp://www.blogjava.net/zyl/archive/2006/09/02/67233.htmlhttp://www.blogjava.net/zyl/comments/67233.htmlhttp://www.blogjava.net/zyl/archive/2006/09/02/67233.html#Feedback0http://www.blogjava.net/zyl/comments/commentRss/67233.htmlhttp://www.blogjava.net/zyl/services/trackbacks/67233.html        这几天，闲着无事，看起了spring的源码，顺便也学习一下，人家的设计理念。
        spring的源码还是比较多的，但是区分的层次比较可以。对比了一下自己设计的程序，有点惭愧，每次分包的时候，设计的都比较烂。
        闲话少说，先来看看spring 的核心包beans。
        beans 包主要提供了接口和类用于处理java beans。
        其中最主要的接口是BeanWrapper：
        Spring 的中心接口，用于访问javabeans 的低层操作。默认实现为BeanWrapperImpl 提供分析和处理标准java beans 用于get 和set 属性，取得属性描述，查询属性的读/写能力。
    用法非常简单
    TestBean tb = new TestBean();
    BeanWrapper bw = new BeanWrapperImpl(tb);
    bw.isReadableProperty("age");//判断age属性是否可读
    bw.setPropertyValue("name", "tom"); //设置name属性的值为tom
    bw.getPropertyValue("int2")//取得属性
    //当然，最强大的是能嵌套设置属性，如：
    //tb中有个spouse的属性，也为TestBean，这样
    bw.setPropertyValue("spouse.name", "tom"); 
    //等价于tb.getSpouse().setName("tom");
    //bw 同样支持数组和集合,map属性设置
    bw.getPropertyValue("array[0].name");
    bw.getPropertyValue("map[key4][0].name");
    
    beans包 还提供了一个PropertyValues用于保存多个属性值，默认的实现MutablePropertyValues
    MutablePropertyValues pvs = new MutablePropertyValues();
    pvs.addPropertyValue("array[0].name", "name5");
    pvs.addPropertyValue("array[1].name", "name4");
    bw.setPropertyValues(pvs);
   
    BeanWrapper的层次结构，也比较简单继承于ConfigurablePropertyAccessor ，而ConfigurablePropertyAccessor 又继承于PropertyAccessor 和   PropertyEditorRegistry 接口。
        有一点不太明白，为什么ConfigurablePropertyAccessor 要继承于PropertyEditorRegistry 
        PropertyEditorRegistry 的主要作用是提供方法用于注册JavaBeans PropertyEditors。默认的实现为  PropertyEditorRegistrySupport
        这就使得BeanWrapperImpl 也需要继承PropertyEditorRegistrySupport，从字面意义上来说，两个类不是很有关系，其实最主要用到的方法，也就是registerDefaultEditors(),注册spring中所有的属性编辑类。
        beans 包中还有两个接口TypeConverter和Mergeable 。TypeConverter由BeanWrapperImpl实现，主要用于转换属性值。其主要的工作由TypeConverterDelegate 这个包内类完成的。Mergeable 主要是用来合并值得，不过具体的实现，在org.springframework.beans.factory.support 包中。
        beans 包中提供了两个有用的工具类，BeanUtils和PropertyAccessorUtils。



布衣郎 2006-09-02 10:10 发表评论
]]>