Spring的轻量级实现

作者： Grey

原文地址：Spring的轻量级实现

本文是参考公众号：码农翻身的从零开始造Spring 教程的学习笔记

源码

github

开发方法

使用TDD的开发方法，TDD的开发流程是：

写一个测试用例
运行：失败
写Just enough的代码，让测试通过
重构代码保持测试通过，

然后循环往复。

说明

仅实现核心功能
基于spring-framework-3.2.18.RELEASE版本

通过XML实例化一个对象

解析XML文件，拿到Bean的id和完整路径，通过反射方式实例化一个对象。

XML格式如下，文件名为：bean-v1.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userService" class="org.spring.service.v1.UserService"></bean>
</beans>

需要解析上述XML并生成userService对象，调用者只需要做如下调用即可：

public class BeanFactoryV1Test {
    @Test
    public void testGetBean() {
        BeanFactory factory = new DefaultBeanFactory("bean-v1.xml");
        UserService userService = (UserService) factory.getBean("userService");
        assertNotNull(userService);
    }
}

思路为：

解析XML，并把XML中的类通过反射方式生成对象，最后，把这个生成的对象放到一个Map中，其中Map的key为beanId，如上例就是：userService, Map的Value是UserService的全路径org.spring.service.v1.UserService

实现细节参考代码见：step1

基础工作和基本封装

增加日志支持：log4j2 + SLF4j
增加异常处理，所有异常的父类设计为BeansException
封装BeanDefinition

由于DefaultBeanFactory中的BEAN_MAP目前只包括了beanClassName信息，后续如果要扩展其他的信息，肯定需要增加字段，所以我们需要抽象出一个接口BeanDefinition，方便后续扩展其他的字段。

封装Resource

在BeanFactory初始化的时候，传入的是XML格式的配置信息，比如bean-v1.xml, Spring会把这个抽象成一个Resource，常见Resource有

FileSystemResource: 从文件地址读配置

ClassPathResource: 从classpath下读配置

BeanFactory在创建Bean的时候，只关注Resource即可。

实现细节参考代码见：vstep4-2-resource

封装XML的解析逻辑和Bean的注册逻辑

设计XmlBeanDefinitionReader，用于解析XML，传入Resource，即可获取所有BeanDefinition，

public void loadBeanDefinitions(Resource resource) {
    // 从Resource中获取所有的BeanDefinition
    // 注册到BEAN_MAP中
}

由于要把BeanDefinition放入BEAN_MAP中，所以XmlBeanDefinitionReader需要持有一个DefaultBeanFactory，且DefaultBeanFactory需要有注册BeanDefinition和获取BeanDefintion的能力，这样DefaultBeanFactory的职责就不单一了，所以需要抽象出一个BeanDefinitionRegistry，这个BeanDefinitionRegistry专门负责注册BeanDefinition和获取BeanDefintion，

public interface BeanDefinitionRegistry {
    /**
     * 注册Bean
     * @param beanId
     * @param beanDefinition
     */
    void registerBeanDefinition(String beanId, BeanDefinition beanDefinition);
}

XmlBeanDefinitionReader只需要持有BeanDefinitionRegistry，即可将解析生成的BeanDefinition注入BEAN_MAP中。

实现细节参考代码见：vstep5-final

单例多例模式的配置实现

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userService" class="org.spring.service.v1.UserService"></bean>
    <bean id="orgService" class="org.spring.service.v1.OrgService" scope="prototype"></bean>
</beans>

其中orgService这个bean配置成了prototype的属性，所以在BeanDefinition这个数据结构要增加是否单例，是否多例的逻辑

public interface BeanDefinition {
    ...
    boolean isSingleton();
    boolean isPrototype();
    ...
}

在DefaultBeanFactory调用getBean的时候，判断是否单例，如果是单例，则复用对象，如果是多例，则new新的对象。

@Override
    public Object getBean(String beanId) {
        // TODO bean存在与否判断
        // TODO 异常处理
        // TODO 构造函数带参数
        BeanDefinition definition = BEAN_MAP.get(beanId);
        if (definition.isSingleton()) {
            Object bean = this.getSingleton(beanId);
            if(bean == null){
                bean = createBean(definition);
                this.registerSingleton(beanId, bean);
            }
            return bean;
        }
        return createBean(definition);
    }

抽象SingletonBeanRegistry这个接口，专门用于注册和获取单例对象，

public interface SingletonBeanRegistry {
    void registerSingleton(String beanName, Object singletonObject);
    Object getSingleton(String beanName);
}

DefaultSingletonBeanRegistry实现这个接口，实现对单例对象的注册

public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {
    // TODO 考虑线程安全的容器
    private final Map<String, Object> singletonObjects = new HashMap<>();
    @Override
    public void registerSingleton(String beanName, Object singletonObject) {
        // 注册单例Bean
        ...
    }
    @Override
    public Object getSingleton(String beanName) {
  // 获取单例Bean
        return this.singletonObjects.get(beanName);
    }
}

DefaultBeanFactory继承DefaultSingletonBeanRegistry这个类，就有了获取单例Bean和注册单例Bean的能力。

实现细节参考代码见：vstep6-scope

整合并抽象出ApplicationContext

我们使用Spring的时候，一般是这样做的：

ApplicationContext ctx = new ClassPathXmlApplicationContext("mycontainer.xml");
UserService userService = (UserService) ctx.getBean("userService");

或

ApplicationContext ctx = new FileSystemApplicationContext("src\\test\\resources\\bean-v1.xml");
UserService userService = (UserService) ctx.getBean("userService");

现在，我们需要抽象出ApplicationContext这个接口来实现如上的功能，其中有如下两个类去实现这个接口。

ClassPathXmlApplicationContext

从classpath中读取配置文件

FileSystemApplicationContext

从文件中读取配置文件

这两个子类都需要持有DefaultBeanFactory才能有getBean的能力，

ClassPathXmlApplicationContext代码如下：

public class ClassPathXmlApplicationContext implements ApplicationContext {
    private final DefaultBeanFactory factory;
    public ClassPathXmlApplicationContext(String configPath) {
        factory = new DefaultBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
        reader.loadBeanDefinitions(new ClassPathResource(configPath));
    }
    @Override
    public Object getBean(String beanId) {
        return factory.getBean(beanId);
    }
}

FileSystemApplicationContext代码如下：

public class FileSystemApplicationContext implements ApplicationContext {
    private final DefaultBeanFactory factory;
    public FileSystemApplicationContext(String configPath) {
        factory = new DefaultBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
        reader.loadBeanDefinitions(new FileSystemResource(configPath));
    }
    @Override
    public Object getBean(String beanId) {
        return factory.getBean(beanId);
    }
}

实现细节参考代码见：vstep7-applicationcontext-v1

通过观察发现，ClassPathXmlApplicationContext和FileSystemApplicationContext大部分代码都是相同的，只有在获取Resource的时候，方法不一样，所以，我们通过模板方法这个设计模式，设计一个抽象类AbstractApplicationContext，代码如下：

public abstract class AbstractApplicationContext implements ApplicationContext {
    private DefaultBeanFactory factory;
    public AbstractApplicationContext(String configPath) {
        factory = new DefaultBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
        reader.loadBeanDefinitions(getResourceByPath(configPath));
    }
    @Override
    public Object getBean(String beanId) {
        return factory.getBean(beanId);
    }
    protected abstract Resource getResourceByPath(String path);
}

这个抽象类实现除了获取Resource以外的所有逻辑，ClassPathXmlApplicationContext和FileSystemApplicationContext都继承这个抽象类，完成Resource的获取逻辑的编写即可。以FileSystemApplicationContext为例，示例代码如下：

public class FileSystemApplicationContext extends AbstractApplicationContext {
    public FileSystemApplicationContext(String configPath) {
        super(configPath);
    }
    @Override
    protected Resource getResourceByPath(String path) {
        return new FileSystemResource(path);
    }
}

实现细节参考代码见：vstep7-applicationcontext-v2

注入Bean和字符串常量

我们需要对于如下类型的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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userService" class="org.spring.service.v2.UserService">
        <property name="accountDao" ref="accountDao"/>
        <property name="itemDao" ref="itemDao"/>
        <property name="owner" value="test"/>
        <property name="version" value="2"/>
        <property name="checked" value="on"/>
    </bean>
    <bean id="accountDao" class="org.spring.dao.v2.AccountDao">
    </bean>
    <bean id="itemDao" class="org.spring.dao.v2.ItemDao">
    </bean>
</beans>

需要达到的目的就是：可以把整型，字符串类型，简单对象类型注入到一个Bean中，我们需要解决如下两个问题：

第一个问题是：把字符串转成各种各样的Value，比如把String转换成Integer或者转换成Boolean。jdk中java.bean包中的PropertyEditorSupport这个类来完成的，我们新建了CustomBooleanEditor和CustomNumberEditor两个类，这两个类都继承于PropertyEditorSupport，分别实现了String类型转换成Boolean类型和String类型转换成Integer类型的功能。其他的类型转换也可以通过类似的方法来实现。然后抽象出了TypeConvert这个接口，并把这些转换器加入一个特定的Map中，Map的key就是要转换的目标的类型，Value就是对应的转换器的实现类，即可实现类型转换。

public interface TypeConverter {
    // TODO 抽象出：TypeMismatchException
    <T> T convertIfNecessary(Object value, Class<T> requiredType);
}

第二个问题是：我们调用Bean的setXXX方法把这些Value值set到目标Bean中，做法是抽象出PropertyValue

public class PropertyValue {
    private final String name;
    private final Object value;
    // 省略构造方法和get/set方法
}

BeanDefiniton需要增加方法获取PropertyValue的逻辑，BeanDefiniton的所有子类，例如：GenericBeanDefinition中需要增加

private List<PropertyValue> propertyValues = new ArrayList<>();

在解析XML文件的时候，就需要把List<PropertyValue>识别出来并加入BeanDefinition中（RuntimeBeanReference，TypedStringValue），使用BeanDefinitionValueResolver把对应的PropertyValue给初始化好，如下代码：

public class BeanDefinitionValueResolver {
    ...
    public Object resolveValueIfNecessary(Object value) {
        if (value instanceof RuntimeBeanReference) {
            ...
        } else if (value instanceof TypedStringValue) {
            return ((TypedStringValue) value).getValue();
        } else {
            //TODO
            throw new RuntimeException("the value " + value + " has not implemented");
        }
    }
    ...
}

而setXXX的背后实现利用的是jdk原生java.beans.Introspector来实现，见DefaultBeanFactory的populateBean方法

private void populateBean(BeanDefinition bd, Object bean) {
        ....
        try {
            for (PropertyValue pv : pvs) {
                String propertyName = pv.getName();
                Object originalValue = pv.getValue();
                Object resolvedValue = valueResolver.resolveValueIfNecessary(originalValue);
                BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
                PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
                for (PropertyDescriptor pd : pds) {
                    if (pd.getName().equals(propertyName)) {
                        Object convertedValue = converter.convertIfNecessary(resolvedValue, pd.getPropertyType());
                        pd.getWriteMethod().invoke(bean, convertedValue);
                        break;
                    }
                }
            }
        } catch (Exception ex) {
            // TODO 封装Exception
            throw new RuntimeException("Failed to obtain BeanInfo for class [" + bd.getBeanClassName() + "]", ex);
        }
    }

其中

pd.getWriteMethod().invoke(bean, convertedValue);

就是对bean的属性进行赋值操作（即：setXXX方法）

实现细节参考代码见：vstep8-inject

实现构造器注入

处理形如以下的配置：

<bean id="userService" class="org.spring.service.v3.UserService">
    <constructor-arg ref="accountDao"/>
    <constructor-arg ref="itemDao"/>
    <constructor-arg value="1"/>
</bean>
<bean id="accountDao" class="org.spring.dao.v3.AccountDao"></bean>
<bean id="itemDao" class="org.spring.dao.v3.ItemDao"></bean>

和上例中注入Bean和字符串常量一样，我们抽象出ConstructorArgument用于表示一个构造函数信息，每个BeanDefinition中持有这个对象，

public class ConstructorArgument {
    private final List<ValueHolder> argumentValues = new LinkedList<>();
    public ConstructorArgument() {}
    public void addArgumentValue(ValueHolder valueHolder) {
        this.argumentValues.add(valueHolder);
    }
    public List<ValueHolder> getArgumentValues() {
        return Collections.unmodifiableList(this.argumentValues);
    }
    public int getArgumentCount() {
        return this.argumentValues.size();
    }
    public boolean isEmpty() {
        return this.argumentValues.isEmpty();
    }
    /**
     * Clear this holder, removing all argument values.
     */
    public void clear() {
        this.argumentValues.clear();
    }
    public static class ValueHolder {
        private Object value;
        private String type;
        private String name;
        // 省略get/set和构造方法
    }
}

在解析XML的时候，XmlBeanDefinitionReader需要负责解析出ConstuctorArgument，DefaultBeanFactory通过指定构造函数来生成Bean对象并通过ConstructorResolver注入Bean实例到构造方法中。

public class ConstructorResolver {
  ....
    public Object autowireConstructor(final BeanDefinition bd) {
       // ...通过bd找到一个合适的构造函数
        try {
            // 找到了一个合适的构造函数，则用这个构造函数初始化Bean对象初始化Bean对象
            return constructorToUse.newInstance(argsToUse);
        } catch (Exception e) {
            // TODO throw new BeanCreationException(bd.getID(), "can't find a create instance using " + constructorToUse);        }
            throw new RuntimeException(bd.getID() + "can't find a create instance using " + constructorToUse);
        }
    }
  ....
}

注：这里指定的构造函数的查找逻辑为：解析出XML的构造函数的参数列表，和通过反射拿到对应的构造函数的参数列表进行对比（每个参数的类型和个数必须一样）

Constructor<?>[] candidates = beanClass.getConstructors();
        BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this.beanFactory);
        ConstructorArgument cargs = bd.getConstructorArgument();
        TypeConverter typeConverter = new SimpleTypeConverter();
        for (int i = 0; i < candidates.length; i++) {
            // 匹配参数类型和个数，要完全对应上才可以
            Class<?>[] parameterTypes = candidates[i].getParameterTypes();
            if (parameterTypes.length != cargs.getArgumentCount()) {
                continue;
            }
            argsToUse = new Object[parameterTypes.length];
            boolean result = this.valuesMatchTypes(parameterTypes,
                    cargs.getArgumentValues(),
                    argsToUse,
                    valueResolver,
                    typeConverter);
            if (result) {
                constructorToUse = candidates[i];
                break;
            }
        }

实现细节参考代码见：vstep9-constructor

实现注解

实现两个注解：@Component @Autowired（只针对属性注入，暂时不考虑方法注入）

且需要实现如下的XML的解析，即实现某个包下的Bean扫描。

<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="org.spring.service.v4,org.spring.dao.v4"></context:component-scan>
</beans>

我们首先需要定义注解Component ，Autowired，代码如下：

@Target({ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    boolean required() default true;
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Component {
    String value() default "";
}

其次，我们需要实现一个功能，即：给一个包名，扫描获取到这个包以及子包下面的所有Class，示例代码如下：

  public Resource[] getResources(String basePackage) throws IOException {
        Assert.notNull(basePackage, "basePackage  must not be null");
        // 把包名中的.转成/, 即可获取包的路径
        String location = ClassUtils.convertClassNameToResourcePath(basePackage);
        // TODO  ClassLoader cl = getClassLoader();
        URL url = Thread.currentThread().getContextClassLoader().getResource(location);
        File rootDir = new File(url.getFile());
        Set<File> matchingFiles = retrieveMatchingFiles(rootDir);
        Resource[] result = new Resource[matchingFiles.size()];
        int i = 0;
        for (File file : matchingFiles) {
            result[i++] = new FileSystemResource(file);
        }
        return result;
    }

主要思路是将包名转换成文件路径，然后递归获取路径下的Class文件。

protected Set<File> retrieveMatchingFiles(File rootDir) throws IOException {
        if (!rootDir.exists()) {
            // Silently skip non-existing directories.
            /*if (logger.isDebugEnabled()) {
                logger.debug("Skipping [" + rootDir.getAbsolutePath() + "] because it does not exist");
            }*/
            return Collections.emptySet();
        }
        if (!rootDir.isDirectory()) {
            // Complain louder if it exists but is no directory.
           /* if (logger.isWarnEnabled()) {
                logger.warn("Skipping [" + rootDir.getAbsolutePath() + "] because it does not denote a directory");
            }*/
            return Collections.emptySet();
        }
        if (!rootDir.canRead()) {
            /*if (logger.isWarnEnabled()) {
                logger.warn("Cannot search for matching files underneath directory [" + rootDir.getAbsolutePath() +
                        "] because the application is not allowed to read the directory");
            }*/
            return Collections.emptySet();
        }
  /*String fullPattern = StringUtils.replace(rootDir.getAbsolutePath(), File.separator, "/");
  if (!pattern.startsWith("/")) {
   fullPattern += "/";
  }
  fullPattern = fullPattern + StringUtils.replace(pattern, File.separator, "/");
  */
        Set<File> result = new LinkedHashSet<>(8);
        doRetrieveMatchingFiles(rootDir, result);
        return result;
    }
    protected void doRetrieveMatchingFiles(File dir, Set<File> result) throws IOException {
        File[] dirContents = dir.listFiles();
        if (dirContents == null) {
           /* if (logger.isWarnEnabled()) {
                logger.warn("Could not retrieve contents of directory [" + dir.getAbsolutePath() + "]");
            }*/
            return;
        }
        for (File content : dirContents) {
            if (content.isDirectory()) {
                if (!content.canRead()) {
             /*       if (logger.isDebugEnabled()) {
                        logger.debug("Skipping subdirectory [" + dir.getAbsolutePath() +
                                "] because the application is not allowed to read the directory");
                    }*/
                } else {
                    doRetrieveMatchingFiles(content, result);
                }
            } else {
                result.add(content);
            }
        }
    }

由于注解的Bean不像之前的xml定义的Bean那样，会对Bean配置一个id，所以，这里解析出来的Bean定义需要自动生成一个BeanId（默认先取注解中的value的配置，否则就就是类名第一个字母小写，抽象BeanNameGenerator来专门对Bean定义ID），同时，Spring中单独新建了一个AnnotatedBeanDefinition接口来定义包含注解的BeanDefinition。

我们得到了对应的Class文件，我们需要通过某种方式去解析这个Class文件，拿到这个Class中的所有信息，特别是注解信息。可以使用ASM这个来解析Class的信息，用ASM的原生方式解析不太方便，解析ClassMetaData和Annotation都需要定义一个Visitor，所以Spring抽象了一个接口MetadataReader来封装ASM的实现

public interface MetadataReader {
    /**
     * Read basic class metadata for the underlying class.
     */
    ClassMetadata getClassMetadata();
    /**
     * Read full annotation metadata for the underlying class,
     * including metadata for annotated methods.
     */
    AnnotationMetadata getAnnotationMetadata();
}

然后，我们需要拿到Bean中的所有Field（带注解的），并把他实例化成一个对象，并将这个对象注入目标Bean中，示例代码如下：

public class AutowiredFieldElement extends InjectionElement {
    ...
    @Override
    public void inject(Object target) {
        Field field = getField();
        try {
            DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
            Object value = factory.resolveDependency(desc);
            if (value != null) {
                ReflectionUtils.makeAccessible(field);
                field.set(target, value);
            }
        } catch (Throwable ex) {
            // TODO 异常处理 throw new BeanCreationException("Could not autowire field: " + field, ex);
            throw new RuntimeException("Could not autowire field: " + field);
        }
    }
}

针对于XML的解析，新建了一个ScannedGenericBeanDefinition来处理扫描包下的所有Bean定义。

使用AutowiredAnnotationProcessor来将上述流程整合起来,同时涉及Bean生命周期的钩子函数设计, 相关示例代码如下：

public interface BeanPostProcessor {
    Object beforeInitialization(Object bean, String beanName) throws BeansException;
    Object afterInitialization(Object bean, String beanName) throws BeansException;
}

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    Object beforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;
    boolean afterInstantiation(Object bean, String beanName) throws BeansException;
    void postProcessPropertyValues(Object bean, String beanName) throws BeansException;
}

public class AutowiredAnnotationProcessor implements InstantiationAwareBeanPostProcessor {
    // 实现Bean初始化，并且预留Bean的生命周期的钩子函数
}

关于Bean的生命周期和Bean生命周期中各个钩子函数，参考如下图

实现细节参考代码见：vstep10-annotation-final

实现AOP

即要实现如下XML格式的解析

<context:component-scan
  base-package="org.litespring.service.v5,org.litespring.dao.v5">
 </context:component-scan>
 <bean id="tx" class="org.litespring.tx.TransactionManager" />
 <aop:config>
  <aop:aspect ref="tx">
   <aop:pointcut id="placeOrder"  expression="execution(* org.litespring.service.v5.*.placeOrder(..))" />
   <aop:before pointcut-ref="placeOrder" method="start" />
   <aop:after-returning pointcut-ref="placeOrder" method="commit" />
   <aop:after-throwing pointcut-ref="placeOrder" method = "rollback"/>
  </aop:aspect>
 </aop:config>

首先，我们需要实现如下功能，即，给定一个表达式，然后判断某个类的某个方法是否匹配这个表达式，这需要依赖AspectJ这个组件来实现，具体使用参考AspectJExpressionPointcut和PointcutTest这两个类。

其次，我们需要通过Bean的名称（"tx")和方法名（"start"）定位到这个Method，然后反射调用这个Method，具体可参考MethodLocatingFactoryTest

public class MethodLocatingFactoryTest {
    @Test
    public void testGetMethod() throws Exception{
        DefaultBeanFactory beanFactory = new DefaultBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
        Resource resource = new ClassPathResource("bean-v5.xml");
        reader.loadBeanDefinitions(resource);
        MethodLocatingFactory methodLocatingFactory = new MethodLocatingFactory();
        methodLocatingFactory.setTargetBeanName("tx");
        methodLocatingFactory.setMethodName("start");
        methodLocatingFactory.setBeanFactory(beanFactory);
        // 获取到目标方法
        Method m = methodLocatingFactory.getObject();
        Assert.assertEquals(TransactionManager.class, m.getDeclaringClass());
        Assert.assertEquals(m, TransactionManager.class.getMethod("start"));
    }
}

然后，我们需要使用AOP Alliance实现指定顺序的链式调用，即根据配置的不同advice顺序调用。

具体可查看ReflectiveMethodInvocation和ReflectiveMethodInvocationTest这两个类。

 @Test
    public void testMethodInvocation() throws Throwable{
        Method targetMethod = UserService.class.getMethod("placeOrder");
        List<MethodInterceptor> interceptors = new ArrayList<>();
        interceptors.add(beforeAdvice);
        interceptors.add(afterAdvice);
        ReflectiveMethodInvocation mi = new ReflectiveMethodInvocation(userService,targetMethod,new Object[0],interceptors);
        mi.proceed();
        List<String> msgs = MessageTracker.getMsgs();
        Assert.assertEquals(3, msgs.size());
        Assert.assertEquals("start tx", msgs.get(0));
        Assert.assertEquals("place order", msgs.get(1));
        Assert.assertEquals("commit tx", msgs.get(2));
    }

其中

  Assert.assertEquals(3, msgs.size());
        Assert.assertEquals("start tx", msgs.get(0));
        Assert.assertEquals("place order", msgs.get(1));
        Assert.assertEquals("commit tx", msgs.get(2));

就是验证我们配置的advice是否按指定顺序运行。

最后，我们需要实现动态代理，在一个方法前后增加一些逻辑，而不用改动原始代码。如果是普通类就使用CGLib实现，如果有接口的类可以使用JDK自带的动态代理，具体可参考CGlibTest和CglibAopProxyTest

实现细节参考代码见：vaop-v3

完整代码

lite-spring

参考资料

从零开始造Spring