手撕设计模式-工厂模式

目录

背景

分类

实现

简单工厂

工厂方法

抽象工厂 

总结

---

背景

在实际业务中我们经常创建对象，常用的做法就是new。但是有些情况下对new不做控制就会造成资源浪费，不能做到多路复用，而且很容易达到系统瓶颈。这个时候就可以考虑使用工厂模式。比如数据库连接资源，Redis连接资源、日志记录等场景。

分类

• Simple Factory： 简单工厂模式，严格意义上它不属于23种设计模式，它违背开闭原则，破坏的是对修改关闭原则。当增加产品的时候，要增加对应产品类和具体工厂。
• Factory Method： 工厂方法模式，相对于简单工厂模式，对工厂做进一步的抽象，是具体产品对应具体工厂。这是工厂还是只生产一种具体产品。
• Abstract Factory： 抽象工厂模式，相对于工厂方法模式，抽象工厂开始生产多等级产品，不同等级的多个产品构成产品族。
• 产品族：是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。
• 产品等级：抽象父类和其不同产品子类构成一个产品等级。

实现

简单工厂

/**
 * 电脑抽象类
 */
public interface Computer {

    /**
     * 制造电脑的方法
     */
    Computer make();
}

/**
 * 笔记本
 */
public class Laptop implements Computer {
    public Laptop() {
        System.out.println("make a Laptop Computer!");
    }

    @Override
    public Computer make() {
        return new Laptop();
    }
}

/**
 * 个人PC,台式机
 */
public class Desktop implements Computer {
    public Desktop() {
        System.out.println("make a Desktop Computer!");;
    }

    @Override
    public Desktop make() {
        return new Desktop();
    }
}


/**
 * 简单工厂模式
 */
public class ComputerSimpleFactory {
    Computer makeComputer(String computerType) {
        switch (computerType) {
            case "desktop":
                return new Desktop();
            case "laptop":
                return new Laptop();
        }
        return null;
    }

    public static void main(String[] args) {
        ComputerSimpleFactory computerSimpleFactory = new ComputerSimpleFactory();
        Computer desktop = computerSimpleFactory.makeComputer("desktop");
        Computer laptop = computerSimpleFactory.makeComputer("laptop");
    }
}

工厂方法

• Computer类使用简单工厂中定义的。

/**
 * 抽象工厂
 */
public interface AbstractFactory {
    Computer makeComputer();
}

/**
 * 台式机工厂
 */
public class DesktapFactory implements AbstractFactory{
    @Override
    public Computer makeComputer() {
        return new Desktop();
    }
}

/**
 * 笔记本工厂
 */
public class LaptopFactory implements AbstractFactory{
    @Override
    public Computer makeComputer() {
        return new Laptop();
    }
}


public class MethodFactory {
    public static void main(String[] args) {
        //制造一台台式机
        DesktapFactory desktapFactory = new DesktapFactory();
        Computer desktop = desktapFactory.makeComputer();
        //制造一台笔记本
        LaptopFactory laptopFactory = new LaptopFactory();
        Computer laptop = laptopFactory.makeComputer();

    }
}

抽象工厂 

/**
 * 抽象工厂
 *
 * 
 */
public interface AbstractFactory {
    /**
     * 制造电脑
     * @return
     */
    public Computer makeComputer();

    /**
     * 制造电源
     * @return
     */
    public PowerSupply makePowerSupply();
}

/**
 * 戴尔工厂
 *
 * 
 */
public class DellFactory implements AbstractFactory{
    /**
     * 制造戴尔电脑
     *
     * @return
     */
    @Override
    public Computer makeComputer() {
        return new DellComputer();
    }

    /**
     * 制造戴尔电源
     *
     * @return
     */
    @Override
    public PowerSupply makePowerSupply() {
        return new DellPowerSupply();
    }
}

/**
 * 惠普工厂
 *
 * 
 */
public class HPFactory implements AbstractFactory{
    /**
     * 制造惠普电脑
     *
     * @return
     */
    @Override
    public Computer makeComputer() {
        return new HpComputer();
    }

    /**
     * 制造惠普电源
     *
     * @return
     */
    @Override
    public PowerSupply makePowerSupply() {
        return new HPPowerSupply();
    }
}


public class DellComputer implements Computer{
    public DellComputer(){
        System.out.println("make a DellComputer!");
    }
    /**
     * 惠普电脑
     */
    @Override
    public Computer make() {
        return null;
    }
}

public class HpComputer implements Computer {
    public HpComputer() {
        System.out.println("make a HpComputer!");
    }

    /**
     * 制造惠普电脑的方法
     */
    @Override
    public Computer make() {
        return null;
    }
}

public interface PowerSupply {
    /**
     * 生产电源
     * @return
     */
    public PowerSupply make();
}

public class DellPowerSupply implements PowerSupply{
    public DellPowerSupply(){
        System.out.println("make a DeskPowerSupply");
    }

    /**
     * 戴尔电源
     * @return
     */
    @Override
    public PowerSupply make() {
        return new DellPowerSupply();
    }
}

public class HPPowerSupply implements PowerSupply{
    public HPPowerSupply(){
        System.out.println("make a HPPowerSupply");
    }

    /**
     * 惠普电源
     * @return
     */
    @Override
    public PowerSupply make() {
        return new HPPowerSupply();
    }
}

public class AbstractFactoryTest {
    public static void main(String[] args) {
        //戴尔工厂
        DellFactory dellFactory = new DellFactory();
        dellFactory.makePowerSupply();
        dellFactory.makeComputer();
        //惠普工厂
        HPFactory hpFactory = new HPFactory();
        hpFactory.makeComputer();
        hpFactory.makePowerSupply();
    }
}

总结

• 工作实践中主要是工厂模式和抽象工厂模式的应用。使用场景：公共资源使用、线程池池、对象池等
• 两者的主要区别是生产一个产品和多个产品，代码形式上区别不大。
• 重点要理解概念，这有助于实际业务场景的抽象设计