[关闭]
@wangyupu 2020-07-20T11:25:07.000000Z 字数 5513 阅读 19

JDBC(JAVA与数据库连接)

JDBC

导入步骤5步走

  1. 加载驱动Class.forName("com.mysql.jdbc.Driver");
  2. 使用DriverManager获取数据库connection连接
  3. 创建Statement对象 用于执行SQL语句
  4. 执行SQL语句
  5. 释放资源

数据库驱动

  1. com.microsoft.jdbc.sqlserver.SQLServerDriver(SQL Server)
  2. com.mysql.jdbc.Driver(MySql)
  3. oracle.jdbc.driver.OracleDriver(Oracle)

Statement常用对象

  1. ##ResultSet executeQuery（sql）
  2. #执行sql查询语句，并返回ResultSet对象

int executeUpdate(sql)

  1. 执行insert,update，delete语句，返回受影响行数

boolean execute(sql)

  1. 执行insert,update，delete语句，返回true或false false成功

防止数据库乱码及日期出错

  1. 放入url连接路径之后
  2. ?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull

PreparedStatement对象使用
防止SQL注入，使用占位符“?”方式进行SQL拼接

  1. #导入包   因为每个mysql-connector-java-5.1.0-  每个项目如果单独整的话都需要自己手动导包

老师讲课实录（标准写法）

  1.  Connection conn = null;//必须这样写就行了
  2.         Statement stat = null;//必须这样写就行了
  3.         try {
  4.             //加载驱动  
  5.             Class.forName("com.mysql.jdbc.Driver");
  6.             //准备数据库连接路径
  7.             String url = "jdbc:mysql://127.0.0.1:3306/xxshop";
  8.             //用户名与密码
  9.             String username = "root";
  10.             String userpwd = "root";
  11.             //根据路径，用户名，密码 使用DriverManager获取数据库connection连接
  12.              conn = DriverManager.getConnection(
  13.                     url,username,userpwd);
  14.             //准备要执行的SQL语句
  15.             String sql= "select user_id,user_name from sf_user";
  16.             //创建Statement对象  用于执行SQL语句
  17.             stat = conn.createStatement();
  18.             //执行SQL语句
  19.             ResultSet rs =  stat.executeQuery(sql);//查询用这个。增删改用Update
  20.             //处理ResultSet结果集
  21.             //rs.next()  返回boolean 值
  22.             while(rs.next()){
  23.                  Long user_id =  rs.getLong(1);
  24.                  String user_name = rs.getString(2);
  25.                  System.out.println("用户ID："+user_id);
  26.                 System.out.println("用户名："+user_name);
  27.             }
  28.         } catch (Exception e) {
  29.             e.printStackTrace();
  30.         } finally {
  31.             //释放资源
  32.             try {
  33.                 stat.close();
  34.                 conn.close();
  35.             } catch (SQLException e) {
  36.                 e.printStackTrace();
  37.             }
  38.         }

防止注入的写法

  1. 使用PreparedStatement对象进行用户登录
  3. /**
  4. * 定义登录方法(传入用户输入的用户名与密码)
  5. */
  6. public User loginUser(String user_name,String user_pwd){
  7.  Connection conn = null;
  8.  PreparedStatement ps = null;
  9. try {
  10. //加载驱动  方言
  11. Class.forName("com.mysql.jdbc.Driver");
  12.    //准备数据库连接路径
  13.  String url = "jdbc:mysql://127.0.0.1:3306/xxshop?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull";
  14. //用户名与密码
  15. String username = "root";
  16. String userpwd = "root";
  17. //获取Connection对象
  18. conn = DriverManager.getConnection(
  19.                     url,username,userpwd);
  20. //准备登录SQL语句  使用占位符?代表参数
  21. String sql ="select user_id,user_name from sf_user where user_name=? and user_password=?";
  22. //预编译SQL语句
  23. ps = conn.prepareStatement(sql);
  24. //ps.setXXXX(位置<从1开始>,值<参数>)
  25. ps.setString(1,user_name);
  26. ps.setString(2,user_pwd);
  27. //执行查询
  28. ResultSet rs = ps.executeQuery();
  29. //用于判断 等于null登录失败，否则成功
  30. User user = null;
  31.    while(rs.next()){
  32.  //进入循环，登录成功，创建user对象
  33.    user = new User();
  34. //使用rs.getXXX("返回的列名") 放入user对象
  35. user.setUser_id(rs.getLong("user_id"));  
  36. user.setUser_name(rs.getString("user_name"));
  37.    }
  38.    return user;//返回用户登录对象
  39.   } catch (Exception e) {
  40.             e.printStackTrace();
  41.         } finally {
  42.             //释放资源
  43.             try {
  44.                 ps.close();
  45.                 conn.close();
  46.             } catch (SQLException e) {
  47.                 e.printStackTrace();
  48.             }
  49.         }
  50. return null;
  51. }

返回List集合核心代码

  1.   List<Goods> goodsList  = new ArrayList<Goods>();
  2.             while(rs.next()){
  3.                 Goods goods = new Goods();
  4.                 goods.setGoods_id(rs.getLong("goods_id"));
  5.                 goods.setGoods_title(rs.getString("goods_title"));
  6.                 goods.setGoods_introduce(rs.getString("goods_introduce"));
  7.                 goodsList.add(goods);
  8.             }
  9.             return goodsList;

修改商品信息核心代码 对象入参

  1.    String sql = "update sf_goods set goods_title=?," +
  2.                     "goods_browse=?,goods_state=? where goods_id=?";
  3.             ps = conn.prepareStatement(sql);
  4.             ps.setString(1,goods.getGoods_title());
  5.             ps.setInt(2,goods.getGoods_browse());
  6.             ps.setInt(3,goods.getGoods_state());
  7.             ps.setLong(4,goods.getGoods_id());
  8.             int i = ps.executeUpdate();
  9.             return  i;

DAO模式的应用

  1. Data Access Object(数据存取对象) 持久层
  2. 创建包
  3. com.dao ----放接口文件 UserDao
  4. BaseDao（数据库工具类）
  5. com.dao.impl----放接口实现类 UserDaoImpl
  6. com.entity ----放实体类 User

封装JDBC

  1. /**
  2.  * 数据库工具类
  3.  */
  4. public class BaseDao {
  5.     Connection conn = null;
  6.     PreparedStatement ps = null;
  7.     //获取Conn对象 打开数据库链接
  8.     public boolean getConn() {
  9.         boolean bool = false;//默认 false 未打开数据库
  10.         try {
  11.             //加载驱动  方言
  12.             Class.forName("com.mysql.jdbc.Driver");
  13.             //准备数据库连接路径
  14.             String url = "jdbc:mysql://127.0.0.1:3306/xxshop?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull";
  15.             //用户名与密码
  16.             String username = "root";
  17.             String userpwd = "root";
  18.             //根据路径，用户名，密码 使用DriverManager获取数据库connection连接
  19.             conn = DriverManager.getConnection(
  20.                     url,username,userpwd);
  21.             bool = true;//已经打开
  22.         } catch (Exception e) {
  23.             e.printStackTrace();
  24.             bool = false ;//已经打开
  25.         }
  26.             return  bool;
  27.     }
  28.     /**
  29.      * 添加，修改，删除数据
  30.      * @param sql
  31.      * @param objs
  32.      * @return
  33.      */
  34.     public int executeUpdate(String sql,Object objs[])
  35.     {
  36.         int res = 0;//初始化执行结果  失败0
  37.         try {
  38.             if(getConn())//打开数据库链接
  39.             {
  40.                 ps = conn.prepareStatement(sql);
  41.                 if(objs!=null){
  42.                     for (int i = 0; i < objs.length; i++) {
  43.                         ps.setObject((i+1),objs[i]);
  44.                     }
  45.                 }
  46.                 res = ps.executeUpdate();
  47.             }
  48.         } catch (Exception e) {
  49.             e.printStackTrace();
  50.         } finally {
  51.             closeResource();//关闭数据源
  52.         }
  53.         return res;
  54.     }
  55.     /**
  56.      * 查询
  57.      * @param sql
  58.      * @param objs
  59.      * @return
  60.      */
  61.     public ResultSet executeSQL(String sql,Object objs[]){
  62.         ResultSet rs = null;
  63.         try {
  64.             if(getConn())//打开数据库链接
  65.             {
  66.                 ps = conn.prepareStatement(sql);
  67.                 //判断是否有参数
  68.                 if (objs != null) {
  69.                     //循环封装参数
  70.                     for (int i = 0; i < objs.length; i++) {
  71.                         ps.setObject((i + 1), objs[i]);
  72.                     }
  73.                 }
  74.                 rs = ps.executeQuery();
  75.             }
  76.         } catch (Exception e) {
  77.             e.printStackTrace();
  78.         } finally {
  79.             closeResource();//释放资源
  80.         }
  81.         return rs;
  82.     }
  83.     //关闭资源
  84.     public void closeResource(){
  85.         try {
  86.             if(ps!=null)
  87.             {
  88.                 ps.close();
  89.             }
  90.             if(conn!=null) {
  91.                 conn.close();
  92.             }
  93.         } catch (SQLException e) {
  94.             e.printStackTrace();
  95.         }
  96.     }
  97. }

调用工具类

  1. 实现类 继承 工具类（BaseDao）
  3. 查询：ResultSet rs = this.executeSQL(SQL语句,Object数组<参数数组>)
  5. 增，删，改: int i = this.executeUpdate(SQL语句,Object数组<参数数组>)
  7. 使用配置文件存储连接信息（properties文件）
  1. jdbc.driver=com.mysql.jdbc.Driver
  2. jdbc.url=jdbc:mysql://127.0.0.1:3306/xxshop?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull
  3. jdbc.username=root
  4. jdbc.pwd=root
  1.    Properties properties = new Properties();
  2. //读取properties文件  BaseDao为当前所在类
  3.  InputStream is = BaseDao.class.getClassLoader().getResourceAsStream("jdbc.properties");
  4.             //将文件信息转换成properties对象
  5.             properties.load(is);
  6.             //通过getProperty（KEY）方法获取属性值
  7.             String driver =  properties.getProperty("jdbc.driver");

使用资源绑定器绑定属性配置文件

  1. ResourceBundle Bundle = ReSourceBundle.getBundle(`配置文件名称`);
  2. String driver = bundle.getstring("driver");
  3. String url = bundle.getstring("url");
  4. String user = bundle.getstring("user");
  5. String password = bundle.getstring("password");
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注