MyBatis(上)

最新推荐文章于 2022-06-06 21:13:42 发布
最新推荐文章于 2022-06-06 21:13:42 发布
阅读量219 收藏 1
点赞数 1
分类专栏： 学习笔记 mysql 文章标签： sql java 数据库 mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/real_rookie/article/details/119992387
版权

MyBatis （上）

HelloWord 接口式编程

/**
 * 1、根据xml配置文件（全局配置文件）创建一个SqlSessionFactory对象 有数据源一些运行环境信息
 * 2、sql映射文件；配置了每一个sql，以及sql的封装规则等。
 * 3、将sql映射文件注册在全局配置文件中
 * 4、写代码：
 * 		1）、根据全局配置文件得到SqlSessionFactory；
 * 		2）、使用sqlSession工厂，获取到sqlSession对象使用他来执行增删改查
 * 			一个sqlSession就是代表和数据库的一次会话，用完关闭
 * 		3）、使用sql的唯一标志来告诉MyBatis执行哪个sql。sql都是保存在sql映射文件中的。
 *
 * @throws IOException
 */
@Test
public void test01() throws IOException {
    //1、获取SqlSessionFactory
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();

    //2、获取 sqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession();

    try {

        //3、获取接口的实现类对象
        EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);

        Employee employee = mapper.getEmpById(1);
        System.out.println(mapper.getClass());

        System.out.println(employee);
    }finally {
        sqlSession.close();
    }

}

-----------------------------------
public interface EmployeeMapper {
	public Employee getEmpById(Integer id);
}
-----------------------------------
public class Employee {
	private Integer id;
	private String lastName;
	private String email;
	private String gender;
}

---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.atguigu.mybatis.dao.EmployeeMapper">
<!-- 
namespace:名称空间;指定为接口的全类名
id：唯一标识
resultType：返回值类型
#{id}：从传递过来的参数中取出id值

public Employee getEmpById(Integer id);
 -->
	<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee">
		select id,last_name lastName,email,gender from tbl_employee where id = #{id}
	</select>
</mapper>


------------------------------配置文件

<?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>
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.jdbc.Driver" />
				<property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
				<property name="username" value="root" />
				<property name="password" value="123456" />
			</dataSource>
		</environment>
	</environments>
	<!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
	<mappers>
		<mapper resource="EmployeeMapper.xml" />
	</mappers>
</configuration>

全局配置文件

引入dtd文件

在这里插入图片描述

setting设置

这是 MyBatis 中极为重要的调整设置，它们会改变MyBatis 的运行时行为。
在这里插入图片描述

typeAliases_别名

<typeAliases>
	<!-- 1、typeAlias:为某个java类型起别名
			type:指定要起别名的类型全类名;默认别名就是类名小写；employee
			alias:指定新的别名
	 -->
	<!-- <typeAlias type="com.atguigu.mybatis.bean.Employee" alias="emp"/> -->
	
	<!-- 2、package:为某个包下的所有类批量起别名 
			name：指定包名（为当前包以及下面所有的后代包的每一个类都起一个默认别名（类名小写），）
	-->
	<package name="com.atguigu.mybatis.bean"/>
	
	<!-- 3、批量起别名的情况下，使用@Alias注解为某个类型指定新的别名 -->
</typeAliases>

enviroments_运行环境

<!-- 
	4、environments：环境们，mybatis可以配置多种环境 ,default指定使用某种环境。可以达到快速切换环境。
		environment：配置一个具体的环境信息；必须有两个标签；id代表当前环境的唯一标识
			transactionManager：事务管理器；
				type：事务管理器的类型;JDBC(JdbcTransactionFactory)|MANAGED(ManagedTransactionFactory)
					自定义事务管理器：实现TransactionFactory接口.type指定为全类名
			
			dataSource：数据源;
				type:数据源类型;UNPOOLED(UnpooledDataSourceFactory)
							|POOLED(PooledDataSourceFactory)
							|JNDI(JndiDataSourceFactory)
				自定义数据源：实现DataSourceFactory接口，type是全类名
	 -->
	 

	 
<environments default="dev_mysql">
	<environment id="dev_mysql">
		<transactionManager type="JDBC"></transactionManager>
		<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>

	<environment id="dev_oracle">
		<transactionManager type="JDBC" />
		<dataSource type="POOLED">
			<property name="driver" value="${orcl.driver}" />
			<property name="url" value="${orcl.url}" />
			<property name="username" value="${orcl.username}" />
			<property name="password" value="${orcl.password}" />
		</dataSource>
	</environment>
</environments>

databaseIdProvider_多数据库支持

<!-- 5、databaseIdProvider：支持多数据库厂商的；
	 type="DB_VENDOR"：VendorDatabaseIdProvider
	 	作用就是得到数据库厂商的标识(驱动getDatabaseProductName())，mybatis就能根据数据库厂商标识来执行不同的sql;
	 	MySQL，Oracle，SQL Server,xxxx
  -->
<databaseIdProvider type="DB_VENDOR">
	<!-- 为不同的数据库厂商起别名 -->
	<property name="MySQL" value="mysql"/>
	<property name="Oracle" value="oracle"/>
	<property name="SQL Server" value="sqlserver"/>
</databaseIdProvider>

mappers_sql映射注册

<!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
<!-- 6、mappers：将sql映射注册到全局配置中 -->
<mappers>
	<!-- 
		mapper:注册一个sql映射 
			注册配置文件
			resource：引用类路径下的sql映射文件
				mybatis/mapper/EmployeeMapper.xml
			url：引用网路路径或者磁盘路径下的sql映射文件
				file:///var/mappers/AuthorMapper.xml
				
			注册接口
			class：引用（注册）接口，
				1、有sql映射文件，映射文件名必须和接口同名，并且放在与接口同一目录下；
				2、没有sql映射文件，所有的sql都是利用注解写在接口上;
				推荐：
					比较重要的，复杂的Dao接口我们来写sql映射文件
					不重要，简单的Dao接口为了开发快速可以使用注解；
	-->
	<!-- <mapper resource="mybatis/mapper/EmployeeMapper.xml"/> -->
	<!-- <mapper class="com.atguigu.mybatis.dao.EmployeeMapperAnnotation"/> -->
	
	<!-- 批量注册： -->
	<package name="com.atguigu.mybatis.dao"/>
</mappers>

映射文件

增删改查

删改

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

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

insert_获取自增主键的值

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

Oracle使用序列生成主键演示

<!-- 
获取非自增主键的值：
	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运行顺序：
		先运行插入的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<!-- ,jdbcType=NULL -->}) 
	<!-- AFTER：
	insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL) 
	values(employees_seq.nextval,#{lastName},#{email}) -->
</insert>

参数处理

单个参数&多个参数&命名参数

单个参数：mybatis不会做特殊处理，
	#{参数名/任意名}：取出参数值。
	
多个参数：mybatis会做特殊处理。
	多个参数会被封装成 一个map，
		key：param1...paramN,或者参数的索引也可以
		value：传入的参数值
	#{}就是从map中获取指定的key的值；
	
	异常：
	org.apache.ibatis.binding.BindingException: 
	Parameter 'id' not found. 
	Available parameters are [1, 0, param1, param2]
	操作：
		方法：public Employee getEmpByIdAndLastName(Integer id,String lastName);
		取值：#{id},#{lastName}

【命名参数】：明确指定封装参数时map的key；@Param("id")
	多个参数会被封装成 一个map，
		key：使用@Param注解指定的值
		value：参数值
	#{指定的key}取出对应的参数值

Employee getEmpByIdAndLastName(@Param("id")Integer id, @Param("lastName")String lastName);

<select id="getEmpByIdAndLastName" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where id = #{id} and last_name=#{lastName}
</select>

POJO&Map&TO

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

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

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

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

参数封装扩展思考

========================思考================================	
public Employee getEmp(@Param("id")Integer id,String lastName);
	取值：id==>#{id/param1}   lastName==>#{param2}

public Employee getEmp(Integer id,@Param("e")Employee emp);参数会被封装在map
	取值：id==>#{param1}    lastName===>#{param2.lastName/e.lastName}

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

结合源码参数封装map的过程
ParamNameResolver解析参数封装：
总结：参数多时会封装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;
    }
  }
}

参数值的获取：#与$取值区别
#{}：可以获取map中的值或者pojo对象属性的值；
${}：可以获取map中的值或者pojo对象属性的值；

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

#{}:更丰富的用法：
	规定参数的一些规则：
	javaType、 jdbcType、 mode（存储过程）、 numericScale、
	resultMap、 typeHandler、 jdbcTypeName、 expression（未来准备支持的功能）；

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

select

返回List

List<Employee> getEmpsByLastNameLike(String lastName);
------------------
List<Employee> like = mapper.getEmpsByLastNameLike("%e%");
for (Employee employee : like) {
	System.out.println(employee);
}

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

记录封装map

//多条记录封装一个map：Map<Integer,Employee>:键是这条记录的主键，值是记录封装后的javaBean
//@MapKey:告诉mybatis封装这个map的时候使用哪个属性作为map的key
@MapKey("lastName")
Map<String, Employee> getEmpByLastNameLikeReturnMap(String lastName);
//返回一条记录的map；key就是列名，值就是对应的值
Map<String, Object> getEmpByIdReturnMap(Integer id);
---------------------------
Map<String, Object> map = mapper.getEmpByIdReturnMap(1);
System.out.println(map);
Map<String, Employee> map = mapper.getEmpByLastNameLikeReturnMap("%r%");
System.out.println(map);

<!--public Map<Integer, Employee> getEmpByLastNameLikeReturnMap(String lastName);  -->
<select id="getEmpByLastNameLikeReturnMap" resultType="com.atguigu.mybatis.bean.Employee">
	select * from tbl_employee where last_name like #{lastName}
</select>

<!--public Map<String, Object> getEmpByIdReturnMap(Integer id);  -->
<select id="getEmpByIdReturnMap" resultType="map">
	select * from tbl_employee where id=#{id}
</select>

resultMap_自定义结果映射规则

<!--自定义某个javaBean的封装规则
type：自定义规则的Java类型
id:唯一id方便引用
  -->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MySimpleEmp">
	<!--指定主键列的封装规则
	id定义主键会底层有优化；
	column：指定哪一列
	property：指定对应的javaBean属性
	  -->
	<id column="id" property="id"/>
	<!-- 定义普通列封装规则 -->
	<result column="last_name" property="lastName"/>
	<!-- 其他不指定的列会自动封装：我们只要写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>

resultMap_关联查询_级联属性封装结果

<!-- 
场景一：
	查询Employee的同时查询员工对应的部门
	Employee===Department
	一个员工有与之对应的部门信息；
	id  last_name  gender    d_id     did  dept_name (private Department dept;)
 -->
 
 
<!--
	联合查询：级联属性封装结果集
  -->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp">
	<id column="id" property="id"/>
	<result column="last_name" property="lastName"/>
	<result column="gender" property="gender"/>
	<result column="did" property="dept.id"/>
	<result column="dept_name" property="dept.departmentName"/>
</resultMap>


<!--  Employee getEmpAndDept(Integer id);-->
<select id="getEmpAndDept" resultMap="MyDifEmp">
	SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,
	d.id did,d.dept_name dept_name FROM tbl_employee e,tbl_dept d
	WHERE e.d_id=d.id AND e.id=#{id}
</select>

resultMap_关联查询_association定义关联对象封装规则
嵌套结果集

<!-- 
	使用association定义关联的单个对象的封装规则；
 -->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp2">
	<id column="id" property="id"/>
	<result column="last_name" property="lastName"/>
	<result column="gender" property="gender"/>
	
	<!--  association可以指定联合的javaBean对象
	property="dept"：指定哪个属性是联合的对象
	javaType:指定这个属性对象的类型[不能省略]
	-->
	<association property="dept" javaType="com.atguigu.mybatis.bean.Department">
		<id column="did" property="id"/>
		<result column="dept_name" property="departmentName"/>
	</association>
</resultMap>

resultMap_关联查询_association分步查询

<!-- 使用association进行分步查询：
	1、先按照员工id查询员工信息
	2、根据查询员工信息中的d_id值去部门表查出部门信息
	3、部门设置到员工中；
 -->
 <!--  id  last_name  email   gender    d_id   -->
 <resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpByStep">
 	<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 property="dept" 
		这里的select调用了其他mapper文件中的查询 
 		select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
 		column="d_id">
		</association>
 </resultMap>
 <!--  public Employee getEmpByIdStep(Integer id);-->
 <select id="getEmpByIdStep" resultMap="MyEmpByStep">
 	select * from tbl_employee where id=#{id}
 	<if test="_parameter!=null">
 		and 1=1
 	</if>
 </select>

---------另一个mapper文件-----------

<!--public Department getDeptById(Integer id);  -->
<select id="getDeptById" resultType="com.atguigu.mybatis.bean.Department">
	select id,dept_name departmentName from tbl_dept where id=#{id}
</select>

resultMap_关联查询_分步查询&延迟加载

	 <!-- 可以使用延迟加载（懒加载）；(按需加载)
	 	Employee==>Dept：
	 		我们每次查询Employee对象的时候，都将一起查询出来。
	 		部门信息在我们使用的时候再去查询；
	 		分段查询的基础之上加上两个配置：
	  -->
-------全局配置文件--------
<settings>
	<!--显示的指定每个我们需要更改的配置的值，即使他是默认的。防止版本更新带来的问题  -->
	懒加载开启，关联的值在需要的时候
	<setting name="lazyLoadingEnabled" value="true"/>
	侵入懒加载
	<setting name="aggressiveLazyLoading" value="false"/>
</settings>

resultMap_关联查询_collection定义关联集合封装规则

<!-- 
public class Department {
		private Integer id;
		private String departmentName;
		private List<Employee> emps;
  did  dept_name  ||  eid  last_name  email   gender  
 -->
 
<!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则  -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDept">
	<id column="did" property="id"/>
	<result column="dept_name" property="departmentName"/>
	<!-- 
		collection定义关联集合类型的属性的封装规则 
		ofType:指定集合里面元素的类型
	-->
	<collection property="emps" ofType="com.atguigu.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 did,d.dept_name dept_name,
			e.id eid,e.last_name last_name,e.email email,e.gender gender
	FROM tbl_dept d
	LEFT JOIN tbl_employee e
	ON d.id=e.d_id
	WHERE d.id=#{id}
</select>

Association和Collection使用时机区别:

Association 在一对一,多对一时使用
Collection 在一对多,多对多时使用

在association标签中 javaType属性指向的是实体类的属性
在collection标签中 javaType属性指向的是集合的类型 ofType指向的是集合的泛型类型

resultMap_关联查询_collection分步查询&延迟加载

<!-- collection：分段查询 -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDeptStep">
	<id column="id" property="id"/>
	<id column="dept_name" property="departmentName"/>
	<collection property="emps" 
		select="com.atguigu.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
		column="{deptId=id}" fetchType="lazy"></collection>
</resultMap>
<!-- public Department getDeptByIdStep(Integer id); -->
<select id="getDeptByIdStep" resultMap="MyDeptStep">
	select id,dept_name from tbl_dept where id=#{id}
</select>
<!-- 扩展：分步查询 多列的值传递过去：
		将多列的值封装map传递；
		column="{key1=column1,key2=column2}"
	fetchType="lazy"：表示使用延迟加载；
			- lazy：延迟
			- eager：立即
 -->

--------------------

<!-- public List<Employee> getEmpsByDeptId(Integer deptId); -->
<select id="getEmpsByDeptId" resultType="com.atguigu.mybatis.bean.Employee">
	select * from tbl_employee where d_id=#{deptId}
</select>

resultMap_discriminator鉴别器

<!-- <discriminator javaType=""></discriminator>
	鉴别器：mybatis可以使用discriminator判断某列的值，然后根据某列的值改变封装行为
	封装Employee：
		如果查出的是女生：就把部门信息查询出来，否则不查询；
		如果是男生，把last_name这一列的值赋值给email;
 -->
 <resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpDis">
 	<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.atguigu.mybatis.bean.Employee">
 			<association property="dept" 
		 		select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
		 		column="d_id">
	 		</association>
 		</case>
 		<!--男生 ;如果是男生，把last_name这一列的值赋值给email; -->
 		<case value="1" resultType="com.atguigu.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>

动态sql

简介

以往的JDBC按照条件拼接sql很痛苦，而mybatis如同jstl语句使用

  • if:判断
  • choose (when, otherwise):分支选择；带了break的switch-case
    如果带了id就用id查，如果带了lastName就用lastName查;只会进入其中一个
  • trim 字符串截取(where(封装查询条件), set(封装修改条件))
  • foreach 遍历集合

if_判断&where&OGNL

查询的时候如果某些条件没带可能sql拼装会有问题
1、给where后面加上1=1，以后的条件都and xxx.
2、mybatis使用where标签来将所有的查询条件包括在内。mybatis就会将where标签中拼装的sql，多出来的and或者or去掉
where只会去掉第一个多出来的and或者or。所以注意and要写条件前面

 <!-- 查询员工，要求，携带了哪个字段查询条件就带上这个字段的值 -->
 <!-- public List<Employee> getEmpsByConditionIf(Employee employee); -->
 <select id="getEmpsByConditionIf" resultType="com.atguigu.mybatis.bean.Employee">
 	select * from tbl_employee
 	<!-- where -->
 	<where>
	 	<!-- test：判断表达式（OGNL）
	 	OGNL参照PPT或者官方文档。
	 	  	 c:if  test
	 	从参数中取值进行判断
	 	
	 	遇见特殊符号应该去写转义字符：
	 	&&：&amp;&amp;
	 	-->
	 	<if test="id!=null">
	 		id=#{id}
	 	</if>
	 	<if test="lastName!=null &amp;&amp; lastName!=&quot;&quot;">
	 		and last_name like #{lastName}
	 	</if>
	 	<if test="email!=null and email.trim()!=&quot;&quot;">
	 		and email=#{email}
	 	</if> 
	 	<!-- ognl会进行字符串与数字的转换判断  "0"==0 -->
	 	<if test="gender==0 or gender==1">
	 	 	and gender=#{gender}
	 	</if>
 	</where>
 </select>

trim_自定义字符串截取

 <!--public List<Employee> getEmpsByConditionTrim(Employee employee);  -->
 <select id="getEmpsByConditionTrim" resultType="com.atguigu.mybatis.bean.Employee">
 	select * from tbl_employee
 	<!-- 后面多出的and或者or where标签不能解决 
 	prefix="":前缀：trim标签体中是整个字符串拼串 后的结果。
 			prefix给拼串后的整个字符串加一个前缀 
 	prefixOverrides="":
 			前缀覆盖： 去掉整个字符串前面多余的字符
 	suffix="":后缀
 			suffix给拼串后的整个字符串加一个后缀 
 	suffixOverrides=""
 			后缀覆盖：去掉整个字符串后面多余的字符
 			
 	-->
 	<!-- 自定义字符串的截取规则 -->
 	<trim prefix="where" suffixOverrides="and">
 		<if test="id!=null">
	 		id=#{id} and
	 	</if>
	 	<if test="lastName!=null &amp;&amp; lastName!=&quot;&quot;">
	 		last_name like #{lastName} and
	 	</if>
	 	<if test="email!=null and email.trim()!=&quot;&quot;">
	 		email=#{email} and
	 	</if> 
	 	<!-- ognl会进行字符串与数字的转换判断  "0"==0 -->
	 	<if test="gender==0 or gender==1">
	 	 	gender=#{gender}
	 	</if>
	 </trim>
 </select>

choose_分支选择

只会进入其中一个

<!-- public List<Employee> getEmpsByConditionChoose(Employee employee); -->
<select id="getEmpsByConditionChoose" resultType="com.atguigu.mybatis.bean.Employee">
	select * from tbl_employee 
	<where>
		<!-- 如果带了id就用id查，如果带了lastName就用lastName查;只会进入其中一个 -->
		<choose>
			<when test="id!=null">
				id=#{id}
			</when>
			<when test="lastName!=null">
				last_name like #{lastName}
			</when>
			<when test="email!=null">
				email = #{email}
			</when>
			<otherwise>
				gender = 0
			</otherwise>
		</choose>
	</where>
</select>

set_与if结合的动态更新

<!--public void updateEmp(Employee employee);  -->
<update id="updateEmp">
	<!-- Set标签的使用 -->
	update tbl_employee 
<set>
	<if test="lastName!=null">
		last_name=#{lastName},
	</if>
	<if test="email!=null">
		email=#{email},
	</if>
	<if test="gender!=null">
		gender=#{gender}
	</if>
</set>
where id=#{id} 
</update>

foreach_遍历集合

<!-- List<Employee> getEmpsByConditionForeach(List<Integer> ids);  -->
<select id="getEmpsByConditionForeach" resultType="com.atguigu.mybatis.bean.Employee">
	select * from tbl_employee
	<!--
		collection：指定要遍历的集合：
			list类型的参数会特殊处理封装在map中，map的key就叫list
		item：将当前遍历出的元素赋值给指定的变量
		separator:每个元素之间的分隔符
		open：遍历出所有结果拼接一个开始的字符
		close:遍历出所有结果拼接一个结束的字符
		index:索引。遍历list的时候是index就是索引，item就是当前值
				      遍历map的时候index表示的就是map的key，item就是map的值
		
		#{变量名}就能取出变量的值也就是当前遍历出的元素
	  -->
	<foreach collection="ids" item="item_id" separator=","
		open="where id in(" close=")">
		#{item_id}
	</foreach>
</select>

foreach_mysql下foreach批量插入的两种方式

 <!--批量保存 -->
 <!--public void addEmps(@Param("emps")List<Employee> emps);  -->
 <!--MySQL下批量保存：可以foreach遍历   mysql支持values(),(),()语法-->
 include标签调用了下面的sql标签抽取的重用sql
<insert id="addEmps">
<!-- 	insert into tbl_employee(
 		<include refid="insertColumn"></include>
 	)  -->
 	insert into tbl_employee( employee_id,last_name,email ) 
	values
	<foreach collection="emps" item="emp" separator=",">
		(#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
	</foreach>
 </insert>

内置参数_parameter&_databaseId

<!-- 两个内置参数：
不只是方法传递过来的参数可以被用来判断，取值。。。
mybatis默认还有两个内置参数：
_parameter:代表整个参数
	单个参数：_parameter就是这个参数
	多个参数：参数会被封装为一个map；_parameter就是代表这个map

_databaseId:如果配置了databaseIdProvider标签。
	_databaseId就是代表当前数据库的别名oracle
-->

<!--public List<Employee> getEmpsTestInnerParameter(Employee employee);  -->
<select id="getEmpsTestInnerParameter"
resultType="com.atguigu.mybatis.bean.Employee">
		<if test="_databaseId=='mysql'">
			select * from tbl_employee
			<if test="_parameter!=null">
				where last_name like #{lastName}
			</if>
		</if>
		<if test="_databaseId=='oracle'">
			select * from employees
			<if test="_parameter!=null">
				where last_name like #{_parameter.lastName}
			</if>
		</if>
</select>

bind_绑定

<!--public List<Employee> getEmpsTestInnerParameter(Employee employee);  -->
<select id="getEmpsTestInnerParameter" resultType="com.atguigu.mybatis.bean.Employee">
	<!-- bind：可以将OGNL表达式的值绑定到一个变量中，方便后来引用这个变量的值 -->
	<bind name="_lastName" value="'%'+lastName+'%'"/>
	<if test="_databaseId=='mysql'">
		select * from tbl_employee
		<if test="_parameter!=null">
			where last_name like #{_lastName}
		</if>
	</if>
</select>

sql_抽取可重用的sql片段

<!-- 
抽取可重用的sql片段。方便后面引用 
1、sql抽取：经常将要查询的列名，或者插入用的列名抽取出来方便引用
2、include来引用已经抽取的sql：
3、include还可以自定义一些property，sql标签内部就能使用自定义的属性
		include-property：取值的正确方式${prop},
		#{不能使用这种方式}
		<include refid="insertColumn">
	 		<property name="testColomn" value="abc"/>
	 	</include>
-->
<sql id="insertColumn">
	<if test="_databaseId=='oracle'">
		employee_id,last_name,email
	</if>
	<if test="_databaseId=='mysql'">
		last_name,email,gender,d_id
	</if>
</sql>

end

朱阿朱
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
MyBatis搭建MyBatis
07-25
【MyBatis】搭建MyBatis的文档
Mybatis的一些使用
real_Rickys的博客
04-16 428
在Mybatis的映射中有可能会用到很多外部的类，经常使用全名会导致代码繁琐，所以在application.properties中mybatis.type-aliases-package属性中设置，可以设置多个别名路径 ...
MyBatis参数报错--Parameter 'realName' not found.
weixin_34232363的博客
01-08 618
今天写一个条件查询的时候遇到了问题,也是很久没写了,最后终于解决了 首先在dao层接口的参数上加上@Param注解,查询单个参数可以不加,多个必须加上 @Param注解的作用是给参数命名,参数命名后就能根据名字得到参数值,正确的将参数传入sql语句中 正确写法 List<GmVipMember> selectByRealNameMemIdTelNum(@Param("realNam...
mybatis
HengTian_real的博客
02-25 204
MyBatis小结 Mybatis工具类(加了锁) package online.hengtian.utils; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import...
MyBatis(下)
real_rookie的博客
09-01 134
MyBatis（下）缓存缓存介绍一级缓存体验一级缓存失效的四种情况二级缓存介绍缓存有关的设置以及属性缓存原理图示第三方缓存整合原理&ehcache适配包下载MyBatis整合ehcache&总结整合Spring逆向工程mbg简介运行原理框架分层架构SQLSessionFactory的初始化openSession获取SqlSession对象getMapper获取到接口的代理对象end 缓存 缓存介绍 一级缓存体验 * 一级缓存：（本地缓存）：sqlSession级别的缓存。一级缓存是一直
MyBatis JdbcType 与Oracle、MySql数据类型对应关系详解
热门推荐
loongshawn的博客
01-11 13万+
Mybatis JdbcType与Oracle、MySql数据类型对应列表。
mybatis慢SQL插件
07-19
基于mybatis的慢SQL小插件，原理是mybatis拦截器。只需要在springboot的配置文件做简单的配置，mybatis拦截器将SQL中所有参数自动做了填充。拦截器监控慢SQL并将完整的可执行的SQL语句打印在日志文件中，复制该SQL...
Mybatis详细教程
05-13
Mybatis详细讲解教程，适用于新手学习与应用
mybatis111111111
最新发布
04-03
mybatis111111111
MyBatis.pdf
12-02
自己总结MyBatis的思维导图
Mybatis中Mapper.xml文件中的update语句写法
sdzhangshulong的博客
02-23 7万+
update CT_SYS_DUTYREAL DUTYREAL_UID = #{dutyrealUid,jdbcType=DECIMAL}, DUTYRULE_ID = #{dutyruleId,jdbcType=DECIMAL}, DUTYREAL_ST = #{dut
Mybatis_mybatis常用jdbcType数据类型
weixin_34125592的博客
09-22 397
MyBatis 通过包含的jdbcType类型 BIT         FLOAT      CHAR           TIMESTAMP       OTHER       UNDEFINEDTINYINT     REAL       VARCHAR        BINARY          BLOB        NVARCHARSMALLINT    DOUBLE     LON...
深入浅出MyBatis技术原理与实战-学习-MyBatis 初识(一)
黄裳博客
11-20 769
        MyBatis 本是 Apache 的一个开源项目 iBatis，2010年这个项目由 Apache Software Foundation 迁移到 Google Code，并改变为 MyBatis 。         MyBatis 是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架，MyBatis消除了几乎所有的 JDBC
MyBatis的多表查询
reallllbj的博客
05-03 563
Mybatis 多表查询 在说多表查询之前，首先要了解表之间的关系共有以下几种： 一对一 ： 人和身份证就是一对一的关系。一个人只能有一个身份证号，而一个身份证号只能属于一个人。 多对一（一对多）：学生和班级就是多对一（一对多）的关系。一个班级有多个学生，而一个学生只属于一个班级。 多对多 ： 学生和任课老师就是多对多的关系。一个学生可以有多个任课老师，而一个任课老师可以有多个学生 1.一对一...
四、mybatis第四节
lrs998563的博客
06-06 886
在我们日常使用中，缺少不了分页查询，就好比你百度时，那么多的数据，肯定需要分页来处理。那么我们就可以用分页插件来帮我们快速实现分页查询操作首先了解一下分页查询的sql语句： 其中的page代表你想要查询的页码数，pageSize代表你想要每页显示的数据个数。 那么我们该如何使用分页插件呢？具体步骤如下：（1）在pom.xml中引入pageHelper的依赖jar包 （2） 在mybatis.xml中设置pageHelper的拦截器（写在configuration标签内）
云原生Java架构实战 K8s+Docker+KubeSphere+DevOps（上）
real_rookie的博客
10-26 3840
云原生Java架构 K8s+Docker+KubeSphere+DevOps云平台私有网络VPCVPC的子网计算VPC的交换机重要概念容器化docker概念青云服务器centos安装dockerdocker实战docker进阶部署redis创建Java应用Kubernetes基础概念简介集群的方式end 简介：摘自 尚硅谷雷锋阳老师的语雀文档 云平台 学会使用按量付费的云服务器，开发测试性价比高 私有网络VPC 和网络有关的概念，如何在云服务器开通一个集群 一个云服务器有两个IP：公网IP和私网IP 公网I
云原生Java架构实战 K8s+Docker+KubeSphere+DevOps（中）
real_rookie的博客
10-29 1935
云原生Java架构实战 K8s+Docker+KubeSphere+DevOps（下）KubeSphere平台安装简介Kubernetes上安装KubeSphereend KubeSphere 平台安装 简介 Kubernetes上安装KubeSphere 安装步骤 选择4核8G（master）、8核16G（node1）、8核16G（node2） 三台机器，按量付费进行实验，CentOS7.9 安装Docker 安装Kubernetes 安装KubeSphere前置环境 安装KubeSphere 1、
谷粒商城分布式基础篇
real_rookie的博客
07-29 1487
文章目录简介环境使用vagrant快速创建linux虚拟机虚拟机网络设置linux安装docker配置docker阿里云镜像加速docker安装MySQLdocker安装redis开发工具&环境安装配置配置git-ssh项目结构创建&提交到码云数据库初始化快速开发人人开源搭建后台管理系统 简介 环境 使用vagrant快速创建linux虚拟机 使用virtualbox 6.0 使用vagrant 2.2.5 cmd窗口 vagrant 初始化 centos vagrant ini
云原生Java架构实战 K8s+Docker+KubeSphere+DevOps（下）
real_rookie的博客
11-04 1300
云原生Java架构实战 K8s+Docker+KubeSphere+DevOps（下）应用部署实战ruo-yi-cloud本地环境nacos启动导入ruoyi数据库ruo-yi-cloud上云end 应用部署实战 ruo-yi-cloud 1、项目 https://gitee.com/y_project/RuoYi-Cloud 2、架构 下载项目 本地环境nacos启动 单机模式mysql启动nacos，nacos conf/application.properties配置文件添加如下配置，并运行目录下的
Mybatis +Mybatis Plus
09-07
而Mybatis Plus是在Mybatis的基础上进行二次封装的框架，它简化了Mybatis的使用，提供了更加便捷的CRUD操作方法和更加灵活的查询方式，同时还集成了一些常用的功能模块，如分页、逻辑删除等。 在Spring Boot中整合...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值