JDBC第二次学习

时间：2023-03-09 05:51:56
JDBC第二次学习

脑子太笨，必须得记录下来一些文字，方便回来查询。

这是我的第二次学习JDBC的笔记，看的是传智播客——李勇老师的JDBC系列，已看到第23集。

分析在实际项目中该如何应用JDBC

一个简单用户相关的数据访问层

  1. J2EE三层架构简介：表示层 、业务逻辑层、数据访问层，三层之间用接口隔离。

  2. 定义domain对象User，定义存取用户的接口。

  3. 用JDBC实现接口。

  4. 用配置文件(properties)和反射实现与具体类的耦合。

用图来表示：

JDBC第二次学习

在真实的项目开发中，我们能不能返回ResultSet对象呢? 如下例代码：

static ResultSet read() throws SQLException {

        Connection conn = null;

        Statement st = null;

        ResultSet rs = null;

        try {

            //2.建立连接

            conn = JdbcUtils.getConnection();

            //3.创建语句

            st = conn.createStatement();

            //4.执行语句

            rs = st.executeQuery("select id,name,birthday,money from user");

            //5.处理结果

            while(rs.next()) {

                System.out.println(rs.getObject("id")+"\t"+rs.getObject("name")+

                        "\t"+rs.getObject("birthday")+"\t"+rs.getObject("money"));

            }
return rs;//连接关闭，Statement、ResultSet都失效了。

        } finally {

            JdbcUtils.free(rs, st, conn);

        }

    }

在main()方法中调用：

ResultSet rs = read();

这个其实是不可以的，当Connection关闭之后，ResultSet中的数据你就拿不到了(Statement、ResultSet都失效了)。如果我们要进行传值需要定义个domain对象。

我们重点关注数据访问层的代码如何书写

1、定义domain对象User以及存取用户的接口：

import cn.itcast.jdbc.domain.User;

public interface UserDao {

    public void addUser(User user);

    public User getUser(int userId);

    public User findUser(String loginName, String password);

    public void update(User user);

    public void delete(User user);

}
import java.util.Date;

public class User {

    private int id;

    private String name;

    private Date birthday;

    private float money;

    public int getId() {

        return id;

    }

    public void setId(int id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public Date getBirthday() {

        return birthday;

    }

    public void setBirthday(Date birthday) {

        this.birthday = birthday;

    }

    public float getMoney() {

        return money;

    }

    public void setMoney(float money) {

        this.money = money;

    }

}

2、用JDBC实现接口。在实现的过程中，准确一点说会出现SQLException。关于这个异常的处理，很多工作2年的程序员都不知道怎么样处理，所以对于此异常，定当重视，通常我们结合Service层讲解DAO层的异常处理的方式。

就拿addUser(user)方法来说，中间是有可能出现SQLException的，在处理异常的时候，不能catch住异常之后什么都不做，最起码要打印一下堆栈，最好的方式是将这个异常转化为RuntimeException抛出。做法如下：

建立一个DaoException继承RuntimeException，如下：

public class DaoException extends RuntimeException {

    /**

     *

     */

    private static final long serialVersionUID = 1L;

    public DaoException() {

        // TODO Auto-generated constructor stub

    }

    public DaoException(String message) {

        super(message);

        // TODO Auto-generated constructor stub

    }

    public DaoException(Throwable cause) {

        super(cause);

        // TODO Auto-generated constructor stub

    }

    public DaoException(String message, Throwable cause) {

        super(message, cause);

        // TODO Auto-generated constructor stub

    }

    public DaoException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {

        super(message, cause, enableSuppression, writableStackTrace);

        // TODO Auto-generated constructor stub

    }

}

之后JDBC实现接口的过程中，就抛出DaoException异常，如下(代码太多，折叠之)：

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import cn.itcast.jdbc.JdbcUtils;

import cn.itcast.jdbc.dao.DaoException;

import cn.itcast.jdbc.dao.UserDao;

import cn.itcast.jdbc.domain.User;

public class UserDaoJdbcImpl implements UserDao {

    @Override

    public void addUser(User user) {

        Connection conn = null;

        PreparedStatement ps = null;

        ResultSet rs = null;

        try {

            //2.建立连接

            conn = JdbcUtils.getConnection();

            //3.创建语句

            String sql = "insert into user (name,birthday,money) values (?,?,?)";

            ps = conn.prepareStatement(sql);

            ps.setString(1, user.getName());

            ps.setDate(2, new java.sql.Date(user.getBirthday().getTime()));

            ps.setFloat(3, user.getMoney());

            //4.执行语句

            ps.executeUpdate();

        } catch(SQLException e) {

            throw new DaoException(e.getMessage(), e);

        } finally {

            JdbcUtils.free(rs, ps, conn);

        }

    }

    @Override

    public User getUser(int userId) {

        Connection conn = null;

        PreparedStatement ps = null;

        ResultSet rs = null;

        User user = null;

        try {

            //2.建立连接

            conn = JdbcUtils.getConnection();

            //3.创建语句

            String sql = "select id,name,birthday,money from user where id = ?";

            ps = conn.prepareStatement(sql);

            ps.setInt(1, userId);

            //4.执行语句

            rs = ps.executeQuery();

            //5.处理结果

            while(rs.next()) {

                /*

                 * 优化①处

                 */

                user = mappingUser(rs);

            }

        } catch(SQLException e) {

            throw new DaoException(e.getMessage(), e);

        } finally {

            JdbcUtils.free(rs, ps, conn);

        }

        return user;

    }

    @Override

    public User findUser(String loginName, String password) {

        Connection conn = null;

        PreparedStatement ps = null;

        ResultSet rs = null;

        User user = null;

        try {

            //2.建立连接

            conn = JdbcUtils.getConnection();

            //3.创建语句

            String sql = "select id,name,birthday,money from user where name = ?";

            ps = conn.prepareStatement(sql);

            ps.setString(1, loginName);

            //4.执行语句

            rs = ps.executeQuery();

            //5.处理结果

            while(rs.next()) {

                /*

                 * 优化①处

                 */

                user = mappingUser(rs);

            }

        } catch(SQLException e) {

            throw new DaoException(e.getMessage(), e);

        } finally {

            JdbcUtils.free(rs, ps, conn);

        }

        return user;

    }

    private User mappingUser(ResultSet rs) throws SQLException {

        User user = new User();

        user.setId(rs.getInt("id"));

        user.setName(rs.getString("name"));

        user.setMoney(rs.getFloat("money"));

        user.setBirthday(rs.getDate("birthday"));

        return user;

    }

    @Override

    public void update(User user) {

        Connection conn = null;

        PreparedStatement ps = null;

        ResultSet rs = null;

        try {

            //2.建立连接

            conn = JdbcUtils.getConnection();

            //3.创建语句

            String sql = "update user set name = ?,birthday = ?,money = ? where id = ?";

            ps = conn.prepareStatement(sql);

            ps.setString(1, user.getName());

            ps.setDate(2, new java.sql.Date(user.getBirthday().getTime()));

            ps.setFloat(3, user.getMoney());

            ps.setInt(4, user.getId());

            //4.执行语句

            ps.executeUpdate();

        } catch(SQLException e) {

            throw new DaoException(e.getMessage(), e);

        } finally {

            JdbcUtils.free(rs, ps, conn);

        }

    }

    @Override

    public void delete(User user) {

        Connection conn = null;

        Statement st = null;

        ResultSet rs = null;

        try {

            //2.建立连接

            conn = JdbcUtils.getConnection();

            //3.创建语句

            st = conn.createStatement();

            //4.执行语句

            String sql = "delete from user where id = "+user.getId();

            st.executeUpdate(sql);

        } catch(SQLException e) {

            throw new DaoException(e.getMessage(), e);

        } finally {

            JdbcUtils.free(rs, st, conn);

        }

    }

}

用配置文件(properties)和反射实现与具体类的耦合(?)，此时就要用到工厂模式了。

DaoFactory类如下(视频说代码很经典，谁知道呢？)：

import java.io.InputStream;

import java.util.Properties;

public class DaoFactory {

    /*

     * 注意两个static属性之间的顺序

     * 如果搞反，那么属性userDao始终为空!

     */

    private static UserDao userDao = null;

    private static DaoFactory instance = new DaoFactory();

    private DaoFactory() {

        try {

            Properties prop = new Properties();

            /*

             * 方式一

             * 缺点：路径是写死的，如果我们的配置文件改变了地方，就找不到文件了 。

             */

            //FileInputStream fis = new FileInputStream("src/daoconfig.properties");

            /*

             * 方式二

             * 优点：用类加载器(马丹，涉及到反射技术，又是一个要补的地方)的方法

             * 来得到一个文件的输入流，只要这个文件在classpath路径下(其实编译的xxx.class文件和配置文件

             * 就在根目录下bin目录中，而次bin目录被自动加载到classpath变量值中(别问我why?我也不知道))就能找到。

             */

            InputStream fis = DaoFactory.class.getClassLoader()//类加载器(???)

                    .getResourceAsStream("daoconfig.properties");//daoconfig.properties只要在classpath路径下，就可以加载进来，更加灵活

            prop.load(fis);

            String userDaoClass = prop.getProperty("userDaoClass");

            /*

             * 涉及到反射技术

             */

            Class clazz = Class.forName(userDaoClass);//将类加载到JVM

            userDao = (UserDao)clazz.newInstance();//实例化一个对象

            //System.out.println(userDao);

        } catch (Throwable e) {

            throw new ExceptionInInitializerError(e);

        }

    }

    public static DaoFactory getInstance() {

        return instance;

    }

    public UserDao getUserDao() {

        //System.out.println(userDao);

        return userDao;

    }

}

整体的框架图应该如这幅模样：

JDBC第二次学习

JDBC事务处理

关于事务，我已经在《浅谈事务》一文中详细记录过，在此不赘述了。我们只关注JDBC是如何处理事务的。

示例1(用代码来体现)：

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

public class TxIsolateTest {

    public static void main(String[] args) throws SQLException {

        test();

    }

    static void test() throws SQLException {

        Connection conn = null;

        Statement st = null;

        ResultSet rs = null;

        try {

            conn = JdbcUtils.getConnection();

            /*

             * 设置事务为手动提交，一说也叫打开事务。

             */

            conn.setAutoCommit(false);

            /*

             * 设置事务的隔离级别，这是一个超麻烦的问题，李勇老师也是敷衍过去！

             */

            conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

            String sql = "update user set money = money - 10 where id = 1";

            st = conn.createStatement();

            st.executeUpdate(sql);

            sql = "select money from user where id = 2";

            rs = st.executeQuery(sql);

            float money = 0.0f;

            if(rs.next()) {

                money = rs.getFloat("money");

            }

            if(money > 400)

                throw new RuntimeException("已经超过最大值！");

            sql = "update user set money = money + 10 where id = 2";

            st.executeUpdate(sql);

            /*

             * 提交事务

             */

            conn.commit();

        } catch (SQLException e) {

            if(conn != null)

                /*

                 * 回滚事务，rollback()中不加任何参数，即为回滚所有操作

                 */

                conn.rollback();
throw e;

        } finally {

            JdbcUtils.free(rs, st, conn);

        }

    }

}

示例2：

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Savepoint;

import java.sql.Statement;

public class SavePointTest {

    public static void main(String[] args) throws SQLException {

        test();

    }

    static void test() throws SQLException {

        Connection conn = null;

        Statement st = null;

        ResultSet rs = null;

        Savepoint sp = null;

        try {

            conn = JdbcUtils.getConnection();

            conn.setAutoCommit(false);

            st = conn.createStatement();

            String sql = "update user set money = money - 10 where id = 1";

            st.executeUpdate(sql);

            /*

             * 设置保存点

             */

            sp = conn.setSavepoint();

            sql = "update user set money = money - 10 where id = 3";

            st.executeUpdate(sql);

            sql = "select money from user where id = 2";

            rs = st.executeQuery(sql);

            float money = 0.0f;

            if(rs.next()) {

                money = rs.getFloat("money");

            }

            if(money > 300)

                throw new RuntimeException("已经超过最大值！");

            sql = "update user set money = money + 10 where id = 2";

            st.executeUpdate(sql);

            conn.commit();

        } catch (RuntimeException e) {

            if(conn != null && sp != null) {

                conn.rollback(sp);//回滚到保存点上去，再提交，这样保证到保存点之前那些操作都是有效的(只回滚一部分操作)

                conn.commit();

            }
throw e;

        } catch (SQLException e) {

            if(conn != null)

                conn.rollback();
throw e;

        } finally {

            JdbcUtils.free(rs, st, conn);

        }

    }

}

JTA分布式事务的简要介绍(李勇老师也是敷衍过去了)

跨越多个数据源的事务，使用JTA容器(是啥，不知道？)实现事务。

分成两阶段提交。

代码格式总是如此：

javax.transaction.UserTransaction tx = (UserTransaction)ctx.lookup(“jndi(?)Name");

tx.begin();

//connection1 connection2 (可能来自不同的数据库)…

tx.commit();//tx.rollback();

相关文章