引入Mybatis

专栏精选

引入Mybatis

Mybatis的快速入门

Mybatis的增删改查扩展功能说明

mapper映射的参数和结果

Mybatis复杂类型的结果映射

Mybatis基于注解的结果映射

Mybatis枚举类型处理和类型处理器

再谈动态SQL

Mybatis配置入门

Mybatis行为配置之Ⅰ—缓存

Mybatis行为配置之Ⅱ—结果相关配置项说明

Mybatis行为配置之Ⅲ—其他行为配置项说明

Mybatis行为配置之Ⅳ—日志

Mybatis整合Spring详解

Mybatis插件入门

Mybatis专栏代码资源

摘要

在这篇文章中，我们将为进入Mybatis的世界做好准备工作，主要是了解jdbc操作数据库的基本方法，众所周知JDBC是Java操作数据库的基本规范，Mybatis也需要工作在JDBC之上，了解JDBC是了解为什么使用Mybatis的基础，因此这是一个菜鸟提升技术能力，老鸟巩固基础知识的好机会。准备好开启今天的神奇之旅了吗？

关键字：Mybatis,JDBC,Java,数据库,MySQL,Mybatis入门

引言

大家好，我是奇迹老李，一个专注于分享开发经验和基础教程的博主。这里是我的其中一个技术分享平台，欢迎广大朋友们点赞评论转发分享，重要的是点击关注喔 🙆。今天要和大家分享的内容是JDBC的基础知识。做好准备，Let’s go🚎🚀

正文

JDBC简要介绍

Java代码和数据库之间交互的桥梁是JDBC（Java Database Connectivity），使用jdbc连接数据库并执行sql的代码如下：

public class JdbcApp {
    public static void main(String[] args) {
        try(InputStream inputStream = JdbcApp.class.getResourceAsStream("/mysql-env.properties")){
            //0.读取配置
            Properties properties = new Properties();
            properties.load(inputStream);
            String driver = properties.getProperty("driver");
            String url = properties.getProperty("url");
            String username = properties.getProperty("username");
            String password = properties.getProperty("password");

            //1.加载驱动
            Class.forName(driver);
            //2.建立连接
            Connection conn = DriverManager.getConnection(url, username, password);
            //3.创建sql
            String sql = "select id,name,code,comment from conn_test where is_del='0'";
            PreparedStatement statement = conn.prepareStatement(sql);
            //4.执行sql
            ResultSet resultSet = statement.executeQuery();
            //5.处理结果
            while (resultSet.next()){
                long id = resultSet.getLong("id");
                String name = resultSet.getString("name");
                String code = resultSet.getString("code");
                System.out.println(id+name+code);
            }
            //6.关闭资源
            resultSet.close();
            statement.close();
            conn.close();
        } catch (SQLException e) {
            System.out.println("sql错误");
        } catch (ClassNotFoundException e) {
            System.out.println("类型错误");
        } catch (IOException e){
            System.out.println("文件路径错误");
        }
    }
}

这种方式存在几个问题：

1. 对于过长或复杂sql，尤其是需要根据不同条件生成不同sql的场景不好实现
2. 对查询结果的使用不友好，不能自动映射为对象
3. 对于长文本（sql语句），硬编码影响代码美观，可通过配置文件解决

对于这几个问题，我们通过实现一个例子来体验一下

实现一个查询功能

以下是一个典型的系统管理后台，通过jdbc的方式，如何实现其中的查询按钮基本功能？（注意：在这个专栏的示例中只考虑服务端实现，以打印输出代替页面显示）

代码实现过程如下：

1. 实体类

   package top.sunyog.common.entity;
   
   import java.time.LocalDateTime;
   
   /**
    * 查询条件类
    *
    * @author Myste
    * @since 2023/10/31 15:19
    */
   public class AppSearchVo {
       /*应用名称*/
       private String appName;
       /*认证类型*/
       private String authType;
       /*创建时间-开始*/
       private LocalDateTime startDate;
       /*创建时间-结束*/
       private LocalDateTime endDate;
   
       //省略getter、setter、toString方法
   
       public boolean isEmpty(){
           boolean emptyName = appName == null || "".equals(appName);
           boolean emptyAuth = authType == null || "".equals(authType);
           return emptyName && emptyAuth && startDate==null && endDate==null;
       }
   }
   
   package top.sunyog.common.entity;
   
   import java.time.LocalDate;
   
   /**
    * 数据库映射类
    * @author Myste
    * @since 2023/10/31 15:36
    */
   public class AppTestEntity {
       private Long id;
       private String appName;
       private String appCode;
       private String authType;
       private LocalDate createDate;
       private String creator;
   
       //省略getter、setter、toString方法
   }
   
   

2. 上下文类

   package top.sunyog.jdbc;
   
   import java.io.IOException;
   import java.io.InputStream;
   import java.sql.Connection;
   import java.sql.DriverManager;
   import java.sql.SQLException;
   import java.util.Properties;
   
   /**
    * 上下文类,用于保持数据库连接
    * @author Myste
    * @since 2023/10/31 15:22
    */
   public class JdbcContext {
       private static Connection dbConn=null;
   
       public void initContext(){
           try(InputStream inputStream = JdbcContext.class.getResourceAsStream("/mysql-env.properties")) {
               //0.读取配置
               Properties properties = new Properties();
               properties.load(inputStream);
               String driver = properties.getProperty("driver");
               String url = properties.getProperty("url");
               String username = properties.getProperty("username");
               String password = properties.getProperty("password");
   
               //1.加载驱动
               Class.forName(driver);
               //2.建立连接
               dbConn = DriverManager.getConnection(url, username, password);
           }catch (SQLException e) {
               System.out.println("sql错误");
           } catch (ClassNotFoundException e) {
               System.out.println("类型错误");
           } catch (IOException e){
               System.out.println("文件路径错误");
           }
       }
   
       public void close() throws SQLException {
           if (dbConn!=null && !dbConn.isClosed()) {
               dbConn.close();
           }
       }
   
       public Connection getConn() {
           if(dbConn==null){
               this.initContext();
           }
           return dbConn;
       }
   }
   
   

3. 映射类

   package top.sunyog.jdbc.mapper;
   
   import com.mysql.cj.util.StringUtils;
   import top.sunyog.common.entity.AppSearchVo;
   import top.sunyog.common.entity.AppTestEntity;
   
   import java.sql.Connection;
   import java.sql.PreparedStatement;
   import java.sql.ResultSet;
   import java.sql.SQLException;
   import java.time.LocalDate;
   import java.time.format.DateTimeFormatter;
   import java.util.ArrayList;
   import java.util.List;
   
   /**
    * 数据库映射类,用于查询数据,并将查询结果映射为一个个对象
    * @author Myste
    * @since 2023/10/31 15:35
    */
   public class ApplicationRepository {
       private Connection conn = null;
   
       public ApplicationRepository(Connection conn) {
           this.conn = conn;
       }
   
       public List<AppTestEntity> queryApp(AppSearchVo param) throws SQLException {
           StringBuffer sql = new StringBuffer("select id,app_name,app_code,auth_type,create_date,creator from app_test");
           if (!param.isEmpty()) {
               sql.append(" where 1=1");
               if (!StringUtils.isNullOrEmpty(param.getAppName())) {
                   sql.append(" and app_name like concat('%',?,'%')");
               }
               if (!StringUtils.isNullOrEmpty(param.getAuthType())) {
                   sql.append(" and auth_type = ?");
               }
               if (param.getStartDate() != null) {
                   sql.append(" and create_date >= ?");
               }
               if (param.getEndDate() != null) {
                   sql.append(" and create_date <= ?");
               }
           }
   
           DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
           PreparedStatement statement = this.conn.prepareStatement(sql.toString());
           int i = 0;
           if (!param.isEmpty()) {
               if (!StringUtils.isNullOrEmpty(param.getAppName())) {
                   statement.setString(++i, param.getAppName());
               }
               if (!StringUtils.isNullOrEmpty(param.getAuthType())) {
                   statement.setString(++i, param.getAuthType());
               }
               if (param.getStartDate() != null) {
                   statement.setString(++i, formatter.format(param.getStartDate()));
               }
               if (param.getEndDate() != null) {
                   statement.setString(++i, formatter.format(param.getEndDate()));
               }
           }
   
           ResultSet resultSet = statement.executeQuery();
           //映射结果
           List<AppTestEntity> list = new ArrayList<>();
           while (resultSet.next()) {
               AppTestEntity entity = new AppTestEntity();
               entity.setId(resultSet.getLong("id"));
               entity.setAppName(resultSet.getString("app_name"));
               entity.setAppCode(resultSet.getString("app_code"));
               entity.setAuthType(resultSet.getString("auth_type"));
               String dateStr = resultSet.getString("create_date");
               LocalDate createDate = LocalDate.parse(dateStr, formatter);
               entity.setCreateDate(createDate);
               entity.setCreator(resultSet.getString("creator"));
               list.add(entity);
           }
           return list;
       }
   }
   
   

4. 启动类

   package top.sunyog.jdbc;
   
   import top.sunyog.common.entity.AppSearchVo;
   import top.sunyog.common.entity.AppTestEntity;
   import top.sunyog.jdbc.mapper.ApplicationRepository;
   
   import java.sql.SQLException;
   import java.time.LocalDateTime;
   import java.util.List;
   
   /**
    * 启动类,用于启动上下文,并测试数据库查询功能
    * @author Myste
    * @since 2023/10/31 15:28
    */
   public class JdbcApp {
       public static void main(String[] args) throws SQLException {
           JdbcContext context = new JdbcContext();
           context.initContext();
           ApplicationRepository service = new ApplicationRepository(context.getConn());
           AppSearchVo param = new AppSearchVo();
           param.setAppName("应用");
   //        param.setAuthType("2");
           LocalDateTime now = LocalDateTime.now();
           param.setStartDate(now.plusDays(-1));
           param.setEndDate(now.plusDays(2));
           List<AppTestEntity> list = service.queryApp(param);
           list.forEach(o->System.out.println(o));
   
           context.close();
       }
   }
   
   

程序打印结果

AppTestEntity{id=1, appName='测试应用', appCode='ceshi', authType='1', createDate=2023-10-31, creator='admin'}

剩下的工作就是处理查询的结果并返回数据给客户端。通过这个例子对以上提出的几个问题可以有更清晰的认识，那么这些问题如何解决呢？

orm框架的出现就是为了解决以上问题，常用orm框架有

1. Mybatis（半自动、效率高），国内使用率高
2. Hibernate（全自动、效率低）

总结

今天我们介绍了JDBC操作数据库的基本逻辑，可以看出，通过JDBC的方式操作数据库是比较繁琐的，这也是我们引入Mybatis的一个重要原因。通过后续的学习，可以深刻的体会到Mybatis相比于JDBC的优势。

---

📩 联系方式
邮箱：qijilaoli@foxmail.com

?版权声明
本文为原创文章，版权归作者所有。未经许可，禁止转载。更多内容请访问奇迹老李的博客首页