java超级工厂_java设计模式之工厂模式

一、工厂模式简介

在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。这时就可以采用工厂模式。

工厂模式根据抽象程度的不同分为三种：简单工厂模式(也叫静态工厂模式)、普通工厂模式、以及抽象工厂模式。

工厂模式是编程中经常用到的一种模式。它的主要优点有：

1、可以使代码结构清晰，有效地封装变化。在编程中，产品类的实例化有时候是比较复杂和多变的，通过工厂模式，将产品的实例化封装起来，使得调用者根本无需关心产品的实例化过程，只需依赖工厂即可得到自己想要的产品。

2、对调用者屏蔽具体的产品类。如果使用工厂模式，调用者只关心产品的接口就可以了，至于具体的实现，调用者根本无需关心。即使变更了具体的实现，对调用者来说没有任何影响。

3、降低耦合度。产品类的实例化通常来说是很复杂的，它需要依赖很多的类，而这些类对于调用者来说根本无需知道，如果使用了工厂方法，我们需要做的仅仅是实例化好产品类，然后交给调用者使用。对调用者来说，产品所依赖的类都是透明的。

工厂方法模式有四个要素：

1、工厂接口。工厂接口是工厂方法模式的核心，与调用者直接交互用来提供产品。在实际编程中，有时候也会使用一个抽象类来作为与调用者交互的接口，其本质上是一样的。

2、工厂实现。在编程中，工厂实现决定如何实例化产品，是实现扩展的途径，需要有多少种产品，就需要有多少个具体的工厂实现。

3、产品接口。产品接口的主要目的是定义产品的规范，所有的产品实现都必须遵循产品接口定义的规范。产品接口是调用者最为关心的，产品接口定义的优劣直接决定了调用者代码的稳定性。同样，产品接口也可以用抽象类来代替，但要注意最好不要违反里氏替换原则。

4、产品实现。实现产品接口的具体类，决定了产品在客户端中的具体行为。

适用场景：

1、作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过new就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

2、工厂模式是一种典型的解耦模式，迪米特法则在工厂模式中表现的尤为明显。假如调用者自己组装产品需要增加依赖关系时，可以考虑使用工厂模式。将会大大降低对象之间的耦合度。

3、由于工厂模式是依靠抽象架构的，它把实例化产品的任务交由实现类完成，扩展性比较好。也就是说，当需要系统有比较好的扩展性时，可以考虑工厂模式，不同的产品用不同的实现工厂来组装。

应用实例：

1、假如需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。

2、Hibernate 换数据库只需换方言和驱动就可以。

3、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。

下面结合具体事例来说。举例如下：(我们举一个发送邮件和短信的例子)

1、因为邮件和短信是不同的事物，但执行的操作类似。我们定义一个两者的共同接口。public interface Sender {

public void Send(); //邮件和短信都需要进行发送操作

}

2、实现邮件和短信类

邮件类

public class MailSender implements Sender {

@Override

public void Send() {

System.out.println("this is mailsender!");

}

}

短信类

public class SmsSender implements Sender {

@Override

public void Send() {

System.out.println("this is sms sender!");

}

}

下面来分别介绍三种工厂模式。

二、简单工厂模式

通过提供的不同的静态方法来创建相应的类实例。

定义工厂类

public class SendFactory {

//采用静态方法创建不同的类实例

public static Sender produceMail(){

return new MailSender();

}

public static Sender produceSms(){

return new SmsSender();

}

}

测试

public class FactoryTest {

public static void main(String[] args) {

Sender sender = SendFactory.produceMail();//创建邮件类

sender.Send();

}

}

三、普通工厂模式

通过传入不同的字符串来创建相应的类实例。

定义工厂类

public class SendFactory {

//通过传入的字符串参数决定初始化那个类实例

public Sender produce(String type) {

if ("mail".equals(type)) {

return new MailSender();

} else if ("sms".equals(type)) {

return new SmsSender();

} else {

System.out.println("请输入正确的类型!");

return null;

}

}

}

测试

public class FactoryTest {

public static void main(String[] args) {

SendFactory factory = new SendFactory();

Sender sender = factory.produce("sms");//传入sms字符串，初始化一个短信类实例。

sender.Send();

}

}

四、抽象工厂模式

将工厂类定义为一个接口，不同的类实例的创建需要实现这个接口，从而保证不同的工厂类创建不同的类实例。

首先定义一个工厂类的接口：

public interface Provider {

public Sender produce();

}

之后根据不同的类实例创建相应的工厂类：

邮件工厂类

public class SendMailFactory implements Provider {

@Override

public Sender produce(){

return new MailSender();

}

}

短信工厂类

public class SendSmsFactory implements Provider{

@Override

public Sender produce() {

return new SmsSender();

}

}

测试：

public class Test {

public static void main(String[] args) {

Provider provider1 = new SendMailFactory();//初始化邮件类工厂

Sender sender1 = provider1.produce();//产生一个邮件类实例

sender1.Send();

Provider provider2 = new SendMailFactory();//初始化短信类工厂

Sender sender2 = provider2.produce();//产生一个短信类实例

sender2.Send();

}

}

五、抽象工厂模式的复杂应用

事实上，抽象工厂模式可以更复杂。抽象工厂模式是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

下面来看一个较为复杂的例子：

我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义两个工厂类： ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory接口。然后创建一个工厂创造器/生成器类 FactoryProducer，这个工厂可以生成ShapeFactory和ColorFactory。

1、shape接口

public interface Shape {

void draw();

}

2、建立shape的三个实现类

Rectangle.java

public class Rectangle implements Shape {

@Override

public void draw() {

System.out.println("Inside Rectangle::draw() method.");

}

}

Square.java

public class Square implements Shape {

@Override

public void draw() {

System.out.println("Inside Square::draw() method.");

}

}

Circle.java

public class Circle implements Shape {

@Override

public void draw() {

System.out.println("Inside Circle::draw() method.");

}

}

3、color接口

public interface Color {

void fill();

}

4、建立三个color的实体类

Red.java

public class Red implements Color {

@Override

public void fill() {

System.out.println("Inside Red::fill() method.");

}

}

Green.java

public class Green implements Color {

@Override

public void fill() {

System.out.println("Inside Green::fill() method.");

}

}

Blue.java

public class Blue implements Color {

@Override

public void fill() {

System.out.println("Inside Blue::fill() method.");

}

}

5、建立一个抽象工厂类

public abstract class AbstractFactory {

abstract Color getColor(String color);

abstract Shape getShape(String shape) ;

}

6、针对shape和color创建相应的工厂类，扩展自 AbstractFactory 的工厂类

ShapeFactory.java

public class ShapeFactory extends AbstractFactory {

@Override

public Shape getShape(String shapeType){

if(shapeType == null){

return null;

}

if(shapeType.equalsIgnoreCase("CIRCLE")){

return new Circle();

} else if(shapeType.equalsIgnoreCase("RECTANGLE")){

return new Rectangle();

} else if(shapeType.equalsIgnoreCase("SQUARE")){

return new Square();

}

return null;

}

@Override

Color getColor(String color) {

return null;

}

}

ColorFactory.java

public class ColorFactory extends AbstractFactory {

@Override

public Shape getShape(String shapeType){

return null;

}

@Override

Color getColor(String color) {

if(color == null){

return null;

}

if(color.equalsIgnoreCase("RED")){

return new Red();

} else if(color.equalsIgnoreCase("GREEN")){

return new Green();

} else if(color.equalsIgnoreCase("BLUE")){

return new Blue();

}

return null;

}

}

7、创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取相应的工厂。

FactoryProducer.java

public class FactoryProducer {

public static AbstractFactory getFactory(String choice){

if(choice.equalsIgnoreCase("SHAPE")){

return new ShapeFactory();//返回一个shape工厂类实例

} else if(choice.equalsIgnoreCase("COLOR")){

return new ColorFactory();//返回一个color工厂类实例

}

return null;

}

}

8、测试：

public class AbstractFactoryPatternDemo {

public static void main(String[] args) {

//获取形状工厂

AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");

//获取形状为 Circle 的对象，通过形状工厂生成

Shape shape1 = shapeFactory.getShape("CIRCLE");

//调用 Circle 的 draw 方法

shape1.draw();

//获取形状为 Rectangle 的对象

Shape shape2 = shapeFactory.getShape("RECTANGLE");

//调用 Rectangle 的 draw 方法

shape2.draw();

//获取形状为 Square 的对象

Shape shape3 = shapeFactory.getShape("SQUARE");

//调用 Square 的 draw 方法

shape3.draw();

//获取颜色工厂

AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");

//获取颜色为 Red 的对象

Color color1 = colorFactory.getColor("RED");

//调用 Red 的 fill 方法

color1.fill();

//获取颜色为 Green 的对象

Color color2 = colorFactory.getColor("Green");

//调用 Green 的 fill 方法

color2.fill();

//获取颜色为 Blue 的对象

Color color3 = colorFactory.getColor("BLUE");

//调用 Blue 的 fill 方法

color3.fill();

}

}

五、总结

普通工厂模式：

一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例。

区别：

普通工厂模式只有一个抽象产品类，而抽象工厂模式有多个。

普通工厂模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。