庄周梦蝶

生活、程序、未来
   :: 首页 ::  ::  :: 聚合  :: 管理

org.springframework.core简单分析

Posted on 2007-04-10 16:56 dennis 阅读(3750) 评论(2)  编辑  收藏 所属分类: java源码解读
    这个包的类主要用于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反射技术也有不小的帮助。


评论

# re: org.springframework.core简单分析  回复  更多评论   

2007-04-11 11:53 by cresposhi
不错 up
最近正在重读Core Java
对这些框架源代码很有感觉。。。

# re: org.springframework.core简单分析  回复  更多评论   

2007-04-11 14:44 by dennis
@cresposhi
呵呵,我也是最近闲着无聊就读读源码,多谢关注

只有注册用户登录后才能发表评论。


网站导航: