设计模式之工厂模式

public interface Car {
    public void drive();
}

public class Benz implements Car {

    public void drive() {
        System.out.println("Driving Benz");
    }
}

public class Bmw implements Car {

    public void drive() {
        System.out.println("Driving Bmw");
    }
}

public class CarFactory {
    /***
     * 简单工厂，告诉我产品的名字，我就能给你生成相应的产品
     * @param carName
     * @return
     */
    public static Car createCar(String carName){
        if(carName.equals("Benz")){
            return new Benz();
        }else if(carName.equals("Bmw")){
            return new Bmw();
        }
        return null;
    }
}

public class Person {
    public static void main(String[] args) {
        Car car = CarFactory.createCar("Bmw");
        car.drive();
    }

}

public interface ICarFactory {
    Car createCar();
}

public class BmwFactory implements ICarFactory {

    public Car createCar() {
        return new Bmw();
    }
}

public class BenzFactory implements ICarFactory {
    
    public Car createCar() {
        return new Benz();
    }
}

public class Person {

    public static void main(String[] args) {
        ICarFactory factory = new BmwFactory();
        Car car = factory.createCar();
        car.drive();
    }
}

public  interface IAbstractFactory
{
    T Create<T>();
}

public  class AbstractFactory : IAbstractFactory
{
    /// <summary>
    /// 工厂与工厂能够创建的对象类型字典之间的映射字典
    /// </summary>
    private static readonly IDictionary<Type, Dictionary<Type, Type>> typeMapper = null;
    private Type factoryType = null;

    public static AbstractFactory()
    {
        //从具体的配置项中读取，从配置文件中读取或者通过某个方法来硬编码实现等。
        //这里推荐的做法是从配置文件中读取。
        //根据配置文件中的ObjectInstance 节点放在对应的工厂下的字典中
        //每个工厂节点FactorySection 就会创建一个字典，并且将这个工厂能够创建的类型放在这个字典中
        typeMapper = new Dictionary<Type, Dictionary<Type, Type>>();
    }

    public  AbstractFactory(string typeName)
    {
        this.factoryType = Type.GetType(typeName);
    }
    public T Create<T>()
    {
        if(typeMapper.ContainsKey(this.factoryType))
            return default(T);

        Dictionary<Type, Type> instances = typeMapper[this.factoryType];

        if (!instances.ContainsKey(typeof(T)))
            return default(T);

        Type typeInstance = instances[typeof(T)];

        T obj = (T)Activator.CreateInstance(typeInstance);

        return obj;
    }
}

<?xml version="1.0" encoding="utf-8" ?>
<AbstractFactory>
    <FactorySections>
        <FactorySection name="ProductFactory" type="DesignPattern.ProductFactory">
            <ObjectInstance name="" type=""/>
            <ObjectInstance name="" type=""/>
            <ObjectInstance name="" type=""/>
            <ObjectInstance name="" type=""/>
        </FactorySection>
        <FactorySection name="FoodFactory" type="DesignPattern.FoodFactory">
            <ObjectInstance name="" type=""/>
            <ObjectInstance name="" type=""/>
            <ObjectInstance name="" type=""/>
            <ObjectInstance name="" type=""/>
        </FactorySection>
        <FactorySection name="BookFactory" type="DesignPattern.BookFactory">
            <ObjectInstance name="" type=""/>
            <ObjectInstance name="" type=""/>
            <ObjectInstance name="" type=""/>
            <ObjectInstance name="" type=""/>
        </FactorySection>
    </FactorySections>
</AbstractFactory>