java架构师升级之路之设计模式（工厂模式）

简单工厂模式

应用场景：又叫做静态工厂方法(StaticFactory Method) 模式，
但不属于23种设计模式之一，简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该传入哪个产品类，Spring中的BeanFactory就是简单工厂的体现，根据出入的唯一标识来获得Bean对象，但是是否在传入参数前创建还是传入参数后创建，这个要根据具体情况确定。

package com.bjpowernode.simple;

/**
 * ClassName:Milk
 * PackageName:com.bjpowernode.simple
 * Description:
 *
 * @date:2020/6/27 14:39
 * @author:robin
 */
public interface Milk {
     String getName();
}

package com.bjpowernode.simple;

/**
 * ClassName:Yili
 * PackageName:com.bjpowernode.simple
 * Description:
 *
 * @date:2020/6/27 22:41
 * @author:robin
 */
public class Yili implements Milk {
    @Override
    public String getName() {
        return "伊利";
    }
}

package com.bjpowernode.simple;

/**
 * ClassName:Telunsu
 * PackageName:com.bjpowernode.simple
 * Description:
 *
 * @date:2020/6/27 14:41
 * @author:13812536906
 */
public class Telunsu implements Milk {
    @Override
    public String getName() {
        return "特仑苏";
    }
}

package com.bjpowernode.simple;

/**
 * ClassName:SimpleFactory
 * PackageName:com.bjpowernode.simple
 * Description:  简单工厂模式 测试
 *
 * 特点：一个工厂类生产多家牛奶
 *
 * @date:2020/6/27 14:46
 * @author:robin
 */
public class SimpleFactory {
    public  Milk getMilk(String name){
        if ("特仑苏".equals(name)){
            return   new Telunsu();
        }else if("伊利".equals(name)){
            return  new Yili();
        }
         return null;

    }
}

package com.bjpowernode.simple;

/**
 * ClassName:TestSimple
 * PackageName:com.bjpowernode.simple
 * Description:  小作坊式的工厂
 *有点类似小作坊生产，自己new 牛奶
 * @date:2020/6/27 14:41
 * @author:13812536906
 */
public class TestSimple {
    public static void main(String[] args) {
        //new 这个过程是比较复杂的，创建产品的过程隐藏了
        //容易配置错。 比如特仑苏容易写错。
//        System.out.println(new Telunsu().getName());
        Milk milk=new SimpleFactory().getMilk("特仑苏");
        System.out.println(milk);
    }


}

工厂方法模式

Factory Method,应用场景：
通常是由应用程序直接使用new创建新的对象，为了将对象的使用和创建相分离，采用工厂模式，即应用程序将对象的创建和初始化职责交给工厂对象。一般情况下，应用程序有自己的工厂来创建bean对象 。如果将应用程序自己的工厂对象交给Spring管理，那么Spring管理的就不是普通Bean而是工厂Bean。

package com.bjpowernode.func;

import com.bjpowernode.simple.Milk;

/**
 * ClassName:Factory
 * PackageName:com.bjpowernode.func
 * Description:
 *
 * @date:2020/6/27 22:29
 * @author:robin
 */
public interface Factory {
   Milk getMilk();
}

package com.bjpowernode.func;

import com.bjpowernode.simple.Milk;
import com.bjpowernode.simple.Yili;

/**
 * ClassName:YiliFactory
 * PackageName:com.bjpowernode.func
 * Description:
 *
 * @date:2020/6/27 22:40
 * @author:robin
 */
public class YiliFactory implements  Factory {
    @Override
    public Milk getMilk() {
        return new Yili();
    }

}

package com.bjpowernode.func;

import com.bjpowernode.simple.Milk;
import com.bjpowernode.simple.Telunsu;

/**
 * ClassName:TelunsuFactory
 * PackageName:com.bjpowernode.func
 * Description:
 *
 * @date:2020/6/27 22:36
 * @author:robin
 */
public class TelunsuFactory implements  Factory {
    @Override
    public Milk getMilk() {
        return new Telunsu();
    }
}

package com.bjpowernode.func;

import com.bjpowernode.simple.Milk;
import com.bjpowernode.simple.Telunsu;

/**
 * ClassName:FactoryTest
 * PackageName:com.bjpowernode.func
 * Description:   工厂方法测试：
 * 特点： 多家工厂生产不同牛奶      ------>社会的进步，不再是一家生产多种牛奶
 *
 * @date:2020/6/27 22:30
 * @author:13812536906
 */
public class FactoryTest {
    public static void main(String[] args) {
//          Factory factory=new Factory() {
//              @Override
//              public Milk getMilk() {
//                  return new Telunsu();
//              }
//          };
//        System.out.println(factory.getMilk());
        //还是需要new 对象，还是需要复杂的配置.这种其实就是一种多态的表现
        //货比三家，不知道谁好谁坏。

        Factory factory=new TelunsuFactory();
        System.out.println(factory.getMilk());
        Factory factory2=new YiliFactory();
        System.out.println(factory2.getMilk());

    }
}

抽象工厂模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。
模式的结构
抽象工厂模式的主要角色如下。
a>抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
b>具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
c>抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
d>具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。

package com.bjpowernode.absc;

import com.bjpowernode.simple.Milk;

/**
 * ClassName:AbstractFactory
 * PackageName:com.bjpowernode.absc
 * Description:
 *抽象接口是用户的主入口
 * @date:2020/6/27 22:56
 * @author:robin
 */
public abstract  class   AbstractFactory {
    //公共的逻辑, 接口就不能如下定义
 /*   public    void  getClor(){

    }*/

    //方便统一管理
    public  abstract Milk getMengniu();
    public  abstract Milk getYili();
    public  abstract Milk getTelunsu();
}

package com.bjpowernode.absc;

import com.bjpowernode.func.YiliFactory;
import com.bjpowernode.simple.Milk;
import com.bjpowernode.simple.Telunsu;
import com.bjpowernode.simple.Yili;

/**
 * ClassName:MilkFactory
 * PackageName:com.bjpowernode.absc
 * Description:
 *
 * @date:2020/6/27 23:04
 * @author:robin
 */
public   class MilkFactory extends  AbstractFactory {

    @Override
    public Milk getMengniu() {
        //抽象工厂模式与工厂方法模式混用
        return new YiliFactory().getMilk();
    }

    @Override
    public Milk getYili() {
        return new Yili();
    }

    @Override
    public Milk getTelunsu() {
        return new Telunsu();
    }
}

package com.bjpowernode.absc;

/**
 * ClassName:AbsctractoryTest
 * PackageName:com.bjpowernode.absc
 * Description:
 *
 * @date:2020/6/27 22:59
 * @author:robin
 */
public class AbsctractoryTest {
    public static void main(String[] args) {
          MilkFactory factory=new MilkFactory();
          //对于用户而言，直接拿牛奶了，不需要new .
        System.out.println(factory.getYili());
    }
}

本文地址：https://blog.csdn.net/qq_30347133/article/details/107378167