Mybatis的学习总结

最新推荐文章于 2024-03-07 23:45:00 发布

今天更博学了吗

最新推荐文章于 2024-03-07 23:45:00 发布

阅读量617

点赞数 2

文章标签： mybatis java mysql

本文链接：https://blog.csdn.net/weixin_45856713/article/details/109608928

版权

Mybatis

第一天
第二天
第三天
第四天

本次mybatis学习时间总共四天的时间分为四大段描述总结自己的学习过程

第一天

mybatis入门

mybatis的概述

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录。

mybatis的环境搭建

第一步：创建maven工程并导入坐标

创建项目
创建ｍｙｂａｔｉｓ
创建ｍｙｂａｔｉｓ２
创建完成后的项目结构
创建数据库文件

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(32) NOT NULL COMMENT '用户名称',
  `birthday` datetime default NULL COMMENT '生日',
  `sex` char(1) default NULL COMMENT '性别',
  `address` varchar(256) default NULL COMMENT '地址',
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;



insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (41,'老王','2018-02-27 17:47:08','男','北京'),(42,'小二王','2018-03-02 15:09:37','女','北京金燕龙'),(43,'小二王','2018-03-04 11:34:34','女','北京金燕龙'),(45,'传智播客','2018-03-04 12:04:06','男','北京金燕龙'),(46,'老王','2018-03-07 17:37:26','男','北京'),(48,'小马宝莉','2018-03-08 11:44:00','女','北京修正');





DROP TABLE IF EXISTS `account`;

CREATE TABLE `account` (
  `ID` int(11) NOT NULL COMMENT '编号',
  `UID` int(11) default NULL COMMENT '用户编号',
  `MONEY` double default NULL COMMENT '金额',
  PRIMARY KEY  (`ID`),
  KEY `FK_Reference_8` (`UID`),
  CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;



insert  into `account`(`ID`,`UID`,`MONEY`) values (1,41,1000),(2,45,1000),(3,41,2000);



DROP TABLE IF EXISTS `role`;

CREATE TABLE `role` (
  `ID` int(11) NOT NULL COMMENT '编号',
  `ROLE_NAME` varchar(30) default NULL COMMENT '角色名称',
  `ROLE_DESC` varchar(60) default NULL COMMENT '角色描述',
  PRIMARY KEY  (`ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;



insert  into `role`(`ID`,`ROLE_NAME`,`ROLE_DESC`) values (1,'院长','管理整个学院'),(2,'总裁','管理整个公司'),(3,'校长','管理整个学校');





DROP TABLE IF EXISTS `user_role`;

CREATE TABLE `user_role` (
  `UID` int(11) NOT NULL COMMENT '用户编号',
  `RID` int(11) NOT NULL COMMENT '角色编号',
  PRIMARY KEY  (`UID`,`RID`),
  KEY `FK_Reference_10` (`RID`),
  CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `role` (`ID`),
  CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert  into `user_role`(`UID`,`RID`) values (41,1),(45,1),(41,2);

添加pom.xml坐标依赖

<?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>org.example</groupId>
    <artifactId>Mybatis_03</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--设置打包方式-->
    <packaging>jar</packaging>

    <dependencies>
        <!--导入mybatis坐标-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <!--数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <!--<version>5.1.6</version> 因为我本地是8.0的sql版本 老版本存在问题-->
            <version>8.0.21</version>
        </dependency>
        <!--日志-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
         <!--lombok 插件-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
    </dependencies>
</project>

第二步：创建实体类和Dao接口

创建用户实体类

/**
 * @author : Ahao
 * @date : 23:18 2020/11/10
 */
@Data
@ToString
public class User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
}

创建Dao 持久层

/**
 * @author : Ahao
 * @date : 23:26 2020/11/10
 * 用户的持久层接口
 */
public interface IUserDao {
    /**
     * 查询所有操作
     */
    List<User> findAll();
}
}

第三步：创建Mybatis的主配置文件

SqlMapConfig.xml

resources 文件下创建 SqlMapConfig.xml、log4j.properties 、Mapper文件夹下IUserDao.xml

<?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">
<!--mybatis的主配置文件-->
<configuration>
    <!--配置环境-->
    <environments default="mysql"> <!--名字可以随便去，只是声明一个名字 注意和下面  id名字保持一致-->
        <!--配置mysql的环境-->
        <environment id="mysql"><!--名字与上面的default保持一致-->
            <!--配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源（连接池）-->
            <dataSource type="POOLED">
                <!--配置连接数据库的四个基本信息-->
                <!--数据库连接驱动-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!--数据库连接端口号 数据库名称-->
                <property name="url" value="jdbc:mysql://location:3306/user?serverTimezone=Asia/Shanghai"/>
                <!--数据库 用户名 密码-->
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件-->
    <mappers>
        <mapper resource="Mapper/IUserDao.xml"/>
    </mappers>
</configuration>

创建log4j.properties文件

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

第四步：创建映射配置文件

IUserDao.xml

<?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 namespace="com.study.dao.IUserDao" resultType="com.study.pojo.User">
    <!--配置查询所有-->
    <select id="findAll">
        select * from user;
    </select>
</mapper>

第五步创建测试类

MybatisTest

/**
 * @author : Ahao
 * @date : 0:00 2020/11/11
 * mybatis的入门案例
 */
public class MybatisTest {
    /**
     * mybatis入门案例
     * @param args
     */
    public static void main(String[] args) throws IOException {
        //1.读取配置文件
        InputStream resource = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        //因为SqlSessionFactory 是一个接口 说明无法new出对象 所以找他的实现类来进行创建
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(resource);
        //3.使用工厂生成SqlSession
        SqlSession sqlSession = factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象
        IUserDao mapper = sqlSession.getMapper(IUserDao.class);
        //5.使用代理对象执行方法
        List<User> all = mapper.findAll();
        for (User user : all){
            System.out.println(user);
        }
        //6.释放资源
        sqlSession.close();
        resource.close();
    }
}

第六步：最终项目结构

在这里插入图片描述

控制台输出

使用注解开发

删除原项目resources mapper文件
修改SqlMapConfig.xml

 <!--指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件
        如果是使用注解来配置的话，此处应该使用class属性指定被注解的dao层全限定类名
    -->
    <mappers>
        <!--使用Mapper.xml <mapper resource="Mapper/IUserDao.xml"/>-->
        <mapper class="com.study.dao.IUserDao"/>
    </mappers>

修改IUserDao 接口

 /**
     * 查询所有操作
     */
    @Select("select * from user")
    List<User> findAll();

自定义mybtis框架

第二天

mybatis基本使用

mybatis的单表curd操作

IUserDao接口新增接口

/**
 * @author : Ahao
 * @date : 23:26 2020/11/10
 *
 * 用户的持久层接口
 */
public interface IUserDao {
    /**
     * 查询所有操作
     */
    List<User> findAll();

    /**
     * 保存用户
     */
    int  saveUser(User user);

    /**
     * 更新用户
     */
    int updateUser(User user);

    /**
     * 根据ID删除
     */
    int deleteUser(Integer id);

    /**
     * 根据Id查询用户信息
     */
    User findById(Integer id);

    /**
     * 根据名称进行模糊查询
     */
    List<User> findByName(String name);

    /**
     * 查询宗用户数
     */
    int findTotal();
}

IUserDao.xml 新增方法以及sql

<?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 namespace="com.study.dao.IUserDao">
    <!--根据ID进行删除-->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id=#{id}
    </delete>

     <!--配置查询所有-->
    <select id="findAll" resultType="com.study.pojo.User">
        select * from user;
    </select>

    <!--根据id查询用户信息-->
    <select id="findById" resultType="com.study.pojo.User" parameterType="java.lang.Integer">
        select * from user where id =#{id};
    </select>

    <!--根据用户名称模糊查询-->
    <select id="findByName" resultType="com.study.pojo.User" parameterType="java.lang.String">
        select * from user where username like #{name}
    </select>

    <!--查询用户总记录数-->
    <select id="findTotal" resultType="java.lang.Integer">
        select count(*) from user;
    </select>

    <!--添加用户-->
    <insert id="saveUser" parameterType="com.study.pojo.User">
        <!--配置插入操作后 返回插入数据的Id -->
        <!--keyProperty id的属性名称  keyColumn数据库的id字段值  resultType返回参数的类型 order在什么时候执行-->
        <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
                select last_insert_id();
        </selectKey>
        insert into  `user` (username,address,sex,birthday) values (#{username},#{address},#{sex},#{birthday});
    </insert>

    <!--更新用户-->
    <update id="updateUser" parameterType="com.study.pojo.User">
        update user set username=#{username},address=#{address},sex=#{sex},birthday=#{birthday} where id =#{id}
    </update>

</mapper>

编写测试类

package com.study.test;

import com.study.dao.IUserDao;
import com.study.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.After;
import org.junit.Before;
import org.junit.Test;

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

/**
 * @author : Ahao
 * @date : 0:00 2020/11/11
 * mybatis的入门案例
 */
public class MybatisTest {

    private SqlSession sqlSession;
    private IUserDao mapper;
    private InputStream in;

    //获取初始文件
    @Before//用于在测试方法执行前执行
    public void init() throws IOException {
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        //因为SqlSessionFactory 是一个接口 说明无法new出对象 所以找他的实现类来进行创建
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生成SqlSession
        sqlSession = factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象
        mapper = sqlSession.getMapper(IUserDao.class);
    }

    //关闭操作
    @After//用于测试方法执行后执行
    public void destroy() throws IOException {
        //提交事务  如果没有会被回滚掉
        sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }
    /**
     * mybatis入门案例
     */
    @Test
    public void findAll(){
        List<User> all = mapper.findAll();
        for (User user : all){
            System.out.println(user);
        }
    }

    @Test
    public void testSave() {
        User user = new User();
        user.setUsername("Ahao");
        user.setAddress("ShangHai");
        user.setBirthday(new Date());
        user.setSex("男");
        mapper.saveUser(user);
        /*//提交事务  如果没有会被回滚掉
        sqlSession.commit();*/
    }

    /**
     * 测试更新操作
     * @throws IOException
     */
    @Test
    public void testupdate() {
        User user = new User();
        user.setId(48);
        user.setUsername("Ahao");
        user.setAddress("ShangHai");
        user.setBirthday(new Date());
        user.setSex("男");
        mapper.updateUser(user);
    }

    /**
     * 根据Id删除用户信息
     */
    @Test
    public  void deleteUser(){
        mapper.deleteUser(48);
    }

    /**
     * 根据id查询用户信息
     */
    @Test
    public void findById(){
        User byId = mapper.findById(49);
        System.out.println(byId);
    }

    /**
     * 根据用户名 进行模糊查询
     */
    @Test
    public void findByName(){
        List<User> byName = mapper.findByName("%王%");
        for (User user : byName){
            System.out.println(user);
        }
    }

    /**
     * 获取用户总数
     */
    @Test
    public void findTotal(){
        int total = mapper.findTotal();
        System.out.println(total);
    }

    /**
     * 返回添加的ID
     * IUserDao.xml 增加 
     * <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
     * 这个标签适用于 修改 删除 添加方法
     */
    @Test
    public void testSave2() {
        User user = new User();
        user.setUsername("Ahao");
        user.setAddress("ShangHai last insert id");
        user.setBirthday(new Date());
        user.setSex("男");
        System.out.println("保存操作之前："+user);
        //保存操作之前：User(id=null, username=Ahao, birthday=Thu Nov 12 23:37:57 CST 2020, sex=男, address=ShangHai last insert id)
        mapper.saveUser(user);
        System.out.println("保存操作之后："+user);
        //保存操作之后：User(id=51, username=Ahao, birthday=Thu Nov 12 23:37:57 CST 2020, sex=男, address=ShangHai last insert id)
    }
}

mybatis的参数和返回值

一、参数

1.parameterType(输入类型)

每个sql,xml 标签里的 parameterType=“传入类型”

2.传递简单类型

与上面相同

3.传递pojo对象

mybatis使用ognl表达式解析对象字段的值，#{}或者${}括号中的值为pojo实体类中的属性名称
OGNL表达式解释

4.传递pojo包装对象(由多个对象组成查询条件)

开发中通过pojo传递查询条件，查询条件是综合的查询条件，不仅包括用户查询条件还包括其他的查询条件（比如将用户购买商品信息也作为查询条件），这是可以使用包装对象传递输入参数。
Pojo类中包含pojo
需求：根据用户名查询用户信息，查询条件放到QuerVo的user属性中。

IUserDao新增接口

 /**
     * 需求：根据用户名查询用户信息，查询条件放到QuerVo的user属性中
     */
    List<User> findUserByVo(QueryVo vo);

QueryVo 实体类在pojo中

/**
 * @author : Ahao
 * @date : 23:58 2020/11/12
 */
@Data
public class QueryVo {
    private User user;
}

IUserDao.xml新增sql

 <!--需求：根据用户名查询用户信息，查询条件放到QuerVo的user属性中-->
    <select id="findUserByVo" resultType="com.study.pojo.User" parameterType="com.study.pojo.QueryVo">
        <!--此时使用QueryVo 里面的user对象获取参数-->
         select * from user where username like #{user.username}
    </select>

测试类新增方法

/**
     * 需求：根据用户名查询用户信息，查询条件放到QuerVo的user属性中
     */
    @Test
    public void findByVo(){
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUsername("%王%");
        vo.setUser(user);

        List<User> userByVo = mapper.findUserByVo(vo);
        for (User u : userByVo){
            System.out.println(u);
        }
    }

二、返回值（结果类型封装）

1.resultType输出简单类型

可以是int，String等等简单的类型

2.resultType输出pojo对象

可以是pojo的对象也是查询一个信息 XX xx

3.resultType输出pojo列表

可以是pojo的列表也是查询多条信息 List

mybatis的dao层编写

mybatis的配置细节

几个标签的使用

第三天

mybatis中的连接池以及事务控制

1.简单介绍一下连接池

连接池就是用于储存连接的一个容器
容器其实就是一个集合对象,该集合对象必须是线程安全的,不能出现两个线程拿到同一个连接。该集合还必须实现队列的特性:先进先出

2.mybatis中的线程池

mybatis连接池提供了三种方式的配置
配置的位置:
主配置文件SqlMapConfig.xml中dataSource标签中type属性就是表示采用那种连接池方式。
type属性的取值:
POOLED 采用传统的javax.sql.DataSource规范中的连接池,mybatis中有针对规范的实现。
UNPOOLED 采用传统的获取连接的方式，虽然也实现Javax.sql.DataSource接口，但是并没有使用池的思想。
JNDI 采用服务器提供的JNDI技术实现，来获取DataSource对象，不同的服务器所能拿到DataSource是不一样。
注意：如果不是web或者maven的war工程，是不能使用的。
我们使用的是tomcat服务器，采用连接池就是dbcp连接池。

mybatis事务控制的分析

06_mybatis中的事务原理和自动提交设置

mybatis基于XML配置的动态Sql语句使用

mappers配置文件中的几个标签
if where foreach sql

mybatis的多表查询

首先严谨来说一下表之间的关系有一下:

关系	描述
一对多	用户和订单
多对一	订单和用户
一对一	人和身份证号
多对多	学生和老师

特例: 如果拿出每一个订单,他都只属于一个用户。所以mybatis就把多对一看做了一对一。

一对一

示例: 用户和账户
一个用户可以有多个账户
一个账户只能属于一个用户(多个账户可以属于通一个用户)
步骤

1.建立两张表:用户表, 账户表

让用户表和账户表之间具备一对多的关系: 需要使用外键在账户表中添加

用户表就是user不需要重新添加

DROP TABLE IF EXISTS `account`;

CREATE TABLE `account` (
  `ID` int(11) NOT NULL COMMENT '编号',
  `UID` int(11) default NULL COMMENT '用户编号',
  `MONEY` double default NULL COMMENT '金额',
  PRIMARY KEY  (`ID`),
  KEY `FK_Reference_8` (`UID`),
  CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;


insert  into `account`(`ID`,`UID`,`MONEY`) values (1,46,1000),(2,45,1000),(3,46,2000);

2.建立两个实体类:用户实体类和账户实体类

让用户和账户的实体类能体现出一对多的关系

创建账户实体类

/**
 * @author : Ahao
 * @date : 23:56 2020/11/17
 */
@Data
public class Acount implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;

}

创建用户实体类

/**
 * @author : Ahao
 * @date : 23:18 2020/11/10
 * 用户实体类
 */
@Getter
@Setter
@ToString
public class User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
}

3.建立两个配置文件

用户的配置文件
账户的配置文件

<!--指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件-->
    <mappers>
    	<!--用户配置文件位置-->
        <mapper resource="Mapper/IUserDao.xml"/>
        <!--账户配置文件位置-->
        <mapper resource="Mapper/IAcountDao.xml"/>
    </mappers>

创建IAcountDao接口

/**
 * @author : Ahao
 * @date : 23:57 2020/11/17
 */
public interface IAcountDao {
    /**
     * 测试Acount 环境搭建用例
     */
    List<Acount> findAll();
}

创建AcountDao.xml

<?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 namespace="com.study.dao.IAcountDao">

    <!--测试Acount 环境搭建用例-->
    <select id="findAll" resultType="com.study.pojo.Acount">
         select * from account
    </select>
</mapper>

创建UsertDao.xml

<?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 namespace="com.study.dao.IUserDao">

</mapper>

创建AcountTest测试类测试环境是否搭建成功

/**
 * @author : Ahao
 * @date : 0:00 2020/11/11
 * mybatis的入门案例
 */
public class AcountTest {

    private SqlSession sqlSession;
    private IAcountDao mapper;
    private InputStream in;

    //获取初始文件
    @Before//用于在测试方法执行前执行
    public void init() throws IOException {
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        //因为SqlSessionFactory 是一个接口 说明无法new出对象 所以找他的实现类来进行创建
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生成SqlSession
        sqlSession = factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象
        mapper = sqlSession.getMapper(IAcountDao.class);
    }

    //关闭操作
    @After//用于测试方法执行后执行
    public void destroy() throws IOException {
        //提交事务  如果没有会被回滚掉
        sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }

    /**
     * 测试Acount 环境搭建用例
     */
    @Test
    public void findAll(){
        List<Acount> all = mapper.findAll();
        all.forEach((as)->{
            System.out.println(as);
        });
    }
}

一对一的配置:通过重写子类的方式

一对一当我们查询用户时,可以同时得到用户下所包含的账户信息

目前的实体类是无法满足我们的需求的所以新建AcountUser实体类继承Acount实体类重新ToString方法注意返回值要使用super引用父类的属性

/**
 * @author : Ahao
 * @date : 23:59 2020/11/19
 */
@Data
public class AcountUser extends Acount {
    private String username;
    private String address;
    private String sex;
    private String birthday;

    @Override
    public String toString() {
        return super.toString()+"   AcountUser{" +
                "username='" + username + '\'' +
                ", address='" + address + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday='" + birthday + '\'' +
                '}';
    }
}

IAcountDao 新增接口findByOneToOne

	/**
     * 一对一操作
     * 一对一的配置:通过重写子类的方式
     * 查询所有账户,同时获取当前用户信息
     */
    List<AcountUser> findByOneToOne();

IAcountDao.xml新增findByOneToOne 方法

<!-- 一对一操作   查询所有账户,同时获取当前用户信息 -->
    <select id="findByOneToOne" resultType="com.study.pojo.AcountUser">
         select u.*,a.ID as aid,a.UID as uid ,a.MONEY money from account a,user u where u.id=a.uid
    </select>

test/java/下新增OneToOneTest 测试类

/**
 * @author : Ahao
 * @date : 23:22 2020/11/19
 * 一对一案例
 */
public class OneToOneTest {

    private SqlSession sqlSession;
    private IAcountDao mapper;
    private InputStream in;

    //获取初始文件
    @Before//用于在测试方法执行前执行
    public void init() throws IOException {
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        //因为SqlSessionFactory 是一个接口 说明无法new出对象 所以找他的实现类来进行创建
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生成SqlSession
        sqlSession = factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象
        mapper = sqlSession.getMapper(IAcountDao.class);
    }

    //关闭操作
    @After//用于测试方法执行后执行
    public void destroy() throws IOException {
        //提交事务  如果没有会被回滚掉
        sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }

    /**
     * 一对一操作
     * 查询所有账户,同时获取当前用户信息
     */
    @Test
    public void findAll(){
        List<AcountUser> all = mapper.findByOneToOne();
        all.forEach((al)->{
            System.out.println(al);
        });
    }
}
此时运行得到结果 
Acount(id=41, uid=41, money=1000.0)   AcountUser{username='老王', address='北京', sex='男', birthday='2018-02-27 17:47:08'}
Acount(id=45, uid=45, money=1000.0)   AcountUser{username='传智播客', address='北京金燕龙', sex='男', birthday='2018-03-04 12:04:06'}
Acount(id=41, uid=41, money=2000.0)   AcountUser{username='老王', address='北京', sex='男', birthday='2018-02-27 17:47:08'}

根据结果可以看到 一个账户信息对应一个用户

一对一的配置:建立实体类关系的方式

从表实体应该包含一个主表实体的对象引用
Acount实体类新增 User 对象

/**
 * @author : Ahao
 * @date : 23:56 2020/11/17
 */
@Getter
@Setter
@ToString
public class Acount implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;

    private User user;
}

IAcountDao 新增findByOneToOne2 接口

 /**
     * 一对一操作
     * 一对一的配置:建立实体类关系的方式
     * 查询所有账户,同时获取当前用户信息
     */
    List<Acount> findByOneToOne2();

IAcountDao.xml新增方法和resultMap

<!--定义封装的account 和user的返回实体类resultMap -->
    <resultMap id="accountUserMap" type="com.study.pojo.Acount">
        <id property="id" column="aid"/>
        <result property="uid" column="uid"/>
        <result property="money" column="moeny"/>
        <association property="user" column="uid" javaType="com.study.pojo.User">
            <result property="id" column="id"/>
            <result property="username" column="username"></result>
            <result property="address" column="address"></result>
            <result property="sex" column="sex"></result>
            <result property="birthday" column="birthday"></result>
        </association>
    </resultMap>
    <!--一对一操作  一对一的配置:建立实体类关系的方式查询所有账户,同时获取当前用户信息-->
    <select id="findByOneToOne2" resultMap="accountUserMap">
        select u.*,a.ID as aid,a.UID as uid,a.MONEY moeny from account a,`user` u where a.UID = u.id
    </select>

OneToOneTest测试类新增测试方法 findByOneToOne2

/**
     * 一对一操作
     * 一对一的配置:建立实体类关系的方式
     * 查询所有账户,同时获取当前用户信息
     */
    @Test
    public void findByOneToOne2(){
        List<Acount> all = mapper.findByOneToOne2();
        all.forEach((al)->{
            System.out.println(al);
        });
    }
此时运行得到结果 
Acount(id=1, uid=41, money=1000.0, user=User(id=41, username=老王, birthday=Tue Feb 27 17:47:08 CST 2018, sex=男, address=北京))
Acount(id=2, uid=45, money=1000.0, user=User(id=45, username=传智播客, birthday=Sun Mar 04 12:04:06 CST 2018, sex=男, address=北京金燕龙))
Acount(id=3, uid=41, money=2000.0, user=User(id=41, username=老王, birthday=Tue Feb 27 17:47:08 CST 2018, sex=男, address=北京))
根据结果可以看到 一个账户信息对应一个用户

1414141414141414141414141414141414141414141414141414

第四天

mybatis对的缓存和注解开发

mybatis中的加载时机（查询的时机）

mybatis中的一级缓存和二级缓存

mybatis的注解开发

单表CRUD

多表查询

问题解决

1.解决实体类属性和数据库列名不对应的方式

1.sql语句设置别名

 <!--id,username,address,sex,birthday 字段为数据库列名-->
 <!--userId,userName,userAddress,userSex,userBirthay 字段为实体类属性-->
select id as userId,username as userName,address as userAddress,sex as userSex,birthday as userBirthay frin user;

2.使用resultMap配置对应关系

<!--配置 查询结果的列名和实体类属性名的对应关系-->
    <resultMap id="userMap" type="com.study.pojo.User">
        <!--主键字段的对应-->
        <id property="id" column="id"></id>
        <!--property 实体类属性名 column数据库列名-->
        <result property="username" column="userName"></result>
        <result property="address" column="userAddress"></result>
        <result property="sex" column="userSex"></result>
        <result property="birthday" column="userBirthday"></result>
    </resultMap>
    <!--配置查询所有-->
    <select id="findAll" resultMap="userMap">
        select * from user;
    </select>

今天更博学了吗

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
3
评论
Mybatis的学习总结

Mybatis第一天mybatis入门mybatis的概述mybatis的环境搭建第一步：创建maven工程并导入坐标第二步：创建实体类和Dao接口第三步：创建Mybatis的主配置文件SqlMapConfig.xml第四步：创建映射配置文件IUserDao.xml第五步：最终项目结构mybatis的入门案例自定义mybtis框架第二天mybatis基本使用mybatis的单表curd操作mybatis的参数和返回值mybatis的dao层编写mybatis的配置细节几个标签的使用第三天mybatis的深入
复制链接

扫一扫