`

如何重构出DAO模式

    博客分类：
  • java
DAO设计模式OracleMySQLSQL Server 
阅读更多

一、前言
    本文的目的是将一个获取数据库连接的普通类重构成DAO+Abstract Factory模式。
    二、设计初衷
    使用数据访问对象（DAO，Data Access Object）模式来抽象和封装所有对数据源的访问。DAO管理着与数据源的连接以便检索和存储数据。可以降低商业逻辑层和数据访问层的耦合度，提高应用的可维护性和可移植性。
    由于底层数据源实现变化时，DAO向客户端提供的接口不会变化，所有该模式允许DAO调整到不同的存储模式，而不会影响其客户端或者业务组件。显然，DAO充当了组件和数据源之间的适配器。
    三、重构
    首先，创建一个获取数据库连接的普通类：
    DAOClient.java
    import java.sql.*;
    publicclass DAOClient {
        publicstaticvoid main( String[] args ) {
           try {
               //For Oracle
               Class.forName( "oracle.jdbc.driver.OracleDriver" );
               Connection conn = DriverManager.getConnection(
                      "jdbc:oracle:thin:@localhost:1521:dy", "scott", "tiger" );
               System.out.println( conn.toString() );
           } catch ( ClassNotFoundException e ) {
               e.printStackTrace();
           } catch ( SQLException e ) {
               e.printStackTrace();
           }
        }
    }

    再将这段代码封装到一个getConnection()方法中以便其它的地方调用：
    import java.sql.*;
    publicclass DAOClient {
        publicstaticvoid main( String[] args ) {
           Connection conn = getConnection();
           System.out.println( conn.toString() );
        }
        /**
         *得到一个Connection对象
         *@returnjava.sql.Connection
         */
        privatestatic Connection getConnection() {
           Connection conn = null;
           try {
               //For Oracle
               Class.forName( "oracle.jdbc.driver.OracleDriver" );
               conn = DriverManager.getConnection(
                      "jdbc:oracle:thin:@localhost:1521:dy", "scott", "tiger" );
           } catch ( ClassNotFoundException e ) {
               e.printStackTrace();
           } catch ( SQLException e ) {
               e.printStackTrace();
           }
           return conn;
        }
    }

    再将此方法定义到针对Oracle的工厂类中：
    OracleDAOFactory.java
    import java.sql.*;
    publicclass OracleDAOFactory {
        private OracleDAOFactory() {}
        /**
         *返回一个OracleDAOFactory对象
         *@returnOracleDAOFactory类型对象
         */
        publicstatic OracleDAOFactory newInstance() {
           returnnew OracleDAOFactory();
        }
        /**
         *得到一个Connection对象
         *@returnjava.sql.Connection
         */
        public Connection getConnection() {
           Connection conn = null;
           try {
               //For Oracle
               Class.forName( "oracle.jdbc.driver.OracleDriver" );
               conn = DriverManager.getConnection(
                      "jdbc:oracle:thin:@localhost:1521:dy", "scott", "tiger" );
           } catch ( ClassNotFoundException e ) {
               e.printStackTrace();
           } catch ( SQLException e ) {
               e.printStackTrace();
           }
           return conn;
        }
    }

    此时，DAOClient.java这个测试类的代码应修改为：
    import java.sql.*;
    public class DAOClient {
        publicstaticvoid main( String[] args ) {
           Connection conn = OracleDAOFactory.newInstance().getConnection();
           System.out.println( conn.toString() );
        }
    }

    考虑：通常，数据库服务器、数据库名、数据库用户、密码等应该从配置文件中获取。因此，修改Oracle的工厂类：
    import java.io.IOException;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.util.Properties;
    publicclass OracleDAOFactory {
        privatestatic Properties prop = new Properties();
        static {
           try {
               prop.load( OracleDAOFactory.class
                      .getResourceAsStream( "config.properties" ) );
           } catch ( IOException e ) {
               System.out.println( "File:config.properties no find,PLS check out!" );
               e.printStackTrace();
           }
        }
        private String CONNECTION_SERVER_NAME = prop
               .getProperty( "oracle_server_name" );
        private String CONNECTION_DRIVER = prop.getProperty( "oracle_conn_driver" );
        private String CONNECTION_DBINSTANCE = prop
               .getProperty( "oracle_dbInstance" );
        private String CONNECTION_USER = prop.getProperty( "oracle_conn_user" );
        private String CONNECTION_PWD = prop.getProperty( "oracle_conn_pwd" );
        private String CONNECTION_URL = "jdbc:oracle:thin:@"
               + CONNECTION_SERVER_NAME + ":1521:" + CONNECTION_DBINSTANCE;

       private OracleDAOFactory() {}
        /**
         *返回一个OracleDAOFactory对象
         *@returnOracleDAOFactory类型对象
         */
        publicstatic OracleDAOFactory newInstance() {
           returnnew OracleDAOFactory();
        }
        /**
         *得到一个Connection对象
         *@returnjava.sql.Connection
         */
        public Connection getConnection() {
           Connection conn = null;
           try {
               Class.forName( CONNECTION_DRIVER );
               conn = DriverManager.getConnection(
                      CONNECTION_URL, CONNECTION_USER, CONNECTION_PWD );
           } catch ( ClassNotFoundException e ) {
               e.printStackTrace();
           } catch ( SQLException e ) {
               e.printStackTrace();
           }
           return conn;
        }
    }

    添加配置文件config.properties：
    oracle_server_name=localhost
    oracle_conn_driver=oracle.jdbc.driver.OracleDriver
    oracle_dbInstance=dy
    oracle_conn_user=scott
    oracle_conn_pwd=tiger

    继续考虑，客户端在获取数据库连接时使用的是针对Oracle的数据库的工厂，但如果数据库变化了，那么客户端的代码还是要改变。因此，可以定义一个DAOFactory类，定义了一个抽象方法：getConnection()用于获取数据库连接，还有一个getDAOFactory()方法，根据参数dbType的值，返回不同的DAOFactory。
    DAOFactory.java
    import java.sql.Connection;
    publicabstractclass DAOFactory {
        publicstaticfinalintORACLE = 1;
        publicstaticfinalintSQLSERVER = 2;
        publicstaticfinalintMYSQL = 3;

        public abstract Connection getConnection();

        publicstatic DAOFactory getDAOFactory( int dbType ) {
           switch( dbType ) {
           caseORACLE:
               return OracleDAOFactory.newInstance();
           caseSQLSERVER:
               return SqlDAOFactory.newInstance();
           caseMYSQL:
               return MySqlDAOFactory.newInstance();
           default:
               returnnull;
           }
        }
    }

    SqlDAOFactory.java
    import java.io.IOException;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.util.Properties;
    publicclass SqlDAOFactory extends DAOFactory {
        privatestatic Properties prop = new Properties();
        static {
           try {
               prop.load( OracleDAOFactory.class
                      .getResourceAsStream( "config.properties" ) );
           } catch ( IOException e ) {
               System.out.println( "File:config.properties no find,PLS check out!" );
               e.printStackTrace();
           }
        }
        private String CONNECTION_SERVER_NAME = prop
               .getProperty( "sqlserver_server_name" );
        private String CONNECTION_DRIVER = prop.getProperty( "sqlserver_conn_driver" );
        private String CONNECTION_DBINSTANCE = prop
               .getProperty( "sqlserver_dbInstance" );
        private String CONNECTION_USER = prop.getProperty( "sqlserver_conn_user" );
        private String CONNECTION_PWD = prop.getProperty( "sqlserver_conn_pwd" );
        private String CONNECTION_URL = "jdbc:microsoft:sqlserver://"
               + CONNECTION_SERVER_NAME + ":1433;DatabaseName="
               + CONNECTION_DBINSTANCE;

        private SqlDAOFactory() {}
        /**
         *返回一个SqlDAOFactory对象
         *@returnSqlDAOFactory类型对象
         */
        publicstatic SqlDAOFactory newInstance() {
           returnnew SqlDAOFactory();
        }
        /**
         *得到一个Connection对象
         *@returnjava.sql.Connection
         */
        public Connection getConnection() {
           Connection conn = null;
           try {
               Class.forName( CONNECTION_DRIVER );
               conn = DriverManager.getConnection(
                      CONNECTION_URL, CONNECTION_USER, CONNECTION_PWD );
           } catch ( ClassNotFoundException e ) {
               e.printStackTrace();
           } catch ( SQLException e ) {
               e.printStackTrace();
           }
           return conn;
        }
    }

    MySqlDAPFactory.java
    import java.io.IOException;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.util.Properties;
    publicclass MySqlDAOFactory extends DAOFactory {
        privatestatic Properties prop = new Properties();
        static {
           try {
               prop.load( OracleDAOFactory.class
                      .getResourceAsStream( "config.properties" ) );
           } catch ( IOException e ) {
               System.out.println( "File:config.properties no find,PLS check out!" );
               e.printStackTrace();
           }
        }
        private String CONNECTION_SERVER_NAME = prop
               .getProperty( "mysql_server_name" );
        private String CONNECTION_DRIVER = prop.getProperty( "mysql_conn_driver" );
        private String CONNECTION_DBINSTANCE = prop
               .getProperty( "mysql_dbInstance" );
        private String CONNECTION_USER = prop.getProperty( "mysql_conn_user" );
        private String CONNECTION_PWD = prop.getProperty( "mysql_conn_pwd" );
        private String CONNECTION_URL = "jdbc:mysql://"
               + CONNECTION_SERVER_NAME + ":3306/" + CONNECTION_DBINSTANCE
               + "?useUnicode=true&characterEncoding=UTF-8";

        private MySqlDAOFactory() {}
        /**
         *返回一个MySqlDAOFactory对象
         *@returnMySqlDAOFactory类型对象
         */
        publicstatic MySqlDAOFactory newInstance() {
           returnnew MySqlDAOFactory();
        }
        /**
         *得到一个Connection对象
         *@returnjava.sql.Connection
         */

       public Connection getConnection() {
           Connection conn = null;
           try {
               Class.forName( CONNECTION_DRIVER );
               conn = DriverManager.getConnection(
                      CONNECTION_URL, CONNECTION_USER, CONNECTION_PWD );
           } catch ( ClassNotFoundException e ) {
               e.printStackTrace();
           } catch ( SQLException e ) {
               e.printStackTrace();
           }
           return conn;
        }
    }

    修改config.properties配置文件：
    #Oracle
    oracle_server_name=localhost
    oracle_conn_driver=oracle.jdbc.driver.OracleDriver
    oracle_dbInstance=dy
    oracle_conn_user=scott
    oracle_conn_pwd=tiger

    #SqlServer
    sqlserver_server_name=localhost
    sqlserver_conn_driver=com.microsoft.jdbc.sqlserver.SQLServerDriver
    sqlserver_dbInstance=test
    sqlserver_conn_user=sa
    sqlserver_conn_pwd=sa

    #MySql
    mysql_server_name=localhost
    mysql_conn_driver=com.mysql.jdbc.Driver
    mysql_dbInstance=test
    mysql_conn_user=root
    mysql_conn_pwd=root

    最后，修改客户端文件DAOClient.java代码：
    import java.sql.*;
    public class DAOClient {
        public static void main( String[] args ) {
           DAOFactory dao = DAOFactory.getDAOFactory( DAOFactory.ORACLE );
           Connection conn = dao.getConnection();
           System.out.println( conn.toString() );
        }
    }

    通过这种DAO+(Abstract)Factory方式，在将程序迁移到其它数据库中时，在客户端程序中几乎不用做修改，唯一需要做的，就是在获得DAOFactory对象的时候，修改相应的参数，例如，迁移到MySql下的时候：
    DAOFactory dao = DAOFactory.getDAOFactory( DAOFactory.MYSQL );

分享到：
| Java中的代理模式
评论
1 楼 liangwenzheng 2008-11-15  

leanrning
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    如何重构DAO模式

    ### 如何重构DAO模式 #### 一、引言 数据访问对象（DAO，Data Access Object）模式是一种在软件开发中非常流行的模式，特别是在那些需要处理大量数据的应用程序中。通过抽象和封装对数据源的所有访问操作，DAO模式...

    重构DAO

    重构DAO DAO（Data Access Object）模式是一种常用的设计模式，旨在抽象和封装对数据源的访问。通过使用DAO模式，可以降低商业逻辑层和数据访问层的耦合度，提高应用的可维护性和可移植性。 1. DAO模式的优点 ...

    如何重构DAO模式源文件

    总之，重构DAO模式源文件是一个旨在提升代码质量和可维护性的过程。通过合理地设计接口、消除冗余、解耦合和利用设计模式，我们可以让代码更加健壮，便于团队协作和长期维护。同时，不要忘记在整个重构过程中保持...

    j2ee重构DAO&MVC等模式.ppt

    本文主要探讨了Java开发中的几种常见设计模式：简单工厂、工厂模式、单例模式、DAO模式以及MVC模式。这些模式在实际项目中扮演着重要角色，有助于提高代码的可维护性和灵活性。 首先，简单工厂模式是一种用于创建...

    运用DAO和对象化进行重构_项目教程(2)_复习

    1. DAO模式：DAO模式的核心在于创建一个接口或抽象类，定义了对数据访问的操作，然后提供具体的实现类来处理实际的数据操作，如SQL查询。这样，当数据库技术发生变化时，只需要修改具体的实现，而不会影响到业务逻辑...

    运用DAO和对象化进行重构_项目教程(1)_

    标题中的“运用DAO和对象化进行重构”指的是在现有代码基础上，通过引入DAO模式和更深入的面向对象设计，对项目进行优化的过程。重构是为了提高代码的结构，使其更易理解、扩展和维护，而DAO和对象化是实现这一目标...

    DAOPattern(设计模式).pdf

    本文将根据提供的部分文件内容，详细介绍DAO模式的核心概念、动机以及其实现方式。 #### 动机与背景 在J2EE环境中，存在多种不同的规范和机制用于访问持久化存储和遗留数据。例如，在企业级Java Beans应用程序中，...

    jspdaoguestbook_java_dao2006com_typical3xe_

    "结合DAO设计模式，通过JSP+DAO修改之前的留言管理程序"表明此项目不仅是一个全新的开发，而且可能是对先前的留言系统的升级或重构，利用DAO模式来优化数据访问层。 【标签】"java dao2006com typical3xe"中的"java...

    dao-design-pattern:用PHP实现DAO设计模式的示例

    - **ORM（对象关系映射）**：虽然DAO模式不直接涉及ORM，但有时可以与ORM框架（如Doctrine）结合使用，以减少手动编写SQL的负担。 理解DAO设计模式及其在PHP中的应用对于开发高质量、可维护的Web应用程序至关重要。...

    Java宠物管理系统

    DAO模式是软件设计中常用的一种模式，它将数据访问逻辑与业务逻辑分离，使得代码更易于测试和重构。 在该系统中，数据库配置和接口实现类的配置都是通过XML文件完成的。XML文件是一种结构化的数据存储格式，常用于...

    简析DAO的发展进程及治理机制.pdf

    分布式自治组织（DAO）是一种基于区块链技术的新型组织形态，由共享规则驱动，实现分散决策和自动化任务...随着技术的演进和社会接受度的提高，DAO有望在解决现有问题的基础上，开创出更加创新的治理模式和应用场景。

    中南大学软件学院架构jpetstore重构

    - 分析现有代码：理解原有系统的业务逻辑，识别出需要重构的部分。 - 设计新的架构：基于Struts2重新规划应用的结构，确定Action类、Service层和DAO层的职责。 - 实现Struts2配置：编写struts.xml配置文件，定义...

    daodao-android.zip

    在现代Android开发中，混合开发模式下，前端部分可能采用React Native或Cordova等技术，此时JavaScript代码用于构建用户界面并处理部分业务逻辑。 3. **pc.js** 和 **dn.js**：同样可能是JavaScript文件，可能与主...

    springmvc重构员工管理系统

    在IT行业中，SpringMVC是Java企业级应用开发中...通过以上步骤，我们可以利用SpringMVC的强大功能，构建出一个高效、稳定、易于维护的员工管理系统。这不仅提升了开发效率，也为后期的系统扩展和升级打下了坚实的基础。

    Hibernate泛型DAO接口，大部分通用都已包括

    泛型DAO是DAO模式的一种改进，它引入了Java的泛型特性，使得DAO接口或实现类可以支持多种类型的实体类。这大大提高了代码的复用性，减少了重复的代码编写。例如，我们有以下一个简单的泛型DAO接口： ```java public...

    spring3.1+hibernate4+Jpa Dao

    DAO模式是一种设计模式，用于隔离业务逻辑层和数据访问层，使得业务逻辑层不受底层数据存储方式的影响。在"spring3.1+hibernate4+jpa框架集成Dao部分"中，DAO层通常是： 1. **泛型设计**：使用泛型可以创建更通用的...

    junit-test-dao

    - **定义**：DAO是一种设计模式，用于封装对数据库的访问操作，将业务逻辑与数据访问逻辑分离。 - **作用**：提高代码的可维护性和可扩展性，简化业务逻辑层的代码。 **2. 单元测试挑战** - **依赖问题**：DAO...

    java MVC模式范例

    Java MVC（Model-View-...总结起来，Java MVC模式范例是一个典型的Web应用程序设计案例，通过模型处理数据，视图展示数据，控制器协调二者，配合DAO模式实现与数据库的交互，以达到高效、可维护的软件开发目标。

Magicbox
Global site tag (gtag.js) - Google Analytics