工厂模式

工厂模式常见的有三种简单工厂模式、工厂方法模式、抽象工厂模式

（一）简单工厂模式

简单工厂模式又称静态工厂方法模式。它存在的目的很简单：定义一个用于创建对象的接口。 组成结构： **1) 工厂类角色(Creator)**：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。 **2) 抽象产品角色(Product)**：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。 **3) 具体产品角色(ConcreteProduct)**：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

1
public interface Figure(){public double calculateArea();//计算面积}

具体产品角色 – 正方形、圆形：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Square implements Figure{//正方形
	public Square(){}
	public Square(double length){
		this.length = length;
	}
	private double length;
    // getters/setters ...
    @Override
    public double calculateArea(){
		return this.getLength() * this.getLength();
	}
}
public class Circle implements Figure{//圆形
	public Circle(){}
	public Circle(double radius){
		this.radius = radius;
	}
	private double radius;
    // getters/setters ...
    @Override
	public double calculateArea(){
		return this.getRadius() * this.getRadius() * Math.PI;
	}
}

工厂类角色-图形工厂：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class FigureFactory{
	public static Figure createFigure(String typeName, double figureArgs){
		if("Circle".equalsIgnoreCase(typeName)){
			return new Circle(figureArgs);
		}else if("Square".equalsIgnoreCase(typeName)){
			return new Square(figureArgs);
		}
	}
}
//测试代码
public class Test {
    public static void main(String []args){
    	Figure figure = null;
    	if(...){//界面逻辑需要圆形
    		figure = FigureFactory.createFigure("Circle", 2.0);
    	}else if(...){//界面逻辑需要正方形
    		figure = FigureFactory.createFigure("Square", 2.0);
    	}
    	System.out.println("面积为："+figure.calculateArea());
    }
}

（二）工厂方法模式

新增一个产品必须新增一个对应的工厂类

工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

组成结构： **1) 抽象工厂角色(Creator)**： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在 java 中它由抽象类或者接口来实现。 **2) 具体工厂角色(ConcreteCreator1,2)**：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 **3) 抽象产品角色(Product)**：它是具体产品继承的父类或者是实现的接口。在 java 中一般有抽象类或者接口来实现。 **4) 具体产品角色(ConcreteProduct1,2)**：具体工厂角色所创建的对象就是此角色的实例。在 java 中由具体的类来实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//图形工厂
public interface FigureFactory{
	public Figure createFigure(double figureArgs);
}
//圆形工厂
public class CircleFactory implements FigureFactory{
	@Override
	public Figure createFigure(double figureArgs){
		return new Circle(figureArgs);
	}
}
//正方形工厂 与 圆形工厂类似，此处省略

//测试代码
public class Test {
    public static void main(String []args){
    	FigureFactory figureFactory = null;
    	if(...){//界面逻辑需要圆形
    		figureFactory = new CircleFactory();
    	}else if(...){//界面逻辑需要正方形
    		figureFactory = new SqureFactory();
    	}
    	Figure figure = figureFactory.createFigure(2.0);
    	System.out.println("面积为："+figure.calculateArea());
    }
}

结合项目：

在网关项目当中创建会话Session的时候和SessionFactory的时候用到了工厂模式，以下是他们的接口和工厂，没有用到的时候确实不理解

GatewaySession：

1
2
3
4
5
6
7
8
9
public interface GatewaySession {

    Object get(String uri, Object parameter);

    IGenericReference getMapper(String uri);

    Configuration getConfiguration();

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class DefaultGatewaySession implements GatewaySession {

    private Configuration configuration;

    public DefaultGatewaySession(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public Object get(String uri, Object parameter) {

        /* 以下这部分内容，后续拆到执行器中处理 */

        // 配置信息
        HttpStatement httpStatement = configuration.getHttpStatement(uri);
        String application = httpStatement.getApplication();
        String interfaceName = httpStatement.getInterfaceName();

        // 获取基础服务（创建成本较高，内存存放获取）
        ApplicationConfig applicationConfig = configuration.getApplicationConfig(application);
        RegistryConfig registryConfig = configuration.getRegistryConfig(application);
        ReferenceConfig<GenericService> reference = configuration.getReferenceConfig(interfaceName);
        // 构建Dubbo服务
        DubboBootstrap bootstrap = DubboBootstrap.getInstance();
        bootstrap.application(applicationConfig).registry(registryConfig).reference(reference).start();
        // 获取泛化调用服务
        ReferenceConfigCache cache = ReferenceConfigCache.getCache();
        GenericService genericService = cache.get(reference);

        return genericService.$invoke(httpStatement.getMethodName(), new String[]{"java.lang.String"}, new Object[]{"小傅哥"});
    }

    @Override
    public IGenericReference getMapper(String uri) {
        return configuration.getMapper(uri, this);
    }

    @Override
    public Configuration getConfiguration() {
        return configuration;
    }

}

GatewaySessionFactory：

1
2
3
4
5
public interface GatewaySessionFactory {

    GatewaySession openSession();

}

DefaultGateWaySessionFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class DefaultGatewaySessionFactory implements GatewaySessionFactory {

    private final Configuration configuration;

    public DefaultGatewaySessionFactory(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public GatewaySession openSession() {
        return new DefaultGatewaySession(configuration);
    }

}

抽象工厂

抽象工厂模式就是产品线更加复杂，但是又会回到当初的简单工厂的局面，违反开闭原则