Android设计模式之（4）----工厂方法模式

工厂方法模式

---

比如富士康是一个工厂,为其他外部厂商提供相同或者不同的产品，而外部厂商不用关心富士康内部的实现过程，只需要接受结果即可。如果有新的产品，也只需要告诉富士康，富士康负责生产输出就好。

因此工厂模式可大幅度降低模块之间的耦合，加强扩展性。

应用场景

需要生成一个或者多个复杂对象的具体实现

工厂模式分类

• 工厂方法模式
  
  • 标准工厂
  • 简单工厂
  • 反射工厂
  • 缓存工厂
  • 私有工厂
• 抽象工厂模式

本文主要介绍工厂方法模式。

工厂方法模式特点

• 一个抽象类可以实现多个具体类

具体实现

Q:使用工厂模式来判断一个程序猿他是具体的什么样的程序猿（PHP,Android,iOS,Java等等）

（一）标准工厂方法

1.建立一个接口来获取程序猿类型

public interface CodeMonkey {
    public  void showCodeMonkeyType();//展示是什么类型的程序猿
}

2.实现接口生成不同类型的程序猿

Android程序猿：

public class AndroidCodeMonkey implements  CodeMonkey {
    @Override
    public void showCodeMonkeyType() {
        System.out.println("我是Android攻城狮");
    }
}

iOS程序猿：

public class IosCodeMonkey implements  CodeMonkey {
    @Override
    public void showCodeMonkeyType() {
        System.out.print("我是iOS攻城狮");
    }
}

3.建立抽象的工厂接口

public abstract class Factory {
    public abstract CodeMonkey showCodeMonkeyType() ;
}

4.通过抽象的工厂接口进行具体类的实现

public class AndroidMonkeyFactory extends Factory {

    @Override
    public CodeMonkey showCodeMonkeyType() {
        return new AndroidCodeMonkey();
    }
}

public class IosMonkeyFactory extends Factory {
    @Override
    public CodeMonkey showCodeMonkeyType() {
        return new IosCodeMonkey();
    }
}

5.具体调用

CodeMonkey codeMonkey = new AndroidCodeMonkey();
        codeMonkey.showCodeMonkeyType();

        new IosCodeMonkey().showCodeMonkeyType();

6.输出结果

我是Android攻城狮

我是iOS攻城狮

程序猿（产品）在创建过程中都是通过接口来进行生成,生成某一类型程序猿时降低了使用者和产品本身耦合

（二）简单工厂模式（静态工厂模式）

静态工厂的方法是静态的,不允许外部进行扩展更改,如果有内容的更改需要对当前静态工厂进行更改。

代码示例：

public class CodeMonkeyEasyFactory {
    public final static String GENERATE_IOS = "android";
    public final static String GENERATE_ANDROID = "ios";
    public static CodeMonkey generateCodeMonkey(String flag) throws Exception {
        CodeMonkey codeMonkey = null;
        switch (flag){
            case GENERATE_ANDROID:
                codeMonkey =  new AndroidCodeMonkey();
                break;
            case GENERATE_IOS:
                codeMonkey =  new IosCodeMonkey();
                break;

            default:
                throw new Exception("UNDEFINED FLAG");
        }
        return codeMonkey;
    }
}

上述静态工厂在内部已经定义了iOS和Android的静态常亮,使用过程中只需要外部传入具体的数值,内部进行判断即可,但是若有新的程序猿产生,除了实现具体的程序猿,还需要对静态工厂扩展增加。
外部调用：

CodeMonkeyEasyFactory.generateCodeMonkey(CodeMonkeyEasyFactory.GENERATE_ANDROID).showCodeMonkeyType();
CodeMonkeyEasyFactory.generateCodeMonkey(CodeMonkeyEasyFactory.GENERATE_IOS).showCodeMonkeyType();

显示结果：

我是Android攻城狮

我是iOS攻城狮

（三）反射工厂

只需要实现具体的产品类型而不需要修改工厂,通过反射抛到上层直接让外部使用获取。

代码示例：

1.泛型类型约束将具体类型抛到上层工厂进行处理

public abstract class IGenerator {
    public abstract <T extends CodeMonkey>T generateCodeMonkey(Class<T> clazz) throws Exception;
}

2.实现具体产品内容

public class CodeMonkeyReflexFactory extends IGenerator {
    @Override
    public <T extends CodeMonkey> T generateCodeMonkey(Class<T> clazz) throws Exception {
        CodeMonkey codeMonkey = null;
        codeMonkey = (CodeMonkey) Class.forName(clazz.getName()).newInstance();
        return (T)codeMonkey;
    }
}

调用方式:

 new CodeMonkeyReflexFactory().generateCodeMonkey(AndroidCodeMonkey.class).showCodeMonkeyType();

显示结果：

我是Android攻城狮

（四）缓存工厂

将复杂对象或者频繁使用的内容作为一个长期的存储,再次使用时直接进行提取

代码示例：

public class CodeMonkeyCacheFactory  extends IGenerator {
    private Map<String, CodeMonkey> map = new HashMap<>();

    @Override
    public <T extends CodeMonkey> T generateCodeMonkey(Class<T> clazz) throws Exception {
        CodeMonkey CodeMonkey = null;
        if (map.containsKey(clazz.getName()))
            CodeMonkey = map.get(clazz.getName());
        else {
            CodeMonkey = (CodeMonkey) Class.forName(clazz.getName()).newInstance();
            map.put(clazz.getName(), CodeMonkey);
        }
        return (T) CodeMonkey;
    }
}

将具体的产品类型存储于hasmap,再次使用时可直接提取使用。

调用方式:

“`
new CodeMonkeyCacheFactory().generateCodeMonkey(AndroidCodeMonkey.class).showCodeMonkeyType();

“`

显示结果:

我是Android攻城狮

（五) 私有产品构造

限制外部使用new XXX()的方式进行创建

public class CodeMonkeyPrivateFactory extends IGenerator {
    public <T extends CodeMonkey> T generateCodeMonkey(Class<T> clazz) throws Exception {
        CodeMonkey iPhone = null;
        Class phone = Class.forName(clazz.getName());
        //拿到构造器不检测权限
        phone.getDeclaredConstructor().setAccessible(true);
        iPhone = (CodeMonkey) phone.newInstance();
        return (T) iPhone;
    }
}

调用方式:

 new CodeMonkeyPrivateFactory().generateCodeMonkey(AndroidCodeMonkey.class).showCodeMonkeyType();

显示结果:

我是Android攻城狮

总结

以上就是工程模式的介绍.降低模块耦合,提高扩展性,有新的产品内容出现只需要扩展工厂即可完成。

github代码地址