Java教程

Mybatis持久层框架学习入门

本文主要是介绍Mybatis持久层框架学习入门，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
概述

Mybatis是一款优秀的持久层框架，支持定制化SQL和存储过程，能够将Java类直接映射到数据库记录。本文将详细介绍Mybatis的基本概念、优势、环境搭建以及常用操作，帮助读者全面了解Mybatis持久层框架学习入门。

Mybatis简介

Mybatis基本概念

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 通过 XML 或注解配置描述来将 Java 类映射成数据库中的记录。它通过使用简单的 Java 操作来完成以前繁复的 JDBC 操作。

MyBatis 通过定义 XML 映射文件或注解来配置 SQL，能够将 SQL 执行结果映射为 Java 对象，使得 Java 对象与数据库的关系映射更加直接和灵活。

Mybatis的优势和应用场景

优势：

  1. 灵活性：MyBatis 的配置和 SQL 映射文件使 SQL 语句的维护变得简单。
  2. 性能：MyBatis 的性能优于那些使用存储过程和预编译语句的框架，因为它使用动态 SQL，减少了数据库访问次数。
  3. 易用性：通过简单的配置，MyBatis 可以与各种数据库系统进行交互。
  4. 强大的映射：MyBatis 的映射文件使 SQL 语句的映射变得简单，支持复杂类型映射。

应用场景：

  • 中小型企业级应用：中小型企业由于资源有限，MyBatis 可以提供数据库访问的灵活性和高性能，同时减少开发工作量。
  • 复杂的数据库操作：对于具有复杂数据库操作的应用，MyBatis 的强大映射功能可以使得数据库操作更加直接和灵活。
  • 需要高性能的应用：MyBatis 通过动态 SQL 和配置文件来优化 SQL 语句的执行效率，使得应用在处理数据库操作时更加高效。
Mybatis环境搭建

开发环境准备

要使用 MyBatis，需要准备以下环境：

  1. Java 开发环境：配置 JDK 和开发工具，如 Eclipse 或 IntelliJ IDEA。
  2. 数据库环境：安装 MySQL、Oracle 等数据库，并创建数据库和表。
  3. 依赖库：下载 MyBatis 的依赖库。

以下为简单的开发环境配置示例：

<!-- pom.xml 中的依赖配置 -->
<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.21</version>
    </dependency>
</dependencies>

添加Mybatis依赖

在 Maven 项目的 pom.xml 文件中添加 MyBatis 和数据库驱动的依赖：

<dependencies>
    <!-- 添加 MyBatis 依赖 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>
    <!-- 添加 MySQL 驱动依赖 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.21</version>
    </dependency>
</dependencies>

配置文件的编写

MyBatis 的配置文件 mybatis-config.xml 通常包含以下内容：

  1. 环境配置：定义数据库连接信息。
  2. 类型别名：定义类型别名，简化配置。
  3. 映射文件：指定 SQL 映射文件的位置。
<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>
    <typeAliases>
        <typeAlias type="com.example.entity.User" alias="User" />
    </typeAliases>
    <mappers>
        <mapper resource="com/example/mapper/UserMapper.xml" />
    </mappers>
</configuration>

创建数据库表

假设我们有一个名为 users 的表，其结构如下：

CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50),
    password VARCHAR(50)
);
Mybatis核心概念

SqlSession和SqlSessionFactory

SqlSessionFactory 用于创建 SqlSession，而 SqlSession 用于执行数据库操作。

// 创建 SqlSessionFactory
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-config.xml"));

// 使用 SqlSessionFactory 创建 SqlSession
SqlSession session = factory.openSession();

映射文件和Mapper接口

映射文件通常定义 SQL 语句和结果映射，而 Mapper 接口定义了数据库操作方法。

<!-- UserMapper.xml -->
<mapper namespace="com.example.mapper.UserMapper">
    <select id="selectUserById" resultType="User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>
// UserMapper.java
public interface UserMapper {
    User selectUserById(int id);
}

{}和${}的区别和使用场景

  • #{...}：用于预编译语句的占位符，可以防止 SQL 注入，提供类型安全。
  • ${...}：用于字符串拼接，不安全，容易导致 SQL 注入。
<select id="selectUserByIdWithDynamicSql" resultType="User">
    SELECT * FROM users WHERE id = #{id}
</select>

<select id="selectUserByIdWithDynamicSql2" resultType="User">
    SELECT * FROM users WHERE id = ${id}
</select>

配置文件中的参数插值示例

在 XML 配置文件中使用 #{...} 和 ${...} 的示例：

<update id="updateUserById">
    UPDATE users SET username = #{username}, password = #{password} WHERE id = #{id}
</update>

<update id="updateUserByIdWithDynamicSql">
    UPDATE users SET username = ${username}, password = ${password} WHERE id = ${id}
</update>
Mybatis常用操作

CRUD操作详解

CRUD 操作指的是数据库的增删查改操作。下面我们将详细介绍 MyBatis 的 CRUD 操作。

  1. 增：
<!-- UserMapper.xml -->
<insert id="insertUser">
    INSERT INTO users (id, username, password) VALUES (#{id}, #{username}, #{password})
</insert>
// UserMapper.java
public interface UserMapper {
    int insertUser(User user);
}
  1. 删：
<delete id="deleteUserById">
    DELETE FROM users WHERE id = #{id}
</delete>
// UserMapper.java
public interface UserMapper {
    int deleteUserById(int id);
}
  1. 查：
<select id="selectUserById" resultType="User">
    SELECT * FROM users WHERE id = #{id}
</select>
// UserMapper.java
public interface UserMapper {
    User selectUserById(int id);
}
  1. 改：
<update id="updateUserById">
    UPDATE users SET username = #{username}, password = #{password} WHERE id = #{id}
</update>
// UserMapper.java
public interface UserMapper {
    int updateUserById(User user);
}

分页查询

分页查询可以通过设置 RowBounds 来实现。

// 分页查询示例
List<User> users = session.selectList("com.example.mapper.UserMapper.selectUsersByPage", new User(), new RowBounds(0, 10));

动态SQL的使用

MyBatis 通过 <if>, <choose>, <when>, <otherwise> 标签来实现动态 SQL。

<select id="selectUserByCondition" resultType="User">
    SELECT * FROM users
    <where>
        <if test="id != null">
            AND id = #{id}
        </if>
        <if test="username != null">
            AND username = #{username}
        </if>
    </where>
</select>

实际项目示例

假设我们有一个用户管理系统，包含增删查改操作和分页功能。

// UserMapper.java
public interface UserMapper {
    int insertUser(User user);
    int deleteUserById(int id);
    User selectUserById(int id);
    int updateUserById(User user);
    List<User> getUsersByPage(int offset, int limit);
}
<!-- UserMapper.xml -->
<insert id="insertUser">
    INSERT INTO users (id, username, password) VALUES (#{id}, #{username}, #{password})
</insert>

<delete id="deleteUserById">
    DELETE FROM users WHERE id = #{id}
</delete>

<select id="selectUserById" resultType="User">
    SELECT * FROM users WHERE id = #{id}
</select>

<update id="updateUserById">
    UPDATE users SET username = #{username}, password = #{password} WHERE id = #{id}
</update>

<select id="getUsersByPage" resultType="User">
    SELECT * FROM users LIMIT #{offset}, #{limit}
</select>
Mybatis与Spring整合

Spring和Mybatis集成的意义

Spring 是一个轻量级的企业级应用框架，它简化了 Java 应用程序的开发。Spring 对 MyBatis 的支持使我们能够方便地使用 MyBatis 的核心功能，包括依赖注入、AOP 支持、事务管理等。

配置Spring集成Mybatis的步骤

  1. 添加依赖：
<dependencies>
    <dependency>
        <groupId>org.mybatis.spring</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.10</version>
    </dependency>
</dependencies>
  1. 配置数据源：
<!-- applicationContext.xml -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" 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" />
</bean>
  1. 配置 SqlSessionFactoryBean：
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="mapperLocations" value="classpath*:mapper/*.xml" />
</bean>
  1. 配置 MapperScannerConfigurer：
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.example.mapper" />
    <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

使用注解开发Mapper接口

@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User selectUserById(int id);

    @Insert("INSERT INTO users (id, username, password) VALUES (#{id}, #{username}, #{password})")
    void insertUser(User user);
}
Mybatis高级特性

一级和二级缓存

MyBatis 提供了一级缓存和二级缓存，可以提高查询效率。

  1. 一级缓存：默认开启，基于会话的缓存。
<cache/>
  1. 二级缓存：基于数据源的缓存，需显式开启。
<cache
    eviction="FIFO"
    flushInterval="60000"
    size="512"
    readOnly="true"/>

插件开发

MyBatis 允许通过插件拦截特定的调用，以实现自定义的功能。

@Intercepts({@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})})
public class MyPlugin implements Interceptor {
    public Object intercept(Invocation invocation) throws Throwable {
        // 自定义逻辑
        return invocation.proceed();
    }
}

批量操作

批量操作可以提高数据库操作效率。

<insert id="insertUsers">
    INSERT INTO users (id, username, password) VALUES
    <foreach item="item" index="index" collection="list" separator=",">
        (#{item.id}, #{item.username}, #{item.password})
    </foreach>
</insert>
@InsertProvider(type = UserMapperProvider.class, method = "insertUsers")
int insertUsers(@Param("list") List<User> users);

通过以上详细介绍，我们可以看到 MyBatis 是一个非常强大和灵活的持久层框架，适用于各种复杂的应用场景。通过合理使用 MyBatis 的各种特性，可以极大提高数据库操作的效率和灵活性。

这篇关于Mybatis持久层框架学习入门的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
栏目导航