设计模式学习笔记之(二)设计模式之工厂模式

柔情只为你懂 2023-07-10 05:26 18阅读 0赞

# 工厂模式 #

*  工厂模式的诞生就是为了解决用户与产品之间的问题

### 简单工厂模式（Simple Factory） ###

*  又叫做静态工厂方法（StaticFactory Method）模式，但不属于 23 种设计模式之一。简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。
 *  Spring 中的 BeanFactory 就是简单工厂模式的体现，根据传入一个唯一的标识来获得 Bean 对象，但 是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。  
    ![在这里插入图片描述][20200229212206795.png]

### 简单工厂模式栗子 ###

首先建立抽象物品类，以tom老师讲的Milk为例

//milk 抽象接口
    public interface Milk {
        /**
         * 获取一个标准产品
         * @return
         */
        public String getName();
    
    }

各类Milk具体类实现该接口

//蒙牛类
    
    public class Mengniu implements Milk {
        @Override
        public String getName() {
            return "蒙牛";
        }
    }
    //特仑苏
    public class Telunsu implements Milk {
        @Override
        public String getName() {
            return "特仑苏";
        }
    }
    //伊利
    public class Yili implements  Milk {
        @Override
        public String getName() {
            return "伊利";
        }
    }
    //三鹿
    public class Sanlu implements  Milk{
        @Override
        public String getName() {
            return "三鹿";
        }
    }

创建工厂

public class SimpleFactory {
        public Milk getMilk(String name){
            if("特仑苏".equals(name)){
                return new Telunsu();
            }else if("伊利".equals(name)){
                return new Yili();
            }else if("蒙牛".equals(name)){
                return new Mengniu();
            }else if("三鹿".equals(name)){
                return  new Sanlu();
            } else {
                System.out.println("不能生产您所需的产品");
                return null;
            }
        }
    }

测试

public class SimpleFactoryTest {
    
        public static void main(String[] args) {
    
            //这个new的过程实际上一个比较复杂的过程
            //有标准就不需要自己new了
            System.out.println("-------------------------");
           /System.out.println(new Telunsu().getName());
            //小作坊式的生产模式
            //用户本身不再关心生产的过程，而只需要关心这个结果
            SimpleFactory factory = new SimpleFactory();
            //把用户的需求告诉工厂
            //创建产品的过程隐藏了，对于用户而且完全不清楚是怎么产生的
            System.out.println("-------------------------");
            System.out.println(factory.getMilk("蒙牛"));
            System.out.println("-------------------------");
            System.out.println(factory.getMilk("xxx"));
            System.out.println("-------------------------");
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70]  
**需要注意的是简单工厂模式方法并没有存在于23中设计模式之中**

### 工厂模式方法（Factory Method） ###

*  工程模式方法属于23类设计模式之一，因为简单工厂缺少了**工厂的精细化的分工**，所以需要一种新的工厂模式----工厂模式方法
 *  应用场景：通常由应用程序直接使用 new 创建新的对象，为了将对象的创建和使用相分离，采用工厂模 式,即应用程序将对象的创建及初始化职责交给工厂对象。
 *  一般情况下,应用程序有自己的工厂对象来创建 Bean.如果将应用程序自己的工厂对象交给 Spring 管 理,那么 Spring 管理的就不是普通的 Bean,而是工厂 Bean。  
    ![在这里插入图片描述][2020030113244057.png]

### 工厂模式方法栗子 ###

建立工厂接口

public interface Factory {
    
        //工厂必然具有生产产品技能，统一的产品出口
        Milk getMilk();
    
    }

实现工厂接口

/** Mengniu***/
    public class MengniuFactory implements  Factory {
        @Override
        public Milk getMilk() {
            return new Mengniu();
        }
    }
    /** 伊利***/
    public class YiliFactory implements Factory {
        @Override
        public Milk getMilk() {
            return new Yili();
        }
    }
    /**特仑苏***/
    public class TelunsuFactory implements Factory {
        @Override
        public Milk getMilk() {
            return new Telunsu();
        }
    }
    /** 三鹿***/
    public class SanluFactory implements  Factory {
        @Override
        public Milk getMilk() {
            return new Sanlu();
        }
    }

测试代码

public class FactoryTest {
        public static void main(String[] args) {
            //System.out.println(new Factory().getMilk(););
            Factory factory = new SanluFactory();
            System.out.println("---------------------");
            System.out.println(factory.getMilk().getName());
            System.out.println("---------------------");
    
        }
    }

工厂模式方法提升了**专业化水平和精细化程度**，无需用户自己直接与产品交涉，在一定程度上降低了代码的耦合性，但是这种方式任然有不足之处，如可扩展性不强，如此抽象工程模式便诞生了。

### 抽象工厂模式 ###

抽象工厂模式是对工厂模式方法的的可扩展性增强，从而使得代码更能符合开闭环原则。

//建立抽象工厂
    public abstract class AbstractFactory {
        //公共的逻辑
        //方便于统一管理
        /**
         * 获得一个蒙牛品牌的牛奶
         * @return
         */
        public  abstract Milk getMengniu();
        /**
         * 获得一个伊利品牌的牛奶
         * @return
         */
        public abstract  Milk getYili();
    
        /**
         * 获得一个特仑苏品牌的牛奶
         * @return
         */
        public  abstract  Milk getTelunsu();
        public abstract Milk getSanlu();
    }

建立工厂

public class MilkFactory extends  AbstractFactory {
        @Override
        public Milk getMengniu() {
            return new Mengniu();
        }
        @Override
        public Milk getYili() {
            return new Yili();
        }
        @Override
        public Milk getTelunsu() {
            return new Telunsu();
        }
        @Override
        public Milk getSanlu() {
            return new Sanlu();
        }
    }

整体代码测试

public class AbstractFactoryTest {
        public static void main(String[] args) {
            MilkFactory factory = new MilkFactory();
            //对于用户而言，更加简单了
            //用户只有选择的权利了，保证了程序的健壮性
            System.out.println(factory.getSanlu());
        }
    }

*  总而言之，**在测试代码中用户只需要选择对应的bean就可以，而修改代码的权利在于设计者，不能让用户去修改代码，如需要另外添加一个工厂，就直接修改抽象工厂和继承抽象工厂的实体即可**。

[20200229212206795.png]: https://img-blog.csdnimg.cn/20200229212206795.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200229221918868.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu,size_16,color_FFFFFF,t_70
[2020030113244057.png]: https://img-blog.csdnimg.cn/2020030113244057.png