Java使用MyBatis操作数据库详解

学习知识要善于思考，思考，再思考！今天golang学习网小编就给大家带来《Java如何用MyBatis操作数据库》，以下内容主要包含等知识点，如果你正在学习或准备学习文章，就都不要错过本文啦~让我们一起来看看吧，能帮助到你就更好了！

MyBatis通过SQL映射文件与Java接口的绑定简化数据库操作，1. 引入MyBatis依赖以集成框架；2. 编写XML映射文件定义SQL语句并配置namespace、parameterType和resultType；3. 创建Java接口声明对应方法，由MyBatis自动生成实现；4. 配置mybatis-config.xml设置数据库连接与映射文件路径；5. 使用SqlSessionFactory创建SqlSession并获取Mapper执行操作，需手动提交事务；6. 利用动态SQL标签如if、where、foreach根据条件拼接SQL；7. 启用一级缓存（默认）和二级缓存提升性能，注意缓存一致性；8. 通过association、collection处理一对一、一对多等复杂映射关系，最终实现高效灵活的数据库访问。

直接操作数据库，听起来就像直接用锤子砸钉子，虽然可行，但效率嘛... MyBatis就像一个精巧的工具箱，帮你把那些繁琐的JDBC代码隐藏起来，让你专注于SQL本身。

解决方案：

MyBatis的核心在于SQL映射文件和Java接口。你需要定义一个接口，然后在XML文件中编写SQL语句，MyBatis会负责将接口方法和SQL语句关联起来。

1. 引入MyBatis依赖：

   首先，在你的Maven或Gradle项目中添加MyBatis的依赖。比如，Maven配置如下：

   <dependency>
       <groupId>org.mybatis</groupId>
       <artifactId>mybatis</artifactId>
       <version>3.5.9</version>
   </dependency>

   顺便提一句，选择合适的MyBatis版本很重要，太旧的版本可能不支持新的特性，太新的版本可能不稳定。

2. 编写SQL映射文件：

   创建一个XML文件（例如UserMapper.xml），用于定义SQL语句。这个文件需要放在classpath下。

   <?xml version="1.0" encoding="UTF-8"?>
   <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <mapper namespace="com.example.dao.UserMapper">
   
       &lt;select id=&quot;getUserById&quot; parameterType=&quot;int&quot; resultType=&quot;com.example.entity.User&quot;&gt;
           SELECT id, name, email FROM users WHERE id = #{id}
       &lt;/select&gt;
   
       <insert id="insertUser" parameterType="com.example.entity.User">
           INSERT INTO users (name, email) VALUES (#{name}, #{email})
       </insert>
   
       <update id="updateUser" parameterType="com.example.entity.User">
           UPDATE users SET name = #{name}, email = #{email} WHERE id = #{id}
       </update>
   
       <delete id="deleteUser" parameterType="int">
           DELETE FROM users WHERE id = #{id}
       </delete>
   
   </mapper>

   namespace 属性必须和对应的Java接口完全匹配。parameterType 和 resultType 分别指定了输入参数类型和返回结果类型。#{id} 这样的语法是MyBatis的参数占位符。

3. 定义Java接口：

   创建一个Java接口（例如UserMapper.java），声明与SQL映射文件中定义的SQL语句对应的方法。

   package com.example.dao;
   
   import com.example.entity.User;
   
   public interface UserMapper {
       User getUserById(int id);
       void insertUser(User user);
       void updateUser(User user);
       void deleteUser(int id);
   }

   这个接口定义了数据库操作的方法，MyBatis会根据SQL映射文件中的配置，自动生成接口的实现类。

4. 配置MyBatis：

   创建一个MyBatis配置文件（例如mybatis-config.xml），用于配置数据库连接信息和SQL映射文件。

   <?xml version="1.0" encoding="UTF-8"?>
   <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
   <configuration>
       <environments default="development">
           <environment id="development">
               <transactionManager type="JDBC"/>
               <dataSource type="POOLED">
                   <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                   <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
                   <property name="username" value="root"/>
                   <property name="password" value="password"/>
               </dataSource>
           </environment>
       </environments>
       <mappers>
           <mapper resource="com/example/dao/UserMapper.xml"/>
       </mappers>
   </configuration>

   environments 节点定义了数据库连接信息，mappers 节点指定了SQL映射文件的位置。

5. 使用MyBatis：

   在Java代码中，使用MyBatis提供的SqlSessionFactory来创建SqlSession，然后通过SqlSession获取Mapper接口的实例，执行数据库操作。

   import org.apache.ibatis.io.Resources;
   import org.apache.ibatis.session.SqlSession;
   import org.apache.ibatis.session.SqlSessionFactory;
   import org.apache.ibatis.session.SqlSessionFactoryBuilder;
   import com.example.dao.UserMapper;
   import com.example.entity.User;
   
   import java.io.IOException;
   import java.io.InputStream;
   
   public class MyBatisExample {
       public static void main(String[] args) throws IOException {
           String resource = "mybatis-config.xml";
           InputStream inputStream = Resources.getResourceAsStream(resource);
           SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
   
           try (SqlSession session = sqlSessionFactory.openSession()) {
               UserMapper userMapper = session.getMapper(UserMapper.class);
               User user = userMapper.getUserById(1);
               System.out.println(user);
   
               User newUser = new User();
               newUser.setName("Alice");
               newUser.setEmail("alice@example.com");
               userMapper.insertUser(newUser);
               session.commit(); // 记得提交事务
   
               user = userMapper.getUserById(newUser.getId()); // 假设数据库自增生成了ID
               System.out.println(user);
           }
       }
   }

   注意，每次执行完数据库操作后，都需要调用session.commit()提交事务，否则数据不会被写入数据库。

MyBatis的动态SQL有什么用？

动态SQL是MyBatis的一大亮点。它可以根据不同的条件生成不同的SQL语句，避免了大量的字符串拼接操作。例如，你可以使用、、、、、、等标签来构建动态SQL。

<select id="findUsers" parameterType="map" resultType="com.example.entity.User">
    SELECT * FROM users
    <where>
        <if test="name != null and name != ''">
            name LIKE #{name}
        </if>
        <if test="email != null and email != ''">
            AND email LIKE #{email}
        </if>
    </where>
&lt;/select&gt;

这个例子中，只有当name和email不为空时，才会将对应的条件添加到SQL语句中。where标签会自动处理AND关键字，避免出现语法错误。

MyBatis的缓存机制如何提升性能？

MyBatis提供了两级缓存：一级缓存和二级缓存。

• 一级缓存（SqlSession级别）： 默认开启，作用范围是同一个SqlSession。在同一个SqlSession中，如果执行相同的查询语句，MyBatis会直接从缓存中获取结果，避免重复查询数据库。
• 二级缓存（SqlSessionFactory级别）： 默认关闭，作用范围是同一个SqlSessionFactory创建的多个SqlSession。需要手动配置开启。

开启二级缓存需要在MyBatis配置文件中添加如下配置：

<settings>
    <setting name="cacheEnabled" value="true"/>
</settings>

然后在SQL映射文件中，为需要开启缓存的SQL语句添加标签：

<cache eviction="LRU" flushInterval="60000" readOnly="true" size="1024"/>
&lt;select id=&quot;getUserById&quot; parameterType=&quot;int&quot; resultType=&quot;com.example.entity.User&quot; useCache=&quot;true&quot;&gt;
    SELECT id, name, email FROM users WHERE id = #{id}
&lt;/select&gt;

eviction 属性指定了缓存的淘汰策略，flushInterval 属性指定了缓存的刷新间隔，readOnly 属性指定了缓存是否只读，size 属性指定了缓存的大小。

不过，使用二级缓存需要注意缓存一致性问题。如果数据库中的数据发生了变化，需要及时刷新缓存，避免出现脏数据。

如何处理MyBatis中的复杂类型映射？

MyBatis可以处理各种复杂类型映射，例如一对一、一对多、多对多等。

• 一对一映射： 使用标签。

  <resultMap id="UserResultMap" type="com.example.entity.User">
      <id property="id" column="user_id"/>
      <result property="name" column="user_name"/>
      <result property="email" column="user_email"/>
      <association property="address" javaType="com.example.entity.Address">
          <id property="id" column="address_id"/>
          <result property="street" column="address_street"/>
          <result property="city" column="address_city"/>
      </association>
  </resultMap>
  
  &lt;select id=&quot;getUserById&quot; parameterType=&quot;int&quot; resultMap=&quot;UserResultMap&quot;&gt;
      SELECT
          u.id AS user_id,
          u.name AS user_name,
          u.email AS user_email,
          a.id AS address_id,
          a.street AS address_street,
          a.city AS address_city
      FROM users u
      LEFT JOIN addresses a ON u.address_id = a.id
      WHERE u.id = #{id}
  &lt;/select&gt;

• 一对多映射： 使用标签。

  <resultMap id="UserResultMap" type="com.example.entity.User">
      <id property="id" column="user_id"/>
      <result property="name" column="user_name"/>
      <result property="email" column="user_email"/>
      <collection property="orders" ofType="com.example.entity.Order">
          <id property="id" column="order_id"/>
          <result property="orderDate" column="order_date"/>
          <result property="totalAmount" column="total_amount"/>
      </collection>
  </resultMap>
  
  &lt;select id=&quot;getUserById&quot; parameterType=&quot;int&quot; resultMap=&quot;UserResultMap&quot;&gt;
      SELECT
          u.id AS user_id,
          u.name AS user_name,
          u.email AS user_email,
          o.id AS order_id,
          o.order_date AS order_date,
          o.total_amount AS total_amount
      FROM users u
      LEFT JOIN orders o ON u.id = o.user_id
      WHERE u.id = #{id}
  &lt;/select&gt;

• 多对多映射： 实际上可以看作是两个一对多映射的组合。

总的来说，MyBatis是一个非常灵活和强大的持久层框架。它让你专注于SQL本身，避免了大量的JDBC代码，提高了开发效率。当然，学习MyBatis也需要一定的成本，需要掌握SQL、XML、Java等知识。但一旦掌握了MyBatis，你就可以更加轻松地操作数据库，构建高效稳定的应用程序。

好了，本文到此结束，带大家了解了《Java使用MyBatis操作数据库详解》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多文章知识！