设计模式
(二)工厂模式
1. 概念
在基类中定义创建对象的一个接口,让子类决定实例化哪个类。工厂方法让一个类的实例化延迟到子类中进行。
1.1 场景
- 解耦:将对象的创建与使用分离。
- 降低代码重复: 如果创建某个对象的过程都很复杂,需要一定的代码量,而且很多地方都要用到,那么就会有很多的重复代码。
- 降低维护成本 :由于创建过程都由工厂统一管理,所以发生业务逻辑变化,不需要找到所有需要创建某个对象的地方去逐个修正,只需要在工厂里修改即可,降低维护成本。
1.2 目标
在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。
1.3 思路
对象的创建过程下放到子类中执行。
1.4 使用场景
- JDBC中Connection对象的获取(DriverManager.getConnection())。
- Hibernate中SessionFactory创建Session,Mybatis中SqlSessionFactory创建SqlSession。
- spring中IOC容器创建管理bean对象(BeanFactory)。
- JDK中Calendar的getInstance方法。
- XML解析时的DocumentBuilderFactory创建解析器对象。
- 反射中Class对象的newInstance()。
2. 实现
(一)简单工厂模式(虽然某种程度不符合设计原则,但实际使用最多)
- 创建接口
Shape.java
public interface Shape {
void draw();
}
- 实现接口
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.");
}
}
- 创建工厂
ShapeFactory.java
public class ShapeFactory {
//使用 getShape 方法获取形状类型的对象
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("Square")){
return new Square();
} else if(shapeType.equalsIgnoreCase("Rectangle")){
return new Rectangle();
} return null;
}
}
- 构造对象
FactoryDemo.java
public class FactoryDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
//获取 Square的对象,并调用它的 draw 方法
Shape shape1 = shapeFactory.getShape("Square");
//调用 Circle 的 draw 方法
shape1.draw();
//获取 Rectangle的对象,并调用它的 draw 方法
Shape shape2 = shapeFactory.getShape("Rectangle");
//调用 Rectangle 的 draw 方法
shape2.draw();
}
优点:根据外界给定信息,创建具体得对象类,初步降低耦合性,明确区分各自得职责。
缺点:一旦增删产品,就要修改工厂逻辑,扩展困难。
(二)工厂方法模式(不修改已有类的前提下,通过增加新的工厂类实现扩展)
- 创建接口
public interface Shape {
void draw();
}
- 创建工厂接口
public interface ShapeFactory {
public Shape createDraw();
}
- 实现工厂接口
public class RectangleFactory implements ShapeFactory {
@Override
public Shape createDraw() {
return new Rectangle ();
}
}
public class SquareFactory implements ShapeFactory {
@Override
public Shape createDraw() {
return new Square ();
}
}
- 构造对象
FactoryDemo.java
public class FactoryDemo{
public static void main(String[] args){
ShapeFactory rectangle = new RectangleFactory ();
ShapeFactory square = new SquareFactory ();
Shape shape1 = rectangle.createDraw();
Shape shape2 = square .createDraw();
shape1.draw();
shape2.draw();
}
}
优点:解决了简单工厂模式得缺点,每个具体得工厂类只完成单一任务,提高了扩展性。
缺点:如果需要同时修改多个产品,会使得扩展麻烦,每增加一个产品,需要增加对应得子工厂。
(三)抽象工厂模式(不可以增加产品,可以增加产品族)
- 创建形状接口
public interface Shape {
void draw();
}
- 实现接口
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.");
}
}
- 创建颜色接口
public interface Color {
void fill();
}
- 实现接口
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.");
}
}
- 为颜色和形状创建抽象类工厂
public abstract class AbstractFactory {
public abstract Color getColor(String color);
public abstract Shape getShape(String shape) ;
}
- 形状实现工厂类
ShapeFactory.java
public class ShapeFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("Square")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("Rectangle")){
return new Rectangle();
}
return null;
}
@Override
public Color getColor(String color) {
return null;
}
}
- 颜色实现工厂类
ColorFactory.java
public class ColorFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
return null;
}
@Override
public Color getColor(String color) {
if(color == null){
return null;
}
if(color.equalsIgnoreCase("Red")){
return new Red();
} else if(color.equalsIgnoreCase("Green")){
return new Green();
}
return null;
}
}
- 创建工厂生产者
FactoryProducer.java
public class FactoryProducer {
public static AbstractFactory getFactory(String choice){
if(choice.equalsIgnoreCase("Shape")){
return new ShapeFactory();
} else if(choice.equalsIgnoreCase("Color")){
return new ColorFactory();
}
return null;
}
}
- 构造对象
AbstractFactoryDemo.java
public class AbstractFactoryDemo {
public static void main(String[] args) {
//获取形状工厂
AbstractFactory shapeFactory = FactoryProducer.getFactory("Shape");
//获取形状为 Rectangle 的对象
Shape shape1 = shapeFactory.getShape("Rectangle");
//调用 Rectangle 的 draw 方法
shape1.draw();
//获取形状为 Square 的对象
Shape shape2 = shapeFactory.getShape("Square");
//调用 Square 的 draw 方法
shape2.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();
}
优点:抽象工厂隔离了具体类得生产,降低了模块间的耦合性,创建了一个完整的产品系列,利于产品得一致性。
缺点:难以支撑新产品(种类)得出现,抽象工厂几乎确定了可以被创建的产品集合,支持新种类的产品就需要扩展该工厂接口,这将涉及抽象工厂类及其所有子类的改变。