Spring中的用到的设计模式

应该说设计模式是咱们在写代码时候的一种被认可的较好的模式。好的设计模式就像是给代码造了一个很好的骨架，在这个骨架里，你能够知道心在哪里，肺在哪里，由于大多数人都认识这样的骨架，就有了很好的传播性。这是从易读和易传播来感知设计模式的好处。固然设计模式自己更重要的是设计原则的一种实现，好比开闭原则，依赖倒置原则，这些是在代码的修改和扩展上说事。说到底就是人类和代码发生关系的四种场合：阅读，修改，增长，删除。让每一种场合都比较舒服的话，就须要用设计模式。

下面来简单列举Spring中的设计模式：

1. 简单工厂

又叫作静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该建立哪个产品类。

Spring中的BeanFactory就是简单工厂模式的体现，根据传入一个惟一的标识来得到Bean对象，可是否是在传入参数后建立仍是传入参数前建立这个要根据具体状况来定。

以下配置，就是在 HelloItxxz 类中建立一个 itxxzBean。

<beans>

    <bean id="singletonBean" class="com.itxxz.HelloItxxz">

        <constructor-arg>

            <value>Hello! 这是singletonBean!value>

        </constructor-arg>

   </ bean>

 

    <bean id="itxxzBean" class="com.itxxz.HelloItxxz"

        singleton="false">

        <constructor-arg>

            <value>Hello! 这是itxxzBean! value>

        </constructor-arg>

    </bean>

 

</beans>

2. 工厂方法（Factory Method）

定义一个用于建立对象的接口，让子类决定实例化哪个类。Factory Method使一个类的实例化延迟到其子类。

Spring中的FactoryBean就是典型的工厂方法模式。

一般由应用程序直接使用new建立新的对象，为了将对象的建立和使用相分离，采用工厂模式,即应用程序将对象的建立及初始化职责交给工厂对象。

通常状况下,应用程序有本身的工厂对象来建立bean.若是将应用程序本身的工厂对象交给Spring管理,那么Spring管理的就不是普通的bean,而是工厂Bean。

螃蟹就以工厂方法中的静态方法为例讲解一下：

import java.util.Random;

public class StaticFactoryBean {

      public static Integer createRandom() {

           return new Integer(new Random().nextInt());

       }

}

建一个config.xm配置文件，将其归入Spring容器来管理,须要经过factory-method指定静态方法名称

<bean id="random"

class="example.chapter3.StaticFactoryBean" factory-method="createRandom" //createRandom方法必须是static的,才能找到 scope="prototype"

/>

测试:

public static void main(String[] args) {
      //调用getBean()时,返回随机数.若是没有指定factory-method,会返回StaticFactoryBean的实例,即返回工厂Bean的实例       XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("config.xml"));       System.out.println("我是IT学习者建立的实例:"+factory.getBean("random").toString());

}

3. 单例（Singleton）

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

Spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例，这是由于Spring管理的是是任意的Java对象。

核心提示点：Spring下默认的bean均为singleton，能够经过singleton=“true|false” 或者 scope=“？”来指定

4. 适配器（Adapter）

将一个类的接口转换成客户但愿的另一个接口。Adapter模式使得本来因为接口不兼容而不能一块儿工做的那些类能够一块儿工做。

Spring中在对于AOP的处理中有Adapter模式的例子

在Spring的Aop中，使用的Advice（通知）来加强被代理类的功能。Spring实现这一AOP功能的原理就使用代理模式（一、JDK动态代理。二、CGLib字节码生成技术代理。）对类进行方法级别的切面加强，即，生成被代理类的代理类， 并在代理类的方法前，设置拦截器，经过执行拦截器重的内容加强了代理方法的功能，实现的面向切面编程。

Adapter类接口：Target

public interface AdvisorAdapter {

 

boolean supportsAdvice(Advice advice);

 

      MethodInterceptor getInterceptor(Advisor advisor);

 

}  MethodBeforeAdviceAdapter类，Adapter

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {

 

      public boolean supportsAdvice(Advice advice) {

            return (advice instanceof MethodBeforeAdvice);

      }

 

      public MethodInterceptor getInterceptor(Advisor advisor) {

            MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();

      return new MethodBeforeAdviceInterceptor(advice);

      }

 

}

 

5.包装器（Decorator）

动态地给一个对象添加一些额外的职责。就增长功能来讲，Decorator模式相比生成子类更为灵活。

Spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另外一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。

 

在咱们的项目中遇到这样一个问题：咱们的项目须要链接多个数据库，并且不一样的客户在每次访问中根据须要会去访问不一样的数据库。咱们以往在spring和hibernate框架中老是配置一个数据源，于是sessionFactory的dataSource属性老是指向这个数据源而且恒定不变，全部DAO在使用sessionFactory的时候都是经过这个数据源访问数据库。可是如今，因为项目的须要，咱们的DAO在访问sessionFactory的时候都不得不在多个数据源中不断切换，问题就出现了：如何让sessionFactory在执行数据持久化的时候，根据客户的需求可以动态切换不一样的数据源？咱们能不能在spring的框架下经过少许修改获得解决？是否有什么设计模式能够利用呢？ 
首先想到在spring的applicationContext中配置全部的dataSource。这些dataSource多是各类不一样类型的，好比不一样的数据库：Oracle、SQL Server、MySQL等，也多是不一样的数据源：好比apache 提供的org.apache.commons.dbcp.BasicDataSource、spring提供的org.springframework.jndi.JndiObjectFactoryBean等。而后sessionFactory根据客户的每次请求，将dataSource属性设置成不一样的数据源，以到达切换数据源的目的。

 

 

6. 代理（Proxy）

为其余对象提供一种代理以控制对这个对象的访问。

从结构上来看和Decorator模式相似，但Proxy是控制，更像是一种对功能的限制，而Decorator是增长职责。

Spring的Proxy模式在aop中有体现，好比JdkDynamicAopProxy和Cglib2AopProxy。

 

7.观察者（Observer）

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，全部依赖于它的对象都获得通知并被自动更新。

Spring中Observer模式经常使用的地方是listener的实现。如ApplicationListener。

8. 策略（Strategy）

定义一系列的算法，把它们一个个封装起来，而且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

Spring中在实例化对象的时候用到Strategy模式，见以下图：

在SimpleInstantiationStrategy中有以下代码说明了策略模式的使用状况：

还有 ，第一个地方，加载资源文件的方式，使用了不一样的方法，好比：ClassPathResourece，FileSystemResource，ServletContextResource，UrlResource但他们都有共同的借口Resource；

第二个地方就是在Aop的实现中，采用了两种不一样的方式，JDK动态代理和CGLIB代理；

第三个地方就是Spring的事务管理，PlatformTransactionManager表明事务管理接口，可是它不知道底层如何管理事务，它只要求事务管理

提供开始事务(getTransaction(),commit(),rollback()三个方法，可是如何实现则交给具体实现类来完成--不一样的实现类表明不一样的事务管理策略。

通常来讲，spring事务管理下面主要针对

1) JDBC(org.springframework.jdbc.datasource.DataSourceTransactionManager),

2) Hibernate (org.springframework.orm.hibernate3.HibernateTransactionManager)，

3) JTA (org.springframework.transaction.jta.JtaTransactionManager)和

4) JPA(org.springframework.orm.jpa.JpaTransactionManager)

四种具体的底层事务控制来包装的。

9.模板方法（Template Method）

定义一个操做中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类能够不改变一个算法的结构便可重定义该算法的某些特定步骤。Template Method模式通常是须要继承的。这里想要探讨另外一种对Template Method的理解。Spring中的JdbcTemplate，在用这个类时并不想去继承这个类，由于这个类的方法太多，可是咱们仍是想用到JdbcTemplate已有的稳定的、公用的数据库链接，那么咱们怎么办呢？咱们能够把变化的东西抽出来做为一个参数传入JdbcTemplate的方法中。可是变化的东西是一段代码，并且这段代码会用到JdbcTemplate中的变量。怎么办？那咱们就用回调对象吧。在这个回调对象中定义一个操纵JdbcTemplate中变量的方法，咱们去实现这个方法，就把变化的东西集中到这里了。而后咱们再传入这个回调对象到JdbcTemplate，从而完成了调用。这多是Template Method不须要继承的另外一种实现方式吧。

如下是一个具体的例子：

JdbcTemplate中的execute方法：

JdbcTemplate执行execute方法：