• JDBC的封装

    目录

    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

    然后在里面添加一下数据

    1. # 加载驱动
    2. driver = com.mysql.jdbc.Driver
    3. # 数据库地址
    4. url = jdbc:mysql://127.0.0.1:3306/myschool
    5. #用户名
    6. username = root
    7. #密码
    8. password = root

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

    1. //创建一个年纪类
    2. public class Grade {
    3.     /**
    4.      * 年纪编号
    5.      */
    6.     private int gradeId;
    7.     /**
    8.      * 年假名称
    9.      */
    10.     private String gradeName;
    11.  
    12.     public Grade() {
    13.     }
    14.  
    15.     public Grade(int gradeId, String gradeName) {
    16.         this.gradeId = gradeId;
    17.         this.gradeName = gradeName;
    18.     }
    19.  
    20.     /**
    21.      * 获取
    22.      * @return gradeId
    23.      */
    24.     public int getGradeId() {
    25.         return gradeId;
    26.     }
    27.  
    28.     /**
    29.      * 设置
    30.      * @param gradeId
    31.      */
    32.     public void setGradeId(int gradeId) {
    33.         this.gradeId = gradeId;
    34.     }
    35.  
    36.     /**
    37.      * 获取
    38.      * @return gradeName
    39.      */
    40.     public String getGradeName() {
    41.         return gradeName;
    42.     }
    43.  
    44.     /**
    45.      * 设置
    46.      * @param gradeName
    47.      */
    48.     public void setGradeName(String gradeName) {
    49.         this.gradeName = gradeName;
    50.     }
    51.     @Override
    52.     public String toString() {
    53.         return "Grade{gradeId = " + gradeId + ", gradeName = " + gradeName + "}";
    54.     }
    55. }

    数据库如下图：

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

    1. /**
    2.  * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
    3.  * @author 
    4.  * @date 2022-09-12 21:35:49
    5.  * @version 1.0.0
    6.  * @description 将年纪对象的所有操作抽取成接口
    7.  * 实现对数据库的增删改查
    8.  */
    10. public interface GradeDao {
    11.     /**
    12.      * @description 查询班级信息
    13.      * key为空查询所有班级信息
    14.      * key有值，根据key值进行模糊查询
    15.      * @author
    16.      * @date 2022-09-09 11:41:14
    17.      * @param key 进行模糊查询的关键字
    18.      * @return {@link List< Grade>}
    19.      */
    20.      List<Grade> getALL(String key);
    21.      /**
    22.       * @description 添加数据
    23.       * @author
    24.       * @date 2022-09-09 11:41:18
    25.       * @param grade 年纪对象
    26.       * @return {@link int}
    27.       */
    28.      int insertGrade(Grade grade);
    29.      /**
    30.       * @description 修改数据
    31.       * @author
    32.       * @date 2022-09-09 11:41:23
    33.       * @param grade 年纪对象
    34.       * @return {@link int}
    35.       */
    36.      int updateGrade(Grade grade);
    37.      /**
    38.       * @description 删除数据
    39.       * @author
    40.       * @date 2022-09-09 11:41:26
    41.       * @param gradeId 年纪ID
    42.       * @return {@link int}
    43.       */
    44.      int deleteGrade(int gradeId);
    45. }

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

    1. /**
    2.  * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
    3.  * @author 齐孟伟
    4.  * @date 2022-09-12 21:58:38
    5.  * @version 1.0.0
    6.  * @description 数据库的实现类分别实现接口
    7.  */
    9. public class GradeDaoImpl extends BaseDao implements GradeDao {
    10.     /**
    11.      * @description 查询班级信息
    12.      * key为空查询所有班级信息
    13.      * key有值，根据key值进行模糊查询
    14.      * @author
    15.      * @date 2022-09-09 11:41:14
    16.      * @param key 进行模糊查询的关键字
    17.      * @return {@link List< Grade>}
    18.      */
    19.     @Override
    20.     public List<Grade> getALL(String key) {
    21.         //sql语句
    22.         String sql = "SELECT * FROM GRADE WHERE GRADENAME LIKE CONCAT('%',?,'%')";
    23.         //将获取的key放进数组
    24.         Object [] obj = {key};
    25.         //处理返回结果
    26.         ResultSet resultSet = this.select(sql,obj);
    27.         //创建年纪对象
    28.         Grade grade = null;
    29.         //创建数组用来存储年纪对象
    30.         List<Grade> gradeList = new ArrayList<>();
    31.         try{
    32.             //resultSet.next()：判断返回结果是否有值
    33.             while (resultSet.next()){
    34.                 grade = new Grade();
    35.                 //获取数据库表的内容，这里的1可以是获取到表的列名，1表示第一列，2，表是第二列要有顺序
    36.                 grade.setGradeId(resultSet.getInt(1));
    37.                 grade.setGradeName(resultSet.getString(2));
    38.  
    39.                 gradeList.add(grade);
    40.             }
    41.         }catch (Exception e){
    42.             e.printStackTrace();
    43.         }finally {
    44.             //关闭资源
    45.             this.close(resultSet);
    46.         }
    47.         return gradeList;
    48.     }
    49.     /**
    50.      * @description 添加数据
    51.      * @author
    52.      * @date 2022-09-09 11:41:18
    53.      * @param grade 年纪对象
    54.      * @return {@link int}
    55.      */
    56.     @Override
    57.     public int insertGrade(Grade grade) {
    58.         //sql语句
    59.         String sql = "INSERT INTO GRADE(GRADEID, GRADENAME) VALUES (?,?)";
    60.         //将对象的属性值添加到 数组中
    61.         Object [] obj = {grade.getGradeId(),grade.getGradeName()};
    62.         //调用 添加数据的方法
    63.         return this.update(sql,obj);
    64.     }
    65.     /**
    66.      * @description 修改数据
    67.      * @author
    68.      * @date 2022-09-09 11:41:23
    69.      * @param grade 年纪对象
    70.      * @return {@link int}
    71.      */
    72.     @Override
    73.     public int updateGrade(Grade grade) {
    74.         //sql语句
    75.         String sql = "UPDATE GRADE SET GRADENAME = ? WHERE GRADEID = ?";
    76.         //将对象的属性值添加到 数组中
    77.         Object [] obj = {grade.getGradeName(),grade.getGradeId()};
    78.         //调用 添加数据的方法
    79.         return this.update(sql,obj);
    80.     }
    81.     /**
    82.      * @description 删除数据
    83.      * @author
    84.      * @date 2022-09-09 11:41:26
    85.      * @param gradeId 年纪ID
    86.      * @return {@link int}
    87.      */
    88.     @Override
    89.     public int deleteGrade(int gradeId) {
    90.         //sql语句
    91.         String sql = "DELETE FROM GRADE WHERE GRADEID = ?";
    92.         //将对象的属性值添加到 数组中
    93.         Object [] obj = {gradeId};
    94.         //调用 添加数据的方法
    95.         return this.update(sql,obj);
    96.     }
    97. }

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

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

    1. /**
    2.  * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
    3.  * @author
    4.  * @date 2022-09-12 22:01:34
    5.  * @version 1.0.0
    6.  * @description 将通用的操作（如打开、关闭连接等）封装到工具类
    7.  */
    9. public class BaseDao {
    10.     /**
    11.      * 获取驱动
    12.      */
    13.     Connection connection = null;
    14.     /**
    15.      * 连接数据库并进行操作
    16.      */
    17.     PreparedStatement preparedStatement = null;
    18.     /**
    19.      * 处理返回结果
    20.      */
    21.     ResultSet resultSet = null;
    22.     /**
    23.      * @description 获取驱动
    24.      * @author
    25.      * @date 2022-09-09 11:50:58
    26.      * @param
    27.      * @return {@link Connection}
    28.      */
    29.     public Connection getConnection(){
    30.         //根据指定的键获取对应的值
    31.         DataSourceConfig dataSourceConfig = new DataSourceConfig();
    32.         // 获取驱动
    33.         String driver = dataSourceConfig.getProperty("driver");
    34.         // 获取数据库地址
    35.         String url = dataSourceConfig.getProperty("url");
    36.         // 获取用户名
    37.         String username = dataSourceConfig.getProperty("username");
    38.         // 获取密码
    39.         String password = dataSourceConfig.getProperty("password");
    40.  
    41.         try {
    42.             //加载驱动
    43.             Class.forName("com.mysql.jdbc.Driver");
    44.             connection = DriverManager.getConnection(url,username,password);
    45.         } catch (ClassNotFoundException e) {
    46.             e.printStackTrace();
    47.         } catch (SQLException throwables) {
    48.             throwables.printStackTrace();
    49.         }
    50.         return connection;
    51.     }
    52.     /**
    53.      * @description 查询班级信息
    54.      *      key为空查询所有班级信息
    55.      *      key有值，根据key值进行模糊查询
    56.      * @author
    57.      * @date 2022-09-09 11:54:58
    58.      * @param sql sql语句
    59.      * @param obj key值
    60.      * @return {@link ResultSet}
    61.      */
    62.     public ResultSet select(String sql, Object[] obj){
    63.         this.getConnection();
    64.         try {
    65.             preparedStatement = connection.prepareStatement(sql);
    66.             //若传过来obj不为空，则解析参数集合
    67.             if (obj != null && obj.length > 0){
    68.                 for (int i = 0; i < obj.length; i++) {
    69.                     //对问号传参
    70.                     preparedStatement.setObject((i + 1),obj[i]);
    71.                 }
    72.             }
    73.             resultSet = preparedStatement.executeQuery();
    74.         } catch (SQLException throwables) {
    75.             throwables.printStackTrace();
    76.         }
    77.         return resultSet;
    78.     }
    79.     /**
    80.      * @description 对数据进行添加修改删除
    81.      * @author
    82.      * @date 2022-09-09 11:57:54
    83.      * @param sql sql语句
    84.      * @param obj key值
    85.      * @return {@link int}
    86.      */
    87.     public int update(String sql, Object[] obj){
    88.         //
    89.         this.getConnection();
    90.         int count = 0;
    91.         try {
    92.             preparedStatement = connection.prepareStatement(sql);
    93.             if (obj != null && obj.length > 0){
    94.                 for (int i = 0; i < obj.length; i++) {
    95.                     preparedStatement.setObject((i + 1),obj [i]);
    96.                 }
    97.             }
    98.             count = preparedStatement.executeUpdate();
    99.         } catch (SQLException throwables) {
    100.             throwables.printStackTrace();
    101.         }finally {
    102.             close(resultSet);
    103.         }
    104.         return count;
    105.     }
    106.     /**
    107.      * @description 关闭资源
    108.      * @author
    109.      * @date 2022-09-12 22:00:57
    110.      * @param res 
    111.      * @return
    112.      */
    113.     public void close(ResultSet res){
    114.         try {
    115.             if (res != null){
    116.                 res.close();
    117.             }
    118.             if (resultSet != null){
    119.                 resultSet.close();
    120.             }
    121.             if (preparedStatement != null){
    122.                 preparedStatement.close();
    123.             }
    124.             if (connection != null){
    125.                 connection.close();
    126.             }
    127.         }catch (Exception e){
    128.             e.printStackTrace();
    129.         }
    130.     }
    131. }

    6、在测试类进行测试

    1. /**
    2.  * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
    3.  * @author 齐孟伟
    4.  * @date 2022-09-12 22:20:56
    5.  * @version 1.0.0
    6.  * @description 测试类
    7.  */
    9. public class SchoolSystemApplication {
    10.     public static void main(String[] args) {
    11.         GradeDao gradeDao = new GradeDaoImpl();
    12.         /**
    13.          * 查询
    14.          */
    15.         select("",gradeDao);
    16.         /**
    17.          * 添加数据
    18.          */
    19.         Grade grade = new Grade(6,"第六阶段");
    20.         gradeDao.insertGrade(grade);
    21.         select("",gradeDao);
    22.         /**
    23.          * 修改数据
    24.          */
    25.         // 获取所有的对象
    26.         List<Grade> gradeList = gradeDao.getALL("");
    27.         // 遍历数组
    28.         for (int i = 0; i < gradeList.size(); i++) {
    29.             if (gradeList.get(i).getGradeId() == 6){
    30.                 int gradeId = gradeList.get(i).getGradeId();
    31.                 String gradeName = "高三";
    32.                 Grade grade1 = new Grade(gradeId,gradeName);
    33.                 gradeDao.updateGrade(grade1);
    34.             }
    35.         }
    36.         select("",gradeDao);
    37.         /**
    38.          * 删除数据
    39.          */
    40.         gradeDao.deleteGrade(6);
    41.         select("",gradeDao);
    42.     }
    43.     /**
    44.      * @description 遍历集合里的信息
    45.      * @author
    46.      * @date 2022-09-12 22:21:10
    47.      * @param key key值
    48.      * @param gradeDao
    49.      * @return
    50.      */
    51.     public static void select(String key,GradeDao gradeDao){
    52.         List<Grade> gradeList = gradeDao.getALL(key);
    53.         for (int i = 0; i < gradeList.size(); i++) {
    54.             System.out.println(gradeList.get(i).toString());
    55.         }
    56.         System.out.println("______________________");
    57.     }
    58. }

     7、单例模式

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

    方法名说明

    void load(InputStream inStream)

    通过输入流对指定文件进行装载，获取该文件中所有键-值对。

    String getProperty(String key)

    用指定的键在此属性列表中搜索属性。通过参数key得到其所对应的值。

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

    1. /**
    2.  * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
    3.  * @author
    4.  * @date 2022-09-10 10:47:31
    5.  * @version 1.0.0
    6.  * @description 数据库配置类---读取数据库连接配置
    7.  */
    9. public class DataSourceConfig {
    10.     /**
    11.      * 以类名声明的此类对象
    12.      */
    13.     private static DataSourceConfig dataSourceConfig = null;
    14.     
    15.     Properties properties = null;
    16.     /**
    17.      * @description
    18.      * @author
    19.      * @date 2022-09-10 10:48:02
    20.      * @param
    21.      * @return {@link null}
    22.      */
    23.     public DataSourceConfig(){
    24.         properties = new Properties();
    25.         //配置文件路径
    26.         String configFile = "database.properties";
    27.         //加载配置文件到输入流
    28.         InputStream inputStream = DataSourceConfig.class.getClassLoader().getResourceAsStream(configFile);
    29.         try {
    30.             //从输入流中读取属性列表
    31.             properties.load(inputStream);
    32.         } catch (IOException e) {
    33.             e.printStackTrace();
    34.         }
    35.     }
    36.     /**
    37.      * @description DataSourceConfig判定是否已经被创建
    38.      * 如果创建过，直接返回
    39.      * 如果没有，创建后返回
    40.      * @author
    41.      * @date 2022-09-10 10:45:49
    42.      * @param
    43.      * @return {@link DataSourceConfig}
    44.      */
    45.     public synchronized static DataSourceConfig getInstance(){
    46.         if (dataSourceConfig == null){
    47.             dataSourceConfig = new DataSourceConfig();
    48.         }
    49.         return dataSourceConfig;
    50.     }
    51.     /**
    52.      * @description Properties对象根据传递的key值返回对应的value值
    53.      * @author
    54.      * @date 2022-09-10 10:45:55
    55.      * @param key
    56.      * @return {@link String}
    57.      */
    58.     public String getProperty(String key){
    59.  
    60.         String value = properties.getProperty(key);
    61.         return value;
    62.     }
    63. }

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

    1. /**
    2.      * @description 获取驱动
    3.      * @author 
    4.      * @date 2022-09-10 10:52:34
    5.      * @param
    6.      * @return {@link Connection}
    7.      */
    8.     public Connection getConnection(){
    9.         //根据指定的键获取对应的值
    10.         DataSourceConfig dataSourceConfig = new DataSourceConfig();
    11.         String driver = dataSourceConfig.getProperty("driver");
    12.         String url = dataSourceConfig.getProperty("url");
    13.         String username = dataSourceConfig.getProperty("username");
    14.         String password = dataSourceConfig.getProperty("password");
    15.  
    16.         try {
    17.             //加载驱动
    18.             Class.forName("com.mysql.jdbc.Driver");
    19.             connection = DriverManager.getConnection(url,username,password);
    20.         } catch (ClassNotFoundException e) {
    21.             e.printStackTrace();
    22.         } catch (SQLException throwables) {
    23.             throwables.printStackTrace();
    24.         }
    25.         return connection;
    26.     }

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

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

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

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

    4、只提供私有构造器

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

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

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

    1. /**
    2.  * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
    3.  * @author
    4.  * @date 2022-09-17 16:43:22
    5.  * @version 1.0.0
    6.  * @description 懒汉模式：在类加载时不创建实例，采用延迟加载的方式，在运行调用时创建实例。
    7.  */
    9. public class DataScoreConfig {
    10.     /**
    11.      * DataSourceConfig类的声明
    12.      */
    13.     private static DataScoreConfig dataScoreConfig = null;
    14.     /**
    15.      * Properties类的文件处理引用
    16.      */
    17.     Properties properties = null;
    18.     /**
    19.      * @description 私有话构造方法
    20.      * @author
    21.      * @date 2022-09-17 16:53:13
    22.      * @param
    23.      * @return {@link null}
    24.      */
    25.     public DataScoreConfig(){
    26.         properties = new Properties();
    27.         String configFile = "database.properties";
    28.         InputStream inputStream = DataScoreConfig.class.getClassLoader().getResourceAsStream(configFile);
    29.         try {
    30.             properties.load(inputStream);
    31.         } catch (IOException e) {
    32.             e.printStackTrace();
    33.         }
    34.     }
    35.     /**
    36.      * @description
    37.      * 查看dataSourceConfig是否为空
    38.      * 为空则重新创建引用
    39.      * 不为空直接返回
    40.      * @author
    41.      * @date 2022-09-17 16:53:05
    42.      * @param
    43.      * @return {@link DataScoreConfig}
    44.      */
    45.     public static synchronized DataScoreConfig getInstance(){
    46.         if (dataScoreConfig == null){
    47.             dataScoreConfig = new DataScoreConfig();
    48.         }
    49.         return dataScoreConfig;
    50.     }
    51.     /**
    52.      * @description
    53.      * 通过properties对象的getProperty方法
    54.      * 获取database.properties文件中的对应可以的值
    55.      * @author
    56.      * @date 2022-09-17 16:53:01
    57.      * @param key
    58.      * @return {@link String}
    59.      */
    60.     public String getProperty(String key){
    61.         String value = properties.getProperty(key);
    62.         return value;
    63.     }

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

    1. /**
    2.  * @authorDesc 乾坤未定, 你我皆是黑马.乾坤已定, 那就扭转乾坤
    3.  * @author
    4.  * @date 2022-09-17 16:43:22
    5.  * @version 1.0.0
    6.  * @description 饿汉模式：在类加载的时候，就完成初始化
    7.  */
    9. public class DataScoreConfig {
    10.     /**
    11.      * DataSourceConfig类的声明
    12.      */
    13.     private static DataScoreConfig dataScoreConfig = new DataScoreConfig;
    14.     /**
    15.      * Properties类的文件处理引用
    16.      */
    17.     Properties properties = null;
    18.     /**
    19.      * @description 私有话构造方法
    20.      * @author
    21.      * @date 2022-09-17 16:53:13
    22.      * @param
    23.      * @return {@link null}
    24.      */
    25.     public DataScoreConfig(){
    26.         properties = new Properties();
    27.         String configFile = "database.properties";
    28.         InputStream inputStream =                                     
    29.          DataScoreConfig.class.getClassLoader().getResourceAsStream(configFile);
    30.         try {
    31.             properties.load(inputStream);
    32.             inputStream.close();
    33.         } catch (IOException e) {
    34.             e.printStackTrace();
    35.         }
    36.     }
    37.     /**
    38.      * @description
    39.      * 查看dataSourceConfig是否为空
    40.      * 为空则重新创建引用
    41.      * 不为空直接返回
    42.      * @author
    43.      * @date 2022-09-17 16:53:05
    44.      * @param
    45.      * @return {@link DataScoreConfig}
    46.      */
    47.     public static DataScoreConfig getInstance(){
    48.         return dataScoreConfig;
    49.     }
    50.     /**
    51.      * @description
    52.      * 通过properties对象的getProperty方法
    53.      * 获取database.properties文件中的对应可以的值
    54.      * @author
    55.      * @date 2022-09-17 16:53:01
    56.      * @param key
    57.      * @return {@link String}
    58.      */
    59.     public String getProperty(String key){
    60.         String value = properties.getProperty(key);
    61.         return value;
    62.     }

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

    单例模式懒汉模式饿汉模式
    概念

    在类加载时不创建实例，采用延迟加载的方式，在运行调用时创建实例

    在类加载的时候，就完成初始化

    特点

    类加载速度快，但是运行时获取对象的速度较慢。——“时间换空间”

    类加载较慢，但获取对象速度快。——“空间换时间”

    延迟加载

    具备

    不具备

    线程安全

    线程不安全，解决方法使用同步（synchronized）

    线程安全

  • 相关阅读:
    MIPI CSI接口调试方法： data rate计算
    探秘Elasticsearch：高性能搜索引擎的原理与应用场景（一）
    简单了解Ajax
    什么是数据描述统计分析？（Descriptive Analysis）
    测试开发是什么？为什么现在那么多公司都要招聘测试开发？
    Spring及Spring boot 第四章-第二节 Spring声明式事务管理 @Transactional
    轻拍牛头（求约数C++）
    js获取地址中携带的省市区
    C++ 语言学习 day02 (linux ) delete 函数 面对对象的类，构造函数，析构函数
    SpringBoot集成redis+cookie实现分布式单点登录
  • 原文地址：https://blog.csdn.net/qi341500/article/details/126786442