JDBC的封装

女爷i 2024-04-07 15:04 70阅读 0赞

**目录**

JDBC封装的步骤：

1、在src里面创建一个文件，命名为：database.properties

2、定义实体类：实体类的表名与数据库的表名一致，表中大每一列为实体类的属性

3、将用户对象的所有操作抽取成接口

4、由不同数据库的实现类分别实现接口；实现类实现接口并继承数据库工具类

5、将通用的操作（如打开、关闭连接等）封装到工具类数据库工具类

6、在测试类进行测试

7、单例模式

--------------------

在编写JDBC时存在一些问题：

1、可读性差

2、不利于后期维护和修改

3、不利于代码复用

采用面向接口编程，可以降低代码间的耦合性

JDBC封装：

1、**隔离业务逻辑代码和数据访问代码**

2、**隔离不同数据库的实现**

### JDBC封装的步骤： ###

1、定义实体类传输数据

2、将所有增删改查操作抽取

3、由不同数据库的实现类分别实现接口

4、将通用的操作（打开，关闭连接，增删改查等）封装到数据库工具类BaseDao的通用方法中

具体实现：

#### 1、在src里面创建一个文件，命名为：database.properties ####

然后在里面添加一下数据

# 加载驱动
    driver = com.mysql.jdbc.Driver
    # 数据库地址
    url = jdbc:mysql://127.0.0.1:3306/myschool
    #用户名
    username = root
    #密码
    password = root

#### 2、定义实体类：实体类的表名与数据库的表名一致，表中大每一列为实体类的属性 ####

//创建一个年纪类
    public class Grade {
        /**
         * 年纪编号
         */
        private int gradeId;
        /**
         * 年假名称
         */
        private String gradeName;
    
        public Grade() {
        }
    
        public Grade(int gradeId, String gradeName) {
            this.gradeId = gradeId;
            this.gradeName = gradeName;
        }
    
        /**
         * 获取
         * @return gradeId
         */
        public int getGradeId() {
            return gradeId;
        }
    
        /**
         * 设置
         * @param gradeId
         */
        public void setGradeId(int gradeId) {
            this.gradeId = gradeId;
        }
    
        /**
         * 获取
         * @return gradeName
         */
        public String getGradeName() {
            return gradeName;
        }
    
        /**
         * 设置
         * @param gradeName
         */
        public void setGradeName(String gradeName) {
            this.gradeName = gradeName;
        }
        @Override
        public String toString() {
            return "Grade{gradeId = " + gradeId + ", gradeName = " + gradeName + "}";
        }
    }

数据库如下图：

![6437fecdc57c4e9fb5d97e60a50f3914.png][]

#### 3、将用户对象的所有操作抽取成接口 ####

/**
 * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
 * @author 
 * @date 2022-09-12 21:35:49
 * @version 1.0.0
 * @description 将年纪对象的所有操作抽取成接口
 * 实现对数据库的增删改查
 */
 
 public interface GradeDao {
 /**
 * @description 查询班级信息
 * key为空查询所有班级信息
 * key有值，根据key值进行模糊查询
 * @author
 * @date 2022-09-09 11:41:14
 * @param key 进行模糊查询的关键字
 * @return {@link List< Grade>}
 */
 List<Grade> getALL(String key);
 /**
 * @description 添加数据
 * @author
 * @date 2022-09-09 11:41:18
 * @param grade 年纪对象
 * @return {@link int}
 */
 int insertGrade(Grade grade);
 /**
 * @description 修改数据
 * @author
 * @date 2022-09-09 11:41:23
 * @param grade 年纪对象
 * @return {@link int}
 */
 int updateGrade(Grade grade);
 /**
 * @description 删除数据
 * @author
 * @date 2022-09-09 11:41:26
 * @param gradeId 年纪ID
 * @return {@link int}
 */
 int deleteGrade(int gradeId);
 }

#### **4、****由不同数据库的实现类分别实现接口****；****实现类实现接口并继承数据库工具类** ####

/**
 * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
 * @author 齐孟伟
 * @date 2022-09-12 21:58:38
 * @version 1.0.0
 * @description 数据库的实现类分别实现接口
 */
 
 public class GradeDaoImpl extends BaseDao implements GradeDao {
 /**
 * @description 查询班级信息
 * key为空查询所有班级信息
 * key有值，根据key值进行模糊查询
 * @author
 * @date 2022-09-09 11:41:14
 * @param key 进行模糊查询的关键字
 * @return {@link List< Grade>}
 */
 @Override
 public List<Grade> getALL(String key) {
 //sql语句
 String sql = "SELECT * FROM GRADE WHERE GRADENAME LIKE CONCAT('%',?,'%')";
 //将获取的key放进数组
 Object [] obj = {key};
 //处理返回结果
 ResultSet resultSet = this.select(sql,obj);
 //创建年纪对象
 Grade grade = null;
 //创建数组用来存储年纪对象
 List<Grade> gradeList = new ArrayList<>();
 try{
 //resultSet.next()：判断返回结果是否有值
 while (resultSet.next()){
 grade = new Grade();
 //获取数据库表的内容，这里的1可以是获取到表的列名，1表示第一列，2，表是第二列要有顺序
 grade.setGradeId(resultSet.getInt(1));
 grade.setGradeName(resultSet.getString(2));
 
 gradeList.add(grade);
 }
 }catch (Exception e){
 e.printStackTrace();
 }finally {
 //关闭资源
 this.close(resultSet);
 }
 return gradeList;
 }
 /**
 * @description 添加数据
 * @author
 * @date 2022-09-09 11:41:18
 * @param grade 年纪对象
 * @return {@link int}
 */
 @Override
 public int insertGrade(Grade grade) {
 //sql语句
 String sql = "INSERT INTO GRADE(GRADEID, GRADENAME) VALUES (?,?)";
 //将对象的属性值添加到 数组中
 Object [] obj = {grade.getGradeId(),grade.getGradeName()};
 //调用 添加数据的方法
 return this.update(sql,obj);
 }
 /**
 * @description 修改数据
 * @author
 * @date 2022-09-09 11:41:23
 * @param grade 年纪对象
 * @return {@link int}
 */
 @Override
 public int updateGrade(Grade grade) {
 //sql语句
 String sql = "UPDATE GRADE SET GRADENAME = ? WHERE GRADEID = ?";
 //将对象的属性值添加到 数组中
 Object [] obj = {grade.getGradeName(),grade.getGradeId()};
 //调用 添加数据的方法
 return this.update(sql,obj);
 }
 /**
 * @description 删除数据
 * @author
 * @date 2022-09-09 11:41:26
 * @param gradeId 年纪ID
 * @return {@link int}
 */
 @Override
 public int deleteGrade(int gradeId) {
 //sql语句
 String sql = "DELETE FROM GRADE WHERE GRADEID = ?";
 //将对象的属性值添加到 数组中
 Object [] obj = {gradeId};
 //调用 添加数据的方法
 return this.update(sql,obj);
 }
 }

#### **5、****将通用的操作（如打开、关闭连接等）封装到工具类****数据库工具类** ####

**对BaseDao****：增、删、改的通用方法**

/**
 * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
 * @author
 * @date 2022-09-12 22:01:34
 * @version 1.0.0
 * @description 将通用的操作（如打开、关闭连接等）封装到工具类
 */
 
 public class BaseDao {
 /**
 * 获取驱动
 */
 Connection connection = null;
 /**
 * 连接数据库并进行操作
 */
 PreparedStatement preparedStatement = null;
 /**
 * 处理返回结果
 */
 ResultSet resultSet = null;
 /**
 * @description 获取驱动
 * @author
 * @date 2022-09-09 11:50:58
 * @param
 * @return {@link Connection}
 */
 public Connection getConnection(){
 //根据指定的键获取对应的值
 DataSourceConfig dataSourceConfig = new DataSourceConfig();
 // 获取驱动
 String driver = dataSourceConfig.getProperty("driver");
 // 获取数据库地址
 String url = dataSourceConfig.getProperty("url");
 // 获取用户名
 String username = dataSourceConfig.getProperty("username");
 // 获取密码
 String password = dataSourceConfig.getProperty("password");
 
 try {
 //加载驱动
 Class.forName("com.mysql.jdbc.Driver");
 connection = DriverManager.getConnection(url,username,password);
 } catch (ClassNotFoundException e) {
 e.printStackTrace();
 } catch (SQLException throwables) {
 throwables.printStackTrace();
 }
 return connection;
 }
 /**
 * @description 查询班级信息
 * key为空查询所有班级信息
 * key有值，根据key值进行模糊查询
 * @author
 * @date 2022-09-09 11:54:58
 * @param sql sql语句
 * @param obj key值
 * @return {@link ResultSet}
 */
 public ResultSet select(String sql, Object[] obj){
 this.getConnection();
 try {
 preparedStatement = connection.prepareStatement(sql);
 //若传过来obj不为空，则解析参数集合
 if (obj != null && obj.length > 0){
 for (int i = 0; i < obj.length; i++) {
 //对问号传参
 preparedStatement.setObject((i + 1),obj[i]);
 }
 }
 resultSet = preparedStatement.executeQuery();
 } catch (SQLException throwables) {
 throwables.printStackTrace();
 }
 return resultSet;
 }
 /**
 * @description 对数据进行添加修改删除
 * @author
 * @date 2022-09-09 11:57:54
 * @param sql sql语句
 * @param obj key值
 * @return {@link int}
 */
 public int update(String sql, Object[] obj){
 //
 this.getConnection();
 int count = 0;
 try {
 preparedStatement = connection.prepareStatement(sql);
 if (obj != null && obj.length > 0){
 for (int i = 0; i < obj.length; i++) {
 preparedStatement.setObject((i + 1),obj [i]);
 }
 }
 count = preparedStatement.executeUpdate();
 } catch (SQLException throwables) {
 throwables.printStackTrace();
 }finally {
 close(resultSet);
 }
 return count;
 }
 /**
 * @description 关闭资源
 * @author
 * @date 2022-09-12 22:00:57
 * @param res 
 * @return
 */
 public void close(ResultSet res){
 try {
 if (res != null){
 res.close();
 }
 if (resultSet != null){
 resultSet.close();
 }
 if (preparedStatement != null){
 preparedStatement.close();
 }
 if (connection != null){
 connection.close();
 }
 }catch (Exception e){
 e.printStackTrace();
 }
 }
 }

#### 6、在测试类进行测试 ####

/**
 * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
 * @author 齐孟伟
 * @date 2022-09-12 22:20:56
 * @version 1.0.0
 * @description 测试类
 */
 
 public class SchoolSystemApplication {
 public static void main(String[] args) {
 GradeDao gradeDao = new GradeDaoImpl();
 /**
 * 查询
 */
 select("",gradeDao);
 /**
 * 添加数据
 */
 Grade grade = new Grade(6,"第六阶段");
 gradeDao.insertGrade(grade);
 select("",gradeDao);
 /**
 * 修改数据
 */
 // 获取所有的对象
 List<Grade> gradeList = gradeDao.getALL("");
 // 遍历数组
 for (int i = 0; i < gradeList.size(); i++) {
 if (gradeList.get(i).getGradeId() == 6){
 int gradeId = gradeList.get(i).getGradeId();
 String gradeName = "高三";
 Grade grade1 = new Grade(gradeId,gradeName);
 gradeDao.updateGrade(grade1);
 }
 }
 select("",gradeDao);
 /**
 * 删除数据
 */
 gradeDao.deleteGrade(6);
 select("",gradeDao);
 }
 /**
 * @description 遍历集合里的信息
 * @author
 * @date 2022-09-12 22:21:10
 * @param key key值
 * @param gradeDao
 * @return
 */
 public static void select(String key,GradeDao gradeDao){
 List<Grade> gradeList = gradeDao.getALL(key);
 for (int i = 0; i < gradeList.size(); i++) {
 System.out.println(gradeList.get(i).toString());
 }
 System.out.println("______________________");
 }
 }

#### 7、单例模式 ####

**Java****中提供了****Properties****类来读取配置文件**

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td>方法名</td> 
 <td>说明</td> 
 </tr> 
 <tr> 
 <td> void load(InputStream inStream) </td> 
 <td> 通过输入流对指定文件进行装载，获取该文件中所有键-值对。 </td> 
 </tr> 
 <tr> 
 <td> String getProperty(String key) </td> 
 <td> 用指定的键在此属性列表中搜索属性。通过参数key得到其所对应的值。 </td> 
 </tr> 
 </tbody> 
</table>

读取配置文件，单独放在一个utils包里

/**
     * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
     * @author
     * @date 2022-09-10 10:47:31
     * @version 1.0.0
     * @description 数据库配置类---读取数据库连接配置
     */
    
    public class DataSourceConfig {
        /**
         * 以类名声明的此类对象
         */
        private static DataSourceConfig dataSourceConfig = null;
        
        Properties properties = null;
        /**
         * @description
         * @author
         * @date 2022-09-10 10:48:02
         * @param
         * @return {@link null}
         */
        public DataSourceConfig(){
            properties = new Properties();
            //配置文件路径
            String configFile = "database.properties";
            //加载配置文件到输入流
            InputStream inputStream = DataSourceConfig.class.getClassLoader().getResourceAsStream(configFile);
            try {
                //从输入流中读取属性列表
                properties.load(inputStream);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        /**
         * @description DataSourceConfig判定是否已经被创建
         * 如果创建过，直接返回
         * 如果没有，创建后返回
         * @author
         * @date 2022-09-10 10:45:49
         * @param
         * @return {@link DataSourceConfig}
         */
        public synchronized static DataSourceConfig getInstance(){
            if (dataSourceConfig == null){
                dataSourceConfig = new DataSourceConfig();
            }
            return dataSourceConfig;
        }
        /**
         * @description Properties对象根据传递的key值返回对应的value值
         * @author
         * @date 2022-09-10 10:45:55
         * @param key
         * @return {@link String}
         */
        public String getProperty(String key){
    
            String value = properties.getProperty(key);
            return value;
        }
    }

**读取配置文件，把获取驱动部分改为以下代码即可**

/**
         * @description 获取驱动
         * @author 
         * @date 2022-09-10 10:52:34
         * @param
         * @return {@link Connection}
         */
        public Connection getConnection(){
            //根据指定的键获取对应的值
            DataSourceConfig dataSourceConfig = new DataSourceConfig();
            String driver = dataSourceConfig.getProperty("driver");
            String url = dataSourceConfig.getProperty("url");
            String username = dataSourceConfig.getProperty("username");
            String password = dataSourceConfig.getProperty("password");
    
            try {
                //加载驱动
                Class.forName("com.mysql.jdbc.Driver");
                connection = DriverManager.getConnection(url,username,password);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            return connection;
        }

**此模式称为单例模式：****系统运行期间，有且仅有一个实例**

1、它必须自行创建这个实例

2、定义了静态的该类私有对象

3、一个类只有一个实例——最基本的要求

4、只提供私有构造器

5、它必须自行向整个系统提供这个实例

6、提供一个静态的公有方法，返回创建或者获取本身的静态私有对象

**懒汉模式：在类加载时不创建实例，采用延迟加载的方式，在运行调用时创建实例。**

/**
     * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
     * @author
     * @date 2022-09-17 16:43:22
     * @version 1.0.0
     * @description 懒汉模式：在类加载时不创建实例，采用延迟加载的方式，在运行调用时创建实例。
     */
    
    public class DataScoreConfig {
        /**
         * DataSourceConfig类的声明
         */
        private static DataScoreConfig dataScoreConfig = null;
        /**
         * Properties类的文件处理引用
         */
        Properties properties = null;
        /**
         * @description 私有话构造方法
         * @author
         * @date 2022-09-17 16:53:13
         * @param
         * @return {@link null}
         */
        public DataScoreConfig(){
            properties = new Properties();
            String configFile = "database.properties";
            InputStream inputStream = DataScoreConfig.class.getClassLoader().getResourceAsStream(configFile);
            try {
                properties.load(inputStream);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        /**
         * @description
         * 查看dataSourceConfig是否为空
         * 为空则重新创建引用
         * 不为空直接返回
         * @author
         * @date 2022-09-17 16:53:05
         * @param
         * @return {@link DataScoreConfig}
         */
        public static synchronized DataScoreConfig getInstance(){
            if (dataScoreConfig == null){
                dataScoreConfig = new DataScoreConfig();
            }
            return dataScoreConfig;
        }
        /**
         * @description
         * 通过properties对象的getProperty方法
         * 获取database.properties文件中的对应可以的值
         * @author
         * @date 2022-09-17 16:53:01
         * @param key
         * @return {@link String}
         */
        public String getProperty(String key){
            String value = properties.getProperty(key);
            return value;
        }

**饿汉模式：在类加载的时候，就完成初始化**

/**
     * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
     * @author
     * @date 2022-09-17 16:43:22
     * @version 1.0.0
     * @description 饿汉模式：在类加载的时候，就完成初始化
     */
    
    public class DataScoreConfig {
        /**
         * DataSourceConfig类的声明
         */
        private static DataScoreConfig dataScoreConfig = new DataScoreConfig;
        /**
         * Properties类的文件处理引用
         */
        Properties properties = null;
        /**
         * @description 私有话构造方法
         * @author
         * @date 2022-09-17 16:53:13
         * @param
         * @return {@link null}
         */
        public DataScoreConfig(){
            properties = new Properties();
            String configFile = "database.properties";
            InputStream inputStream =                                     
             DataScoreConfig.class.getClassLoader().getResourceAsStream(configFile);
            try {
                properties.load(inputStream);
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        /**
         * @description
         * 查看dataSourceConfig是否为空
         * 为空则重新创建引用
         * 不为空直接返回
         * @author
         * @date 2022-09-17 16:53:05
         * @param
         * @return {@link DataScoreConfig}
         */
        public static DataScoreConfig getInstance(){
            return dataScoreConfig;
        }
        /**
         * @description
         * 通过properties对象的getProperty方法
         * 获取database.properties文件中的对应可以的值
         * @author
         * @date 2022-09-17 16:53:01
         * @param key
         * @return {@link String}
         */
        public String getProperty(String key){
            String value = properties.getProperty(key);
            return value;
        }

**注意：** **在整个程序运行期间，有且仅有一个实例。****若违背这一点，所设计的类就不是单例类**

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td>单例模式</td> 
 <td>懒汉模式</td> 
 <td>饿汉模式</td> 
 </tr> 
 <tr> 
 <td>概念</td> 
 <td> 在类加载时不创建实例，采用延迟加载的方式，在运行调用时创建实例 </td> 
 <td> 在类加载的时候，就完成初始化 </td> 
 </tr> 
 <tr> 
 <td>特点</td> 
 <td> 类加载速度快，但是运行时获取对象的速度较慢。——“时间换空间” </td> 
 <td> 类加载较慢，但获取对象速度快。——“空间换时间” </td> 
 </tr> 
 <tr> 
 <td>延迟加载</td> 
 <td> 具备 </td> 
 <td> 不具备 </td> 
 </tr> 
 <tr> 
 <td>线程安全</td> 
 <td> 线程不安全，解决方法使用同步（synchronized） </td> 
 <td> 线程安全 </td> 
 </tr> 
 </tbody> 
</table>

[6437fecdc57c4e9fb5d97e60a50f3914.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/89efd38474504e2d91894faab724022b.png