Spring 实现两种设计模式：工厂模式和单态模式（单例模式）

时间 2019-12-11

原文原文链接

本文摘自：李刚著《轻量级 Java EE企业应用实战 Struts2+Spring+hibernate整合开发》html

在Spring 中大量使用的如下两种设计模式：工厂模式和单态模式。java

工厂模式可将Java 对象的调用者从被调用者的实现逻辑中分离出来，调用者只需关心被调用者必须知足的规则(接口) ，而没必要关心实例的具体实现过程。这是面向接口编程的优点，能提升程序的解耦，避免全部的类以硬编码方式耦合在一块儿。spring

若是全部的类直接耦合，极易造成"骨牌效应"，假如B 类调用了A 类，一旦A 类须要修改，则B 类也须要修改；假如C 类调用了B 类，则C 类也须要修改......依次类推，从而致使整个系统都须要改写。形成"牵一发而动全身"，而系统重构的代价是至关高的。数据库

Spring 倡导”面向接口编程“，能够避免上述的问题，使设计良好的架构可保证系统重构的工做被封闭在重构的层内，毫不会影响其余层。编程

Spring 容器是实例化和管理所有bean 的工厂，Spring 默认将全部的bean 设置成单态模式，无须本身完成单态模式，即对全部相同id 的bean 请求都将返回同一个共享实例。所以，单态模式可大大下降Java 对象在建立和销毁时的系统开销。设计模式

一. 单态模式的回顾架构

单态模式限制了类实例的建立，但采用这种模式设计的类，能够保证仅有一个实例，并可提供访问该实例的全局访问点。J2EE应用的大量组件，都须要保证一个类只有一个实例。好比数据库引擎访问点只能有一个。框架

更多的时候，为了提升性能，程序应尽可能减小Java 对象的建立和销毁时的开销。使用单态模式可避免Java 类被屡次实例化，让相同类的所有实例共享同一内存区。性能

为了防止单态模式的类被屡次实例化，应将类的构造器设成私有，这样就保证了只能经过静态方法得到类实例。而该静态方法则保证每次返回的实例都是同一个，这就需将该类的实例设置成类属性，因为该属性须要被静态方法访问，所以该属性应设成静态属性。测试

下面给出单态模式的示例代码：

package ppp;
//单态模式测试类
public class SingletonTest {
//该类的一个普通属性
int value;
//使用静态属性保存该类的一个实例
private static SingletonTest instance;
//构造器私有化，避免该类被屡次实例化
private SingletonTest(){
System.out.println("正在执行构造器...");
}
//提供静态方法返回该类实例
public static SingletonTest getInstance(){
//实例化类实例前，先检查该实例是否存在
if(instance == null){
//若是不存在，则新建一个实例
instance = new SingletonTest();
}
//返回该类的成员变量：该类的实例
return instance;
}
//如下提供对普通属性value的getter和setter方法
public int getValue(){
return value;
}
public void setValue(int values){
this.value = values;
}
public static void main(String args[]){
SingletonTest t1 = SingletonTest.getInstance();
SingletonTest t2 = SingletonTest.getInstance();
t2.setValue(9);
System.out.println(t1 == t2);
}
}

从程序最后的打印结果能够看出，该类的两个实例彻底相同。这证实单态模式类的所有实例是同一共享实例。程序里虽然得到了类的两个实例，但实际上只执行一次构造器，由于对于单态模式的类，不管有多少次的建立实例请求，都只执行一次构造器。

二. 工厂模式的回顾

工厂模式是根据调用数据返回某个类的一个实例，此类能够是多个类的某一个类。一般，这些类知足共同的规则(接口)或父类。调用者只关心工厂生产的实例是否知足某种规范，即实现的某个接口是否可供本身正常调用(调用者仅仅使用)。该模式给对象之间做出了清晰的角色划分，下降程序的耦合。

接口产生的所有实例一般用于实现相同接口，接口里定义了所有实例共同拥有的方法，这些方法在不一样的实现类中实现的方式不一样。从而使程序调用者无须关心方法的具体实现，下降了系统异构的代价。

下面是工厂模式的示例代码：

package ppp;
//Person接口定义
public interface Person {
public String sayHello(String name);
public String sayGoodbye(String name);
}

该接口定义了Person规范，规范要求实现该接口的类必须具备如下两个的方法：能打招呼，能告别。

package ppp;
//American类实现Person接口
public class American implements Person {
public String sayHello(String name){
return name+",hello";
}
public String sayGoodbye(String name)
{
return name+",goodbye";
}
}

下面是Person类的另外一个实现类：Chinese

package ppp;
//Chinese类实现Person接口
public class Chinese implements Person {
public String sayHello(String name){
return name+",您好";
}
public String sayGoodbye(String name)
{
return name+",下次再见";
}
}

而后再看Person工厂的代码：

package ppp;
public class PersonFactory {
public Person getPerson(String ethnic)
{
if(ethnic.equalsIgnoreCase("chin"))
{
return new Chinese();
}else{
return new American();
}
}
}

以上是最简单的工厂模式框架，其主程序以下：

package ppp;
public class FactoryTest {
public static void main(String[] args){
//建立PersonFactory实例，得到工厂实例
PersonFactory pf = new PersonFactory();
//定义接口Person实例，面向接口编程
Person p = null;
//使用工厂得到person实例
p = pf.getPerson("chin");
//下面调用Person接口方法
System.out.println(p.sayHello("wawa"));
System.out.println(p.sayGoodbye("wawa"));
//使用工厂得到Person的另外一个实例
p = pf.getPerson("ame");
//再次调用Person接口的方法
System.out.println(p.sayHello("wawa"));
System.out.println(p.sayGoodbye("wawa"));
}
}

由此可看出，主程序从Person 接口的具体类中解耦出来，并且程序调用者无须关心Person 的实例化过程，主程序仅仅与工厂服务定位结合在一块儿，可得到全部工厂能产生的实例。具体类的变化，接口无须发生任何改变，调用者程序代码部分也无须发生任何改动。
下面是Spring 对这两种模式的实现。

三. Spring 对单态与工厂模式的实现

随着Spring 提供工厂模式的实现，在使用Spring 时，无须本身提供工厂类。由于Spring容器是最大的工厂，并且是个功能超强的工厂。Spring 使用配置文件管理全部的bean ，其配置文件中bean 由Spring 工厂负责生成和管理。

下面是关于两个实例的配置文件：

<?xml version = "1.0" encoding = "gb2312"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springsource.org/dtd/spring-beans.dtd">
<beans>
<bean id = "chinese" class = "ppp.Chinese"/>
<bean id = "american" class = "ppp.American"/>
</beans>

主程序部分以下：

package ppp;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class SpringTest {
public static void main(String[] args) {
//实例化Spring容器
ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
//定义Person接口实例
Person p = null;
//经过Spring上下文得到Chinese实例
p = (Person)ctx.getBean("chinese");
//执行chinese实例的方法
System.out.println(p.sayHello("wawa"));
System.out.println(p.sayGoodbye("wawa"));
p = (Person)ctx.getBean("american");
System.out.println(p.sayHello("wawa"));
System.out.println(p.sayGoodbye("wawa"));
}
}

使用Spring 时，即便没有工厂类PersonFactory ，程序同样可使用工厂模式， Spring彻底能够提供全部工厂模式的功能。

下面对主程序部分进行简单的修改：

package ppp;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class SpringTest{
public static void main(String[] args){
//实例化Spring容器
ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
//定义p1接口的实例p1
Person p1 = null;
//经过Spring上下文得到Chinese实例
p1 = (Person)ctx.getBean("Chinese");
//定义p2接口的实例p2
Person p2 = null;
p2 = (Person)ctx.getBean("Chinese");
System.out.println(p1 == p2);
}
}

程序的执行结果是：true

代表Spring对接受容器管理的所有的bean，默认采用单态模式管理，建议不要随意更改bean的行为方式。由于从性能上讲，单态的bean比非单态的bean性能更为优秀。

仔细检查上面的代码就会发现以下的特色;

（1）除测试部分的主程序外，代码并未出现Spring的特定类和接口。

（2）调用者的代码，也就是测试用的主程序部分，仅仅面向Person的接口编程，而无需知道实现类的具体名称。同时，经过修改配置文件来完全切换底层的具体实现类。

（3）因为厂无需多个实例，所以工厂应该采用单态模式设计，其中Spring上下文也就是Spring工厂，已被设计成单态。

Spring工厂模式，不只提供了建立bean的功能，还提供了对bean的生命周期的管理。最重要的是还以管理bean和bean之间的依赖关系。