设计模式之工厂方法模式
工厂方法模式，顾名思义，调用工厂里的方法的模式。
一、定义
定义一个用于创建对象的接口，让子类决定实例化哪个类。主要用于生成复杂对象的地方。
二、UML类图
工厂模式类图.png
三、解读类图
1.抽象产品类--类图上的Product接口
public abstract class Product {
public abstract void product();
}
2.具体的产品类-类图上的ConcreteProduct
public class ConcreteProduct extends Product{
@Override
public void product() {
System.out.println("生产出一个产品");
}
}
3.抽象的工厂类-类图上的Factory接口
public abstract class Factory {
public abstract Product create();
}
4.具体的工厂类-类图上的ConcreteFactory
public class ConcreteFactory extends Factory{
@Override
public Product create() {
return new ConcreteProduct();
}
}
5.使用工厂类生产产品
public class Client {
public static void main(String[] args) {
Factory factory=new ConcreteFactory();
Product p=factory.create();
p.product();
}
}
输出结果：
生产出一个产品
以上是基本的使用方法。在你需要生产对象的时候可以直接使用具体工厂类的create方法产出你要的对象。在Client代码中是看不到具体的产品类ConcreteProduct，因为我们不需要知道内部的实现细节，不需要知道是怎么生产，这就是使用接口（抽象类）的好处，只需要调用暴露的接口方法就行了。
与此同时代码的可拓展性也变强了。比如我想生产另外的对象，那么只需要换一个工厂就行了。
比如换成2号工厂
Factory factory=new ConcreteFactory2();
2号工厂用于生产2号产品
public class ConcreteFactory2 extends Factory{
@Override
public Product create() {
return new ConcreteProduct2();
}
}
public class ConcreteProduct2 extends Product{
@Override
public void product() {
System.out.println("生产出一个2号产品");
}
}
四、实现工厂方法的第二种方式
有一种方式也比较常用，使用反射的方式去获取产品的对象
1.定义一个工厂抽象类
public abstract class ReflectFactory {
public abstract<T extends Product> T createProduct(Class<T> clz);
}
2.具体工厂类
public class ReflectConcreteFactory extends ReflectFactory{
@Override
public <T extends Product> T createProduct(Class<T> clz) {
Product p=null;
try {
p=(Product) Class.forName(clz.getName()).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return (T) p;
}
}
3.使用工厂类生产
public class ReflectClient {
public static void main(String[] args) {
ReflectFactory factory=new ReflectConcreteFactory();
Product p=factory.createProduct(ConcreteProduct.class);
p.product();
}
}
这种方法和基本使用方法不同的是我在使用工厂生产对象的时候，要传入我想生产的那个具体的对象的类。表面看上去还不如之前的方法好，代码变复杂。
但是这有个好处。只要这个具体产品是Product的子类，这些产品都可通过这一个工厂去实现。而之前的方式只能一个工厂对应一个具体的产品。
简单的举个栗子：基本方法就是-可口可乐只能生产可乐，要生产芬达的饮料要芬达工厂去生产。反射的方法-可口可乐和芬达都是刺激性饮料，现在有个工厂专门生产刺激性饮料，但是你要什么可乐还是芬达饮料，你要先和工厂说，它会根据你的要求给你（也就对应传入的参数）
总的来说，两种方式各有所长，在合适的时候选择合适的，才是最好的。
五、Retrofit源码上工厂方法的应用
1.RequestFactory
（1）调用RequestFactory的create方法生产Request的对象。这个Request就是封装了网络请求信息的对象
class RequestFactory {
okhttp3.Request create(Object[] args) throws IOException {
RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl,
headers, contentType, hasBody, isFormEncoded, isMultipart);
List<Object> argumentList = new ArrayList<>(argumentCount);
for (int p = 0; p < argumentCount; p++) {
argumentList.add(args[p]);
handlers[p].apply(requestBuilder, args[p]);
}
return requestBuilder.get() //建造者模式得到Request的对象
.tag(Invocation.class, new Invocation(method, argumentList))
.build();
}
}
（2）在OkHttpCall中调用这个工厂生产对象
private okhttp3.Call createRawCall() throws IOException {
okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}
2.Converter.Factory
在创建retrofit对象的时候，经常会添加了一个转换工厂，比如下面代码添加的GsonConverterFactory，是用于把数据转换成gson数据类型
Retrofit retrofit=new Retrofit.Builder()
.baseUrl("http://api.github.com/")
.addConverterFactory(GsonConverterFactory.create())
.build();
那么它是怎么使用工厂方法模式的呢？
（1）抽象工厂类
public interface Converter<F, T> {
T convert(F value) throws IOException;
public @Nullable Converter<ResponseBody, ?> responseBodyConverter(Type type,
Annotation[] annotations, Retrofit retrofit) {
return null;
}、
public @Nullable Converter<?, RequestBody> requestBodyConverter(Type type,
Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
return null;
}
}
（2）具体的工厂类
public final class GsonConverterFactory extends Converter.Factory {
public static GsonConverterFactory create() {
return create(new Gson());
}
public static GsonConverterFactory create(Gson gson) {
if (gson == null) throw new NullPointerException("gson == null");
return new GsonConverterFactory(gson);
}
//将响应体类型数据转换成？类型数据
@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
Retrofit retrofit) {
TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
return new GsonResponseBodyConverter<>(gson, adapter);
}
//将？类型的数据转换成请求体类型的数据
@Override
public Converter<?, RequestBody> requestBodyConverter(Type type,
Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
return new GsonRequestBodyConverter<>(gson, adapter);
}
}
咋一看看不出它生产的是什么对象。其实在重写的两个方法里，它通过不同的方法生产不同的对象，深入其中的一个requestBodyConverter方法去看
class GsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
//...
public RequestBody convert(T value) throws IOException {
Buffer buffer = new Buffer();
Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
JsonWriter jsonWriter = gson.newJsonWriter(writer);
adapter.write(jsonWriter, value);
jsonWriter.close();
return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
}
}
最后一行可以看到它返回了一个RequestBody的对象。这也符合了它的目的，就是将现有的类型的数据转换成请求体RequestBody类型的数据。
六、总结
总说看源码不能过于拘泥于细节实现，否则会看得满脸懵逼。但当你真正看的时候，特别是对应初学者，很难区分什么是细节实现，我刚在看Retrofit这部分源码的时候，看到这部分代码，emmn......这到底在干啥。最后我发现原因就是作者使用了大量的设计模式，在你不懂这些设计模式的时候，可不就是看天书一样。但当我去了解一些常用的设计模式基本实现之后，在去看这些代码，莫名其妙的就知道哪些是我不用关心的，比如上面的大多数代码，就为了创建一个对象，我只需要知道创建的对象是什么就行了。
额外说一点
Retrofit是一个很优秀的源码框架。里面用了很多设计模式，很适合花时间去学习。既可以学到Retrofit的源码实现，又能学到多种设计模式，想想就血赚啊~~
当然之后也会有在Retrofit上使用的其他设计模式的文章。
