Mybatis结合实体对象映射类的demo(较为深入)

FBCD1012

已于 2023-04-14 19:00:49 修改

阅读量242

点赞数 3

分类专栏：我的demo 文章标签： mybatis 数据库 mysql

于 2023-04-13 20:48:04 首次发布

本文链接：https://blog.csdn.net/dq3335/article/details/130139797

版权

我的demo 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

前置：Mybatis创建数据库连接对象的过程
1. 首先定义sqlSessionFactoryBuilder
2. 利用Builder创建一个sqlSessionFactory对象
3. 然后利用工厂类创建多个数据库连接对象
- 如图你可以理解其中的流程，整体就是如此的

在这里插入图片描述

对了，这里的sqlsession对象就是关联其中的数据库操作理解的，可以进行一系列的sql语句操作

大致逻辑梳理清楚了，下面直接上代码
这是一个工具类：工具类的思想，将一系列具备重复操作的代码封装到一个类中，这样降低了代码的冗余性，同时也增加了代码的复用性质，降低了耦合度，无论你是用什么语言编写，这种面向对象的思维是值得去学习的！

package Utils;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class mybatisUtils {
     private  static SqlSessionFactory sqlSessionFactory;
     static {
         try {
                 sqlSessionFactory=new SqlSessionFactoryBuilder().build(
                         new FileInputStream("mybatisConfig.xml")
                 );
             } catch (FileNotFoundException e) {
                 throw new RuntimeException(e);
         }
     }
     public static SqlSession setAutoCommitted(boolean commitType){
         return sqlSessionFactory.openSession(commitType);
     }
}

关于代码中的很多语法知识关联
1. 静态代码块（类加载的时候就自动调用代码块中的方法，或者初始化静态代码块中的变量）
2. 文件io读取（这里一般是读取xml文件，来对xml配置文件进行非常优质的理解操作）
3. 工厂常量（便于上下文进行工厂中的数据库对象处理）
语法关联结束之后，下面我就要讲Mybatis中最重头戏的方式，使用xml配置参数以及映射配置

采用mybatis官网的config文件配置

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  </mappers>
</configuration>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://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.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/diffculetymybatistest"/>
                <property name="username" value="root"/>
                <property name="password" value="FBCD"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper url="file:pockerMapper.xml"/>
        <mapper url="file:teacherMapper.xml"/>
        <mapper url="file:studentMapper.xml"/>
    </mappers>
</configuration>

environments 定义不同主机的相关参数环境，注意，这里default 以及id 参数标签必须是一致的
propety 设置连接数据库的几大参数值
1. driverName：数据库驱动(注意这里mysql8之后就是用cj了之前的驱动已经失效且弃用了)
2. url：网络连接数据库端口操作
3. username：数据库用户名称
4. password:数据库密码操作理解（千万需要明确）
transactionManager 事务底层默认的数据库管理这里是jdbc来进行操作的，不同的orm可能会产生不一样的操做理解
dataSource 数据源定义（这里使用的是池化技术）一般就是数据源定义
- 关于一些池化技术的理解，将多个数据源放置在一个数据池中，这样可以减少相关的数据连接载荷，以至于后续可以非常优质的对数据库连接进行操作，还有就是这种理解对于数据库缓冲也是非常优质的技术之一！
- 当数据库非常少的时候我还是不建议你去使用这种技术，毕竟还是非常消耗计算机资源的
- 你可以对参数进行池化取消，数据源这种方式在之前深入学习的时候就已经了解了
mappers : mybatis 中非常特色的技术，通过xml来对对象进行配置，简化开发，同时对于数据映射弱化了代码设置

讲解了最基本的配置文件之后：

下面我们继续深入，基础对数据库进行了连接之后，那么我们应该怎么做呢？下面有请读者进行思索一下

那当然是对数据库中的数据进行java操作的配置，你单纯使用数据库肯定无法进行java的逻辑操作，他始终是持久层的理解

一般我们都是会创建多个对象来进行数据库中的映射

我创建了两张存在联系的表

在这里插入图片描述

细心的读者肯定看的出来.这其实是扑克表主要是使用灵感比较高而已

然后就进行Java对象映射了

这些对象还是比较简单的，如果读者觉得可以产生复杂理解还是可以对上述进行拓展

package POJO;


import lombok.Data;

@Data
public class pocker {
    String cardType;
    Integer cardSum;
}

package POJO;


import lombok.Data;

import java.util.List;

@Data
public class pockers {
    String cardType;
    String cardValue;
    List<pocker>  listPocker;
//    public pockers(String cardType,String cardValue){
//        this.cardType=cardType+"---------------";
//        this.cardValue=cardValue+"----------------";
//    }
}

对了，我这里使用了lombok语法操作至于什么是lombok后续我还是发一篇文章操作

对象创建完毕了之后我们应该如何去增加我们的数据库逻辑操作呢？

创建映射接口！猜对了吗？

package PojoMapper;

import POJO.Student;
import POJO.teacher;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface studentMapper {
    List<teacher> Teacherlist();
    int insertTeacher(@Param("teachId") Integer teacherId,
                      @Param("subject") String subject,
                      @Param("studentId") Integer studentId);
    List<teacher> studentList();
}

package PojoMapper;

import org.apache.ibatis.annotations.Param;

public interface teacherMapper {
    int insertStudent(@Param("studentId") Integer studentId,
                      @Param("teachid") Integer teachid,
                      @Param("studentName") String studentName);
}

对了，为什么这里需要增加@param注解了，这里我先买一个关子QAQ

ok 读者你再一次梳理一下你的逻辑链路，现在我们数据库已经连接了操作逻辑以及对象映射也实现了最终如何将3者联系起来呢？

其实这里还是得使用Mybatis中最优质的方式，使用xml来配置连接，也就是将一系列的操作进行合并

ok,下面创建两种映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="PojoMapper.mapper">
    <resultMap id="pocker" type="POJO.pockers">
        <result column="TYPE" property="cardType"/>
        <result column="VALUE" property="cardValue"/>
        <collection property="listPocker" ofType="POJO.pocker">
            <id column="cardType" property="cardType"/>
            <result column="cardsum" property="cardSum"/>
        </collection>
    </resultMap>
    <select resultType="POJO.pockers" id="selectThings"  resultMap="pocker">
       select * from pockers
    </select>
    <select id="selectToChoseTypes"  resultType="POJO.pockers">
        select  * from pockers where cardType=#{cardType}
    </select>
    <select id="selectToChoseValues"  resultType="POJO.pockers" >
        select  * from  pockers where cardType=#{cardValue}
    </select>
    <insert id="insertCards" parameterType="string">
        insert into pockers (cardType,cardValue) values(#{cardType},#{cardValue})
    </insert>
    <select id="counter" parameterType="string" resultType="java.lang.Integer">
        select  count(*)  from  pockers  where cardValue=#{cardValue}
    </select>
    <select id="selectNumbers" resultType="POJO.pockers" resultMap="pocker">
        SELECT DISTINCT
            p.cardType AS TYPE,
            po.cardValue AS VALUE,
            p.*
        FROM
            pocker AS p
        INNER JOIN
            pockers AS po
        ON
            p.cardType=po.cardType
    </select>
</mapper>

这里对其中的Mybatis中的对应标签结合接口进行操作，增删改查十八般武艺比比皆是

你看其中是不是直接进行了逻辑处理操作呢？使用增删改查逻辑对参数进行理解，这里使用筛选的方法传递参数又如何理解呢？

翻看前面，你就会发现这里的参数是需要和你实体类中注解操作联系起来的，如果你不进行书写，会直接报错喔！数据库找不到参数

下面你就可以对你的对象直接操作了

package mybatisTest;

import org.apache.ibatis.session.SqlSession;
import POJO.pockers;
import PojoMapper.mapper;
import Utils.mybatisUtils;

import java.util.List;

public class mybatisTest {
    static String cardType []={"spade","heart","club","dimond"};
    static String cardValue []={"7","8","9","10","j","q","k"};
    static String theJocker [] ={"sjocker","bjocker"};
    public static void main(String[] args) {
        try(SqlSession session= mybatisUtils.setAutoCommitted(true)) {
            mapper mapper = session.getMapper(mapper.class);
//            List<pockers> pockers =mapper.selectThings();
//            pockers.forEach(System.out::println);
//            System.out.println(mapper.counter("A"));
//            List<POJO.pockers> pockers1 = mapper.selectNumbers();
//            pockers1.forEach(System.out::println);
//            List<pockers> pockers = mapper.selectThings();
//            pockers.forEach(System.out::println);
            List<pockers> pockers = mapper.selectNumbers();
            pockers.forEach(System.out::println);
//            for (int i = 0; i <cardValue.length; i++) {
//                for (int j = 0; j <cardType.length; j++) {
//                    //如何切换一种循环理解？
//                    mapper.insertCards(cardType[j],cardValue[i]);
//                }
//            }
//            mapper.insertCards("blackjocker",theJocker[0]);
//            mapper.insertCards("colorjocker",theJocker[1]);
        }
    }
}

关于为什么使用映射类操作？主要是这里进行反射处理，利用反射可以直接将对象的参数利用接口来进行实现，同时这里也可以实现对象的创建理解，如何处理此处还是必要的

如图所示：运行结果如下

在这里插入图片描述

还有就是关于为什么我这里是用了对象嵌套，这就需要使用mapper里面来操作了

    <resultMap id="pocker" type="POJO.pockers">
        <result column="TYPE" property="cardType"/>
        <result column="VALUE" property="cardValue"/>
        <collection property="listPocker" ofType="POJO.pocker">
            <id column="cardType" property="cardType"/>
            <result column="cardsum" property="cardSum"/>
        </collection>
    </resultMap>