mybatis学习笔记

最新推荐文章于 2023-05-30 17:33:06 发布

阿超LSC

最新推荐文章于 2023-05-30 17:33:06 发布

阅读量212

点赞数

文章标签： mybatis

本文链接：https://blog.csdn.net/weixin_47840269/article/details/109696128

版权

Mybatis简介

一.什么是mybatis：

MyBatis 是一款优秀的持久层框架。（持久层：将程序的数据持久状态和瞬时状态转化的过程）
它支持自定义 SQL、存储过程以及高级映射。
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。
2013年11月迁移到Github。

二.如何获得mybatis

Maven仓库
百度搜索maven，然后输入mybatis，选择版本即可

三.为什么需要mybatis

帮助程序员将数据存入到数据库中
传统的JDBC代码太复杂。
优点：
。简单易学
。灵活
。Sql和代码分离，提高了可维护性
。提供映射标签，支持对象与数据库的orm字段关系映射
。提供对象关系映射标签，支持对象关系组建维护
。提供xml标签，支持编写动态sql

最重要的是使用的人多0.0

四，第一个mybatis程序

思路：搭建环境→导入mybatis→编写代码→测试

环境搭建：
- 搭建数据库

五.新建项目

1，新建一个maven工程

删除src项目（父工程），重新建立一个子模块
导入maven依赖
1，Mysql
2，Mybatis
3，Junit

2，创建一个模块

在idea中连接数据库（注意mysql8.0+的时区问题）
编写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核心配置文件-->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--MySql 数据库更新为8.0及以上后，对应的应用程序数据库链接驱动包也要更新为8.0版本。否则会报驱动异常-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="lsc102314"/>
            </dataSource>
        </environment>
    </environments>

    <!--每一个Mapper.xml都需要再Mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="com/kuang/dao/UserMapper.xml"/>
    </mappers>

</configuration>

参考链接：https://blog.csdn.net/qwq1503/article/details/96688527

3，编写mybatis工具类

//工具类sqlSessionFactory sqlSession
public class MybatisUtils {

    private static SqlSessionFactory sqlSessionFactory;

    static {

        try {
            //使用mybatis第一步获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static SqlSession getSqlSession() {
        return sqlSessionFactory.openSession();
    }
}

4，编写代码,

实体类（空参有参及toString方法）

public class User {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

5，Dao接口

public interface UserDao {
    List<User> getUserList();
}

6，接口实现类

<?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">
<!--namespace=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.kuang.dao.UserDao">

    <!--select查询语句-->
    <select id="getUserList" resultType="com.kuang.pojo.User">
        select * from mybatis.user
    </select>
</mapper>

六，测试

问：MapperRegistry是什么？
答：核心配置文件中注册mappers。

Junit测试

public UserDaoTest() {
}
@Test
public void test() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserDao userDao = (UserDao)sqlSession.getMapper(UserDao.class);
    List<User> userList = userDao.getUserList();
    Iterator var4 = userList.iterator();

    while(var4.hasNext()) {
        User user = (User)var4.next();
        System.out.println(user);
    }

    sqlSession.close();
}

七，CRUD

1，Namespace
Namespace中的报名要和Dao/mapper接口的报名一致
2，Select
3，Insert
4，update
5，delete

选择，查询语句；

UserMapper.xml中的id就是对应的namespace中的方法名（namespace绑定的是接口，而id就是绑定接口中的方法名）；

<mapper namespace="com.kuang.dao.UserMapper">
    <!--select查询语句-->
   <select id="getUserList" resultType="com.kuang.pojo.User">
       select * from mybatis.user
   </select>
</mapper>

。resultType：Sql语句执行的返回值
。parameterType：参数类型（还没用到）

A，编写接口

//查询全部用户
List<User> getUserList();

//根据ID查询用户
User getUserById(int id);

//添加一个用户（insert）
int addUser(User user);

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

//删除一个用户
int deleteUser(int id);

B，编写对应的mapper中的sql语句

<mapper namespace="com.kuang.dao.UserMapper">

    <!--select查询语句-->
   <select id="getUserList" resultType="com.kuang.pojo.User">
       select * from mybatis.user
   </select>
    
    <select id="getUserById" resultType="com.kuang.pojo.User" parameterType="int">
        select * from mybatis.user where id = #{id}
    </select>

    <!--对象中的属性，可以直接取出来-->
    <insert id="addUser" parameterType="com.kuang.pojo.User">
        insert into mybatis.user (id,name,pwd) value (#{id},#{name},#{pwd})
    </insert>

    <!--修改用户-->
    <update id="updateUser" parameterType="com.kuang.pojo.User">
        update mybatis.user set name = #{name },pwd = #{pwd} where id = #{id};
    </update>

    <!--删除用户-->
    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id= #{id}
    </delete>
</mapper>

C，测试

//查询所有用户
@Test
public void test(){

    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    //获得接口的绑定对象
    UserMapper userDao = sqlSession.getMapper(UserMapper.class);
    List<User> userList = userDao.getUserList();

    for (User user : userList) {
        System.out.println(user);
    }
    //关闭SqlSession
    sqlSession.close();
}

//通过id查询用户
@Test
public void getUserById(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    //获得接口的绑定对象
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User userById = mapper.getUserById(1);
    System.out.println(userById);
    sqlSession.close();
}


//注意：增删改需要提交事务
//增加一个用户
@Test
public void addUser() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.addUser(new User(4,"哈哈","123333"));

    //提交事务,切记：增删改必须要这行代码
    sqlSession.commit();
    sqlSession.close();
}

//修改一个用户
@Test
public void updateUser(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.updateUser(new User(4,"呵呵","123456"));

    sqlSession.commit();
    sqlSession.close();
}

//删除一个用户
@Test
public void deleteUser() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.deleteUser(4);
    sqlSession.commit();
    sqlSession.close();
}

注意：增删改这三项一定要注意提交事务，也就是sqlSession.commit();

八，分析错误

1，使用标签不要混淆，如：要进行删除操作，却用了标签
2，mybatis-config.xml文件中的resouce标签绑定的mapper，使用的是路径，需要用“/”来分隔，而不是用“ . ”

<mappers>
    <mapper resource="com/kuang/dao/UserMapper.xml"/>
</mappers>

3，maven没有导出问题，需要在pom.xml文件中配置：

<!--在build中配置resources，来防止我们资源导出失败的问题-->
<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

九，模糊查询

接口UserMapper代码：

//模糊查询
List<User> getUserLike(String value);

UserMapper.xml配置

<!--模糊查询-->
<select id="getUserLike" resultType="com.kuang.pojo.User">
    select * from mybatis.user where name like "%"#{value}"%"
</select>

UserMapperTest测试类代码

/模糊查询
@Test
public void getUserLike(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> userList = mapper.getUserLike("李");

    for (User user : userList) {
        System.out.println(user);
    }
    sqlSession.close();
}

测试结果：
在这里插入图片描述

注意：在xml配置文件中使用到了通配符“%”，不然通过文字“李”查询的时候，什么都查不到

十，本文使用的数据库信息：

在这里插入图片描述

配置解析

一，核心配置文件

mybatis-config.xml
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。配置文档的顶层结构如下：
configuration（配置）
properties（属性）
settings（设置）
ypeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
oenvironment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）

二，环境配置（environments）

1，mybatis可以配置多种环境变量
不过要记住：尽管可以配置多个环境，但每个SqlSessionFactory 实例只能选择一种环境。

2，学会使用配置多套运行环境
在这里插入图片描述

mybatis默认的事务管理器就是JDBC，连接池：POOLED
在mybatis-config.xml文件中

<transactionManager type="JDBC"/>
<dataSource type="POOLED">

三，属性

。我们可以通过properties属性来实现引用配置文件
这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。

。编写一个配置文件

db.properties

driver= com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
username=root
password=lsc102314

。核心配置文件中引入

<!--引入外部配置文件--><!--.properties为外部文件，优先使用外部文件再使用这里引入的-->
<properties resource="db.properties"><!--在同一个文件夹下，所以不用写全路径-->
    <property name="username" value="root"/>
    <property name="pwd" value="lsc102314"/>
</properties>

1，可以直接引入外部文件
2，可以在其中增加一些属性配置
3，如果两个文件有同一个字段，优先使用外部文件（.properties叫外部文件）

四，类型别名

。类型别名是为Java类设置一个短的名字，意在降低冗余的全限定类名书写
。在mybatis-config.xml中设置别名：

<!--给实体类起别名，type="com.kuang.pojo.User"是全路径，alias="User"是别名-->
<typeAliases>
    <typeAlias type="com.kuang.pojo.User" alias="User"/>
</typeAliases>

。也可以指定一个包名，mybatis会在包名下面搜索需要的Java bean，比如：扫描实体类（pojo）的包，它的默认别名就为这个类的类名，首字母小写

<!--给实体类起别名，type="com.kuang.pojo.User"是全路径，alias="User"是别名，此为方式一-->
<!--方式二，<package name="com.kuang.pojo"/> -->
<typeAliases>
    <typeAlias type="com.kuang.pojo.User" alias="User"/>
    <!--<package name="com.kuang.pojo"/>--><!--此为方式二-->
</typeAliases>

什么情况下建议用方式一或者方式二：
在实体类比较少的时候，使用第一种起别名方式，
如果实体类比较多，建议使用第二种，
区别：第一种可以DIY别名（随意起别名），第二种只能是实体类的类名（类名首字母默认小写），如果非要改别名，需要在实体类上增加注解

//注解式起别名
@Alias("hello")//这时候的User类别名为hello，UserMapper.xml中resultType类型应该为hello
               // <select id="getUserList" resultType="hello">
public class User {

五，设置

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。
主要记住这几个

在这里插入图片描述

六，其他配置（不要求掌握）

typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）

七，映射器（mappers）

在mybatis.zml中
优先使用这种方式

<!--每一个Mapper.xml都需要再Mybatis核心配置文件中注册-->
<mappers>
    <mapper resource="com/kuang/dao/UserMapper.xml"/>
</mappers>

- 使用和要注意两点：
A，接口和它的Mapper配置文件必须同名
B，接口和它的Mapper配置文件必须在同一个包下

八，作用域（Scope）和生命周期

生命周期和作用域，是至关重要的，因为错误的使用会导致非常严重的并发问题。
。SqlSessionFactoryBuilder
。一旦创建了 SqlSessionFactory，就不再需要SqlSessionFactoryBuilder了
。局部变量

。SqlSessionFactory
。说白了就是可以想象为：数据库连接池
。SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
。因此SqlSessionFactory的最佳作用域就是应用作用域
。最简单的就是使用单例模式或者静态单例模式
。Sqlsession
。连接到连接池的一个请求
。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
。用完之后需要赶紧关闭close（），否则资源被占用

解决属性名和字段名不一致的问题
一，问题：
。数据库中的字段
在这里插入图片描述

。新建一个项目，拷贝之前的情况，测试实体类字段不一致的情况

public class User {
    private int id;
    private String name;
    private String password; //注意：数据库中这里是pwd
}

测试出现问题
在这里插入图片描述

二．解决方法：

一，起别名

<select id="getUserById" parameterType="int" resultType="com.kuang.pojo.User">
    select id,name,pwd as password from mybatis.user where id = #{id}
</select>

二，resultMap

结果集映射
id name pwd
Id name password

<!--结果集映射-->
<resultMap id="UserMap" type="User">
    <!--column是数据库中的字段，property实体类中的属性-->
    <result column="id" property="id"/>
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
</resultMap>
<select id="getUserById" resultMap="UserMap">
    select * from mybatis.user where id = #{id}
</select>

。resultMap 元素是 MyBatis 中最重要最强大的元素。
。ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

日志

一，日志工厂

如果一个数据库操作，出现了异常，我们需要排错，日志就是最好的助手！
曾经用两种方式：sout，debug
现在：日志工厂
在这里插入图片描述

（图片出处mybatis3 | 配置|设置）

。SLF4J
。LOG4J 【掌握】
。LOG4J2
。JDK_LOGGING |
。COMMONS_LOGGING
。STDOUT_LOGGING 【掌握】
。NO_LOGGING

在mybatis中具体使用哪个日志实现，在设置中设定（mybatis-config）
STDOUT_LOGGING标准日志输出

在mybatis核心配置文件中，配置我们的日志（注意空格及大小写问题）

<!--日志-->
<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

Opening JDBC Connection
Created connection 905735620.
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@35fc6dc4]
==>  Preparing: select * from mybatis.user where id = ? 
==> Parameters: 1(Integer)
<==    Columns: id, name, pwd
<==        Row: 1, 狂神, 123456
<==      Total: 1
User{id=1, name='狂神', password='123456'}
Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@35fc6dc4]
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@35fc6dc4]
Returned connection 905735620 to pool.

二，LOG4J

什么是Log4j？
。Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
。我们也可以控制每一条日志的输出格式；
。通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
。通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

1,导入log4j的包

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

2,log4j.properties

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=【%c】-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/kuang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=【%p】【%d{yy-MM-dd}】【%c】%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

3,配置log4j为日志的实现

<!--日志-->
<settings>
    <!--<setting name="logImpl" value="STDOUT_LOGGING"/>&lt;!&ndash;标准的日志工厂实现&ndash;&gt;-->
    <setting name="logImpl" value="LOG4J"/>
</settings>

4,log4j的properties文件

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.encoding=UTF-8
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/kuang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

4，简单实用
。在要使用Log4j的类中，导入

import org.apache.log4j.Logger;

。日志对象，参数为当前类的class

static Logger logger = Logger.getLogger(UserDaoTest.class);

。日志级别

@Test
public void testLoG4J() {
    logger.info("info：进入了testLog4j");
    logger.info("debug：进入了testLog4j");
    logger.info("error：进入了testLog4j");
}

三，分页

思考：为什么要分页？
。减少数据的处理量

使用Limit分页

 SELECT * from user limit startIndex，pageSize;
 SELECT * from user limit 3; #[0,n]

使用mybatis实现分页，核心SQL
A，接口

//分页
List<User> getUserByLimit(Map<String,Integer> map);

B，Mapper.xml

<!--分页-->
<select id="getUserByLimit" parameterType="map" resultType="user">
    select * from mybatis.user limit #{startIndex} #{pageSize};
</select>

C，测试

@Test
public void  getUserByLimit() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    HashMap<String, Integer> map = new HashMap<String, Integer>();
    map.put("startIndex",0);
    map.put("pageSize",0);

    List<User> userList = mapper.getUserByLimit(map);
    for (User user : userList) {
        System.out.println(user);
    }
    sqlSession.close();
}

RowBounds分页

使用注解开发

一，面向接口编程

1，关于接口的理解
。接口从更深层层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离
。接口的本身反映了系统设计人员对系统的抽象理解
。接口应有两类：
第一类是对一个个体的抽象，他可对应为一个抽象体（abstract class）
第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）
。一个体有可能有多个抽象面。抽象体与抽象面是有区别的。

2，三个面向区别
。面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法
。面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现
。接口实际与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题，更多的体现就是对系统整体的架构

二，使用注解开发

1，注解在接口上实现

@Select("select * from user")
List<User> getUser();

2,需要在核心配置文件中绑定接口（mybatis.xml）

<!--绑定接口-->
<mappers>
    <mapper class="com.kuang.dao.UserMapper"/>
</mappers>

3,测试

@Test
public void test() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    //底层主要应用反射
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> users = mapper.getUser();
    for (User user : users) {
        System.out.println(user);
    }
    sqlSession.close();
}

在这里插入图片描述

使用注解开发，简单的还可以，复杂的就麻烦了，复杂的最好还是使用xml方式比较好

三，CRUD

我们可以在工具类创建的时候实现自动提交事务（在工具类中设置）

public static SqlSession getSqlSession() {
    return sqlSessionFactory.openSession(true);//在这里设置为true之后，以后增删改就不用手动去commit(提交事务)了
}

测试类：
【注意：我们必须要将接口注册绑定到我们的核心配置文件中】

<!--绑定接口-->
<mappers>
    <mapper class="com.kuang.dao.UserMapper"/>
</mappers>

关于@Param（）注解
。基本类型的参数或者String类型，需要加上
。引用类型不需要加
。如果只有一个基本类型的话，可以忽略，但是建议加上
。我们在SQL中引用的就是我们这里的@Param（“xxx”）中设定的属性名

多对一

1，多对一处理
。就好比如多个学生，对应一个老师
对于学生这边而言，关联，，，多个学生关联一个老师【多对一】
对于老师而言，集合，一个老师，有很多学生【一对多】

测试环境搭建
1，新建实体类Teacher，Student
2，建立Mapper接口
3，建立Mapper.xml文件
4，在核心配置文件中绑定注册我们的Mapper接口或者文件
5，测试查询是否能够成功

按照查询嵌套处理

<select id="getStudent" resultMap="StudentTeacher">
select * from student;
</select>

<resultMap id="StudentTeacher" type="Student">
    <result property="id" column="id"/>
    <result property="name" column="name"/>
    <!--复杂的属性，我们需要单独处理
        对象：association
        集合：collection
    -->
    <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
</resultMap>

<select id="getTeacher" resultType="Teacher">
    select * from Teacher where  id = #{id}
</select>

按照结果嵌套处理

<!--按照结果嵌套处理-->
<select id="getStudent2" resultMap="StudentTeacher2">
    select s.id sid,s.name sname,t.name tname
    from student s,teacher t
    where s.tid=t.id;
</select>

<resultMap id="StudentTeacher2" type="Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"/>
    </association>
</resultMap>

回顾Mysql多对一查询方式：
。子查询
。联表查询

一对多处理

比如：一个老师拥有多个学生
对老师而言，就是一对多的关系

1，环境搭建

实体类：

public class Student {

    private int id;
    private String name;
    private int tid;

	//下面就是setget和toString方法

public class Teacher {
    private int id;
    private String name;

    //一个老师拥有多个学生
    private List<Student> students;

	//下面就是setget和toString方法

按照查询嵌套处理

<!--按查询嵌套处理-->
<select id="getTeacher2" resultMap="TeacherStudent2">
    select * from mybatis.teacher where id = #{tid}
</select>

<resultMap id="TeacherStudent2" type="Teacher">
    <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
</resultMap>

<select id="getStudentByTeacherId" resultType="Student">
    select * from mybatis.student where tid = #{tid}
</select>

按照结果嵌套处理

<!--按结果嵌套处理-->
<select id="getTeacher" resultMap="TeacherStudent">
    select s.id sid, s.name sname,t.name tname,t.id tid
    from student s,teacher t
    where s.tid = t.id and t.id = #{tid}
</select>

<resultMap id="TeacherStudent" type="Teacher">
    <result property="id" column="tid"/>
    <result property="name" column="tname"/>
    <!--复杂的属性，我们需要单独处理 对象：association 集合：collection
    javaType="" 指定属性的类型  集合中的泛型信息，我们使用ofType获取-->
    <collection property="students" ofType="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <result property="tid" column="tid"/>
    </collection>
</resultMap>

小结

1，关联 - association【多对一】
2，集合 - collection【一对多】
3，JavaType & ofType
(1)JavaType用来指定实体类中属性的类型
(2)ofType用来指定映射到List或者集合中pojo类型，泛型中的约束类型

注意点：
。保证SQL的可读性，尽量保障通俗易懂，便宜维护
。注意一对多和多对一中，属性名和字段的问题
。如果问题不好排查错误，可以使用日志，建议使用Log4j

1 字节的 UTF-8 序列的字节 1 无效

出现该问题时解决方法为：
下面这种在pom.xml添加以下代码解决了我的问题

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

命名含义：
。pojo，model，mojo：简单的java对象，里面就是放set，get，tostring等方法
。Vo：视图的java对象，有具体的使用范围
。Dto：是可以跟数据库做关联的对象
。Dao：数据存取对象，用来对数据库做存取操作
。d是Data数据的意思，o都是Object的

阿超LSC

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
mybatis学习笔记

Mybatis简介1.什么是mybatis：MyBatis 是一款优秀的持久层框架。（持久层：将程序的数据持久状态和瞬时状态转化的过程）它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。MyBatis 本是apache的
复制链接

扫一扫