Java框架设计之设计模式

心若＆浮沉

已于 2024-05-09 20:24:52 修改

阅读量32

点赞数 1

文章标签： java 设计模式

于 2024-05-09 20:24:22 首次发布

原文链接：https://mp.weixin.qq.com/s/UGkjPhDj-tD7z_8rPR3VIw

版权

Java框架设计之设计模式

我们都知道设计模式和基础设计原则是架构师掌握的基础知识，就是学java的人掌握java语法一个道理，那我们在日常开发工作中又怎么对待设计模式呢？我们会刻意的为了一段代码去选择用设计模式吗？今天我们来说一下设计模式。

什么是设计模式?

想知道什么是设计模式之前我们需要了解什么是开发原则，可以通过文章《基础框架之设计原则》和文章《设计模式之SOLID原则》了解一些基础概念。

设计模式定义：设计模式是描述一种问题的通用解决方案。这种问题在我们的环境中，不停的出现，为了解决这种问题，抽象出来的一种可以重复使用的解决方案。
设计模式组成部分：一个设计模式总共有四个组成部分；模式名称：由少量字组成的名称，有助于表达我们的设计；待解决问题，什么时候需要用这种设计模式，和运用模式的上下文；解决方案，描述组成的设计元素、关系、职责。一般的解决方案都是抽象的，并不代表具体实现；结论，运用这种方案带来的利和弊，主要是指系统弹性、扩展性、和可移植性等影响。

设计模式划分

设计模式一共23种，我们可以通过类型做作用大致分为三类。

创建型设计模式：主要是对实例化过程的抽象，包括：单例模式、工厂模式、建造者模式、原型模式；
结构型设计模式：将类或者对象结合在一起形成更大的结构，包括：代理模式、桥接模式、装饰器模式、适配器模式、门面模式、组合模式、享元模式；
行为型设计模式：对在不同的对象之间划分责任和算法的抽象画，包括“观察者模式、模板模式、策略模式、职责链模式、迭代器模式、状态模式、访问者模式、备忘录模式、命令模式、解释器模式、中介模式；

我们在不了解设计模式的情况下有用到设计模式吗？但肯定是用的，而且用到的设计模式还不少，只是没有对应到具体的设计模式。

设计模式部分讲解

1.工厂模式
工厂模式包括简单工厂、工厂方法、抽象工厂这 3 种细分模式。工厂模式用来创建不同但是相关类型的对象（继承同一父类或者接口的一组子类），由给定的参数来决定创建哪种类型的对象。实际上，如果创建对象的逻辑并不复杂，那我们直接通过 new 来创建对象就可以了，不需要使用工厂模式。当创建逻辑比较复杂，是一个“大工程”的时候，我们就考虑使用工厂模式，封装对象的创建过程，将对象的创建和使用相分离。

示例:

public class NodeComponentFactory {

  private final static Map<String,NodeParser> cacheParser = new HashMap<>();

  static {
      cacheParser.put(NodeParserEnum.method.name(),new MethodNodeComponent());
      cacheParser.put(NodeParserEnum.bean.name(),new BeanNodeComponent());
      cacheParser.put(NodeParserEnum.condition.name(),new ConditionNodeComponent());
  }

  public static NodeParser getNodeInstance(String nodeName){
      return cacheParser.get(nodeName);
  }
}

2.单例模式
单例模式用来创建全局唯一的对象。一个类只允许创建一个对象（或者叫实例），那这个类就是一个单例类，这种设计模式就叫作单例模式。单例有几种经典的实现方式，它们分别是：饿汉式、懒汉式、双重检测、静态内部类、枚举。

public class FlowContext {
  	private static FlowContext instance;
		  private FlowContext(){}
		  public static FlowContext getInstance(){
		      if(instance == null){
		          synchronized (FlowContext.class){
		              if(instance == null){
		                  instance = new FlowContext();
		              }
		          }
		      }
	      return instance;
	  }
}

3.适配器模式
适配器提供跟原始类不同的接口。适配器模式是用来做适配的，它将不兼容的接口转换为可兼容的接口，让原本由于接口不兼容而不能一起工作的类可以一起工作。适配器模式有两种实现方式：类适配器和对象适配器。其中，类适配器使用继承关系来实现，对象适配器使用组合关系来实现。

public interface Node {
	void setName();
	void setId();
	void setNext();	
}
public class MethodNode {
	public void setMethodName(){}
  	public void setMethodId(){}
  	public void setMethodNext(){}
}
public class BeanNode extends MethodNode implements Node {
  	@Override
  	public void setName() {
      	super.setMethodName();
  	}
  	@Override
  	public void setId() {
    	super.setMethodId();
  	}
  	@Override
  	public void setNext() {
	    super.setMethodNext();
  	}
}

4.模板模式
模板方法模式在一个方法中定义一个算法骨架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。这里的“算法”，我们可以理解为广义上的“业务逻辑”，并不特指数据结构和算法中的“算法”。这里的算法骨架就是“模板”，包含算法骨架的方法就是“模板方法”，这也是模板方法模式名字的由来。

public abstract class AbstractNode {
  public void init(String inputUrl, BaseInput baseInput){
      parser();
      setNodeMap();
  }
  public abstract void parser();
  public abstract void setNodeMap();
}
public class TestNode extends AbstractNode{
  @Override
  public void parser() {
      System.out.println("parser");
  }

  @Override
  public void setNodeMap() {
      System.out.println("setNodeMap");
  }
}

5.策略模式
策略模式定义一组算法类，将每个算法分别封装起来，让它们可以互相替换。策略模式可以使算法的变化独立于使用它们的客户端（这里的客户端代指使用算法的代码）。策略模式用来解耦策略的定义、创建、使用。实际上，一个完整的策略模式就是由这三个部分组成的。

public interface Strategy {
  void test();
}
public class TestAStrategy implements Strategy {
  @Override
  public void test() {
      System.out.println("test");
  }
}
public class TestBStrategy implements Strategy {
  @Override
  public void test() {
      System.out.println("test");
  }
}

6.组合模式
组合模式主要是用来处理树形结构数据。正因为其应用场景的特殊性，数据必须能表示成树形结构，这也导致了这种模式在实际的项目开发中并不那么常用。但是，一旦数据满足树形结构，应用这种模式就能发挥很大的作用，能让代码变得非常简洁。

7.装饰器模式
装饰器模式主要解决继承关系过于复杂的问题，通过组合来替代继承，给原始类添加增强功能。这也是判断是否该用装饰器模式的一个重要的依据。除此之外，装饰器模式还有一个特点，那就是可以对原始类嵌套使用多个装饰器。为了满足这样的需求，在设计的时候，装饰器类需要跟原始类继承相同的抽象类或者接口。

public interface IA {
	void f();
}
public class A impelements IA {
 	public void f(){ //... }
}
public class AProxy impements IA {
	private IA a; 
	public AProxy(IA a) { 
		this.a = a; 
	}
	public void f() {
		// 新添加的代理逻辑
		a.f();
	}
}