案例：抽象工厂DatabaseFactory，实现mysql和hbase数据和java的交互读写方法封装（23种设计模式之一）

图示

AbstractDatabaseFactory类

/**
 * 这是一个抽象工厂
 */
public abstract class AbstractDatabaseFactory<T> {
    // 获得抽象产品的接口
    public abstract DatabaseReaderAndWrite<T> buildReaderAndWriter();
}

DatabaseReaderAndWrite类

/**
 * 抽象产品接口，主要是对数据库的读写接口
 */
public interface DatabaseReaderAndWrite<T> {
    /**
     * 单项插入
     * @param t
     */
    public void writer(T t);

    /**
     * 批量插入
     * @param lst
     */
    public void writer(List<T> lst);

    /**
     * 读取用户传入的命令或sql语句，完成解析后对应的结果转为list集合
     * @param sql
     * @return
     */
    public List<T> reader(String sql,Class cls);
}

MySqlDatabaseFactory类：

mysql具体工程，继承AbstractDatabaseFactory

/**
 * 连接mysql数据库具体工厂
 * @param <T>
 */
public class MySqlDatabaseFactory<T> extends AbstractDatabaseFactory<T> {
    private Configuration config;
    public MySqlDatabaseFactory(Configuration cfg) {
        this.config = cfg;
    }

    private Connection createConnection() {
        Connection conn =null;
        try {
            Class.forName(config.get("dirver"));
            conn = DriverManager.getConnection(config.get("url"), config.get("username"), config.get("password"));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }

    /**
     *
     * @return mysql抽象工厂产生具体产品
     */
    @Override
    public DatabaseReaderAndWrite<T> buildReaderAndWriter() {
        return new MySqlRWHandler<T>(createConnection());
    }
}

HbaseDatabasefactory类

hbase具体工程，继承AbstractDatabaseFactory

/**
 * hbase数据库具体工厂
 * @param <T>
 */
public class HbaseDatabaseFactory<T> extends AbstractDatabaseFactory<T>{
    private Configuration config;
    public HbaseDatabaseFactory(Configuration cfg) {
        this.config = cfg;
    }

    private Connection createConnection() {
        org.apache.hadoop.conf.Configuration conf = HBaseConfiguration.create();
        // 用户提供配置变量
        conf.set("hbase.zookeeper.quorum",config.get("hbase.zookeeper.quorum"));
        conf.set("hbase.zookeeper.property.clientPort",config.get("hbase.zookeeper.property.clientPort")==null?"2181"
                :config.get("hbase.zookeeper.property.clientPort"));
        conf.set("hbase.master",config.get("hbase.master")==null?conf.get("hbase.zookeeper.quorum")+"60000"
                :config.get("hbase.master"));
        Connection connection = null;
        try {
            connection = ConnectionFactory.createConnection(conf);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return connection;
    }

    @Override
    public DatabaseReaderAndWrite<T> buildReaderAndWriter() {
        return new HbaseRWHandler<T>(createConnection());
    }
}

Builderfactory类

如果选择0则是hbase工程，1则是mysql工程

/**
 * 工厂建造者
 */
public class BuilderFactory {
    private BuilderFactory(){}
    public static final int HBASE=0;
    public static final int MYSQL=1;

    public static AbstractDatabaseFactory builder(Configuration cfg,int databaseType) {
        switch (databaseType) {
            case 0:
                return new HbaseDatabaseFactory(cfg);
            case 1:
                return new MySqlDatabaseFactory(cfg);
            default:
                return null;
        }
    }
}

Configuration类

配置文件是键值对的格式，所以放入hashmap里

/**
 * 用户的连接数据库的信息配置类
 */
public class Configuration {
    private Map<String,String> properties = new HashMap<>();

    public void set(String key, String prop) {
        properties.put(key,prop);
    }

    public static Configuration create() {
        return new Configuration();
    }

    public String get(String key) {
        return properties.get(key);
    }
}

HbaseRWHandler类

实现了DatabaseReaderAndWrite接口类

/**
 * Hbase数据库读写操作的具体产品
 * @param <T>
 */
public class HbaseRWHandler<T> implements DatabaseReaderAndWrite<T> {
    private Connection conn;
    public HbaseRWHandler(Connection con) {this.conn = con;}
    
    @Override
    public void writer(T t) {}

    @Override
    public void writer(List<T> lst) {}

    @Override
    public List<T> reader(String sql,Class cls) {return null;}
}

MySqlRWHandler类

实现了DatabaseReaderAndWrite接口类

/**
 * MySqlRwHandler是mysql的读写的具体实现（具体产品）
 * @param <T>
 */
public class MySqlRWHandler<T> implements DatabaseReaderAndWrite<T>{
    private Connection conn;
    public MySqlRWHandler(Connection con) {this.conn = con;}
    
    @Override
    public void writer(T t) {}

    @Override
    public void writer(List<T> lst) {}

    @Override
    public List<T> reader(String sql,Class cls) {
        return null;
    }
}

测试结果

public class Demo {
    public static void main(String[] args) {
        Configuration cfg = Configuration.create();
        cfg.set("hbase...quorum","192.168.56.100");
        AbstractDatabaseFactory factory = BuilderFactory.builder(cfg, BuilderFactory.HBASE);
        DatabaseReaderAndWrite rw = factory.buildReaderAndWriter();
        rw.reader("scan 'mydemo:userinfos',Filter=>'ValueFilter(=,substring:zhang)'",String.class);
//        cfg.set("driver","com.mysql.jdbc.Driver");
//        cfg.set("url","jdbc:mysql://localhost:3306/mydemo");
//        cfg.set("username","root");
//        cfg.set("password","ok");
//        AbstractDatabaseFactory factory = BuilderFactory.builder(cfg, BuilderFactory.MYSQL);
//        DatabaseReaderAndWrite rw = factory.buildReaderAndWriter();
//        List<Userinfos> reader = rw.reader("select * from userinfos", Userinfos.class);

    }
}