基于MyBatis注解的学生管理程序--mybatis注解开发的练手项目

基于MyBatis注解的学生管理程序

需求：完成基于MyBatis注解的学生管理程序，能够用MyBatis注解实现查询操作、实现修改操作、实现一对多查询

（1）MyBatis注解开发实现查询操作。根据表1和表2在数据库分别创建一个学生表tb_student和一个班级表tb_class， 并查询id为2的学生的信息。

​ 图：表1

​ 图：表2

其中tb_student表中的 class_id 列将引用 tb_class 表的 id 列作为外键。

（2）MyBatis注解实现修改操作。修改id为4的学生的姓名修改为迪卢克，年龄修改为21。

（3）MyBatis注解实现一对多查询。查询出二班所有学生的信息。

---

实际开发步骤

①数据库准备：

#创建数据库
create database studentprogram;

#创建tb_class表
create table tb_class(
	id int(32) PRIMARY KEY AUTO_INCREMENT,
	classname varchar(40)
);

#往tb_class表中插入数据
insert into tb_class values(1,'一班');
insert into tb_class values(2,'二班');

#创建tb_student表
create table tb_student(
studentid int(32) PRIMARY KEY AUTO_INCREMENT,
studentname CHARACTER(40) NOT NULL,
age int(4) NOT NULL,
class_id int(32) NOT NULL,
FOREIGN KEY(class_id) REFERENCES tb_class(id)
);

#往tb_student表中插入数据
insert into tb_student VALUES(1,' Steve','20','1'),(2,'SteveDash','18','1'),(3,'Kdash','20','2'),(4,'Shy','19','2');

②idea中使用maven方式创建java项目，pom中引入依赖

 <dependencies>
        <!-- MySQL Connector Java 引入java链接MySQL的依赖 -->
        <dependency>
            <groupId>mysql</groupId> <!-- 依赖名 -->
            <artifactId>mysql-connector-java</artifactId> <!-- 组件名 ID -->
            <version>8.0.11</version> <!-- 版本号 -->
        </dependency>
        <!-- 其他依赖项 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>

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

        <!--引入log4j日志包-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>

        <!-- Mockito 依赖 -->
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <version>4.0.0</version>
            <scope>test</scope>
        </dependency>

    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                    <include>mapper/PasswordMSMapper.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

③创建好依赖的配置文件：mybatis-config.xml(Mybatis配置文件)、log4j.properties(log4j日志配置文件)、db.properties(数据库连接配置文件)具体代码如下：

mybatis-config.xml(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>
    <!-- 环境配置 -->
    <!-- 加载类路径下的属性文件 -->
    <properties resource="db.properties"/>

    <settings>
        <!-- resultMap开启自动映射，不需要列出所有字段名-->
        <setting name="autoMappingBehavior" value="FULL" />
        <!--开启mybatis的二级缓存，提高多表关联查询的效率-->
        <setting name="cacheEnabled" value="true"/>
        <!--开启延迟加载开关-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!--将积极加载改为消息加载，按需加载-->
       <setting name="aggressiveLazyLoading" value="false"/>

    </settings>

    <!-- 设置别名 -->
    <typeAliases>
        <package name="pojo"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <!-- 数据库连接相关配置 ,db.properties文件中的内容-->
            <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>

    <!-- mapping文件路径配置 -->

    <mappers>
        <mapper class="dao.TbStudentMapper"/>
        <mapper class="dao.TbClassMapper"/>

    </mappers>


</configuration>

log4j.properties：

###\u6839logger\u8BBE\u7F6E###
log4j.rootLogger = debug,console,file

###
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.Threshold = DEBUG 
log4j.logger.java.sql.Statement=debug 
log4j.appender.console.layout.ConversionPattern = [%p] %d %c - %m%n

###
log4j.appender.file = org.apache.log4j.DailyRollingFileAppender
###
log4j.appender.file.File = D:/log/studentprogram.log
log4j.appender.file.Append = true
log4j.appender.file.Threshold = warn 
log4j.appender.file.layout = org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern = [%p] %d %c - %m%n

db.properties:

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/studentprogram?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
username=root
password=root

④创建自己的工具包通用工具类utils包下的MyBatisUtil.java

package utils;

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 java.io.IOException;
import java.io.InputStream;

public class MyBatisUtil {
    private static SqlSessionFactory factory;

    static{在静态代码块中，factory只会被创建一次
        System.out.println("static factory===============");
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            factory = new SqlSessionFactoryBuilder().build(is);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static SqlSession createSqlSession(){
        return factory.openSession(false);//true为自动提交事务
    }

    public static void closeSqlSession(SqlSession sqlSession){
        if(null != sqlSession)
            sqlSession.close();
    }
}

⑤在java-pojo包下，链接数据库生成pojo类。

​ 这里就不讲了，只放图，前面的文章有介绍如何生成pojo类，这里讲的是需要做的修改，因为涉及到一对多的操作，我们需要在实体类中做一些修改。

TbStudent.java

​ 在 MyBatis 中，pojo类中的属性名通常需要与数据库表的列名一致，但并不是绝对必须要一致。这是因为 MyBatis 通过映射配置文件或注解来将数据库表的列与 Java 对象的属性进行映射，可以通过配置来实现属性名和列名的映射。

如果属性名与列名不一致，我们可以通过 MyBatis 的映射方式来指定属性名和列名的对应关系。这可以通过以下两种方式实现：

1. 映射配置文件方式：在 XML 映射文件中使用 <resultMap> 元素来定义属性名和列名之间的映射关系。

<resultMap id="myResultMap" type="pojo.MyPojo">
    <result property="propertyName" column="column_name"/>
    <!-- 其他属性映射 -->
</resultMap>

2. 注解方式：在使用注解的情况下，可以使用 @Result 注解来指定属性名和列名的映射关系。

@Result(property = "propertyName", column = "column_name")

​ 虽然属性名和列名一致能够简化映射配置，但 MyBatis 提供了灵活的配置选项，可以适应不同的命名约定和需求。

TbClass.java

​ 这里的话，是因为我们等会要满足的需求有一对多，那么我们要确定主表和从表，在主表中添加多一个属性，用来接收多表关联查询的结果private List<TbStudent> studentList;

​ 因为，一个班级里面可以包含多个学生，那么我们就选用班级为主表，因此再里面添加一个属性，用来关联映射接受从表查询出来的学生信息。记得创建完这个属性后还得设置getter和setter方法，供外部访问使用。

---

⑥在java-dao包新建TbClassMapper和TbStudentMapper

TbClassMapper

package dao;

import org.apache.ibatis.annotations.*;
import pojo.TbClass;
import pojo.TbStudent;

import java.util.List;
@Mapper
public interface TbClassMapper {

    @Select("select * from tb_class where id=#{id}")
    @Results({
            @Result(property = "id", column = "id"),
            @Result(property = "classname", column = "classname"),
            @Result(property = "studentList", column = "id", javaType = List.class, many = @Many(select = "dao.TbStudentMapper.findStudentByClass"))})
    TbClass selectAllStudentByClass(Integer id);
}

TbStudentMapper

package dao;

import org.apache.ibatis.annotations.*;
import pojo.TbStudent;

import java.util.List;

public interface TbStudentMapper {
    @Select("select * from tb_student where studentid=#{studentid}")
    TbStudent findStudentById(TbStudent tbStudent);

    @Select("select * from tb_student where class_id=#{class_Id}")
    List<TbStudent> findStudentByClass(Integer id);



    @Update("update tb_student set studentname=#{studentname},age=#{age},class_id=#{class_Id} where studentid=#{studentid}")
    Boolean updateStudent(TbStudent tbStudent);

    @Delete("delete from tb_student where studentid=#{studentid}")
    Boolean deleteStudentById(Integer id);

    @Insert("insert into tb_student(studentname,age,class_id) values(#{studentname},#{age},#{class_Id})")
    @Options(useGeneratedKeys = true,keyColumn = "studentid")
    Boolean insertStudent(TbStudent tbStudent);


}

​ 这里的代码就不解释了，若是有不理解的的，可以根据我的之前发的文章Mybatis的注解开发进行理解，大概就是各自表的增删改查的sql语句。

---

⑦在mybatis-config中引入mapper的地址，使用class方式，因为我们编写的mapper是接口，接口本质上

    </environments>   
	<mappers>
        <mapper class="dao.TbStudentMapper"/>
        <mapper class="dao.TbClassMapper"/>
    </mappers>
</configuration>

​ 在 MyBatis 中，使用 <mapper class="dao.TbClassMapper"/> 的方式是用来指定映射器接口的位置的。这种方式可以用来指定映射器接口的类路径，使得 MyBatis 可以通过扫描指定的包来自动找到映射器接口，并将其注册为映射器。

​ 这种方式的好处是可以更加灵活地组织代码，将映射器接口和对应的 SQL 语句放在同一个类中，便于维护和管理。而传统的 XML 映射器文件需要在配置文件中一个一个地引入，相对比较繁琐。

​ 而且使用 <mapper class="dao.TbClassMapper"/> 方式注册映射器时，MyBatis 会自动将映射器接口与对应的 XML 映射器文件关联起来，前提是接口和 XML 映射器文件位于相同的包路径下，且文件名相同（但后缀为 .xml）。这种关联方式可以使得我们在映射器接口中使用注解或 XML 配置来定义 SQL 映射关系。

---

⑧接下来就是编写测试类了，进行测试看看是否满足需求？

TbClassTest

package Test;

import dao.TbClassMapper;
import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.jupiter.api.Test;
import pojo.TbClass;
import pojo.TbStudent;
import utils.MyBatisUtil;

import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

class TbClassTest {
    private Logger logger= Logger.getLogger(TbClassTest.class);
    
    /*
    一对多关联查询，根据班级id查询出所有的学生
     */
    @Test
    void getId() {
        SqlSession session= MyBatisUtil.createSqlSession();


        TbClass tbClass= session.getMapper(dao.TbClassMapper.class).selectAllStudentByClass(2);
        List<TbStudent> tbStudents=tbClass.getStudentList();
        for(TbStudent tbStudent:tbStudents){
            logger.info("学生id："+tbStudent.getStudentid()+"，学生姓名："+tbStudent.getStudentname()+"，年龄:"+tbStudent.getAge()+"，班级："+tbClass.getClassname());
    }
        session.close();
    }
}

TbStudentTest

package Test;

import dao.TbStudentMapper;
import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.jupiter.api.Test;
import pojo.TbStudent;
import utils.MyBatisUtil;

import static org.junit.jupiter.api.Assertions.*;

class TbStudentTest {
    private Logger logger = Logger.getLogger(TbStudentTest.class);

    /*
    根据id进行学生数据更新，
    必须得几个信息都填入才会更新，
     */
    @Test
    void updateStudentByid() {
        SqlSession session = MyBatisUtil.createSqlSession();

        TbStudent tbStudent = new TbStudent();
        tbStudent.setStudentid(1);
        tbStudent.setStudentname("Stevedash");
        tbStudent.setAge(20);
        tbStudent.setClass_Id(2);
        logger.info(session.getMapper(TbStudentMapper.class).updateStudent(tbStudent));
        session.commit();
        session.close();
    }

    /*
    插入新的信息
     */
    @Test
  void insertStudent() {
        SqlSession session = MyBatisUtil.createSqlSession();
        TbStudent tbStudent = new TbStudent();
        tbStudent.setStudentname("王帅B");
        tbStudent.setAge(23);
        tbStudent.setClass_Id(1);
        Boolean result = session.getMapper(dao.TbStudentMapper.class).insertStudent(tbStudent);

        if (result != false) {
            logger.info("数据插入成功！");
            session.commit();
            session.close();
        } else {
            logger.info("数据插入失败");
        }
    }
}

输出结果如下：

一对多关联查询获取所有2班的同学

---

总结

​ 本文主要讲解了MyBatis的注解开发的实例。常用注解，包括@Select注解、@Insert注解、@Update注解、@Delete注解、@Param注解等；然后编写基于注解的关联查询，一对多查询，通过学习可以了解MyBatis中常用注解的主要作用，并能够掌握这些注解在实际开发中的应用。在MyBatis框架中，这些注解十分重要，熟练的掌握它们能够极大的提高开发效率。

​ 想要跟着学习的可以去我的资源里面找对应的文件下载，我的md文件也会发上去，项目文件会上传可以自己跟着学习一下。

作者：Stevedash

发表于：2023年8月29日 10点34分

注：本文内容基于个人学习理解，如有错误或疏漏，欢迎指正。感谢阅读！如果觉得有帮助，请点赞和分享。