工厂模式

１.１简单工厂模式

定义了一个创建对象的类，由这个类来封装实例化对象的行为。比如一个pizza工厂一共生产三种类型的pizza：chesse,pepper,greak。通过工厂类（SimplePizzaFactory）实例化这三种类型的对象。

public class SimplePizzaFactory {
       public Pizza CreatePizza(String ordertype) {
              Pizza pizza = null;
              if (ordertype.equals("cheese")) {
                     pizza = new CheesePizza();
              } else if (ordertype.equals("greek")) {
                     pizza = new GreekPizza();
              } else if (ordertype.equals("pepper")) {
                     pizza = new PepperPizza();
              }
              return pizza;
       }
}

1.2工厂方法模式

//抽象类
abstract Pizza createPizza();

//子类实现类
public class LDOrderPizza extends OrderPizza {
       Pizza createPizza(String ordertype) {
              Pizza pizza = null;
              if (ordertype.equals("cheese")) {
                     pizza = new LDCheesePizza();
              } else if (ordertype.equals("pepper")) {
                     pizza = new LDPepperPizza();
              }
              return pizza;
       }
}
public class NYOrderPizza extends OrderPizza {
 
	Pizza createPizza(String ordertype) {
		Pizza pizza = null;
 
		if (ordertype.equals("cheese")) {
			pizza = new NYCheesePizza();
		} else if (ordertype.equals("pepper")) {
			pizza = new NYPepperPizza();
		}
		return pizza;
 
	}
 
}

//新增子类
public class BJOrderPizza extends OrderPizza {
       Pizza createPizza(String ordertype) {
              Pizza pizza = null;
              if (ordertype.equals("cheese")) {
                     pizza = new LDCheesePizza();
              } else if (ordertype.equals("pepper")) {
                     pizza = new LDPepperPizza();
              }
              return pizza;
       }
}

好处就是当你需要添加功能的时候，只需要添加实体类，不需要修改原来的代码。

1.3抽象工厂模式

抽象工厂模式的主要角色如下。
抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。
水果接口和水果工厂接口：

//生产水果-接口
public interface Fruit {
	public void get();
}

//水果工厂-接口
public interface FruitFactory {
	public Fruit getApple();
	public Fruit getBanana();
}

水果抽象类实现接口

//苹果抽象类
public abstract class Apple implements Fruit{
	public abstract void get();
}
//香蕉抽象类
public abstract class Banana implements Fruit{
	public abstract void get();
}

//Apple_A 继承Apple
public class Apple_A extends Apple{
	@Override
	public void get() {
		System.out.println("生产A级-苹果");
	}
}
// Apple_B继承Apple类
public class Apple_B extends Apple{
	@Override
	public void get() {
		System.out.println("生产B级-苹果");
	}
}

//	FruitFactory_calssA 要去实现 FruitFactory
public class FruitFactory_calssA implements FruitFactory{
//  A级水果工厂只生产A级水果
	@Override
	public Fruit getApple() {
//		生产A级苹果
		return new Apple_A();
	}

	@Override
	public Fruit getBanana() {
//		生产A级香蕉
		return new Banana_A();
	}

}
public class FruitFactory_calssB implements FruitFactory{
//   B级水果工厂只生产B级水果
	@Override
	public Fruit getApple() {
//		生产B级苹果
		return new Apple_B();
	}

	@Override
	public Fruit getBanana() {
//		生产B级香蕉
		return new Banana_B();
	}

}

1.4总结：

简单工厂模式就是将new操作放入简单的类中，需要使用这个类的时候不通过new操作。而是调用该简单类的方法。工厂方法模式就是将对象实例化代码进行抽象，将具体实现延迟到其子类。抽象工厂模式就是将工厂也进行抽象化，有点像多个工厂方法模式组合起来。

1.５应用实例：

在Spring的bean工厂中, 新对象不是通过new关键字获取的, 而是通过配置文件获取的，具体的过程是: 先读取配置文件获得该类的class对象, 然后通过class对象创建具体的实例对象。所以说Spring其实是个bean容器。具体思路。
１．创建BeanFactory工厂接口, 添加方法getBean()
２．创建BeanFactory的实现类ClassPathXmlApplicationContext. 将在该实现类中展示IOC的具体实现．
３．ClassPathXmlApplicationContext需要一个container容器存放创建的bean对象, 这里使用HashMap实现.
４．在ClassPathXmlApplicationContext的构造方法中读取spring的配置文件, 这里使用到了dom4j. 读取配置文件后根据bean的class属性使用反射创建出bean对象. 然后把id和bean对象分别作为key和value添加到容器中.
５．当工厂被调用getBean()方法时, 从容器中找到对应的bean并返回.