Explicación del patrón de fábrica del patrón de diseño de Java

---

Visión de conjunto

1. El patrón de fábrica (patrón de fábrica simple, patrón de método de fábrica, patrón de fábrica abstracto) es el más utilizado de los 23 patrones de diseño y pertenece al patrón de creación en los patrones de diseño .
2. El patrón de fábrica es una manifestación de la programación orientada a la interfaz de Java. Al crear objetos, no expondremos la lógica de creación al cliente, sino que crearemos objetos a través de interfaces abstractas, uso y creación separados, reduciremos el acoplamiento y facilitaremos la expansión.
3. Hay muchos escenarios de aplicación del modelo de fábrica, como jdbc, spring ioc, spring aop, parsing xml, Executors, etc., los hay innumerables, en desarrollo real, como exportar informes en diferentes formatos, acoplarse con algunas interfaces de diferentes fabricantes de hardware, etc.

Patrón de fábrica simple

/**
 * 手机（抽象产品角色）
 */
public interface Phone {
    
    

    //获取手机
    void getPhone();
}

/**
 * @date 2020/5/9 19:55
 * @Author yz
 * 华为手机实现类（具体产品角色）
 */
public class HuaweiPhone implements Phone{
    
    
    @Override
    public void getPhone() {
    
    
        System.out.println("华为手机");
    }
}

/**
 * @date 2020/5/9 19:54
 * @Author yz
 * 小米手机实现类（具体产品角色）
 */
public class XiaomiPhone implements Phone{
    
    
    @Override
    public void getPhone() {
    
    
        System.out.println("小米手机");
    }
}

/**
 * @date 2020/5/9 19:56
 * @Author yz
 * 手机工厂类（工厂角色）
 */
public class PhoneFactory {
    
    

    /**
     * 生产手机
     */
    public Phone producePhone(String name){
    
    
        Phone phone=null;
        if("xiaomi".equals(name))
            phone=new XiaomiPhone();
        if("huawei".equals(name))
            phone=new HuaweiPhone();
        return phone;
    }
}

public class Customer {
    
    

    public static void main(String[] args) {
    
    
        PhoneFactory phoneFactory=new PhoneFactory();
        Phone xiaomi = phoneFactory.producePhone("xiaomi");
        Phone huawei = phoneFactory.producePhone("huawei");
        xiaomi.getPhone();
        huawei.getPhone();
    }
}

composición

1. Rol de fábrica (PhoneFactory)
2. Función de producto abstracto (teléfono)
3. Múltiples roles de productos específicos (HuaweiPhone, XiaomiPhone)

solicitud

4. El negocio es relativamente simple, con menos clases de implementación.
5. Negocio fijo, básicamente sin necesidad de modificar
6. La persona que llama no necesita preocuparse por la lógica de implementación

ventaja

Protegiendo la implementación, la persona que llama no necesita preocuparse por la implementación específica, buena encapsulación, desacoplamiento y conveniente para la expansión comercial. Cuando se necesita una nueva implementación, solo necesita agregar la clase de implementación y modificar la clase de fábrica.

Desventaja

Cada vez que agrega una clase de implementación, debe modificar la clase de fábrica, lo que viola el principio de apertura y cierre, y cuando hay demasiadas clases de implementación, no es fácil de mantener y la clase de fábrica se hinchará.

Patrón de método de fábrica

/**
 * 手机（抽象产品角色）
 */
public interface Phone {
    
    

    //得到手机
    void getPhone();
}

/**
 * @date 2020/5/9 19:54
 * @Author yz
 * 小米手机实现类（具体产品角色）
 */
public class XiaomiPhone implements Phone {
    
    
    @Override
    public void getPhone() {
    
    
        System.out.println("小米手机");
    }
}

/**
 * @date 2020/5/9 19:55
 * @Author yz
 * 华为手机实现类（具体产品角色）
 */
public class HuaweiPhone implements Phone {
    
    
    @Override
    public void getPhone() {
    
    
        System.out.println("华为手机");
    }
}

/**
 * @date 2020/5/9 19:56
 * @Author yz
 * 手机工厂类（抽象工厂）
 */
public interface PhoneFactory {
    
    
    /**
     * 生产手机
     */
    public Phone producePhone();
}

/**
 * @date 2020/5/9 19:54
 * @Author yz
 * 小米手机工厂类（实例工厂）
 */
public class XiaomiPhoneFactory implements PhoneFactory {
    
    

    @Override
    public Phone producePhone() {
    
    
        return new XiaomiPhone();
    }
}

/**
 * @date 2020/5/16 11:27
 * @Author yz
 * 华为手机工厂类（实例工厂）
 */
public class HuaweiPhoneFactory implements PhoneFactory {
    
    

    @Override
    public Phone producePhone() {
    
    
        return new HuaweiPhone();
    }
}

/**
 * @date 2020/5/9 19:59
 * @Author yz
 * 客户类
 */
public class Customer {
    
    

    public static void main(String[] args) {
    
    
        PhoneFactory xiaomiPhoneFactory=new XiaomiPhoneFactory();
        PhoneFactory huaweiPhoneFactory=new HuaweiPhoneFactory();
        xiaomiPhoneFactory.producePhone().getPhone();
        huaweiPhoneFactory.producePhone().getPhone();
    }
}

composición

1. Rol de fábrica abstracta (PhoneFactory)
2. Función de producto abstracto (teléfono)
3. Múltiples roles de productos específicos (HuaweiPhone, XiaomiPhone)
4. Múltiples roles de fábrica específicos (HuaweiPhoneFactory, XiaomiPhoneFactory)

ventaja

Se ajusta a una sola responsabilidad, cuando se agrega una nueva implementación, no es necesario modificar el código, solo agregar nuevos productos y fábricas, lo que resuelve las deficiencias de las fábricas simples que violan el principio de apertura y cierre.

Desventaja

Cada vez que se agrega un producto (clase de instancia), es necesario agregar una clase de fábrica, lo que puede aumentar fácilmente el número de clases de fábrica y aumentar la dificultad de gestión.

Método de fábrica abstracto

/**
 * 手机（抽象产品角色）
 */
public interface Phone {
    
    

    //生产
    void getPhone();
}

/**
 * @date 2020/5/9 19:54
 * @Author yz
 * 小米手机实现类（具体产品角色）
 */
public class XiaomiPhone implements Phone {
    
    
    @Override
    public void getPhone() {
    
    
        System.out.println("小米手机");
    }
}

/**
 * @date 2020/5/9 19:55
 * @Author yz
 * 华为手机实现类（具体产品角色）
 */
public class HuaweiPhone implements Phone {
    
    
    @Override
    public void getPhone() {
    
    
        System.out.println("华为手机");
    }
}

/**
 * 充电器（抽象产品角色）
 */
public interface Charger {
    
    

    //得到充电器
    void getCharger();
}

/**
 * @date 2020/5/31 16:17
 * @Author yz
 * 小米充电器实现类（具体产品角色）
 */
public class XiaomiCharger implements Charger{
    
    
    @Override
    public void getCharger() {
    
    
        System.out.println("小米充电器");
    }
}

/**
 * @date 2020/5/31 16:17
 * @Author yz
 * 华为充电器实现类（具体产品角色）
 */
public class HuaweiCharger implements Charger{
    
    
    @Override
    public void getCharger() {
    
    
        System.out.println("华为充电器");
    }
}

/**
 * @date 2020/5/9 19:56
 * @Author yz
 * 电子产品工厂类（抽象工厂）
 */
public interface ElectronicFactory {
    
    
    /**
     * 得到手机
     */
    public Phone producePhone();

    /**
     * 得到充电器
     */
    public Charger produceCharger();
}

/**
 * @date 2020/5/9 19:54
 * @Author yz
 * 小米工厂类（实例工厂）
 */
public class XiaomiFactory implements ElectronicFactory {
    
    

    @Override
    public Phone producePhone() {
    
    
        return new XiaomiPhone();
    }

    @Override
    public Charger produceCharger() {
    
    
        return new XiaomiCharger();
    }
}

/**
 * @date 2020/5/16 11:27
 * @Author yz
 * 华为工厂类（实例工厂）
 */
public class HuaweiFactory implements ElectronicFactory {
    
    

    @Override
    public Phone producePhone() {
    
    
        return new HuaweiPhone();
    }

    @Override
    public Charger produceCharger() {
    
    
         return new HuaweiCharger();
    }
}

public class Customer {
    
    

    public static void main(String[] args) {
    
    
        ElectronicFactory xiaomiPhoneFactory=new XiaomiFactory();
        ElectronicFactory huaweiPhoneFactory=new HuaweiFactory();
        xiaomiPhoneFactory.producePhone().getPhone();
        huaweiPhoneFactory.producePhone().getPhone();
        xiaomiPhoneFactory.produceCharger().getCharger();
        huaweiPhoneFactory.produceCharger().getCharger();
    }
}

composición

1. Rol de fábrica abstracta (ElectronicFactory)
2. Múltiples roles de productos abstractos (teléfono, cargador)
3. Múltiples roles de productos específicos (HuaweiPhone, XiaomiPhone, HuaweiCharger, XiaomiCharger)
4. Múltiples roles de fábrica específicos (HuaweiFactory, XiaomiFactory)

ventaja

Se ajusta al principio de apertura y cierre, y es fácil aumentar la familia de productos, solo necesita aumentar los productos y fábricas correspondientes, con alta escalabilidad.

Desventaja

Cuando necesite agregar productos, debe modificar todos los métodos de la clase de fábrica (fábrica abstracta, fábrica de instancias), lo que viola el principio de apertura y cierre.

La diferencia entre el método de fábrica abstracto y el método de fábrica

Patrón de método de fábrica: una clase de producto abstracto puede derivar varias clases de productos concretos. Una clase de fábrica abstracta puede derivar múltiples clases de fábrica concretas. Cada clase de fábrica de hormigón solo puede crear una instancia de una clase de producto de hormigón.

Patrón de fábrica abstracto: múltiples categorías de productos abstractos, cada categoría de producto abstracto puede derivar múltiples categorías de productos específicas. Una clase de fábrica abstracta puede derivar múltiples clases de fábrica concretas. Cada clase de fábrica de hormigón puede crear varias instancias de clases de productos de hormigón.

Diferencia: el patrón de método de fábrica tiene solo una clase de producto abstracto, mientras que el patrón de fábrica abstracto tiene múltiples. La clase de fábrica de hormigón del patrón de método de fábrica solo puede crear una instancia de la clase de producto de concreto, mientras que el patrón de fábrica abstracto puede crear varias instancias.

para resumir

Tres métodos tienen ventajas y desventajas, desde la estructura compleja y la vista ampliada de la fábrica abstracta> método de fábrica> planta simple , el desarrollo real, se utiliza en la fábrica más simple, el método de fábrica y usa menos fábrica abstracta Aunque los métodos y las fábricas abstractas aumentan la escalabilidad del sistema, son más difíciles de modificar que las fábricas simples. Los verdaderos maestros no tienen trucos para ganar. Los maestros de artes marciales no pueden seguir los trucos al 100%. Úselo en combinación con el negocio. Lo mejor es lo mejor.