在之前的兩篇文章中忌栅，我們看到了一些在Spring框架中實現(xiàn)的設計模式。這一次我們會發(fā)現(xiàn)這個流行框架使用的3種新模式。本文將從描述兩個創(chuàng)意設計模式開始：原型和對象池男摧。最后我們將重點關(guān)注行為模式—>觀察者。
原型模式
這篇文章的第一個設計模式是原型译打〔室校可以通過官方文檔查找有關(guān)Spring作用域中的bean作用域的文章中介紹了類似的概念(prototype)。原型設計模式與有用相同名稱的(prototype)作用域有點相似扶平。此設計模式允許通過復制已存在的對象來創(chuàng)建一個對象的實例帆离。副本應該是真正的副本。這意味著新對象的所有屬性應與復制對象的屬性相同结澄。如果不清楚哥谷，比一個簡單的JUnit案例更好的說明：
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();
}
}
在Spring中，在org.springframework.beans.factory.support.AbstractBeanFactory中使用一種特定的原型設計模式麻献，它將初始化bean原型作用域们妥。新對象基于配置文件中的bean定義。我們可以看到勉吻，在給定的例子中：
<bean id="shoppingCart" class="com.waitingforcode.data.ShoppingCart" scope="prototype">
<property name="id" value="9"></property>
</bean>
@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);
}
}
從前面的例子可以看出监婶，ShoppingCart實例是直接從bean定義創(chuàng)建的。最初齿桃，cart1和cart2對象的id值為9.它在測試結(jié)束時被修改惑惶，以證明兩個引用都屬于兩個不同的對象。
對象池
Spring中使用的另一個模型是對象池設計模式短纵。其主要目的在于在一個池中保存特定數(shù)量的對象带污，并根據(jù)需要重新使用。通過它香到，我們可以改善我們想要使用巨型對象的響應時間鱼冀。巨型意味著這些對象的構(gòu)造需要很多時間（例如：持有數(shù)據(jù)庫連接的對象）报破，最好重用已經(jīng)存在的和未獲取的對象，而不是創(chuàng)建新對象千绪。
Spring還使用線程池來管理其調(diào)度部分充易。一些示例位于org.springframework.scheduling.concurrent中。我們檢索數(shù)據(jù)庫（Spring JDBC）項目中的對象池的想法荸型。數(shù)據(jù)庫連接池不是由Spring直接實現(xiàn)的蔽氨，而是適用于Spring工作方式的項目，如C3P0或Jakarta Commons DBCP連接池帆疟。
觀察者
這里呈現(xiàn)的最后一個設計模式是觀察者鹉究。當一個或幾個課程正在等待具體事件時可以使用它。觀察者模式由一個科目和觀察員名單組成踪宠。一個很好的例子就是GUI界面自赔，其中點擊按鈕（按鈕是主題）會引起聽眾（觀察者）啟動的一些操作(再說的直白點就是電影院一場電影這個subject,需要觀眾(也就是觀察者咯),電影產(chǎn)生的一些畫面產(chǎn)生的事件，比如恐怖 電影給男人女人帶來的不同的感官的感受柳琢，傳播到觀察者也就是觀眾的眼里所帶來的不一樣的反應绍妨，這個中間一般會添加一個事件傳播者，在后面解釋Spring的例子的時候會說到)柬脸，例如：打開一個新頁面這個動作他去。可以參考下面的例子：
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();
}
}
可以看到倒堕，關(guān)于我們的Button實例點擊的事件被發(fā)送到所有的觀察者對象灾测。從這些對象開始下載頁面內(nèi)容，第二個將在事件的信息保存在注冊表中垦巴。在Spring中媳搪，觀察者設計模式用于將與應用程序上下文相關(guān)的事件傳輸?shù)給rg.springframework.context.ApplicationListener的實現(xiàn)。要了解它們的實現(xiàn)方法骤宣，我們來看一下AbstractApplicationContext類(老版本的代碼秦爆，新版本的請自行對照)：
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);
}
}
}
在提供的代碼中等限，監(jiān)聽器在內(nèi)部添加到應用程序上下文類中，并且在registerListeners()方法之后芬膝，它們被注冊到由接口org.springframework.context.event.ApplicationEventMulticaster表示的適當?shù)氖录嗦窂V播器(因為有很多l(xiāng)isteners)望门。EventMulticaster負責管理不同的listener和向他們發(fā)布事件。
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));
}
//發(fā)布事件:通過池執(zhí)行任務的方式來做并發(fā)處理蔗候，這樣就把之前的對象池模式給利用上了
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);
}
}
}
...
}
這次我們講3種設計模式:用于在同一個調(diào)用作用域內(nèi)創(chuàng)建bean的原型怒允，避免重新創(chuàng)建巨型對象的對象池埂软，以及將應用程序的上下文事件分派給適當?shù)谋O(jiān)聽器的觀察者锈遥。
原文：Spring框架中的設計模式(三)
轉(zhuǎn)載：極樂科技
