SSM框架学习笔记-Spring-工厂模式篇

写这些博客只是想巩固一下知识点，如果有错误的地方，还请大家在评论区指正

上次讲到了Spring中如何通过xml配置bean对象，这里面涉及到了一个设计模式，叫做工厂模式，比起传统模式，通过工厂模式可以实现解耦，使得程序代码更加简洁更加强大。

通过披萨店的例子来讲解传统模式与工厂模式的差别

客户通过披萨店订购自己喜欢的口味的披萨，然后披萨店制作客户喜欢口味的披萨

根据上面的描述的流程，我们需要一个Pizza类，一个Order类，还有一个PizzaStore类

首先我们声明一个公开的Pizza.class类，然后写不同口味的Pizaa类去继承该类，并实现重写该类中的方法

Pizza类中我们声明一个私有的字符串类型的变量叫PizzaName

在定义制作Pizza的几个方法

preparePizza()准备披萨、bakePizza()烘培披萨、cutPizza()裁剪披萨、boxPizza()装箱披萨

public class Pizza {

    //成员变量私有化
    private String pizzaName;//披萨口味

    public Pizza(String pizzaName) {
        this.pizzaName = pizzaName;
    }

     //对外提供set和get方法
    public void setPizzaName(String pizzaName) {
        this.pizzaName = pizzaName;
    }

    public String getPizzaName() {
        return this.pizzaName;
    }

    //准备披萨
    public void preparePizza() {

    }
    //烘培披萨
    public void bakePizza() {

    }
    //裁剪披萨
    public void cutPizza() {

    }
    //装箱披萨
    public void boxPizza() {

    }
}

来两个不同口味的披萨778

GreekPizza.class

public class GreekPizza extends Pizza {

    public GreekPizza(String pizzaName) {
        super(pizzaName);
    }

    @Override
    public void prepare() {
       System.out.println("制作希腊披萨");
    }

    @Override
    public void bake() {
         System.out.println("烘培希腊披萨");
    }

    @Override
    public void cut() {
        System.out.println("裁剪希腊披萨");
    }

    @Override
    public void box() {
        System.out.println("装箱希腊披萨");
    }
}

 ChessPizza.class

public class ChessPizza extends Pizza {
    
    public ChessPizza(String pizzaName) {
        super(pizzaName);
    }

    @Override
    public void prepare() {
       System.out.println("准备起司披萨");
    }

    @Override
    public void bake() {
       System.out.println("烘培起司披萨");
    }

    @Override
    public void cut() {
       System.out.println("裁剪起司披萨");
    }

    @Override
    public void box() {
       System.out.println("装箱起司披萨");
    }
}

 然后在定义OrderPizza类和PizzaStore类

OrderPizza类中定一个公开、静态的OrderPizza()方法用于读取用户所需要的披萨口味

import java.util.Scanner;

public class OrderPizza {
    public static String orderPizza() {
        Scanner scanner = new Scanner(System.in);
        return scanner.next();
    }
}

PizzaStore类中定义一个productPizza()方法用于获取Pizza口味,制作对应的披萨

 public class PizzaStore {

    public static void productPizza() {
        PizzaAbstract Pizza = null;
        String pizzaName = OrderPizza.orderPizza();
        if (pizzaName.equals("Chess")) {
            Pizza = new ChessPizza();
            Pizza.setPizzaName("Chess");   
            Pizza.prepare();
            Pizza.bake();
            Pizza.cut();
            Pizza.box();

        } else if (pizzaName.equals("Greek")) {
            Pizza = new GreekPizza();
            Pizza.setPizzaName("Greek");
            Pizza.prepare();
            Pizza.bake();
            Pizza.cut();
            Pizza.box();

        } else {
            System.out.println("没有这个类型的披萨");
        }
        
    }

}

正常编写代码大概就是上面的思路，利用继承父类和重写父类方法实现多态，通过多态来实现这个流程

现在如果想添加新的口味披萨，那么需要写新口味的Pizza类去继承Pizza类，重写Pizza类中的方法,而且在PizzaStore类中也要添加新的代码，现在可能只是一两个类，简单修改一下代码就行，但是如果是涉及到的是一个大工程项目，有上千上万个类，那代码就会显得重复。

于是在这个基础上，我们有两个方法可以选择

1.可以把Pizza类声明成抽象类，将披萨有关的方法放入Pizza这个抽象类中，再由不同口味披萨去是继承这个抽象类，在添加新口味披萨的时候，只需重写抽象类种的抽象方法就行。

2.可以把Pizza类声明成一个接口类，在接口定义披萨有关的抽象方法，然后让不同的披萨去实现这个接口中的方法，之后想要添加新的口味披萨，只需要重写接口中的方法。（跟原来的方法差不多）

选择第一种方法，对Pizza类和PizzaStore类进行修改，在创建一个PepperPizza.class

Pizza.class

 public abstract class Pizza{

    protected String PizzaName;

    public abstract void prepare();

    public void bake() {
        System.out.println(PizzaName + " baking");
    }

    public void cut() {
        System.out.println(PizzaName + " cutting");
    }

    public void box() {
        System.out.println(PizzaName + " boxing");
    }

    public void setPizzaName(String PizzaName) {
        this.PizzaName = PizzaName;
    }

}

Order没有修改

PizzaStore.class

public class ProductPizza {

    public static void productPizza() {
        PizzaAbstract Pizza = null;
        String pizzaName = OrderPizza.orderPizza();
        if (pizzaName.equals("Chess")) {
            Pizza = new ChessPizza();
            Pizza.setPizzaName("Chess");
        } else if (pizzaName.equals("Greek")) {
            Pizza = new GreekPizza();
            Pizza.setPizzaName("Greek");
        } else if (pizzaName.equals("Pepper")) {
            Pizza = new PepperPizza();
            Pizza.setPizzaName("Pepper");
        }else {
            System.out.println("没有这个类型的披萨");
        }
        if (Pizza != null) {
            Pizza.prepare();
            Pizza.bake();
            Pizza.cut();
            Pizza.box();
        }


    }


}

CheesPizza.class

public class ChessPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("制作Chess披萨");
    }
}

GreekPizza.class

public class GreekPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("制作Greek披萨");
    }
}

PapperPizza.class

public class PapperPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("制作Papper披萨");
    }
}

 上面讲到的所有的实现该流程的方法都会多多少少涉及对原代码修改，于是引入了工厂模式

工厂模式有简单工厂模式、抽象工厂模式这两种，总的原理就是新建一个工厂类用于创建用户想要的对象，但是用户只知道对象名字，至于创建过程由抽象工厂在完成，用户只需要负责拿到这个对象就可以。今天文章就写到这，工厂模式的实现过程和原理，我学习之后在继续对文章继续书写

1、计算机并不解决问题，它们只是执行解决方案。

2、最好的程序员跟好的程序员相比可不止好那么一点点。这种好不是一个数量级的，取决于标准怎么定：概念创造性、速度、设计的独创性或者解决问题的能力。

3、永远要这样写代码，好像最终维护你代码的人是个狂暴的、知道你住在哪里的精神病患者。

4、人的过失会带来错误，但要制造真正的灾难还得用计算机。

5、控制复杂性是计算机编程的本质。

6、如果你的计算机说英语，那么它很可能是日本造的。

7、唯一对免费软件感到害怕的人，是自己的产品还要不值钱的人。

8、他们拥有计算机，他们也还可能拥有其他的大规模杀伤性武器。

9、要是Java真的有垃圾回收的话，大部分程序在执行的时候就会把自己干掉了。

10、一个组织若是要以电脑做为沟通工具，必需先破除行之有年、固若金汤的官僚体系。