应用集成的6大模型总结

最新推荐文章于 2023-04-14 10:51:50 发布

Rilkean heart

最新推荐文章于 2023-04-14 10:51:50 发布

阅读量580

点赞数

分类专栏：期末复习 #应用集成文章标签： java 软件工程师

本文链接：https://blog.csdn.net/qq_42147816/article/details/103791015

版权

期末复习同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

#应用集成

1 篇文章 0 订阅

订阅专栏

文章目录

创建型模式

1.简单工厂模式（静态工厂方法）

理解：不需要知道这些具体按钮类的名字，只需要知道表示该按钮类的一个参数，并提供一个调用方便的方法，把该参数传入方法即可返回一个相应的按钮对象，此时，就可以使用简单工厂模式。
概念：在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
三个角色：工厂角色负责实现创建所有实例的内部逻辑；抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口；具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。
优点：
- 工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。
- 客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。
- 通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。
缺点：
- 由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。
- 使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。
- 系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。
- 简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。
使用情况：
- 工厂类负责创建的对象比较少：由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。
- 客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型所对应的参数。
应用
- 在JDK类库中广泛使用了简单工厂模式，如工具类java.text.DateFormat，它用于格式化一个本地日期或者时间。
  
  public final static DateFormat getDateInstance();
  public final static DateFormat getDateInstance(int style);
  
  public final static DateFormat getDateInstance(int style,Locale locale);
- java加密

// 简单电视机工厂
// TVFactory.java
public class TVFactory{		// 静态方法
	public static TV produceTV(String brand) throws Exception{  // 注意返回一个由TV接口实现的对象
		if(brand.equalsIgnoreCase("Haier")){
			System.out.println("电视机工厂生产海尔电视机！");
			return new HaierTV();							// 注意返回一个由TV接口实现的对象
		}
		else if(brand.equalsIgnoreCase("Hisense")){
			System.out.println("电视机工厂生产海信电视机！");
			return new HisenseTV();
		}
		else{
			throw new Exception("对不起，暂不能生产该品牌电视机！");
		}
	}
}

// 简单电视机工厂
// Client.java
public class Client{
	public static void main(String args[]){
         try{
         	TV tv;										// TV 是个接口
         	String brandName=XMLUtilTV.getBrandName();
         	tv=TVFactory.produceTV(brandName);			  // 通过类名直接调用静态方法
         	tv.play();									// 调用接口方法
         }catch(Exception e){
         	System.out.println(e.getMessage());
         }
	}
}

UML补充：

空心箭头—> 泛化：is a kind of，指向父类

虚线普通箭头：依赖关系

空心菱形箭头：聚合关系，强调的是整体和部分的关系，其中部分可以脱离整体而存在。比如雁群和一只大雁的关系，就是聚合关系，大雁离开雁群还是可以独立存在的，指向整体。

3行分别是：类名，属性，对象。第一行中可以加<>或者<>

+方法：public方法；#：保护； -：私有

2.工厂方法模式/虚拟构造器/多态工厂

相对于简单工厂模式的改变：

简单工厂模式最大的缺点是当有新产品要加入到系统中时，必须修改工厂类，加入必要的处理逻辑，这违背了“开闭原则”。工厂类职责较重，业务逻辑较为复杂。

现在对该系统进行修改，将具体按钮的创建过程交给专门的工厂子类去完成，我们先定义一个抽象的按钮工厂类，再定义具体的工厂类来生成圆形按钮、矩形按钮、菱形按钮等，它们实现在抽象按钮工厂类中定义的方法。这种抽象化的结果使这种结构可以在不修改具体工厂类的情况下引进新的产品，如果出现新的按钮类型，只需要为这种新类型的按钮创建一个具体的工厂类就可以获得该新按钮的实例，更加符合“开闭原则”。
特点：工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象。
包含4个角色：Product：抽象产品 ConcreteProduct：具体产品 Factory：抽象工厂 ConcreteFactory：具体工厂
优点：
- 工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无须关心创建细节，甚至无须知道具体产品类的类名。
- 基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，是因为所有的具体工厂类都具有同一抽象父类。
- 在系统中加入新产品无须修改抽象工厂和抽象产品提供的接口，无须修改客户端，也无须修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了。系统的可扩展性也就变得非常好，符合“开闭原则”。
缺点：
- 在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。
- 由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。

// 抽象工厂类
public abstract class PayMethodFactory{
    public abstract AbstractPay getPayMethod();
}
// 具体工厂类
public class CashPayFactory extends PayMethodFactory{
    public AbstractPay getPayMethod(){
        return new CashPay();
    }
} 
// 客户类
public class Client{
    public static void main(String args[]){
        PayMethodFactory factory;
        AbstractPay payMethod;
        //factory=new CashPayFactory();
        factory=(PayMethodFactory)XMLUtil.getBean(); //getBean()的返回类型为Object，此处需要进行强制类型转换
        payMethod =factory.getPayMethod();
        payMethod.pay(); 
	}
}
//配置文件
<?xml version="1.0"?>
<config>
	<className>CashPayFactory</className>
</config>

Java反射(Java Reflection)：
是指在程序运行时获取已知名称的类或已有对象的相关信息的一种机制，包括类的方法、属性、超类等信息，还包括实例的创建和实例类型的判断等。可通过Class类的forName()方法返回与带有给定字符串名的类或接口相关联的Class对象，再通过newInstance()方法创建此对象所表示的类的一个新实例，即通过一个类名字符串得到类的实例。

//创建一个字符串类型的对象

Class c = Class.forName(“String”);

Object obj = c.newInstance();

return obj;

//工厂接口和2个具体实现
public interface TVFactory{
    public TV produceTV();
}
public class HisenseTVFactory implements TVFactory{
    public TV produceTV(){
    	System.out.println("海信电视机工厂生产海信电视机。");
    	return new HisenseTV();
    }
}
public class HaierTVFactory implements TVFactory{
    public TV produceTV() {
    	System.out.println("海尔电视机工厂生产海尔电视机。");
    	return new HaierTV();
    }
}
//TV接口和2个具体实现
public interface TV{
	public void play();
}
public class HaierTV implements TV{
	public void play(){
		System.out.println("海尔电视机播放中......");
	}
}
public class HisenseTV implements TV{
	public void play(){
		System.out.println("海信电视机播放中......");
	}	
}
//Clinet类
public class Client{
	public static void main(String args[]){
         try{
         	TV tv;
         	TVFactory factory;
         	factory=(TVFactory)XMLUtil.getBean();
         	tv=factory.produceTV();
         	tv.play();
         }catch(Exception e) {
         	System.out.println(e.getMessage());
         }
	}
}

3.抽象工厂模式/Kit模式

产品等级结构（纵向）：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，构成父子关系。
产品族（横向）：产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。
概念：当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式。抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。它与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构。
优点：
- 抽象工厂模式隔离了具体类的生成，由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。
- 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。
- 增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。
缺点：
- 在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。
- 开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）

public interface EFactory{
	public Television produceTelevision();
	public AirConditioner produceAirConditioner();
}
// 两个工厂生产的商品
public interface AirConditioner{
	public void changeTemperature();
}
public interface Television{
	public void play();
}
// 两个工厂
public class HaierFactory implements EFactory{
	public Television produceTelevision(){
		return new HaierTelevision();
	}
	public AirConditioner produceAirConditioner(){
		return new HairAirConditioner();
	}
}
public class TCLFactory implements EFactory{
	public Television produceTelevision(){
		return new TCLTelevision();
	}
	public AirConditioner produceAirConditioner(){
		return new TCLAirConditioner();
	}
}
// 海尔的两个产品
public class HaierTelevision implements Television{
	public void play(){
		System.out.println("海尔电视机播放中......");
	}
}
public class HaierAirConditioner implements AirConditioner{
	public void changeTemperature(){
		System.out.println("海尔空调温度改变中......");
	}
}
// TCL的两个产品
public class TCLAirConditioner implements AirConditioner{
	public void changeTemperature(){
		System.out.println("TCL�յ��¶ȸı���......");
	}
}
public class TCLTelevision implements Television{
	public void play(){
		System.out.println("TCL电视机播放中......");
	}
}
// Client
public class Client{
	public static void main(String args[]){
         try{
         	EFactory factory;
         	Television tv;
         	AirConditioner ac;
         	factory=(EFactory)XMLUtil.getBean();
         	tv=factory.produceTelevision();
         	tv.play();
         	ac=factory.produceAirConditioner();
         	ac.changeTemperature();
         }catch(Exception e){
         	System.out.println(e.getMessage());
         }
	}
}

应用
- Java SE AWT

对象行为型模式

### 策略模式 /政策模式

背景：为了解决这些问题，可以定义一些独立的类来封装不同的算法，每一个类封装一个具体的算法，在这里，每一个封装算法的类我们都可以称之为策略(Strategy)，为了保证这些策略的一致性，一般会用一个抽象的策略类来做算法的定义，而具体每种算法则对应于一个具体策略类。用一句话来说，就是“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。
概念：定义一系列算法，将每一个算法封装起来并让它们可以相互替换，让算法独立于使用它的客户而变化。
包含角色：Context: 环境类 Strategy: 抽象策略类 ConcreteStrategy: 具体策略类
优点：
- 策略模式提供了对“开闭原则”的完美支持，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或行为。
- 策略模式提供了管理相关的算法族的办法。
- 策略模式提供了可以替换继承关系的办法。
- 使用策略模式可以避免使用多重条件转移语句。
缺点：
- 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
- 策略模式将造成产生很多策略类，可以通过使用享元模式在一定程度上减少对象的数量。

public interface Sort{
	public abstract int[] sort(int arr[]);
}
// 具体sort实现
public class BubbleSort implements Sort{
	public int[] sort(int arr[]){
	   int len=arr.length;
       for(int i=0;i<len;i++) {
           for(int j=i+1;j<len;j++) {
              int temp;
              if(arr[i]>arr[j]){
                  temp=arr[j];
                  arr[j]=arr[i];
                  arr[i]=temp;
              }             
           }
		}
		System.out.println("ggg");
		return arr;
	}
}
// sort算法作为数组处理类的一部分（整体与部分）
public class ArrayHandler{
	private Sort sortObj;              // 私有成员
	public int[] sort(int arr[]){
		sortObj.sort(arr);			// 执行arr排序算法
		return arr;					// 返回排好序的数组
	}
	public void setSortObj(Sort sortObj) {
		this.sortObj = sortObj; 
	}
}
// Client
public class Client{
	public static void main(String args[]){
	   int arr[]={1,4,6,2,5,3,7,10,9};
	   int result[];
	   ArrayHandler ah=new ArrayHandler();   
	   Sort sort;
       sort=(Sort)XMLUtil.getBean()；     
       ah.setSortObj(sort);  //设置具体策略
       result=ah.sort(arr);       
       //for(int i=0;i<result.length;i++){
       //	    System.out.print(result[i] + ",");
       }
	}
}

结构型模式

概念：结构型模式(Structural Pattern)描述如何将类或者对象结合在一起形成更大的结构，就像搭积木，可以通过简单积木的组合形成复杂的、功能更为强大的结构。

适配器模式 / 对象结构型模式 /包装器

背景：类似于电源适配器的设计和编码技巧被称为适配器模式。通常情况下，客户端可以通过目标类的接口访问它所提供的服务。有时，现有的类可以满足客户类的功能需要，但是它所提供的接口不一定是客户类所期望的，这可能是因为现有类中方法名与目标类中定义的方法名不一致等原因所导致的。因此，现有的接口需要转化为客户类期望的接口，以保证对现有类的重用。否则客户类就不能利用现有类所提供的功能，适配器模式可以完成这样的转化。
概念：将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作。
包含4个角色：Target：目标抽象类 Adapter：适配器类 Adaptee：适配者类 Client：客户类
优点：
- 将目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，而无须修改原有代码。
- 增加类的透明性和复用性，将具体的实现封装在适配者类，对客户端类来说是透明的，提高了适配者的复用性。
- 灵活性和扩展性都非常好，通过使用配置文件，可以很方便地更换适配器，也可以在不修改原有代码的基础上增加新的适配器类，完全符合“开闭原则”。
- 由于适配器类是适配者类的子类，因此可以在适配器类中置换一些适配者的方法，使得适配器的灵活性更强。
缺点：
- 对于Java、C#等不支持多重继承的语言，一次最多只能适配一个适配者类，而且目标抽象类只能为抽象类，不能为具体类，其使用有一定的局限性，不能将一个适配者类和它的子类都适配到目标接口。
- 与类适配器模式相比，要想置换适配者类的方法就不容易。
使用环境：
- 系统需要使用现有的类，而这些类的接口不符合系统的需要。
- 想要建立可重复使用的类，用于与一些彼此之间没有太大关联的一些类

public interface Robot{
	public void cry();
	public void move();
}
// 适配器，统一成标准的cry和move
public class DogAdapter extends Dog implements Robot{
	public void cry(){
		System.out.print("机器人模仿：");
		super.wang();
	}
	public void move(){
		System.out.print("机器人模仿：");
		super.run();
	}
}
// 把不标准的wang和run
public class Dog{
	public void wang(){
		System.out.println("狗汪汪叫！");
	}
	public void run(){
		System.out.println("狗快快跑！");
	}
}
// client
public class Client{
	public static void main(String args[]){
		Robot robot=(Robot)XMLUtil.getBean();
		robot.cry();
		robot.move();
	}
}

应用：
- 每一个具体数据库引擎（如SQL Server、Oracle、MySQL等）的JDBC驱动软件都是一个介于JDBC接口和数据库引擎接口之间的适配器软件。

对象行为型模式

观察者模式 /发布-订阅 / 模型-视图 / 源-监听器（Source/Listener） / 从属者模式

背景：建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应做出反应。在此，发生改变的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系。
概念：对象间的一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。
包含4个角色：Subject: 目标 ConcreteSubject: 具体目标 Observer: 观察者 ConcreteObserver: 具体观察者
优点：
- 可以实现表示层和数据逻辑层的分离，并定义了稳定的消息更新传递机制，抽象了更新接口，使得可以有各种各样不同的表示层作为具体观察者角色。
- 观察者模式在观察目标和观察者之间建立一个抽象的耦合。
- 观察者模式支持广播通信，符合“开闭原则”的要求。
缺点：
- 如果一个观察目标对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
- 如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
- 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，仅知道观察目标发生了变化。
使用环境：
- 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
- 一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。一个对象必须通知其他对象，而并不知道这些对象是谁。
- 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。
应用：
- jdk的事件处理模型委派事件模型(Delegation Event Model, DEM)。
- Java语言解析XML的技术SAX2以及Servlet技术的事件处理机制都基于DEM

// 观察者
public interface MyObserver{
	void response();  //抽象响应方法
}
// 观察目标
public abstract class MySubject{
	protected ArrayList observers = new ArrayList();
	//注册方法
	public void attach(MyObserver observer){
		observers.add(observer);
	} 	
	//注销方法
	public void detach(MyObserver observer){
		observers.remove(observer);
	}	
	public abstract void cry(); //抽象通知方法
}
// 观察目标的实现
public class Cat extends MySubject{
	public void cry(){
		System.out.println("喵");
		System.out.println("----------------------------");		
		for(Object obs:observers){
			((MyObserver)obs).response();
		}	
	}	   	
}
// 观察者的实现
public class Dog implements MyObserver{
	public void response(){
		System.out.println("汪汪");
	}	
}
// client
public class Client{
	public static void main(String a[]){
		MySubject subject=new Cat();	
		MyObserver obs1,obs2,obs3;
		obs1=new Mouse();
		obs2=new Mouse();
		obs3=new Dog();	
		subject.attach(obs1);
		subject.attach(obs2);
		subject.attach(obs3);	
		MyObserver obs4;
		obs4=new Pig();
		subject.attach(obs4);	
		subject.cry();		
	}
}

Rilkean heart

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
应用集成的6大模型总结

文章目录创建型模式1.简单工厂模式（静态工厂方法）2.工厂方法模式/虚拟构造器/多态工厂3.抽象工厂模式/Kit模式对象行为型模式结构型模式适配器模式 / 对象结构型模式 /包装器对象行为型模式观察者模式 /发布-订阅 / 模型-视图 / 源-监听器（Source/Listener） / 从属者模式创建型模式1.简单工厂模式（静态工厂方法）理解：不需要知道这些具体按钮类的名字，只需要知...
复制链接

扫一扫