MyBatis学习笔记

已于 2022-06-26 19:31:01 修改
阅读量234 收藏
点赞数
分类专栏： MyBatis 文章标签： mybatis
于 2022-06-25 14:08:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44768683/article/details/125458129
版权

MyBatis学习笔记–持续上传更新

文章目录

前言

本次学习笔记基于尚硅谷在B站推出的MyBatis课程进行学习记录，在此感谢尚硅谷官方“让天下没有难学的技术”。感谢！

  • 视频学习地址：https://www.bilibili.com/video/BV1VP4y1c7j7
  • 学习思维导图：在这里插入图片描述

一、Mybatis简介

1、MyBatis历史

MyBatis最初是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation迁移到了Google Code。随着开发团队转投Google Code旗下，iBatis3.x正式更名为MyBatis。代码于2013年11月迁移到Github。

iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）。

  • SQL Maps：SQL Map提供了一个简洁的框架，使用简单的XML描述文件将Java Bean，Map实现和基本数据类型的包装类（String，Integer等）映射成JDBC的PreparedStatement。
  • Data Access Objects（DAO，数据访问对象）：DAO对象包括数据引擎功能，通过数据引擎功能，它可以访问结构化查询语言(SQL)数据库。

2、MyBatis特性

  1. MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架
  2. MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
  3. MyBatis 可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录
  4. MyBatis 是一个 半自动的ORM（Object Relation Mapping）框架

3、MyBatis下载

  • MyBatis下载地址：https://github.com/mybatis/mybatis-3
  • MyBatis中文文档：https://mybatis.org/mybatis-3/zh/index.html

4、MyBatis和其它持久化层技术对比

  • JDBC
    • SQL 夹杂在Java代码中耦合度高，导致硬编码内伤
    • 维护不易且实际开发需求中 SQL 有变化，频繁修改的情况多见
    • 代码冗长，开发效率低
  • Hibernate 和 JPA
    • 操作简便，开发效率高
    • 程序中的长难复杂 SQL 需要绕过框架
    • 内部自动生产的 SQL，不容易做特殊优化
    • 基于全映射的全自动框架，大量字段的 POJO 进行部分映射时比较困难。
    • 反射操作太多，导致数据库性能下降
  • MyBatis
    • 轻量级，性能出色
    • SQL 和 Java 编码分开，功能边界清晰。Java代码专注业务、SQL语句专注数据
    • 开发效率稍逊于HIbernate，但是完全能够接受

二、MyBatis框架搭建及实现CRUD

开发环境

  • IDE：idea 2020.3
  • 构建工具：maven 3.6.3
  • MySQL版本：MySQL 5.7
  • MyBatis版本：MyBatis 3.5.7

创建maven工程

来吧，展示！
在这里插入图片描述

1. 引入依赖

1.定义打包方式：jar。
2.引入对应依赖：Mybatis核心，junit测试，MySQL驱动，log4j日志。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.atguigu.mybatis</groupId>
    <artifactId>MyBatis_demo1</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--打包方式为jar-->
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- Mybatis核心 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>

        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.3</version>
        </dependency>

        <!-- log4j日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>

</project>

2. 创建核心配置文件

核心配置文件：

  • 主要用于配置连接数据库的环境以及MyBatis的全局配置信息
  • 核心配置文件存放的位置是src/main/resources目录下

(习惯上命名为mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。)

<?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.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/数据库名"/>
                <property name="username" value="root"/>
                <property name="password" value="密码"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->
    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

3. 创建表及实体类

3.1 创建数据库&表

1）创建数据库：mybatis
2）创建数据表：t_user
在这里插入图片描述

3.2 创建实体类

根据表字段从而创建相应属性，并通过idea快捷键Alt+Insert快速生成无参/有参构造方法、get/set方法、toString方法等。

package com.min.mybatis.pojo;

/**
 * 用户类
 */
public class User {
    private Integer id;

    private String username;

    private String password;

    private Integer age;

    private String sex;

    private String email;

    public User(Integer id, String username, String password, Integer age, String sex, String email) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
        this.sex = sex;
        this.email = email;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

4. 导入日志文件

  • log4j的配置文件名为log4j.xml，存放的位置是src/main/resources目录下
  • 日志的级别：FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)，从左到右打印的内容越来越详细
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"><!--报红没关系-->
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

5. 编写mapper接口

MyBatis中的mapper接口相当于以前的dao。但是区别在于，mapper仅仅是接口，我们不需要提供实现类。

package com.min.mybatis.mapper;

import com.min.mybatis.pojo.User;

import java.util.List;

/**
 * 用户mapper接口
 */
public interface UserMapper {

    /**
     * MyBatis面向接口编程要保证两个一致：
     *
     * 1. mapper接口的全类名  和  映射文件的命名空间（namespace）保持一致
     * 2. mapper接口中方法的方法名  和  映射文件中编写SQL的标签的id属性保持一致
     *
     * 表--实体类--mapper接口--映射文件
     */

    //说明:增删改都是返回数量，可以用int接收，不需查看返回值用void

    /**
     * 添加用户信息
     */
    int insertUser();

    /**
     * 修改用户信息
     */
    void updateUser();

    /**
     * 删除用户信息
     */
    void deleteUser();

    /**
     * 根据id查询用户信息
     */
    User getUserById();

    /**
     * 查询所有的用户信息
     */
    List<User> getAllUser();
}

6. 编写映射文件

MyBatis中可以面向接口操作数据，要保证两个一致：

  • mapper接口的全类名和映射文件的命名空间（namespace）保持一致
  • mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致
<?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.min.mybatis.mapper.UserMapper">

    <!--int insertUser();-->
    <insert id="insertUser">
        insert into t_user
        values (null, 'admin', '123456', 23, '男', '12345@qq.com')
	</insert>

    <!--void updateUser();-->
    <update id="updateUser">
        update t_user set username = '张三' where id = 2
    </update>

    <!--void deleteUser();-->
    <delete id="deleteUser">
        delete from t_user where id = 3
    </delete>

    <!--User getUserById();-->
    <!--
        查询功能的标签必须设置resultType或resultMap
        resultType：设置默认的映射关系
        resultMap：设置自定义的映射关系
    -->
    <select id="getUserById" resultType="com.min.mybatis.pojo.User">
        select * from t_user where id = 1
    </select>

    <!--List<User> getAllUser();-->
    <select id="getAllUser" resultType="com.min.mybatis.pojo.User">
        select * from t_user
    </select>

</mapper>

7. 编写测试类

注意：SqlSession默认不自动提交事务，若需要自动提交事务，则在获取sqlSession对象时，使用SqlSession sqlSession = sqlSessionFactory.openSession(true);，传入一个Boolean类型的参数，值为true，这样就可以自动提交。

package com.min.mybatis.test;

import com.min.mybatis.mapper.UserMapper;
import com.min.mybatis.pojo.User;
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.Test;

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

public class UserMapperTest {

    @Test
    public void testInsertUser() throws IOException {

        //1、加载核心配置文件
        /**注意事项：
         * 1)Resources是org.apache.ibatis.io包下的
         * 2)getResourceAsStream是以字符流方式获取核心配置文件信息的
         */
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");

        //2、获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

        //3、获取SqlSessionFactory
        /**
         * 通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象
         */
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);

        //4、获取sqlSession对象
        /**(1)此时通过SqlSession对象所操作的sql都必须手动提交或回滚事务*/
        //SqlSession sqlSession = sqlSessionFactory.openSession();
        /**(2)此时通过SqlSession对象所操作的sql都会自动提交*/
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //5、获取mapper接口对象
        /**
         * 底层通过【代理模式】创建UserMapper接口的代理实现类对象
         */
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //6、测试功能
        /**
         * 调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，
         * 通过调用的方法名匹配映射文件中的SQL标签，并执行标签中的SQL语句
         */
        int result = userMapper.insertUser();
        /**
         * 手动提交事务
         * 当在第4步获取sqlSession对象时，设置sqlSessionFactory.openSession(true);就是自动提交事务
         */
        //sqlSession.commit();
        System.out.println("result:" + result);

    }


    @Test
    public void testUpdateUser() throws IOException {
        //1、加载核心配置文件
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        //2、获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //3、获取SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //4、获取sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //5、获取mapper接口对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //6、测试功能
        userMapper.updateUser();
    }

    @Test
    public void testDeleteUser() throws IOException {
        //1、加载核心配置文件
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        //2、获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //3、获取SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //4、获取sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //5、获取mapper接口对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //6、测试功能
        userMapper.deleteUser();
    }


    @Test
    public void testGetUserById() throws IOException {
        //1、加载核心配置文件
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        //2、获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //3、获取SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //4、获取sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //5、获取mapper接口对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //6、测试功能
        User user = userMapper.getUserById();
        System.out.println(user);
    }

    @Test
    public void testGetAllUser() throws IOException {
        //1、加载核心配置文件
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        //2、获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //3、获取SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //4、获取sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //5、获取mapper接口对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //6、测试功能
        List<User> list = userMapper.getAllUser();
        list.forEach(user -> System.out.println(user));
    }
}

三、核心配置文件详解

1、核心配置文件标签

核心配置文件(mybatis-config.xml)中的标签必须按照固定的顺序：

properties、settings、typeAliases、typeHandlers、objectFactory、objectWrapperFactory、reflectorFactory、plugins、environments、databaseIdProvider、mappers

2、核心配置文件案例

<?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>
    <!--引入properties文件，此时就可以${属性名}的方式访问属性值-->
    <properties resource="jdbc.properties"></properties>
    
    <settings>
        <!--将表中字段的下划线自动转换为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>
    
    <typeAliases>
        <!--
        typeAlias：设置某个具体的类型的别名
        属性：
        	type：需要设置别名的类型的全类名
        	alias：设置此类型的别名，且别名不区分大小写。若不设置此属性，该类型拥有默认的别名，即类名
        -->
        <!--<typeAlias type="com.atguigu.mybatis.bean.User"></typeAlias>-->
        <!--<typeAlias type="com.atguigu.mybatis.bean.User" alias="user"></typeAlias>-->
        <!--以包为单位，将包下所有的类型设置默认的类型别名，即类名且不区分大小写-->
        <package name="com.atguigu.mybatis.bean"/>
    </typeAliases>
    
    <!--
    environments：设置多个连接数据库的环境
    属性：
	    default：设置默认使用的环境的id
    -->
    <environments default="mysql_test">
        <!--
        environment：设置具体的连接数据库的环境信息
        属性：
	        id：设置环境的唯一标识，可通过environments标签中的default设置某一个环境的id，表示默认使用的环境
        -->
        <environment id="mysql_test">
            <!--
            transactionManager：设置事务管理方式
            属性：
	            type：设置事务管理方式，type="JDBC|MANAGED"
	            type="JDBC"：设置当前环境的事务的提交或回滚的管理都必须手动处理
	            type="MANAGED"：设置事务被管理，例如spring中的AOP
            -->
            <transactionManager type="JDBC"/>
            <!--
            dataSource：设置数据源
            属性：
	            type：设置数据源的类型，type="POOLED|UNPOOLED|JNDI"
	            type="POOLED"：表示使用数据库连接池缓存数据库连接，即会将创建的连接进行缓存，下次使用可以从缓存中直接获取，不需要重新创建
	            type="UNPOOLED"：表示不使用数据库连接池，即每次使用连接都需要重新创建
	            type="JNDI"：表示调用上下文中的数据源
            -->
            <dataSource type="POOLED">
                <!--设置连接数据库的驱动，驱动类的全类名-->
                <property name="driver" value="${jdbc.driver}"/>
                <!--设置连接数据库的连接地址-->
                <property name="url" value="${jdbc.url}"/>
                <!--设置连接数据库的用户名-->
                <property name="username" value="${jdbc.username}"/>
                <!--设置连接数据库的密码-->
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    
    <!--引入映射文件-->
    <mappers>
        <!-- <mapper resource="UserMapper.xml"/> -->
        <!--
        以包为单位，将包下所有的映射文件引入核心配置文件
        注意：
			1. 此方式必须保证mapper接口和mapper映射文件必须在相同的包下
			2. mapper接口要和mapper映射文件的名字一致
        -->
        <package name="com.atguigu.mybatis.mapper"/>
    </mappers>
</configuration>

四、MyBatis获取参数值的两种方式（重点）

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

  • ${}的本质就是：字符串拼接
  • ${}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号
  • #{}的本质就是：占位符赋值
  • #{}使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号

1、单个字面量类型的参数

若mapper接口中的方法参数为单个的字面量类型，此时可以使用${}和#{}以任意的名称（最好见名识意）获取参数的值，注意使用${}时需要手动加单引号。

1）使用#{}占位符赋值

<!--User getUserByUsername(String username);-->
<select id="getUserByUsername" resultType="User">
	select * from t_user where username = #{username}
</select>

2）使用${}字符串拼接

<!--User getUserByUsername(String username);-->
<select id="getUserByUsername" resultType="User">
	select * from t_user where username = '${username}'
</select>

2、多个字面量类型的参数

若mapper接口中的方法参数为多个时，此时MyBatis会自动将这些参数放在一个map集合中，有两种键值对情况：

  1. 以arg0，arg1… …为键，以参数为值
  2. 以param1，param2… …为键，以参数为值
  • 因此只需要通过${}或#{}访问map集合提供的键就可以获取相对应的值（注意${}需要手动加单引号）
  • 其中map提供的键，使用arg或者param都行，要注意的是：arg是从arg0开始的，param是从param1开始的
<!--User checkLogin(String username,String password);-->
<select id="checkLogin" resultType="User">  
	select * from t_user where username = #{param1} and password = #{param2}  
</select>

select * from t_user where username = #{arg0} and password = #{arg1}  
select * from t_user where username = '${param1}' and password = '${param2}'

3、map集合类型的参数

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

<!--User checkLoginByMap(Map<String,Object> map);-->
<select id="checkLoginByMap" resultType="User">
	select * from t_user where username = #{username} and password = #{password}
</select>

@Test
public void checkLoginByMap() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    //手动创建map集合
	Map<String,Object> map = new HashMap<>();
	map.put("usermane","admin");
	map.put("password","123456");
	User user = mapper.checkLoginByMap(map);
	System.out.println(user);
}

4、实体类类型的参数

若mapper接口中的方法参数为实体类对象时，此时可以使用${}和#{}（注意${}需要手动加单引号），通过访问实体类对象中的属性名获取属性值，其实是因为实体类中成员变量的get/set方法就可以用这样的方式以属性名参数获取值。

<!--int insertUser(User user);-->
<insert id="insertUser">
	insert into t_user values(null,#{username},#{password},#{age},#{sex},#{email})
</insert>

@Test
public void insertUser() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
	User user = new User(null,"Tom","123456",12,"男","123@321.com");
	mapper.insertUser(user);
}

5、使用@Param标识参数

@param注解源码解析:https://www.bilibili.com/video/BV1VP4y1c7j7?p=29

可以通过@Param注解标识mapper接口中的方法参数，此时，会将这些参数放在map集合中：

  1. 以@Param注解的value属性值为键，以参数为值
  2. 以param1，param2… …为键，以参数为值
  • 只需要通过${}和#{}访问map集合的键就可以获取相对应的值（注意${}需要手动加单引号）
//验证登录(使用@Param)
User checkLoginByParam(@Param("username") String username,@Param("password") String password)

<!--User CheckLoginByParam(@Param("username") String username, @Param("password") String password);-->
<select id="CheckLoginByParam" resultType="User">
    select * from t_user where username = #{username} and password = #{password}
</select>

@Test
public void checkLoginByParam() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
	mapper.CheckLoginByParam("admin","123456");
}

6、总结

建议分成两种情况进行处理

  1. 实体类类型的参数
  2. 使用@Param标识参数
LouisMin23
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CMake GUI 使用指南
KgCrystal的博客
10-06 2300
生成构建文件后，你可以使用所选的构建系统来构建项目。在 Configure 过程中，CMake 会解析源码目录中的 CMakeLists.txt 文件，并根据文件中的配置选项生成相应的 GUI 控件。CMake 会根据你的配置选项，在构建目录中生成适合你选择的构建系统的构建文件。通过 CMake GUI，你可以更方便地进行项目配置和生成构建文件，从而简化了项目的构建过程。点击 “Generate”，CMake 会在 project/build 目录中生成适合你选择的构建系统的构建文件。
免编译cmake-gui
10-29
cmake-gui，针对编译opencv找不到with_v4l非常有效。
cmake gui安装教程_cmake安装与使用
weixin_39784195的博客
02-01 3553
CMake(cross platform make)是一个开源的跨平台工具系列，旨在构建，测试和打包软件。使用指定名为CMakeLists.txt的配置文件可以控制软件的构建、测试和打包等流程。通过编写平台无关的CMakeLists.txt文件和需要简单的配置，CMake就能生成对应目标平台的构建文件1.安装(1)Linux所有主流的Linux发行版的源中都包含有cmake的安装包，直接从源中添加...
linux下使用cmake-gui编译WXQT
最新发布
sspdfn的专栏
05-27 411
在ubunt下使用CMake-gui配置WXQT的工程。
Ubuntu18.04中用CMake-gui安装OpenCV4.1.0
嵌入式与人工智能
06-26 981
cmake-gui OpenCV
一文搞定CMake的使用
weixin_63260810的博客
05-13 1370
cmake使用教程
Linux C++项目 CMake-GUI 编译OpenCV和Multi-tracker
hello world
03-01 5669
一、cmake opencv编译 参考：Linux 使用cmake构建OpenCV项目_sandalphon4869的博客-CSDN博客 参考：Linux 下编译安装OpenCV,Cmake的安装_wzy的博客-CSDN博客 1.1 opencv编译 安装cmake：sudo apt-get install cmake 注意这个不是gui的版本 测试cmake是否安装成功：cmake --version cmake version 2.8.10.2 安装cmake-gui：sudo apt..
利用Cmake-gui编译opencv4.5.1+opencv_contrib+gpu模块
qq_42221707的博客
12-04 1209
opencv4.5.1可以用SURF/SIFT等，主要也是为了使用gpu模块进行加速。
windows中的CMake如何使用
web修理工
10-13 839
CMake是一个比make更高级的编译配置工具，它可以根据不同平台、不同的编译器，生成相应的Makefile或者vcproj项目。 通过编写CMakeLists.txt，可以控制生成的Makefile，从而控制编译过程。CMake自动生成的Makefile不仅可以通过make命令构建项目生成目标文件，还支持安装（make install）、测试安装的程序是否能正确执行（make test，或者ctest）、生成当前平台的安装包（make package）、生成源码包（make package_source）
海思3559环境采用cmake-gui交叉编译opencv及opencv_contrib
qq_40778196的博客
05-10 906
ubuntu16.04海思3559环境，采用cmake-gui交叉编译opencv及opencv_contrib过程以及出现的问题解决。
CMake 用户交互指南
Duran.L的专栏
06-11 394
通过CMake系列博文中的第一篇CMake快速入门，相信大家对于CMake已经有了一个感性的认识。本文在此基础上，主要介绍如何使用cmake交互程序完成构建任务。文章的内容主要翻译自，重点关注了针对Windows和Linux平台的内容，并增加了一些必要的解释。
cmake-gui配置 交叉编译opencv
qq_48739372的博客
11-28 1073
Target System →Operating System 填写Linux （L大写，填入其他如：linux-arm，后面configure会出现错误）；Compliers → C and Complier → C++填入对应交叉编译工具链gcc和g++路径；然后在CMAKE_INSTALL_PREFIX中质量的目录下就会生成编译处的库文件。圆圈处填上opencv源码路径，矩形处填刚刚创建的build路径。在点击config完成配置，如下。点击finish完成配置。点击configure。
IDE/以glog为例实践CMake-Gui工具使用
river.qu
06-16 2325
本文描述如何使用cmake-gui工具构建glog开源项目，附带其编译、安装、打包过程；介绍了glog构建配置项的含义，glog解决方案组成项目等，并对其中涉及的调试追踪和测试技术做了概要描述。
CMakeLists.txt基础指令与cmake-gui生成VS项目的步骤
手写不期而遇的博客
11-17 1973
本博客主要介绍cmake的基本指令，同时，很多使用Visual Studio小白从Gitbub下载项目源码后，看到CMakeLists.txt，不知道如何使用Visual Studio编译源码；针对以上问题，做一下简单操作与解释，方便小白入门，大佬就没必要继续看啦…
CMake-gui使用简介，以及CMakeList指令简单说明
热门推荐
weixin_43277501的博客
02-24 1万+
简述 参考了这篇博客：ht...
Windows使用cmake编译libcurl以及VS的一些使用
u012477435的博客
05-29 3593
文章目录一、windows有关Visual studio的一些使用1.1 Visual studio搜索库文件的顺序1.1.1 DLL的搜索顺序1.1.2 头文件的查找顺序1.1.3 lib搜索的顺序1.2 静态库与动态库1.2.1 关键点1.2.2 在visual studio的引用1.2 VS删除某个库二、libcurl的编译2.1 cmake-gui的安装2.2 libssh22.3 openssl2.4 libcurl三、opencv的编译四、ncnn的编译五、rdkafka的编译 一、window
cmake安装与使用
nanke_yh的博客
10-03 1192
下载地址：https://cmake.org/download/ 需要根据个人机器型号对应下载版本即可。
Ubuntu安装GStreamer并添加对OpenCV的支持
qq_42731705的博客
03-28 5153
ubuntu16.04 上安装 gstreamer https://gstreamer.freedesktop.org/documentation/installing/on-linux.html?gi-language=c OpenCV添加Gstreamer支持 ubuntu下安装多版本的opencv并且切换使用
ssh使用密钥实现免密登录
zhangxiaoyang0的专栏
10-19 403
环境 Mac+Cent OS 7 生成密钥对ssh-keygen -t rsa -C "xxx"，默认文件名称是id_rsa和id_rsa.pub，如果不需要修改密钥文件名称，一路回车直到密钥对生成完成；如果想自己指定，需要在第一次交互中输入自己指定的文件名称。 在~/.ssh目录下添加authorized_keys 文件，并将上一步生成的公钥写入该文件cat ~/.ssh/id_rsa.pub > authorized_keys。 ssh-copy-id -i ~/.ssh/id_rsa.pub
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值