菜鸟之路：23种设计模式之——抽象工厂模式

最新推荐文章于 2024-08-05 14:57:08 发布

良月柒

最新推荐文章于 2024-08-05 14:57:08 发布

阅读量470

点赞数

分类专栏：设计模式文章标签：抽象工厂模式设计模式

本文链接：https://blog.csdn.net/lkp1603645756/article/details/81209315

版权

设计模式专栏收录该内容

23 篇文章 3 订阅

订阅专栏

什么是抽象工厂模式？

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

抽象工厂模式有哪些优点？

1、最大的好处便是易于交换产品系列，由于具体工厂类，在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同产品配置。

2、它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操作实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。

我们来看看抽象工厂模式的结构图：

如果项目使用的是MySQL数据，现在如果需要更换为Oracle数据，为了灵活更换数据库，如何设计程序呢？

接下来通过抽象工厂模式模仿数据访问程序。

抽象工厂模式实现：

构建两张数据库表的对应类，只声明，不做任何操作。

Name类：

/**
 * 作者：LKP
 * 时间：2018/7/25
 * 模拟User表
 */
public class User {
    //不做任何实现
}

Type类：

/**
 * 作者：LKP
 * 时间：2018/7/25
 * 模拟Type表
 */
public class Type {
    //不做任何操作
}

为两张表创建相应的实现类：

IUser接口，用于客户端访问，解除与具体数据库访问的耦合：

/**
 * 作者：LKP
 * 时间：2018/7/25
 */
public interface IUser {
    void Insert(User user);

    User getUser(int id);
}

IType接口，用于客户端访问，解除与具体数据库访问的耦合：

/**
 * 作者：LKP
 * 时间：2018/7/25
 */
public interface IType {
    void Insert(Type type);

    Type getType(int id);
}

MySQLUser类，用于访问MySQL的User表：

/**
 * 作者：LKP
 * 时间：2018/7/25
 * MySQL数据库的User表
 */
public class MySQLUser implements IUser {
    @Override
    public void Insert(User user) {
        System.out.println("在MySQL数据库中给User表增加了一条记录");
    }

    @Override
    public User getUser(int id) {
        System.out.println("在MySQL数据库中根据ID得到了User表一条记录");
        return null;
    }
}

OracleUser类，用于访问Oracle的User表：

/**
 * 作者：LKP
 * 时间：2018/7/25
 * Oracle数据库的User表
 */
public class OracleUser implements IUser {
    @Override
    public void Insert(User user) {
        System.out.println("在Oracle数据库中给User表增加了一条记录");
    }

    @Override
    public User getUser(int id) {
        System.out.println("在Oracle数据库中根据ID得到User表一条记录");
        return null;
    }
}

同理创建相应的MySQL和Oracle数据库的Type表。

MySQLType类，用于访问MySQL的Type表：

/**
 * 作者：LKP
 * 时间：2018/7/25
 * MySQL数据库的Type表
 */
public class MySQLType implements IType {
    @Override
    public void Insert(Type type) {
        System.out.println("在MySQL数据库中给Type表增加了一条记录");
    }

    @Override
    public Type getType(int id) {
        System.out.println("在MySQL数据库中根据ID得到了Type表一条记录");
        return null;
    }
}

OracleType类，用于访问Oracle的Type表：

/**
 * 作者：LKP
 * 时间：2018/7/25
 * Oracle数据库的Type表
 */
public class OracleType implements IType {
    @Override
    public void Insert(Type type) {
        System.out.println("在Oracle数据库中给Type表增加了一条记录");
    }

    @Override
    public Type getType(int id) {
        System.out.println("在Oracle数据库中根据ID得到Type表一条记录");
        return null;
    }
}

接下来再让我们构建一个IFactory接口，定义一个访问User表对象和Type对象的抽象的工厂接口。

/**
 * 作者：LKP
 * 时间：2018/7/25
 */
public interface IFactory {
    IUser CreateUser();     
    IType CreateType();
}

MySQLFactory类，实现IFactory接口，实例化MySQLUser和MySQLType。

/**
 * 作者：LKP
 * 时间：2018/7/25
 * MySQL抽象工厂
 */
public class MySQLFactory implements IFactory {
    @Override
    public IUser CreateUser() {
        return new MySQLUser();
    }

    @Override
    public IType CreateType() {
        return new MySQLType();
    }
}

OracleFactory类，实现IFactory接口，实例化OracleUser和OralceType。

/**
 * 作者：LKP
 * 时间：2018/7/25
 */
public class OracleFactory implements IFactory {
    @Override
    public IUser CreateUser() {
        return new OracleUser();
    }

    @Override
    public IType CreateType() {
        return new OracleType();
    }
}

客户端代码：

/**
 * 作者：LKP
 * 时间：2018/7/25
 * 客户端
 */
public class Client {
    public static void main(String[] args){
        User user = new User();
        Type type = new Type();

        IFactory factory = new MySQLFactory();
        //IFactory factory = new OracleFactory();

        IUser iu = factory.CreateUser();

        iu.Insert(user);
        iu.getUser(1);

        IType it = factory.CreateType();

        it.Insert(type);
        it.getType(1);

    }
}

只需确认实例化哪一个数据库访问对象给factory。

运行结果如下：