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

时间  2019-11-07
标签 spring 框架 设计 模式 栏目 Spring 繁體版
原文   原文链接

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

原创： 瑞查德-Jackhtml

在以前的两篇文章中，咱们看到了一些在Spring框架中实现的设计模式。这一次咱们会发现这个流行框架使用的3种新模式。java

本文将从描述两个创意设计模式开始：原型和对象池。spring

最后咱们将重点关注行为模式—>观察者。数据库

 

本篇前传：设计模式

原型模式

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

  1. 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定义。咱们能够看到，在给定的例子中：ide

  1. <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定义建立的。最初，cart1和 cart2对象的 id值为 9.它在测试结束时被修改，以证实两个引用都属于两个不一样的对象。post

对象池

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

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

观察者

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

  1. 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();

 }

}

     

     

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

  1. 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);

   }

 }

}

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

  2. 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);

           }

       }



   }

...

}

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

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程