多数据库切换?设计模式--抽象工厂引导下思路

缘起

某日,部门Leader找到小明:“小明,我们公司不是用的SQL Server的数据库吗,但是后面可能会改,比如去使用Access或Mysql或其他的,你觉得该怎么去设计这个代码呢?”

小明一脸所思,陷入了思考中…

Leader:“或者你先这样,先把最基本的访问数据库的示例写一下。”

小明听后,几分钟后代码出炉。

User类

public class User {
    
    private int id;
    private String name;
	..getter/setter
}

SqlServerUser类,用于操作User表,假设只有新增用户和查询用户的方法。

public class SqlServerUser {
    
    public void insert(User user) {
        System.out.println("Sql server插入了一条用户数据");
    }
    
    public void getUser(int id) {
        System.out.println("Sql server查询一条用户数据");
    }
    
}
  • 客户端调用
User user = new User();
SqlServerUser sqlServerUser = new SqlServerUser();
sqlServerUser.insert(user);

sqlServerUser.getUser(1);

改造

Leader:“你看这里,是不是最基本的实现了Sql server数据库的操作,假如换成别的你还要改一大堆对吧,那么你是不是可以把每个数据库的操作都封装起来呢,而且它们所有数据库执行的操作结果都是一致的。当我需要哪个数据库的操作时,就实例化哪个数据库的实例去使用就完事儿了”

小明听后,立即想到了之前的工厂模式。

多数据库切换?设计模式--抽象工厂引导下思路_第1张图片

  • IUser接口:用户客户端访问,解除与具体数据库访问的耦合
public interface IUser {
    void insert(User user);
    User getUser(int id);
}
  • SqlServerUser:用于访问Sqlserver的User
public class SqlServerUser implements IUser{

    public void insert(User user) {
        System.out.println("Sql server插入了一条用户数据");
    }
    public User getUser(int id) {
        System.out.println("Sql server查询一条用户数据");
        return null;
    }
}
  • AccessUser:用于Access的User
public class AccessUser implements IUser{

    public void insert(User user) {
        System.out.println("Access插入了一条用户数据");
    }
    public User getUser(int id) {
        System.out.println("Access查询一条用户数据");
        return null;
    }
}
  • IFactory:定义一个创建访问User表对象的抽象的工厂接口
public interface IFactory {

    IUser createUser();
}
  • SqlserverFactory:实现IFactory接口,实例化SqlServerUser
public class SqlServerFactory implements IFactory {
    @Override
    public IUser createUser() {
        return new SqlServerUser();
    }
}
  • AccessFactory:实现IFactory接口,实例化AccessUser
public class AccessFactory implements IFactory {

    @Override
    public IUser createUser() {
        return new AccessUser();
    }
}
  • 客户端调用
User user = new User();
IFactory factory = new SqlServerFactory();
IUser iUser = factory.createUser();

iUser.insert(user);
iUser.getUser(1);

再增部门

Leader看后,点了点头,“假如我再新增一个部门表的数据库操作呢”

小明继续编码中。。。

  • 部门
public class Dept {
    private int id;
    private String name;
}
  • IDept
public interface IDept {
    void insert(Dept dept);
    Dept getDept(int id);
}
  • SqlserverDept:访问Sqlserver的部门数据
public class SqlServerDept implements IDept{

    @Override
    public void insert(Dept dept) {
        System.out.println("Sqlserver 新增一条部门数据");
    }

    @Override
    public Dept getDept(int id) {
        System.out.println("Sqlserver查询一条部门数据");
        return null;
    }
}
  • AccessDept
public class AccesssDept implements IDept{

    @Override
    public void insert(Dept dept) {
        System.out.println("Access 新增一条部门数据");
    }

    @Override
    public Dept getDept(int id) {
        System.out.println("Access查询一条部门数据");
        return null;
    }
}
  • IFactory
public interface IFactory {

    IUser createUser();

    IDept createDept();
}
  • SqlServerFactory
public class SqlServerFactory implements IFactory {

    @Override
    public IUser createUser() {
        return new SqlServerUser();
    }

    @Override
    public IDept createDept() {
        return new SqlServerDept();
    }
}
  • AccessFactory
public class AccessFactory implements IFactory {

    @Override
    public IUser createUser() {
        return new AccessUser();
    }

    @Override
    public IDept createDept() {
        return new AccesssDept();
    }
}
  • 客户端
User user = new User();
IFactory factory = new SqlServerFactory();
IUser iUser = factory.createUser();

iUser.insert(user);
iUser.getUser(1);

IDept dept = factory.createDept();
dept.insert(new Dept());
dept.getDept(1);

Leader:“很好,这样子后面如果有很多表,也只需要多增加一些类就行了,只要能把代码灵活性提高,多增加一些类也没有啥问题。”

而且你这种代码结构实际是使用了一种抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

像上面我们的IUser和IDept其实就是两中产品的抽象,那么实际的SqlServerUser、SqlServerDept、AccessUser、AccessDept就是他们的具体分类的实现。IUser和IDept实际就是两种不同的产品分类,然后具体的产品实现由子类进行衍生。

IFactory类就是我们的抽象工厂类了,它里面应该包含所有的产品创建的抽象方法。那么SqlserverFactory和AccessFactory就是两种产品的工厂,具体生成哪种产品由它们来决定。

优缺点

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

缺点:显而易见,每次如果有一个新的表,至少需要增加三个类,而且还需要改动至少三处。这样大批量的改动显然是非常丑陋的做法。

简单工厂改进抽象工厂

多数据库切换?设计模式--抽象工厂引导下思路_第2张图片

直接去除IFatory和子Factory,用DataAccess取而代之它们。

public class DataAccess { 
    private static String db = "Sqlserver";
    public static IUser createUser() {
        IUser res = null;
        switch (db) {
            case "Sqlserver":
                res = new SqlServerUser();
                break;
            case "Access":
                res = new AccessUser();
                break;
        }
        return res;
    }
    public static IDept createDept() {
        IDept res = null;
        switch (db) {
            case "Sqlserver":
                res = new SqlServerDept();
                break;
            case "Access":
                res = new AccesssDept();
                break;
        }
        return res;
    }
}
  • 客户端
User user = new User();
IUser iUser = DataAccess.createUser();

iUser.insert(user);
iUser.getUser(1);

IDept dept = DataAccess.createDept();
dept.insert(new Dept());
dept.getDept(1);

客户端中没有出现一个Sqlserver或Access的字样,将耦合度降到最低。

Tips:在DataAccess类中db字段若不想硬编码到代码中,可以在项目资源文件夹中创建一个文件,读取文件的db属性,使用反射的方式动态生成需要的SqlserverUser或其他产品对象。

你可能感兴趣的:(设计模式,Java,数据库,设计模式)