MyBatis框架-应用篇(1)

最新推荐文章于 2023-06-27 20:26:59 发布

小敬哥

最新推荐文章于 2023-06-27 20:26:59 发布

阅读量1.2k

点赞数

文章标签： java mybatis

本文链接：https://blog.csdn.net/classjing/article/details/117847153

版权

1. Mybatis概述

1.1. Mybatis是什么

Mybatis是一个持久层（DAO）框架。

1.2. Mybatis的作用

Mybatis是一个持久层框架,当然作用就是操作数据库的（增删改查）

1.3. 为什么需要学习Mybatis

Mybatis的理念:让开发者是10%的代码就可以实现数据库的操作。

解决方案: 持久层（DAO）的零实现. 所谓的零实现,就是不用写实现类代码,直接使用接口就可以操作数据库.

提高开发的效率！！！真的写很少代码！！！就可以增删改查。

写的更少，做的更多

1.4. Mybatis的作用

Mybatis框架能够让我们以最少的代码就可以操作数据库。从而提高开发的效率！！！

–如何将代码减少呢？

持久层的零实现（不需要写实现类）

可以自动将数据封装到对象里面不需要手工编写映射的关系

1.5. Mybatis配置流程图

在这里插入图片描述

Resources:资源类，用于读取总配置文件

SqlSessionFactoryBuilder:会话工厂构造类，通过读取的总配置文件构建会话工厂

SqlSessionFactory:会话工厂

SqlSession:会话,就是操作数据库的操作类

2. 入门示例

2.1. 配置流程说明

–获得数据库连接

第一步：导入包（任何框架需要的事情）

第二步：创建总配置文件，文件名随便写

第三步：创建一个MybatisUtils工具类，（获得操作对象）

–需求：插入数据到数据库

第四步：创建一个映射接口

第五步：创建一个映射文件

第六步：在总配置文件加载映射文件。

第七步：编写测试插入数据代码

2.2. 配置步骤

2.2.1. 下载mybatis框架

https://github.com/mybatis/mybatis-3

2.2.2. 创建一个普通java项目并导入相关

在这里插入图片描述

2.2.3. 创建主配置文件 mybatis-config.xml

在项目的 src 下面创建配置文件 mybatis-config.xml

具体配置参考mybatis的官方文档即可

<?xml version="1.0" encoding="UTF-8" ?>
<!-- dtd约束 -->
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- 根元素: 用于配置mybatis -->
<configuration>
  <!-- 配置mybatis的运行环境 ,可以配置多个环境,但是一次只能使用一个 
  
  	default属性 : 当前使用的环境 ,使用下面环境的id 即可  -->
  <environments default="dev_mysql">
  	<!-- 环境配置  id 属性,就是当前环境的表示 -->
    <environment id="dev_mysql">
      <!-- 配置MyBatis事务管理器 
      	type属性 :  事物类型
      		JDBC  使用事务(正常提交commit,异常回滚事务 rollback) 默认
      		MANAGED : 不使用事务 
        -->
      <transactionManager type="JDBC"/>
      <!-- 配置MyBatis的数据源
      	type : 配置连接池
      		POOLED :mybatis内置的一个连接池(默认)
      		后期都交给spring管理了,配置 dbcp连接池,阿里巴巴的 druid连接池
       -->
      <dataSource type="POOLED">
      	<!-- 连接数据库的操作 -->
      	<!-- 数据库驱动 -->
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <!-- 连接数据库的url -->
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
        <!-- 连接数据库账号 -->
        <property name="username" value="root"/>
        <!-- 连接数据库密码 -->
        <property name="password" value="admin"/>
      </dataSource>
    </environment>
  </environments>
  <!-- 配置映射文件 -->
  <mappers>
  	<!-- 配置包扫描映射文件 -->
  	<!-- <package name=""/> -->
  	<!-- 配置单个映射文件 -->
    <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  </mappers>
</configuration>

2.2.4. 创建MyBatisUtil工具类

MyBatisUtil工具类的作用主要用于读取配置文件，创建工厂对象，提供创建SqlSession数据库操作对象的方法

package cn.zj.mybatis.util;


import java.io.InputStream;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MyBatisUtil {
	private MyBatisUtil() {
	}
	
	//SqlSessionFactory 会话工厂对象
	private static SqlSessionFactory  factory;
	//类加载到JVM中就立马执行static代码块,并且只会执行一次
	static {
		//资源文件
		String resource = "mybatis-config.xml";
		//try(){}catch(Exception e){} try的圆括号内部能够自动释放/关闭资源
		try(InputStream inputStream = Resources.getResourceAsStream(resource)) {
			//创建SqlSessionFactory 对象
			factory = new SqlSessionFactoryBuilder().build(inputStream);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	/**
	 * 创建SqlSession对象
	 * @return SqlSession对
	 */
	public static SqlSession openSession() {
		//创建Session对象
		SqlSession session = factory.openSession();
		return session;
	}

}

2.2.5. 创建数据库表对应的实体类

package cn.zj.mybatis.pojo;

public class User {
	private Integer id;
	private String name;
	private String password;
	private Integer age;
	
	public User() {
		super();
	}

	public User(Integer id, String name, String password, Integer age) {
		super();
		this.id = id;
		this.name = name;
		this.password = password;
		this.age = age;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPassword() {
		return password;
	}

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

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", password=" + password + ", age=" + age + "]";
	}
	
}

2.2.6. 创建一个操作接口

package cn.zj.mybatis.mapper;

import cn.zj.mybatis.pojo.User;

/*
 * 使用MyBatis的动态代理开发编写代码遵循四个原则
 *  1.映射文件的namespace命名空间的值必须是对应接口的全限定名
	2.映射文件的对应功能 id值必须等于映射接口中方法的名称
	3.映射文件的参数类型必须和接口中方法的参数类型一致
	4.映射文件查询的返回结果类型必须和接口的方法的返回数据类型一致，
		DML操作返回的受影响的行数，除外
 */
public interface UserMapper {

	int insertUserInfo(User u);
}

2.2.7. 创建表对应的映射文件 :UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 配置映射
namespace : 命名空间(通俗说法: 给当前映射文件的唯一标识:起一个唯一的名字)	
 -->
<mapper namespace="cn.zj.mybatis.pojo.UserMapper">
	<!-- 新增操作
		id: 当前功能的唯一标识,和接口方法同名
		parameterType ： 参数的类型
		useGeneratedKeys：是否返回数据库生成的主键 true是/false否 
		keyProperty : 数据库主键对应java的pojo对象的属性
		keyColumn : 数据表的主键列明
	 -->
	<insert id="insertUserInfo" parameterType="User" 
		useGeneratedKeys="true"
		keyProperty="id"
		keyColumn="id"
	>
</mapper>

2.2.8. 创建测试类准备测试

	
	//插入操作
// 新增操作
@Test
public void testInsert() throws Exception {
	//1.创建SqlSession操作对象
	SqlSession session = MyBatisUtil.openSession();
	
	//2.创建UserMapper接口的代理对象
	UserMapper userMapper = session.getMapper(UserMapper.class);

	
	//3.创建用户对象
	User user = new User(null, "小敬哥", "qf", 18);
	
	//4.执行UserMapper的插入操作
	userMapper.insertUserInfo(user);
	
	//5.提交事务
	session.commit();
	
	//6.关闭session
	session.close();

}

3. log4j日志框架的配置

3.1. 说明

log4j是一个日志输出框架,就是用于输出日志的。

Mybatis的日志输出是通过Log4J输出的。主流框架大部分都是Log4j输出的。Spring框架也可以通过Log4j输出日志！！

问题：既然Log4j功能类似System.out.println（），为什么使用log4j而不直接使用System.out.println（）？

答：Log4j提供了强大的日志输出的自定义功能。

通过级别输出日志（调试、信息、警告、错误、致命异常）
可以指定输出到控制台，以及输出到文件。
可以设置输出的日志格式

所以学习LOG4J.需要学会自定义配置LOG4J的输出格式以及输出等级

3.2. 下载路径

Log4j的下载地址:http://logging.apache.org/log4j/1.2/

3.3. 配置步骤

3.3.1. 第一步：导入log4j-1.2.17.jar的包

在这里插入图片描述

3.3.2. 第二步：在src下创建一个log4j.propertis文件

注意：文件名必须为log4j.properties

# Global logging configuration
log4j.rootLogger=ERROR, stdout
# MyBatis logging configuration...
# log4j.logger.org.mybatis.example.BlogMapper=TRACE
#  前缀(log4j.logger)+点（.）需要记录日志的命名空间 = 日志级别
log4j.logger.cn.zj.mybatis.mapper=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

3.4. 运行效果

在这里插入图片描述

4. MyBatis完成CRUD操作

4.1. 单行查询

4.1.1. 映射文件

UserMapper.xml 中继续编写

 <!-- 单行查询
  resultType : 查询结果对应的封装的返回类型
   -->
<select id="selectByUserId" parameterType="integer" resultType="cn.zj.mybatis.pojo.User">
    select * from user where id = #{id}
</select>

4.1.2. 测试方法

// 单行查询
@Test
public void testFindById() throws Exception {
	//1.创建SqlSession操作对象
	SqlSession session = MyBatisUtil.openSession();
	//2.创建UserMapper接口的代理对象
	UserMapper userMapper = session.getMapper(UserMapper.class);
	//3.执行单行查询操作
	User user = userMapper.selectByPrimaryKey(1);
	
	System.out.println(user);

	// 4.关闭session
	session.close();
}

4.2. 多行查询

4.2.1. 映射文件

<!-- 多行查询
   resultType : 无论是多行查询还是单行查询,返回的结果类型都是对应的JavaBean的类型
   -->
<select id="selectAll" resultType="cn.zj.mybatis.pojo.User">
    select * from user
</select>

4.2.2. 测试方法

@Test
public void testFindAll() throws Exception {

	SqlSession session = MyBatisUtil.openSession();

	// 创建UserMaper的代理对象
	UserMapper mapper = session.getMapper(UserMapper.class);

	// 3.执行多行查询
	List<User> users = mapper.selectAll();
	for (User user : users) {
		System.out.println(user);
	}

	// 4.关闭session
	session.close();
}

4.3. 删除操作

4.3.1. 映射文件

<!-- 删除操作  -->
<delete id="deleteById" parameterType="integer">
    delete from user where id = #{id}
</delete>

4.3.2. 测试方法

// 删除操作
@Test
public void testDelete() throws Exception {
	// 1.创建SqlSession操作对象
	SqlSession session = MyBatisUtil.openSession();
	// 2.创建UserMapper接口的代理对象
	UserMapper userMapper = session.getMapper(UserMapper.class);

	// 3.执行UserMapper的插入操作
	userMapper.deleteById(3);

	// 4.提交事务
	session.commit();

	// 5.关闭session
	session.close();
}

4.4. 修改操作

4.4.1. 映射文件

<!-- 修改操作 -->
<update id="updateByUserId" parameterType="cn.zj.mybatis.pojo.User">
    update user set name = #{name},password = #{password},age = #{age} where id = #{id}
</update>

4.4.2. 测试方法

// 修改操作
@Test
public void testUpdate() throws Exception {
	// 1.创建SqlSession操作对象
	SqlSession session = MyBatisUtil.openSession();
	// 2.创建UserMapper接口的代理对象
	UserMapper userMapper = session.getMapper(UserMapper.class);
	// 3.创建用户对象
	User user = new User(2, "段誉", "dy", 25);

	// 4.执行UserMapper的插入操作
	userMapper.updateUserInfo(user);

	// 5.提交事务
	session.commit();

	// 6.关闭session
	session.close();
}

5. ResultMap 手动映射

MyBatis的查询结果集都是自动映射封装的，单行查询将数据库一条数据封装成对应的Java对象。多行查询，先将每一行封装成对象，再将每个对象添加到集合中，最后返回一个List集合对象。

但是：必须保证查询结果集和pojo对象的属性名相同，否则无法自动封装

问题：如何解决查询结果集名称和pojo对象属性不同的映射封装？

解决方案：

使用手动映射封装 ****标签
可以使用mybatis的驼峰命名法

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <!-- 映射配置
 	namespace : 命名空间，通俗讲，每个映射文件唯一的标识名称
  -->
<mapper namespace="cn.zj.mybatis.mapper.UserMapper">

	<!-- 
		resultType : 自动映射
		resultMap ： 手动映射，值 自定义对应手动映射标签的 id的值
		注意：自动映射和手动映射二选一，不能同时使用
	 -->
	<select id="findByUserId" parameterType="Integer"  resultMap="user_map">
		<!-- #{} OGNL表达式语言  -->
		select id  u_id,name u_name,password u_password ,age u_age from user  where id = #{id}
	</select>
	
	
	<!-- 手动映射
		type :需要手动映射的数据类型
		id ：唯一标识
	 -->
	<resultMap type="User" id="user_map">
		<!-- 
			主键列映射
			<id column="" property="" javaType="" jdbcType=""/>
			column :结果的列名
			property:domain对象的对应的属性名
			javaType :domian对象的属性的类型（可选，默认自动关联）
			jdbcType :结果集列类型（可选，默认自动关联）
		 -->
		<id column="u_id" property="id" javaType="Integer" jdbcType="INTEGER"/>
		
		<!-- 
			主键列映射
			<result column="" property="" javaType="" jdbcType=""/>
			column :结果的列名
			property:domain对象的对应的属性名
			javaType :domian对象的属性的类型（可选，默认自动关联）
			jdbcType :结果集列类型（可选，默认自动关联）
		-->
		<result column="u_name" property="name"/>
		<result column="u_age" property="age"/>
		<result column="u_password" property="password"/>
	</resultMap>
	
	<!-- 多行查询 
		注意：查询不管单行还是多行查询，返回的数据类型都是数据表对应的domain类型
		多行不是放回集合
	-->
	<select id="selectAll" resultMap="user_map">
		select id  u_id,name u_name,password u_password ,age u_age from user
	</select>		
</mapper>

6. 主配置文件说明与细节配置

:环境集标签,就是用于配置数据库的连接信息的

:用于配置具体环境参数

:配置使用的事务类型,JDBC

:配置数据源的参数,POOLED

具体参数参看PooledDataSource的set方法

:配置属性

:配置映射文件信息的

<mapper class|resource>:配置具体指定的mapper文件

class:配置使用注解时指定有注解的映射接口

resource:指定映射文件

:mybatis对propertis文件的支持

:用于配置别名

:用于配置自定义类型处理器.

:配置Mybatis的默认设置的.

总配置文件的标签顺序

<!ELEMENT configuration (properties?, settings?, typeAliases?, typeHandlers?, objectFactory?, objectWrapperFactory?, reflectorFactory?, plugins?, environments?, databaseIdProvider?, mappers?)>

这句话的意思就是configuration 标签下的标签的****顺序*以及*标签出现的个数****的声明

根据这个声明可以看到顺序为:

properties
settings
typeAliases
typeHandlers
objectFactory
objectWrapperFactory
reflectorFactory
plugins
environments
databaseIdProvider
mappers

DTD规则文件标签的出现的次数说明

如果声明的标签后?:表示出现0-1次

如果声明的标签后*:表示出现0-N次

如果声明的标签后+:表示出现1-N次

如果声明的标签后什么都没有:表示出现1次

6.1. 别名typeAliases标签

在UserMapper.xml文件中User无论是作为参数还是作为查询返回数据类型，都需要写上全限定名，实际可以写上简单类名即可，但是需要配置别名

MyBatis框架提供了两种别名机制，一种是自定义别名，一种是内置别名

6.1.1. 自定义别名

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "mybatis-3-config.dtd" >
<!-- XMLConfigBuilder是总配置文件的构建类 -->
<configuration>
<!-- 别名设置  -->
	<typeAliases>
		<!-- 设置单个类的别名 
			type ：要设置别名的全限定名
			alias ：别名 
		-->
		<typeAlias type="cn.zj.mybatis.pojo.User" alias="User"/>
	</typeAliases>

 
  <!-- 用于配置数据库的连接参数 ,environments这个标签可以配置多个数据库的连接,default表示默认使用的配置-->
  <environments default="default-msql">
  
     <!-- 数据库的连接参数 Configuration查看参数-->
     <!-- 所有框架的静态属性都可以在这个框架的类里面找到,不用死记硬背 -->
     <!-- id:就是一个标识符 -->
     <environment id="default-msql">
        <!-- 事务类型 -->
        <!-- 事务类型有哪些
         JDBC:使用JDBC事务
         MANAGED:不用事务
         -->
        <transactionManager type="JDBC"></transactionManager>
        <!-- 数据源 -->
        <!-- type表示数据库的类型
           JNDI:使用JNDI获得数据源.
           POOLED:使用默认的连接池获得数据源
           UNPOOLED:不用数据源
         
          -->
          <!-- org.apache.ibatis.datasource.pooled.PooledDataSource -->
        <dataSource type="POOLED">
           <!-- 所有的property对应的是一个set方法 -->
           <!-- 四要素 -->
           <property name="driver" value="org.gjt.mm.mysql.Driver"/>
           <property name="url" value="jdbc:mysql://localhost:3306/school"/>
           <property name="username" value="root"/>
           <property name="password" value="123456"/>
        </dataSource>
     
     </environment>
  
  </environments>
  <!-- 加载映射文件 -->
  <mappers>
    <mapper resource="mybatis-mapper/StudentMapper.xml"/>
  </mappers>
</configuration>

如果配置成功,在映射文件里面可以直接使用别名

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <!-- 映射配置
 	namespace : 命名空间，通俗讲，每个映射文件唯一的标识名称
  -->
<mapper namespace="test">
	<!-- 单行查询操作
		<select id="">
			id :当前功能唯一标识
			parameterType ： 当前参数的数据类型
			resultType ：查询结果要封装返回对象的数据类型
			标签内部的文本内容： 要操作SQL语句
	 -->
	<select id="findById" parameterType="Integer" resultType="User">
		<!-- #{} OGNL表达式语言  -->
		select * from user where id = #{id}
	</select>
	
	<!-- 多行查询 
		注意：查询不管单行还是多行查询，返回的数据类型都是数据表对应的pojo类型
		多行不是放回集合
	-->
	<select id="findAll" resultType="User">
		select * from user
	</select>
	
	<!-- 新增数据
		keyProperty ： 数据库表主键对应的pojo类型的属性
		useGeneratedKeys: 是否生成主键，如果为true，数据保存以后
		MyBatis会自动把数据库当前数据的主键值设置pojo对应的id中去
		 
	 -->
	<insert id="insertUserInfo" 
			parameterType="User" 
			keyProperty="id"
			useGeneratedKeys="true">
			<!-- #{对象的属性名称} -->
		insert into user (name,password,age)values(#{name},#{password},#{age})		
	</insert>
	
	<!-- 删除数据 -->
	<delete id="deleteById" parameterType="Integer" >
		delete from user where id = #{id}
	</delete>
	
	<!-- 
		修改操作
	 -->
	 <update id="updateUserInfoById" parameterType="User">
	 	update user set name = #{name} ,password = #{password},age = #{age} where id = #{id}
	 </update>	
</mapper>

6.1.2. 内置别名

所谓的内置别名,就是Mybatis框架自带别名.

Mybatis已经将****常用的数据类型****的别名内置声明了.所以这些内置的别名不需要配置就可以直接使用.

内置的别名就是,Mybatis框架默认已经设置的别名.

别名	映射的类型
_byte	byte
_long	long
_short	short
_int	int
_integer	int
_double	double
_float	float
_boolean	boolean
string	java.lang.String
byte	Byte
long	Long
short	Short
int	Integer
integer	Integer
double	Double
float	Float
boolean	Boolean
date	java.util.Date
decimal	BigDecimal
bigdecimal	BigDecimal
object	Object
map	java.util.Map
hashmap	HashMap
list	List
arraylist	ArrayList
collection	Collection
iterator	Iterator

6.2. properties 读取配置文件

一般开发会将单独的数据库连接字符串配置到一个独立的以 *.properties* 的配置文件中

Mybaits框架中配置文件的标签可以读取配置文件中的内容。并可以使用${}的语法设置给框架的数据库连接操作代码

6.2.1. 在classpath下面创建一个db.properties数据库连接配置文件

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

6.2.2. 在mybatis-config.xml主配置文件中配置标签读取配置文件

<!-- 根标签，在内部配置MyBatis框架信息 -->
<configuration>

    <!-- 读取classpath下面的 数据库配置文件、
  读取以后再下面链接数据库的配置中就可以使用
  ${配置文件key} 获取对应的数据库连接相关信息
  -->
    <properties resource="db.properties"/>
</configuration>configuration>

6.2.3. 连接数据库的配置修改为 ${key}的方式

<environment id="mysql">
    <!-- 配置事务管理器
      type ： 事务管理器的类型，使用的MyBatis框架自定义的一种别名
         JDBC :使用原生的JDBC作为事务管理
      -->
    <transactionManager type="JDBC"/>
    <!-- 配置MyBatis的数据源
       type : 配置连接池
       POOLED :mybatis内置的一个连接池(默认)
        后期都交给spring管理了,配置 dbcp连接池,阿里巴巴的 druid连接池
       -->
    <dataSource type="POOLED">
        <property name="driver" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </dataSource>
</environment>

6.3. settings标签

Mybatis默认设置了很多默认配置.有时候,我们需求与默认的配置的参数不一样,

我们就需要修改这些默认配置的参数.

如:Mybatis已经对骆驼命名法的支持,但默认是不开启的.可以通过 mapUnderscoreToCamelCase 参数设置为true支持

表示Mybatis启动可以配置的设置

设置参数	描述	有效值	默认值
cacheEnabled	该配置影响的所有映射器中配置的缓存的全局开关。	true \| false	TRUE
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态。	true \| false	FALSE
aggressiveLazyLoading	当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载（参考lazyLoadTriggerMethods).	true \| false	false (true in ≤3.4.1)
multipleResultSetsEnabled	是否允许单一语句返回多结果集（需要兼容驱动）。	true \| false	TRUE
useColumnLabel	使用列标签代替列名。不同的驱动在这方面会有不同的表现，具体可参考相关驱动文档或通过测试这两种不同的模式来观察所用驱动的结果。	true \| false	TRUE
useGeneratedKeys	允许 JDBC 支持自动生成主键，需要驱动兼容。如果设置为 true 则这个设置强制使用自动生成主键，尽管一些驱动不能兼容但仍可正常工作（比如 Derby）。	true \| false	FALSE
autoMappingBehavior	指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示取消自动映射；PARTIAL 只会自动映射没有定义嵌套结果集映射的结果集。 FULL 会自动映射任意复杂的结果集（无论是否嵌套）。	NONE, PARTIAL, FULL	PARTIAL
autoMappingUnknownColumnBehavior	指定发现自动映射目标未知列（或者未知属性类型）的行为。	NONE, WARNING, FAILING	NONE
NONE: 不做任何反应
FAILING: 映射失败 (抛出 SqlSessionException)
defaultExecutorType	配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）； BATCH 执行器将重用语句并执行批量更新。	SIMPLE REUSE BATCH	SIMPLE
defaultStatementTimeout	设置超时时间，它决定驱动等待数据库响应的秒数。	任意正整数	Not Set (null)
defaultFetchSize	为驱动的结果集获取数量（fetchSize）设置一个提示值。此参数只可以在查询设置中被覆盖。	任意正整数	Not Set (null)
safeRowBoundsEnabled	允许在嵌套语句中使用分页（RowBounds）。 If allow, set the false.	true \| false	FALSE
safeResultHandlerEnabled	允许在嵌套语句中使用分页（ResultHandler）。 If allow, set the false.	true \| false	TRUE
mapUnderscoreToCamelCase	是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射	true \|false	*FALSE*
localCacheScope	MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据。	SESSION \| STATEMENT	SESSION
jdbcTypeForNull	当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。某些驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。	JdbcType enumeration. Most common are: NULL, VARCHAR and OTHER	OTHER
lazyLoadTriggerMethods	指定哪个对象的方法触发一次延迟加载。	A method name list separated by commas	equals,clone,hashCode,toString
defaultScriptingLanguage	指定动态 SQL 生成的默认语言。	A type alias or fully qualified class name.	org.apache.ibatis.scripting.xmltags.XMLLanguageDriver
callSettersOnNulls	指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这对于有 Map.keySet() 依赖或 null 值初始化的时候是有用的。注意基本类型（int、boolean等）是不能设置成 null 的。	true \| false	FALSE
returnInstanceForEmptyRow	当返回行的所有列都是空时，MyBatis默认返回null。当开启这个设置时，MyBatis会返回一个空实例。请注意，它也适用于嵌套的结果集 (i.e. collectioin and association)。（从3.4.2开始）	true \| false	false
logPrefix	指定 MyBatis 增加到日志名称的前缀。	Any String	Not set
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J \| LOG4J \| LOG4J2 \| JDK_LOGGING \| COMMONS_LOGGING \| STDOUT_LOGGING \| NO_LOGGING	Not set
proxyFactory	指定 Mybatis 创建具有延迟加载能力的对象所用到的代理工具。	CGLIB \| JAVASSIST	JAVASSIST (MyBatis 3.3 or above)
vfsImpl	指定VFS的实现	自定义VFS的实现的类全限定名，以逗号分隔。	Not set
useActualParamName	允许使用方法签名中的名称作为语句参数名称。为了使用该特性，你的工程必须采用Java 8编译，并且加上-parameters选项。（从3.4.1开始）	true \| false	TRUE
configurationFactory	Specifies the class that provides an instance of Configuration. The returned Configuration instance is used to load lazy properties of deserialized objects. This class must have a method with a signature static Configuration getConfiguration(). (Since: 3.2.3)	A type alias or fully qualified class name.	Not set

如支持骆驼命名法

在 mybatis-config.xml 中配置

  <!-- 配置默认的参数 -->
  <settings>
    <!-- 默认支持骆驼命名法 -->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
  </settings>

7. MyBatis的注解开发

MyBatis的映射配置除了使用xml配置以外，还支持注解配置sql语句

问题：为什么有了xml配置还有注解配置

答：MyBatis的注解开发更简洁，只需要将对应的SQL语句的注解标注对应的功能方法上，直接连 XxxMapper.xml映射文件都可以省略了

本身注解开发就是Java配置的一种趋势，后期学习SpringBoot时候，发现全部用纯注解配置

MyBatis提供了下面注解进行映射文件配置

@Select 查询数据注解@Insert 插入数据注解@Delete 删除数据注解@Update 修改数据注解@Options 选项配置@Results 手动映射配置@Result ： @results中的具体的某一列的映射信息配置

7.1. 案例代码

package cn.zj.mybatis.mapper;
import java.util.List;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Options;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.ResultMap;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import cn.zj.mybatis.domain.User;

/**
 * 
 * @Select 查询注解
 * @Insert
 *
 */
public interface UserMapper {
	
	@Select("select id u_id,name u_name,password u_password,age u_age from user where id = #{id}")
	@Results({
        @Result(id=true,property="id",column="u_id"),
        @Result(property="name",column="u_name"),
        @Result(property="password",column="u_password"),
        @Result(property="age",column="u_age")
    })
	User selectByPrimaryKey(Integer id);
	
	@Select("select * from user")
	List<User> findAll();
	
	
	@Insert("insert into user (name,password,age)values(#{name},#{password},#{age})")
	@Options(keyProperty="id",useGeneratedKeys=true)
	int insertUserInfo(User user);
	
	@Delete("delete from user where id = #{id}")
	int deleteByUserId(Integer id);
	
	@Update("update user set name = #{name} ,password = #{password},age = #{age} where id = #{id}")
	int updateUserInfoById(User user);
	
}

7.2. 注解映射的配置

  <mappers>
  	<!-- 配置具体的映射文件 ，映射xml文件-->
  <!--  <mapper resource="cn/zj/mybatis/mapper/UserMapper.xml"/>  -->
  	<!-- 接口映射权限定名 -->
  	<mapper class="cn.zj.mybatis.mapper.UserMapper"/>
  </mappers>

8. 方法多参数传递使用@Param注解

*Mybatis默认情况下是不支持传入多个参数的.只能传入一个参数.*

所谓的传入参数指定是Mybatis操作()的传入参数.方案1：将这些参数封装到一个对象里面（JavaBean/Map），再传入.方案2：给参数设置一个@Param注解支持，而且多参数的类型要统一问题：为什么不支持多个参数?因为Java语法1.7以前.是不能通过反射技术获得方法的参数名的. 解决方案使用 @Param参数注解

案例代码


import java.util.Map;

import org.apache.ibatis.annotations.Param;

import cn.zj.mybatis.domain.User;

public interface UserMapper {
	
	/**
	 * 模拟登陆操作
	 * @param user 封装有账号密码的User对象
	 * @return 查询结果封装的User对象
	 */
	User login1(User user);
	
	/**
	 * 模拟登陆操作
	 * @param user 封装有账号密码的Map集合
	 * @return 查询结果封装的User对象
	 */
	User login2(Map<String, Object> map);
	
	
	User login3(@Param("username")String name,@Param("pwd")String password);
	
}

测试代码

@Test
public void testlogin3() throws Exception {

    SqlSession session = MyBatidUtil.openSession();

    UserMapper mapper = session.getMapper(UserMapper.class);

    User user = mapper.login3("小敬哥", "xiaojingge");

    System.out.println(user);
}

9. #{}与${}的区别

在MyBatis框架中支持两种 OGNL语法

#{}基于JDBC的PreparedStatement类,SQL语句参数使用 ?占位符，在运行阶段动态设置参数，但是 ?不能作为表名.

预编译语句对象的SQL语句只能操作 DML和DQL 语句，不能操作DDL语句

1.#{}表示设置预编译的参数,就是?的参数,所以如果要不固定的表名不能使用#{},只能使用${}

2. $KaTeX parse error: Expected 'EOF', got '#' at position 27: \dots接把参数拼接到SQL语句中.而#̲{]是使用?来代替. 所以$ {}是不安全的.

3. $KaTeX parse error: Expected 'EOF', got '#' at position 14: {}只能获得参数池的值,而#̲{}可以获得方法的参数值,也可\dots$ {}获得参数的值,这个参数必须要加上@Param

如果非必要情况,不要使用${}

问题：那么${}有什么用呢？

答：注意基于JDBC的接口的原来的表名是不可以使用?的，？只能用于传入的参数。

如果操作的涉及表名这些非参数的数据时，需要使用${}

9.1. 删除案例代码

UserMapper.java代码

package cn.zj.mybatis.mapper;


import org.apache.ibatis.annotations.Param;


public interface UserMapper {
	
	/**
	 * 动态删除数据库中指定表名
	 * @param tableName 表名
	 * @return
	 */
	int dropTable(@Param("tableName")String tableName);
}

映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <!-- 映射配置
 	namespace : 命名空间，通俗讲，每个映射文件唯一的标识名称
  -->
<mapper namespace="cn.zj.mybatis.mapper.UserMapper">
	
	<!-- 
		使用 #{} 不能使用在表名操作 
	 -->
	<delete id="dropTable" parameterType="String">
		<!-- drop table #{tableName} -->
		drop table ${tableName}
	</delete>
</mapper>

9.2. 打印效果

9.2.1. 使用 #{}

使用此种方法无法删除数据库表
在这里插入图片描述

9.2.2. 使用${}

在这里插入图片描述

小敬哥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
MyBatis框架-应用篇(1)

1. Mybatis概述1.1. Mybatis是什么Mybatis是一个持久层（DAO）框架。1.2. Mybatis的作用Mybatis是一个持久层框架,当然作用就是操作数据库的（增删改查）1.3. 为什么需要学习MybatisMybatis的理念:让开发者是10%的代码就可以实现数据库的操作。解决方案: 持久层（DAO）的零实现. 所谓的零实现,就是不用写实现类代码,直接使用接口就可以操作数据库.提高开发的效率！！！真的写很少代码！！！就可以增删改查。写的更少，做的更多1.4. M
复制链接

扫一扫