精华内容
下载资源
问答
  • 在这里我使用抽象工厂模式简单模拟数据库连接池 2.准备 首先搞清楚抽象工厂中的四个角色 我们需要的是一个可用直接拿到数据库连接的池,因此具体对象就是数据库的连接池,抽象对象就是数据库连接对象Connection对象...

    使用抽象工厂模式模拟JDBC连接池

    工厂方法模式
    简单工厂模式
    抽象工厂模式

    1.连接池

    连接池:连接池是创建和管理一个连接的缓冲池的技术,这些连接准备好被任何需要它们的线程使用。

    在这里我使用抽象工厂模式简单模拟数据库连接池

    2.准备

    首先搞清楚抽象工厂中的四个角色

    我们需要的是一个可用直接拿到数据库连接的池,因此具体对象就是数据库的连接池,抽象对象就是数据库连接对象Connection对象,

    抽象工厂里面定义数据库连接池的通用行为,创建一个连接池,拿到一个连接,回收一个连接。

    具体工厂继承抽象工厂同时细化连接池的行为,比如获取当前可用连接等等。

    抽象工厂:连接池的通用行为

    具体工厂:继承抽象工厂,并提供该连接池的具体行为

    抽象对象:Connection

    具体对象:数据库的连接池

    搞清楚这些就可以开始动手了

    3.实现

    抽象工厂:

    public	abstract class Pool {
    
    	public Driver driver = null;//驱动对象
    	
    	public String propertiesName = "jdbc.properties";//配置文件名称
    	
    	public int normalConnect = 10;//保持连接数
    	
    	public String driverName = null;//驱动字符串
    	
    	public String username;//用户名
    	
    	public String password;//密码
    	
    	public String url;//地址
    	
    	
    	{//静态代码块初始化成员变量
    		InputStream is = Pool.class.getResourceAsStream(propertiesName);
    		Properties p = new Properties();
    		//加载配置文件
    		try {
    			p.load(is);
    			this.driverName = p.getProperty("driverName");
    			this.username = p.getProperty("username");
    			this.password = p.getProperty("password");
    			this.url = p.getProperty("url");
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	/**
    	 * 注册JDBC驱动
    	 */
    	@SuppressWarnings("deprecation")
    	public void loadDriver() {
    		try {
    			Driver driver = (Driver) Class.forName(driverName).newInstance();
    			this.driver = driver;
    			System.out.println("驱动注册成功"+driverName);
    		} catch (Exception e) {
    			e.printStackTrace();
    			System.out.println("驱动注册失败检查驱动字符串是否正确");
    		}
    	}
    	
    	
    	/**
    	 * 从连接池中拿到一个连接
    	 * @return
    	 */
    	public abstract Connection getConnection();
    	
    	
    	/**
    	 * 把一个连接返回连接池
    	 * @param con 连接对象
    	 */
    	public abstract void freeConnection(Connection con);
    	
    	
    	/**
    	 * 关闭所有的连接,撤销驱动注册
    	 */
    	public abstract void release();
    	
    }
    

    具体工厂:

    public class DBconnectionPool extends Pool {
    
    	// 空闲连接
    	private int num = 0;
    	// 存储连接的容器
    	private Vector<Connection> freeConnections = new Vector<Connection>();
    
    	/**
    	 * 初始化
    	 */
    	public DBconnectionPool() {
    		super.loadDriver();// 加载驱动
    		for (int i = 0; i < normalConnect; i++) {// 创建连接
    			freeConnections.add(newConnection());
    			num++;
    		}
    	}
    
    	/**
    	 * 从连接池中拿到一个连接
    	 * 
    	 * @return
    	 */
    	@Override
    	public Connection getConnection() {
    		if (freeConnections.size() > 0) {// 连接池中有空闲连接
    			Connection con = freeConnections.get(0);
    			freeConnections.removeElementAt(0);
    			num--;
    			System.out.println("客户端拿取了一个连接"+con);
    			return con;
    		}
    		System.out.println("连接池无可用连接");
    		return null;
    	}
    
    	/**
    	 * 把一个连接返回连接池
    	 * 
    	 * @param con 连接对象
    	 */
    	@Override
    	public void freeConnection(Connection con) {
    		freeConnections.add(con);
    		num++;
    		System.out.println("客户端放回了一个连接");
    	}
    
    	/**
    	 * 关闭连接,并注销驱动
    	 */
    	@Override
    	public void release() {
    		freeConnections.removeAllElements();//移除所有连接
    		num=0;
    		try {
    			DriverManager.deregisterDriver(driver);//注销驱动
    		} catch (SQLException e) {
    			e.printStackTrace();
    			System.out.println("驱动注销失败");
    		}
    		System.out.println("连接池已经关闭");
    	}
    
    	/**
    	 * 创建一个连接
    	 * 
    	 * @return
    	 * @throws SQLException
    	 */
    	public Connection newConnection() {
    		try {
    			Connection con = DriverManager.getConnection(url, username, password);
    			System.out.println("连接池创建了一个连接");
    			return con;
    		} catch (Exception e) {
    			e.printStackTrace();
    			System.out.println("连接创建失败");
    			return null;
    		}
    	}
    
    	/**
    	 * 返回可用连接
    	 * 
    	 * @return
    	 */
    	public int getNum() {
    		return num;
    	}
    
    }
    

    客户端调用

    public class Client {
    
    	public static void main(String[] args) throws SQLException {
    		//创建连接池
    		DBconnectionPool pool = new	DBconnectionPool();
    		System.out.println(pool.getNum());//10
    		//拿到一个连接
    		Connection con1 = pool.getConnection();
    		pool.getConnection();//再次获取
    		
    		System.out.println(pool.getNum());//8
    		
    		pool.freeConnection(con1);//放回一个连接
    		con1.close();
    		System.out.println(pool.getNum());//9
    		pool.release();//注销连接池
    		pool.getConnection();//这个时候已经连接池中已经没有可用的连接了
    	}
    	
    }
    

    在这里插入图片描述
    配置文件
    在这里插入图片描述

    tip:连接数据库需要一个jar包(mysql-connector-java.jar)

    展开全文
  • 设计模式--抽象工厂模式实现多数据库连接 设计模式,.net设计模式,抽象工厂
  • 说下对抽象工厂模式的理解: 抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口, 而无需指定他们具体的类。 在抽象工厂的内部包含了所有产品创建的抽象方法, 也就是说, 每个工厂都会生产所有提供的...

    说下对抽象工厂模式的理解:
    抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口, 而无需指定他们具体的类。
    在抽象工厂的内部包含了所有产品创建的抽象方法, 也就是说, 每个工厂都会生产所有提供的产品,因而, 不同的产品有不同工厂所生产的不同规格
    他的优点是:
    1. 可以方便的更换产品的系列, ie, 更换具体的工厂
    2. 他让具体的创建实例过程和客户端分离, 客户通过他们的抽象接口实现对实例的操作, 产品的具体类名也被具体工厂分离实现, 不会出现在客户代码中。

    但是他也有缺点: 在需要添加产品的时候, 需要改动具体的工厂, 违反了开闭原则

    在C#中, 书中介绍了可以使用反射机制实现,借助简单工厂, 去除switch, if 的逻辑判断, 解决维护和扩展的 问题。

    UML 图
    这里写图片描述
    程序执行效果图:
    这里写图片描述
    代码
    factory.h

    #ifndef _FACTORY_H_
    #define _FACTORY_H_
    
    #include "MainProduct.h"
    #include <memory>
    
    using std::shared_ptr;
    
    /************************************************************************/
    /* 工厂接口                                                             */
    /************************************************************************/
    class CIFactory{
    public:
        virtual shared_ptr<CIUser> createUser() = 0;
        virtual shared_ptr<CIDepartment> createDepartment() = 0;
    };
    
    #endif // _FACTORY_H_

    mainfactory.h

    #ifndef _MAINFACTORY_H_
    #define _MAINFACTORY_H_
    
    #include "Factory.h"
    #include "MainProduct.h"
    
    /************************************************************************/
    /* sql 工厂                                                             */
    /************************************************************************/
    class SqlFactory : public CIFactory{
    public:
        shared_ptr<CIUser> createUser(){
            return shared_ptr<CIUser>(new SqlServerUser());
        }
    
        shared_ptr<CIDepartment> createDepartment(){
            return shared_ptr<CIDepartment>(new SqlServerDepartment());
        }
    };
    
    /************************************************************************/
    /* access 工厂                                                          */
    /************************************************************************/
    class AccessFactory : public CIFactory{
    public:
        shared_ptr<CIUser> createUser(){
            return shared_ptr<CIUser>(new AccessUser());
        }
    
        shared_ptr<CIDepartment> createDepartment(){
            return shared_ptr<CIDepartment>(new AccessDepartment());
        }
    };
    
    #endif // _MAINFACTORY_H_
    

    product.h

    #ifndef _PRODUCT_H_
    #define _PRODUCT_H_
    
    #include <string>
    
    /************************************************************************/
    /* user 数据结构                                                        */
    /************************************************************************/
    class User{
    public:
        int Id() const { return _id; }
        void Id(int val) { _id = val; }
        std::string Name() const { return _name; }
        void Name(std::string val) { _name = val; }
    
    private:
        int _id;    
        std::string _name;  
    };
    
    class CIUser{
    public:
        virtual void Insert(User user) = 0;
        virtual User getUser(int id) const = 0;
    };
    
    /************************************************************************/
    /* department 数据结构                                                        */
    /************************************************************************/
    class Department{
    public:
        int Id() const { return _id; }
        void Id(int val) { _id = val; }
        std::string Name() const { return _name; }
        void Name(std::string val) { _name = val; }
    
    private:
        int _id;
        std::string _name;
    };
    
    class CIDepartment{
    public:
        virtual void Insert(Department department) = 0;
        virtual Department getDepartment(int id) const = 0;
    };
    
    
    #endif // _PRODUCT_H_
    

    mainproduct.h

    #ifndef _MAINPRODUCT_H_
    #define _MAINPRODUCT_H_
    
    #include "product.h"
    #include <iostream>
    
    using std::cout;
    using std::endl;
    
    /************************************************************************/
    /* sql server user                                                      */
    /************************************************************************/
    class SqlServerUser : public CIUser{
    public:
        void Insert(User user){
            cout << "sql server insert a record" << endl;
        }
    
        User getUser(int id) const{
            cout << "get user from sql server" << endl;
            return User();
        }
    };
    
    /************************************************************************/
    /* Access user                                                      */
    /************************************************************************/
    class AccessUser : public CIUser{
    public:
        void Insert(User user){
            cout << "access insert a record" << endl;
        }
    
        User getUser(int id) const{
            cout << "get user from access" << endl;
            return User();
        }
    };
    
    /************************************************************************/
    /* sql server department                                                */
    /************************************************************************/
    class SqlServerDepartment : public CIDepartment{
    public:
        void Insert(Department user){
            cout << "sql server insert a record" << endl;
        }
    
        Department getDepartment(int id) const{
            cout << "get Department from sql server" << endl;
            return Department();
        }
    };
    
    /************************************************************************/
    /* Access department                                                    */
    /************************************************************************/
    class AccessDepartment : public CIDepartment{
    public:
        void Insert(Department user){
            cout << "access insert a record" << endl;
        }
    
        Department getDepartment(int id) const{
            cout << "get Department from access" << endl;
            return Department();
        }
    };
    
    #endif // _MAINPRODUCT_H_
    

    main.cpp

    #include "MainFactory.h"
    #include "MainProduct.h"
    #include <iostream>
    #include <memory>
    
    using namespace std;
    
    int main(){
        shared_ptr<User> user(new User);
        shared_ptr<CIFactory> factory(new SqlFactory);
        shared_ptr<CIUser> iuser = factory->createUser();
    
        iuser->Insert(*user);
        iuser->getUser(1);
    
        system("pause");
        return 0;
    }
    
    展开全文
  • 抽象工厂模式解析 抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时,使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口,使客户端在不必...

    抽象工厂模式解析

    抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时,使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口,使客户端在不必指定产品的具体的情况下,创建多个产品族中的产品对象。根据里氏替换原则,任何接受父类型的地方,都应当能够接受子类型。因此,实际上系统所需要的,仅仅是类型与这些抽象产品角色相同的一些实例,而不是这些抽象产品的实例。换言之,也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。(摘自百度百科)

    此处不对抽象工厂模式进行详细的解析,不大理解的读者可以到网上找相关的知识,可以找到很多的.

    代码实现

    温馨提示:如果此时读者还没由安装mysql数据库那就先把数据库安装好.

    // "Factory.h"
    #ifndef __FACTORY_H__
    #define __FACTORY_H__
    
    #include <iostream>
    #include <memory>
    #include "Product.h"
    
    class CIFactory {
    public:
        virtual std::shared_ptr<CIUser> CreateUser() = 0;
     
    };
    
    #endif
    

    解析: 这个头文件封装了一个工厂的抽象类,里面有一个虚函数,其中使用C++11的智能指针shared_ptr来管理返回的对象指针,而CIUser则是数据库的抽象类.

    // "MysqlFactory.h"
    #ifndef __MYSQLFACTORY_H__
    #define __MYSQLFACTORY_H__
    
    #include "Factory.h"
    #include "MysqlProduct.h"
    
    // mysql工厂
    class sqlFactory : public CIFactory
    {
    public:
        std::shared_ptr<CIUser> CreateUser() {
            return std::shared_ptr<CIUser>(new SqlServerUser());
        }
    };
    
    #endif
    

    解析: 该头文件实现了虚基类的派生类,想要编写sql server等数据库工厂时只需要仿照此处的代码即可,上面这个代码值针对mysql数据库的,使用抽象类CIUser指针来接收派生类SqlServerUser对象指针.

    // "Product.h"
    #ifndef __PRODUCT_H__
    #define __PRODUCT_H__
    
    #include <string>
    #include <memory>
    
    class User 
    {
    public:
        int Id() const { return id_; }
        void SetId(int val) { id_ = val; }
        std::string Name() const { return name_; }
        void SetName(std::string val) { name_ = val; }
    
    private:
        int id_;
        std::string name_;
    };
    
    class CIUser 
    {
    public:
        virtual bool InitSql() = 0;
        virtual bool ConnSql(std::string host, 
                            std::string user, 
                            std::string pwd, 
                            std::string db_name) = 0;
        virtual bool SelectSql(std::string sql) = 0;
        virtual bool InsertSql(std::string sql) = 0;
        virtual bool DelSql(std::string sql) = 0;
        virtual void Insert(User user) = 0;
        virtual User getuser(int id) const = 0;
    };
    
    #endif
    

    解析: Product.h头文件主要是对象接口,例如我在此处要实现的是数据库操作的抽象工厂,那么这个头文件里面我要写的就是数据库的虚基类,提供派生类使用.

    // "MysqlProduct.h"
    #ifndef __MYSQLPRODUCT_H__
    #define __MYSQLPRODUCT_H__
    
    #include "Product.h"
    #include <iostream>
    #include <mysql/mysql.h>
    
    class SqlServerUser : public CIUser
    {
    public:
        SqlServerUser() {
            InitSql();
        }
    
        ~SqlServerUser() {
            if (m_pConnection != NULL) {
                mysql_close(m_pConnection);
                m_pConnection = NULL;
            }
        }
    
        bool InitSql() {
            m_pConnection = mysql_init(NULL);
            if (m_pConnection == NULL) {
                std::cout << "init mysql error!" << std::endl;
                return false;
            }
            return true;
        }
    
        bool ConnSql(std::string host, 
                            std::string user, 
                            std::string pwd, 
                            std::string db_name) {
            // 建立数据库连接
            m_pConnection = mysql_real_connect(m_pConnection, host.c_str(),  
                    user.c_str(), pwd.c_str(), db_name.c_str(), 0, NULL, 0);
            if (NULL == m_pConnection)
            {
                std::cout << "Error: " << mysql_error(m_pConnection);
                return false;
            }
    
            // Linux下 Windows下使用mysql_query(connection, "SET NAMES GB2312"); 用以解决读取数据库中文数据时乱码
            mysql_query(m_pConnection, "SET NAMES UTF8");
    
            return true;
        }
                        
        bool SelectSql(std::string sql) {
            // 执行sql语句
            if (mysql_query(m_pConnection, sql.c_str()))
            {
                std::cout << "Select Error: " << mysql_error(m_pConnection);
                return false;
            }
    
            // 获取数据
            result = mysql_use_result(m_pConnection);
            for (int i = 0; i < mysql_field_count(m_pConnection); ++i)
            {
                // 获取下一行
                row = mysql_fetch_row(result);
                if (row <= 0)
                    break;
                for (int j = 0; j < mysql_num_fields(result); ++j)
                {
                    std::cout << row[j] << " ";
                }
                std::cout << std::endl;
    
            }
            mysql_free_result(result);          // 释放结果集的内存
    
            return true;
        }
    
        bool InsertSql(std::string sql) {
            if (mysql_query(m_pConnection, sql.c_str()))
            {
                std::cout << "Insert Error: " << mysql_error(m_pConnection);
                return false;
            }
    
            return true;
        }
    
        bool DelSql(std::string sql) {
            if (mysql_query(m_pConnection, sql.c_str()))
            {
                std::cout << "Del Error: " << mysql_error(m_pConnection);
                return false;
            }
    
            return true;
        }
    
        void Insert(User user) {
            std::cout << "sql server insert a record" << std::endl;
        }
    
        User getuser(int id) const {
            std::cout << "get user from sql server" << std::endl;
         
            return User();
        }
    
    private:
        MYSQL *m_pConnection;
        MYSQL_RES *result;  
        MYSQL_ROW row;
    };
    
    #endif
    

    解析:MysqlProduct.h是数据库接口的派生类,里面主要封装了对mysql数据库的操作,里面的代码都比较简单就不做详细介绍了.像扩展其他数据库的时候只需要仿照此头文件就可以了.

    下面我们来实现main.cc文件来测试上面的抽象工厂.

    温馨提示:此处我建了了一个数据表叫user,里面有三个字段:user_id;name;sex

    #include "../Include/MysqlFactory.h"
    #include "../Include/MysqlProduct.h"
    #include <iostream>
    #include <memory>
    
    using namespace std;
    
    int main(void) 
    {  
        // 抽象工厂的方式获取mysql工厂 
        shared_ptr<CIFactory> factory(new sqlFactory);
        shared_ptr<CIUser> iuser = factory->CreateUser();
        
        // 连接mysql数据库
        if (iuser->ConnSql("数据库IP地址如:localhost", "用户名如:root", "password", "数据库名")) {
            std::cout << "connect mysql success!" << std::endl;
        }
    
        std::string sql = "SELECT * FROM user WHERE user_id = 1";
        iuser->SelectSql(sql);
    
        // 插入语句
        sql = "INSERT INTO user(name, sex) VALUES ('jack', '男')";
        if (iuser->InsertSql(sql)) {
            std::cout << "insert success!" << std::endl;
        }
    
        system("pause");
        return 0;
    }
    

    CMake编写

    下面来看看我的文件目录吧:

    • SqlFactory
      • build
      • Include
        • Factory.h
        • MysqlFactory.h
        • Product.h
        • MysqlProduct.h
      • src
        • main.cc
        • CMakeLists.txt
      • CMakeLists.txt

    我们先来看看SqlFactory目录下的CMakeLists.txt

    PROJECT(SQLTEST)
    ADD_SUBDIRECTORY(src)
    

    下面来编写src目录下的CMakeLists.txt脚本

    SET(SOULIST_SRC main.cc)
    
    ADD_EXECUTABLE(test ${SOULIST_SRC})
    TARGET_LINK_LIBRARIES(test mysqlclient)
    
    # 用以编译shared_ptr
    if(UNIX)  
        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -std=gnu++0x")  
    endif()  
    

    这时我的代码跟脚本就已经全部完成了,下面我们来运行代码吧
    将终端来到SqlFactory/build目录下,编辑:

    cmake ..
    make
    

    这时在build目录下的src文件夹下就可以看到可执行文件test了,编辑:

    ./test
    

    即可运行程序了.

    展开全文
  • 如何利用抽象工厂更换数据库

    千次阅读 热门讨论 2013-08-18 21:26:21
    VS中我们都加入了抽象工厂模式,都懂的这种模式可以用来更换数据库。具体应用起来大家都知道应用反射,首先我介绍下我的情况吧。  现在的情况是我的D层程序集和命名空间都为DAL,D层的类也都是以Sql为前缀来命名,...
       VS中我们都加入了抽象工厂模式,都懂的这种模式可以用来更换数据库。具体应用起来大家都知道应用反射,首先我介绍下我的情况吧。 
    

       现在的情况是我的D层程序集和命名空间都为DAL,D层的类也都是以Sql为前缀来命名,例如SqlCancelCardDAL,在工厂中,我的代码时这么写的,大家可以看一下:

    Imports DFactory
    Imports IDAL
    Imports System.Reflection
    Imports System.Configuration
    
    Public Class DataAccess   
        Private ReadOnly assemblyName As String = "DAL"
        Dim strDB As String = System.Configuration.ConfigurationSettings.AppSettings("DB")
    
        '返回一个IStudent接口
        Public Function CheckStuID() As IStudent
            Dim ClassName As String = assemblyName + "." + strDB + "StuInfoDAL"
            Return CType(Assembly.Load("DAL").CreateInstance(ClassName), IStudent)
        End Function
    
        '返回注册接口IRegist
        Public Function AboutRegist() As IRegist
            Dim ClassName As String = assemblyName + "." + strDB + "RegistDAL"
            Return CType(Assembly.Load("DAL").CreateInstance(ClassName), IRegist)
        End Function
    
        '返回充值接口ICharge
        Public Function InsertInfo() As ICharge
            Dim ClassName As String = assemblyName + "." + strDB + "ChargeDAL"
            Return CType(Assembly.Load("DAL").CreateInstance(ClassName), ICharge)
        End Function
       ......
      End Class
    

    App.config中反射为:

    <add key="DB" value="Sql"/>
    改变为
    <add key="DB" value="Oracle"/>
    

        接着想,我们原来的命名空间跟改变的OracleDAO命名空间完全不一样,看一下原来的工厂代码这样写的:

     Private ReadOnly assemblyName As String = "DAL"

        这样就在程序里把命名空间给写死了,但是我们同样可以利用反射的原理将命名空间移动到XML中,不需要打开VS来看,因为我们的运行都是从项目文件中UI层Debug开始的,所以只需在UI\bin\Debug\UI.exe.config中添加一句:

    <add key="MM" value="OracleDAO"/>

      同时在工厂层中将写死的命名空间那句改为:

     Private ReadOnly assemblyName = System.Configuration.ConfigurationSettings.AppSettings("MM")

       最后一步就是:将每个方法中的return句中“DAL”改为assemblyName即为完美。

       这样我们的程序如何更改数据库只需在配置文件中更改命名空间和反射中类的前缀即可,这样就充分运用了抽象工厂+反射,实现更换数据库的功能。

    展开全文
  • 抽象工厂模式是一种创建型模式。它为创建一组相关或者是相互依赖的对象提供一个接口,而不是指定它们的具体类。 类图: 抽象工厂模式UML类图.png AbstractProduct(抽象产品类):需要创建的产品的抽象类。 ...
  • 抽象工厂模式

    2021-03-19 14:14:36
    抽象工厂模式一、抽象工厂模式二、抽象工厂模式实例之数据库操作工厂1.实例说明2.实例类图3.实例代码参考文献 一、抽象工厂模式 抽象工厂模式(Abstract Factory Pattern)是所有形式的工厂模式中最为抽象和最具一般...
  • 数据工厂主要是通过把数据库的连接做成一个抽象工厂,如命名DALFactory,程序中所有的数据库连接都通过这个工厂类来产生,用来负责根据配置文件动态创建系统所需的数据访问逻辑对象。  我们就拿PETSHOP来举例...
  • 本人做了一个抽象工厂的小案例,只要修改配置文件,就可以轻松的切换数据库,里面附有ACCESS数据库,不需要配置 sql数据库附加上去就好了,修改配置连接 就可以轻松切换 数据库 如有问题请联系qimenglin_aptech@163.com ...
  • 北大青鸟S3项目------MyBookShop(抽象工厂模式+数据库)源码《=========放心的下吧,保证有用,里面带有数据库
  • 大话设计模式(七)抽象工厂模式

    万次阅读 2016-10-09 13:36:27
    大话设计模式(七)抽象工厂模式菜鸟程序员碰到问题,只会用时间来摆平。前言  今天主要讲解抽象工厂模式抽象工厂模式(Abstract Factory Pattern)是工厂方法模式的进一步抽象,其英文原话”Provide an interface...
  • 文章目录抽象工厂模式一、模式动机二、模式结构类图二、数据库操作工厂类图代码三、优缺点优点缺点五、适用性 一、模式动机 为了更清晰地理解抽象工厂方法模式,需引入两个概念: 产品等级结构:产品等级结构即...
  • 抽象工厂模式的区别及优缺点及使用场景简单工厂普通简单工厂多方法简单工厂静态方法简单工厂工厂方法模式抽象工厂模式 工厂模式是java设计模式中比较简单的一个设计模式,但很多地方都用到了工厂模式,(如解析xml...
  • 设计模式——抽象工厂模式

    千次阅读 2018-04-06 17:11:06
    抽象工厂是对工厂模式的进一步抽象,可以说工厂生产的是对象,而抽象工厂生产的是工厂,比起工厂模式多了一个产品族的概念。产品族: 位于不同产品等级结构中,功能相关联的产品组成的家族。例如软件中选择MySql+PHP...
  • C#抽象工厂模式Demo

    2016-06-29 22:08:52
    完整的抽象工厂模式数据库和代码全部都有,希望能帮助到一些人。
  • 工厂模式三部曲-抽象工厂模式

    千次阅读 2016-05-29 00:11:11
    工厂模式三部曲-抽象工厂模式 什么是抽象工厂模式 简单了解一下 按照惯例,我们先了解一下什么是抽象工厂模式抽象工厂模式和工厂方法模式很相似,但是抽象工厂模式将抽象发挥的更加极致,是三种...
  • 一、概念及类图1、简单工厂模式(静态工厂模式) 在简单工厂模式中,工厂类可以根据参数的不同返回不同的类的实例。 2、工厂方法模式(多态模式) 工厂方法模式的核心是抽象工厂类Factory,...3、抽象工厂模式 该模式
  • 抽象工厂模式:我们现在要对mysql/oracle数据库中的User表进行操作,User表定义如下:public class User { private int uid; private String uname; public int getUid() { return uid; } public void set...
  • 设计模式在实际业务应用中的介绍之1——抽象工厂模式实现对数据库访问组件的封装基于C#打造的通用数据库访问组件基于C#打造的通用数据库访问组件,完全支持开闭原则,设计上支持可扩展支持任意主流数据库,目前组件...
  • 抽象工厂模式概述

    千次阅读 2014-11-16 23:13:30
    一、抽象工厂模式概述   抽象工厂提供一个接口,通过该接口可以在不指定具体类的情况下,创建一系列相关的或相互独立的对象。 抽象工厂模式是工厂方法模式的泛化版,工厂方法模式是一种特殊的抽象工厂模式。在...
  • 工厂方法模式与抽象工厂模式

    千次阅读 2015-02-13 22:45:16
    抽象工厂模式与工厂方法模式的区别  可以这么说,工厂方法模式是一种极端情况的抽象工厂模式,而抽象工厂模式可以看成是工厂方法模式的一种推广。 (1)、其实工厂方法模式是用来创建一个产品的等级结构的,而抽象...
  • 抽象工厂模式: 以脸萌为例,当圣诞节、元旦节、新年来了,需要生产一个节日系列的脸萌产品,不同节日系列的人物.. 1>首先有男孩女孩: package com.zy.factoryProject; /** * 男孩 * * @...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 58,421
精华内容 23,368
关键字:

抽象工厂模式数据库