org.springframework.core简单分析

    这个包的类主要用于spring框架的异常处理和一些核心的助手类（与框架具体部分无关的）。
    这个包中主要应用到了简单工厂模式，用于判断jdk版本，根据jdk版本不同提供不同的集合类、当前方法栈信息等。我们来看看是如何判断当前用户的jdk版本的：

package org.springframework.core;

public class JdkVersion {
    
    public static final int JAVA_13 = 0;
    
    public static final int JAVA_14 = 1;
    
    public static final int JAVA_15 = 2;

    private static String javaVersion;

    private static int majorJavaVersion = JAVA_13;
    
    static {
        javaVersion = System.getProperty("java.version");
        // should look like "1.4.1_02"
        if (javaVersion.indexOf("1.4.") != -1) {
            majorJavaVersion = JAVA_14;
        }
        else if (javaVersion.indexOf("1.5.") != -1) {
            majorJavaVersion = JAVA_15;
        }
        // else leave as 1.3 default
    }

    /**
     * Return the full Java version string, as returned by
     * <code>System.getProperty("java.version")</code>.
     */
    public static String getJavaVersion() {
        return javaVersion;
    }

    /**
     * Get the major version code. This means we can do things like
     * <code>if (getMajorJavaVersion() < JAVA_14)</code>.
     * @return a code comparable to the JAVA_XX codes in this class
     * @see #JAVA_13
     * @see #JAVA_14
     * @see #JAVA_15
     */
    public static int getMajorJavaVersion() {
        return majorJavaVersion;
    }

}

直接获取系统的java.version属性来进行jdk版本的判断。而CollectionFactory依据这个类来创建不同的集合类型，如果是jdk1.4就优先使用jdk1.4的集合框架，再次选择Commons Collections，最后才不得已就使用jdk1.3的集合框架，这里比较有趣的是判断Commons Collections的方法就是尝试Class.forName一个Commons集合框架中的对象，如果成功，当然证明classpath有commons-collections.jar包：

static  {
         //  Check whether JDK 1.4+ collections and/or
         //  Commons Collections 3.x are available.
         if  (JdkVersion.getMajorJavaVersion()  >=  JdkVersion.JAVA_14) {
            logger.info( " JDK 1.4+ collections available " );
        }
         try  {
            Class.forName(COMMONS_COLLECTIONS_CLASS_NAME);
            commonsCollections3xAvailable  =   true ;
            logger.info( " Commons Collections 3.x available " );
        }
         catch  (ClassNotFoundException ex) {
            commonsCollections3xAvailable  =   false ;
        }
    }

然后就是一系列的getXXXIfPossible（）方法用以获取最优版本的集合类型，比如getLinkedHashMapIfPossible()：

public   static  Map createLinkedMapIfPossible( int  initialCapacity) {
         if  (JdkVersion.getMajorJavaVersion()  >=  JdkVersion.JAVA_14) {
            logger.debug( " Creating [java.util.LinkedHashMap] " );
             return  Jdk14CollectionFactory.createLinkedHashMap(initialCapacity);
        }
         else   if  (commonsCollections3xAvailable) {
            logger.debug( " Creating [org.apache.commons.collections.map.LinkedMap] " );
             return  CommonsCollectionFactory.createLinkedMap(initialCapacity);
        }
         else  {
            logger.debug( " Falling back to [java.util.HashMap] for linked map " );
             return   new  HashMap(initialCapacity);
        }
    }

其中的Jdk14CollectionFactory 和CommonsCollectionFactory 也都是工厂类。可以看到，一个优秀的通用框架对于版本的兼容性非常重视。

    这个包中另外一个需要注意的就是用于spring AOP功能实现的辅助类——ControlFlow。ControlFlow按照rod johnson的说法就是用于获取当前调用的方法栈的具体信息。ControlFlow是一个接口，拥有3个方法用于判断当前方法栈的位置：

public   interface  ControlFlow {

     /**
      查找当前方法调用是否则在某类中
     *  @param  clazz the clazz to look for
      */
     boolean  under(Class clazz);

     /**
     * 查找当前方法调用是否则在某类的某个方法中
     * according to the current stack trace.
     *  @param  clazz the clazz to look for
     *  @param  methodName the name of the method to look for
      */
     boolean  under(Class clazz, String methodName);

     /**
     * 当前栈帧是否包含传入的记号
     *  @param  token the token to look for
      */
     boolean  underToken(String token);

}

然后根据jdk版本的不同采用不同的方式实现这个接口：Jdk14ControlFlow和Jdk13ControlFlow。这是典型的 策略模式的应用。需要注意的是，这两个具体类的是放在工厂类ControlFlowFactory中作为内部类实现的:

public   abstract   class  ControlFlowFactory {
   
    static   class  Jdk13ControlFlow  implements  ControlFlow {
  
   

     static   class  Jdk14ControlFlow  implements  ControlFlow {
   
}

在这里，我们可以学到的东西就如何去判断当前方法栈的信息？jdk1.4之前只能通过对StackTrace的字符串进行分析，而jdk1.4引入了java.lang.StackTraceElement用于获取当前方法调用所处的栈帧的信息，看看spring的使用方法，相当简单：

static   class  Jdk14ControlFlow  implements  ControlFlow {

         private  StackTraceElement[] stack;

         public  Jdk14ControlFlow() {
             this .stack  =   new  Throwable().getStackTrace();
        }

         /**
         * Searches for class name match in a StackTraceElement.
          */
         public   boolean  under(Class clazz) {
            Assert.notNull(clazz,  " Class must not be null " );
            String className  =  clazz.getName();
             for  ( int  i  =   0 ; i  <  stack.length; i ++ ) {
                 if  ( this .stack[i].getClassName().equals(className)) {
                     return   true ;
                }
            }
             return   false ;
        }

         /**
         * Searches for class name match plus method name match
         * in a StackTraceElement.
          */
         public   boolean  under(Class clazz, String methodName) {
            Assert.notNull(clazz,  " Class must not be null " );
            Assert.notNull(methodName,  " Method name must not be null " );
            String className  =  clazz.getName();
             for  ( int  i  =   0 ; i  <   this .stack.length; i ++ ) {
                 if  ( this .stack[i].getClassName().equals(className)  &&
                         this .stack[i].getMethodName().equals(methodName)) {
                     return   true ;
                }
            }
             return   false ;
        }

         /**
         * Leave it up to the caller to decide what matches.
         * Caller must understand stack trace format, so there's less abstraction.
          */
         public   boolean  underToken(String token) {
             if  (token  ==   null ) {
                 return   false ;
            }
            StringWriter sw  =   new  StringWriter();
             new  Throwable().printStackTrace( new  PrintWriter(sw));
            String stackTrace  =  sw.toString();
             return  stackTrace.indexOf(token)  !=   - 1 ;
        }
}

获取当前栈帧的信息，对于一般的java开发者没有什么意义，对于AOP的实现和框架开发者可能有比较重要的作用，我还未研读spring的aop部分，不敢妄言，留待以后解答，如果您已经研读过这部分代码，不吝赐教。

这个包另外的一个特点就是将java的反射API演示了一遍，特别是Constant.java（用于提取某个类public static final定义的常量）和ReflectiveVisitorHelper （反射助手类），对于学习java反射技术也有不小的帮助。

dennis 2007-04-10 16:56 发表评论