Mybatis3_映射文件

最新推荐文章于 2021-10-16 17:37:06 发布
最新推荐文章于 2021-10-16 17:37:06 发布
阅读量143 收藏 1
点赞数
分类专栏： Mybatis 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gingerMr/article/details/119852198
版权

文章目录

Mybatis 映射文件

映射文件指导着 MyBatis 如何进行数据库增删改查，有着非常重要的意义。

  • cache – 该命名空间的缓存配置。
  • cache-ref – 引用其它命名空间的缓存配置。
  • resultMap – 描述如何从数据库结果集中加载对象，是最复杂也是最强大的元素。
  • parameterMap – 老式风格的参数映射。此元素已被废弃，并可能在将来被移除！请使用行内参数映射。文档中不会介绍此元素。
  • sql – 可被其它语句引用的可重用语句块。
  • insert – 映射插入语句。
  • update – 映射更新语句。
  • delete – 映射删除语句。
  • select – 映射查询语句。

1. insert、update、delete元素

在这里插入图片描述

<!-- public void addEmp(Employee employee); -->
<!-- parameterType：参数类型，可以省略。-->
<insert id="addEmp" parameterType="com.ginger.mybatis.bean.Employee">
	insert into employee(last_name,email,gender)
	values(#{lastName},#{email},#{gender})
</insert>

<!-- public void updateEmp(Employee employee); -->
<update id="updateEmp">
	update employee
	set last_name=#{lastName},email=#{email},gender=#{gender}
	where id=#{id}
</update>

<!-- public void deleteEmpById(Integer id); -->
<delete id="deleteEmpById">
	delete from employee where id=#{id}
</delete>

Mybatis 允许增删改直接定义以下类型返回值 Integer、Long、Boolean、void。

/**
 * 测试增删改
 * 1、mybatis允许增删改直接定义以下类型返回值
 * 		Integer、Long、Boolean、void
 * 2、我们需要手动提交数据
 * 		sqlSessionFactory.openSession();===》手动提交
 * 		sqlSessionFactory.openSession(true);===》自动提交
 * @throws IOException 
 */
@Test
public void test03() throws IOException{
	SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
	//1、获取到的SqlSession不会自动提交数据
	SqlSession openSession = sqlSessionFactory.openSession();
	try{
		EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
		//测试添加
		Employee employee = new Employee(1, "小强","xiaoqiang@qq.com", "1");
		mapper.addEmp(employee);
		System.out.println(employee.getId());
		
		//测试修改
		//Employee employee = new Employee(1, "Tom", "jerry@jerry.com", "0");
		//boolean updateEmp = mapper.updateEmp(employee);
		//System.out.println(updateEmp);

		//测试删除
		//mapper.deleteEmpById(2);
		//2、手动提交数据
		openSession.commit();
	}finally{
		openSession.close();
	}
}

在这里插入图片描述

1.1 主键生成方式

若数据库支持自动生成主键的字段（比如 MySQL 和 SQL Server），则可以设置 useGeneratedKeys=”true”，然后再把 keyProperty 设置到目标属性上。
在这里插入图片描述

<!-- public void addEmp(Employee employee); -->
<!-- parameterType：参数类型，可以省略。
获取自增主键的值：
    mysql支持自增主键，自增主键值的获取，mybatis也是利用statement.getGenreatedKeys()。
    useGeneratedKeys="true"：使用自增主键获取主键值策略。
    keyProperty：指定对应的主键属性，也就是mybatis获取到主键值以后，将这个值封装给javaBean的哪个属性。
-->
<insert id="addEmp" parameterType="com.ginger.mybatis.bean.Employee"
        useGeneratedKeys="true" keyProperty="id" databaseId="mysql">
	insert into tbl_employee(last_name,email,gender) 
	values(#{lastName},#{email},#{gender})
</insert>

而对于不支持自增型主键的数据库（例如 Oracle），则可以使用 selectKey 子元素：selectKey 元素将会首先运行，id 会被设置，然后插入语句会被调用。
在这里插入图片描述

<!--
	获取非自增主键的值：
		Oracle不支持自增，Oracle使用序列来模拟自增。
		每次插入的数据的主键是从序列中拿到的值；如何获取到这个值。
 -->
<insert id="addEmp" databaseId="oracle">
	<!--
		keyProperty：查出的主键值封装给javaBean的哪个属性。
		order="BEFORE"：当前sql在插入sql之前运行。
		   AFTER：当前sql在插入sql之后运行。
		resultType：查出的数据的返回值类型。
		
		BEFORE运行顺序：
		先运行selectKey查询id的sql，查出id值封装给javaBean的id属性。
		在运行插入的sql，就可以取出id属性对应的值。
		
		AFTER运行顺序：这种方式可能会有点问题，如果插入的是多条最后一个会把前面的覆盖掉，还是使用BEFORE更好。
		先运行插入的sql（从序列中取出新值作为id）。
		再运行selectKey查询id的sql。
	-->
	<selectKey keyProperty="id" order="BEFORE" resultType="Integer">
	        <!-- 编写查询主键的sql语句 -->
	        <!-- BEFORE-->
	        select EMPLOYEES_SEQ.nextval from dual
	        <!-- AFTER：
	        select EMPLOYEES_SEQ.currval from dual -->
	</selectKey>
	
    <!-- 插入时的主键是从序列中拿到的 -->
    <!-- BEFORE: -->
    insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL)
    values(#{id},#{lastName},#{email})
    <!-- AFTER：
    insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL)
    values(employees_seq.nextval,#{lastName},#{email}) -->
</insert>
1.1.1 selectKey

在这里插入图片描述

2. 参数（Parameters）传递

2.1 单个参数

单个参数：可以接受基本类型，对象类型，集合类型的值，这种情况 MyBatis 可直接使用这个参数，不需要经过任何处理。
单个参数：Mybatis 不会做特殊处理，#{参数名/任意名}：取出参数值。

<select id="getEmpById" resultType="com.ginger.mybatis.bean.Employee" databaseId="mysql">
	<!--select * from employee where id = #{id}-->
	select * from employee where id = #{suibian}
</select>

<select id="getEmpById" resultType="com.ginger.mybatis.bean.Employee" databaseId="mysql">
	<!--select * from employee where id = #{id}-->
	select * from employee where id = #{suibian}
</select>

//接口
public interface EmployeeMapper {
	public Employee getEmpById(Integer id);
}

//测试
@Test
public void test01() throws IOException {
	// 1、获取sqlSessionFactory对象
	SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
	// 2、获取sqlSession对象
	SqlSession openSession = sqlSessionFactory.openSession();
	try {
		// 3、获取接口的实现类对象
		// 会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
		EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
		Employee employee = mapper.getEmpById(1);
		System.out.println(employee);
	} finally {
		openSession.close();
	}
}

在这里插入图片描述

2.2 多个参数

多个参数：任意多个参数，都会被 MyBatis 重新包装成一个Map传入。Map 的 key 是 param1，param2或者0，1 … 值就是参数的值。
多个参数：mybatis会做特殊处理。

多个参数会被封装成一个 map。

  • key：param1…paramN，或者参数的索引也可以。
  • value：传入的参数值。
  • #{}就是从 map 中获取指定的key的值。
2.2.1 多个参数使用参数名获取值（会报错）
<!--  public Employee getEmpByIdAndLastName(Integer id,String lastName);-->
<select id="getEmpByIdAndLastName" resultType="com.ginger.mybatis.bean.Employee">
	select * from employee where id = #{id} and last_name=#{lastName}
</select>

// 接口
public interface EmployeeMapper {
	public Employee getEmpByIdAndLastName(Integer id, String lastName);
}

// 测试
@Test
public void test02() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        // 会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
        Employee employee = mapper.getEmpByIdAndLastName(1, "小明");
        System.out.println(employee);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

2.2.2 使用param1和param2或者0和1获取值
<!-- public Employee getEmpByIdAndLastName(Integer id,String lastName); -->
<select id="getEmpByIdAndLastName" resultType="com.ginger.mybatis.bean.Employee">
	select * from employee where id = #{param1} and lastname=#{param2}
</select>
或者
<!--  public Employee getEmpByIdAndLastName(Integer id,String lastName);-->
<select id="getEmpByIdAndLastName" resultType="com.gigner.mybatis.bean.Employee">
	select * from employee where id = #{0} and lastname=#{1}
</select>

// 接口
public interface EmployeeMapper {
	public Employee getEmpByIdAndLastName( Integer id, String lastName);
}

// 测试
@Test
public void test02() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
        Employee employee = mapper.getEmpByIdAndLastName(1, "小明");
        System.out.println(employee);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

2.3 命名参数@Param

命名参数：为参数使用 @Param 起一个名字，MyBatis 就会将这些参数封装进 map 中， key 就是我们自己指定的名字。

命名参数：明确指定封装参数时 map 的 key，@Param(“id”)。

多个参数会被封装成 一个map。

  • key：使用@Param注解指定的值。
  • value：参数值。
  • #{指定的key}取出对应的参数值。
<!-- public Employee getEmpByIdAndLastName(Integer id,String lastName); -->
<select id="getEmpByIdAndLastName" resultType="com.ginger.mybatis.bean.Employee">
	select * from employee where id = #{id} and lastname=#{lastName}
</select>

// 接口
public Employee getEmpByIdAndLastName(@Param("id") Integer id, @Param("lastName") String lastName);

// 测试
@Test
public void test02() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        // 会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
        Employee employee = mapper.getEmpByIdAndLastName(2, "小王");
        System.out.println(employee);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

2.4 POJO

POJO：当这些参数属于我们业务POJO时，我们直接传递POJO。

POJO：如果多个参数正好是我们业务逻辑的数据模型，我们就可以直接传入pojo。
#{属性名}：取出传入的pojo的属性值。

<!--public Employee getEmpByEmployee(Employee employee);-->
<select id="getEmpByEmployee" resultType="com.ginger.mybatis.bean.Employee">
	select * from employee where id = #{id} and lastname=#{lastName}
</select>

// 接口
public Employee getEmpByEmployee(Employee employee);

// 测试
@Test
public void test03() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        // 会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
        Employee employee = new Employee();
        employee.setId(2);
        employee.setLastName("小王");
        Employee result = mapper.getEmpByEmployee(employee);
        System.out.println(result);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

2.5 Map

Map：我们也可以封装多个参数为map，直接传递。

Map：如果多个参数不是业务模型中的数据，没有对应的pojo，不经常使用，为了方便，我们也可以传入map。
#{key}：取出map中对应的值。

<!-- public Employee getEmpByMap(Map<String, Object> map); -->
<select id="getEmpByMap" resultType="com.ginger.mybatis.bean.Employee">
    select * from employee where id=#{id} and lastname=#{lastName}
</select>

// 接口
public Employee getEmpByMap(Map<String, Object> map);

// 测试
@Test
public void test04() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        // 会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
        Map<String,Object> map = new HashMap<>();
        map.put("id",3);
        map.put("lastName", "小李");
        Employee employee = mapper.getEmpByMap(map);
        System.out.println(employee);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

2.6 TO

如果多个参数不是业务模型中的数据，但是经常要使用，推荐来编写一个TO（Transfer Object）数据传输对象。

public Page{
	int index;
	int size;
}

2.7 参数传递扩展

// 传递多个参数，第一个参数指定了map的键值，可以使用#{id}或者#{param1}取值，第二个参数没有指定map键值，就只能#{param2}取值。
// 取值：id==>#{id/param1}   lastName==>#{param2}
public Employee getEmp(@Param("id")Integer id,String lastName);

// 传递多个参数，第一个参数没有指定map键值就只能使用#{param1}取值，第二个参数指定了map键值，可以使用#{param2.lastName}
// 或者#{emp.lastName}取值。
public Employee getEmp(Integer id,@Param("emp")Employee emp);
// 取值：id==>#{param1}    lastName===>#{param2.lastName/emp.lastName}

/*
	特别注意：如果是参数是Collection（List、Set）类型或者是数组，也会特殊处理，也是把传入的list或者数组封装在map中。
		key：Collection（传入List或者Set键值都是collection），如果是List键值还可以使用这个key(list)数组(array)。
*/
public Employee getEmpById(Collection<Integer> collection);
//取值：取出第一个id的值： #{collection[0]}
public Employee getEmpById(List<Integer> ids);
//取值：取出第一个id的值： #{list[0]}
public Employee getEmpById(Integer[] ids);
//取值：取出第一个id的值： #{array[0]}

3. 参数处理

3.1 结合源码 Mybatis 怎么处理参数

总结：参数多时会封装map，为了不混乱，我们可以使用 @Param 来指定封装时使用的key。
#{key}就可以取出map中的值；

(@Param("id")Integer id,@Param("lastName")String lastName);
ParamNameResolver解析参数封装map的。
//1、names：{0=id, 1=lastName}；构造器的时候就确定好了
	确定流程：
	1.获取每个标了param注解的参数的 @Param 的值：id，lastName；  赋值给name;
	2.每次解析一个参数给map中保存信息：（key：参数索引，value：name的值）
		name的值：
			标注了param注解：注解的值
			没有标注：
				1.全局配置：useActualParamName（jdk1.8）：name=参数名
				2.name=map.size()；相当于当前元素的索引
	{0=id, 1=lastName,2=2}
				
args【1，"Tom",'hello'】:
public Object getNamedParams(Object[] args) {
    final int paramCount = names.size();
    //1、参数为null直接返回
    if (args == null || paramCount == 0) {
      return null;
     
    //2、如果只有一个元素，并且没有Param注解；args[0]：单个参数直接返回
    } else if (!hasParamAnnotation && paramCount == 1) {
      return args[names.firstKey()];
      
    //3、多个元素或者有Param标注
    } else {
      final Map<String, Object> param = new ParamMap<Object>();
      int i = 0;
      
      //4、遍历names集合；{0=id, 1=lastName,2=2}
      for (Map.Entry<Integer, String> entry : names.entrySet()) {
     
      	//names集合的value作为key;  names集合的key又作为取值的参考args[0]:args【1，"Tom"】:
      	//eg:{id=args[0]:1,lastName=args[1]:Tom,2=args[2]}
        param.put(entry.getValue(), args[entry.getKey()]);
           
        // add generic param names (param1, param2, ...)param
        //额外的将每一个参数也保存到map中，使用新的key：param1...paramN
        //效果：有Param注解可以#{指定的key}，或者#{param1}
        final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
        // ensure not to overwrite parameter named with @Param
        if (!names.containsValue(genericParamName)) {
          param.put(genericParamName, args[entry.getKey()]);
        }
        i++;
      }
      return param;
    }
  }
}

3.2 #{} 和 ${}参数值的获取

#{}：可以获取map中的值或者pojo对象属性的值。
${}：可以获取map中的值或者pojo对象属性的值。

#{}和${}区别：
在这里插入图片描述
在这里插入图片描述

select * from employee where id=${id} and lastname=#{lastName}
Preparing: select * from employee where id=3 and lastname=?
	区别：
		#{}:是以预编译的形式，将参数设置到sql语句中，PreparedStatement，防止sql注入。
		${}:取出的值直接拼装在sql语句中，会有安全问题。
		大多情况下，我们去参数的值都应该去使用#{}。
		
		原生jdbc不支持占位符的地方我们就可以使用${}进行取值。
		比如分表、排序...按照年份分表拆分。
			select * from ${year}_salary where xxx;
			select * from tbl_employee order by ${f_name} ${order}

<!-- public Employee getEmpByMap(Map<String, Object> map); -->
<select id="getEmpByMap" resultType="com.ginger.mybatis.bean.Employee">
    select * from ${tableName} where id=${id} and lastname=#{lastName}
</select>

// 接口
public Employee getEmpByMap(Map<String, Object> map);

// 测试
@Test
public void test05() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
        Map<String,Object> map = new HashMap<>();
        map.put("id",3);
        map.put("lastName", "小李");
        map.put("tableName","employee");
        Employee employee = mapper.getEmpByMap(map);
        System.out.println(employee);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

3.3 #{}更多的用法

在这里插入图片描述

  • javaType 通常可以从参数对象中来去确定。
  • 如果 null 被当作值来传递，对于所有可能为空的列，jdbcType 需要被设置。
  • 对于数值类型，还可以设置小数点后保留的位数。
  • mode 属性允许指定 IN，OUT 或 INOUT 参数。如果参数为 OUT 或 INOUT，参数对象属性的真实值将会被改变，就像在获取输出参数时所期望的那样。
  • 参数位置支持的属性。
    javaType、jdbcType、mode、numericScale、resultMap、typeHandler、jdbcTypeName、expression。
  • 实际上通常被设置的是。
    可能为空的列名指定 jdbcType。
#{}:更丰富的用法：
	规定参数的一些规则：
	javaType、 jdbcType、 mode（存储过程）、 numericScale、resultMap、 typeHandler、 jdbcTypeName、 expression（未来准备支持的功能）。

	jdbcType通常需要在某种特定的条件下被设置：
		在我们数据为null的时候，有些数据库可能不能识别mybatis对null的默认处理，比如Oracle（报错）。
		
		JdbcType OTHER：无效的类型，因为mybatis对所有的null都映射的是原生Jdbc的OTHER类型，oracle不能正确处理，mysql是可以处理的。
		
		由于全局配置中：jdbcTypeForNull=OTHER，oracle不支持。有两种办法解决
		1、#{email,jdbcType=NULL};
		2、jdbcTypeForNull=NULL
			<setting name="jdbcTypeForNull" value="NULL"/>

MyBatis 默认对的空值映射为 JDBC OTHER 类型，OTHER 类型 Mysql 是认识的，但是Oracle是不认识的所以会出现报错。
在这里插入图片描述

<!-- Oracle 数据库环境 -->
<insert id="addEmp" databaseId="oracle">
	<selectKey keyProperty="id" order="BEFORE" resultType="Integer">
		<!-- 编写查询主键的sql语句 -->
		<!-- BEFORE-->
		select EMPLOYEES_SEQ.nextval from dual 
	</selectKey>
	
	<!-- 插入时的主键是从序列中拿到的 -->
	<!-- BEFORE:-->
	insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL) 
	values(#{id},#{lastName},#{email<!-- ,jdbcType=NULL -->}) 
</insert>

// 接口
public Long addEmp(Employee employee);

// 测试
@Test
public void test03() throws IOException{
  	// 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
	try{
		EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
		//测试添加
		//在邮箱位置插入一个空值
		Employee employee = new Employee(null, "jerry3",null, "1");
		mapper.addEmp(employee);
		System.out.println(employee.getId());
		openSession.commit();
	}finally{
		openSession.close();
	}
}

在这里插入图片描述

4. select 元素

  • select元素来定义查询操作。
  • Id：唯一标识符。
    用来引用这条语句，需要和接口的方法名一致。
  • parameterType：参数类型。
    可以不传，MyBatis 会根据 TypeHandler 自动推断。
  • resultType：返回值类型。
    别名或者全类名，如果返回的是集合，定义集合中元素的类型，不能和resultMap同时使用。
    在这里插入图片描述

4.1 返回结果自动映射

全局setting设置

  • autoMappingBehavior 默认是 PARTIAL，开启自动映射的功能，唯一的要求是列名和 javaBean 属性名一致。
  • 如果 autoMappingBehavior 设置为null则会取消自动映射。
  • 数据库字段命名规范，POJO属性符合驼峰命名法，如A_COLUMN，我们可以开启自动驼峰命名规则映射功能，mapUnderscoreToCamelCase=true。

4.2 resultType

4.2.1 resultType 返回值是 List
<!-- public List<Employee> getEmpsByLastNameLike(String lastName); -->
<!--resultType：如果返回的是一个集合，要写集合中元素的类型  -->
<select id="getEmpsByLastNameLike" resultType="com.ginger.mybatis.bean.Employee">
	select * from tbl_employee where lastname like #{lastName}
</select>

// 接口
public List<Employee> getEmpsByLastNameLike(String lastName);

// 测试
@Test
public void test06() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
        List<Employee> like = mapper.getEmpsByLastNameLike("%小%");
        for (Employee employee : like) {
            System.out.println(employee);
        }
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

4.2.2 resultType 返回值是 Map
4.2.2.1 返回一条记录
<!--public Map<String, Object> getEmpByIdReturnMap(Integer id);  -->
<select id="getEmpByIdReturnMap" resultType="map">
	select * from employee where id=#{id}
</select>

// 接口
// 返回一条记录的map，key就是列名，值就是对应的值。
public Map<String, Object> getEmpByIdReturnMap(Integer id);

// 测试
@Test
public void test07() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
        Map<String, Object> map = mapper.getEmpByIdReturnMap(1);
        System.out.println(map);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

4.2.2.2 返回多条记录
<!--public Map<Integer, Employee> getEmpByLastNameLikeReturnMap(String lastName); -->
<select id="getEmpByLastNameLikeReturnMap" resultType="com.ginger.mybatis.bean.Employee">
	select * from employee where lastname like #{lastName}
</select>

// 接口
// 多条记录封装一个 map：Map<String,Employee>：键是这条记录的主键，值是记录封装后的javaBean。
// @MapKey：告诉mybatis封装这个map的时候使用哪个属性作为map的key，要注意@MapKey指定的键类型要和返回值Map的键类型要一样,不然会报错。
@MapKey("lastName") // 如果返回值是map并且返回多条记录，要指定一下map的key值如果不指定也会报错。
public Map<String, Employee> getEmpByLastNameLikeReturnMap(String lastName);

// 测试
@Test
public void test08() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
        Map<String, Employee> map = mapper.getEmpByLastNameLikeReturnMap("%小%");
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.println(key+"---"+map.get(key));
        }
        System.out.println("--------------");
        System.out.println(map);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

4.3 resultMap

自定义resultMap，实现高级结果集映射。

constructor：类在实例化时，用来注入结果到构造方法中。
	idArg：ID 参数，标记结果作为 ID 可以帮助提高整体效能。
	arg：注入到构造方法的一个普通结果。
id：一个 ID 结果，标记结果作为 ID 可以帮助提高整体效能。
result：注入到字段或 JavaBean 属性的普通结果。
association：一个复杂的类型关联，许多结果将包成这种类型。
	嵌入结果映射：结果映射自身的关联，或者参考一个。
collection：复杂类型的集
	嵌入结果映射：结果映射自身的集,或者参考一个。
discriminator：使用结果值来决定使用哪个结果映射。
	case：基于某些值的结果映射
		嵌入结果映射：这种情形结果也映射它本身，因此可以包含很多相同的元素，或者它可以参照一个外部的结果映射。
4.3.1 id & result

id 和 result 映射一个单独列的值到简单数据类型(字符串，整型，双精度浮点数，日期等)的属性或字段。
在这里插入图片描述

<!--
	自定义某个javaBean的封装规则
	type：自定义规则的Java类型。
	id:唯一id方便引用。
-->
<resultMap id="MySimpleEmp" type="com.ginger.mybatis.bean.Employee">
	<!--
		指定主键列的封装规则。
		id定义主键会底层有优化。
		column：指定哪一列。
		property：指定对应的javaBean属性。
	-->
	<id column="id" property="id"/>
	<!-- 定义普通列封装规则，为了演示我将数据库中的lastname列改为last_name。-->
	<result column="last_name" property="lastName"/>
	<!-- 其他不指定的列会自动封装：我们只要写 resultMap 就把全部的映射规则都写上。 -->
	<!-- 如果数据库中有些列和javaBean的属性能够对应上其实不用写映射规则的，但是建议只要写 resultMap 就把全部的映射规则都写上。-->
	<result column="email" property="email"/>
	<result column="gender" property="gender"/>
</resultMap>

<!-- resultMap：自定义结果集映射规则。-->
<!-- public Employee getEmpById(Integer id); -->
<select id="getEmpById"  resultMap="MySimpleEmp">
	select * from tbl_employee where id=#{id}
</select>

// 接口
public Employee getEmpById(Integer id);

// 测试
@Test
public void test09() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
        Employee employee = mapper.getEmpById(1);
        System.out.println(employee);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

4.3.2 association

复杂对象映射。
POJO中的属性可能会是一个对象。
我们可以使用联合查询，并以级联属性的方式封装对象。

4.3.2.1 使用级联属性的方式封装对象
<!--
    场景一：
        查询Employee的同时查询员工对应的部门
        Employee===>Department
        一个员工有与之对应的部门信息；
        id  last_nam  email  gender  depa_id  did  dept_name (private Department dept)
-->
<!--
    联合查询：级联属性封装结果集。
    这里有个点一定要注意	employee，deparment	这两张表的id名称都是一样的一定要区别开来（可能都是使用第一个id），不然会有问题。
-->
<resultMap type="com.ginger.mybatis.bean.Employee" id="MyDifEmp">
    <id column="id" property="id"/>
    <result column="last_name" property="lastName"/>
    <result column="email" property="email"/>
    <result column="gender" property="gender"/>
    <result column="did" property="dept.id"/>
    <result column="depa_name" property="dept.departmentName"/>
</resultMap>

<!--public Employee getEmpAndDept(Integer id);-->
<select id="getEmpAndDept" resultMap="MyDifEmp">
	SELECT
      e.id,
      e.last_name last_name,
      e.email,
      e.gender,
      e.depa_id,
      d.id did,
      d.depa_name
    FROM
      employee e,
      department d
    WHERE d.id = e.depa_id
    AND d.id = #{id}
</select>

// 接口
public Employee getEmpAndDept(Integer id);

// 测试
@Test
public void test10() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
        Employee employee = mapper.getEmpAndDept(1);
        System.out.println(employee);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

4.3.2.2 association 标签定义对象的封装规则
<!--
	使用association定义关联的单个对象的封装规则。
-->
<resultMap type="com.ginger.mybatis.bean.Employee" id="MyDifEmp2">
    <id column="id" property="id"/>
    <result column="last_name" property="lastName"/>
    <result column="email" property="email"/>
    <result column="gender" property="gender"/>

    <!--
        association：可以指定联合的javaBean对象
        property="dept"：指定哪个属性是联合的对象
        javaType：指定这个属性对象的类型[不能省略]
    -->
    <association property="dept" javaType="com.ginger.mybatis.bean.Department">
        <id column="did" property="id"></id>
        <result column="depa_name" property="departmentName"></result>
    </association>
</resultMap>

<!--  public Employee getEmpAndDept(Integer id);-->
<select id="getEmpAndDept" resultMap="MyDifEmp2">
	SELECT
	  e.id,
	  e.last_name last_name,
	  e.email,
	  e.gender,
	  e.depa_id,
	  d.id did,
	  d.depa_name
	FROM
	  employee e,
	  department d
	WHERE d.id = e.depa_id
	AND d.id = #{id}
</select>

// 接口
public Employee getEmpAndDept(Integer id);

// 测试
@Test
public void test10() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
        Employee employee = mapper.getEmpAndDept(1);
        System.out.println(employee);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

4.3.2.3 association 分段查询
<!--EmployeeMapper.xml-->
<!--
    使用association进行分步查询：
        1、先按照员工id查询员工信息。
        2、根据查询员工信息中的d_id值去部门表查出部门信息。
        3、部门设置到员工中。
-->
<!--  id  last_name  email  gender  depa_id  -->
<resultMap type="com.ginger.mybatis.bean.Employee" id="MyDifEmp3">
    <id column="id" property="id"/>
    <result column="last_name" property="lastName"/>
    <result column="email" property="email"/>
    <result column="gender" property="gender"/>

    <!--
        association定义关联对象的封装规则
   		select：表明当前属性是调用select指定的方法查出的结果。
    	column：指定将哪一列的值传给这个方法。
	    流程：使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性。
	-->
    <association column="did"
                 select="com.ginger.mybatis.dao.DepartmentMapper.getDeptById"
                 property="dept"></association>
</resultMap>

<!--  public Employee getEmpByIdStep(Integer id);-->
<select id="getEmpByIdStep" resultMap="MyDifEmp3">
	select * from employee where id=#{id}
</select>

<!--DepartmentMapper.xml-->
<!--public Department getDeptById(Integer id);  -->
<select id="getDeptById" resultType="com.ginger.mybatis.bean.Department">
	select id,depa_name departmentName from department where id=#{id}
</select>

// EmployeeMapper接口
public Employee getEmpAndDept(Integer id);

// DepartmentMapper接口
public Department getDeptById(Integer id);

// 测试
@Test
public void test11() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
        Employee employee = mapper.getEmpAndDept(3);
        System.out.println(employee);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

4.3.2.3 association 分段查询延迟加载
其实可以使用延迟加载（懒加载）(按需加载):
	Employee===>Dept：
		我们每次查询Employee对象的时候，都将一起查询出来。
		部门信息在我们使用的时候再去查询。
		分段查询的基础之上加上两个配置。

在 Mybatis 的主配置文件中，在 setttings 中加入开启延迟加载配置。
在这里插入图片描述

<settings>
	<!--显示的指定每个我们需要更改的配置的值，即使他是默认的。防止版本更新带来的问题  -->
	<setting name="lazyLoadingEnabled" value="true"/>
	<setting name="aggressiveLazyLoading" value="false"/>
</settings>

旧版本的 MyBatis 需要额外的支持包。

  • asm-3.3.1.jar
  • cglib-2.2.2.jar

我还是用上面的测试类测试有延迟加载没有延迟加载到底是怎么样的。

// 测试
@Test
public void test11() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
        Employee employee = mapper.getEmpAndDept(3);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述
在这里插入图片描述

4.3.3 collection
4.3.3.1 collection 标签定义对象的封装规则
<!-- 
	场景二：
		查询部门的时候将部门对应的所有员工信息也查询出来。
-->
<!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则-->
<resultMap type="com.ginger.mybatis.bean.Department" id="MyDept">
	<id column="id" property="id"/>
	<result column="depa_name" property="departmentName"/>
	<!-- 
		collection：定义关联集合类型的属性的封装规则
		ofType：指定集合里面元素的类型
	-->
	<collection property="emps" ofType="com.ginger.mybatis.bean.Employee">
		<!-- 定义这个集合中元素的封装规则 -->
		<id column="eid" property="id"/>
		<result column="last_name" property="lastName"/>
		<result column="email" property="email"/>
		<result column="gender" property="gender"/>
	</collection>
</resultMap>

<!-- public Department getDeptByIdPlus(Integer id); -->
<select id="getDeptByIdPlus" resultMap="MyDept">
	SELECT
	  d.id,
	  d.depa_name,
	  e.id eid,
	  e.last_name,
	  e.email,
	  e.gender,
	  e.depa_id
	FROM
	  department d
	  LEFT JOIN employee e
		ON d.id = e.depa_id
	WHERE d.id = #{id}
</select>

// 接口
public Department getDeptByIdPlus(Integer id);

// 测试
@Test
public void test13() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        DepartmentMapper mapper = openSession.getMapper(DepartmentMapper.class);
        Department department =   mapper.getDeptByIdPlus(1);
        System.out.println(department);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

4.3.3.2 collection 分段查询
<!-- DepartmentMapper.xml -->
<!-- collection：分段查询 -->
<resultMap type="com.ginger.mybatis.bean.Department" id="MyDept2">
	<id column="id" property="id"/>
	<id column="depa_name" property="departmentName"/>
	<collection property="emps" 
		select="com.ginger.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
		column="id" ></collection>
</resultMap>

<!-- public Department getDeptByIdStep(Integer id); -->
<select id="getDeptByIdStep" resultMap="MyDept2">
	select id,depa_name from department where id=#{id}
</select>

<!-- EmployeeMapperPlus.xml -->
<!-- public List<Employee> getEmpsByDeptId(Integer deptId); -->
<select id="getEmpsByDeptId" resultType="com.ginger.mybatis.bean.Employee">
    select * from employee where depa_id=#{deptId}
</select>

// 接口
public Department getDeptByIdStep(Integer id);

// 接口
public List<Employee> getEmpsByDeptId(Integer deptId);

// 测试
@Test
public void test14() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        DepartmentMapper mapper = openSession.getMapper(DepartmentMapper.class);
        Department department =   mapper.getDeptByIdStep(1);
        System.out.println(department);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

4.3.3.3 collection分段查询延迟加载

在 Mybatis 的主配置文件中，在setttings中加入开启延迟加载配置。
在这里插入图片描述

<settings>
	<!--显示的指定每个我们需要更改的配置的值，即使他是默认的。防止版本更新带来的问题 -->
	<setting name="lazyLoadingEnabled" value="true"/>
	<setting name="aggressiveLazyLoading" value="false"/>
</settings>

我还是用上面的测试类测试有延迟加载没有延迟加载到底是怎么样的。

@Test
public void test14() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        DepartmentMapper mapper = openSession.getMapper(DepartmentMapper.class);
        Department department =   mapper.getDeptByIdStep(1);

        System.out.println(department.getDepartmentName());

        System.out.println(department.getEmps());
    } finally {
        openSession.close();
    }
}

在这里插入图片描述
在这里插入图片描述

4.3.3.4 collection扩展
  • 分步查询的时候通过column指定，将对应的列的数据传递过去，我们有时需要传递多列数据。
  • 使用{key1=column1,key2=column2…}的形式。
  • association 或者 collection 标签的 fetchType=eager/lazy 可以覆盖全局的延迟加载策略，指定立即加载（eager）或者延迟加载（lazy）。
扩展：多列的值传递过去
	将多列的值封装map传递。
	column="{key1=column1,key2=column2}"
	fetchType="lazy"（默认）：表示使用延迟加载，在association，collection标签中都有这个属性，就算开启了全局延迟加载，在这两个标签上也可以开启和关闭。
		- lazy：延迟
		- eager：立即

<!-- collection：分段查询 -->
<resultMap type="com.ginger.mybatis.bean.Department" id="MyDept2">
	<id column="id" property="id"/>
	<id column="depa_name" property="departmentName"/>
	<collection property="emps"
		select="com.ginger.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
			<!-- 
				{deptId=id} 这样可以传递多个值，这个键要和EmployeeMapperPlus.xml的sql中的键值要对应上，不然获取不到值。
				select * from employee where depa_id=#{deptId} 这个sql是EmployeeMapperPlus.xml文件中的。
			-->
			column="{deptId=id}" fetchType="lazy"></collection>
</resultMap>

<!-- public Department getDeptByIdStep(Integer id); -->
<select id="getDeptByIdStep" resultMap="MyDept2">
	select id,depa_name from department where id=#{id}
</select>

// 测试
@Test
public void test14() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        DepartmentMapper mapper = openSession.getMapper(DepartmentMapper.class);
        Department department =   mapper.getDeptByIdStep(1);
        System.out.println(department);
    } finally {
        openSession.close();
    }
}

这样也是可行的。
在这里插入图片描述

4.3.4 discriminator
<!-- EmployeeMapperPlus.xml -->
<!--
	<discriminator javaType=""></discriminator>
	鉴别器：mybatis可以使用discriminator判断某列的值，然后根据某列的值改变封装行为。
	封装Employee：
		如果查出的是女生：就把部门信息查询出来，否则不查询。
		如果是男生，把last_name这一列的值赋值给email。
-->
<resultMap id="MyDisEmp" type="com.ginger.mybatis.bean.Employee">
    <id column="id" property="id"/>
    <result column="last_name" property="lastName"/>
    <result column="email" property="email"/>
    <result column="gender" property="gender"/>
    <!--
        column：指定判定的列名
        javaType：列值对应的java类型
    -->
    <discriminator javaType="string" column="gender">
        <!--女生：resultType：指定封装的结果类型，不能缺少。或者指定resultMap封装规则也可以。-->
        <case value="0" resultType="com.ginger.mybatis.bean.Employee">
            <association column="depa_id"
                         select="com.ginger.mybatis.dao.DepartmentMapper.getDeptById"
                         property="dept"
                         fetchType="eager">
            </association>
        </case>
        <!--男生：如果是男生，把last_name这一列的值赋值给email。 -->
        <case value="1" resultType="com.ginger.mybatis.bean.Employee">
            <id column="id" property="id"/>
            <result column="last_name" property="lastName"/>
            <result column="last_name" property="email"/>
            <result column="gender" property="gender"/>
        </case>
    </discriminator>
</resultMap>

<!--public Employee getEmpByIdStep(Integer id);-->
<select id="getEmpByIdStep" resultMap="MyDisEmp">
    select * from employee where id=#{id}
</select>

<!-- DepartmentMapper.xml -->
<!-- collection：分段查询 -->
<resultMap type="com.ginger.mybatis.bean.Department" id="MyDept2">
	<id column="id" property="id"/>
	<id column="depa_name" property="departmentName"/>
	<collection property="emps"
		select="com.ginger.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
			column="{deptId=id}" fetchType="lazy"></collection>
</resultMap>

<!-- public Department getDeptByIdStep(Integer id); -->
<select id="getDeptByIdStep" resultMap="MyDept2">
	select id,depa_name from department where id=#{id}
</select>

// 接口
public Employee getEmpByIdStep(Integer id);

// 接口
public Department getDeptById(Integer id);

// 测试
@Test
public void test15() throws IOException {
    // 1、获取sqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    // 2、获取sqlSession对象
    SqlSession openSession = sqlSessionFactory.openSession();
    try {
        // 3、获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
        Employee employee1 = mapper.getEmpByIdStep(1);
        System.out.println(employee1);
        System.out.println("----------------------");
        Employee employee2 = mapper.getEmpByIdStep(4);
        System.out.println(employee2);
    } finally {
        openSession.close();
    }
}

在这里插入图片描述

gingerMr_程序人生
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mybatis教程3(映射文件)
波波烤鸭的博客
01-20 3404
MyBatis 的真正强大在于它的映射语句，也是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 就是针对 SQL 构建的，并且比普通的方法做的更好。 log4j 在程序的运行的过程中为了便于查询sql的输出，需要引入log4j 添加依赖 &amp;amp;amp;amp;amp;lt;dependency&amp;amp;amp;amp;amp;...
MyBatis开发 1
Liuxin2448的博客
04-22 193
MVC模型 Model模型：JavaBean实现，用于封装业务数据UserBean和业务逻辑UserDaoImpl View视图：JSP+JSTL实现，用于收集客户动作<form>和显示业务数据<table> Controller控制器：Servlet实现，用于流程控制 MyBatis开发步骤 1、添加依赖 <dependency> <groupId>org.mybatis</groupId> &l
Mybatis-generator逆向工程
ak12313546的博客
02-08 1458
$.Mybatis-generator介绍 MyBatis Generator（MBG）是MyBatisMyBatis和iBATIS的代码生成器。它将为所有版本的MyBatis以及版本2.2.0之后的iBATIS版本生成代码。它将内省数据库表（或许多表），并将生成可用于访问表的工件。这减少了设置对象和配置文件以与数据库表交互的初始麻烦。MBG寻求对简单CRUD（创建，检索，更新，删...
MyBatis(三)映射文件
weixin_44966780的博客
10-16 416
映射文件
Mybatis 之 MyBatis3 的SQL 映射文件与动态SQL
渡西湖
06-20 1507
Mybatis 之 MyBatis3 的SQL 映射文件与动态SQL        MyBatis 框架是基于SQL 映射的，所以SQL 映射文件在此框架中的位置非常重要.动态SQL 是MyB atis 提供的， 它根据指定的条件来执行指定的SQL 语句， 它使SQL 映射文件中的SQL 语句在执行时具有动态性.&lt;resultMap &gt;标签在&lt;select&gt;标签中使用res...
关于MyBatis找不到映射文件的问题
09-06
一、MyBatis映射文件的配置 在MyBatis中，映射文件是用于定义SQL语句和Java对象之间的映射关系的配置文件。通常情况下，映射文件会被放在资源目录（resources）下的某个子目录（如mapper）下。在MyBatis的核心配置...
MybatisGenerate_代码生成_tkMybatis_mybatisgenerate_mybatis_
10-03
3. **运行生成**：配置完成后，运行MybatisGenerate，它会根据你的配置自动扫描数据库中的表，并生成相应的代码文件。这一步骤通常是自动化的，避免了手动创建和编辑大量文件的工作。 4. **自定义扩展**：如果你有...
MyBatis_3_User_Guide.zip_mybatis_mybatis api
09-24
这份"MyBatis_3_User_Guide.zip"压缩包内包含的"MyBatis_3_User_Guide.pdf"文档，是MyBatis 3的用户指南，它全面解析了MyBatis框架的核心功能和使用方法。以下是一些主要知识点的详细说明： 1. **配置文件**：...
Mybatis_dao.rar_mybatis dao_mybatis_dao.rar
09-21
这个压缩包文件"**Mybatis_dao.rar_mybatis_dao_mybatis_dao.rar**"包含了实现这个集成项目的相关资源，特别是DAO（数据访问对象）部分，这是业务逻辑与数据库交互的关键组件。 首先，让我们深入了解一下Mybatis。...
Mybatis中Mapper映射文件使用详解
08-19
Mapper映射文件是一个xml格式文件，必须遵循相应的dtd文件规范，如ibatis-3-mapper.dtd。Mapper映射文件的主要作用是将Java方法与SQL语句进行映射，使得Mybatis可以根据Java方法的调用来执行相应的SQL语句。 Mapper...
MyBatis 3.4 中文手册
05-11
MyBatis 3.4 中文手册，包括手册、源代码xref、Java api doc、测试源代码xref。 文档日期： 17 四月 2016 | 版本: 3.4.0 chm编日期：2016年5月11日 文件大小：2.98MB
使用MyBatis Generator自动创建代码
03-06
使用MyBatis Generator自动创建代码,有问题留言，下载地址：https://blog.csdn.net/qq_40374604/article/details/88242892
mybatis三种映射方式
qq_17690301的博客
01-18 6757
mybatis有三种映射ORM的方式：纯xml文件映射，基于xml的接口映射以及基于注解的接口映射 以一个例子来说明：这里有一个商品类Product（映射到表product_），类均放在包com.pojo下 Product类 public class Product { int id; String name; float price; public int getId() { ...
MyBatis 4
二月
01-28 239
文章目录第四天Mybatis 延迟加载策略使用 assocation 实现延迟加载使用 Collection 实现延迟加载Mybatis 缓存Mybatis中的一级缓存和二级缓存Mybatis 注解开发mybatis 的常用注解说明使用 Mybatis 注解实现基本 CRUD 第四天 Mybatis 延迟加载策略 延迟加载? 立即加载？ Mybatis 缓存 缓存？ 何时缓存 Mybatis 一级缓存 Mybatis 二级缓存 Mybatis 注解开发 使用 Mybat
Mybatis3 （2）xml映射文件
sean的博客
11-15 385
SQL 映射文件有很少的几个顶级元素（按照它们应该被定义的顺序）： cache – 给定命名空间的缓存配置。 cache-ref – 其他命名空间缓存配置的引用。 resultMap – 是最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象。 parameterMap – 已废弃！老式风格的参数映射。内联参数是首选,这个元素可能在将来被移除，这里不会记录。 sql – 可被其他语句引...
MyBatis3 ---- 高级映射
qq_40535097的博客
05-19 426
MyBatis(3) ---- 高级映射 mybatis 执行过程 配置MybatisCfg.xml 文件 编写mapper.xml, 编写sql 在MybatisCfg.xml 内注册mapper.xml 创建SqlSessionFactory 创建SqlSession 使用SqlSession操作数据库（如要提交事务，需要使用commit()） 释放资源 Mybatis 开发Dao 原始...
MyBatis3-映射文件
maniacxx的博客
04-24 282
三.映射文件 &gt;映射文件指导着MyBatis如何进行数据库增删改查， 有着非常重要的意义； •resultMap – 自定义结果集映射 •insert – 映射插入语句 •update – 映射更新语句 •delete – 映射删除语句 •select – 映射查询语句 3.1 insert &lt;!--public void addEmp(Employee emplo...
mybatis教程4(动态SQL)
波波烤鸭的博客
01-22 3442
动态SQL语句 MyBatis 的强大特性之一便是它的动态 SQL。如果你有使用 JDBC 或其它类似框架的经验，你就能体会到根据不同条件拼接 SQL 语句的痛苦。例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL 这一特性可以彻底摆脱这种痛苦。 虽然在以前使用动态 SQL 并非一件易事，但正是 MyBatis 提供了可以被用在任意 SQL 映射语句中的...
MyBatis_4
CBXdm的博客
11-09 161
MyBatis_4 一、Sql映射文件中的parameterType属性传入参数 【insert/update/delete/select元素的输入参数】 parameterType属性传入参数 1.String+基本类型 【String—java.lang.String,int/boolean,java.lang.Integer】 2.POJO类型【对象型】 com.wangxing.bean.Student 3.集合类型【list,hashMap】 当数据访问接口的方法只有一个参数的时候【Strin
mybatis如何创建映射文件
最新发布
07-29
下面是创建MyBatis映射文件的步骤： 1. 创建映射文件： 首先，我们需要创建一个XML文件，用于存储MyBatis的映射信息。一般将其命名为"xxxMapper.xml"，其中"xxx"是对应的Java对象或数据库表的名称。 2. 定义命名...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值