Android设计模式-工厂方法模式

工厂方法模式介绍

工厂方法模式（Factory Pattern），是创建型模式之一。它结构简单，应用广泛。下面看看它的定义：

定义一个用于创建对象的接口，让子类决定实例化哪个类。

使用场景

在任何需要生成复杂对象的地方，都可以使用工厂方法模式。复杂对象适合使用工厂模式，用new就可以完成创建的对象无需使用工厂模式。

工厂方法模式的通用模式代码

//抽象产品类public abstract class Product {    //产品类的抽象方法 由具体实现类去实现    public abstract void method();}//具体产品类Apublic class ConcreteProductA extends Product {    @Override    public void method() {        System.out.println("我是具体产品A");    }}//具体产品类Bpublic class ConcreteProductB extends Product {    @Override    public void method() {        System.out.println("我是具体产品B");    }}//抽象工厂类public abstract class Factory {    //抽象工厂方法    //返回具体的产品对象    public abstract Product createProduct();}//具体工厂类public class ConcreteFactory extends Factory {    //返回一个具体产品的对象    @Override    public Product createProduct() {        return new ConcreateProductA();    }}//客户类public class Client {    public static void main(String[] args) {        Factory factory = new ConcreteFactory();        Product p = factory.createProduct();        p.method();    }}

以上主要分为四大角色：一是抽象工厂，其为工厂方法模式的核心；二是具体工厂，它实现了具体的业务逻辑；三是抽象产品，它是工厂方法模式所创建的产品的父类；四是具体产品，为实现抽象产品的某个具体产品的对象。

上述代码中，我们在Client类中构造了一个工厂对象，并通过其产生了一个产品对象，这里得到的是ConcreteProductA的实例，如果要得到ConcreteProductB的实例，更改ConcreteFactory中的逻辑即可：

//具体工厂类public class ConcreteFactory extends Factory {    //返回一个具体产品的对象    @Override    public Product createProduct() {        return new ConcreateProductA();    }}

也可以利用反射来生产具体的产品对象：

public abstract  class Factory {    //抽象工厂方法 具体生产什么由子类来实现    // @param clz 产品对象类类型    // @return 具体的产品对象    public abstract <T extends Product> T createProduct(Class<T> clz);}//具体工厂类public class ConcreteFactory extends Factory {    @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;    }}

最后是Client的实现：

public class Client {    public static void main(String[] args) {        Factory factory = new ConcreateFactory();        Product p = factory.createProduct(ConcreteProductB.class);        p.method();    }}

使用反射技术，需要哪一个类的对象就传入哪一个类的类型即可，这种方式动态、灵活。当然，反射也是比较耗费资源的。你也可以尝试为每一产品类定义一个具体的工厂，各司其职：

//具体工厂类 Apublic class ConcreteFactoryA extends Factory {    //返回A产品的对象    @Override    public Product createProduct() {        return new ConcreateProductA();    }}//具体工厂类 Bpublic class ConcreteFactoryB extends Factory {    //返回B产品的对象    @Override    public Product createProduct() {        return new ConcreateProductB();    }}

//客户端调用public class Client {    public static void main(String[] args) {        Factory factoryA = new ConcreteFactoryA();        Product productA = factoryA.createProduct();        productA.method();        Factory factoryB = new ConcreteFactoryB();        Product productB = factoryB.createProduct();        productB.method();    }}

上面这种方式成为多工厂方法模式。

工厂方法模式的简单实现

下面一个组装汽车的生产线为例，对于某款品牌的汽车，比如Q3、Q5、Q7，内部结构差异并不是很大，所以，一条生产线就能“应付”这三种车型：

//该类生产线的抽象类定义public abstract class AudiFactory {    //某车型的工厂方法    // @param clz 具体的SUV型号类型    // @return 具体    public abstract <T extends AudiCar> T createAudiCar(Class<T> clz);}//具体工厂类（具体的生产线）public class AudiCarFactory extends AudiFactory {    @Override    public <T extends AudiCar> T createAudiCar(Class<T> clz) {        AudiCar car = null;        try {            car = (AudiCar)Class.forName(clz.getName()).newInstance();        } catch (Exception e) {            e.printStackTrace();        }        return (T)car;    }}

对于这三种车型的共性，我们用AudiCar这个抽象类来声明，每种车型还有自己的特性，分别用AudiQ3、AudiQ5、AudiQ7来声明，这三个类都是AudiCar的子类：

//汽车的抽象产品类 体现不同型号汽车的共性public abstract class AudiCar {    //定义一个汽车的行为，如drive    public abstract void drive();    //定义一个汽车的行为，如自动巡航    public abstract void selfNavigation();}

//具体车型AudiQ3public class AudiQ3 extends AudiCar {    @Override    public void drive() {        System.out.println(" Q3 启动啦！");    }    @Override    public void selfNavigation() {        System.out.println(" Q3 开始自动巡航啦！");    }}//具体车型AudiQ5public class AudiQ5 extends AudiCar {    @Override    public void drive() {        System.out.println(" Q5 启动啦！");    }    @Override    public void selfNavigation() {        System.out.println(" Q5 开始自动巡航啦！");    }}//具体车型AudiQ7public class AudiQ5 extends AudiCar {    @Override    public void drive() {        System.out.println(" Q7 启动啦！");    }    @Override    public void selfNavigation() {        System.out.println(" Q7 开始自动巡航啦！");    }}

最后看Client端代码：

public class Client {    public static void main(String[] args) {        //构造一个制造汽车的工厂对象        AudiFactory factory = new AudiCarFactory();        //生产一台Q3        AudiQ3 audiQ3 = factory.createAudiCar(AudiQ3.class);        audiQ3.drive();        audiQ3.selfNavigation();        //生产一台Q5        AudiQ3 audiQ5 = factory.createAudiCar(AudiQ5.class);        audiQ5.drive();        audiQ5.selfNavigation();        //生产一台Q7        AudiQ3 audiQ7 = factory.createAudiCar(AudiQ7.class);        audiQ7.drive();        audiQ7.selfNavigation();    }}

//输出结果如下Q3 启动啦！Q3 开始自动巡航啦！Q5 启动啦！Q5 开始自动巡航啦！Q7 启动啦！Q7 开始自动巡航啦！

工厂方法模式实战

下面以数据存储为例，介绍一个工厂方法模式的实例。

大家都知道Android数据持久化有很多种方法，如SharedPreferences或者SQLite，也可是使用常规的文件存储。但是数据库的操作无非就是增删改查，我们可以将每一种数据操作的方式作为一个产品类，在抽象产品类中定义操作的抽象方法。

public abstract class IOHandler {    // 添加一条个人信息    // @param id 身份证号码    // @param name 名字    public abstract void add(String id, String name);    //删除一条个人信息    // @param id 身份证号码    public abstract void remove(String id);    //更新一条个人信息    // @param id 身份证号码    // @param name 名字    public abstract void update(String id, String name);    //查询身份证对应的人名    // @param id 身份证号码    // @return 名字    public abstract String query(String id);}

对于每种持久化方式，我们都可以定义一个具体的IO处理类，这里就定义3种，分别是普通文件存储、xml文件存储和SQLite数据库存储：

//文件存储public class FileHandler extends IOHandler {    @Override    public void add(String id, String name) {        //业务逻辑    }    @Override    public void remove(String id) {        //业务逻辑    }    @Override    public void update(String id, String name) {        //业务逻辑    }    @Override    public void query(String id) {        //业务逻辑        return "AigeStudio";    }}//xml文件存储public class XMLHandler extends IOHandler {    @Override    public void add(String id, String name) {        //业务逻辑    }    @Override    public void remove(String id) {        //业务逻辑    }    @Override    public void update(String id, String name) {        //业务逻辑    }    @Override    public void query(String id) {        //业务逻辑        return "SMBrother";    }}//文件存储public class DBHandler extends IOHandler {    @Override    public void add(String id, String name) {        //业务逻辑    }    @Override    public void remove(String id) {        //业务逻辑    }    @Override    public void update(String id, String name) {        //业务逻辑    }    @Override    public void query(String id) {        //业务逻辑        return "Android";    }}

下面是简单的工厂实现：

public class IOFactory {    //获取IO处理者    // @param clz IOHandler 类型的class对象    // @return IOHandler 对象    public static <T extends IOHandler> T getIOHandler(Class<T> clz) {        IOHandler handler = null;        try {            handler = (IOHandler)Class.forName(clz.getName()).newInstance();        } catch(Exception e) {            e.printStackTrace();        }        return (T)handler;    }}

最后，我们在Activity中设置将从不同数据文件中查询得到的数据展示在一个TextView上：

public class FactoryActivity extends Activity {    @Override    protected void onCreate(Bundle saveInstanceState) {        super.onCreate(saveInstanceState);        setContentView(R.layout.activity_main);        ... ...        ... ...        final TextView tvContent = (TextView) findViewById(R.id.factory_content_tv);        //查询获取普通文件数据的按钮对象并设置监听        Button btnFile = (Button) findViewById(R.id.factory_file_btn);        btnFile.setOnClickListener(new View.OnClickListener() {            @Override            public void onCLick(View view) {                IOHandler handler = IOFactory.getIOHandler(FileHandler.class);                Log.d("AigeStudio", handler.query("4455645646"));                tvContent.setText(handler.query("4455645646"));            }        });        //获取查询xml文件数据的按钮对象并设置监听        Button btnXml = (Button) findViewById(R.id.factory_xml_btn);        btnXml.setOnClickListener(new View.OnClickListener() {            @Override            public void onCLick(View view) {                IOHandler handler = IOFactory.getIOHandler(XMLHandler.class);                tvContent.setText(handler.query("4455645646"));            }        });        //获取查询数据库数据的按钮对象并设置监听        Button btnDb = (Button) findViewById(R.id.factory_db_btn);        btnDb.setOnClickListener(new View.OnClickListener() {            @Override            public void onCLick(View view) {                IOHandler handler = IOFactory.getIOHandler(DBHandler.class);                tvContent.setText(handler.query("4455645646"));            }        });    }}