• 【SSM】MyBatis 操作数据库（重点：Mybatis两种使用方式）

    【大家好，我是爱干饭的猿，本文重点介绍ORM 框架和Mybatis的关系、如何通过注解 或者 通过XML配置文件的使用Mybatis，以及参数占位符 #{} 和 ${} 的区别， 什么是sql 注入。

    后续会继续分享其他重要知识点总结，如果喜欢这篇文章，点个赞👍，关注一下吧】

    上一篇文章：《【SSM】Spring AOP 统一问题处理（重点：Spring AOP 实现原理）》

    🤞目录🤞

    🎁1.MyBatis 是什么？

    🎁2. 什么是ORM框架？

    🎁3. MyBatis 的使用

    3.1 添加MyBatis框架支持

    1. 新项目添加MyBatis框架

    2. 旧项目添加MyBatis框架

    3.2 配置连接字符串和MyBatis

    1. 配置连接字符串

    2. 配置 MyBatis 中的 XML 路径

    3.3 通过注解使用Mybatis

    1. 查询

    2. 插入

    3. 修改

    4. 删除

    5. 总览（增删查改）

    3.4 通过XML配置文件的形式使用Mybatis

    0. 关于resultMap

    1. 查询

    2. 插入

    3. 修改

    4. 删除

    5. 总览（增删查改）

    3.5 参数占位符 #{} 和 ${} 和 sql 注入

    🎁1.MyBatis 是什么？

    MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 去除了几乎所有的 JDBC 代码以及设置参数和获 取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

    简单来说 MyBatis 是更简单完成程序和数据库交互的工具，也就是更简单的操作和读取数据库工具。

    🎁2. 什么是ORM框架？

    ORM 把数据库映射为对象：

    • 数据库表（table）--> 类（class）
    • 记录（record，行数据）--> 对象（object）
    • 字段（field） --> 对象的属性（attribute）

    一般的 ORM 框架，会将数据库模型的每张表都映射为一个 Java 类。 也就是说使用 MyBatis 可以像操作对象一样来操作数据库中的表，可以实现对象和数据库表之间的转换。

    MyBatis 也是一个 ORM 框架，ORM（Object Relational Mapping)，即对象关系映射。在面向对象编程语言中，将关系型数据库中的数据 与对象建立起映射关系，进而自动的完成数据与对象的互相转换：

    1. 将输入数据（即传入对象）+SQL 映射成原生 SQL

    2. 将结果集映射为返回对象，即输出对象

     

    一些其他框架：

    • Hibernate框架：偏向简化SQL的模式
    • MyBatis框架：偏向ORM的模式
    • Spring 内部提供的JdbcTemplate：偏向简化SQL的模式
    • JPA ：完全倒向了ORM的形式，建表的过程都被抽象，我们看到的只有类（我写了类，框架根据类建表)

    🎁3. MyBatis 的使用

    3.1 添加MyBatis框架支持

    1. 新项目添加MyBatis框架

    2. 旧项目添加MyBatis框架

    a. 使用 EditStarters插件

     

    b. 手动添加

    1.         
    2. 		<dependency>
    3. 			<groupId>org.springframework.bootgroupId>
    4. 			<artifactId>spring-boot-starter-data-jdbcartifactId>
    5. 		dependency>
    6. 		
    7. 		<dependency>
    8. 			<groupId>org.mybatis.spring.bootgroupId>
    9. 			<artifactId>mybatis-spring-boot-starterartifactId>
    10. 			<version>2.2.2version>
    11. 		dependency>
    12. 		
    13. 		<dependency>
    14. 			<groupId>mysqlgroupId>
    15. 			<artifactId>mysql-connector-javaartifactId>
    16. 			<scope>runtimescope>
    17. 		dependency>

    3.2 配置连接字符串和MyBatis

    此步骤需要进行两项设置，数据库连接字符串设置和 MyBatis 的 XML 文件配置。

    1. 配置连接字符串

    如果是 application.yml 添加如下内容：

    1. spring:
    2.   datasource:
    3.     url: jdbc:mysql://127.0.0.1:3306/***?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai
    4.     username: root
    5.     password: 123456

    2. 配置 MyBatis 中的 XML 路径

    通过XML配置文件的形式使用Mybatis 时需要配置，通过注解使用Mybatis时，不需要配置

    1. mybatis:
    2.   mapper-locations: classpath:mapper/**.xml

    3.3 通过注解使用Mybatis

    定义Mapper 接口

    1. @Repository // 消除报错
    2. @Mapper   // Mapper 注解
    3. public interface UserMapper {
    4.  
    5. }

    1. 查询

    1.     // 1. 查询
    2.     // 1.1 通过uid 查询得到Map对象
    3.     @Select("select uid, username, password from users where uid = #{uid}")
    4.     Map select1(@Param("uid") int uid);
    5.  
    6.     // 1.2 通过uid 查询得到User类对象
    7.     @Select("select uid, username, password from users where uid = #{uid}")
    8.     UserDO select2(@Param("uid") int uid);

    2. 插入

    1.     // 2. 插入
    2.     // 2.1 插入，返回插入成功的条数
    3.     @Insert("insert into users (username, password) values (#{username}, #{password})")
    4.     int insert1(UserDO userDO);
    5.  
    6.     // 2.2 由于用不到这个返回值，所以写成 void 更常见
    7.     @Insert("insert into users (username, password) values (#{username}, #{password})")
    8.     void insert2(UserDO userDO);
    9.  
    10.     // 2.3 插入后拿到自增id
    11.     // 通过 @Options 注解，添加一些配置，得到自增主键，设置成 uid
    12.     // keyProperty : 对象的属性名是 uid
    13.     // keyColumn : 表的字段名的 uid
    14.     @Insert("insert into users (username, password) values (#{username}, #{password})")
    15.     @Options(useGeneratedKeys = true, keyProperty = "uid", keyColumn = "uid")
    16.     void insert3(UserDO userDO);

    3. 修改

    1.     // 3. 修改
    2.     @Update("update users set username = #{username}, password = #{password} where uid = #{uid}")
    3.     int update(UserDO userDO);

    4. 删除

    1.     // 4. 删除
    2.     @Delete("delete from users where uid = #{uid}")
    3.     int delete(@Param("uid") int uid);

    5. 总览（增删查改）

    1. import org.apache.ibatis.annotations.*;
    2. import org.springframework.stereotype.Repository;
    3. import java.util.Map;
    4.  
    5. @Repository // 消除报错
    6. @Mapper   // Mapper 注解
    7. public interface UserMapper {
    8.  
    9.     // 1. 查询
    10.     // 1.1 通过uid 查询得到Map对象
    11.     @Select("select uid, username, password from users where uid = #{uid}")
    12.     Map select1(@Param("uid") int uid);
    13.  
    14.     // 1.2 通过uid 查询得到User类对象
    15.     @Select("select uid, username, password from users where uid = #{uid}")
    16.     UserDO select2(@Param("uid") int uid);
    17.  
    18.     // 2. 插入
    19.     // 2.1 插入，返回插入成功的条数
    20.     @Insert("insert into users (username, password) values (#{username}, #{password})")
    21.     int insert1(UserDO userDO);
    22.  
    23.     // 2.2 由于用不到这个返回值，所以写成 void 更常见
    24.     @Insert("insert into users (username, password) values (#{username}, #{password})")
    25.     void insert2(UserDO userDO);
    26.  
    27.     // 2.3 插入后拿到自增id
    28.     // 通过 @Options 注解，添加一些配置，得到自增主键，设置成 uid
    29.     // keyProperty : 对象的属性名是 uid
    30.     // keyColumn : 表的字段名的 uid
    31.     @Insert("insert into users (username, password) values (#{username}, #{password})")
    32.     @Options(useGeneratedKeys = true, keyProperty = "uid", keyColumn = "uid")
    33.     void insert3(UserDO userDO);
    34.  
    35.     // 3. 修改
    36.     @Update("update users set username = #{username}, password = #{password} where uid = #{uid}")
    37.     int update(UserDO userDO);
    38.  
    39.     // 4. 删除
    40.     @Delete("delete from users where uid = #{uid}")
    41.     int delete(@Param("uid") int uid);
    42. }

    3.4 通过XML配置文件的形式使用Mybatis

    先配置 MyBatis 中的 XML 路径，然后在mapper下 .xml 文件中写

     

    定义Mapper 接口：

    1. import org.apache.ibatis.annotations.Mapper;
    2. import org.apache.ibatis.annotations.Param;
    3. import org.springframework.stereotype.Repository;
    4. import java.util.List;
    5.  
    6. @Repository
    7. @Mapper
    8. public interface UserMapper {
    9.     // 1. 查询
    10.     // 1.1 单个查询
    11.     User selectOneByUid(@Param("uid") int uid);
    12.     // 1.2 多个查询
    13.     List selectListByUidList(@Param("uidList") List uidList);
    14.     // 1.3 动态查询
    15.     User selectByUser(@Param("user") User user);
    16.  
    17.     // 2. 插入
    18.     // 2.1 单个插入
    19.     int insertOneUser(@Param("user") User user);
    20.     // 2.1 批量插入
    21.     int insertBatch(@Param("userList") List userList);
    22.  
    23.     // 3. 修改
    24.     void update(int uid , String username);
    25.  
    26.     // 4. 删除
    27.     void delete(int uid);
    28. }

    0. 关于resultMap

    使用场景：

    • 字段名称和程序中的属性名不同的情况，可使用 resultMap 配置映射；
    • 一对一和一对多关系可以使用 resultMap 映射并查询数据。
    1.     
    2.     <resultMap id="xxx" type="com.haomin.mybatis_xml.User">
    3.         <id property="uid" javaType="Integer" column="uid" jdbcType="INTEGER" />
    4.         <result property="username" javaType="String" column="username" jdbcType="VARCHAR" />
    5.         <result property="password" column="password" />
    6.     resultMap>

    1. 查询

    1.     
    2.     <select id="selectOneByUid" resultType="com.haomin.mybatis_xml.User" parameterType="int">
    3.         select uid, username, password from users where uid = #{uid}
    4.     select>
    5.  
    6.     
    7.     <select id="selectListByUidList" resultMap="xxx" parameterType="List">
    8.         select uid, username, password from users where uid in (
    9.             <foreach collection="uidList" item="id" separator=", ">
    10.                 #{id}
    11.             foreach>
    12.         ) order by uid
    13.     select>
    14.  
    15.     
    16.     <select id="selectByUser" resultMap="xxx" parameterType="com.haomin.mybatis_xml.User">
    17.         select uid, username, password from users where
    18.         <if test="user.uid != null">
    19.             uid = #{user.uid}
    20.         if>
    21.         <if test="user.username != null">
    22.             and username = #{user.username}
    23.         if>
    24.         <if test="user.password != null">
    25.             and password = #{user.password}
    26.         if>
    27.     select>

    2. 插入

    1.     
    2.     <insert id="insertOneUser" useGeneratedKeys="true" keyProperty="uid" keyColumn="uid">
    3.         insert into users (username, password) values
    4.         (#{user.username}, #{user.password})
    5.     insert>
    6.  
    7.     
    8.     <insert id="insertBatch" useGeneratedKeys="true" keyProperty="uid" keyColumn="uid">
    9.         insert into users (username, password) values
    10.         <foreach collection="userList" item="user" separator=", ">
    11.             (#{user.username}, #{user.password})
    12.         foreach>
    13.     insert>

    3. 修改

    1.     
    2.     <update id="update">
    3.         update users set username = #{username} where uid = #{uid}
    4.     update>

    4. 删除

    1.     
    2.     <delete id="delete">
    3.         delete from users where uid = #{uid}
    4.     delete>

    5. 总览（增删查改）

    1. "1.0" encoding="UTF-8" ?>
    2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    3.  
    4. <mapper namespace="com.haomin.mybatis_xml.UserMapper">
    5.     
    6.     <resultMap id="xxx" type="com.haomin.mybatis_xml.User">
    7.         <id property="uid" javaType="Integer" column="uid" jdbcType="INTEGER" />
    8.         <result property="username" javaType="String" column="username" jdbcType="VARCHAR" />
    9.         <result property="password" column="password" />
    10.     resultMap>
    11.  
    12.     
    13.     <select id="selectOneByUid" resultType="com.haomin.mybatis_xml.User" parameterType="int">
    14.         select uid, username, password from users where uid = #{uid}
    15.     select>
    16.  
    17.     
    18.     <select id="selectListByUidList" resultMap="xxx" parameterType="List">
    19.         select uid, username, password from users where uid in (
    20.             <foreach collection="uidList" item="id" separator=", ">
    21.                 #{id}
    22.             foreach>
    23.         ) order by uid
    24.     select>
    25.  
    26.     
    27.     <select id="selectByUser" resultMap="xxx" parameterType="com.haomin.mybatis_xml.User">
    28.         select uid, username, password from users where
    29.         <if test="user.uid != null">
    30.             uid = #{user.uid}
    31.         if>
    32.         <if test="user.username != null">
    33.             and username = #{user.username}
    34.         if>
    35.         <if test="user.password != null">
    36.             and password = #{user.password}
    37.         if>
    38.     select>
    39.  
    40.     
    41.     <insert id="insertOneUser" useGeneratedKeys="true" keyProperty="uid" keyColumn="uid">
    42.         insert into users (username, password) values
    43.         (#{user.username}, #{user.password})
    44.     insert>
    45.  
    46.     
    47.     <insert id="insertBatch" useGeneratedKeys="true" keyProperty="uid" keyColumn="uid">
    48.         insert into users (username, password) values
    49.         <foreach collection="userList" item="user" separator=", ">
    50.             (#{user.username}, #{user.password})
    51.         foreach>
    52.     insert>
    53.  
    54.     
    55.     <update id="update">
    56.         update users set username = #{username} where uid = #{uid}
    57.     update>
    58.  
    59.     
    60.     <delete id="delete">
    61.         delete from users where uid = #{uid}
    62.     delete>
    63. mapper>

    当然还有更多用法：可以参考 Mybatis 官方文档

    3.5 参数占位符 #{} 和 ${} 和 sql 注入

    #{}：预编译处理。

    ${}：字符直接替换。

    #{}预编译处理是指：MyBatis 在处理#{}时，会将 SQL 中的 #{} 替换为?号，使用 PreparedStatement 的 set 方法来赋值，编译后会带上 ‘ ’。

    ${}直接替换：是 MyBatis 在处理 ${} 时，就是把 ${} 替换成变量的值。

    结论：

    • 用于查询的字段，尽量使用 #{} 预查询的方式，如果用${} 可能会出现sql注入问题。
    • 使用 ${sort} 可以实现排序查询或者分页，而使用 #{sort} 就不能实现排序查询了，因为当使用 #{sort} 查询时，如果传递的值为 String 则会加单引号，就会导致 sql 错误。

    sql 注入代码例子：

    执行：

    select * from userinfo where username = '${name}' and password = '${pwd}'

    当sql 为 ： ' or 1=1  时

    执行语句：

    select * from users where username = ' or 1=1  and password = ' or 1=1;

    当然，Mybatis 还有更多用法：可以参考 Mybatis 官方文档

    分享到此，感谢大家观看！！！

    如果你喜欢这篇文章，请点赞加关注吧，或者如果你对文章有什么困惑，可以私信我。

    🏓🏓🏓

  • 相关阅读:
    化繁为简，国内知名期货交易所依托 MogDB 数据库促信创改造项目提速
    go语言判断管道是否关闭的误区
    @Override 的作用
    单元测试：会变化的定义
    C++之二叉搜索树详解
    C语言 题目 1760: 字符序列模式识别
    FPGA之旅设计99例之第十四例-----接收红外遥控数据
    docker run 参数
    牛客网刷题训练(一）
    Oracle/PLSQL: Avg Function
  • 原文地址：https://blog.csdn.net/m0_62218217/article/details/127392647