[一点笔记]Mybatis配置及sql操作（一）

最新推荐文章于 2024-10-18 19:46:57 发布
原创 最新推荐文章于 2024-10-18 19:46:57 发布 · 412 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#mysql #mybatis #java #maven

这篇博客记录了在maven项目中使用Mybatis进行数据库操作的学习过程，包括全局配置、映射文件的配置，涉及增删改查操作，深入讲解了select、resultMap、association、collection、discriminator等标签的用法，以及返回类型封装、自定义映射规则、关联查询、级联封装、分步查询和延迟加载等高级特性。详细内容见代码注释和项目结构解析。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

创建maven项目进行的mybatis相关知识学习，包括：

  mybatis全局配置
  mybatis映射文件配置与增删改查
  mybatis映射文件select、resoultmap、association、collection、discriminator标签
  mybatis返回类型封装、自定义映射规则、关联查询、级联封装、分步查询、延迟加载

#说明见代码中注释
项目结构如图：
在这里插入图片描述

mybatis-config

<?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：引入类路径下资源
        url：引入网络路径或磁盘路径资源
        -->
    <properties resource="dbcconfig.properties"></properties>

    <!--设置每一个项设置值
    name：项名
    value：值-->
    <!--开启驼峰命名-->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--懒加载，所有值在使用时被检索-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!--关闭时检索的内容中被使用的部分在调用时才被加载-->
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

    <!--typeAliases为某个java类起别名(别名不区分大小写)
    在类中可以使用@Alias（""）注解起别名
    默认全小写，
    alias：指定新别名-->
    <typeAliases>
        <typeAlias type="com.model.User" alias="usr"/>
        <!--批量起别名
        package为某个包下所有类批量起名
        name:指定包名，为当前包以及下面所有的后代包的每一个类都起一个默认包名（别名为类名小写）-->
        <!--<package name="com.model"/>-->
    </typeAliases>

    <environments default="development">
        <!--配置环境default指定某种环境
            environment配置具体环境必须有两个标签id表示当前环境标识
                transactionManager：事务管理器
                    type：事务管理器类型；JDBC(JdbcTransactionFactory)|MANAGED(ManagedTransactionFactory)
                dataSource：数据源
                    type：数据源类型；UNPOOLED（UnpooledDataSourceFactory）|POOLED（PooledDataSourceFactory）|JNDI（JndiDataSourceFactory）
                        默认为POOLED
                    自定义数据源：实现DataSourceFactory接口-->
        <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>
    <mappers>
        <!--mapper：注册SQL映射文件
            注册配置文件
            resource：引用类路径下的sql映射文件
            url（完全限定资源定位符）：引用网络或磁盘路径下的sql映射
                <mapper url="file:///var/mappers/AuthorMapper.xml"/>
            注册接口
            class：使用映射器接口实现类的完全限定类名
                需求1）有sql映射文件.xml，并且与接口放在同一目录下
                    2）没有sql映射文件，所有sql用注解写在接口上（不推荐）
            package：批量注册-->
        <mapper resource="mapper.xml"/>
        <mapper resource="jobmapper.xml"/>
    </mappers>
</configuration>

mapper

<?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.model.UserMapper">
    <!--Mybatis传参时，
        单个参数可以随意取名
        多个参数时会被封装成一个map
             [arg1, arg0, param1, param2]
             表示1：
             key:param1。。。paramN;使用参数索引取值
             value：传入的参数值
             表示2：
             key:在接口中使用@Param标签明确指定value名称
             value：传入的参数值
            #{}从map中获取指定的key值
            表示3：
            使用pojo中的属性值
            表示4：
            传入map
        #{}:以预编译的形式将参数设置到sql语句中PreparedStatement
        ${}:取出的值直接拼装在sql语句中
            -->
    <select id="getUserById" resultType="usr">
        SELECT * FROM user WHERE ID = #{ID}
    </select>

    <select id="bufferedGetUser" resultType="usr">
        SELECT * FROM user WHERE ID = ${id} AND username = ${"username"}
        <!--SELECT * FROM user WHERE ID = #{id} AND username = #{username}-->
    </select>

    <!--自定义封装规则
        使用id标签定义主键会有底层优化
        type：自定义规则的Java类型
        id：唯一id方便引用-->
    <resultMap id="Myusr" type="usr">
        <!--指定主键列的封装规则
            column：指定数据库中的列
            property：指定对应javabean属性-->
        <id column="ID" property="ID"/>
        <!--定义普通列封装-->
        <result column="username" property="username"/>
        <result column="password" property="password"/>
    </resultMap>

    <select id="getUserLikeName" resultMap="Myusr">
        SELECT * FROM user WHERE username LIKE #{username}
    </select>

    <!--联合查询
        同时查询个人信息和职业
        对应表：
        | ID | username | password | jobid | job  |-->
    <resultMap id="usrjob" type="usr">
        <id column="ID" property="ID"/>
        <result column="username" property="username"/>
        <result column="password" property="password"/>
        <result column="jobid" property="job.ID"/>
        <result column="job" property="job.jobName"/>
    </resultMap>
    <select id="getUserAndJob" resultMap="usrjob">
        select u.ID,u.username,u.password,u.j_ID jobid,j.job_name job FROM user u,job j WHERE u.j_ID=j.ID AND u.ID=#{id};
    </select>

    <!--resultmap 中使用association实现分步查询-->
    <resultMap id="userjobByStep" type="usr">
        <id column="ID" property="ID"/>
        <result column="username" property="username"/>
        <result column="password" property="password"/>
        <!--association用于定义对象
            column="j_ID"
            column="{id=j_ID}"都可以
            fetchType="lazy"表示延迟加载，-->
        <association property="job" select="com.model.JobMapper.getJobByID" column="{id=j_ID}" fetchType="lazy"/>
    </resultMap>
    <select id="getUserJobByStep" resultMap="userjobByStep">
        SELECT * FROM user WHERE ID = #{id}
    </select>

    <!--discriminator
        鉴别器：用于判断某列的值，然后根据某列的值改变封装行为-->
    <resultMap id="userDis" type="usr">
        <id column="ID" property="ID"/>
        <result column="username" property="username"/>
        <result column="password" property="password"/>
        <!--column:指定判定的类名
            javaType：列值对应的java类型-->
        <discriminator javaType="string" column="username">
            <!--resultType:指定封装结果类型，不能缺少。resltType/resultMap二选一-->
            <case value="kk" resultType="usr">
                <association property="job" select="com.model.JobMapper.getJobByID" column="{id=j_ID}" fetchType="lazy"/>
            </case>
        </discriminator>
    </resultMap>
    <!--parameterType:参数类型（可省略）
        useGeneratedKeys="true" 使用自增主键获取主键值策略
        keyProperty 指定对应的主键，MyBatis获取追主键值后将这个值赋给javaBean的哪个主键
        -->
    <insert id="addUser" useGeneratedKeys="true" keyProperty="ID">
        INSERT INTO user(username,password) VALUES(#{username},#{password})
    </insert>

    <update id="updateUser">
        UPDATE user SET username=#{username},password=#{password} WHERE ID=#{ID}
    </update>

    <delete id="deleteUserById">
        DELETE FROM user WHERE ID=#{id}
    </delete>
</mapper>

jobmapper

<?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.model.JobMapper">
    <select id="getJobByID" resultType="com.model.Job">
        SELECT ID,job_name jobName FROM job WHERE ID=#{id}
    </select>

    <!--| ID | username | J_ID | jid  | job_name |-->
    <resultMap id="job" type="com.model.Job">
        <id column="jid" property="ID"/>
        <result column="job_name" property="jobName"/>
        <!--collection用于定义集合类型的属性封装规则
            oftype:指定集合里面元素类型-->
        <collection property="users" ofType="com.model.User">
            <!--定义集合内封装规则-->
            <id column="ID" property="ID"/>
            <result column="username" property="username"/>
            <result column="J_ID" property="j_ID"/>
        </collection>
    </resultMap>
    <select id="getUserjobByID" resultMap="job">
        SELECT u.ID,u.username,u.J_ID,j.ID jid,j.job_name FROM job j LEFT JOIN user u ON u.j_ID=1 AND u.j_ID=j.ID WHERE u.j_ID=#{id}
    </select>
</mapper>

dbcconfig.properties

jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/mybatis_1?serverTimezone=UTC
jdbc.username = root
jdbc.password = 123456

Job

package com.model;

import java.util.List;

public class Job {
    private Integer ID;
    private String jobName;
    private List<User> users;

    public Integer getID() {
        return ID;
    }

    public void setID(Integer ID) {
        this.ID = ID;
    }

    public String getJobName() {
        return jobName;
    }

    public void setJobName(String jobName) {
        this.jobName = jobName;
    }

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

    @Override
    public String toString() {
        return "Job{" +
                "ID=" + ID +
                ", jobName='" + jobName + '\'' +
                '}';
    }
}

Jobmapper

package com.model;

import java.util.List;

public interface JobMapper {

    Job getJobByID(Integer id);

    Job getUserjobByID(Integer id);
}

User

package com.model;

import java.io.Serializable;

public class User implements Serializable{
    private Integer ID;
    private String username;
    private int password;
    private Integer j_ID;
    private Job job;

    public User() {
    }

    public User(Integer ID, String username, int password) {
        this.ID = ID;
        this.username = username;
        this.password = password;
    }

    public Integer getID() {
        return ID;
    }

    public void setID(int ID) {
        this.ID = ID;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getPassword() {
        return password;
    }

    public void setPassword(int password) {
        this.password = password;
    }

    public Integer getJ_ID() {
        return j_ID;
    }

    public void setJ_ID(Integer j_ID) {
        this.j_ID = j_ID;
    }

    public Job getJob() {
        return job;
    }

    public void setJob(Job job) {
        this.job = job;
    }

    @Override
    public String toString() {
        return "User{" +
                "ID=" + ID +
                ", username='" + username + '\'' +
                ", password=" + password +
                '}';
    }
}

UserMapper

package com.model;

import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface UserMapper {

    User getUserById(Integer id);

    User bufferedGetUser(@Param("id") Integer id, @Param("username") String username);
//    User bufferedGetUser(Integer id, String username);

    List<User> getUserLikeName(String username);

    User getUserAndJob(Integer id);

    User getUserJobByStep(Integer id);

    void addUser(User user);

    boolean updateUser(User user);

    boolean deleteUserById(Integer id);
}

sqlSF（测试类）

package com.model.test;

import com.model.Job;
import com.model.JobMapper;
import com.model.User;
import com.model.UserMapper;
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.Test;

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

public class sqlSF {
    public SqlSessionFactory getfactory(String configPath)throws Exception{
        String resource = configPath;
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        return sqlSessionFactory;
    }

    @Test
    public void getTest()throws Exception{
        SqlSession session = getfactory("mybatis-config.xml").openSession();

        try {
            UserMapper userMapper = session.getMapper(UserMapper.class);
            User user = userMapper.getUserById(1);
            System.out.println(user);
        }finally {
            session.close();
        }
    }

    @Test
    public void addTest()throws Exception{
        //openSession不会自动提交数据
        SqlSession session = getfactory("mybatis-config.xml").openSession();

        try {
            UserMapper userMapper = session.getMapper(UserMapper.class);
            User user = new User(null,"xiaoke2",110);
            userMapper.addUser(user);
            //使用自增主键后Bean中可获得id值
            System.out.println(user.getID());
            //手动提交数据
            session.commit();
        }finally {
            session.close();
        }
    }

    @Test
    public void updateTest()throws Exception{
        //openSession不会自动提交数据
        SqlSession session = getfactory("mybatis-config.xml").openSession();

        try {
            UserMapper userMapper = session.getMapper(UserMapper.class);
            User user = new User(1,"like2",12345678);
            /*Mybatis允许的增删改返回值
                Integer, Long, Boolean, void
              openSession（）手动提交
              openSession(true)自动提交
             */
            boolean updateUser = userMapper.updateUser(user);
            System.out.println(updateUser);

            session.commit();
        }finally {
            session.close();
        }
    }

    @Test
    public void deleteTest()throws Exception{
        //openSession不会自动提交数据
        SqlSession session = getfactory("mybatis-config.xml").openSession();

        try {
            UserMapper userMapper = session.getMapper(UserMapper.class);
            Boolean deleteUser =  userMapper.deleteUserById(9);
            System.out.println(deleteUser);
            session.commit();
        }finally {
            session.close();
        }
    }

    @Test
    public void select2Test()throws Exception{
        //openSession不会自动提交数据
        SqlSession session = getfactory("mybatis-config.xml").openSession();

        try {
            UserMapper userMapper = session.getMapper(UserMapper.class);
            User user = userMapper.bufferedGetUser(1,"like2");
            System.out.println(user);
//            session.commit();
        }finally {
            session.close();
        }
    }

    @Test
    public void select3Test()throws Exception{
        SqlSession session = getfactory("mybatis-config.xml").openSession(true);

        try {
            UserMapper userMapper = session.getMapper(UserMapper.class);
            List<User> user = userMapper.getUserLikeName("%ke%");
            for (User u:user){
                System.out.println(u);
            }
//            session.commit();
        }finally {
            session.close();
        }
    }

    @Test
    public void select4Test()throws Exception{
        SqlSession session = getfactory("mybatis-config.xml").openSession();

        try {
            UserMapper userMapper = session.getMapper(UserMapper.class);
            User user = userMapper.getUserAndJob(1);
            System.out.println(user);
            System.out.println(user.getJob());
//            session.commit();
        }finally {
            session.close();
        }
    }

    @Test
    public void jobselectTest()throws Exception{
        SqlSession session = getfactory("mybatis-config.xml").openSession();

        try {
            JobMapper jobMapper = session.getMapper(JobMapper.class);
            Job job = jobMapper.getJobByID(1);
            System.out.println(job);
//            session.commit();
        }finally {
            session.close();
        }
    }

    @Test
    public void userjobByStepTest()throws Exception{
        SqlSession session = getfactory("mybatis-config.xml").openSession();

        try {
            UserMapper userMapper = session.getMapper(UserMapper.class);
            User user = userMapper.getUserJobByStep(7);
            System.out.println(user);
            System.out.println(user.getJob());
//            session.commit();
        }finally {
            session.close();
        }
    }

    @Test
    public void jobuserTest()throws Exception{
        SqlSession session = getfactory("mybatis-config.xml").openSession();

        try {
            JobMapper jobMapper = session.getMapper(JobMapper.class);
            Job job = jobMapper.getUserjobByID(1);
            System.out.println(job);
            System.out.println(job.getUsers());
        }finally {
            session.close();
        }
    }
}
005MyBatis配置sql语句
java1592724884的博客
07-24 310
1.配置CRUD语句的方式（两种） 目标：将crud语句与封装sql语句的对象（我们写的是接口，MyBatis会根据该接口反射出对应的对象）所对应的方法绑定，到时候我们直接指向该方法就能执行sql语句。 1.1 利用xml文件 在Mapper.xml中用元素定义CRUD语句（定义的CRUD元素为mapper子元素）例如： <select id="queryUser" resultType="com.lyx.domain.User" databaseId="mysql" > sel
Mybatis相关配置以及动态Sql
m0_50985141的博客
03-18 1827
一、Mybatis核心文件配置 1.自定义实体类别名配置 对于要多次书写的实体类，只需自定义实体类别名，就可以提高书写效率 <!--在核心配置文件中--> <typeAliases> <!--方式1：type：别名，alias：当前实体类的全限定名称--> <typeAlias type="user" alias="com.pojo.user" /> <!--方式2：使用别名的包扫描，它直接将实体所在包指定，别名默认
mybatis配置之sql小结（一）
易大师不易
03-27 384
1.控制台打印sql语句,在configuration.xml配置如下：                 2.批量插入sql语句，在mapper.xml中：     insert into t_record (addTime,empId,activityId,flag)  values            (#{item.addTime},#{item.emp
MyBatis配置sql日志
大跳蚤的博客
01-03 441
SpringBoot默认使用spring-boot-starter-logging,需要排除掉所有logging依赖.引入spring-boot-starter-log4j依赖.     在src/src/main/resources中添加log4j.properties     # Global logging configuration log4j.rootLogger=ERROR, st
mybatis动态SQL配置文件
苏凯的博客
10-23 998
<?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：命名空间，用于隔离sql，还有一个很重要的...
Mybatis学习笔记之动态SQL揭秘
08-26
Mybatis中的动态SQL是一种强大的特性，它能够使我们在SQL语句中实现某些逻辑，使得我们的开发更加灵活和高效。在本篇文章中，我们将对Mybatis中的动态SQL进行详细的介绍，并提供一些实用的示例代码。 一、if元素 ...
mybatis 动态sql内容讲解及笔记
05-06
mybatis 动态sql内容讲解及笔记
MyBatis笔记详解以及动态SQL
03-27
MyBatis笔记详解以及动态SQL。
mybatis笔记
12-19
MyBatis是一个优秀的Java持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis可以使用简单的XML或注解进行配置和原始映射，将接口和Java的...
狂神说Mybatis笔记,md格式的
02-12
Mybatis 是一款强大的Java持久层框架，它简化了与数据库之间的交互，使开发者能够更专注于SQL的编写，而不需要处理大量的JDBC代码。本笔记基于狂神说的讲解，将全面解析Mybatis的核心概念、使用方法以及实战技巧。 ...
MyBatis 配置sql语句输出
喜哥的博客
10-23 408
此处使用log4j,加入jar包，然后在src路径下加入:log4j.properties文件 填入以下配置就可以打印了 [plain] view plain copy print?log4j.rootLogger=DEBUG, Console    #Console  log4j.appender.Console=org.apache.log4j.ConsoleAppender  log4j.ap
14. 使用MyBatis注解配置SQL
程序员阿红的博客
02-26 3657
14. 使用MyBatis注解配置SQL 1.MyBatis常用注解 @Insert：实现新增，代替了 @Delete：实现删除，代替了 @Update：实现更新，代替了 @Select：实现查询，代替了 @Result：实现结果集封装，代替了 @Results：可以与@Result 一起使用，封装多个结果集，代替了 @One：实现一对一结果集封装，代替了 @Many：实现一对多结果集封装，代替了 2.项目结构和核心配置 使用注解开发摒弃了传统的xml映射文件，而是在接
【MyBatis】—动态SQL（配置文件方式）
m0_56233309的博客
03-17 1771
常用SQL及其作用
Mysql中的sql_mode设置
weixin_45066351的博客
05-30 1357
set @@global.sql_mode='修改后的值';//修改sql_mode配置。//查询当前sql_mode配置。
MyBatis入门及MyBatis中SQL语句实战
最新发布
y1204599680的博客
10-18 1481
半自动的ORM持久层框架具有较高的SQL灵活性，支持高级映射，动态SQL，延时加载和缓存等特性数据库无关性较低。
MyBatis 中如何执行 SQL 语句
热门推荐
stormjun的博客
07-11 1万+
MyBatis 提供了多种方式来执行 SQL 语句，包括直接使用 SqlSession 执行、使用映射器执行、使用 SqlSessionTemplate 执行等。在执行 SQL 语句时，需要将 SQL 语句中的参数和返回结果。
mybatis 中 mysql sql_mode=only_full_group_by的错误。
gonefuture的学习博客
04-14 2192
我在项目使用mybits时写过一条sql:@Select("SELECT name, SUM(feed_Weight) feedWeight,weight FROM aquaculture where name <= #{name} and id_patch = #{idPatch} group by name ") List<FeedWeight> feedWeight(@Param("
MySQL的sql_mode解析与设置
canway01的博客
01-02 145
sql_mode类型 sql_mode：它定义了MySQL应该支持的sql语法，对数据的校验等等。 查看MySQL sql_mode类型 show variables like ‘sql_mode’ 1、ONLY_FULL_GROUP_BY： 对于GROUP BY聚合操作，如果在SELECT中的列，没有在GROUP BY中出现，那么将认为这个SQL是不合法的，因为列不在GROUP BY语句中。 因...
MyBatis操作数据库表和动态SQL的使用
小S的博客
05-26 1739
MyBatis的多表查询和动态SQL的实现，你还记得如何操作吗？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值