抽象工厂模式简化学习

提到设计i模式不得不提抽象工厂模式,普通的工厂模式已经不足以满足我们日常开发于是深化出了抽象工厂模式,下面我们一起来学习一下

场景

• 现在有不同品牌手机对象和不同品牌汽车对象我们希望通过抽象工厂模式进行创建

设计

1. 创建两个接口里面各自包含了汽车和手机的公共对象

2. 创建一个抽象工厂对象 里面有获取工厂的方法,各个对象分别创建对应的工厂对象
   

3. 最后创建一个最外层的对象工厂 基于上面的抽象工厂建立策略模式获取指定的对象工厂获取到希望获取到的对象工厂最终得到目标对象
   
   代码实现

4. 定义手机和车的接口

public interface CarBase {
    /**
     * 汽车可以开
     * 这里的接口自定义即可
     *
     * @return 具体实现
     */
    String carCanDrive();

    /**
     * 汽车可以很快
     * 自定义即可
     *
     * @return 具体事项
     */
    String carCanFast();
}

public interface PhoneBase {
    /**
     * 手机可以打电话
     * 这里的接口自定义即可
     *
     * @return 具体实现
     */
    String phoneCanCall();

    /**
     * 手机可以发消息
     * 自定义即可
     *
     * @return 具体事项
     */
    String phoneCanSend();
}

2. 创建车和手机的基类 用于横向扩展

/**
 * 手机基本类
 */
public class PhoneBasic implements PhoneBase, Serializable {
    @Override
    public String phoneCanCall() {
        return null;
    }

    @Override
    public String phoneCanSend() {
        return null;
    }
}

/**
 *	车基本类
 */
public class CarBasic implements CarBase, Serializable {
    @Override
    public String carCanDrive() {
        return null;
    }

    @Override
    public String carCanFast() {
        return null;
    }
}

3. 创建车和手机的具体类

/**
 *	某马具体类
 */
public class MaCar extends CarBasic {
    @Override
    public String carCanDrive() {
        System.out.println("某马汽车可以开");
        return "某马汽车可以开具体实现";
    }

    @Override
    public String carCanFast() {
        System.out.println("某马汽车可以很快");
        return "某马汽车可以很快具体实现";
    }
}

/**
 *	某驰具体类
 */
public class ChiCar extends CarBasic {
    @Override
    public String carCanDrive() {
        System.out.println("某驰汽车可以开");
        return "某驰汽车可以开具体实现";
    }

    @Override
    public String carCanFast() {
        System.out.println("某驰汽车可以很快");
        return "某驰汽车可以很快具体实现";
    }
}

/**
 *	华某具体类
 */
public class HuaPhone extends PhoneBasic {
    @Override
    public String phoneCanCall() {
        System.out.println("华某手机可以打电话");
        return "华某手机可以打电话具体实现";
    }

    @Override
    public String phoneCanSend() {
        System.out.println("华某手机可以发消息");
        return "华某手机可以发消息具体实现";
    }
}

/**
 *	华米具体类
 */
public class MiPhone extends PhoneBasic {
    @Override
    public String phoneCanCall() {
        System.out.println("某米手机可以打电话");
        return "某米手机可以打电话具体实现";
    }

    @Override
    public String phoneCanSend() {
        System.out.println("某米手机可以发消息");
        return "某米手机可以发消息具体实现";
    }
}

4. 创建抽象工厂 用于策略模式路由到具体的工厂对象

public abstract class AbstractFactory {
    /**
     * 工厂类型
     * */
    private Integer type;

    /**
     * 通过type获取到
     *
     * @param tClass 根据类型获取指定对象
     * @return 返回指定对象
     * @throws  Exception
     */
    public abstract <T> T getTargetObject(Class<T> tClass) throws Exception;

    public Integer getType() {
        return type;
    }

    public void setType(Integer type) {
        this.type = type;
    }
}

5. 创建大类工厂对象

/**
 * 汽车工厂
 * */
@Component
public class CarFactory extends AbstractFactory {

    private Integer type = 2;

    @Override
    public <T> T getTargetObject(Class<T> tClass) throws Exception {
        if (!CarBasic.class.isAssignableFrom(tClass)) {
            throw new Exception(tClass.getName() + "不属于" + CarBasic.class.getName());
        }
        // 这里内容具体可以自定义我图方便就直接反射实例化了
        return tClass.newInstance();
    }

    @Override
    public Integer getType() {
        return this.type;
    }

    @Override
    public void setType(Integer type) {
        this.type = type;
    }
}

/**
 * 手机工厂
 * */
@Component
public class PhoneFactory extends AbstractFactory {
    /**
     * 这里建议使用枚举
     * */
    private Integer type = 1;

    @Override
    public <T> T getTargetObject(Class<T> tClass) throws Exception{
        // 通过传递过来的tClass获取到下面的对象
        if (!PhoneBasic.class.isAssignableFrom(tClass)) {
            throw new Exception(tClass.getName() + "类型不属于" + PhoneBase.class.getName());
        }
        return tClass.newInstance();
    }

    @Override
    public Integer getType() {
        return type;
    }

    @Override
    public void setType(Integer type) {
        this.type = type;
    }
}

6. 创建工厂入口 获取大类工厂对象对外暴露

@Component
public class BeanFactory {

    @Autowired
    private List<AbstractFactory> factoryList;

    private static HashMap<Integer,AbstractFactory> FACTORY_MAP = new HashMap<>();

    @PostConstruct
    private void init(){
        for (AbstractFactory abstractFactory : factoryList) {
            FACTORY_MAP.put(abstractFactory.getType(),abstractFactory);
        }
    }

	/**
	 * 基于策略模式返回具体的大类工厂对象
 	 */
    public AbstractFactory getFactory(Integer type){
        return FACTORY_MAP.get(type);
    }
}

7. 测试

    @Autowired
    private BeanFactory beanFactory;

    @RequestMapping("/factory")
    public void factory() throws Exception {
        AbstractFactory factory = beanFactory.getFactory(1);
        MiPhone miPhone = factory.getTargetObject(MiPhone.class);
        miPhone.phoneCanCall();
        miPhone.phoneCanSend();

        AbstractFactory factory1 = beanFactory.getFactory(2);
        MaCar maCar = factory1.getTargetObject(MaCar.class);
        maCar.carCanDrive();
        maCar.carCanFast();
    }
结果:
	某米手机可以打电话
	某米手机可以发消息
	某马汽车可以开
	某马汽车可以很快