第一章Mybatis基础操作学习

库里不会投三分

已于 2023-01-11 02:50:28 修改

阅读量375

点赞数 1

分类专栏： SSM框架文章标签： mybatis 学习 java

于 2023-01-11 02:49:26 首次发布

本文链接：https://blog.csdn.net/qq_50985215/article/details/128638609

版权

SSM框架专栏收录该内容

10 篇文章 1 订阅

订阅专栏

MyBatis简介

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）。

MyBatis特性

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

MyBatis 是支持定制化 SQL，动态sql、存储过程以及高级映射的优秀的持久层框架
- 定制化SQL,比如在Hibernates中sql是框架自动生成，在mybatis中sql需要我们自己写
- 高级映射，比如当我们的属性名和字段名不一致，或者出现多对一的映射关系，mybatis有对应的解决方案
- 动态sql就是（在进行sql操作的时候）动态的根据属性值（所匹配的条件）来拼接数据库执行的sql语句，也就是多次查询或变更操作，根据传入的属性值不同，动态拼接出不同的可执行sql。包含判断为空、循环等；
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
- 它内部封装了JDBC，开发的时候只需要去关注我们的sql语句本身，需要化精力去加载驱动，创建连接，创建statement ，关闭资源等复杂的过程
MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old JavaObjects，普通的Java对象）映射成数据库中的记录
MyBatis 是一个半自动的ORM（Object Relation Mapping 对象关系映射）框架
- 对象关系映射，在面对对象编程语言中，将关系数据库中的数与对象建立起映射关系，进而自动的完成数据对应
  - 类——>数据表
  - 对象——>一行数据（记录）
  - 属性——>字段
- JDBC是纯手动（比如获取连接等什么操作和sql都是需要自己完成），Mybatis是半自动，我们只需要关注sql的编写，Hibernate是全自动（连sql都不要自己写）

通过XML或者注解的方式将要执行的各种statement配置起来，并通过java对象和statement的sql的动态参数进行映射生成最终执行的sql语句，最后mybatis框架执行sql并将结果映射为Java对象返回

和其它持久化层技术对比

JDBC

SQL 夹杂在Java代码中耦合度高，导致硬编码内伤
维护不易且实际开发需求中 SQL 有变化，频繁修改的情况多见
- 我们的sql语句写在Java代码中，我们的代码会打成jar包，所以如果要维护sql代码是非常麻烦的
代码冗长，开发效率低

创建数据库连接池 DataSource，或者加载驱动
通过 DataSource 获取数据库连接 Connection，或者通过DriverManager.getConnection
编写要执行带 ? 占位符的 SQL 语句
通过 Connection 及 SQL 创建操作命令对象 Statement或者PreparedStatement
替换占位符：指定要替换的数据库字段类型，占位符索引及要替换的值
使用 Statement 执行 SQL 语句 executeUpdate executeQuery
查询操作：返回结果集 ResultSet，更新操作：返回更新的数量
处理结果集
释放资源

Hibernate 和 JPA

操作简便，开发效率高
程序中的长难复杂 SQL 需要绕过框架
内部自动生产的 SQL，不容易做特殊优化
基于全映射的全自动框架，大量字段的 POJO 进行部分映射时比较困难。
反射操作太多，导致数据库性能下降

MyBatis

轻量级，性能出色
SQL 和 Java 编码分开（sql可以写在xml文件中），解除sql和程序代码的耦合，功能边界清晰。Java代码专注业务、SQL语句专注数据
开发效率稍逊于HIbernate，但是完全能够接受
能够很好的跟Spring进行集成

搭建MyBatis

开发环境

IDE：idea 2020.2
构建工具：maven 3.5.4
MySQL版本：MySQL 5.7
MyBatis版本：MyBatis 3.5.7

MySQL不同版本的注意事项
1、驱动类driver-class-name
MySQL 5版本使用jdbc5驱动，驱动类使用：com.mysql.jdbc.Driver
MySQL 8版本使用jdbc8驱动，驱动类使用：com.mysql.cj.jdbc.Driver
2、连接地址url
MySQL 5版本的url：
jdbc:mysql://localhost:3306/ssm
MySQL 8版本的url：
jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC

创建maven工程

工程视角和文件视角

.idea 工程文件，我们一般不管
src/main/java/放置源码的根目录
src/main/resources放置工程外部资源的地方（比如视频和音频)，和配置文件
src/test/java/test/放置测试代码（单元测试代码）
maven-demo2.iml idea的模块文件，一般不管
pom.xml maven自己的项目配置文件，会改动，很重要
target是构建完成产出的目录(编译好的类文件，构建好的包文件)，可以随时删除，因为每次运行都会生成

pom.xml

  <version>1.0-SNAPSHOT</version>
    <!--    打包方式-->
    <packaging>jar</packaging>
    <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.49</version>
        </dependency>
    </dependencies>

设置打包方式 jar
导入需要的依赖
- mybatis
- junit
- mysql驱动，我们的mysql版本的5.7

创建MyBatis的核心配置文件

<?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/ssm"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->
    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

设置连接需要的四大数据
- 驱动
- url
- 用户名
- 密码
引入映射文件

创建mapper接口

public interface UserMapper {
    int insertUser();
}

创建MyBatis的映射文件

<?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.lsc.mybatis.Mapper.UserMapper">
<!--    mapper接口和映射文件要保证两个一致-->
<!--    1mapper接口的全类名个映射文件的namespace一致-->
<!--    2mapper接口中的方法的方法名要和映射文件中的sql的id保证一致-->
        <insert id="insertUser">
            insert into t_user values(null,'lsc','245281',22,'男','lsc0702481@163.com')
        </insert>
</mapper>

mapper
- namespace——设置对应的mapper接口
- 设置对应操作的id，跟对应接口的方法对应起来
编写sql语句

相关概念：ORM（Object Relationship Mapping）对象关系映射。

对象：Java的实体类对象
关系：关系型数据库
映射：二者之间的对应关系

Java概念	数据库概念
类	表
属性	字段/列
对象	记录/行

映射文件的命名规则：

表所对应的实体类的类名+Mapper.xml
例如：表t_user，映射的实体类为User，所对应的映射文件为UserMapper.xml
因此一个映射文件对应一个实体类，对应一张表的操作
MyBatis映射文件用于编写SQL，访问以及操作表中的数据
MyBatis映射文件存放的位置是src/main/resources/mappers目录下

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

mapper接口的全类名和映射文件的命名空间（namespace）保持一致
mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致

通过junit测试功能

public class MybatisTest {
    @Test
    public void testInsert() throws IOException {
        //获取核心配置文件的输入流
        InputStream is = Resources.getResourceAsStream("mybatis_config.xml");
        //获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //获取SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //获取sql的会话对象SqlSession(不会自动提交事务)，是MyBatis提供的操作数据库的对象
        //SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取sql的会话对象SqlSession(会自动提交事务)，是MyBatis提供的操作数据库的对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //获取UserMapper的代理实现类对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        //调用mapper接口中的方法，实现添加用户信息的功能
        int result = mapper.insertUser();
        //提供sql以及的唯一标识找到sql并执行，唯一标识是namespace.sqlId
        /*int result = sqlSession.insert("com.atguigu.mybatis.mapper.UserMapper.insertUser");*/
        System.out.println("结果："+result);
  
        //关闭SqlSession
        sqlSession.close();

    }
}

在test/java下进行编写测试类

为什么接口没被实现就能被调用

因为底层使用的是代理模式

//提供sql以及的唯一标识找到sql并执行，唯一标识是namespace.sqlId
int result = sqlSession.insert("com.lsc.mybatis.mapper.UserMapper.insertUser");
//底层也是依靠sqlSession.insert和"com.lsc.mybatis.mapper.UserMapper.insertUser"全类名去重写了这个j

通过这种方式也能实现执行对应的sql语句

//获取UserMapper的代理实现类对象
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
//调用mapper接口中的方法，实现添加用户信息的功能
int result = mapper.insertUser();

加入log4j日志功能

在pom.xml中导入依赖

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

加入log4j的配置文件
log4j的配置文件名为log4j.xml，存放的位置是src/main/resources目录下

<?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>

不带参数的增删改查

Mapper接口的编写

public interface UserMapper {
    int insertUser();
    int updateUser();
    int deleteUser();
    User getUser();
    List<User> getAllUser();
}

对应Mapper接口的xml文件编写

<mapper namespace="com.lsc.mybatis.Mapper.UserMapper">
<!--    mapper接口和映射文件要保证两个一致-->
<!--    1mapper接口的全类名个映射文件的namespace一致-->
<!--    2mapper接口中的方法的方法名要和映射文件中的sql的id保证一致-->

        <!--    int insertUser();-->
        <insert id="insertUser">
            insert into t_user values(null,'lsc','245281',22,'男','lsc0702481@163.com')
        </insert>
        <!--     int updateUser();-->
        <update id="updateUser">
            update t_user set username='刘颂成' where id=1
        </update>
        <!--     int deleteUser-->
        <delete id="deleteUser">
            delete from t_user where id=1
        </delete>
        <!--     User getUser-->
        <!--
             resultType：设置结果类型，即查询的数据要转换为的java类型
             resultMap：自定义映射，处理多对一或一对多的映射关系
        -->
   		<!-- 查询一个实体类对象-->
        <select id="getUser" resultType="com.lsc.mybatis.pojo.User">
            select * from t_user where id=1;
        </select>
        <!--    List<User> getAllUser()-->
        <select id="getAllUser" resultType="com.lsc.mybatis.pojo.User">
            select * from t_user
        </select>
</mapper>

resultType：设置结果类型，即查询的数据要转换为的java类型自动映射，用于属性名和表中字段名一致的情况
- select * from t_user *从表中查出的数据是一系列字段数据，但是我们需要的是User类型对象，所以需要我们在xml配置
  - 因为我们表中的字段名跟我们的类中的属性名是一一对应的，且对应的类型也是一样的，所以不需要额外配置
resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况

核心配置文件详解

关于mybatis标签的顺序

<!--
MyBatis核心配置文件中，标签的顺序：
properties?,settings?,typeAliases?,typeHandlers?,
objectFactory?,objectWrapperFactory?,reflectorFactory?,
plugins?,environments?,databaseIdProvider?,mappers?
-->

必须按照上面的顺序，不然会报错

environments

<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/ssm"/>
                <property name="username" value="root"/>
                <property name="password" value="245281"/>
            </dataSource>
        </environment>
        <environment id="test">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url"
                          value="jdbc:mysql://localhost:3306/ssmserverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
</environments>

environments表示配置多个连接数据库的环境
- default表示设置默认使用环境的id，我们的例子中使用的id为develpoment的环境
environment表示配置某个具体的环境
- id表示连接数据库环境的唯一标识，不能重复

关于environment标签详解

transactionManager ：设置事务管理方式
- JDBC:表示当前环境中，执行SQL时，使用的是JDBC中原生的事务管理方式，事务的提交或回滚需要手动处理
- MANAGED:表示被管理，例如Spring中有对应事务管理方式
dataSource 配置数据源
- type 设置数据源的类型
  - POOLED表示使用数据库连接池缓存数据库连接
  - UNPOOLED：表示不使用数据库连接池
  - JNDI：表示使用上下文中的数据源
- url 设置连接数据库的连接地址
- username 设置连接数据库的用户名
- password 设置连接数据库的密码

properties

对应的properties文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.username=root
jdbc.password=123456

<properties resource="jdbc.properties" />
<environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <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>

properties 用来引入properties文件
- resource中写的是我们对应properties的位置
利用${}来获取我们的properties中的数据

typeAliases

<typeAliases>
<typeAlias type="com.lsc.mybatis.pojo.User"></typeAlias>
<!--以包为单位，将包下所有的类型设置默认的类型别名，即类名且不区分大小写-->
<package name="com.lsc.mybatis.pojo"/>
</typeAliases>

UserMapper.xml

<!--  不设置别名之前的操作-->
<!--        <select id="getAllUser" resultType="com.lsc.mybatis.pojo.User">-->
<!--            select * from t_user-->
<!--        </select>-->
    <select id="getAllUser" resultType="User">
              select * from t_user
    </select>

typeAliases 设置某个类型的别名
- type设置需要设置别名的类型
- alias 设置某个类型的别名，如果不设置该属性，那么该类型拥有的默认别名，即类名且不区分大小写

mappers

<mappers>

<!--<mapper resource="mappers/UserMapper.xml"/>-->
<package name="com.lsc.mybatis.mapper"/>
</mappers>

mappers表示配置多个映射文件
mapper表示配置一个映射文件
- resource表示映射文件的位置
pacakage 表示以包为单位引入映射文件
- 必须满足两个条件
  - mapper接口所在的包要和映射文件所在的包一致
  - mapper接口要和映射文件的名字一致

我们看到编译后的class文件，我们的UserMapper接口和对应的UserMapper.xml文件在同一个目录下

Mybatis获取参数的两种方式

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

${}的本质就是字符串替换，#{}的本质就是占位符赋值（预编译处理）
- ${}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号；
- #{}使用占位符赋值的方式拼接sql（会把sql中的#{}替换为?,然后调用PreparedStatemen的set方法来赋值），此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号
  - 使用#{}可以有效发防止SQL注入

单个字面量类型的参数

UserMapper接口

public interface UserMapper {
    /**
     * 根据用户名查询用户新鲜
     * @param userName
     * @return
     */
    User getUserByUserName(String userName);
}

UserMapper.xml

<mapper namespace="com.lsc.mybatis.mappers.UserMapper">
<!--            User getUserByUserName(String userName);-->
        <select id="getUserByUserName" resultType="User">
                select * from t_user where username=#{username}
        </select>
<!--        <select id="getUserByUserName" resultType="User">-->
<!--                select * from t_user where username=#{abc}-->
<!--        </select>-->
<!--        <select id="getUserByUserName" resultType="User">-->
<!--                select * from t_user where username='${username}'-->
<!--        </select>-->
    <!-- 
	对应${}的进行字符串拼接的方式
	DEBUG 01-09 18:34:17,535 ==>  Preparing: select * from t_user where username='刘颂成'  (BaseJdbcLogger.java:137) 
	DEBUG 01-09 18:34:17,558 ==> Parameters:   (BaseJdbcLogger.java:137) 
	DEBUG 01-09 18:34:17,573 <==      Total: 1  (BaseJdbcLogger.java:137) 
	-->
    <!-- 
	对应#{}占位符方式
    DEBUG 01-09 18:38:18,389 ==>  Preparing: select * from t_user where username=?  (BaseJdbcLogger.java:137) 
	DEBUG 01-09 18:38:18,412 ==> Parameters: 刘颂成(String)  (BaseJdbcLogger.java:137) 
	DEBUG 01-09 18:38:18,432 <==      Total: 1  (BaseJdbcLogger.java:137) 
	-->
</mapper>

若mapper接口中的方法参数为单个的字面量类型

此时可以使用 $KaTeX parse error: Expected 'EOF', got '#' at position 4: {}和#̲{}以`任意的名称`获取参数的\dots$ {}需要手动加单引号

多个字面量类型的参数

UserMapper接口

public interface UserMapper {
	/**
     * 验证登录
     * @param userName
     * @param password
     * @return
     */
    User checkLogin(String userName,String password);
}

UserMapper.xml文件

<mapper namespace="com.lsc.mybatis.mappers.UserMapper">
    
            <!--        User checkLogin(String userName,String password);-->
<!--        <select id="checkLogin" resultType="User">-->
<!--                select * from t_user where username=#{param1} and pwd=#{param2}-->
<!--        </select>-->
        <select id="checkLogin" resultType="User">
                select * from t_user where username='${arg0}' and pwd='${arg1}'
        </select>
</mapper>

若mapper接口中的方法参数为多个时

此时MyBatis会自动将这些参数放在一个map集合中
- 以arg0,arg1…为键，以参数为值；
- 或者param1,param2…为键，以参数为值；

因此只需要通过 $KaTeX parse error: Expected 'EOF', got '#' at position 4: {}和#̲{}访问map集合的键就可以获\dots$ {}需要手动加单引号

map集合类型的参数

UserMapper接口

public interface UserMapper {	
    /**
     * 验证登录（以map集合作为参数）
     * @param map
     * @return
     */
    User checkLoginByMap(Map<String,Object> map);
}

传入的参数

 @Test
    public void checkLoginByMapTest(){
        SqlSession sqlSession= SqlSessionUtil.getSqlSession();
        Map<String,Object> map=new HashMap<>();
        String userName="刘颂成";
        String password="123";
        map.put("username",userName);
        map.put("password",password);
        UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
        User user = userMapper.checkLoginByMap(map);
        System.out.println(user);
    }

UserMapper.xml

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

若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中只需要通过 $KaTeX parse error: Expected 'EOF', got '#' at position 4: {}和#̲{}**访问map集合的键就可\dots$ {}需要手动加单引号

实体类类型的参数

UserMapper接口

public interface UserMapper {	
/**
     * 添加用户信息
     * @param user
     */
    int insertUser(User user);
}

User类

public class User {
    private Integer id;
    private String username;
    private String pwd;
    private Integer age;
    private String gender;
    private String email;
}

UserMapper.xml

<mapper namespace="com.lsc.mybatis.mappers.UserMapper">

        <!--        void insertUser(User user);-->
        <insert id="insertUser" >
                insert into t_user values(null,#{username},#{pwd},#{age},#{gender},#{email})
        </insert>
</mapper>

若mapper接口中的方法参数为实体类对象时

此时可以使用 $KaTeX parse error: Expected 'EOF', got '#' at position 4: {}和#̲{}，直接通过访问实体类对象中\dots$ {}需要手动加单引号

使用@Param标识参数

UserMapper

/**
 * 验证登录（使用@Param）
 * @param username
 * @param password
 * @return
 */
User checkLoginByParam(@Param("username") String username,@Param("password") String password);

UserMapper.xml

<mapper namespace="com.lsc.mybatis.mappers.UserMapper">
<!--        User checkLoginByParam(@Param("username") String username,@Param("pwd") String password);-->
        <select id="checkLoginByParam" resultType="User">
                select * from t_user where username=#{username} and pwd=#{password}
        </select>
</mapper>

可以通过@Param注解标识mapper接口中的方法参数

会将这些参数放在map集合中，以@Param注解的value属性值为键，以参数为值；
以param1,param2…为键，以参数为值；
只需要通过 $KaTeX parse error: Expected 'EOF', got '#' at position 4: {}和#̲{}访问map集合的键就可以获\dots$ {}需要手动加单引号

总结

这么多种情况，我们需要来规定一下，以方便使用

存在@Param注解，那么就Param注解的value属性值为键，以参数为值
不存在@Param注解,以param1,param2…为键，以参数为值

只需要通过#{}和 ${}访问map集合的键，就可以获取相对应的值,一定要注意$ {}的单引号问题，一般情况下都是用#{}

MyBatis的各种查询功能

查询一个实体类对象

<mapper namespace="com.lsc.mybatis.Mapper.SelectMapper">
        <!--    User getUserById(@Param("id") Integer id);-->
        <select id="getUserById" resultType="User">
            select * from t_user where id= #{id}
        </select>
</mapper>

  /**
     * 根据id查询用户信息
     * @param id
     * @return
     */
    User getUserById(@Param("id") Integer id);

根据我们的resultType来将User和t_user数据表中的数据对应起来,且需要将属性名和t_user表中字段名对应起来

查询一个list集合

<mapper namespace="com.lsc.mybatis.Mapper.SelectMapper">
<!--    List<User> getAllUser();-->
        <select id="getAllUser" resultType="User">
            select * from t_user
        </select>
</mapper>

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

如果查询出多条数据，我们可以使用List来进行装入
若sql语句查询的结果为多条时，一定不能以实体类类型作为方法的返回值
- 否则会抛出异常TooManyResultsException
- 若sql语句查询的结果为1条时，此时可以使用实体类类型或list集合类型作为方法的返回值

查询单个数据

<mapper namespace="com.lsc.mybatis.Mapper.SelectMapper">
<!--    Integer getCount();-->
    <select id="getCount" resultType="int" >
        select count(*) from t_user
    </select>
</mapper>

	/**
     * 查询用户的总数量
     * @return
     */
    Integer getCount();

我们在resultType中设置了int,这个int是Integer的别名

MyBatis中为Java中常用的类型设置了类型别名

Integer：Integer，int
int：_int,_integer
Map：map
String：string

查询一条数据为map集合

<mapper namespace="com.lsc.mybatis.Mapper.SelectMapper">
<!--    Map<String,Object> getUserByIdToMap(@Param("id") Integer id);-->
    <select id="getUserByIdToMap" resultType="map">
        select * from t_user where id= #{id}
    </select>
</mapper>

 /**
     * 根据id查询用户信息为map集合
     * @param id
     * @return
     */
    Map<String,Object> getUserByIdToMap(@Param("id") Integer id);

注意我们的Map的类型是String作为key和value为Object

查询多条数据为map集合

方式一

<mapper namespace="com.lsc.mybatis.Mapper.SelectMapper">
<!--    List<Map<String,Object>> getAllUserToMap();-->
    <select id="getAllUserToMap" resultType="Map">
        select * from t_user
    </select>
</mapper>

 /**
     * 查询所有的用户信息为map集合
     * 若查询的数据有多条，并且要将每条数据转换为map集合
     * @return
     */
   List<Map<String,Object>> getAllUserToMap();

将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，此时可以将这些map放在一个list集合中获取

方式二

<mapper namespace="com.lsc.mybatis.Mapper.SelectMapper">
<!--    @MapKey("id")-->
<!--    Map<String,Object> getAllUserToMap();-->
        <select id="getAllUserToMap" resultType="map">
            select * from t_user
        </select>
</mapper>
//查询结果
{
 1={gender=男, id=1, pwd=123, age=22, email=lsc0702481@163.com, username=刘颂成},
 2={gender=女, id=2, pwd=123, age=20, email=lkx@163.com, username=李可新}, 
 3={gender=男, id=3, pwd=123, age=222, email=xm@163.com, username=小米},
 4={gender=女, id=4, pwd=123, age=19, email=xiaoming@163.com, username=小红},
 5={gender=男, id=5, pwd=123, age=22, email=xac@163.com, username=小啊成},
 6={gender=女, id=6, pwd=123, age=20, email=xkx@163.com, username=小可新}
}

  /**
     * 查询所有的用户信息为map集合
     * 若查询的数据有多条，并且要将每条数据转换为map集合
     * @return
     */
    @MapKey("id")
    Map<String,Object> getAllUserToMap();

将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，并且最终要以一个map的方式返回数据，此时需要通过@MapKey注解设置map集合的键，值是每条数据所对应的map集合

库里不会投三分

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

第一章Mybatis基础操作学习

文章目录

MyBatis简介

MyBatis历史

MyBatis特性

和其它持久化层技术对比

搭建MyBatis

开发环境

创建maven工程

创建MyBatis的核心配置文件

创建mapper接口

创建MyBatis的映射文件

通过junit测试功能

加入log4j日志功能

不带参数的增删改查

Mapper接口的编写

对应Mapper接口的xml文件编写

核心配置文件详解

关于mybatis标签的顺序

environments

properties

typeAliases

mappers

Mybatis获取参数的两种方式

单个字面量类型的参数

多个字面量类型的参数

map集合类型的参数

实体类类型的参数

使用@Param标识参数

总结

MyBatis的各种查询功能

查询一个实体类对象

查询一个list集合

查询单个数据

查询一条数据为map集合

查询多条数据为map集合