原型模式

这篇文章的第一个设计模式是原型。可以通过官方文档查找有关Spring作用域中的bean作用域的文章中介绍了类似的概念(prototype)。原型设计模式与有用相同名称的(prototype)作用域有点相似。此设计模式允许通过复制已存在的对象来创建一个对象的实例。副本应该是真正的副本。这意味着新对象的所有属性应与复制对象的属性相同。如果不清楚，比一个简单的JUnit案例更好的说明：

1. publicclassPrototypeTest{

2. 
   

3.  @Test

4.  publicvoidtest(){

5.    RobotfirstRobot=newRobot("Droid#1");

6.    RobotsecondRobot=(Robot)firstRobot.clone();

7.    assertTrue("Cloned robot's instance can't be the same as the"

8.      +" source robot instance",

9.      firstRobot!=secondRobot);

10.    assertTrue("Cloned robot's name should be '"+firstRobot.getName()+"'"

11.      +" but was '"+secondRobot.getName()+"'",

12.      secondRobot.getName().equals(firstRobot.getName()));

13.  }

14. 
    

15. }

16. 
    

17. 
    

18. classRobotimplementsCloneable{

19.  privateStringname;

20. 
    

21.  publicRobot(Stringname){

22.    this.name=name;

23.  }

24. 
    

25.  publicStringgetName(){

26.    returnthis.name;

27.  }

28. 
    

29.  protectedObjectclone()throwsCloneNotSupportedException{

30.    returnsuper.clone();

31.  }

32. }

在Spring中，在org.springframework.beans.factory.support.AbstractBeanFactory中使用一种特定的原型设计模式，它将初始化bean原型作用域。新对象基于配置文件中的bean定义。我们可以看到，在给定的例子中：

1. <beanid="shoppingCart"class="com.waitingforcode.data.ShoppingCart"scope="prototype">

2.  <propertyname="id"value="9"></property>

3. </bean>

1. @RunWith(SpringJUnit4ClassRunner.class)

2. @ContextConfiguration(locations={"applicationContext-test.xml"})

3. publicclassSpringPrototypeTest{

4. 
   

5.  @Autowired

6.  privateBeanFactorybeanFactory;

7. 
   

8.  @Test

9.  publicvoidtest(){

10.    ShoppingCartcart1=(ShoppingCart)beanFactory.getBean("shoppingCart");

11.    assertTrue("Id of cart1 should be 9 but was "+cart1.getId(),

12.      cart1.getId()==9);

13.    cart1.setId(100);

14.    ShoppingCartcart2=(ShoppingCart)beanFactory.getBean("shoppingCart");

15.    assertTrue("Id of cart2 should be 9 but was "+cart2.getId(),

16.      cart2.getId()==9);

17.    assertTrue("Id of second cart ("+cart2.getId()+") shouldn't be the same as the first one: "+cart1.getId(),

18.      cart1.getId()!=cart2.getId());

19.    cart2.setId(cart1.getId());

20.    assertTrue("Now (after cart2.setId(cart1.getId())), the id of second cart ("+cart2.getId()+") should be the same as the first one: "

21.      +cart1.getId(),cart1.getId()==cart2.getId());

22.    assertTrue("Both instance shouldn't be the same",cart1!=cart2);

23.  }

24. 
    

25. }

从前面的例子可以看出，ShoppingCart实例是直接从bean定义创建的。最初，cart1和cart2对象的id值为9.它在测试结束时被修改，以证明两个引用都属于两个不同的对象。

对象池

Spring中使用的另一个模型是对象池设计模式。其主要目的在于在一个池中保存特定数量的对象，并根据需要重新使用。通过它，我们可以改善我们想要使用巨型对象的响应时间。巨型意味着这些对象的构造需要很多时间（例如：持有数据库连接的对象），最好重用已经存在的和未获取的对象，而不是创建新对象。

Spring还使用线程池来管理其调度部分。一些示例位于org.springframework.scheduling.concurrent中。我们检索数据库（SpringJDBC）项目中的对象池的想法。数据库连接池不是由Spring直接实现的，而是适用于Spring工作方式的项目，如C3P0或JakartaCommonsDBCP连接池。

观察者

这里呈现的最后一个设计模式是观察者。当一个或几个课程正在等待具体事件时可以使用它。观察者模式由一个科目和观察员名单组成。一个很好的例子就是GUI界面，其中点击按钮（按钮是主题）会引起听众（观察者）启动的一些操作(再说的直白点就是电影院一场电影这个subject,需要观众(也就是观察者咯),电影产生的一些画面产生的事件，比如恐怖 电影给男人女人带来的不同的感官的感受，传播到观察者也就是观众的眼里所带来的不一样的反应，这个中间一般会添加一个事件传播者，在后面解释Spring的例子的时候会说到)，例如：打开一个新页面这个动作。可以参考下面的例子：

1. publicclassObserverTest{

2. 
   

3.  @Test

4.  publicvoidtest(){

5.    ObserverpageOpener=newPageOpener();

6.    Observerregister=newRegister();

7.    Buttonbtn=newButton();

8.    btn.addListener(pageOpener);

9.    btn.addListener(register);

10.    btn.clickOn();

11.    assertTrue("Button should be clicked but it wasn't",

12.      btn.wasClicked());

13.    assertTrue("Page opener should be informed about click but it wasn't",

14.      pageOpener.wasInformed());

15.    assertTrue("Register should be informed about click but it wasn't",

16.      register.wasInformed());

17.  }

18. 
    

19. }

20. 
    

21. classButton{

22. 
    

23.  privatebooleanclicked;

24.  privateList<observer>listeners;

25. 
    

26.  publicList<observer>getListeners(){

27.    if(this.listeners==null){

28.      this.listeners=newArrayList<observer>();

29.    }

30.    returnthis.listeners;

31.  }

32. 
    

33.  publicvoidaddListener(Observerobserver){

34.    getListeners().add(observer);

35.  }

36. 
    

37.  publicbooleanwasClicked(){

38.    returnthis.clicked;

39.  }

40. 
    

41.  publicvoidclickOn(){

42.    this.clicked=true;

43.    informAll();

44.  }

45. 
    

46.  privatevoidinformAll(){

47.    for(Observerobserver:getListeners()){

48.      observer.informAboutEvent();

49.    }

50.  }

51. 
    

52. }

53. 
    

54. abstractclassObserver{

55.  protectedbooleaninformed;

56. 
    

57.  publicvoidinformAboutEvent(){

58.    this.informed=true;

59.  }

60. 
    

61.  publicbooleanwasInformed(){

62.    returnthis.informed;

63.  }

64. }

65. 
    

66. classPageOpenerextendsObserver{

67. 
    

68.  @Override

69.  publicvoidinformAboutEvent(){

70.    System.out.println("Preparing download of new page");

71.    super.informAboutEvent();

72.  }

73. 
    

74. }

75. 
    

76. classRegisterextendsObserver{

77. 
    

78.  @Override

79.  publicvoidinformAboutEvent(){

80.    System.out.println("Adding the action to register");

81.    super.informAboutEvent();

82.  }

83. }

可以看到，关于我们的Button实例点击的事件被发送到所有的观察者对象。从这些对象开始下载页面内容，第二个将在事件的信息保存在注册表中。在Spring中，观察者设计模式用于将与应用程序上下文相关的事件传输到org.springframework.context.ApplicationListener的实现。要了解它们的实现方法，我们来看一下AbstractApplicationContext类(老版本的代码，新版本的请自行对照)：

1. publicabstractclassAbstractApplicationContextextendsDefaultResourceLoader

2.  implementsConfigurableApplicationContext,DisposableBean{

3.  /** Statically specified listeners */

4.  privateSet<applicationlistener<?>>applicationListeners=newLinkedHashSet<applicationlistener<?>>();

5. 
   

6.  // some other fields and methods

7.  @Override

8.  publicvoidaddApplicationListener(ApplicationListener<?>listener){

9.    if(this.applicationEventMulticaster!=null){

10.      this.applicationEventMulticaster.addApplicationListener(listener);

11.    }

12.    else{//新版本这里直接咔嚓掉，上面的applicationEventMulticaster一旦为空，就会报错的

13.      this.applicationListeners.add(listener);

14.    }

15.  }

16. 
    

17.  /**

18.    * Return the list of statically specified ApplicationListeners.

19.    */

20.  publicCollection<applicationlistener<?>>getApplicationListeners(){

21.    returnthis.applicationListeners;

22.  }

23. 
    

24.  /**

25.    * Add beans that implement ApplicationListener as listeners.

26.    * Doesn't affect other listeners, which can be added without being beans.

27.    */

28.  protectedvoidregisterListeners(){

29.    // Register statically specified listeners first.

30.    for(ApplicationListener<?>listener:getApplicationListeners()){

31.      getApplicationEventMulticaster().addApplicationListener(listener);

32.    }

33.    // Do not initialize FactoryBeans here: We need to leave all regular beans

34.    // uninitialized to let post-processors apply to them!

35.    String[]listenerBeanNames=getBeanNamesForType(ApplicationListener.class,true,false);

36.    for(StringlisName:listenerBeanNames){

37.      getApplicationEventMulticaster().addApplicationListenerBean(lisName);

38.    }

39.  }

40. }

在提供的代码中，监听器在内部添加到应用程序上下文类中，并且在registerListeners()方法之后，它们被注册到由接口org.springframework.context.event.ApplicationEventMulticaster表示的适当的事件多路广播器(因为有很多listeners)。EventMulticaster负责管理不同的listener和向他们发布事件。

1. publicclassSimpleApplicationEventMulticasterextendsAbstractApplicationEventMulticaster{

2.    privateExecutortaskExecutor;

3.    privateErrorHandlererrorHandler;

4. 
   

5.    publicSimpleApplicationEventMulticaster(){

6.    }

7. 
   

8.    publicSimpleApplicationEventMulticaster(BeanFactorybeanFactory){

9.        this.setBeanFactory(beanFactory);

10.    }

11. 
    

12.    publicvoidsetTaskExecutor(ExecutortaskExecutor){

13.        this.taskExecutor=taskExecutor;

14.    }

15. 
    

16.    protectedExecutorgetTaskExecutor(){

17.        returnthis.taskExecutor;

18.    }

19. 
    

20.    publicvoidsetErrorHandler(ErrorHandlererrorHandler){

21.        this.errorHandler=errorHandler;

22.    }

23. 
    

24.    protectedErrorHandlergetErrorHandler(){

25.        returnthis.errorHandler;

26.    }

27. 
    

28.    publicvoidmulticastEvent(ApplicationEventevent){

29.        this.multicastEvent(event,this.resolveDefaultEventType(event));

30.    }

31.    //发布事件:通过池执行任务的方式来做并发处理，这样就把之前的对象池模式给利用上了

32.    publicvoidmulticastEvent(finalApplicationEventevent,ResolvableTypeeventType){

33.        ResolvableTypetype=eventType!=null?eventType:this.resolveDefaultEventType(event);

34.        Iteratorvar4=this.getApplicationListeners(event,type).iterator();

35. 
    

36.        while(var4.hasNext()){

37.            finalApplicationListener<?>listener=(ApplicationListener)var4.next();

38.            Executorexecutor=this.getTaskExecutor();

39.            if(executor!=null){

40.                executor.execute(newRunnable(){

41.                    publicvoidrun(){

42.                        SimpleApplicationEventMulticaster.this.invokeListener(listener,event);

43.                    }

44.                });

45.            }else{

46.                this.invokeListener(listener,event);

47.            }

48.        }

49. 
    

50.    }

51. ...

52. }

这次我们讲3种设计模式:用于在同一个调用作用域内创建bean的原型，避免重新创建巨型对象的对象池，以及将应用程序的上下文事件分派给适当的监听器的观察者。

原文链接：https://mp.weixin.qq.com/s/wsTqmXSSM0ixMlk_2af0FA