设计模式 总目录
https://preparedata.blog.csdn.net/article/details/134512591
文章目录
-
- [设计模式 总目录](#设计模式 总目录)
- 一、案例
- [二、抽象类 AbstractOrder （顶层的订单抽象类）](#二、抽象类 AbstractOrder （顶层的订单抽象类）)
- 三、生产厂家的实现类
-
- [3.1 北方厂家 NorthOrder](#3.1 北方厂家 NorthOrder)
- [3.2 南方厂家 SouthOrder](#3.2 南方厂家 SouthOrder)
- 四、单一生产厂家的生产业务线
-
- [4.1 北方厂家的帽子 NorthHatOrder](#4.1 北方厂家的帽子 NorthHatOrder)
- [4.2 北方厂家的鞋子 NorthShoeOrder](#4.2 北方厂家的鞋子 NorthShoeOrder)
- [4.3 南方厂家的帽子 SouthHatOrder](#4.3 南方厂家的帽子 SouthHatOrder)
- [4.4 南方厂家的鞋子 SouthShoeOrder](#4.4 南方厂家的鞋子 SouthShoeOrder)
- 五、调用
一、案例
在的下单业务中，对于不同的类型的商品（鞋子、帽子），包含南方、北方生产厂商， 两个厂商都可以生产鞋子、帽子。
这时候可以利用抽象工厂模式，依据不同的厂商和商品类型，调用不同的处理器，进行下单
1.定义 抽象类 AbstractOrder 定义声明下单方法， 实现公共下单逻辑； 可以获取厂商&商品类型的实例， 也可以获取商品类型的实例；
2.定义 实现类 NorthOrder（北方厂商）、 SouthOrder（南方厂商）继承AbstractOrder， 实现厂商下单逻辑， 同时也可以调用父级AbstractOrder的公共方法
3.定义 子类 NorthHatOrder（北方厂商-帽子产线）、NorthShoeOrder（北方厂商-鞋子产线）、 SouthHatOrder（南方厂商-帽子产线）、SouthShoeOrder（南方厂商-帽子产线） 继承NorthOrder（北方厂商）、SouthOrder（南方厂商）
实现厂商&商品类型下单逻辑， 同时也可以调用父级的公共方法
当生产厂商、商品类型更多的时候，添加实现类，能够利用拆分不同的下单业务，约束接口， 抽取公共方法，统一参数等
个人理解，抽象工厂和简单工厂目的大体相同，都是在于业务执行器的选择，也就是if else 的处理
抽象工厂是更多是一个在if else 中嵌套if else处理的过程。
二、抽象类 AbstractOrder （顶层的订单抽象类）
java
package com.pd.shopping.order.designptern.abstractfactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* @author hll
*/
@Slf4j
@Component
public abstract class AbstractOrder {
/**
* 获取南方、北方工厂
* @param orderRegion
* @return
*/
public static AbstractOrder getInstance(String orderRegion) {
switch (orderRegion){
case "north":
//可以利用一些获取Bean的工具获取， 避免new
//SpringApplicationUtil.getBean(ShoeOrder.class);
return new NorthOrder();
case "south":
return new SouthOrder();
default:
return null;
}
}
/**
* 获取南方、北方工厂 下的帽子、或鞋子业务线
* @param orderRegion
* @param orderType
* @return
*/
public static AbstractOrder getInstance(String orderRegion, String orderType){
//可以利用一些枚举值， 避免拼接
switch (orderRegion + "-" + orderType){
case "north-hat":
//可以利用一些获取Bean的工具获取， 避免new
//SpringApplicationUtil.getBean(ShoeOrder.class);
return new NorthHatOrder();
case "north-shoe":
return new NorthShoeOrder();
case "south-hat":
return new SouthHatOrder();
case "south-shoe":
return new SouthShoeOrder();
default:
return null;
}
}
/**
* 创建订单
* @param map
*/
public abstract void create(Map<String,Object> map);
/**
* 查询
* @param map
*/
public abstract void query(Map<String,Object> map);
/**
* 公共方法
*/
public void common(){
log.debug("调用公共方法");
}
}三、生产厂家的实现类
3.1 北方厂家 NorthOrder
java
package com.pd.shopping.order.designptern.abstractfactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* @author hll
*/
@Slf4j
@Component
public class NorthOrder extends AbstractOrder {
/**
* 帽子公共方法
*/
public void northCommon(){
}
@Override
public void create(Map<String, Object> map) {
}
@Override
public void query(Map<String, Object> map) {
}
}3.2 南方厂家 SouthOrder
java
package com.pd.shopping.order.designptern.abstractfactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* @author hll
*/
@Slf4j
@Component
public class SouthOrder extends AbstractOrder {
/**
* 帽子公共方法
*/
public void southCommon(){
}
@Override
public void create(Map<String, Object> map) {
}
@Override
public void query(Map<String, Object> map) {
}
}四、单一生产厂家的生产业务线
4.1 北方厂家的帽子 NorthHatOrder
java
package com.pd.shopping.order.designptern.abstractfactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.Map;
@Slf4j
@Component
public class NorthHatOrder extends NorthOrder {
/**
* 创建订单
* @param map
*/
@Override
public void create(Map<String,Object> map){
super.northCommon();
super.common();
log.debug("创建鞋子订单");
}
/**
* 查询
* @param map
*/
@Override
public void query(Map<String,Object> map){
super.northCommon();
super.common();
log.debug("查询鞋子订单");
}
}4.2 北方厂家的鞋子 NorthShoeOrder
java
package com.pd.shopping.order.designptern.abstractfactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.Map;
@Slf4j
@Component
public class NorthShoeOrder extends NorthOrder {
/**
* 创建订单
* @param map
*/
@Override
public void create(Map<String,Object> map){
super.northCommon();
super.common();
log.debug("创建鞋子订单");
}
/**
* 查询
* @param map
*/
@Override
public void query(Map<String,Object> map){
super.northCommon();
super.common();
log.debug("查询鞋子订单");
}
}4.3 南方厂家的帽子 SouthHatOrder
java
package com.pd.shopping.order.designptern.abstractfactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.Map;
@Slf4j
@Component
public class SouthHatOrder extends SouthOrder {
/**
* 创建订单
* @param map
*/
@Override
public void create(Map<String,Object> map){
super.southCommon();
super.common();
log.debug("创建鞋子订单");
}
/**
* 查询
* @param map
*/
@Override
public void query(Map<String,Object> map){
super.southCommon();
super.common();
log.debug("查询鞋子订单");
}
}4.4 南方厂家的鞋子 SouthShoeOrder
java
package com.pd.shopping.order.designptern.abstractfactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.Map;
@Slf4j
@Component
public class SouthShoeOrder extends SouthOrder {
/**
* 创建订单
* @param map
*/
@Override
public void create(Map<String,Object> map){
super.southCommon();
super.common();
log.debug("创建鞋子订单");
}
/**
* 查询
* @param map
*/
@Override
public void query(Map<String,Object> map){
super.southCommon();
super.common();
log.debug("查询鞋子订单");
}
}五、调用
java
@GetMapping("/abstractFactoryOrder")
public void abstractFactoryOrder() {
//获取南方、北方工厂 下的帽子、或鞋子业务线
AbstractOrder.getInstance("north","hat").create(new HashMap<>());
AbstractOrder.getInstance("south","hat").create(new HashMap<>());
//获取南方、北方工厂 下的业务线
AbstractOrder.getInstance("north").create(new HashMap<>());
AbstractOrder.getInstance("south").create(new HashMap<>());
}