设计模式--工厂模式、简单工厂模式

---

 

设计模式--工厂模式、简单工厂模式

 

1.概述

---

1.1 定义
"Define an interface for creating an boject, but let subclasses decide which class to instantiate. Factory Method lets a clss defer instantiation to subclsses"(定义一个用于创建对象的接口，让其子类决定实例化那一个类。工厂方法使一个雷的实例化延迟到其子类)
工厂模式：提供一个工厂对象，该工厂的工厂方法接受参数(Class对象或字符串)来产生具体的产品。
简单工厂模式：提供一个一个抽象工厂，一个抽象产品。每一个具体的产品都由一个具体的工厂产生。
1.2 意义
工厂模式、简单工厂模式是典型的解耦框架，它使得对象的创建不在依赖与new关键字，而是依赖于该工厂。
1.3 应用
Spring框架中Spring就是一个大的工厂，它管理所以的Bean对象。
JDK中java.util.concurrent包中提供了ThreadFactory接口，你可以实现该接口以创建自定义的Thread。

2.详解

---

2.1 工厂模式
提供一个工厂对象，该工厂的工厂方法接受参数(Class对象或字符串)来产生具体的产品。

抽象产品

public abstract class Product {
    public abstract void method();
}

具体的产品

public class ProductA extends Product {
    @Override
    public void method() {
        System.out.println("I am ProductA");
    }
}
public class ProductB extends Product {
    @Override
    public void method() {
        System.out.println("I am ProductB");
    }
}

工厂对象

public class ProductFactory {
    /**
     * 通过接受参数创建相应的产品
     * 参数可以为 Class、String、Enum
     */
    public <T extends Product> T create(Class<T> c) {
        T t = null;
        try {
            t = (T) Class.forName(c.getName()).newInstance();
        } catch (Exception e){
            // 异常处理
        }
        return t;
    }
}

通过工厂创建相应的产品

public class Client {
    public static void main(String[] args){
        ProductFactory factory = new ProductFactory();
        Product productA = factory.create(ProductA.class);
        productA.method();
        Product productB = factory.create(ProductB.class);
        productB.method();
    }
}output:
I am ProductA
I am ProductB

2.2 简单工厂模式
提供一个一个抽象工厂，一个抽象产品。每一个具体的产品都由一个具体的工厂产生。

抽象产品

public abstract class Product {
    public abstract void method();
}

具体的产品

public class ProductA extends Product {
    @Override
    public void method() {
        System.out.println("I am ProductA");
    }
}
public class ProductB extends Product {
    @Override
    public void method() {
        System.out.println("I am ProductB");
    }
}

抽象工厂

public abstract class Factory {
    public abstract Product create();
}

具体的工厂

public abstract class Factory {
    public abstract Product create();
}
public class ProductFactoryB extends Factory {
    @Override
    public Product create() {
        return new ProductB();
    }
}

通过工厂创建相应的产品

public class Client {
    public static void main(String[] args){
        Factory factoryA = new ProductAFactory();
        Product productA = factoryA.create();
        productA.method();

        Factory factoryB = new ProductBFactory();
        Product productB = factoryB.create();
        productB.method();
    }
}output:
I am ProductA
I am ProductB

3.延伸

---

3.1 通过工厂创建单例

public class SingletonFactory {
    private static Singleton singleton;
    static {
        try {
            @SuppressWarnings("unchecked")
            Class<Singleton> c = (Class<Singleton>) 
                    Class.forName(Singleton.class.getName());
            Constructor<Singleton> constructor = c.getDeclaredConstructor();
            constructor.setAccessible(true);
            singleton = constructor.newInstance();
        } catch (Exception e){
            // 异常处理
        }
    }
    public static Singleton getSingleton(){
        return singleton;
    }
}

 我们通过反射机制创建了一个单例对象。

4.应用

使用反射机制实现Spring的IOC。虽然与工厂模式没有联系，但是Spring也算是一个大工厂，只是使用Map实现的工厂，我就将就写在这里了。

我主要使用读取XML文件的方式模拟Spring，当然其中许多Spring的关键字没有实现，如factory-method等等。