简单工厂模式

设计模式 总目录

https://preparedata.blog.csdn.net/article/details/134512591

一、案例

在的下单业务中，对于不同的类型的商品（鞋子、帽子），需要处理的下单业务，可能存在部分相同，部分不同
这时候可以利用简单工厂模式，依据不同的商品类型，调用不同的处理器，进行下单

1.定义 抽象类 AbstractOrder 定义声明下单方法， 实现公共下单逻辑； 提供获取对应商品类型的实例 HatOrder（帽子业务）、 ShoeOrder（鞋子业务）

2.定义 实现类 HatOrder（帽子）、 ShoeOrder（鞋子）继承AbstractOrder， 实现下单逻辑， 同时也可以调用父级AbstractOrder的公共方法

抽象类是一种特殊的接口

当商品类型更多的时候，添加实现类， 继承AbstractOrder，能够利用拆分不同的下单业务，约束接口， 抽取公共方法，统一参数等

二、抽象类 （订单抽象类）

package com.pd.shopping.order.designPattern.factory;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @author hll
 */
@Slf4j
@Component
public abstract class AbstractOrder {

    public static AbstractOrder getInstance(String orderType) {
        switch (orderType){
            case "shoe":
                //可以利用一些获取Bean的工具获取， 避免new
                //SpringApplicationUtil.getBean(ShoeOrder.class);
                return new ShoeOrder();
            case "hat":
                return new HatOrder();
            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("调用公共方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

三、实现类

3.1 帽子订单

package com.pd.shopping.order.designPattern.factory;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @author hll
 */
@Slf4j
@Component
public class HatOrder extends AbstractOrder{

    /**
     * 创建订单
     * @param map
     */
    @Override
    public void create(Map<String,Object> map){
        super.common();
        log.debug("创建帽子订单");
    }


    /**
     * 查询
     * @param map
     */
    @Override
    public void query(Map<String,Object> map){
        super.common();
        log.debug("创建帽子订单");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

3.2 鞋子订单

package com.pd.shopping.order.designPattern.factory;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @author hll
 */
@Slf4j
@Component
public class ShoeOrder extends AbstractOrder{

    /**
     * 创建订单
     * @param map
     */
    @Override
    public void create(Map<String,Object> map){
        super.common();
        log.debug("创建鞋子订单");
    }


    /**
     * 查询
     * @param map
     */
    @Override
    public void query(Map<String,Object> map){
        super.common();
        log.debug("查询鞋子订单");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

四、调用

@GetMapping("/factoryOrder")
public void factoryOrder() {
    AbstractOrder.getInstance("shoe").create(new HashMap<>());
    AbstractOrder.getInstance("hat").query(new HashMap<>());
}
1
2
3
4
5