Spring框架中的设计模式（二）

public class TestProxyAop {
 
  @Test
  public void test() {
    ProxyFactory factory = new ProxyFactory(new House());
    factory.addInterface(Construction.class);
    factory.addAdvice(new BeforeConstructAdvice());
    factory.setExposeProxy(true);
 
    Construction construction = (Construction) factory.getProxy();
    construction.construct();
    assertTrue("Construction is illegal. "
      + "Supervisor didn't give a permission to build "
      + "the house", construction.isPermitted());
  }
 
}
 
interface Construction {
  public void construct();
  public void givePermission();
  public boolean isPermitted();
}
 
class House implements Construction{
         
  private boolean permitted = false;
   
  @Override
  public boolean isPermitted() {
    return this.permitted;
  }
   
  @Override
  public void construct() {
    System.out.println("I'm constructing a house");
  }
 
  @Override
  public void givePermission() {
    System.out.println("Permission is given to construct a simple house");
    this.permitted = true;
  }
}
 
class BeforeConstructAdvice implements MethodBeforeAdvice {
 
  @Override
  public void before(Method method, Object[] arguments, Object target) throws Throwable {
    if (method.getName().equals("construct")) {
      ((Construction) target).givePermission();
    }
  }
         
}

public class CompositeTest {
 
  @Test
  public void test() {
    TextTagComposite composite = new PTag();
    composite.addTag(new SpanTag());
    composite.addTag(new EmTag());
     
    // sample client code
    composite.startWrite();
    for (TextTag leaf : composite.getTags()) {
      leaf.startWrite();
      leaf.endWrite();
    }
    composite.endWrite();
    assertTrue("Composite should contain 2 tags but it contains "+composite.getTags().size(), composite.getTags().size() == 2);
  }
 
}
 
 
interface TextTag {
  public void startWrite();
  public void endWrite();
}
 
interface TextTagComposite extends TextTag {
  public List<TextTag> getTags();
  public void addTag(TextTag tag);
}
 
class PTag implements TextTagComposite {
  private List<TextTag> tags = new ArrayList<TextTag>();
         
  @Override
  public void startWrite() {
    System.out.println("<p>");
  }
 
  @Override
  public void endWrite() {
    System.out.println("</p>");
  }
 
  @Override
  public List<TextTag> getTags() {
    return tags;
  }
   
  @Override
  public void addTag(TextTag tag) {
    tags.add(tag);
  }
}
 
class SpanTag implements TextTag {
 
  @Override
  public void startWrite() {
    System.out.println("<span>");
  }
 
  @Override
  public void endWrite() {
    System.out.println("</span>");
  }
 
}
 
class EmTag implements TextTag {
 
  @Override
  public void startWrite() {
    System.out.println("<em>");
  }
 
  @Override
  public void endWrite() {
    System.out.println("</em>");
  }
         
}

@Override
public String getHandlerMethodName(HttpServletRequest request) throws NoSuchRequestHandlingMethodException {
  String methodName = null;
 
  // Check parameter names where the very existence of each parameter
  // means that a method of the same name should be invoked, if any.
  if (this.methodParamNames != null) {
    for (String candidate : this.methodParamNames) {
      if (WebUtils.hasSubmitParameter(request, candidate)) {
        methodName = candidate;
        if (logger.isDebugEnabled()) {
          logger.debug("Determined handler method '" + methodName +
            "' based on existence of explicit request parameter of same name");
        }
        break;
      }
    }
  }
 
  // Check parameter whose value identifies the method to invoke, if any.
  if (methodName == null && this.paramName != null) {
    methodName = request.getParameter(this.paramName);
    if (methodName != null) {
      if (logger.isDebugEnabled()) {
        logger.debug("Determined handler method '" + methodName +
          "' based on value of request parameter '" + this.paramName + "'");
      }
    }
  }
 
  if (methodName != null && this.logicalMappings != null) {
    // Resolve logical name into real method name, if appropriate.
    String originalName = methodName;
    methodName = this.logicalMappings.getProperty(methodName, methodName);
    if (logger.isDebugEnabled()) {
      logger.debug("Resolved method name '" + originalName + "' to handler method '" + methodName + "'");
    }
  }
 
  if (methodName != null && !StringUtils.hasText(methodName)) {
    if (logger.isDebugEnabled()) {
      logger.debug("Method name '" + methodName + "' is empty: treating it as no method name found");
    }
    methodName = null;
  }
 
  if (methodName == null) {
    if (this.defaultMethodName != null) {
      // No specific method resolved: use default method.
      methodName = this.defaultMethodName;
      if (logger.isDebugEnabled()) {
        logger.debug("Falling back to default handler method '" + this.defaultMethodName + "'");
      }
    }
    else {
      // If resolution failed completely, throw an exception.
      throw new NoSuchRequestHandlingMethodException(request);
    }
  }
 
  return methodName;
}

public class TemplateMethod {
 
  public static void main(String[] args) {
    HouseAbstract house = new SeaHouse();
    house.construct();
  }
 
}
 
abstract class HouseAbstract {
  protected abstract void constructFoundations();
  protected abstract void constructWall();
   
  // template method
  public final void construct() {
    constructFoundations();
    constructWall();
  }
}
 
class EcologicalHouse extends HouseAbstract {
 
  @Override
  protected void constructFoundations() {
    System.out.println("Making foundations with wood");
  }
 
  @Override
  protected void constructWall() {
    System.out.println("Making wall with wood");
  }
         
}
 
class SeaHouse extends HouseAbstract {
 
  @Override
  protected void constructFoundations() {
    System.out.println("Constructing very strong foundations");
  }
 
  @Override
  protected void constructWall() {
    System.out.println("Constructing very strong wall");
  }
         
}

Constructing very strong foundations
Constructing very strong wall

/**
  * Do nothing: We hold a single internal BeanFactory and rely on callers
  * to register beans through our public methods (or the BeanFactory's).
  * @see #registerBeanDefinition
  */
@Override
protected final void refreshBeanFactory() throws IllegalStateException {
  if (this.refreshed) {
    throw new IllegalStateException(
      "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
  }
  this.beanFactory.setSerializationId(getId());
  this.refreshed = true;
}
 
@Override
protected void cancelRefresh(BeansException ex) {
  this.beanFactory.setSerializationId(null);
  super.cancelRefresh(ex);
}
 
/**
  * Not much to do: We hold a single internal BeanFactory that will never
  * get released.
  */
@Override
protected final void closeBeanFactory() {
  this.beanFactory.setSerializationId(null);
}
 
/**
  * Return the single internal BeanFactory held by this context
  * (as ConfigurableListableBeanFactory).
  */
@Override
public final ConfigurableListableBeanFactory getBeanFactory() {
  return this.beanFactory;
}
 
/**
  * Return the underlying bean factory of this context,
  * available for registering bean definitions.
  * <p><b>NOTE:</b> You need to call {@link #refresh()} to initialize the
  * bean factory and its contained beans with application context semantics
  * (autodetecting BeanFactoryPostProcessors, etc).
  * @return the internal bean factory (as DefaultListableBeanFactory)
  */
public final DefaultListableBeanFactory getDefaultListableBeanFactory() {
  return this.beanFactory;
}