XML Schema 编写

package com.foo;

import java.util.ArrayList;
import java.util.List;

public class Component {

  private String name;
  private List<Component> components = new ArrayList<Component> ();

  // 'components' 没有 setter 方法
  public void addComponent(Component component) {
    this.components.add(component);
  }

  public List<Component> getComponents() {
    return components;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }
}

package com.foo;

import infra.beans.factory.FactoryBean;

import java.util.List;

public class ComponentFactoryBean implements FactoryBean<Component> {

  private Component parent;
  private List<Component> children;

  public void setParent(Component parent) {
    this.parent = parent;
  }

  public void setChildren(List<Component> children) {
    this.children = children;
  }

  public Component getObject() throws Exception {
    if (this.children != null && this.children.size() > 0) {
      for (Component child : children) {
        this.parent.addComponent(child);
      }
    }
    return this.parent;
  }

  public Class<Component> getObjectType() {
    return Component.class;
  }

  public boolean isSingleton() {
    return true;
  }
}

package com.foo;

import infra.beans.factory.xml.NamespaceHandlerSupport;

public class ComponentNamespaceHandler extends NamespaceHandlerSupport {

  public void init() {
    registerBeanDefinitionParser("component", new ComponentBeanDefinitionParser());
  }
}

package com.foo;

import infra.beans.factory.config.BeanDefinition;
import infra.beans.factory.support.AbstractBeanDefinition;
import infra.beans.factory.support.BeanDefinitionBuilder;
import infra.beans.factory.support.ManagedList;
import infra.beans.factory.xml.AbstractBeanDefinitionParser;
import infra.beans.factory.xml.ParserContext;
import infra.util.xml.DomUtils;
import org.w3c.dom.Element;

import java.util.List;

public class ComponentBeanDefinitionParser extends AbstractBeanDefinitionParser {

  protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    return parseComponentElement(element);
  }

  private static AbstractBeanDefinition parseComponentElement(Element element) {
    BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(ComponentFactoryBean.class);
    factory.addPropertyValue("parent", parseComponent(element));

    List<Element> childElements = DomUtils.getChildElementsByTagName(element, "component");
    if (childElements != null && childElements.size() > 0) {
      parseChildComponents(childElements, factory);
    }

    return factory.getBeanDefinition();
  }

  private static BeanDefinition parseComponent(Element element) {
    BeanDefinitionBuilder component = BeanDefinitionBuilder.rootBeanDefinition(Component.class);
    component.addPropertyValue("name", element.getAttribute("name"));
    return component.getBeanDefinition();
  }

  private static void parseChildComponents(List<Element> childElements, BeanDefinitionBuilder factory) {
    ManagedList<BeanDefinition> children = new ManagedList<>(childElements.size());
    for (Element element : childElements) {
      children.add(parseComponentElement(element));
    }
    factory.addPropertyValue("children", children);
  }
}

package com.foo;

public class JCacheInitializer {

  private final String name;

  public JCacheInitializer(String name) {
    this.name = name;
  }

  public void initialize() {
    // lots of JCache API calls to initialize the named cache...
  }
}

package com.foo;

import infra.beans.factory.xml.NamespaceHandlerSupport;

public class JCacheNamespaceHandler extends NamespaceHandlerSupport {

  public void init() {
    super.registerBeanDefinitionDecoratorForAttribute("cache-name",
      new JCacheInitializingBeanDefinitionDecorator());
  }

}

package com.foo;

import infra.beans.factory.config.BeanDefinitionHolder;
import infra.beans.factory.support.AbstractBeanDefinition;
import infra.beans.factory.support.BeanDefinitionBuilder;
import infra.beans.factory.xml.BeanDefinitionDecorator;
import infra.beans.factory.xml.ParserContext;
import org.w3c.dom.Attr;
import org.w3c.dom.Node;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class JCacheInitializingBeanDefinitionDecorator implements BeanDefinitionDecorator {

  private static final String[] EMPTY_STRING_ARRAY = new String[0];

  public BeanDefinitionHolder decorate(Node source, BeanDefinitionHolder holder,
      ParserContext ctx) {
    String initializerBeanName = registerJCacheInitializer(source, ctx);
    createDependencyOnJCacheInitializer(holder, initializerBeanName);
    return holder;
  }

  private void createDependencyOnJCacheInitializer(BeanDefinitionHolder holder,
      String initializerBeanName) {
    AbstractBeanDefinition definition = ((AbstractBeanDefinition) holder.getBeanDefinition());
    String[] dependsOn = definition.getDependsOn();
    if (dependsOn == null) {
      dependsOn = new String[]{initializerBeanName};
    } else {
      List dependencies = new ArrayList(Arrays.asList(dependsOn));
      dependencies.add(initializerBeanName);
      dependsOn = (String[]) dependencies.toArray(EMPTY_STRING_ARRAY);
    }
    definition.setDependsOn(dependsOn);
  }

  private String registerJCacheInitializer(Node source, ParserContext ctx) {
    String cacheName = ((Attr) source).getValue();
    String beanName = cacheName + "-initializer";
    if (!ctx.getRegistry().containsBeanDefinition(beanName)) {
      BeanDefinitionBuilder initializer = BeanDefinitionBuilder.rootBeanDefinition(JCacheInitializer.class);
      initializer.addConstructorArg(cacheName);
      ctx.getRegistry().registerBeanDefinition(beanName, initializer.getBeanDefinition());
    }
    return beanName;
  }
}