public class PrototypeTest {
 
  @Test
  public void test() {
    Robot firstRobot = new Robot("Droid#1");
    Robot secondRobot = (Robot) firstRobot.clone();
    assertTrue("Cloned robot's instance can't be the same as the"
      +" source robot instance", 
      firstRobot != secondRobot);
    assertTrue("Cloned robot's name should be '"+firstRobot.getName()+"'"
      +" but was '"+secondRobot.getName()+"'", 
      secondRobot.getName().equals(firstRobot.getName()));
  }
 
}
 
 
class Robot implements Cloneable {
  private String name;
   
  public Robot(String name) {
    this.name = name;
  }
   
  public String getName() {
    return this.name;
  }
 
  protected Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"applicationContext-test.xml"})
public class SpringPrototypeTest {
 
  @Autowired
  private BeanFactory beanFactory;
   
  @Test
  public void test() {
    ShoppingCart cart1 = (ShoppingCart) beanFactory.getBean("shoppingCart");
    assertTrue("Id of cart1 should be 9 but was "+cart1.getId(), 
      cart1.getId() == 9);
    cart1.setId(100);
    ShoppingCart cart2 = (ShoppingCart) beanFactory.getBean("shoppingCart");
    assertTrue("Id of cart2 should be 9 but was "+cart2.getId(), 
      cart2.getId() == 9);
    assertTrue("Id of second cart ("+cart2.getId()+") shouldn't be the same as the first one: "+cart1.getId(), 
      cart1.getId() != cart2.getId());
    cart2.setId(cart1.getId());
    assertTrue("Now (after cart2.setId(cart1.getId())), the id of second cart ("+cart2.getId()+") should be the same as the first one: "
      +cart1.getId(), cart1.getId() == cart2.getId());
    assertTrue("Both instance shouldn't be the same", cart1 != cart2);
  }
 
}

public class ObserverTest {
 
  @Test
  public void test() {
    Observer pageOpener = new PageOpener();
    Observer register = new Register();
    Button btn = new Button();
    btn.addListener(pageOpener);
    btn.addListener(register);
    btn.clickOn();
    assertTrue("Button should be clicked but it wasn't", 
      btn.wasClicked());
    assertTrue("Page opener should be informed about click but it wasn't", 
      pageOpener.wasInformed());
    assertTrue("Register should be informed about click but it wasn't", 
      register.wasInformed());
  }
 
}
 
class Button {
         
  private boolean clicked;
  private List<observer> listeners;
   
  public List<observer> getListeners() {
    if (this.listeners == null) {
      this.listeners = new ArrayList<observer>();
    }
    return this.listeners;
  }
   
  public void addListener(Observer observer) {
    getListeners().add(observer);
  }
   
  public boolean wasClicked() {
    return this.clicked;
  }
   
  public void clickOn() {
    this.clicked = true;
    informAll();
  }
   
  private void informAll() {
    for (Observer observer : getListeners()) {
      observer.informAboutEvent();
    }
  }
         
}
 
abstract class Observer {
  protected boolean informed;
   
  public void informAboutEvent() {
    this.informed = true;
  }
   
  public boolean wasInformed() {
    return this.informed;
  }
}
 
class PageOpener extends Observer {
         
  @Override
  public void informAboutEvent() {
    System.out.println("Preparing download of new page");
    super.informAboutEvent();
  }
         
}
 
class Register extends Observer {
 
  @Override
  public void informAboutEvent() {
    System.out.println("Adding the action to register");
    super.informAboutEvent();
  }
}

public abstract class AbstractApplicationContext extends DefaultResourceLoader
 implements ConfigurableApplicationContext, DisposableBean {
  /** Statically specified listeners */
  private Set<applicationlistener<?>> applicationListeners = new LinkedHashSet<applicationlistener<?>>();
   
  // some other fields and methods
  @Override
  public void addApplicationListener(ApplicationListener<?> listener) {
    if (this.applicationEventMulticaster != null) {
      this.applicationEventMulticaster.addApplicationListener(listener);
    }
    else {//新版本这里直接咔嚓掉，上面的applicationEventMulticaster一旦为空，就会报错的
      this.applicationListeners.add(listener);
    }
  }
 
  /**
 * Return the list of statically specified ApplicationListeners.
 */
  public Collection<applicationlistener<?>> getApplicationListeners() {
    return this.applicationListeners;
  }
 
  /**
 * Add beans that implement ApplicationListener as listeners.
 * Doesn't affect other listeners, which can be added without being beans.
 */
  protected void registerListeners() {
    // Register statically specified listeners first.
    for (ApplicationListener<?> listener : getApplicationListeners()) {
      getApplicationEventMulticaster().addApplicationListener(listener);
    }
    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let post-processors apply to them!
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String lisName : listenerBeanNames) {
      getApplicationEventMulticaster().addApplicationListenerBean(lisName);
    }
  }
}

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
    private Executor taskExecutor;
    private ErrorHandler errorHandler;

    public SimpleApplicationEventMulticaster() {
    }

    public SimpleApplicationEventMulticaster(BeanFactory beanFactory) {
        this.setBeanFactory(beanFactory);
    }

    public void setTaskExecutor(Executor taskExecutor) {
        this.taskExecutor = taskExecutor;
    }

    protected Executor getTaskExecutor() {
        return this.taskExecutor;
    }

    public void setErrorHandler(ErrorHandler errorHandler) {
        this.errorHandler = errorHandler;
    }

    protected ErrorHandler getErrorHandler() {
        return this.errorHandler;
    }

    public void multicastEvent(ApplicationEvent event) {
        this.multicastEvent(event, this.resolveDefaultEventType(event));
    }
	//发布事件:通过池执行任务的方式来做并发处理，这样就把之前的对象池模式给利用上了
    public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
        ResolvableType type = eventType != null?eventType:this.resolveDefaultEventType(event);
        Iterator var4 = this.getApplicationListeners(event, type).iterator();

        while(var4.hasNext()) {
            final ApplicationListener<?> listener = (ApplicationListener)var4.next();
            Executor executor = this.getTaskExecutor();
            if(executor != null) {
                executor.execute(new Runnable() {
                    public void run() {
                        SimpleApplicationEventMulticaster.this.invokeListener(listener, event);
                    }
                });
            } else {
                this.invokeListener(listener, event);
            }
        }

    }
...
}