设计模式-抽象工厂模式的应用场景及Java中对抽象工厂的应用

1. 什么是抽象工厂模式

• 抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定他们的类
• 抽象工厂模式（Abstract Factory Pattern）隶属于设计模式中的创建型模式，用于产品族的构建。抽象工厂是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂是指当有多个抽象角色时使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。
  工厂模式中的每一个形态都是针对一定问题的解决方案，工厂方法针对的是多个产品系列结构；而抽象工厂模式针对的是多个产品族结构，一个产品族内有多个产品系列

2. 抽象工厂模式的优点/缺点及适用场景

2.1 抽象工厂模式的优点

• 具体产品在应用层的代码隔离，无需关心创建的细节
• 将一个系列的产品统一到一起创建

2.2 抽象工厂模式的缺点

• 具体产品在应用层的代码隔离，无需关系创建的细节
• 将一个系列的产品统一到一起创建

2.3 抽象工厂模式的适用场景

• 客户端(应用层)不依赖于产品类实例如何被创建、实现等细节
• 强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量重复的代码
• 提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现

3.抽象工厂模式简单案例

3.1 创建抽象工厂

• 可以生产手机也可以生成电脑

package com.san.factroy.abst;

import com.san.factroy.fac.Computer;
import com.san.factroy.fac.Mobile;

/**
 * @ClassName AbstFactory
 * @Description TODO
 * @Author ZhangSan_Plus
 * @Date 2022/10/12 19:21
 * @Version 1.0
 **/
public abstract class AbstFactory {
    public abstract Mobile genMobile();

    public abstract Computer genComputer();
}

3.2 创建苹果工厂

• 创建苹果工厂并继承抽象工厂 可以生产手机和电脑

package com.san.factroy.apple;

import com.san.factroy.abst.AbstFactory;
import com.san.factroy.fac.Computer;
import com.san.factroy.fac.Mobile;

/**
 * @ClassName IphoneFactory
 * @Description TODO
 * @Author ZhangSan_Plus
 * @Date 2022/10/12 19:23
 * @Version 1.0
 **/
public class IphoneFactory extends AbstFactory {
    @Override
    public Mobile genMobile() {
        return new Iphone();
    }

    @Override
    public Computer genComputer() {
        return new MacBook();
    }
}

3.3 创建小米工厂

• 创建小米工厂并继承抽象工厂 可以生产手机和电脑

package com.san.factroy.mi;

import com.san.factroy.abst.AbstFactory;
import com.san.factroy.fac.Computer;
import com.san.factroy.fac.Mobile;

/**
 * @ClassName MiFactory
 * @Description TODO
 * @Author ZhangSan_Plus
 * @Date 2022/10/12 19:26
 * @Version 1.0
 **/
public class MiFactory extends AbstFactory {
    @Override
    public Mobile genMobile() {
        return new MiMobile();
    }

    @Override
    public Computer genComputer() {
        return new MiComputer();
    }
}

3.4 创建手机产品

• 手机有拨打电话和发送短信的功能

package com.san.factroy.fac;

/**
 * @ClassName Mobile
 * @Description TODO
 * @Author ZhangSan_Plus
 * @Date 2022/10/12 19:15
 * @Version 1.0
 **/
public interface Mobile {
    /**
     * 拨打电话
     *
     * @param
     * @return void
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 19:17 2022/10/12
     **/
    void dialNumber();

    /**
     * 发送断线
     *
     * @param
     * @return void
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 19:17 2022/10/12
     **/
    void sendMsg();
}

3.5 创建电脑产品

• 电脑有玩游戏和编写Java程序的功能

package com.san.factroy.fac;

/**
 * @ClassName Computer
 * @Description TODO
 * @Author ZhangSan_Plus
 * @Date 2022/10/12 19:17
 * @Version 1.0
 **/
public interface Computer {
    /**
     * 玩游戏
     *
     * @param
     * @return void
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 19:18 2022/10/12
     **/
    void playGames();

    /**
     * 写Java程序
     *
     * @param
     * @return void
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 19:18 2022/10/12
     **/
    void writeJava();
}

3.6 小米手机和小米电脑

• 小米手机

package com.san.factroy.mi;

import com.san.factroy.fac.Mobile;

/**
 * @ClassName MiMobile
 * @Description TODO
 * @Author ZhangSan_Plus
 * @Date 2022/10/12 19:25
 * @Version 1.0
 **/
public class MiMobile implements Mobile {
    @Override
    public void dialNumber() {
        System.out.println("MI 拨打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("MI 发送短信");
    }
}

• 小米电脑

package com.san.factroy.mi;

import com.san.factroy.fac.Computer;

/**
 * @ClassName MiComputer
 * @Description TODO
 * @Author ZhangSan_Plus
 * @Date 2022/10/12 19:25
 * @Version 1.0
 **/
public class MiComputer implements Computer {
    @Override
    public void playGames() {
        System.out.println("Mi电脑 打游戏");
    }

    @Override
    public void writeJava() {
        System.out.println("Mi电脑 编写Java程序");
    }
}

3.7 苹果手机和苹果电脑

• 苹果手机

package com.san.factroy.apple;

import com.san.factroy.fac.Mobile;

/**
 * @ClassName Iphone
 * @Description TODO
 * @Author ZhangSan_Plus
 * @Date 2022/10/12 19:19
 * @Version 1.0
 **/
public class Iphone implements Mobile {
    @Override
    public void dialNumber() {
        System.out.println("苹果 拨打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("苹果 发送短信");
    }
}

• 苹果电脑

package com.san.factroy.apple;

import com.san.factroy.fac.Computer;

/**
 * @ClassName MacBook
 * @Description TODO
 * @Author ZhangSan_Plus
 * @Date 2022/10/12 19:20
 * @Version 1.0
 **/
public class MacBook implements Computer {
    @Override
    public void playGames() {
        System.out.println("MacBook 打游戏");
    }

    @Override
    public void writeJava() {
        System.out.println("MacBook 编写Java程序");
    }
}

3.8 具体使用

package com.san.factroy;

import com.san.factroy.abst.AbstFactory;
import com.san.factroy.apple.IphoneFactory;
import com.san.factroy.fac.Computer;
import com.san.factroy.fac.Mobile;
import com.san.factroy.mi.MiFactory;

/**
 * @ClassName Client
 * @Description TODO
 * @Author ZhangSan_Plus
 * @Date 2022/10/12 19:28
 * @Version 1.0
 **/
public class Client {
    public static void main(String[] args) {
        AbstFactory iphoneFac = new IphoneFactory();
        AbstFactory miFac = new MiFactory();
        Computer macBook = iphoneFac.genComputer();
        Computer miComputer = miFac.genComputer();
        Mobile miMobile = miFac.genMobile();
        Mobile iphone = iphoneFac.genMobile();
        macBook.playGames();
        miComputer.playGames();
        miMobile.dialNumber();
        iphone.dialNumber();
    }
}

4.抽象工厂模式在Java中的应用

• 在 Spring 中，BeanFactory 是用于管理 Bean 的一个工厂，所有工厂都是 BeanFactory 的子类。这样我们可以通过 IOC 容器来管理访问 Bean，根据不同的策略调用 getBean() 方法，从而获得具体对象。

package org.springframework.beans.factory;

import org.springframework.beans.BeansException;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;


public interface BeanFactory {

	String FACTORY_BEAN_PREFIX = "&";

	Object getBean(String name) throws BeansException;

	<T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException;

	Object getBean(String name, Object... args) throws BeansException;

	<T> T getBean(Class<T> requiredType) throws BeansException;

	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	boolean containsBean(String name);

	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
	
	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;

	String[] getAliases(String name);

}