Spring之设计模式2

个人专题目录

9、原型模式

可以通过官方文档查找有关Spring作用域中的bean作用域的文章中介绍了类似的概念(prototype)。原型设计模式与有用相同名称的(prototype)作用域有点相似。此设计模式允许通过复制已存在的对象来创建一个对象的实例。副本应该是真正的副本。这意味着新对象的所有属性应与复制对象的属性相同。如果不清楚，比一个简单的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定义创建的。最初，cart1和cart2对象的id值为9.它在测试结束时被修改，以证明两个引用都属于两个不同的对象。

10、对象池

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

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

11、观察者

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

可以看到，关于我们的Button实例点击的事件被发送到所有的观察者对象。从这些对象开始下载页面内容，第二个将在事件的信息保存在注册表中。在Spring中，观察者设计模式用于将与应用程序上下文相关的事件传输到org.springframework.context.ApplicationListener的实现。要了解它们的实现方法，我们来看一下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);
        }
    }
}

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

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);
            }
        }

    }
...
}

12、适配器

当我们需要在给定场景下(也就是给定接口)想要不改变自身行为而又想做到一些事情的情况下(就是我给电也就是接口了，你来做事也就是各种电器)，使用适配器设计模式(这里再说一点，就相当于我们再一个规章制度的环境下，如何去适应并达到我们期待的效果，放在架构设计这里，可以拿一个php系统和一个Java系统来说，假如两者要互相调用对方的功能，我们可以设计一套对外的api来适配)。这意味着在调用此对象之前，我们将更改使用对象而不改变机制。拿一个现实中的例子进行说明，想象一下你想要用电钻来钻一个洞。要钻一个小洞，你会使用小钻头，钻一个大的需要用大钻头。可以看下面的代码：

public class AdapterTest {
    public static void main(String[] args) {
        HoleMaker maker = new HoleMakerImpl();
        maker.makeHole(1);
        maker.makeHole(2);
        maker.makeHole(30);
        maker.makeHole(40);
    }
}

interface HoleMaker {
    void makeHole(int diameter);
}

interface DrillBit {
    void makeSmallHole();

    void makeBigHole();
}

// Two adaptee objects
class BigDrillBit implements DrillBit {
    @Override
    public void makeSmallHole() {
        // do nothing
    }

    @Override
    public void makeBigHole() {
        System.out.println("Big hole is made byt WallBigHoleMaker");
    }
}

class SmallDrillBit implements DrillBit {
    @Override
    public void makeSmallHole() {
        System.out.println("Small hole is made byt WallSmallHoleMaker");
    }

    @Override
    public void makeBigHole() {
        // do nothing
    }
}

// Adapter class
class Drill implements HoleMaker {
    private DrillBit drillBit;

    public Drill(int diameter) {
        drillBit = getMakerByDiameter(diameter);
    }

    @Override
    public void makeHole(int diameter) {
        if (isSmallDiameter(diameter)) {
            drillBit.makeSmallHole();
        } else {
            drillBit.makeBigHole();
        }
    }

    private DrillBit getMakerByDiameter(int diameter) {
        if (isSmallDiameter(diameter)) {
            return new SmallDrillBit();
        }
        return new BigDrillBit();
    }

    private boolean isSmallDiameter(int diameter) {
        return diameter < 10;
    }
}

// Client class
class HoleMakerImpl implements HoleMaker {
    @Override
    public void makeHole(int diameter) {
        HoleMaker maker = new Drill(diameter);
        maker.makeHole(diameter);
    }
}
还有 70% 的精彩内容
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。
支付 ¥2.99 继续阅读

推荐阅读更多精彩内容

  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 135,234评论 19赞 139
  • Spring-IoC容器文档（5.0.7BUILD-SNAPSHOT）
    1.1 Spring IoC容器和bean简介 本章介绍了Spring Framework实现的控制反转（IoC）...
    起名真是难阅读 2,626评论 0赞 8
  • Spring IoC 容器
    1.1 spring IoC容器和beans的简介 Spring 框架的最核心基础的功能是IoC（控制反转）容器，...
    simoscode阅读 6,779评论 2赞 22
  • Spring boot参考指南
    Spring Boot 参考指南 介绍 转载自:https://www.gitbook.com/book/qbgb...
    毛宇鹏阅读 46,997评论 6赞 342
  • 2017年5月总结
    5月大事记 5月1日 见南昌趁早读书会会长亭亭羊，见周馨 5月2日 南昌趁早多多视频 5月5日 出发山东，参...
    姑娘好好过阅读 307评论 3赞 4