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

工厂方法模式介绍

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

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

使用场景

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

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

//抽象产品类
public abstract class Product {
    //产品类的抽象方法 由具体实现类去实现
    public abstract void method();
}

//具体产品类A
public class ConcreteProductA extends Product {
    @Override
    public void method() {
        System.out.println("我是具体产品A");
    }
}

//具体产品类B
public 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();

    }
}

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

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


//具体工厂类 B
public 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();
}

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

//具体车型AudiQ5
public class AudiQ5 extends AudiCar {
    @Override
    public void drive() {
        System.out.println(" Q5 启动啦！");
    }
    @Override
    public void selfNavigation() {
        System.out.println(" Q5 开始自动巡航啦！");
    }
}
//具体车型AudiQ7
public 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"));
            }
        });


    }

}