Spring框架之工厂模式

简单的工厂模式

        工厂模式：把原来分布在各个地方的对象的创建过程单独抽离出来，统一交给工厂类来创建所需的对象。 （需要使用对象的时候，不要自己去new，通过工厂（方法）来创建对应的对象）

1.常规模式创建对象Factory01

第一步：提供一个Factory01类，用于提供User对象的方法

package com.lr.spring.factory01;

public class Factory01 {
    //提供User对象的方法
    public static User getUserInstance(){
        return new User();
    }
}

第二步：直接new对象即可

public class FactoryTest01 {
    @Test
    public void testFactory01(){
        User user = new User();
        User user2= Factory01.getUserInstance();
    }

测试结果 

 

2.简单工厂模式

第一步：先写一个Car接口类 

package com.lr.spring.factory02;

public interface Car {
    void start();
    void run();
    void stop();
}

第二步：创建接口的各种实现类 

 

package com.lr.spring.factory02;

public class Benz implements Car {
    @Override
    public void start() {
        System.out.println("奔驰，发动了！");
    }

    @Override
    public void run() {
        System.out.println("奔驰，在行驶！");

    }

    @Override
    public void stop() {
        System.out.println("奔驰，停下了！");

    }
}

 

 都实现接口的这三个方法

第三步：根据外界传入参数的不同，创建不同的实现类

package com.lr.spring.factory02;

public class Factory02 {
    //根据外界传入参数的不同，创建不同的实现类
    public static Car getCarInstance(String str) {
        Car car = null;
        if ("QQ".equals(str)) {
            car = new QQ();
        } else if ("Bmw".equals(str)) {
            car = new Bmw();
        } else if ("Benz".equals(str)) {
            car = new Benz();
        }
        return car;
    }
}

测试

 @Test
    public void testFactory02(){
        Car car= Factory02.getCarInstance("QQ");
        car.start();
        car.run();
        car.stop();
    }

结果 

 

 

对比两种方法的优缺点：

factory01缺点：只能提供单一的对象

factory02缺点：通过接口的方式，提供该接口实现类的对象，但每次创建一个新该接口的实现类，都要去修改提供对象的方法

 所以我们还需要一种新的方式：工厂模式

第一步：提供一个配置文件

Benz=com.lr.spring.factory02.Benz
Bmw=com.lr.spring.factory02.Bmw
QQ=com.lr.spring.factory02.QQ
OOOO=com.lr.spring.factory02.OOOO

第二步：创建工厂模式提供创建对象的方法

package com.lr.spring.factory03;
import com.lr.spring.factory02.Car;
import com.lr.spring.factory02.QQ;
import java.io.FileInputStream;
import java.util.Properties;
public class Factory03 {
//    Properties 集合的工具类用来存储集合信息，用来操作.properties(k=v)文件,tonggk获取对应的v
    public static Car getCarInstance(String str) throws Exception{
        //1.创建Properties集合对象
        Properties properties=new Properties();
        //2.加载（读取）car.Properties，把配置文件信息统一加载到了Properties集合对象中
        properties.load(new FileInputStream("D:\\code\\spring01\\src\\main\\resources\\car.properties"));
        System.out.println(properties);
        //3.参数str就相当于Properties文件中的k值获取对应的v值
        //包名.类名（类的全限定名）
        String value= properties.getProperty(str);
        //4.反射创建对象    Class.ForName(包名.类名).newInstance()
        //根据包名.类名创建该类的反射对象
        Car car=(Car) Class.forName(value).newInstance();
        return new QQ();
    }
}

 测试

   @Test
    public void testFactory03() {
        Car car= null;
        try {
            car = Factory03.getCarInstance("QQ");
        } catch (Exception e) {
            e.printStackTrace();
        }
        car.start();
        car.run();
        car.stop();
    }

 

 factory03：解决了不管创建该接口多少个实现类，永远都不需要修改工厂中创建对象的方法。
根据配置信息，任意来编写该接口的实现类，根据接口实现类的的信息来创建对象的实现类对象。