精华内容
下载资源
问答
  • 抽象工厂 数据库
    2021-10-28 22:51:14

    1、抽象工厂模式:提供一个创建对象的接口IFactory ,该接口中定义了一个的创建对象的方法createUser(),这个方法的返回值是接口类型,当在客户端创建了IFactory接口的某个实现类的实例instance之后,就可以调用IFactory 接口中的创建对象的方法,返回对象实例user
    比如:
    IFactory instance= new MySqlFactory();

    IFactory instance= new OracleFactory();
    IUser user = instance.createUser();
    由于我们在IFactory 中声明方法时用的返回值类型是一个接口类型,所以就可以用接口类型IUser接收对象实例user,这时我们可以发现:IFactory的实例instance可以是MySQL类型的也可以是Oracle类型的,所以调用创建对象的方法instance.createUser()时就可以创建出MySQL类型的实例或者是Oracle类型的实例,然后可以继续调用MySQL类型对象的各种方法或Oracle类型对象的各种方法。这样就是实现了数据库的切换,值得注意的是:在整个切换过程中,我们只需更改一行代码
    2、优点:对于多个系列的产品,可以在客户端通过抽象接口去创建不同系列的实例,而每种实例底层的逻辑全部被封装在服务端,这样客户端看上去只改了一行代码而已。
    3、缺点
    (1) 在每一个类中都需要一句: IFactory instance= new MySqlFactory();,如果我们有1000个这样的类那是不是要new上1000次呢?
    (2) 尽管如此我们还是要在客户端改一行代码,那可不可以实现不改代码就切换数据库呢?(tips:可以通过反射+简单工厂模式实现在配置文件中切换数据库,将编译期创建对象转化为运行时期创建对象,这样就可以避免更改代码了,请看文末。。。)

    package 创建型模式.工厂模式.抽象工厂模式.AbstractFactory;
    import 创建型模式.工厂模式.抽象工厂模式.department.IDepartment;
    import 创建型模式.工厂模式.抽象工厂模式.user.IUser;
    
    /**
     * @Author: lxpStu
     * @Date: 2021/10/28/21:55
     * @Description: 创建不同对象的抽象工厂接口
     */
    public interface IFactory {
        /**
         * 创建用户表
         * @return 接口类型IUser
         */
        IUser createUser();
    
        /**
         * 创建部门表
         * @return 接口类型IDepartment
         */
        IDepartment createDepartment();
    }
    
    package 创建型模式.工厂模式.抽象工厂模式.AbstractFactory.impl;
    import 创建型模式.工厂模式.抽象工厂模式.AbstractFactory.IFactory;
    import 创建型模式.工厂模式.抽象工厂模式.department.IDepartment;
    import 创建型模式.工厂模式.抽象工厂模式.department.impl.MySqlDepartment;
    import 创建型模式.工厂模式.抽象工厂模式.user.IUser;
    import 创建型模式.工厂模式.抽象工厂模式.user.impl.MySqlUser;
    
    /**
     * @Author: lxpStu
     * @Date: 2021/10/28/22:10
     * @Description: MySQL数据库的对象工厂
     */
    public class MySqlFactory implements IFactory {
    
        @Override
        public IUser createUser() {
            return new MySqlUser();
        }
    
        @Override
        public IDepartment createDepartment() {
            return new MySqlDepartment();
        }
    }
    
    package 创建型模式.工厂模式.抽象工厂模式.AbstractFactory.impl;
    
    import 创建型模式.工厂模式.抽象工厂模式.AbstractFactory.IFactory;
    import 创建型模式.工厂模式.抽象工厂模式.department.IDepartment;
    import 创建型模式.工厂模式.抽象工厂模式.department.impl.OracleDepartment;
    import 创建型模式.工厂模式.抽象工厂模式.user.IUser;
    import 创建型模式.工厂模式.抽象工厂模式.user.impl.OracleUser;
    
    /**
     * @Author: lxpStu
     * @Date: 2021/10/28/22:12
     * @Description: Oracle数据库的对象工厂
     */
    public class OracleFactory implements IFactory {
        @Override
        public IUser createUser() {
            return new OracleUser();
        }
    
        @Override
        public IDepartment createDepartment() {
            return new OracleDepartment();
        }
    }
    
    package 创建型模式.工厂模式.抽象工厂模式.department;
    
    /**
     * @Author: lxpStu
     * @Date: 2021/10/28/22:00
     * @Description: 部门表接口
     */
    public interface IDepartment {
    
        /**
         * 部门表的插入方法
         */
        void insert();
    }
    
    package 创建型模式.工厂模式.抽象工厂模式.department.impl;
    import 创建型模式.工厂模式.抽象工厂模式.department.IDepartment;
    
    /**
     * @Author: lxpStu
     * @Date: 2021/10/28/22:08
     * @Description: MySQL数据库的部门表
     */
    public class MySqlDepartment implements IDepartment {
        @Override
        public void insert() {
            System.out.println("向MySQL数据库中的部门表中插入一条数据");
        }
    }
    
    package 创建型模式.工厂模式.抽象工厂模式.department.impl;
    import 创建型模式.工厂模式.抽象工厂模式.department.IDepartment;
    
    /**
     * @Author: lxpStu
     * @Date: 2021/10/28/22:08
     * @Description: MySQL数据库的部门表
     */
    public class OracleDepartment implements IDepartment {
        @Override
        public void insert() {
            System.out.println("向Oracle数据库中的部门表中插入一条数据");
        }
    }
    
    package 创建型模式.工厂模式.抽象工厂模式.user;
    
    /**
     * @Author: lxpStu
     * @Date: 2021/10/28/21:57
     * @Description: 用户表接口
     */
    public interface IUser {
    
        /**
         * 用户表的插入数据方法
         */
        void insert();
    }
    
    package 创建型模式.工厂模式.抽象工厂模式.user.impl;
    import 创建型模式.工厂模式.抽象工厂模式.user.IUser;
    
    /**
     * @Author: lxpStu
     * @Date: 2021/10/28/22:04
     * @Description: MySQL 数据库下的User表
     */
    public class MySqlUser implements IUser {
    
        @Override
        public void insert() {
            System.out.println("向MySQL数据库的User表中插入一条数据");
        }
    }
    
    package 创建型模式.工厂模式.抽象工厂模式.user.impl;
    import 创建型模式.工厂模式.抽象工厂模式.user.IUser;
    
    /**
     * @Author: lxpStu
     * @Date: 2021/10/28/22:06
     * @Description: Oracle数据库下的User表
     */
    public class OracleUser implements IUser {
        @Override
        public void insert() {
            System.out.println("向Oracle数据库的User表中插入一条数据");
        }
    }
    
    package 创建型模式.工厂模式.抽象工厂模式;
    import 创建型模式.工厂模式.抽象工厂模式.AbstractFactory.IFactory;
    import 创建型模式.工厂模式.抽象工厂模式.AbstractFactory.impl.MySqlFactory;
    import 创建型模式.工厂模式.抽象工厂模式.AbstractFactory.impl.OracleFactory;
    import 创建型模式.工厂模式.抽象工厂模式.department.IDepartment;
    import 创建型模式.工厂模式.抽象工厂模式.user.IUser;
    
    /**
     * @Author: lxpStu
     * @Date: 2021/10/28/22:14
     * @Description: 模拟客户端测试类
     *
     * 可以发现测试代码中只有第23行和第30行代码不同,其余地方全部相同
     */
    public class Main {
        public static void main(String[] args) {
    
            IFactory factory = null;
            IUser user = null;
            IDepartment dept = null;
    
            factory = new MySqlFactory();
            user = factory.createUser();
            user.insert();
            dept = factory.createDepartment();
            dept.insert();
    
            factory = new OracleFactory();
            user = factory.createUser();
            user.insert();
            dept = factory.createDepartment();
            dept.insert();
        }
    }
    
    

    改为反射+配置文件实现修改配置文件切换数据库

    //配置文件:db.properties
    className=DB.changeDB.user.impl.MySqlUser
    methodName=insert
    //测试代码
      public static void main(String[] args) throws Exception {
    
            Properties pro = new Properties();
            InputStream in = Main.class.getClassLoader().getResourceAsStream("db.properties");
            pro.load(in);
            String className = pro.getProperty("className");
            String methodName = pro.getProperty("methodName");
    
            Class clz = Class.forName(className);
            Object o = clz.newInstance();
            Method method = clz.getMethod(methodName);
            method.invoke(o);
        }
     // 输出
    C:\java\java8\jdk\bin\java.exe...MySQL数据库的User表中插入一条数据
    
    Process finished with exit code 0
    
    更多相关内容
  • NULL 博文链接:https://walleyekneel.iteye.com/blog/1113114
  • 反射机制与抽象工厂结合多数据库模型源码.zip
  • 自己这2天写的一个 关于抽象工厂的例子 Mysql --Oracle 之间转换 希望对大家有帮助 JAVA语言写的
  • 用C#抽象工厂编写的完整项目案例,项目虽小,但绝对正确无误,正常运行。内含数据库文件。适合帮助初学者了解抽象工厂项目的编程思想和项目架构
  • 本人做了一个抽象工厂的小案例,只要修改配置文件,就可以轻松的切换数据库,里面附有ACCESS数据库,不需要配置 sql数据库附加上去就好了,修改配置连接 就可以轻松切换 数据库 如有问题请联系qimenglin_aptech@163.com ...
  • 文章目录抽象工厂模式一、模式动机二、模式结构类图二、数据库操作工厂类图代码三、优缺点优点缺点五、适用性 一、模式动机 为了更清晰地理解抽象工厂方法模式,需引入两个概念: 产品等级结构:产品等级结构即...

    抽象工厂模式


    一、模式动机

    为了更清晰地理解抽象工厂方法模式,需引入两个概念:

    • 产品等级结构:产品等级结构即产品的继承结构,如一个抽象类是电视机,其子类有海尔电视机、海信电视机、TCL电视机,则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构,抽象电视机是父类,而具体品牌的电视机是其子类

    • 产品族:在抽象工厂模式中,产品族是指由同一个工厂生产的,位于不同产品等级结构中的一组产品,如海尔电器工厂生产的海尔电视机、海尔电冰箱,海尔电视机位于电视机产品等级结构中,海尔电冰箱位于电冰箱产品等级结构中

    当系统所提供的工厂所需生产的具体产品并不是一个简单的对象,而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式。

    抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。

    抽象工厂模式与工厂方法模式最大的区别在于,工厂方法模式针对的是一个产品等级结构,而抽象工厂模式则需要面对多个产品等级结构,一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建 。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时,抽象工厂模式比工厂方法模式更为简单、有效率。

    二、模式结构

    抽象工厂模式包含四个角色

    • 抽象工厂用于声明生成抽象产品的方法

    • 具体工厂实现了抽象工厂声明的生成抽象产品的方法,生成一组具体产品,这些产品构成了一个产品族,每一个产品都位于某个产品等级结构中

    • 抽象产品为每种产品声明接口,在抽象产品中定义了产品的抽象业务方法

    • 具体产品定义具体工厂生产的具体产品对象,实现抽象产品接口中定义的业务方法

    类图

    在这里插入图片描述

    二、数据库操作工厂

    ​ 某系统为了改进数据库操作的性能,自定义数据库连接对象Connection和语句对象Statement,可针对不同类型的数据库提供不同的连接对象和语句对象,如提供Oracle或SQL Server专用连接类和语句类,而且用户可以通过配置文件等方式根据实际需要动态更换系统数据库。使用抽象工厂模式设计该系统。

    类图

    在这里插入图片描述

    代码
    /*** AbstractProduct ***/
    interface Connection{    //连接
        public abstract void getConnection();
    }
    
    interface Statement{     //声明
        public abstract void getSatement();
    }
    
    /*** Product ***/
    class MysqlConnection implements Connection{
        public void getConnection(){
            System.out.println("MysqlConnection~");
        }
    }
    
    class OracleConnection implements Connection{
        public void getConnection(){
            System.out.println("OracleConncetion~");
        }
    }
    
    class MysqlStatement implements Statement{
        public void getStatement(){
            System.out.println("MysqlStatement~");
        }
    }
    
    class OracelStatement implements Statement{
        public void getStatement(){
            System.out.println("OracelStatement~");
        }
    }
    
    /*** AbstractFactory ***/
    interface AbstractFactory{
        public abstract Connection creatConnection();
        public abstract Statement  creatStatement();
    }
    
    /*** Factory ***/
    class MysqlFactory implements AbstractFactory{
        public Connection creatConnetion(){
            return (new MysqlConnection());
        }
        public Statement creatStatement(){
            return (new MysqlStatement());
        }
    }
    
    class OracleFactory implements AbstractFactory{
        public Connection creatConnection(){
            return (new OracleConnection());
        }
        public Statement creatStatement(){
            return (new OracleStatement());
        }
    }
    
    /*** main ***/
    public static void main(String[] args){
        System.out.println("---MysqlProduct---");
        AbstractFactory mysqlFactory = new MysqlFactory();
        Connection mysqlConnection = mysqlFactory.creatConnection();
        Statement  mysqlStatement  = mysqlFactory.creatStatement();
        mysqlConnection.getConnction();
        mysqlStatement.getStatement();
        
        System.out.println("---OracleProduct---");
        AbstractFactory oracleFactory = new OracleFactory();
        Connection oracleConnection = orcaleFactory.creatConnection();
        Statement  oracleStatement  = oracleFactory.creatStatement();
        oracleConnection.getConnection();
        oracleStatement.getSatement();
    }
    

    三、优缺点

    优点
    • 抽象工厂模式隔离了具体类的生成,使得客户并不需要知道什么被创建。由于这种隔离,更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口,因此只需改变具体工厂的实例,就可以在某种程度上改变整个软件系统的行为。另外,应用抽象工厂模式可以实现高内聚低耦合的设计目的,因此抽象工厂模式得到了广泛的应用
    • 当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说,是一种非常实用的设计模式
    • 增加新的具体工厂和产品族很方便,无须修改已有系统,符合**“开闭原则”**
    缺点
    • 在添加新的产品对象时,难以扩展抽象工厂来生产新种类的产品,这是因为在抽象工厂角色中规定了所有可能被创建的产品集合,要支持新种类的产品就意味着要对该接口进行扩展,而这将涉及到对抽象工厂角色及其所有子类的修改,显然会带来较大的不便
    • 开闭原则的倾斜性(增加新的工厂和产品族容易,增加新的产品等级结构麻烦
    五、适用性
    • 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有类型的工厂模式都是重要的
    • 系统中有多于一个的产品族,而每次只使用其中某一产品族
    • 属于同一个产品族的产品将在一起使用,这一约束必须在系统的设计中体现出来
    • 系统提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于具体实现
    展开全文
  • 主要介绍了PHP设计模式之抽象工厂模式,结合实例形式分析了php抽象工厂模式的概念、原理、使用方法及相关操作注意事项,需要的朋友可以参考下
  • 前言:本文需对反射和抽象工厂模式有一定了解。 了解->Java反射 了解->抽象工厂模式 IUser接口 public interface IUser { void Insert(User user); User getUser(String id); } SqlserverUser public ...

    前言:本文需对反射和抽象工厂模式有一定了解。
    了解->Java反射
    了解->抽象工厂模式
    在这里插入图片描述
    IUser接口

    public interface IUser {
     void Insert(User user);
     User getUser(String id);
    }
    

    SqlserverUser

    public class SqlserverUser implements IUser {
    
    	@Override
    	public void Insert(User user) {
    		System.out.println("在SqlserverUser中插入一条数据");
    	}
    
    	@Override
    	public User getUser(String id) {
    		System.out.println("在SqlserverUser中查询一条数据");
    		return null;
    	}
    
    }
    

    AccessUser

    public class AccessUser implements IUser {
    
    	@Override
    	public void Insert(User user) {
    		System.out.println("在AccessUser中插入一条数据");
    		
    	}
    
    	@Override
    	public User getUser(String id) {
    		System.out.println("在AccessUser中查询一条数据");
    		return null;
    	}
    
    }
    

    IDepartment

    public interface IDepartment {
     void Insert(Department department);
     Department getDepartment(String id);
    }
    
    

    SqlserverDepartment

    public class SqlserverDepartment implements IDepartment{
    
    	@Override
    	public void Insert(Department department) {
    		System.out.println("在SqlserverDepartment中插入一条数据");
    		
    	}
    
    	@Override
    	public Department getDepartment(String id) {
    		System.out.println("在SqlserverDepartment中查询一条数据");
    		return null;
    	}
    
    }
    

    AccessDepartment

    public class AccessDepartment implements IDepartment {
    
    	@Override
    	public void Insert(Department department) {
    		System.out.println("在AccessDepartment中插入一条数据");
    		
    	}
    
    	@Override
    	public Department getDepartment(String id) {
    		System.out.println("在AccessDepartment中查询一条数据");
    		return null;
    	}
    
    }
    

    DataAccess

    public class Data {
    
    private static String db;
    
      public static IUser CreateUser() throws IOException, InstantiationException, IllegalAccessException
      {
    	 Properties p = new Properties();
    	 
    	 try { 
    		
    		  InputStream in =Data.class.getClassLoader().getResourceAsStream("database.properties");
    	      p.load(in);}
    	 catch (Exception e) {
    			
    			e.printStackTrace();
    			
    		}
    	  db=p.getProperty("DB");
    	  String className = "抽象工厂模式." + db +"User";
    		//获取以className字符串为名的类
    		Class<IUser> userDaoImplClass = null;
    		try {
    			userDaoImplClass = (Class<IUser>) Class.forName(className);
    		} catch (ClassNotFoundException e1) {
    			
    			e1.printStackTrace();
    		}
    		//返回类的实例
    		try {
    			return userDaoImplClass.getConstructor().newInstance();
    		} catch (Exception e) {
    			
    			e.printStackTrace();
    		}
    		return null;
    		
      }
      public static IDepartment CreateDepartment() throws IOException, InstantiationException, IllegalAccessException
      {
    	 Properties p = new Properties();
    	 
    	 try { 
    		
    		  InputStream in =Data.class.getClassLoader().getResourceAsStream("database.properties");
    	      p.load(in);}
    	 catch (Exception e) {
    			
    			e.printStackTrace();
    			
    		}
    	  db=p.getProperty("DB");
    	  String className = "抽象工厂模式." + db +"User";
    		//获取以className字符串为名的类
    		Class<IDepartment> DepartmentDaoImplClass = null;
    		try {
    			DepartmentDaoImplClass = (Class<IDepartment>) Class.forName(className);
    		} catch (ClassNotFoundException e1) {
    			
    			e1.printStackTrace();
    		}
    		//返回类的实例
    		try {
    			return DepartmentDaoImplClass.getConstructor().newInstance();
    		} catch (Exception e) {
    			
    			e.printStackTrace();
    		}
    		return null;
    		
      }
    }
    
    

    配置文件需注意的问题
    getClassLoader().getResourceAsStream()的参数是根目录src下的路径,即使配置文件在同目录下,也不能下成getClassLoader().getResourceAsStream(“配置文件”),这样程序会报错,得到的InputStream是null值。
    getClassLoader()和getURLClassLoader()的区别:ClassLoader()只能查找src目录下的文件,而URLClassLoader()则能查找任意目录下的文件。

    展开全文
  • 抽象工厂模式

    2021-03-19 14:14:36
    抽象工厂模式一、抽象工厂模式二、抽象工厂模式实例之数据库操作工厂1.实例说明2.实例类图3.实例代码参考文献 一、抽象工厂模式 抽象工厂模式(Abstract Factory Pattern)是所有形式的工厂模式中最为抽象和最具一般...

    一、抽象工厂模式

    抽象工厂模式(Abstract Factory Pattern)是所有形式的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式又称为Kit模式,属于对象创建型模式。在抽象工厂模式中,引入了产品等级结构和产品族的概念,产品等级结构是指抽象产品与具体产品所构成的继承层次关系,产品族(Product Family)是同一个工厂所生产的一系列产品,即位于不同产品等级结构且功能相关联的产品组成的家族。
    抽象工厂模式是工厂方法模式的升级版本,工厂方法模式只生产一个等级的产品,而抽象工厂模式可生产多个等级的产品。
    定义:是一种为访问类提供一个创建一组相关或相互依赖对象的接口,且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
    使用频率:5星
    抽象工厂模式结构图
    在这里插入图片描述

    模式结构
    抽象工厂模式同工厂方法模式一样,也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成,但抽象工厂中方法个数不同,抽象产品的个数也不同。
    抽象工厂模式的主要角色如下:
    1、抽象工厂(Abstract Factory):提供了创建产品的接口,它包含多个创建产品的方法 newProduct(),可以创建多个不同等级的产品。
    2、具体工厂(Concrete Factory):主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建。
    3、抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品。
    4、具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间是多对一的关系。
    应用场景
    1、当需要创建的对象是一系列相互关联或相互依赖的产品族时,如电器工厂中的电视机、洗衣机、空调等。
    2、系统中有多个产品族,但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
    3、系统中提供了产品的类库,且所有产品的接口相同,客户端不依赖产品实例的创建细节和内部结构。

    二、抽象工厂模式实例之数据库操作工厂

    1.实例说明

    某系统为了改进数据库操作的性能,自定义数据库连接对象Connection和语句对象Statement,可针对不同类型的数据库提供不同的连接对象和语句对象,如提供Oracle或MySQL专用连接类和语句类,而且用户可以通过配置文件等方式根据实际需要动态更换系统数据库。使用抽象工厂模式设计系统。

    2.实例类图

    在这里插入图片描述

    3.实例代码

    本例中,DBF接口充当抽象工厂,其子类OracleFactory和MySQLFactory充当具体工厂,Connection和Statement接口充当抽象产品,其子类OracleConnection、MySQLConnection、OracleStatement和MySQLStatement充当具体产品。本实例代码如下:

    //数据库连接接口:抽象产品
    interface Connection
    {
    	public void connect();
    }
    
    //Oracle数据库连接类:具体产品
    class OracleConnection implements Connection
    {
    	public void connect()
    	{
    		System.out.println("连接Oracle数据库");
    	}
    }
    //MySQL数据库连接类:具体产品
    class MySQLConnection implements Connection
    {
    	public void connect()
    	{
    		System.out.println("连接MySQL数据库");
    	}
    }
    
    /
    
    //数据库语句接口:抽象产品
    interface Statement
    {
    	public void executeStatement();
    }
    
    //Oracle数据库语句类:具体产品
    class OracleStatement implements Statement
    {
    	public void executeStatement()
    	{
    		System.out.println("执行Oracle数据库语句");
    	}
    }
    //MySQL数据库连接类:具体产品
    class MySQLStatement implements Statement
    {
    	public void executeStatement()
    	{
    		System.out.println("执行MySQL数据库语句");
    	}
    }
    /
    
    //数据库工厂接口:抽象工厂
    interface DBFactory
    {
    	public Connection createConnection();
    	public Statement createStatement();
    }
    
    //Oracle数据库工厂:具体工厂
    class OracleFactory implements DBFactory
    {
    	public Connection createConnection()
    	{
    		return new OracleConnection();
    	}
    	public Statement createStatement();
    	{
    		return new OracleStatement();
    	}
    }
    //MySQL数据库工厂:具体工厂
    class MySQLFactory implements DBFactory
    {
    	public Connection createConnection()
    	{
    		return new MySQLConnection();
    	}
    	public Statement createStatement();
    	{
    		return new MySQLStatement();
    	}
    }
    
    

    客户端测试类代码如下:

    class Client
    {
    	public static void main(String[] args)
    	{
    		DBFactory factory;
    		Connection connection;
    		Statement statement;
    		factory = new OracleFactory();
    		connection = factory.createConnection();
    		statement = factory.createStatement();
    		connection.connect();
    		statement.executeStatement();
    	}
    }
    

    运行结果如下:

    连接Oracle数据库
    执行Oracle数据库语句
    

    总结部分大多与工厂模式差不多,但是区别在于如果增加新的产品等级结构,每个工厂要生产一个新的类型的对象,则需要修改抽象工厂接口和所有具体工厂类,从这个角度看,抽象工厂模式违背了开闭原则,因此在使用抽象工厂模式时需要仔细分析所有的产品结构,避免再设计完成之后修改源代码,特别是抽象层代码。

    参考文献

    【1】抽象工厂模式(详解版)
    【2】设计模式实训教程(第2版) 刘伟 编著 清华大学出版社

    展开全文
  • 目录前言Abstract Factory设计模式1.模式的应对场景2.案例1:数据库的connection、command依赖3....抽象工厂模式解决的是“一系列相互依赖的对象”的创建工作。 设计模式之工厂模式(Factor Method) 2.案
  • 抽象工厂来实现多种数据库访问,包括SQL和Access。
  • 在这里我使用抽象工厂模式简单模拟数据库连接池 2.准备 首先搞清楚抽象工厂中的四个角色 我们需要的是一个可用直接拿到数据库连接的池,因此具体对象就是数据库的连接池,抽象对象就是数据库连接对象Connection对象...
  • 设计模式--抽象工厂模式实现多数据库连接 设计模式,.net设计模式,抽象工厂
  • 大话设计模式之抽象工厂抽象工厂 + 反射 + 配置文件) 提供一个创建一系列相关或互相依赖的对象的接口,而无需指定他们具体的类 2.抽象工厂的结构图
  • 主要介绍了C#的设计模式编程之抽象工厂模式的应用,注意区分一下简单工厂模式、工厂方法模式和抽象工厂模式概念之间的区别,需要的朋友可以参考下
  • 主要介绍了iOS应用开发中使用设计模式中的抽象工厂模式,示例代码为传统的Objective-C,需要的朋友可以参考下
  • 23种设计模式——抽象工厂模式

    千次阅读 2022-04-30 22:28:54
    抽象工厂本质:选择产品族的实现
  • 区分三种工厂模式,简单工厂模式,工厂方法模式和抽象工厂模式。
  • 抽象工厂实例实验报告
  • 现在,开始创建一个抽象工厂,判断不同的数据库,对不同的数据库,实例化不同的子类. 同时定义一个抽象方法,让其子类实现具体的操作.具体代码如下: /** * 构建抽象DAO工厂 * 此工厂根据不同的数据库产品得到对应...
  • 利用抽象工厂模式实现不同数据库连接。要求按照P102页6.3.2实例说明,实现类图代码,并且编写测试客户端,给出动态更换数据库的运行结果。 二.设计类图 三、类具体代码(要求有相关注释) //Connection接口: ...
  • 抽象工厂实现ADO.NET的多类型数据库连接:Access和SqlServer
  • 抽象工厂设计模式
  • Mysql数据库使用ODBC连接要自己配置 抽象工厂和三层的描述在博客里
  • 通过抽象工厂搜提供的接口,可以创建产品的家族,利用这个接口书写代码,我们的代码将从实际工厂解耦,以便在不同上下文中实现各种各样的工厂,制造出各种不同的产品。这是与博客《抽象工厂模式--GOF的23个之一》...
  • 设计模式 抽象工厂模式 反射 配置文件 设计模式 抽象工厂模式 反射 配置文件 设计模式 抽象工厂模式 反射 配置文件 设计模式 抽象工厂模式 反射 配置文件 设计模式 抽象工厂模式 反射 配置文件 设计模式 抽象工厂...
  • java中的抽象工厂模式

    2021-12-06 13:50:59
    设计模式之抽象工厂模式(FactoryMethod Pattern) 相关定义:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。 工厂方法的实现主要是通过以下步骤: 创建一个或多个抽像工厂(代码里面为...
  • 用一个简单的小例子 实现抽象工厂设计模式 采用面向对象思想编程 程序实现了MyShool的一个简单的添加学员的功能 采用抽象工厂实现程序支持访问多数据库(Access和SQL)...详细见资料

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,391
精华内容 30,556
关键字:

抽象工厂 数据库