Mybatis-获取参数值的两种方式

最新推荐文章于 2024-04-26 20:19:53 发布
最新推荐文章于 2024-04-26 20:19:53 发布
阅读量1.3k 收藏 22
点赞数 48
分类专栏： # Mybatis / Mybatis Plus 文章标签： mybatis 数据库 java 学习 笔记 sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sakurapaid/article/details/137093029
版权

1. ${ } 和 #{ }

MyBatis获取参数值的两种方式：${ } 和 #{ }

对于初学者来说，理解MyBatis中获取参数值的两种方式——#{}和${}，关键在于明白它们如何影响SQL语句的构建以及为何在安全性、灵活性上有显著差异。下面我将用简单易懂的语言来解释这两者的本质、工作原理及使用注意事项。

1. ${}：字符串拼接

本质：${}在MyBatis中被视为字符串替换符。当你在SQL语句中使用${}时，MyBatis会直接将它包围的变量名替换为实际传入的值。这种方式类似于在编程语言中进行字符串拼接操作，即将传入的值作为文本片段插入到SQL语句中。

工作原理：

SELECT * FROM users WHERE username = '${username}'

假设传入的username参数为 'zhangsan'，MyBatis会将上述SQL语句中的${username}替换为 'zhangsan'，生成如下已拼接好的SQL：

SELECT * FROM users WHERE username = 'zhangsan'

特点与注意事项：

  • 手动处理引号：由于${}直接参与字符串拼接，因此对于字符串类型或日期类型的字段值，你需要确保传入的值已经正确地加上了单引号。例如，如果你传入的是 'zhangsan' 而不是 zhangsan，MyBatis不会帮你自动加上单引号。
  • SQL注入风险：由于${}直接将传入的值作为原始文本插入到SQL语句中，没有进行任何预处理或转义，因此它不提供对SQL注入攻击的防护。如果传入的值来自不可信的用户输入，恶意用户可能通过构造特定的输入来篡改SQL语句的结构和意图，从而对数据库造成潜在威胁。因此，除非有明确需求且能够确保输入安全，否则应避免在条件查询等涉及用户输入的地方使用${}。
  • 适用场景：${}通常用于那些需要原样插入到SQL语句中且不会引起SQL注入风险的情况，如动态表名、列名（虽然不推荐），或者在你已经确保传入值安全的情况下。

2. #{}：预编译占位符

本质：#{}在MyBatis中是一个预编译占位符。当SQL语句中包含#{}时，MyBatis会将其替换为一个问号（?），并在执行SQL时使用PreparedStatement来设置参数值。这种方式利用数据库的预编译机制，确保了参数值的安全性和类型正确性。

工作原理：

SELECT * FROM users WHERE username = #{username}

同样假设传入的username参数为 'zhangsan'，MyBatis会将上述SQL语句中的#{username}替换为 ?，然后使用PreparedStatement向数据库发送如下预编译SQL：

SELECT * FROM users WHERE username = ?

同时，MyBatis会将 'zhangsan' 作为参数值，通过PreparedStatement的set方法安全地绑定到SQL语句中的对应位置。

特点与注意事项：

  • 自动处理引号：使用#{}时，MyBatis会根据参数的实际类型自动为其添加合适的引号或进行其他必要的类型转换。对于字符串和日期类型，MyBatis会自动加上单引号。所以你不需要担心引号问题，只需传入值即可。
  • 防SQL注入：#{}利用预编译机制，确保参数值与SQL语句主体分离，由数据库在执行时负责正确的参数绑定。这从根本上杜绝了SQL注入攻击的可能性，极大地增强了系统的安全性。
  • 适用场景：#{}是推荐的参数传递方式，适用于所有需要动态传入值的场景，特别是涉及到用户输入或敏感信息的条件查询、更新操作等。

举个代码例子：

1. ${}：字符串拼接

想象一下，我们有一个简单的executeQuery()方法，它接受一个用户输入的字符串（比如用户名），然后拼接到SQL查询语句中。

public List<User> executeQuery(String unsafeUsername) {
    // 直接拼接字符串，模拟${}的行为
    String sql = "SELECT * FROM users WHERE username = '" + unsafeUsername + "'";

    // 假设这里有代码执行SQL查询并返回结果...
    // executeSQL(sql);

    return null; // 这里仅作演示，实际应返回查询结果
}

现在，假设用户输入了一个恶意的用户名，如：

String maliciousUsername = "' OR '1'='1"; // 模拟SQL注入攻击

调用executeQuery(maliciousUsername)后，生成的SQL语句将是：

SELECT * FROM users WHERE username = '' OR '1'='1'

由于直接拼接字符串，恶意用户成功篡改了SQL语句的结构，导致查询结果不受控制，暴露了SQL注入风险。

2. #{}：预编译占位符

接下来，我们用类似的方式模拟#{}的工作原理，使用PreparedStatement来设置参数值。

public List<User> executePreparedQuery(String safeUsername) {
    String sql = "SELECT * FROM users WHERE username = ?"; // 使用占位符

    try (Connection conn = getConnection();
         PreparedStatement pstmt = conn.prepareStatement(sql)) {

        pstmt.setString(1, safeUsername); // 安全地设置参数值

        // 假设这里有代码执行PreparedStatement并返回结果...
        // ResultSet rs = pstmt.executeQuery();

        // return processResultSet(rs); // 这里仅作演示，实际应处理结果集并返回结果
    } catch (SQLException e) {
        throw new RuntimeException(e);
    }

    return null; // 这里仅作演示，实际应返回查询结果
}

同样，假设用户输入了恶意的用户名：

String maliciousUsername = "' OR '1'='1";

调用executePreparedQuery(maliciousUsername)时，尽管恶意用户名被传递给了PreparedStatement，但由于预编译机制，数据库会将它视为一个独立的字符串值，而不是SQL语句的一部分。生成并执行的SQL实际上等同于：

SELECT * FROM users WHERE username = ''' OR ''1''=''1''

可以看到，尽管用户输入了恶意内容，但预编译机制确保了参数值被正确地转义和隔离，有效地防止了SQL注入攻击。

小总结

  • ${}就像在Java代码中直接拼接字符串，将用户输入的值原样插入到SQL语句中，需要手动处理引号，并且存在SQL注入风险。仅在确保输入安全且有特殊需求时考虑使用。
  • #{}则是通过预编译机制（如Java中的PreparedStatement），将参数值与SQL语句主体分离，由数据库在执行时负责正确的参数绑定。这样既自动处理了引号和类型转换，又从根本上杜绝了SQL注入攻击，是所有常规参数传递场景的推荐选择。

2. 单个字面量类型参数

当MyBatis的mapper接口中的方法参数仅为一个字面量类型（如Integer、String、Date等基本类型或其包装类），并且您需要在对应的SQL映射文件中引用这个参数时，可以使用${}或#{}来获取该参数的值。

考虑到使用#{}更加安全可靠，所以就用它举个代码例子

UserMapper.java接口

package com.sakurapaid.mybatis3.demo01.mapper;

import com.sakurapaid.mybatis3.demo01.bean.User;

import java.util.List;

public interface UserMapper {
    // 1.添加用户
    public int addUser(User user);

    // 2.修改用户
    public int updateUser(User user);

    // 3.查询所有用户
    public List<User> findAllUser();

    // 4.根据id删除指定用户
    public int deleteUserById(int id);

    // 5. 根据用户名查询用户
    public User findUserByName(String name);
}

UserMapper.xml映射文件

这里的parameterType不是全类名，是因为我在配置文件中做了取别名操作

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 定义mapper接口的命名空间 -->
<mapper namespace="com.sakurapaid.mybatis3.demo01.mapper.UserMapper">
    <!--1.添加用户-->
    <insert id="addUser" parameterType="User">
        insert into user(name,age,sex) values(#{name},#{age},#{sex})
    </insert>
    
    <!--2.修改用户-->
    <update id="updateUser" parameterType="User">
        update user set name=#{name},age=#{age},sex=#{sex} where id=#{id}
    </update>
    
    <!--3.查询所有用户-->
    <select id="findAllUser" resultType="User">
        select * from user
    </select>
    
    <!--4.根据id删除指定用户-->
    <delete id="deleteUserById" parameterType="int">
        delete from user where id=#{id}
    </delete>
    
    <!--5.根据用户名查询用户-->
    <select id="findUserByName" resultType="User">
        select * from user where name=#{name}
    </select>
</mapper>

测试输出

package com.sakurapaid.mybatis3.demo01.test;

import com.sakurapaid.mybatis3.demo01.bean.User;
import com.sakurapaid.mybatis3.demo01.mapper.UserMapper;
import com.sakurapaid.mybatis3.demo01.utils.SqlSessionUtils;
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 org.junit.jupiter.api.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
 * 用户测试类
 */
public class UserTest {
    @Test
    public void test() throws IOException {
        // 从SqlSessionUtils工具类获取SqlSession对象
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        // 获取UserMapper接口的代理对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        // 1.添加用户
        /*User user1 = new User(0, "小明", 18, "男");
        int i = userMapper.addUser(user1);
        if (i > 0) {
            System.out.println("添加成功");
        } else {
            System.out.println("添加失败");
        }*/

        // 2.修改用户
        /*User user2 = new User(1, "萨达姆", 26, "男");
        int i = userMapper.updateUser(user2);
        if (i > 0) {
            System.out.println("修改成功");
        } else {
            System.out.println("修改失败");
        }*/

        // 3.查询所有用户
        /*List<User> users = userMapper.findAllUser();
        if (!users.isEmpty()) {
            for (User user : users) {
                System.out.println(user);
            }
        } else {
            System.out.println("没有数据");
        }*/

        // 4.根据id删除指定用户
        /*int i = userMapper.deleteUserById(4);
        if (i > 0) {
            System.out.println("删除成功");
        } else {
            System.out.println("删除失败");
        }*/

        // 5.根据用户名查询用户
        User user = userMapper.findUserByName("萨达姆");
        if (user != null) {
            System.out.println("查询成功");
            System.out.print(user);
        } else {
            System.out.println("没有数据");
        }
    }
}

3. 多个字面量类型参数

当MyBatis的mapper接口中的方法参数有多个字面量类型（如Integer、String、Date等基本类型或其包装类），MyBatis会以特定方式组织这些参数，以便在SQL映射文件中引用它们。

参数组织方式

  • 默认键名：MyBatis会自动将这些参数放入一个Map集合中。每个参数以其在方法参数列表中的位置作为键名，即arg0, arg1, arg2, ...。例如，对于方法getUserInfo(int id, String name)，参数id对应的键为arg0，参数name对应的键为arg1。
  • 自定义键名：如果在方法参数上使用@Param("paramName")注解，MyBatis会使用注解中指定的名称作为键。例如，@Param("userId") int id和@Param("userName") String name，则键分别为userId和userName。

引用参数

  • 使用${}或#{}：在SQL映射文件中，可以通过${argN}或#{argN}（或使用自定义键名的${paramName}、#{paramName}）来访问Map集合中对应的值。其中，N表示参数在方法参数列表中的位置（从0开始计数），paramName为使用@Param注解指定的名称。
  • 手动添加单引号：对于${}，与单个参数情况相同，对于字符串或日期类型的值，需要手动添加单引号。而对于#{}，仍然无需手动添加任何引号，MyBatis会自动处理。

示例

假设mapper接口方法为：

public User getUserInfo(@Param("userId") int id, @Param("userName") String name);

对应的SQL映射文件片段：

SELECT * FROM users WHERE id = #{userId} AND username = '${userName}'

再举一个代码例子

现在我要传入两个参数，id和name，来查询对应的用户信息

UserMapper.java

package com.sakurapaid.mybatis3.demo01.mapper;

import com.sakurapaid.mybatis3.demo01.bean.User;

import java.util.List;

public interface UserMapper {
    // 1.添加用户
    public int addUser(User user);

    // 2.修改用户
    public int updateUser(User user);

    // 3.查询所有用户
    public List<User> findAllUser();

    // 4.根据id删除指定用户
    public int deleteUserById(int id);

    // 5.根据用户名查询用户
    public User findUserByName(String name);

    // 6.输入id和姓名，查询用户
    public User findUserByIdAndName(int id, String name);
}

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 定义mapper接口的命名空间 -->
<mapper namespace="com.sakurapaid.mybatis3.demo01.mapper.UserMapper">
    <!--1.添加用户-->
    <insert id="addUser" parameterType="User">
        insert into user(name,age,sex) values(#{name},#{age},#{sex})
    </insert>
    
    <!--2.修改用户-->
    <update id="updateUser" parameterType="User">
        update user set name=#{name},age=#{age},sex=#{sex} where id=#{id}
    </update>
    
    <!--3.查询所有用户-->
    <select id="findAllUser" resultType="User">
        select * from user
    </select>
    
    <!--4.根据id删除指定用户-->
    <delete id="deleteUserById" parameterType="int">
        delete from user where id=#{id}
    </delete>
    
    <!--5.根据用户名查询用户-->
    <select id="findUserByName" resultType="User">
        select * from user where name=#{name}
    </select>
    
    <!--6.输入id和姓名，查询用户-->
    <select id="findUserByIdAndName" resultType="User">
        <!--select * from user where id=#{param1} and name=#{param2}-->
        select * from user where id=#{arg0} and name=#{arg1}
    </select>
</mapper>

如果此时sql语句还像单个字面量直接写标识符，编译就会报错

<!--6.输入id和姓名，查询用户-->
<select id="findUserByIdAndName" resultType="User">
    <!--select * from user where id=#{param1} and name=#{param2}-->
    <!--select * from user where id=#{arg0} and name=#{arg1}-->
    select * from user where id=#{id} and name=#{name}
</select>
// 6.输入id和姓名，查询用户
User user = userMapper.findUserByIdAndName(1, "萨达姆");
if (user != null) {
    System.out.println("查询成功");
    System.out.print(user);
} else {
    System.out.println("没有数据");

报错的关键简单总结就是，在执行MyBatis的数据库查询时，查询语句中引用了一个名为id的参数，但在对应的Mapper接口方法调用时并没有提供这个参数。MyBatis在处理SQL映射时未能找到与#{id}占位符相对应的参数值，因此抛出了org.apache.ibatis.binding.BindingException: Parameter 'id' not found的错误。这意味着在编写Mapper接口方法时，应当确保方法签名中包含所有在映射文件中使用的参数，同时在实际调用该方法时，也需要正确传递这些参数。

如何解决，此时就可以使用，也就是我注释上写的代码

默认键名：MyBatis会自动将这些参数放入一个Map集合中。每个参数以其在方法参数列表中的位置作为键名，即arg0, arg1, arg2, ...。或者param1, param2, param3, ...。

<!--6.输入id和姓名，查询用户-->
<select id="findUserByIdAndName" resultType="User">
    <!--select * from user where id=#{param1} and name=#{param2}-->
    <!--select * from user where id=#{arg0} and name=#{arg1}-->
</select>

还有有种方法是--自定义键名：如果在方法参数上使用@Param("paramName")注解，MyBatis会使用注解中指定的名称作为键。例如，@Param("userId") int id和@Param("userName") String name，则键分别为userId和userName。

这个到文章的后面再讲

4. map集合类型的参数

若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中 只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${ }需要手动加单引号

又举个代码例子

map集合方式输入id和姓名，查询用户

在 MyBatis 中，当一个 Mapper 接口方法需要接收多个参数时，可以使用 Map 集合作为参数类型，将各个参数以键值对的形式封装在 Map 中。这样，只需一个参数即可传递多个值，使得接口签名更为简洁。以下是具体的步骤和示例：

1. 定义 Mapper 接口方法

首先，在 UserMapper.java 中定义一个使用 Map 类型参数的方法，如：

public User findUserByIdAndName2(Map<String, Object> map);

此方法表示我们要根据 id 和 name 两个属性查询用户信息。

2. 编写 XML 映射文件

接着，在 UserMapper.xml 中编写对应的 SQL 查询语句，使用 #{} 占位符来引用 Map 中的键值：

<!-- 7.map集合方式输入id和姓名，查询用户 -->
<select id="findUserByIdAndName2" resultType="User">
    select * from user where id = #{id} and name = #{name}
</select>

这里，#{id} 和 #{name} 分别代表 Map 参数中键为 "id" 和 "name" 的值。MyBatis 会在执行时自动从传入的 Map 中取出对应的值，并将其作为预编译参数插入 SQL 查询中，保证安全性。

3. 准备参数与调用查询

最后，在应用程序中创建一个 HashMap 实例，填充所需的 id 和 name 值，然后调用 Mapper 方法执行查询：

// 7.map集合方式输入id和姓名，查询用户
Map<String, Object> map = new HashMap<>();
map.put("id", 1);
map.put("name", "萨达姆");

User userByIdAndName2 = userMapper.findUserByIdAndName2(map);

if (userByIdAndName2 != null) {
    System.out.println("查询成功");
    System.out.println(userByIdAndName2); // 修改为 println 输出整行
} else {
    System.out.println("没有数据");
}

这段代码首先创建了一个 HashMap 并放入 "id" 和 "name" 的键值对。然后，调用 userMapper.findUserByIdAndName2(map) 执行查询。根据查询结果，判断是否找到了匹配的用户，并打印相应的信息。

总结

通过上述步骤，我们展示了如何使用 Map 类型参数在 MyBatis 中实现多参数查询。关键要点如下：

  • 使用 Map 集合封装多个查询参数，简化接口定义。
  • 在 Mapper 接口中声明接受 Map 参数的方法。
  • 在 XML 映射文件中，使用 #{mapKey} 格式引用 Map 中的键值，确保 SQL 安全性。
  • 在应用中创建 Map 实例，填充参数，调用 Mapper 方法执行查询，并处理查询结果。

这种做法尤其适用于参数数量不确定或变动频繁的场景，有助于保持代码的灵活性和可维护性。初学者在实际编程中可以借鉴此模式，根据需求适配自己的查询逻辑。

5. 实体类类型的参数

若mapper接口中的方法参数为实体类对象时 此时可以使用${}和#{}，通过访问实体类对象中的属性名获取属性值，注意${}需要手动加单引号

在 MyBatis 中，当一个 Mapper 接口方法的参数为实体类对象时，可以直接使用实体类属性作为 SQL 语句中的占位符值。这种方式简化了参数传递，无需手动构建 Map 或其他数据结构。

以User实体类作为参数，添加用户

1. 定义 Mapper 接口方法

首先，在 UserMapper.java 中定义一个使用 User 实体类作为参数的方法，如：

public int addUser2(User user);

此方法表示我们要根据 User 实例的属性值来添加一个新的用户记录到数据库。

2. 编写 XML 映射文件

接着，在 UserMapper.xml 中编写对应的 SQL 插入语句，使用 #{属性名} 占位符来引用实体类对象的属性：

<!-- 8.以User实体类作为参数，添加用户 -->
<insert id="addUser2">
    insert into user values(0, #{name}, #{age}, #{sex})
</insert>

这里，#{name}, #{age}, 和 #{sex} 分别代表 User 对象的 name, age, 和 sex 属性值。MyBatis 会在执行时自动从传入的 User 实例中取出对应的属性值，并将其作为预编译参数插入 SQL 插入语句中，保证安全性。

3. 准备参数与调用添加方法

最后，在应用程序中创建一个 User 实例，填充所需的属性值，然后调用 Mapper 方法执行添加操作：

// 8.以User实体类作为参数，添加用户
User user = new User(0, "小明", 18, "男");

int i = userMapper.addUser2(user);

if (i > 0) {
    System.out.println("添加成功");
} else {
    System.out.println("添加失败");
}

这段代码首先创建了一个 User 对象，并设置了 name, age, 和 sex 属性。然后，调用 userMapper.addUser2(user) 执行添加操作。根据返回的受影响行数判断添加是否成功，并打印相应的信息。

总结

通过上述步骤，我们展示了如何使用实体类类型参数在 MyBatis 中实现用户添加操作。关键要点如下：

  • 直接使用实体类对象作为 Mapper 方法的参数，简化参数传递。
  • 在 Mapper 接口中声明接受实体类对象的方法。
  • 在 XML 映射文件中，使用 #{属性名} 格式引用实体类对象的属性，确保 SQL 安全性。
  • 在应用中创建实体类实例，填充属性值，调用 Mapper 方法执行添加操作，并根据返回结果判断操作是否成功。

这种做法适用于参数与实体类属性紧密关联的场景，能够简化代码结构，提高代码的可读性和一致性。初学者在设计数据操作接口时，可以优先考虑使用实体类作为参数，以充分利用 MyBatis 对实体类属性的自动映射功能。

6. 使用@Param标识参数

可以通过@Param注解标识mapper接口中的方法参数 此时，会将这些参数放在map集合中，以@Param注解的value属性值为键，以参数为值；以 param1,param2...为键，以参数为值；只需要通过${}和#{}访问map集合的键就可以获取相对应的值， 注意${}需要手动加单引号

在 MyBatis 中，@Param 注解可以用于为 Mapper 接口方法的参数提供别名，特别是在方法包含多个参数时，有助于清晰地标识每个参数的作用，并在 XML 映射文件中通过别名引用它们。以下是如何使用 @Param 注解查询用户的步骤和示例：

使用@Param输入id和姓名，查询用户

1. 定义 Mapper 接口方法

首先，在 UserMapper.java 中定义一个带有 @Param 注解的方法，为 id 和 name 参数赋予别名：

// 9.使用@Param输入id和姓名，查询用户
public User findUserByIdAndName3(@Param("id") int id, @Param("name") String name);

这里，@Param("id") 和 @Param("name") 分别为 int id 和 String name 参数指定了别名 "id" 和 "name"。这些别名将在 XML 映射文件中作为占位符的键来使用。

2. 编写 XML 映射文件

接着，在 UserMapper.xml 中编写对应的 SQL 查询语句，使用 #{别名} 占位符来引用带有 @Param 注解的参数：

<!--9.使用@Param输入id和姓名，查询用户-->
<select id="findUserByIdAndName3" resultType="User">
    select * from user where id = #{id} and name = #{name}
</select>

这里，#{id} 和 #{name} 分别代表方法参数中被 @Param 注解标记为 "id" 和 "name" 的值。MyBatis 会在执行时自动从方法参数中取出对应的值，并将其作为预编译参数插入 SQL 查询中，保证安全性。

不写id和name的话，也可以以 param1,param2...为键，以参数为值；

3. 调用查询方法

最后，在应用程序中直接调用 Mapper 方法，传入 id 和 name 参数值：

// 9.使用@Param输入id和姓名，查询用户
User userByIdAndName3 = userMapper.findUserByIdAndName3(1, "萨达姆");

if (userByIdAndName3 != null) {
    System.out.println("查询成功");
    System.out.println(userByIdAndName3); // 修改为 println 输出整行
} else {
    System.out.println("没有数据");
}

这段代码直接调用 userMapper.findUserByIdAndName3(1, "萨达姆")，传入 id 和 name 的具体值。根据查询结果，判断是否找到了匹配的用户，并打印相应的信息。

总结

通过上述步骤，我们展示了如何使用 @Param 注解在 MyBatis 中实现多参数查询。关键要点如下：

  • 使用 @Param 注解为 Mapper 接口方法的参数指定别名，增加代码可读性。
  • 在 Mapper 接口中声明带有 @Param 注解的方法。
  • 在 XML 映射文件中，使用 #{别名} 格式引用 @Param 注解标记的参数，确保 SQL 安全性。
  • 在应用中直接调用 Mapper 方法，传入相应参数值，并处理查询结果。

这种做法特别适用于方法参数较多且需要清晰标识其用途的场景，增强了代码的可理解性和维护性。初学者在编写多参数的 MyBatis 查询方法时，应优先考虑使用 @Param 注解来提升代码质量。注意，这里并不涉及将参数放入 Map 集合中，而是直接使用注解提供的别名与方法参数关联。

雨空集
关注
  • 48
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【内附完整redis配置文件】linux服务器命令设置redis最大限制内存大小，设置redis内存回收机制，redis有哪些回收机制
G佳伟
04-23 484
redis经常出现进程自己挂掉，经排查后是因为redis占用内存过大，导致服务器内存爆满进程自己挂掉。
Mybatis-获取值的两种方式
Philosophy7的博客
04-09 1764
Mybatis一、增删改查操作二、获取参数值的两种方式(重点掌握)三、小结 一、增删改查操作 1、添加 public interface UserMapper { public int insertUser(User user); //添加 } <insert id="insertUser" parameterType="user"> insert into user(id,name,gender) values(#{id},#{name},#{gender}) </inse
MyBatis - 06 - MyBatis获取参数值的两种方式（重要）
qq_39413850的博客
02-26 429
1、回顾JDBC原生的获取参数值的方式 2、MyBatis获取参数值的两种方式 3、MyBatis获取参数值的五种情况 4、@Param源码分析
MyBatis-获取参数值的多种方法
FYJZLN12138的博客
04-20 1549
三、MyBatis获取参数值的多种方法(重点) MyBatis获取参数值的两种方式：${}和#{} ${}的本质就是字符串拼接，#{}的本质就是占位符赋值 ${}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号；但是#{}使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号 能用#{}就不用$[}，因为${}会引起sql注入 1、前期准备 1）新建模块，然后导入依赖，并配置log4j日志文件： 导入依赖：
MyBatis--获取参数值
藜笙的博客
11-21 774
若mapper接口方法的参数为map集合类型的参数,只需要通过#{}和${}访问map集合的键,就可以获取相对应的值,一定要注意${}的单引号问题。若mapper接口方法的参数为单个的字面量类型,此时可以通过#{}和${}以任意的内容获取参数值,一定要注意${}的单引号问题。1.若mapper接口方法的参数为单个的字面量类型,此时可以通过#{}和${}以任意的内容获取参数值,一定要注意${}的单引号问题。${}的本质是字符串 ，#{}的本质是占位符赋值。使用${ } ,需要用单引号括起来。
MyBatis-Plus入门+MyBatis-Plus文档手册 中文pdf高清版.rar
11-09
mybatis在持久层框架中还是比较火的，一般项目都是基于ssm。虽然mybatis可以直接在xml中...《MyBatis-Plus入门文档》主要介绍了MyBatis-Plus入门使用，以及关于mybatis-plus的更多介绍及特性，感兴趣的可以下载学习一下
MyBatis-Plus 的官方示例(mybatis-plus-samples-master.zip)
05-05
本工程为 MyBatis-Plus 的官方示例，项目结构如下： mybatis-plus-sample-quickstart: 快速开始示例 mybatis-plus-sample-quickstart-springmvc: 快速开始示例（Spring MVC版本） mybatis-plus-sample-reduce-...
mybatis-plus3.5.2 jar包
06-25
mybatis-plus3.5.2常用jar包，mybatis-plus-3.5.2.jar、mybatis-plus-annotation-3.5.2.jar、mybatis-plus-core-3.5.2.jar、mybatis-plus-extension-3.5.2.jar、mybatis-plus-generator-3.5.2.jar和源码包mybatis-...
mybatis-plus源码（mybatis-plus-3.5.1.zip）
03-03
mybatis-plus源码（mybatis-plus-3.5.1.zip）
mybatis-plus-generator-ui:对mybatis-plus-generator进行封装，通过Web UI快速生成兼容的Spring boot，mybatis-plus框架的各类业务代码
03-20
提供一致的Web UI用于生成兼容mybatis-plus框架的相关功能代码，包括Entity，Mapper，Mapper.xml，Service，Controller等，可以自定义模板以及各种输出参数，也可以通过SQL查询语句直接生成代码。 使用方法 ♡maven...
【kettle001】访问国产达梦数据库并处理数据至execl文件
kngines
04-22 426
一直以来想写下基于kettle的系列文章，作为较火的数据ETL工具，也是日常项目开发中常用的一款工具，最近刚好挤时间梳理、总结下这块儿的知识体系。熟悉、梳理、总结下达梦（DM）关系型数据库相关知识体系。
探秘MySQL主从复制的多种实现方式
todoitbo的博客
04-26 658
本文将深入探讨MySQL主从复制的多种实现方式，包括基于语句、基于行和混合模式等。无论您是初学者还是有经验的数据库管理员，都能通过本文全面了解MySQL主从复制技术的多样化选择，从而提高数据库的可用性和性能。
redis分布式锁到底怎么用
LinggoLing的博客
04-22 445
分布式锁到底怎么用
mysql-connector-java和spring-boot-starter-jdbc和mybatis-spring-boot-start
xzy的博客
04-23 958
JDBC是使用java语言操作mysql数据库的规范，java语言必须按照这个规范写才可以操作mysql数据库。
SpringCloudAlibaba：2.1nacos
最新发布
m0_63040701的博客
04-26 696
Nacos是阿里巴巴开源的服务注册中心以及配置中心Nacos=注册中心Eureka + 服务配置Config + 服务总线Bus。
SpringBoot JPA使用
gochenguowei的博客
04-25 711
是 Spring 框架提供的一个模块，用于简化与关系型数据库的交互和数据访问。它基于JPA（Java Persistence API）标准，并提供了一组易于使用的API和工具，帮助开发人员更轻松地进行数据库操作。通过Spring Data JPA，开发人员可以通过编写简洁的代码来执行常见的 CRUD 操作，同时还支持高级查询、分页、事务管理等功能。它的目标是提供一种更简单、更高效的方式来处理数据库操作，减少开发人员的工作量，并提高应用程序的可维护性和可扩展性。
redis的订阅与发布功能
qq_19891197的博客
04-20 635
redis的订阅与发布功能
MYSQL学习——存储引擎
star_and_sun的博客
04-24 223
mysql 引擎特点
怎么实现 MyBatis-Plus 的 Mapper 对象创建和获取
06-08
创建和获取 MyBatis-Plus 的 Mapper 对象，可以通过以下两种方式进行： 1. 使用 Spring Boot 自动装配 如果您的项目使用了 Spring Boot，可以直接使用 Spring Boot 提供的自动装配机制来创建和获取 MyBatis-Plus 的 Mapper 对象。具体来说，您需要完成以下两个步骤： 1. 在 `application.properties` 或 `application.yml` 中配置 MyBatis-Plus 的相关参数，包括数据源配置、Mapper 扫描路径等。例如： ```yaml # 数据源配置 spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase spring.datasource.username=root spring.datasource.password=123456 # MyBatis-Plus 配置 mybatis-plus.mapper-locations=classpath:mapper/**/*.xml mybatis-plus.type-aliases-package=com.example.entity ``` 2. 在需要使用 Mapper 对象的地方，通过 `@Autowired` 注解注入对应的 Mapper 对象即可。例如： ```java @RestController public class MyController { @Autowired private MyMapper myMapper; @GetMapping("/getVariable") public String getVariable() { return myMapper.getVariable(); } } ``` 在上述代码中，我们使用 `@Autowired` 注解将 `MyMapper` 对象注入到了 `MyController` 控制器中，并在 `getVariable` 方法中使用该对象查询数据库并返回结果。 2. 手动创建 Mapper 对象 如果您的项目没有使用 Spring Boot，或者需要手动创建 Mapper 对象，可以通过以下步骤进行： 1. 在 `pom.xml` 中引入 MyBatis-Plus 的依赖： ```xml <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>${mybatis-plus.version}</version> </dependency> ``` 2. 在需要使用 Mapper 对象的地方，通过 `SqlSessionFactory` 和 `MapperRegistry` 对象手动创建 Mapper 对象。例如： ```java public class MyBatisPlusUtils { // 获取 SqlSessionFactory 对象 private static SqlSessionFactory getSqlSessionFactory() { // 创建数据源对象 DataSource dataSource = new PooledDataSource( "com.mysql.jdbc.Driver", "jdbc:mysql://localhost:3306/mydatabase", "root", "123456" ); // 创建 MyBatis 配置对象 MybatisConfiguration configuration = new MybatisConfiguration(); configuration.setMapUnderscoreToCamelCase(true); // 创建 SqlSessionFactory 对象 SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder() .build(configuration, dataSource); return sessionFactory; } // 获取 Mapper 对象 public static <T> T getMapper(Class<T> mapperClass) { // 创建 SqlSessionFactory 对象 SqlSessionFactory sessionFactory = getSqlSessionFactory(); // 创建 MapperRegistry 对象 MapperRegistry mapperRegistry = new MapperRegistry(sessionFactory.getConfiguration()); // 注册 Mapper 对象 mapperRegistry.addMapper(mapperClass); // 获取 Mapper 对象 return sessionFactory.openSession().getMapper(mapperClass); } } ``` 在上述代码中，我们定义了一个 `getSqlSessionFactory` 方法，用于创建 `SqlSessionFactory` 对象；并定义了一个 `getMapper` 方法，用于手动创建 Mapper 对象。在 `getMapper` 方法中，我们首先通过 `getSqlSessionFactory` 方法获取到了 `SqlSessionFactory` 对象，然后创建了一个 `MapperRegistry` 对象，并将需要创建的 Mapper 对象注册到了该对象中；最后通过 `SqlSessionFactory` 对象的 `openSession` 方法获取到了一个 `SqlSession` 对象，并调用该对象的 `getMapper` 方法获取到了需要的 Mapper 对象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雨空集

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值