备案控制台
开发者社区 数据库 文章 正文

[Java]Mybatis学习笔记(动力节点老杜)（六）

2023-08-06 48
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： [Java]Mybatis学习笔记(动力节点老杜)（六）

在 IDEA 中配置 MyBatis 配置文件模版

新建 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=""/>
    <typeAliases>
        <package name=""/>
    </typeAliases>
    <environments default="dev">
        <environment id="dev">
            <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>
        <package name=""/>
    </mappers>
</configuration>

测试使用新建的MyBatis核心配置文件模版

在 IDEA 中配置 SqlMapper 配置文件模版

新建 SqlMapper 配置文件模版

<?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="">
</mapper>

测试使用新建的SqlMapper配置文件模版

插入数据时获取自动生成的主键

业务场景说明

  • 存在业务场景，当我们向一张表中插入了一条数据，由于主键一般是自增的，在插入数据时，一般不指定主键，但是此时还有另外一张表，与新插入数据的表有关联关系，该表的外键需要使用新插入的数据的主键值，建立数据之间的关联关系，此时我们就需要获取自动生成的主键值
  • 业务背景：
  • 一个用户有多个角色：插入一个用户数据的同时需要给该用户分配角色：需要将生成的用户的id插入到角色表的user_id字段上
  • 实现方式有两种：
  • 第一种方式：可以先插入用户数据，再写一条查询语句获取新插入用户数据的id，然后再在角色表插入user_id字段。【比较麻烦】
  • 第二种方式：mybatis提供了一种方式更加便捷。

接口声明

/**
 * 插入汽车信息，同时使用生成的主键值
 *
 * @param car 汽车信息
 * @return 影响数据库的条数
 */
int insertCarUseGeneratedKey(Car car);

SQL

<!-- 
  useGeneratedKeys="true" 开启使用自动生成的主键
  keyProperty="id" 指定要将自动生成的主键值保存到用于
           传递数据给SQL语句的对象的哪个属性上
-->
<insert id="insertCarUseGeneratedKey" useGeneratedKeys="true" keyProperty="id">
  insert into t_car 
  values (null, #{carNum}, #{brand}, #{guidePrice}, #{produceTime}, #{carType});
</insert>

测试

@Test
public void testInsertCarUseGeneratedKey() {
    SqlSession sqlSession = SqlSessionUtil.openSession();
    CarMapper mapper = sqlSession.getMapper(CarMapper.class);
    Car car = new Car(null, "9199", "凯美瑞", 32.0, "2020-11-12", "电车");
    int count = mapper.insertCarUseGeneratedKey(car);
    System.out.println("影响数据库的条数：" + count);
    System.out.println(car);
    SqlSessionUtil.close();
}

Mybatis 参数处理

  • 数据库表：t_student
USE dbtest;
DROP TABLE IF EXISTS t_student;
CREATE TABLE t_student (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(255),
    age INT,
    height DOUBLE,
    birth DATE,
    sex CHAR(1)
);
INSERT INTO t_student(name, age, height, birth, sex) VALUES ('张三', 20, 1.77, '2001-01-02', '男');
INSERT INTO t_student(name, age, height, birth, sex) VALUES ('李四', 20, 1.67, '2001-11-22', '女');
  • 学生类：Student
package cw.study.mybatis.pojo;
import java.util.Date;
/**
 * ClassName: Student
 * Package: cw.study.mybatis.pojo
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-28 11:49
 * @Version 1.0
 */
public class Student {
    private Long id;
    private String name;
    private Integer age;
    private Double height;
    private Character sex;
    private Date birth;
    // constructor
    // setter and getter
    // toString
}

单个简单类型参数

  • 简单类型包括：
  • byte short int long float double char
  • Byte Short Integer Long Float Double Character
  • String
  • java.util.Date
  • java.sql.Date
  • select 标签中有个 parameterType属性：告诉mybatis框架，我这个方法的参数类型是什么类型。
  • 明确指明类型，MyBatis 可以不用进行类型推断，可以提高效率
<!--
  select 标签中有个 parameterType属性
    告诉mybatis框架，我这个方法的参数类型是什么类型。
  mybatis框架自身带有类型自动推断机制，所以大部分情况下parameterType属性都是可以省略不写的。
-->
<select id="selectById" resultType="Student" parameterType="java.lang.Long">
  select * from t_student where id = #{id}
</select>
  • mybatis框架自身带有类型自动推断机制，所以大部分情况下parameterType属性都是可以省略不写的。
SQL语句编译后：select * from t_student where id = ?
JDBC代码是一定要给 ? 传值的，会调用 ps.setXxx(第几个问号, 传什么值);
  ps.setLong(1, 1L);
  ps.setString(1, "zhangsan");
  ps.setDate(1, new Date());
  ps.setInt(1, 100);
  ...
<!-- mybatis框架实际上内置了很多别名，可以参考开发手册 -->
<select id="selectByName" resultType="Student" parameterType="string">
  select * from t_student where name = #{name}
</select>
  • 在#{}中，可以明确告诉mybatis框架，该参数会用什么类型的数据进行填充，对应数据库中的数据类是什么
  • 明确指明类型，MyBatis 可以不用进行类型推断，可以提高效率
<select id="selectByName" resultType="Student" parameterType="string">
  select * from t_student where name = #{name, javaType=String, jdbcType=VARCHAR}
</select>
  • 根据id查询、name查询、birth查询、sex查询
package cw.study.mybatis.mapper;
import cw.study.mybatis.pojo.Student;
import java.util.Date;
import java.util.List;
/**
 * ClassName: StudentMapper
 * Package: cw.study.mybatis.mapper
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-28 11:55
 * @Version 1.0
 */
public interface StudentMapper {
    // 根据id查询
    List<Student> selectById(Long id);
    // name查询
    List<Student> selectByName(String name);
    // birth查询
    List<Student> selectByBirth(Date birth);
    // sex查询
    List<Student> selectBySex(Character sex);
}
<?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="cw.study.mybatis.mapper.StudentMapper">
  <!--
    select 标签中有个 parameterType属性
      告诉mybatis框架，我这个方法的参数类型是什么类型。
    mybatis框架自身带有类型自动推断机制，所以大部分情况下parameterType属性都是可以省略不写的。
  -->
  <select id="selectById" resultType="Student" parameterType="java.lang.Long">
    select * from t_student where id = #{id}
  </select>
  <!-- mybatis框架实际上内置了很多别名，可以参考开发手册 -->
  <select id="selectByName" resultType="Student" parameterType="string">
    select * from t_student where name = #{name, javaType=String, jdbcType=VARCHAR}
  </select>
  <select id="selectByBirth" resultType="Student" parameterType="date">
    select * from t_student where birth = #{birth}
  </select>
  <select id="selectBySex" resultType="Student">
    select * from t_student where sex = #{sex}
  </select>
</mapper>
/**
 * ClassName: StudentMapperTest
 * Package: cw.study.mybatis.test
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-28 11:59
 * @Version 1.0
 */
public class StudentMapperTest {
    @Test
    public void testSelectById() {
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> students = mapper.selectById(1L);
        students.forEach(System.out::println);
        SqlSessionUtil.close();
    }
    @Test
    public void testSelectByName() {
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> students = mapper.selectByName("李四");
        students.forEach(System.out::println);
        SqlSessionUtil.close();
    }
    @Test
    public void testSelectByBirth() throws ParseException {
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        List<Student> students = mapper.selectByBirth(simpleDateFormat.parse("2001-11-22"));
        students.forEach(System.out::println);
        SqlSessionUtil.close();
    }
    @Test
    public void testSelectBySex() {
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> students = mapper.selectBySex('男');
        students.forEach(System.out::println);
        SqlSessionUtil.close();
    }
}

Map 集合

  • 使用Map集合进行参数的传递，将每个条件以key和value的形式存放到集合中，在使用集合中的数据的时候需要通过#{map集合的key}来取值。
/**
 * 通过集合传递要插入数据库中的学生信息
 * 
 * @param map 学生信息
 * @return 影响数据库的条数
 */
int insertStudentByMap(Map<String, Object> map);
<!--
  parameterType="map" 可以省略, 可以自动推出传入的参数为map集合
  在使用集合中的数据的时候需要通过#{map集合的key}来取值。
-->
<insert id="insertStudentByMap" parameterType="map">
  insert into t_student(id, name, age, sex, height, birth)
  values (null, #{name}, #{age}, #{sex}, #{height}, #{birth});
</insert>
@Test
public void testInsertStudentByMap() {
    // 封装数据
    HashMap<String, Object> map = new HashMap<>();
    // name, age, sex, height, birth
    map.put("name", "张三");
    map.put("age", 20);
    map.put("sex", '男');
    map.put("height", 1.80);
    map.put("birth", new Date());
    SqlSession sqlSession = SqlSessionUtil.openSession();
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    int count = mapper.insertStudentByMap(map);
    System.out.println(count);
    sqlSession.commit();
    SqlSessionUtil.close();
}

实体类 POJO

  • 使用实体类pojo进行参数的传递，将数据封装到实体类中，在使用实体类中的数据的时候需要通过#{get方法去掉get首字母小写}来取值。
/**
 * 通过实体类传递要插入数据库的学生信息
 * 
 * @param student 学生信息
 * @return 影响数据库记录的条数
 */
int insertStudentByPojo(Student student);
<!--
  parameterType="student" 可以省略，可以自动推出类型为Student类
    可以使用 student 是因为在MyBatis核心配置文件中配置了别名
  在使用集合中的数据的时候需要通过#{get方法去掉get首字母小写}来取值。
-->
<insert id="insertStudentByPojo" parameterType="student">
  insert into t_student(id, `name`, age, sex, height, birth)
  values (null, #{name}, #{age}, #{sex}, #{height}, #{birth});
</insert>
@Test
public void testInsertStudentByPojo() {
  // 封装数据
    Student student = new Student(null, "李四", 23, 1.78, '男', new Date());
    SqlSession sqlSession = SqlSessionUtil.openSession();
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    int count = mapper.insertStudentByPojo(student);
    System.out.println(count);
    sqlSession.commit();
    SqlSessionUtil.close();
}

多参数

  • 如果是操作数据库的方法的形参列表是多个参数的话，mybatis框架会自动创建一个Map集合。并且Map集合是以这种方式存储参数的：
map.put("arg0", name);
map.put("arg1", sex);
map.put("param1", name);
map.put("param2", sex);
  • 注意：低版本的mybatis中，使用的是：#{0}和#{1}，以及#{2}…，使用mybatis3.4.2之前的版本时：要用#{0}和#{1}这种形式。
  • 高版本的mybatis中，使用的是：
// arg 从 0 开始
#{arg0}
#{arg1}
#{arg2}
// param 从 1 开始
#{param1}
#{param2}
#{param3}
  • 对于操作数据库的方法的形参列表是多个参数的情况，在SQL语句中取数据不能直接使用形参的参数名，会报错
/**
 * 根据学生的姓名和性别进行学生信息的查询
 * 
 * @param name 学生的姓名
 * @param sex 学生的性别
 * @return 学生信息组成的集合
 */
List<Student> selectByNameAndSex(String name, Character sex);
<!-- parameterType="" 不用写了 -->
<select id="selectByNameAndSex" resultType="student">
  select * from t_student
  where `name` = #{arg0} and sex = #{param2};
</select>
@Test
public void testSelectByNameAndSex() {
    SqlSession sqlSession = SqlSessionUtil.openSession();
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    List<Student> students = mapper.selectByNameAndSex("张三", '男');
    students.forEach(System.out::println);
    SqlSessionUtil.close();
}

@Param（命名参数）

  • 对于操作数据库的方法中形参列表的参数为多个的情况，如果使用arg0 arg1 param1 param2这种方式的话，代码的可读性太差。
  • 在MyBatis中，为我们提供了@Param注解，使我们可以不用arg0 arg1 param1 param2，@Param注解使我们可以自定义存放参数的map集合的key，可以增强代码的可读性。

@Param 的使用

/**
 * 根据学生的姓名和性别进行学生信息的查询
 *
 * @param name 学生的姓名
 * @param sex 学生的性别
 * @return 学生信息组成的集合
 */
List<Student> selectByNameAndSexAnnotation(
        // 使用@Param注解指定参数在map集合中的key
      // @Param注解中的value属性用于指定参数在map集合中的key
        @Param("name") String name, 
        @Param("sex") Character sex
);
  • 使用Param注解后，mybatis框架底层的实现原理：
map.put("name", name);
map.put("sex", sex);
<select id="selectByNameAndSexAnnotation" resultType="student">
  select * from t_student
  where `name` = #{name} and sex = #{sex};
</select>
@Test
public void testSelectByNameAndSexAnnotation() {
    SqlSession sqlSession = SqlSessionUtil.openSession();
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    List<Student> students = mapper.selectByNameAndSexAnnotation("张三", '男');
    students.forEach(System.out::println);
    SqlSessionUtil.close();
}

注意点

  • 使用了@Param注解之后，arg0和arg1失效了
<select id="selectByNameAndSexAnnotation" resultType="student">
  select * from t_student
  where `name` = #{arg0} and sex = #{arg1};
</select>

  • 使用了@Param注解之后，param1和param2还可以用
<select id="selectByNameAndSexAnnotation" resultType="student">
  select * from t_student
  where `name` = #{param1} and sex = #{param2};
</select>

@Param源码分析

源码跟踪
// mapper 实际上指向了代理对象
StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
// selectByNameAndSexAnnotation 是代理对象 mapper 的代理方法
// 执行到这时，会调用代理对象mapper的代理方法
List<Student> students = mapper.selectByNameAndSexAnnotation("张三", '男');
  • 调用代理对象mapper的代理方法，就是执行 MapperProxy 的 invoke 方法
// Object proxy：代理对象
// Method method：目标方法 
// Object[] args：目标方法的参数
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
        return Object.class.equals(method.getDeclaringClass()) ? method.invoke(this, args) : this.cachedInvoker(method).invoke(proxy, method, args, this.sqlSession);
    } catch (Throwable var5) {
        throw ExceptionUtil.unwrapThrowable(var5);
    }
}
  • 接下来执行 this.cachedInvoker(method).invoke(proxy, method, args, this.sqlSession)
// MapperProxy 内部类 PlainMethodInvoker 的方法
public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
    return this.mapperMethod.execute(sqlSession, args);
}
  • 执行 MapperMethod 的 execute 方法进行 SQL 语句类和代理目标方法返回值类型的匹配
// MapperMethod 的方法
public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    Object param;
    // this.command.getType() 获取 SQL 语句的类型（insert|update|select|delete）
    switch (this.command.getType()) {
        case INSERT:
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.insert(this.command.getName(), param));
            break;
        case UPDATE:
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.update(this.command.getName(), param));
            break;
        case DELETE:
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.delete(this.command.getName(), param));
            break;
        case SELECT:
            // this.method.returnsVoid() 我们定义的Mapper接口中的方法无返回值
            if (this.method.returnsVoid() && this.method.hasResultHandler()) {
                this.executeWithResultHandler(sqlSession, args);
                result = null;
                // 我们定义的Mapper接口中的方法返回多条记录
            } else if (this.method.returnsMany()) {
                result = this.executeForMany(sqlSession, args);
            } else if (this.method.returnsMap()) {
                result = this.executeForMap(sqlSession, args);
            } else if (this.method.returnsCursor()) {
                result = this.executeForCursor(sqlSession, args);
            } else {
                param = this.method.convertArgsToSqlCommandParam(args);
                result = sqlSession.selectOne(this.command.getName(), param);
                if (this.method.returnsOptional() && (result == null || !this.method.getReturnType().equals(result.getClass()))) {
                    result = Optional.ofNullable(result);
                }
            }
            break;
        case FLUSH:
            result = sqlSession.flushStatements();
            break;
        default:
            throw new BindingException("Unknown execution method for: " + this.command.getName());
    }
    if (result == null && this.method.getReturnType().isPrimitive() && !this.method.returnsVoid()) {
        throw new BindingException("Mapper method '" + this.command.getName() + " attempted to return null from a method with a primitive return type (" + this.method.getReturnType() + ").");
    } else {
        return result;
    }
}
  • SQL 语句的类型以及返回结果的类型匹配完成后，进行Mapper接口代理方法的执行
private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
    // 将Mapper接口参数组成的数组转换为SQL语句中占位符填充的参数
    // 转换成 param1 = value1 param2 = value2 ... 的形式
    // 或者 arg1 = value1 arg2 = value2 ... 的形式
    // 或者 'name' = value1 'sex' = value2 ... 的形式
    Object param = this.method.convertArgsToSqlCommandParam(args);
    List result;
    if (this.method.hasRowBounds()) {
        RowBounds rowBounds = this.method.extractRowBounds(args);
        result = sqlSession.selectList(this.command.getName(), param, rowBounds);
    } else {
        result = sqlSession.selectList(this.command.getName(), param);
    }
    if (!this.method.getReturnType().isAssignableFrom(result.getClass())) {
        return this.method.getReturnType().isArray() ? this.convertToArray(result) : this.convertToDeclaredCollection(sqlSession.getConfiguration(), result);
    } else {
        return result;
    }
}
public Object convertArgsToSqlCommandParam(Object[] args) {
    return this.paramNameResolver.getNamedParams(args);
}
  • 调用 ParamNameResolver 类的 getNamedParams(args) 方法进行转换
public Object getNamedParams(Object[] args) {
    // private final SortedMap<Integer, String> names;
    // 是一个Map集合，key为第几个参数，value为参数对应的名字
    int paramCount = this.names.size();
    if (args != null && paramCount != 0) {
        // 判断方法参数上是否有Param注解
        if (!this.hasParamAnnotation && paramCount == 1) {
            Object value = args[(Integer)this.names.firstKey()];
            return wrapToMapIfCollection(value, this.useActualParamName ? (String)this.names.get(0) : null);
        } else { // 有Param注解走该分支
            // 有Param注解会新建一个Map集合 param集合
            Map<String, Object> param = new MapperMethod.ParamMap();
            int i = 0;
          // 遍历存储参数名字的Map集合
            for(Iterator var5 = this.names.entrySet().iterator(); var5.hasNext(); ++i) {
                Map.Entry<Integer, String> entry = (Map.Entry)var5.next();
                // 向param集合中添加数据，key为接口方法参数的名字 entry.getValue()
                // value为接口方法参数的参数值 args[(Integer)entry.getKey()]
                param.put(entry.getValue(), args[(Integer)entry.getKey()]);
                // genericParamName 通用参数名
                String genericParamName = "param" + (i + 1); // param1 param2 ...
                // 集合是否包含通用参数名 param1 param2 ...
                if (!this.names.containsValue(genericParamName)) {
                    // 这个就是可以使用 param1 param2 获取参数值
                    // 向集合中添加 param1=value1 param2=value2
                    param.put(genericParamName, args[(Integer)entry.getKey()]);
                }
            }
            return param;
        }
    } else {
        return null;
    }
}
图示分析

MyBatis查询语句专题

返回 POJO（一条记录）

public interface CarMapper {
    /**
     * 根据id查询汽车信息
     * 
     * @param id 汽车信息的id
     * @return 汽车信息
     */
    Car selectById(Long id);
}
<!-- 
  如果SQL语句中不使用别名，
  则读取数据后字段名与对象的属性名不一致的话
  不一致的属性的值会为null
-->
<select id="selectById" resultType="car">
  select id,
         car_num      as carNum,
         brand,
         guide_price  as guidePrice,
         produce_time as produceTime,
         car_type     as carType
  from t_car
  where id = #{id};
</select>
@org.junit.Test
public void testSelectById() {
    SqlSession sqlSession = SqlSessionUtil.openSession();
    CarMapper mapper = sqlSession.getMapper(CarMapper.class);
    Car car = mapper.selectById(5L);
    System.out.println(car);
    SqlSessionUtil.close();
}

  • 如果返回的结果集可能有多条记录，则不能使用一个pojo对象进行接收，否则会报TooManyResultsException，返回的结果集可能有多条数据记录，则需要使用集合进行接收
文章标签：
Java
SQL
mybatis
数据库
存储
数据库连接
关键词：
Java mybatis
MyBatis java
Java学习笔记
MyBatis学习笔记
Java节点
萤火虫的小尾巴
目录
相关文章
bbpp
|
1月前
|
Java 编译器 开发工具
Java基础学习笔记——idea篇
JDK由JRE（包含JVM和核心类库）和开发工具箱（如javac编译器和java运行工具）组成。Java项目结构包括Project、Module、Package和Class。IDEA快捷键包括：生成main方法（main psvm）、复制代码（Ctrl+D）、删除代码（Ctrl+Y/X）、格式化代码（Ctrl+Alt+L）、重命名（Shift+F6）等。
bbpp
17 0
穆雄雄.
|
2月前
Mybatis+mysql动态分页查询数据案例——分页工具类(Page.java)
Mybatis+mysql动态分页查询数据案例——分页工具类(Page.java)
穆雄雄.
28 1
穆雄雄.
|
2月前
Mybatis+mysql动态分页查询数据案例——工具类(MybatisUtil.java)
Mybatis+mysql动态分页查询数据案例——工具类(MybatisUtil.java)
穆雄雄.
17 1
Yeats_Liao
|
7天前
|
SQL Java 数据库连接
15：MyBatis对象关系与映射结构-Java Spring
15：MyBatis对象关系与映射结构-Java Spring
Yeats_Liao
27 4
L&ecirc;v&iuml;
|
15天前
|
SQL Java 数据库连接
Java从入门到精通：3.1.2深入学习Java EE技术——Hibernate与MyBatis等ORM框架的掌握
Java从入门到精通：3.1.2深入学习Java EE技术——Hibernate与MyBatis等ORM框架的掌握
L&ecirc;v&iuml;
19 1
橙子先生
|
24天前
|
XML Java 数据库连接
java对象有集合mybatis如何映射
java对象有集合mybatis如何映射
橙子先生
18 4
穆雄雄.
|
2月前
|
Java 数据库连接 mybatis
mybatis简单案例源码详细【注释全面】——Utils层（MybatisUtils.java）
mybatis简单案例源码详细【注释全面】——Utils层（MybatisUtils.java）
穆雄雄.
14 0
穆雄雄.
|
2月前
|
Java 数据库连接 mybatis
mybatis简单案例源码详细【注释全面】——测试层（UserMapperTest.java）
mybatis简单案例源码详细【注释全面】——测试层（UserMapperTest.java）
穆雄雄.
10 0
穆雄雄.
|
2月前
|
Java 数据库连接 mybatis
mybatis简单案例源码详细【注释全面】——Dao层接口（UserMapper.java）
mybatis简单案例源码详细【注释全面】——Dao层接口（UserMapper.java）
穆雄雄.
10 0
Hacynn
|
22小时前
|
Java
【Java多线程】分析线程加锁导致的死锁问题以及解决方案
【Java多线程】分析线程加锁导致的死锁问题以及解决方案
Hacynn
6 1

热门文章

最新文章

  • 1
    答案很详细的MyBatis面试题（含示例代码）
  • 2
    【mybatis】第一篇，Springboot中使用插件PageHelper不生效解决方案
  • 3
    【mybatis-plus】自定义多数据源，动态切换数据源事务失效问题
  • 4
    MyBatis二级缓存解密：深入探究缓存机制与应用场景
  • 5
    【mybatis-plus】Springboot+AOP+自定义注解实现多数据源操作（数据源信息存在数据库）
  • 6
    MyBatis初探：揭示初始化阶段的核心流程与内部机制
  • 7
    MyBatis之旅：从零开始的环境搭建与配置
  • 8
    深入源码：解密MyBatis数据源设计的精妙机制
  • 9
    什么是MyBatis持久层框架？
  • 10
    mybatis和mybatiplus中Error attempting to get column ‘xx‘ from result set
  • 1
    [Java基础]——类的生命周期
    14
  • 2
    [java进阶]——泛型类、泛型方法、泛型接口、泛型的通配符
    28
  • 3
    【java进阶】Java中线程的实现方式
    22
  • 4
    【java进阶】集合的三种遍历(迭代器、增强for、Lambda)
    19
  • 5
    [java进阶]——方法引用改写Lambda表达式
    34
  • 6
    深入理解 Java 多线程、Lambda 表达式及线程安全最佳实践
    124
  • 7
    java base64转doc文件
    34
  • 8
    [JavaWeb]——过滤器filter与拦截器Interceptor的使用、执行过程、区别
    46
  • 9
    Java中的异常语法知识居然这么好玩！后悔没有早点学习
    37
  • 10
    Java必刷入门递归题×5（内附详细递归解析图）
    25

    • 相关课程

    更多
  • MyBatis持久层框架入门
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • 从《阿里巴巴Java开发手册》编写推广谈技术成长
  • 如何通过 Serverless 提高 Java 微服务治理效
  • Java Spring Boot开发实战系列课程【第6讲】：Spring Boot 2.0实战MyBatis与优化(Java面试题)

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）