在DAO模式中，数据库的关闭和异常处理，都是在什么地方，什么时候？
有的说过，在DAO的代码中，数据库不用显式的关闭，它会自动关闭，数据库的异常处理交直接抛出给调用它的方法，即谁调用它就有谁来处理？这具体说，是什么意思

大家对这方面的理解呢？

我举例说明一下啊！
//查询一个表中的数据
public NoteForm selectById(int id) {
                NoteForm note = new NoteForm();
                con = new DBConnection();
                sql = "select id,title,author,content from note where id=?";
                try {
                        pstmt = con.getCon().prepareStatement(sql);
                        pstmt.setInt(1, id);
                        rs = pstmt.executeQuery();
                       
                        if(rs.next()) {
                                note.setId(rs.getInt("id"));
                                note.setTitle(rs.getString("title"));
                                note.setAuthor(rs.getString("author"));
                                note.setContent(rs.getString("content"));
                        }
                } catch (SQLException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();//此处处理异常
                } finally {
                        try { //此处关闭数据库
                                rs.close();
                                pstmt.close();
                                con.close();
                        } catch (SQLException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                       
                }
               
                return note;
        }

//添加
        public void insert(NoteForm note) {
                con = new DBConnection();
                sql = "insert into note(title,author,content) values(?,?,?)";
                try {
                        pstmt = con.getCon().prepareStatement(sql);
                        pstmt.setString(1, note.getTitle());
                        pstmt.setString(2, note.getAuthor());
                        pstmt.setString(3, note.getContent());
                        pstmt.executeUpdate();
                       
                } catch (SQLException e) {//此处又是处理异常
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                } finally {
                        try {//同样是关闭数据库
                                pstmt.close();
                                con.close();
                        } catch (SQLException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                }
        }
以上只是本人的一点愚见，未知可否为你解惑？

我在学习JDBC时候对数据库操作也是非常混乱,但是后来我就理清了思路了,

我和楼主分享下经验吧!
这些是必要的属性
        private Statement stmt;
        private PreparedStatement pstmt;
        private ResultSet rs;
        private Connection con;
首先是这个获取连接串的方法:
        private Connection getConn(){
                String driverName=ProReader.getInstance().getProperty("driverClassName");
                String url=ProReader.getInstance().getProperty("url");
                String user=ProReader.getInstance().getProperty("username");
                String password=ProReader.getInstance().getProperty("password");
                try {
                        Class.forName(driverName);
                        con=DriverManager.getConnection(url,user,password);
                } catch (ClassNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                } catch (SQLException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                return con;
        }
采取的是配置文件读取,可支持编译后的数据库字符串变动的修改

这个ClossAll方法可关闭所有连接,并且防止了空指针异常的出现
        public void closeAll(){
                        try {
                                if(pstmt!=null){
                                pstmt.close();
                                }
                                if(stmt!=null){
                                        stmt.close();
                                }
                                if(rs!=null){
                                        rs.close();
                                }
                                if(con!=null){
                                        con.close();
                                }
                        } catch (SQLException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
        }

接下来是这个构造方法的实现

在构造的同时获取了数据库连接串,并且将Statement 创建,你就可以直接执行对数据库的操作了

        public BaseDao(){
                closeAll();
                con=getConn();
                try {
                        stmt=con.createStatement();
                } catch (SQLException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }

最后是通用的方法

public Object execute(String sql,boolean isQuery){
                if(isQuery){
                        return executeQuery(sql);
                }else{
                        return executeUpdate(sql);
                }
        }
        public ResultSet executeQuery(String sql){
                try {
                       
                        rs=stmt.executeQuery(sql);
                } catch (SQLException e) {
                        e.printStackTrace();
                }
                return rs;
        }
        public int executeUpdate(String sql){
                int ret=-1;
                try {
                        ret=stmt.executeUpdate(sql);
                } catch (SQLException e) {
                        e.printStackTrace();
                }
                return ret;
        }
        public ResultSet pExecuteQuery(String sql,Object [] param){
                try {
                        if(pstmt!=null){
                                pstmt.close();
                        }
                        pstmt=con.prepareStatement(sql);
                        for(int i=1;i<=param.length;i++){
                                pstmt.setObject(i, param[i-1]);
                        }
                        return pstmt.executeQuery();
                } catch (SQLException e) {
                        e.printStackTrace();
                        return null;
                }
        }
        public int pExecuteUpdate(String sql,Object [] param){
                try {
                        if(pstmt!=null){
                                pstmt.close();
                        }
                        pstmt=con.prepareStatement(sql);
                        for(int i=1;i<=param.length;i++){
                                pstmt.setObject(i, param[i-1]);
                        }
                        return pstmt.executeUpdate();
                } catch (SQLException e) {
                        e.printStackTrace();
                        return -1;
                }
        }
        public Object pExecute(String sql,Object [] param,boolean isQuery){
                if(isQuery){
                        return pExecuteQuery(sql, param);
                }else{
                        return pExecuteUpdate(sql, param);
                }
        }



不过在最后别忘记关闭数据库,调用下closeAll方法就可以将所有的关闭!

public Boolean validate() throws SQLException{
               
                String sql="select userID from userInfo where loginName=? and loginPass=?";
                BaseDao bd=new BaseDao();
                ResultSet rs=bd.pExecuteQuery(sql, new Object[]{getLoginName(),getLoginPass()});
                if(rs.next()){
                        bd.closeAll();
                        return true;
                }else{
                        bd.closeAll();
                        return false;
                }
        }

楼主要是对JDBC有兴趣可以QQ上找我要的这个BaseDao,我之前写项目时候就是用这个BaseDao(),在开发过程中是没有任何问题的

你QQ多少？我的563952634

楼上的两位还是没有直接回答我的问题啊，我看两位的代码，意思应该是数据库的异常处理和关闭是在具体的方法实现的时候，不是在被调用的时候处理了。

那我再问一下，被调用处还需要处理吗？？？？？？