2.Java设计模式-----抽象工厂模式(Abstract Factory Pattern)

抽象工厂模式(Abstract Factory),是23种设计模式之一。抽象工厂模式是这样子定义的:

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

       在学习抽象工厂模式之前,最好熟悉简单工厂模式以及工厂方法模式,这样对理解抽象工厂模式会有一定帮助,而且抽象工厂模式是基于工厂方法模式而来的。如果你还没有了解到什么是简单工厂模式以及工厂方法模式,你可以去了解一下:1.大白话讲解-----工厂方法模式(Factory Pattern)     工厂模式------关心的是结果

       你可能看着上面的定义,一时无法理解它到底是什么意思。 你可以接着继续往下面看,看了这个实例,我相信你应该就能够理解上面这句话的含义了。

现在我们有一个新的需求:

        ①现在我有一套系统,系统里面分别用到了MySQL和Oracle数据库。

        ②我需要对这两套数据库进行相同的操作,比如:我要对MySQL和Oracle进行用户信息的相同操作(insert,get用户信息等)

现在既然已经有了相关的需求,那我们现在就可以来对该需求进行一些简单的分析:

        ①数据库两套:MySQL、Oracle

        ②分别要对两套数据库中的数据,都进行insert操作、get信息操作

接下来,我们就来按照我们平常的思路,来编写一下代码了。

①我们现在分别有两个类MySQLUser类、OracleUser类,然后类里都有insertUser()和getUser()方法来实现相关操作

//1.MySQLUser.java
public class MySQLUser {
    public void insertUser(){
        System.out.println("我是MySQL中的insert方法");
    }
    public void getUser(){
        System.out.println("我是MySQL中的getUser方法");
    }
}
//2.OracleUser.java
public class OracleUser {
    public void insertUser(){
        System.out.println("我是Oracle中的insertUser方法");
    }
    public void getUser(){
        System.out.println("我是Oracle中的getUser方法");
    }
}

然后我们在main方法中测试一下:

public class Test {
    public static void main(String[] args) {
        MySQLUser mysql = new MySQLUser();
        mysql.getUser();//打印结果:我是MySQL中的getUser方法
        mysql.insertUser();//打印结果:我是MySQL中的insert方法
        OracleUser oracle = new OracleUser();
        oracle.getUser();//打印结果:我是Oracle中的getUser方法
        oracle.insertUser();//打印结果:我是Oracle中的insertUser方法
    }
}

如上结果,完全可以实现我们的功能。但是,看上去确实有点太low了。如果我有10个乃至100个地方需要用到mysql对象,那么我每次都需要new MySQLUser()才能够获取到一个mysql对象,然后对其进行操作。借用工厂方法模式,我们可以来一个工厂方法Factory来帮助我们去创建mysql对象和oracle对象。

②接下来,我们可以将其进一步进行修改。

       1.从MySQLUser类和OracleUser类中抽取出一个IUser接口,接口包括insertUser()和getUser()抽象方法

       2.MySQLUser类和OracleUser类,分别实现IUser接口,然后重写insertUser()和getUser()方法

       3.创建MySQLFactory和OracleFactory工厂类,主要用来创建用户,从工厂类中可以抽取出一个IFactory接口,接口包括createUser()抽象方法

       4.MySQLFactory类和OracleFactory类,分别实现IFactory接口,并且重写createUser()方法

       5.进行测试

代码实现具体如下:

//1.IUser接口
public interface IUser {
    public void insertUser();
    public void getUser();
}
//2.1 MySQLUser类实现IUser
public class MySQLUser implements IUser {
    @Override
    public void insertUser(){
        System.out.println("我是MySQL中的insert方法");
    }
    @Override
    public void getUser(){
        System.out.println("我是MySQL中的getUser方法");
    }
}
//2.2 OracleUser类实现IUser
public class OracleUser implements IUser {
    @Override
    public void insertUser(){
        System.out.println("我是Oracle中的insertUser方法");
    }
    @Override
    public void getUser(){
        System.out.println("我是Oracle中的getUser方法");
    }
}
//3.IFactory接口
public interface IFactory {
    public IUser createUser();
}
//4.1 MySQLFactory类实现IFactory 
public class MySQLFactory implements IFactory {
    @Override
    public IUser createUser() {
        return new MySQLUser();
    }
}
//4.2 OracleFactory类实现IFactory 
public class OracleFactory implements IFactory {
    @Override
    public IUser createUser() {
        return new OracleUser();
    }
}
//5.测试
public class Test01 {
    public static void main(String[] args) {
        IFactory factory = new MySQLFactory();
        IUser user = factory.createUser();
        user.insertUser(); //打印结果:我是MySQL中的insert方法
        user.getUser();//打印结果:我是MySQL中的getUser方法
    }
}

       如果现在我不用MySQL了,目前要换成Oracle,则只需要将new MySQLFactory()换成new OracleFactory()即可。你会发现这完全就是工厂方法模式。对的。就是工厂方法模式的实现。我们开头就说到:抽象工厂模式是基于工厂方法模式而来的。接下来,我们再继续向着抽象工厂模式继续演进吧

③现在我们又有了新的需求:

          现在MySQL和Oracle中,都有一张日志Log表,我们在insertUser之后,都要向日志表中添加一条数据

    现在我们来对这个需求进行一下简单的分析:

          1.之前MySQLUser和OracleUser分别有一个insertUser()和getUser()方法,目前它们都需要往日志表中添加日志

          2.所以我们现在抽取出一个ILog接口,接口中有一个insertLog()抽象方法

          3.新建一个MySQLLog类和OracleLog类,分别实现ILog接口,然后重写insertLogr()方法

          4.之前IFactory接口已有createUser()功能的情况下,在该接口中新增一个createLog()抽象方法,来满足插入日志的功能

          5.MySQLFactory类和OracleFactory类,因为实现了IFactory接口,需要重写createLog()方法

          6.开启测试

//2.ILog接口
public interface ILog {
    public void insertLog();
}
//3.1 MySQLLog实现ILog接口
public class MySQLLog implements ILog {
    @Override
    public void insertLog() {
        System.out.println("我是MySQL中的insertLog方法");
    }
}
//3.2 OracleLog实现ILog接口
public class OracleLog implements ILog {
    @Override
    public void insertLog() {
        System.out.println("我是Oracle中的insertLog方法");
    }
}
//4.IFactory接口新增createLog()方法
public interface IFactory {
    public IUser createUser();
    public ILog createLog();
}
//5.1 MySQLFactory工厂类重写新增的createLog()方法
public class MySQLFactory implements IFactory {
    @Override
    public IUser createUser() {
        return new MySQLUser();
    }
    @Override
    public ILog createLog() {
        return new MySQLLog();
    }
}
//5.2 OracleFactory工厂类重写新增的createLog()方法
public class OracleFactory implements IFactory {
    @Override
    public IUser createUser() {
        return new OracleUser();
    }
    @Override
    public ILog createLog() {
        return new OracleLog();
    }
}
//6.开启测试
public class Test02 {
    public static void main(String[] args) {
        IFactory factory = new MySQLFactory();
        IUser mysql = factory.createUser();
        mysql.getUser(); //打印结果:我是MySQL中的getUser方法

        ILog log = factory.createLog();
        log.insertLog(); //打印结果:我是MySQL中的insertLog方法
    }
}

④我们现在有个改变,就是说在③中第6步测试中,我们现在业务要废弃MySQL而使用Oracle了,现在我们只需要将第6步中的new MySQLFactory() 换成 new OracleFactory()即可。而无需改动其他代码,就能够解决业务的变动,这就已经明显解决了与具体数据库之间的耦合关系

⑤如果我们现在又要换成SqlServer呢。则我们现在只需要实现如下几步,即可满足要求

         1.创建一个SqlServerUser,来实现已写好的IUser接口,并重写其中的insertUser()和getUser()方法。

         2.创建一个SqlServerFactory,实现已写好的IFactory接口,并重写其中的createUser()方法。

         3.在③中第6步测试中,直接将new MySQLFactory()换成new SqlServerFactory()即可。

         4.这样就可以最大程度上解决功能与业务代码之间的耦合,将修改工作量降到最低。

⑥实际上我们这次代码的重构中,已经使用到了抽象工厂模式,抽象工厂可能表面上看起来貌似与工厂方法模式没什么区别的。所以,抽象工厂模式是基于工厂方法模式而来的。现在你在重头来看一下抽象工厂模式的定义:抽象工厂模式,提供一个创建一系列相关或互相依赖对象的接口,而无需指定它们具体的类。你也许可能就会有所体会

⑦在该实例中,你完全可以理解成是多个工厂方法的组合。

⑧抽象工厂模式的优点:

        1.方便交换产品系列,诸如在本实例中,如果现在业务需求需要将MySQL替换为Oracle或者SqlServer,你只需要将new MySQLFactory()替换为new OracleFactory()或者new SqlServerFactory()即可满足要求。这样可以在保证在最小改动的情况下而完成对整体业务的修改,起到了最大程度的解耦操作。

        2.在实现过程(xxxFactory类中)和具体使用中(测试类中),我们通过向上造型用到IFactory,IUser,ILog类,我们在具体使用中就用到了上面三个类,我们通过factory.createUser()来创建用户,通过factory.createLog()来插入日志。如果没有new xxxFactory()的话,我们完全不知道我们是在操作哪个类型的数据库,从而达到了实现类和使用之间的隔离。

⑨抽象工厂模式的缺点:

         在我们每次需要createUser和createLog的时候,我们都需要通过IFactory factory = new xxxFactory();来获取到factory对象,然后对其进行相关的操作。如果我现在有100个地方需要使用,则需要来100次new操作,这显然是太扯淡了。这算的上一个缺点吧。

⑩面对⑨中的缺点,我们该如何解决这种问题?

       我们可以使用反射机制来解决,可以参考1.大白话讲解-----工厂方法模式(Factory Pattern)中的⑩部分来做出修改,这就是抽象工厂方法了。

附:全文实例结构图:

2.Java设计模式-----抽象工厂模式(Abstract Factory Pattern)_第1张图片

Demo实例地址: https://download.csdn.net/download/lzb348110175/11147854

---->如有疑问,请发表评论,或者联系博主:[email protected],欢迎哦^_^

 

你可能感兴趣的:(设计模式)