JDBC（三）DAO设计

一、DAO的设计思想

1.没有DAO的情况

当应用中没有DAO设计的时候,会出现什么问题.-->为了解决功能重复问题.

  • 1.当只有一个客户端处理数据时，如下图，此时的设计,在客户端中编写了操作JDBC的代码.这从功能上分析,是没有问题的.
单客户端对DB的操作.png
  • 2.但是上面的方法存在功能代码重复的问题。因为把功能代码编写在客户端中,此时若有3个客户端,则功能代码会重复3次.效果如下图:
多客户端对DB的操作.png
  • 3.该问题的解决方案,我们从之前的开发经验入手去分析:
    数组 :存储数据,把数据存储到内存中.
    数据库:存储数据,把数据存储到磁盘中.

数组的相关操作:
1):把数据存储到数组.
2):取出数组中的数据.
3):修改数组中的数据.
4):删除数组中的数据.
此时,也是在每一个客户端中编写代码,如此一来,在每一个客户端中代码依然重复.编写一个数组的工具类:ArrayList.把所有和数组相关的CRUD操作封装在ArrayList类中.以后,客户端需要什么功能,就只需要创建ArrayList对象,并调用相应的方法即可(如下图).

数组的方式处理多客户端对DB的操作.png

2.DAO的介绍

  • DAO(Data Access Object)是一个数据访问接口，数据访问：顾名思义就是与数据库打交道。夹在业务逻辑与数据库资源中间。

  • 在核心J2EE模式中是这样介绍DAO模式的：为了建立一个健壮的J2EE应用，应该将所有对数据源的访问操作抽象封装在一个公共API中。

  • 用程序设计的语言来说，就是建立一个接口，接口中定义了此应用程序中将会用到的所有事务方法。在这个应用程序中，当需要和数据源进行交互的时候则使用这个接口，并且编写一个单独的类来实现这个接口在逻辑上对应这个特定的数据存储。

  • DAO中的主要操作:增删改查(CRUD).引入DAO之后,此时设计如下图:

DAO在逻辑上的关系.png

上面的设计图是使用了DAO思想之后的设计,
从功能的正确与否的角度分析没有问题,但是考虑设计save和get方法：

public void save(String name,Integer age){}

若参数过多,此时save方法的参数就会出现爆炸式增长.

public XXX get(Long id){}

此时查询指定ID的某一个学生信息,问题:XXX表示什么类型.
此时:若XXX表示String,就只能查询学生的名字.
若XXX表示Integer,就只能查询学生的名字.
那如果,我同时想得到学生的名字和年龄,怎么办?????
解决方案:把学生的信息封装成一个对象(Student).

数据对象的形式在DAO中处理.png
学生对象的DAO操作.png

二、DAO的规范

DAO其实是一个组件(可以重复使用),包括:

1.分包规范:

域名倒写.项目模块名.组件;

   com.song.pss.domain;  //装pss模块的domain类,模型对象.
   com.song.pss.dao;     //装pss模块的dao接口.
   com.song.pss.dao.impl;//装pss模块的dao接口的实现类.
   com.song.pss.test;    //暂时存储DAO的测试类,以后的测试类不应该放这里.
包结构.png

2.声明类

dao对象的名字:xxxDAO,比如:employeeDAO/employeeDao,

  • Domain数据对象：以下的,Xxx都表示一个对象比如Employee,Department.
  • DAO 接口: IXxxDAO/IXxxDao, IEmployeeDAO/IEmployeeDao:仅仅是表示对Employee对象的CRUD的封装
  • DAO实现类: XxxDAOImpl/XxxDaoImpl,EmployeeDAOImpl/EmployeeDaoImpl:仅仅表示IEmployeeDAO的实现.
  • DAO测试类: XxxDAOTest:表名就是XxxDAO组件的测试类,应该测试DAO组件中的所有方法.

开发建议:面向接口编程,声明DAO对象:

(1) 传统的做法 :EmployeeDAOImpl dao = new EmployeeDAOImpl();
(2) 面向接口编程:IEmployeeDAO dao = new EmployeeDAOImpl();
把实现类赋给接口类型,体现多态的特性:可以屏蔽不同子类之间实现的差异.

public void show(List list){}

3.一般开发的顺序:

1):先建立模型对象:domain
2):编写DAO接口.
3):定义DAO实现类.
4):生产DAO测试类.
5):实现DAO实现类.
6):在DAO测试类中测试DAO方法.

4.调用:

show(new  ArrayList());  //YES
show(new  LinkedList()); //YES

三、DAO的实现

Student

public class Student {
    
    private Long id;
    
    private String name;
    
    private int age;
    
    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;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
  • IStudentDAO
public interface IStudentDAO {
    
    
    /**
     * 保存指定学生对象
     * @param stu
     */
    public void save(Student stu);
    
    
    /**
     * 更新指定id的学生对象
     * @param stu
     */
    public void update(Student stu);
    
    
    
    /**
     * 删除指定id的学生
     * @param id
     */
    public void delete(Long id);
    
    
    /**
     * 获取指定id学生的对象
     * @param id
     * @return
     */
    public Student getSingle(Long id);
    
    
    /**
     * 获取全部学生对象
     * @return
     */
    public List<Student> list();

}
  • StudentDAOImpl
public class StudentDAOImpl implements IStudentDAO {

    public void save(Student stu) {
        StringBuilder sb = new StringBuilder(100);
        sb.append("INSERT INTO t_student(name,age) VALUES(");
        sb.append("'").append(stu.getName()).append("'");
        sb.append(",").append(stu.getAge()).append(")");
        String sql = sb.toString();
        Connection conn = null;
        Statement st = null;
        try {
            // 加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 获取连接
            conn = DriverManager.getConnection("jdbc:mysql:///jarry", "root", "123456");
            // 获取语句对象
            st = conn.createStatement();
            // 执行
            System.out.println("save:" + sql);
            st.executeUpdate(sql);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            try {
                if (st != null) {
                    st.close();
                }
            } catch (Exception e3) {
                e3.printStackTrace();
            } finally {
                try {
                    if (conn != null) {
                        conn.close();
                    }
                } catch (Exception e3) {
                    e3.printStackTrace();
                }
            }
        }
    }

    public void update(Student stu) {
        StringBuilder sb = new StringBuilder(100);
        sb.append("UPDATE t_student SET name =");
        sb.append("'").append(stu.getName()).append("'");
        sb.append(",age = ").append(stu.getAge());
        sb.append(" WHERE id = ").append(stu.getId());

        String sql = sb.toString();
        Connection conn = null;
        Statement st = null;
        try {
            // 加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 获取连接
            conn = DriverManager.getConnection("jdbc:mysql:///jarry", "root", "123456");
            // 获取语句对象
            st = conn.createStatement();
            // 执行
            System.out.println("update:" + sql);
            st.executeUpdate(sql);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            try {
                if (st != null) {
                    st.close();
                }
            } catch (Exception e3) {
                e3.printStackTrace();
            } finally {
                try {
                    if (conn != null) {
                        conn.close();
                    }
                } catch (Exception e3) {
                    e3.printStackTrace();
                }
            }
        }
    }

    public void delete(Long id) {
        String sql = "DELETE t_student WHERE id = " + id;
        Connection conn = null;
        Statement st = null;
        try {
            // 加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 获取连接
            conn = DriverManager.getConnection("jdbc:mysql:///jarry", "root", "123456");
            // 获取语句对象
            st = conn.createStatement();
            // 执行
            System.out.println("delete:" + sql);
            st.executeUpdate(sql);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放资源

            try {
                if (st != null) {
                    st.close();
                }
            } catch (Exception e3) {
                e3.printStackTrace();
            } finally {
                try {
                    if (conn != null) {
                        conn.close();
                    }
                } catch (Exception e3) {
                    e3.printStackTrace();
                }
            }
        }
    }

    public Student getSingle(Long id) {
        String sql = "SELECT * FROM t_student WHERE id = " + id;
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            // 加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 获取连接
            conn = DriverManager.getConnection("jdbc:mysql:///jarry", "root", "123456");
            // 获取语句对象
            st = conn.createStatement();
            // 执行
            System.out.println("getSingle:" + sql);
            rs = st.executeQuery(sql);
            if (rs.next()) {
                Student stu = new Student();
                stu.setName(rs.getString("name"));
                stu.setAge(rs.getInt("age"));
                stu.setId(rs.getLong("id"));
                return stu;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            try {
                if (rs != null) {
                    rs.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            } finally {
                try {
                    if (st != null) {
                        st.close();
                    }
                } catch (Exception e3) {
                    e3.printStackTrace();
                } finally {
                    try {
                        if (conn != null) {
                            conn.close();
                        }
                    } catch (Exception e3) {
                        e3.printStackTrace();
                    }
                }
            }
        }
        return null;
    }

    public List<Student> list() {
        String sql = "SELECT * FROM t_student";
        List<Student> list = new ArrayList<Student>();
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            // 加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 获取连接
            conn = DriverManager.getConnection("jdbc:mysql:///jarry", "root", "123456");
            // 获取语句对象
            st = conn.createStatement();
            // 执行
            rs = st.executeQuery(sql);
            while (rs.next()) {
                Student stu = new Student();
                stu.setName(rs.getString("name"));
                stu.setAge(rs.getInt("age"));
                stu.setId(rs.getLong("id"));
                list.add(stu);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            try {
                if (rs != null) {
                    rs.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            } finally {
                try {
                    if (st != null) {
                        st.close();
                    }
                } catch (Exception e3) {
                    e3.printStackTrace();
                } finally {
                    try {
                        if (conn != null) {
                            conn.close();
                        }
                    } catch (Exception e3) {
                        e3.printStackTrace();
                    }
                }
            }
        }
        return null;
    }
}

四、重构设计

1.问题1:在DAO组件中每一个DAO方法,都得加载注册驱动,都得获取Connection对象.

存在问题:
每一个DAO方法的代码都重复了.如果要切换MySQL为Oracle,就得修改每一个DAO方法的代码.

// 加载驱动
Class.forName("com.mysql.jdbc.Driver");
// 获取连接
conn = DriverManager.getConnection("jdbc:mysql:///jarry", "root", "123456");

解决方案:
把DAO方法中的这四个连接数据库的基本信息(驱动名,url,账号,密码)作为DAO类的成员变量.

private String driverClassName="com.mysql.jdbc.Driver";
private String url="jdbc:mysql:///jarry";
private String userName="root";
private String password="123456";

提取之后,DAO方法的代码,只需要直接引用成员变量即可:

// 加载驱动
Class.forName(driverClassName);
// 获取连接
conn = DriverManager.getConnection(url, userName, password);

2.问题2:问题1的解决方案,已经把四个连接数据库的基本信息(驱动名,url,账号,密码)作为DAO类的成员变量.

这本身是没有问题的,但是:在实际开发中,往往不止一个DAO类,难道每一个DAO实现类都得编写.

解决方案:
定义一个Jdbc的工具类:JdbcUtil,把上述四行代码定义在JdbcUtil类中,然后各个DAO类直接调用即可.

public class JdbcUtil {

    public static String driverClassName="com.mysql.jdbc.Driver";
    public static String url="jdbc:mysql:///jarry";
    public static String userName="root";
    public static String password="123456";

}

此时在DAO方法中的调用代码如下:

// 加载驱动
Class.forName(JdbcUtil.driverClassName);
// 获取连接
conn = DriverManager.getConnection(JdbcUtil.url, JdbcUtil.userName, JdbcUtil.password);

3.问题3:问题2在JdbcUtil中的使用public来修饰变量,破坏封装了.

在问题2:其实每一个DAO方法,只需要获取Connection对象即可,是不需要关系如何创建Connection的.

解决方案:
在JdbcUtil类中向外暴露一个getConn方法,用于向调用者返回Connection对象.

public class JdbcUtil {
    
    
    private static String driverClassName="com.mysql.jdbc.Driver";
    private static String url="jdbc:mysql:///jarry";
    private static String userName="root";
    private static String password="123456";
    
    
    
    public static Connection getConn(){
        Connection conn = null;
        try {
            // 获取连接
            Class.forName(JdbcUtil.driverClassName);
            // 加载驱动
            conn = DriverManager.getConnection(url, userName, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }
    
}

此时在DAO方法中的调用代码如下:

// 获取连接
conn = JdbcUtil.getConn();

4.在DAO方法中都会调用JdbcUtil.getConn()方法,但是在getConn方法底层,每次调用都会重新加载注册一次驱动,而这是没有必要的.

解决方案:如何保证加载注册驱动只会执行一次?把加载注册驱动代码,存放到JdbcUtil的静态代码块中。

public class JdbcUtil {
    
    
    private static String driverClassName="com.mysql.jdbc.Driver";
    private static String url="jdbc:mysql:///jarry";
    private static String userName="root";
    private static String password="123456";
    
    
    public JdbcUtil() {
             //在JdbcUtil的字节码被加载进JVM就执行，只是执行一次
        try {
            // 获取连接
            Class.forName(JdbcUtil.driverClassName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static Connection getConn(){
        Connection conn = null;
        try {
            // 加载驱动
            conn = DriverManager.getConnection(url, userName, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }
    
}

5.问题5:每一个DAO方法都得关闭资源(没有任何技术含量,但是又必须得写).

解决方案:在JdbcUtil类中定义close方法,专门用于关闭资源.
此时在DAO方法中的调用代码如下:

JdbcUtil.close(conn, st, rs);   // 如果是查询方法需要关闭资源
JdbcUtil.close(conn, st, null);  //  如果是增删改方法需要关闭资源

6.问题6:在JdbcUtil类中,定义了连接数据库的四个基本信息,虽然即使以后需要切换数据库,只需要修改一次.

但是,需要修改源代码(因为我们在代码中写死了信息(硬编码)).
解决方案:把数据库的连接信息抽取到一个配置文件(properties/xml)中去.
db.properties放在代码根目录下：

Paste_Image.png
drvierClassName = com.mysql.jdbc.Driver
url=jdbc:mysql:///jdbcdemo
username=root
password=admin

新的问题:如何在Java代码中读取db.properties文件,并获取其中的信息.

以后,实施人员需要修改数据库的连接信息,只需要修改db.properties文件即可.

public class JdbcUtil {
    
    

    private static Properties properties=new Properties();
    static {
        //在JdbcUtil的字节码被加载进JVM就执行，只是执行一次
        try {
            InputStream inStream=Thread.currentThread().getContextClassLoader()
                    .getResourceAsStream("db.properties");
            properties.load(inStream);
            Class.forName(properties.getProperty("driverClassName"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    
    
    
    public static Connection getConn(){
        Connection conn = null;
        try {
            // 加载驱动
            conn = DriverManager.getConnection(properties.getProperty("url"), properties.getProperty("userName"), properties.getProperty("password"));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }
    
}

7.问题7:在DAO方法中拼接SQL,太恶心了.

解决方案:预编译语句对象来解决.

8.问题8:此时,每一个Connection对象,获取之后只使用一次就关闭了(获取连接/关闭连接比较耗性能),没有充分利用Connection对象.

解决方案:连接池思想.

9.问题9:在DAO实现类中,增删改操作的代码模板相同,查询操作代码模板相同,存在了相同的代码结构.

解决方案:JdbcTemplate.

10.问题10:我不想拼SQL,拼SQL不爽,能不能一行代码就搞定操作呢.

解决方案:期待Hibernate框架.

五.预编译语句对象-PreparedStatement

1.PreparedStatement的实现

public class PreParedStatementTest extends TestCase{
    
    
    //statement
    public  void testStatement() throws SQLException{
        String sql="INSERT INTO t_student (name,age) VALUES ('marry',18)";
        Connection conn=JdbcUtil.getConn();
        Statement st = st=conn.createStatement();
        st.execute(sql);
        JdbcUtil.close(conn, st, null);
    }
    
    
    //preparedStatement
    public void testPreparedStatement() throws SQLException{
        String sql="INSERT INTO t_student (name,age) VALUES (?,?)";
        Connection conn=JdbcUtil.getConn();
        PreparedStatement ps = conn.prepareStatement(sql);
        ps.setString(1, "kity");
        ps.setInt(2, 23);
        ps.executeUpdate();
        JdbcUtil.close(conn, ps, null);
    }

}

2.Statement和PreparedStatement的区别:

PreparedStatement存在的优势:
1):更好的可读性,可维护性.
2):可以提供更好的性能(预编译).MySQL不支持PreparedStatement性能优化.
3):更安全,可以防止SQL注入的问题.

PrepareStatement的优势.png
防止SQL注入.png
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,530评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 86,403评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,120评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,770评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,758评论 5赞 367
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,649评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,021评论 3赞 398
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,675评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,931评论 1赞 299
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,659评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,751评论 1赞 330
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,410评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,004评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,969评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,203评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,042评论 2赞 350
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,493评论 2赞 343

推荐阅读更多精彩内容