几种常用的设计模式介绍
1.
设计模式的起源
最早提出“设计模式”概念的是建筑设计大师亚力山大Alexander。在1970年他的《建筑的永恒之道》里描述了投计模式的发现,因为它已经存在了千百年之久,而现代才被通过大量的研究而被发现。
在《建筑的永恒之道》里这样描述:模式是一条由三个部分组成的通用规则:它表示了一个特定环境、一类问题和一个解决方案之间的关系。每一个模式描述了一个不断重复发生的问题,以及该问题解决方案的核心设计。
在他的另一本书《建筑模式语言》中提到了现在已经定义了253种模式。比如:
说明城市主要的结构:亚文化区的镶嵌、分散的工作点、城市的魅力、地方交通区
住宅团组:户型混合、公共性的程度、住宅团组、联排式住宅、丘状住宅、老人天地室内环境和室外环境、阴和阳总是一气呵成
针对住宅:夫妻的领域、儿童的领域、朝东的卧室、农家的厨房、私家的沿街露台、个人居室、起居空间的序列、多床卧室、浴室、大储藏室
针对办公室、车间和公共建筑物:灵活办公空间、共同进餐、共同小组、宾至如归、等候场所、小会议室、半私密办公室
尽管亚力山大的著作是针对建筑领域的,但他的观点实际上适用于所有的工程设计领域,其中也包括软件设计领域。“软件设计模式”,这个术语是在1990年代由Erich Gamma等人从建筑设计领域引入到计算机科学中来的。目前主要有23种。
2.
软件设计模式的分类
2.1.
创建型
创建对象时,不再由我们直接实例化对象;而是根据特定场景,由程序来确定创建对象的方式,从而保证更大的性能、更好的架构优势。创建型模式主要有简单工厂模式(并不是23种设计模式之一)、工厂方法、抽象工厂模式、单例模式、生成器模式和原型模式。
2.2.
结构型
用于帮助将多个对象组织成更大的结构。结构型模式主要有适配器模式adapter、桥接模式bridge、组合器模式component、装饰器模式decorator、门面模式、亨元模式flyweight和代理模式proxy。
2.3.
行为型
用于帮助系统间各对象的通信,以及如何控制复杂系统中流程。行为型模式主要有命令模式command、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式state、策略模式、模板模式和访问者模式。
3.
常见设计模式介绍
3.1. 单例模式(singleton)
有些时候,允许自由创建某个类的实例没有意义,还可能造成系统性能下降。如果一个类始终只能创建一个实例,则这个类被称为单例类,这种模式就被称为单例模式。
一般建议单例模式的方法命名为:getInstance(),这个方法的返回类型肯定是单例类的类型了。getInstance方法可以有参数,这些参数可能是创建类实例所需要的参数,当然,大多数情况下是不需要的
publicclass Singleton {
publicstaticvoid main(String[] args) { //创建Singleton对象不能通过构造器,只能通过getInstance方法 Singleton s1 = Singleton.getInstance(); Singleton s2 = Singleton.getInstance(); //将输出true System.out.println(s1 == s2); }
//使用一个变量来缓存曾经创建的实例 privatestatic Singleton //将构造器使用private修饰,隐藏该构造器 private Singleton(){ System.out.println("Singleton被构造!"); }
//提供一个静态方法,用于返回Singleton实例 //该方法可以加入自定义的控制,保证只产生一个Singleton对象 publicstatic Singleton getInstance() { //如果instance为null,表明还不曾创建Singleton对象 //如果instance不为null,则表明已经创建了Singleton对象,将不会执行该方法 if (instance == { //创建一个Singleton对象,并将其缓存起来 instance = } returninstance; } } |
单例模式主要有如下两个优势:
1)
减少创建Java实例所带来的系统开销
2)
便于系统跟踪单个Java实例的生命周期、实例状态等。
3.2. 简单工厂(StaticFactory Method)
简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。
A实例调用B实例的方法,称为A依赖于B。如果使用new关键字来创建一个B实例(硬编码耦合),然后调用B实例的方法。一旦系统需要重构:需要使用C类来代替B类时,程序不得不改写A类代码。而用工厂模式则不需要关心B对象的实现、创建过程。
Output,接口
publicinterface Output { //接口里定义的属性只能是常量 intMAX_CACHE_LINE = 50; //接口里定义的只能是public的抽象实例方法 void out(); void } |
Printer,Output的一个实现
//让Printer类实现Output publicclass { private String[] //用以记录当前需打印的作业数 privateintdataNum = 0; publicvoid out() { //只要还有作业,继续打印 while(dataNum > 0) { System.out.println("打印机打印:" //把作业队列整体前移一位,并将剩下的作业数减1 System.arraycopy(printData , 1, } } publicvoid getData(String msg) { if (dataNum >= { System.out.println("输出队列已满,添加失败"); } else { //把打印数据添加到队列里,已保存数据的数量加1。 printData[dataNum++] = msg; } } } |
BetterPrinter,Output的一个实现
publicclass BetterPrinter { private String[] //用以记录当前需打印的作业数 privateintdataNum = 0; publicvoid out() { //只要还有作业,继续打印 while(dataNum > 0) { System.out.println("高速打印机正在打印:" //把作业队列整体前移一位,并将剩下的作业数减1 System.arraycopy(printData , 1, } } publicvoid getData(String msg) { if (dataNum >= { System.out.println("输出队列已满,添加失败"); } else { //把打印数据添加到队列里,已保存数据的数量加1。 printData[dataNum++] = msg; } } } |
OutputFactory,简单工厂类
public Output getPrinterOutput(String type) { if (type.equalsIgnoreCase("better")) { returnnew BetterPrinter(); } else { returnnew Printer(); } } |
Computer
publicclass Computer { private Output
public Computer(Output out) { this.out = out; } //定义一个模拟获取字符串输入的方法 publicvoid keyIn(String msg) { out.getData(msg); } //定义一个模拟打印的方法 publicvoid print() { out.out(); } publicstaticvoid main(String[] args) { //创建OutputFactory OutputFactory of = //将Output对象传入,创建Computer对象 Computer c = new Computer(of.getPrinterOutput("normal")); c.keyIn("建筑永恒之道"); c.keyIn("建筑模式语言"); c.print();
c = new Computer(of.getPrinterOutput("better")); c.keyIn("建筑永恒之道"); c.keyIn("建筑模式语言"); c.print(); } |
使用简单工厂模式的优势:让对象的调用者和对象创建过程分离,当对象调用者需要对象时,直接向工厂请求即可。从而避免了对象的调用者与对象的实现类以硬编码方式耦合,以提高系统的可维护性、可扩展性。工厂模式也有一个小小的缺陷:当产品修改时,工厂类也要做相应的修改。
3.3. 工厂方法(Factory Method)和抽象工厂(Abstract Factory)
如果我们不想在工厂类中进行逻辑判断,程序可以为不同产品类提供不同的工厂,不同的工厂类和产不同的产品。
当使用工厂方法设计模式时,对象调用者需要与具体的工厂类耦合,如:
//工厂类的定义1 publicclass BetterPrinterFactory implements OutputFactory { public Output getOutput() { //该工厂只负责产生BetterPrinter对象 returnnew BetterPrinter(); } } //工厂类的定义2 publicclass PrinterFactory implements OutputFactory { public Output getOutput() { //该工厂只负责产生Printer对象 returnnew Printer(); } } //工厂类的调用 //OutputFactory of = new BetterPrinterFactory(); OutputFactory of = new PrinterFactory(); Computer c = |
使用简单工厂类,需要在工厂类里做逻辑判断。而工厂类虽然不用在工厂类做判断。但是带来了另一种耦合:客户端代码与不同的工厂类耦合。
为了解决客户端代码与不同工厂类耦合的问题。在工厂类的基础上再增加一个工厂类,该工厂类不制造具体的被调用对象,而是制造不同工厂对象。如:
//抽象工厂类的定义,在工厂类的基础上再建一个工厂类 publicclass OutputFactoryFactory { //仅定义一个方法用于返回输出设备。 publicstatic OutputFactory getOutputFactory( String type) { if (type.equalsIgnoreCase("better")) { returnnew BetterPrinterFactory(); } else { returnnew PrinterFactory(); } } }
//抽象工厂类的调用 OutputFactory of = OutputFactoryFactory.getOutputFactory("better"); Computer c = new Computer(of.getOutput()); |
3.4. 代理模式(Proxy)
代理模式是一种应用非常广泛的设计模式,当客户端代码需要调用某个对象时,客户端实际上不关心是否准确得到该对象,它只要一个能提供该功能的对象即可,此时我们就可返回该对象的代理(Proxy)。
代理就是一个Java对象代表另一个Java对象来采取行动。如:
publicclass { //组合一个image实例,作为被代理的对象 private Image //使用抽象实体来初始化代理对象 public ImageProxy(Image image) { this.image = image; } /** * * * */ publicvoid show() { //只有当真正需要调用image的show方法时才创建被代理对象 if (image { image = } image.show(); } } |
调用时,先不创建:
Image image = new ImageProxy(null); |
Hibernate默认启用延迟加载,当系统加载A实体时,A实体关联的B实体并未被加载出来,A实体所关联的B实体全部是代理对象——只有等到A实体真正需要访问B实体时,系统才会去数据库里抓取B实体所对应的记录。
借助于Java提供的Proxy和InvocationHandler,可以实现在运行时生成动态代理的功能,而动态代理对象就可以作为目标对象使用,而且增强了目标对象的功能。如:
Panther
publicinterface { //info方法声明 publicvoid info(); //run方法声明 publicvoid run(); } |
GunPanther
publicclass GunPanther { //info方法实现,仅仅打印一个字符串 publicvoid info() { System.out.println("我是一只猎豹!"); } //run方法实现,仅仅打印一个字符串 publicvoid run() { System.out.println("我奔跑迅速"); } } |
MyProxyFactory,创建代理对象
publicclass MyProxyFactory { //为指定target生成动态代理对象 publicstatic Object getProxy(Object target) throws Exception { //创建一个MyInvokationHandler对象 MyInvokationHandler handler = new MyInvokationHandler(); //为MyInvokationHandler设置target对象 handler.setTarget(target); //创建、并返回一个动态代理 return Proxy.newProxyInstance(target.getClass().getClassLoader() , target.getClass().getInterfaces(), handler); } } |
MyInvokationHandler,增强代理的功能
publicclass { //需要被代理的对象 private Object publicvoid setTarget(Object target) { this.target = target; } //执行动态代理对象的所有方法时,都会被替换成执行如下的invoke方法 public Object invoke(Object proxy, Method method, Object[] args) throws Exception { TxUtil tx = new TxUtil(); //执行TxUtil对象中的beginTx。 tx.beginTx(); //以target作为主调来执行method方法 Object result = method.invoke(target , args); //执行TxUtil对象中的endTx。 tx.endTx(); return result; } } |
TxUtil
publicclass TxUtil { //第一个拦截器方法:模拟事务开始 publicvoid beginTx() { System.out.println("=====模拟开始事务====="); } //第二个拦截器方法:模拟事务结束 publicvoid endTx() { System.out.println("=====模拟结束事务====="); } } |
测试
publicstaticvoid main(String[] args) throws Exception { //创建一个原始的GunDog对象,作为target Panther target = //以指定的target来创建动态代理 Panther panther = (Panther)MyProxyFactory.getProxy(target); //调用代理对象的info()和run()方法 panther.info(); panther.run(); } |
Spring所创建的AOP代理就是这种动态代理。但是Spring AOP更灵活。
3.5. 命令模式(Command)
某个方法需要完成某一个功能,完成这个功能的大部分步骤已经确定了,但可能有少量具体步骤无法确定,必须等到执行该方法时才可以确定。(在某些编程语言如Ruby、Perl里,允许传入一个代码块作为参数。但Jara暂时还不支持代码块作为参数)。在Java中,传入该方法的是一个对象,该对象通常是某个接口的匿名实现类的实例,该接口通常被称为命令接口,这种设计方式也被称为命令模式。
如:
Command
publicinterface Command { //接口里定义的process方法用于封装“处理行为” void process(int[] target); } |
ProcessArray