抽象工厂模式

Posted 2020-09-25 程姐

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

涉及到多个产品系列的问题，工厂方法模式组合叫抽象工厂模式。如下图涉及到大于1个的产品，Oracle、mysql两个产品。应用的具体工厂是由两种不同的数据库实现，可以很方便的切换两个数据库的访问的代码。

 

只是涉及到一个产品系列问题，才叫工厂方法模式。如下图 只涉及Leifeng这一产品

抽象工厂模式代码展示开始

Department类

package abstractFactory.dept;

public class Department {
    private long id;
    private String deptName;
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getDeptName() {
        return deptName;
    }
    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }
    
}

IDeptDao接口类

package abstractFactory.dept;

public interface IDeptDao {
    void insert(Department dept);
    void getDept(int id);
}

MysqlDeptDao类

package abstractFactory.dept;

public class MysqlDeptDao implements IDeptDao {

    @Override
    public void insert(Department dept) {
        System.out.println("在mysql数据库的department表插入一条记录");
    }

    @Override
    public void getDept(int id) {
        System.out.println("在mysql数据库的department表根据ID获取一条记录");
    }

}

OracleDeptDao类

package abstractFactory.dept;

public class OracleDeptDao implements IDeptDao {

    @Override
    public void insert(Department dept) {
        System.out.println("在oracle数据库的department表插入一条记录");
    }

    @Override
    public void getDept(int id) {
        System.out.println("在oracle数据库的department表根据ID获取一条记录");
    }

}

User类

package abstractFactory.user;

public class User {
    private long id;
    private String name;
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
}

 

IUserDao类

package abstractFactory.user;

public interface IUserDao {
    void insert(User user);
    void getUser(int id);
}

MysqlUserDao类

package abstractFactory.user;

public class MysqlUserDao implements IUserDao {

    @Override
    public void insert(User user) {
        System.out.println("在mysql数据库的user表插入一条记录");
    }

    @Override
    public void getUser(int id) {
        System.out.println("在mysql数据库的user表根据ID获取一条记录");
    }

}

OracleUserDao类

package abstractFactory.user;

public class OracleUserDao implements IUserDao {

    @Override
    public void insert(User user) {
        System.out.println("在oracle数据库的user表插入一条记录");
    }

    @Override
    public void getUser(int id) {
        System.out.println("在oracle数据库的user表根据ID获取一条记录");
    }

}

IFactory类

package abstractFactory;

import abstractFactory.dept.IDeptDao;
import abstractFactory.user.IUserDao;

public interface IFactory {
    IUserDao createUser();
    IDeptDao createDept();
}

MysqlFactory类

package abstractFactory;

import abstractFactory.dept.IDeptDao;
import abstractFactory.dept.MysqlDeptDao;
import abstractFactory.user.IUserDao;
import abstractFactory.user.MysqlUserDao;

public class MysqlFactory implements IFactory {

    @Override
    public IUserDao createUser() {
        return new MysqlUserDao();
    }

    @Override
    public IDeptDao createDept() {
        return new MysqlDeptDao();
    }

}

OracleFactory类

package abstractFactory;

import abstractFactory.dept.IDeptDao;
import abstractFactory.dept.OracleDeptDao;
import abstractFactory.user.IUserDao;
import abstractFactory.user.OracleUserDao;

public class OracleFactory implements IFactory {

    @Override
    public IDeptDao createDept() {
        return new OracleDeptDao();
    }

    @Override
    public IUserDao createUser() {
        return new OracleUserDao();
    }

}

Business类

package abstractFactory;

import abstractFactory.dept.Department;
import abstractFactory.dept.IDeptDao;
import abstractFactory.user.IUserDao;
import abstractFactory.user.User;

public class Business {

    public static void main(String[] args) {
        //产品1系列
        User user = new User();
        IFactory factory = new OracleFactory();
        //IFactory factory = new MysqlFactory();
        IUserDao iuDao = factory.createUser();
        iuDao.insert(user);
        iuDao.getUser(1);
        
        //产品2系列
        Department dept = new Department();
        IDeptDao idepatDao = factory.createDept();
        idepatDao.insert(dept);
        idepatDao.getDept(1);
        
    }

}

 抽象工厂模式的优点和缺点:

最大的好处就是易于交换产品系列，由于具体工厂类，例如：Ifactory factory = new OracleFactory()（或IFactory factory = new MysqlFactory()）,在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即使用不同的产品配置。

第二大好处：它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品得具体类名也被具体工厂的实现分离。（oracle还是mysql实现的就不知道，抽象接口IFactory的具体的工厂OracleFactory或MysqlFactory实现分离）

缺点：需求是增加功能，增加一个职责（job类），需要增加Job、IJobDao、MysqlJobDao、OracleJobDao这4个类（增加不可避免），同时还要修改IFactory、OracleFactory、MysqlFactory，才能增加职责。修改的类多，而且违反“开放-封闭原则”。