mybatis

最新推荐文章于 2024-05-21 09:03:18 发布

今晚打老虎_头很铁

最新推荐文章于 2024-05-21 09:03:18 发布

阅读量189

点赞数

分类专栏： Mybatis 文章标签： mybatis

本文链接：https://blog.csdn.net/qq_37482956/article/details/103474054

版权

Mybatis 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

数据库厂商标识（databaseIdProvider）

映射器（mappers）

Xml 映射文件

insert 、update 和 delete

两个内置参数_parameter和_databaseId （bind标签）

SQL 抽取

缓存

一级缓存 (sqlSession级别的缓存)

二级缓存 (基于namespace级别的缓存)

和缓存有关的设置/属性：

入门

在pox.xml中导入坐标依赖

         <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>

在数据库中创建一个user表

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) DEFAULT NULL,
  `password` varchar(50) DEFAULT NULL,
  `name` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'zhangsan', '123', '张三');
INSERT INTO `user` VALUES ('2', 'lisi', '123', '李四');

在domain包下创建实体类(属性名与数据库字段一一对应)

package com.hcl.doamin;

public class User {
    private Integer id;
    private String username;
    private String password;
    private String name;

    // 此处省略Get,Set,ToString
}

在resources目录创建mybatis-config.xml全局配置文件

<?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/test"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 将我们写好的sql映射文件（UserMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

在resources目录创建UserMapper.xml Sql映射文件

<?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:名称空间;（没定义接口时可以随便写）指定为接口的全类名
    id：唯一标识(对应的方法名)
    resultType：返回值类型
    #{id}：从传递过来的参数中取出id值
 -->
<mapper namespace="com.hcl.dao.UserMapper">
    <!-- public User findUserById(int id);-->
    <select id="findUserById" resultType="com.hcl.domain.User">
    select * from user where id = #{id}
  </select>
</mapper>

在test包下创建MybatisTest.java 进行测试

package com.hcl;

import com.hcl.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;

public class MybatisTest {

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

        // 2、获取sqlSession实例，能直接执行已经映射的sql语句
        // 获取sqlSession 对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 执行sql语句
        // statement : sql的唯一标识，namespace+id
       User user = sqlSession.selectOne("com.hcl.dao.UserMapper.findUserById", 1);
        System.out.println(user);  // User{id=1, username='zhangsan', password='123', name='张三'}

        // 关闭资源
        sqlSession.close();
    }
}

第二种：代理方式实现

在dao包下创建UserMapper.java接口

package com.hcl.dao;

import com.hcl.domain.User;
public interface UserMapper {
    public User findUserById(int id);
}

MybatisTest.java 进行测试

package com.hcl;

import com.hcl.dao.UserMapper;
import com.hcl.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
/**
 * 1、接口式编程
 * 	原生：		XxxDao		====>  XxxDaoImpl
 * 	mybatis：	XxxMapper	====>  XxxMapper.xml
 *
 * 2、SqlSession代表和数据库的一次会话；用完必须关闭；
 * 3、SqlSession和connection一样她都是非线程安全。每次使用都应该去获取新的对象。
 * 4、mapper接口没有实现类，但是mybatis会为这个接口生成一个代理对象。
 * 		（将接口和xml进行绑定）
 * 		EmployeeMapper empMapper =	sqlSession.getMapper(EmployeeMapper.class);
 * 5、两个重要的配置文件：
 * 		mybatis的全局配置文件：包含数据库连接池信息，事务管理器信息等...系统运行环境信息
 * 		sql映射文件：保存了每一个sql语句的映射信息：
 * 					将sql抽取出来。
 *
 *
 */
public class MybatisTest {

    // 方法二 ： 代理实现（常用）

    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        // 加载配置文件，创建 SqlSessionFactory 工厂
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        return  new SqlSessionFactoryBuilder().build(inputStream);
    }
    @Test
    public void test2() throws IOException {
        // 1. 获取sqlSessionFactory工厂对象
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();

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

        // 3. 获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.findUserById(1);
        System.out.println(mapper.getClass()); // class com.sun.proxy.$Proxy3
        System.out.println(user);

        // 4. 释放资源
        sqlSession.close();
    }
}

Xml配置

属性（properties）

在resources目录下创建db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=123456

orcl.driver=oracle.jdbc.OracleDriver
orcl.url=jdbc:oracle:thin:@localhost:1521:orcl
orcl.username=scott
orcl.password=123456

properties文件的引入

    <!--
        1、mybatis可以使用properties来引入外部properties配置文件的内容；
        resource：引入类路径下的资源
        url：引入网络路径或者磁盘路径下的资源
    -->
    <properties resource="db.properties"></properties>

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

设置（settings）

    <!--
        2、settings包含很多重要的设置项
        setting:用来设置每一个设置项
            name：设置项名
            value：设置项取值
    -->
    <settings>
        <!-- 开启驼峰命名法 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

更多属性

设置名	描述	有效值	默认值
cacheEnabled	全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存。	true \| false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。	true \| false	false
aggressiveLazyLoading	当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载（参考 lazyLoadTriggerMethods)。	true \| false	false （在 3.4.1 及之前的版本默认值为 true）
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: 输出提醒日志 ('org.apache.ibatis.session.AutoMappingUnknownColumnBehavior' 的日志等级必须设置为 WARN) FAILING: 映射失败 (抛出 SqlSessionException)	NONE, WARNING, FAILING	NONE
defaultExecutorType	配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）； BATCH 执行器将重用语句并执行批量更新。	SIMPLE REUSE BATCH	SIMPLE
defaultStatementTimeout	设置超时时间，它决定驱动等待数据库响应的秒数。	任意正整数	未设置 (null)
defaultFetchSize	为驱动的结果集获取数量（fetchSize）设置一个提示值。此参数只可以在查询设置中被覆盖。	任意正整数	未设置 (null)
defaultResultSetType	Specifies a scroll strategy when omit it per statement settings. (Since: 3.5.2)	FORWARD_ONLY \| SCROLL_SENSITIVE \| SCROLL_INSENSITIVE \| DEFAULT(same behavior with 'Not Set')	Not Set (null)
safeRowBoundsEnabled	允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为 false。	true \| false	False
safeResultHandlerEnabled	允许在嵌套语句中使用分页（ResultHandler）。如果允许使用则设置为 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 常量，常用值：NULL, VARCHAR 或 OTHER。	OTHER
lazyLoadTriggerMethods	指定哪个对象的方法触发一次延迟加载。	用逗号分隔的方法列表。	equals,clone,hashCode,toString
defaultScriptingLanguage	指定动态 SQL 生成的默认语言。	一个类型别名或完全限定类名。	org.apache.ibatis.scripting.xmltags.XMLLanguageDriver
defaultEnumTypeHandler	指定 Enum 使用的默认 TypeHandler 。（新增于 3.4.5）	一个类型别名或完全限定类名。	org.apache.ibatis.type.EnumTypeHandler
callSettersOnNulls	指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这在依赖于 Map.keySet() 或 null 值初始化的时候比较有用。注意基本类型（int、boolean 等）是不能设置成 null 的。	true \| false	false
returnInstanceForEmptyRow	当返回行的所有列都是空时，MyBatis默认返回 null。当开启这个设置时，MyBatis会返回一个空实例。请注意，它也适用于嵌套的结果集（如集合或关联）。（新增于 3.4.2）	true \| false	false
logPrefix	指定 MyBatis 增加到日志名称的前缀。	任何字符串	未设置
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J \| LOG4J \| LOG4J2 \| JDK_LOGGING \| COMMONS_LOGGING \| STDOUT_LOGGING \| NO_LOGGING	未设置
proxyFactory	指定 Mybatis 创建具有延迟加载能力的对象所用到的代理工具。	CGLIB \| JAVASSIST	JAVASSIST （MyBatis 3.3 以上）
vfsImpl	指定 VFS 的实现	自定义 VFS 的实现的类全限定名，以逗号分隔。	未设置
useActualParamName	允许使用方法签名中的名称作为语句参数名称。为了使用该特性，你的项目必须采用 Java 8 编译，并且加上 -parameters 选项。（新增于 3.4.1）	true \| false	true
configurationFactory	指定一个提供 Configuration 实例的类。这个被返回的 Configuration 实例用来加载被反序列化对象的延迟加载属性值。这个类必须包含一个签名为static Configuration getConfiguration() 的方法。（新增于 3.2.3）	类型别名或者全类名.	未设置

类型别名（typeAliases）

    <!-- 3、typeAliases：别名处理器：可以为我们的java类型起别名
			别名不区分大小写
	-->
    <typeAliases>
        <!--  type: java 全类名   alias：别名-->
        <typeAlias type="com.hcl.domain.User" alias="user"></typeAlias>

        <!-- 2、package:为某个包下的所有类批量起别名
            name：指定包名（为当前包以及下面所有的后代包的每一个类都起一个默认别名（类名小写），）
         -->
        <package name="com.hcl.domain"/>
        <!-- 3. 在javabean 加上 @Alias 注解
            @Alias("user")
            public class User {
                ...
            }
         -->
    </typeAliases>

mybatis 已经给 java 中常见的数据类型起好了别名

类型处理器（typeHandlers）

无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，都会用类型处理器将获取的值以合适的方式转换成 Java 类型。

插件（plugins）

MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：

Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
ParameterHandler (getParameterObject, setParameters)
ResultSetHandler (handleResultSets, handleOutputParameters)
StatementHandler (prepare, parameterize, batch, update, query)

环境配置（environments）

    <!--
    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">
        <!-- name: 数据库名    value: 别名 -->
        <property name="MySQL" value="mysql"/>
        <property name="DB2" value="db2"/>
        <property name="Oracle" value="oracle" />
    </databaseIdProvider>

databaseId：设置数据库标识（使用哪个数据库执行）

<mapper namespace="com.hcl.dao.UserMapper">
    <!-- public User findUserById(int id);-->
    <select id="findUserById" resultType="user" databaseId="mysql">
        select * from user where id = #{id}
    </select>
    <select id="findUserById" resultType="user" databaseId="oracle">
        select * from user where id = #{id}
    </select>
</mapper>

映射器（mappers）

    <!-- 将我们写好的sql映射文件（UserMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->

    <mappers>
        <!--
        mapper:注册一个sql映射
            注册配置文件
            resource：引用类路径下的sql映射文件
                mybatis/mapper/EmployeeMapper.xml
            url：引用网路路径或者磁盘路径下的sql映射文件
                file:///var/mappers/AuthorMapper.xml
        -->
        <mapper resource="com/hcl/dao/UserMapper.xml"/>
    </mappers>

class (注册接口) 有sql映射文件，映射文件名必须和接口同名，并且放在与接口同一目录下

    <mappers>
        <!--
          注册接口
            class：引用（注册）接口，
                1、有sql映射文件，映射文件名必须和接口同名，并且放在与接口同一目录下；
                2、没有sql映射文件，所有的sql都是利用注解写在接口上;
                推荐：
                    比较重要的，复杂的Dao接口我们来写sql映射文件
                    不重要，简单的Dao接口为了开发快速可以使用注解；
        -->
        <!--<mapper class="com.hcl.dao.UserMapper"></mapper>-->
        <mapper class="com.hcl.dao.UserMapperAnnotation"></mapper>
    </mappers>

package com.hcl.dao;

import com.hcl.domain.User;
import org.apache.ibatis.annotations.Select;

public interface UserMapperAnnotation {
    @Select("select * from user where id =#{id}")
    public User findUserById(int id);
}

批量注册（映射文件名必须和接口同名，并且放在与接口同一目录下）

    <mappers>
        <!-- 批量注册：  映射文件名必须和接口同名，并且放在与接口同一目录下-->
        <package name="com.hcl.dao"/>
    </mappers>

Xml 映射文件

insert 、update 和 delete

UserMapper.java

package com.hcl.dao;

import com.hcl.domain.User;
public interface UserMapper {
    public User findUserById(int id);
    public void addUser(User user);
    public void updateUser(User user);
    public Long deleteUser(int id);
}

UserMappr.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.hcl.dao.UserMapper">

    <!-- public void addUser(User user);-->
    <!-- parameterType: 参数类型，可以省略，-->
    <insert id="addUser" parameterType="com.hcl.domain.User">
        insert into user(username,password,name) values(#{username},#{password},#{name});
    </insert>

    <!-- public void updateUser(User user);-->
    <update id="updateUser" parameterType="user">
        update user set username = #{username},password=#{password},name=#{name} where id=#{id};
    </update>
    <!--     public boolean deleteUser(int id);
             mybatis 允许增删改直接定义以下数据类型
             Integer Long Boolean(>1 true ,<=0 false)
             delete =0 也是成功的
     -->
    <delete id="deleteUser" parameterType="int">
        delete from user where id = #{id};
    </delete>
</mapper>

MybatisTest 测试类

package com.hcl;

import com.hcl.dao.UserMapper;
import com.hcl.dao.UserMapperAnnotation;
import com.hcl.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;

public class MybatisTest {
    private static SqlSessionFactory getSqlSessionFactory() throws IOException {
        // 加载配置文件，创建 SqlSessionFactory 工厂
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        return  new SqlSessionFactoryBuilder().build(inputStream);
    }

    @Test
    public void test4() throws IOException {
        // 1. 获取sqlSessionFactory工厂对象
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        // 2. 获取sqlSession 对象 // true 自动提交
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        // 3. 获取接口的实现类对象
        //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        // 添加用户
//        User user = new User(null,"long","123","小龙");
//        mapper.addUser(user);
        // 修改用户
  /*      User user2 = new User(10,"long","122333","小龙");
        mapper.updateUser(user2);*/

        // 删除用户
        Long res = mapper.deleteUser(14);
        System.out.println(res);
        // 4. 释放资源
        sqlSession.close();
    }


}

insert 主键自增（mysql）

    <!-- public void addUser(User user);-->
    <!-- parameterType: 参数类型，可以省略，
        获取自增主键的值：
		mysql支持自增主键，自增主键值的获取，mybatis也是利用statement.getGenreatedKeys()；
		useGeneratedKeys="true"：使用自增主键获取主键值策略
		keyProperty：指定对应的主键属性，也就是mybatis获取到主键值以后，将这个值封装给javaBean的哪个属性
    -->
    <insert id="addUser" parameterType="com.hcl.domain.User" useGeneratedKeys="true"
            keyProperty="id" databaseId="mysql">
        insert into user(username,password,name) values(#{username},#{password},#{name});
    </insert>

insert 主键自增（oracle）

在主配置文件中设置 default 为 oracle

<environments default="dev_oracle">
</environments>

    <!--
    获取非自增主键的值：
        Oracle不支持自增；Oracle使用序列来模拟自增；
        每次插入的数据的主键是从序列中拿到的值；如何获取到这个值；
    -->
    <insert id="addUser" parameterType="com.hcl.domain.User" useGeneratedKeys="true"
            keyProperty="id" databaseId="oracle">
        <!--
            keyProperty:查出的主键值封装给javaBean的哪个属性
            order="BEFORE":当前sql在插入sql之前运行
                   AFTER：当前sql在插入sql之后运行
            resultType:查出的数据的返回值类型

            BEFORE运行顺序：
                先运行selectKey查询id的sql；查出id值封装给javaBean的id属性
                在运行插入的sql；就可以取出id属性对应的值
            -->
        <selectKey keyProperty="id" order="BEFORE" resultType="int">
            select s_user.nextval from dual
        </selectKey>
        insert into tab_user(id,username,password,name) values(#{id},#{username},#{password},#{name})
    </insert>

参数

    public User findUser(@Param("id") int id,@Param("username") String username);

    <!--  public User findUser(int id,String username);-->
    <select id="findUser" resultType="user">
        select * from user where id =#{id} and username = #{username};
    </select>

参数设置：

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


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


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

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

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

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

public Employee getEmp(Integer id,@Param("e")Employee emp);
	取值：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中的值或者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 (resultType = 泛型）

    <!-- 返回类型为List -->
    <!-- public List<User> findAll(); -->
    <select id="findAll" resultType="user">
        select * from user;
    </select>

返回类型为map

    // 返回一条记录的map: key 就是列名，value:就是对应的值
    // {password=123, name=小龙, id=13, username=long}
    public Map<String,Object> getUserByIdReturnMap(int id);

    //多条记录封装一个map：Map<Integer,User>:键是这条记录的主键，值是记录封装后的javaBean
    //@MapKey:告诉mybatis封装这个map的时候使用哪个属性作为map的key
    // {16=User{id=16, username='long', password='123', name='小龙'}, 17=User{id=17, username='long', password='123', name='小龙'}}
    @MapKey("id")
    public Map<Integer,User> getUserByUsernameLikeReturnMap(String username);

    <!-- 单条数据 resultType = "map" -->
    <!--   public Map<String,Object> getUserByIdReturnMap(int id); -->
    <select id="getUserByIdReturnMap" resultType="map">
        select * from user where id = #{id}
    </select>

    <!-- 多条数据 resultType = "值的类型" -->
    <!-- public Map<Integer,User> getUserByUsernameLikeReturnMap(String username);-->
    <select id="getUserByUsernameLikeReturnMap" resultType="user">
        select * from user where username like #{username}
    </select>

resultMap (自定义javabean的封装规则）

 <!--自定义某个javaBean的封装规则
        type：自定义规则的Java类型
        id:唯一id方便引用
     -->
    <resultMap id="my_user" type="com.hcl.domain.User">
        <!--指定主键列的封装规则
            id定义主键会底层有优化；
            column：指定哪一列(数据库字段)
            property：指定对应的javaBean属性
         -->
        <id column="id" property="id"></id>
        <!-- 定义普通列封装规则 -->
        <result column="username" property="username"></result>
        <result column="password" property="password"></result>
        <result column="name" property="name"></result>
    </resultMap>

    <!-- resultMap:自定义结果集映射规则；  -->
    <!-- public User findUserById(int id);-->
    <select id="findUserById" resultMap="my_user">
        select * from user where id = #{id}
    </select>

创建部门表，一个部门有多个用户，一个用户只属于一个部门

create table dept(
id int(11) PRIMARY key,
dept_name varchar(32)
)

INSERT into dept values(1,"开发部"),(2,"科研部"),(3,"人事部")

-- 给用户表添加一列
alter table user add dept_id int;

-- 给dept_id 设置外键
alter table user add CONSTRAINT fk_user_dept
foreign key(dept_id) references dept(id)

创建Dept.java

package com.hcl.domain;

public class Dept {
    private Integer id;
    private String deptName;
    
    // 省略get\set\toString 
}

在User.java 中添加属性

public class User {
    private Integer id;
    private String username;
    private String password;
    private String name;
    private Dept dept;
}

查询用户的同时查询所在部门 (一)

<!--
    场景一：
            查询user的同时查询用户对应的部门
            一个员工对应一个部门；
    -->
    <!--联合查询：级联属性封装结果集  -->
    <resultMap id="my_user_1" type="com.hcl.domain.User">
        <id column="id" property="id"></id>
        <result column="username" property="username"></result>
        <result column="password" property="password"></result>
        <result column="name" property="name"></result>

        <result column="id" property="dept.id"></result>
        <result column="dept_name" property="dept.deptName"></result>
    </resultMap>
    <!-- public User findUserAndDeptById(int id);-->
    <select id="findUserAndDeptById" resultMap="my_user_1">
        select u.*,d.id,d.dept_name from user u ,dept d where u.dept_id = d.id and u.id = #{id}
    </select>

查询用户的同时查询所在部门 (二)

    <resultMap id="my_user_2" type="com.hcl.domain.User">
        <id column="id" property="id"></id>
        <result column="username" property="username"></result>
        <result column="password" property="password"></result>
        <result column="name" property="name"></result>
        <!--  association可以指定联合的javaBean对象
                property="dept"：指定哪个属性是联合的对象
                javaType:指定这个属性对象的类型[不能省略]
        -->
        <association property="dept" javaType="com.hcl.domain.Dept" >
            <id column="id" property="id"></id>
            <result column="dept_name" property="deptName"></result>
        </association>
    </resultMap>
    <!-- public User findUserAndDeptById(int id);-->
    <select id="findUserAndDeptById" resultMap="my_user_2">
        select u.*,d.id,d.dept_name from user u ,dept d where u.dept_id = d.id and u.id = #{id}
    </select>

查询用户的同时查询所在部门 (三) 分步查询

DeptMapper.xml

<mapper namespace="com.hcl.dao.DeptMapper">
    <!--     public Dept findDeptById(int id);-->
    <select id="findDeptById" resultType="com.hcl.domain.Dept">
        select * from dept where id = #{id}
    </select>
</mapper>

UserMapper.xml

    <!-- 使用association进行分步查询：
         1、先按照员工id查询员工信息
         2、根据查询员工信息中的d_id值去部门表查出部门信息
         3、部门设置到员工中；
     -->
    <resultMap id="user_dept_step" type="com.hcl.domain.User">
        <id column="id" property="id"></id>
        <result column="username" property="username"></result>
        <result column="password" property="password"></result>
        <result column="name" property="name"></result>
        <!-- association定义关联对象的封装规则
            select:表明当前属性是调用select指定的方法查出的结果
            column:指定将哪一列的值传给这个方法

            流程：使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性
        -->
        <association property="dept" select="com.hcl.dao.DeptMapper.findDeptById" javaType="com.hcl.domain.Dept"
                     column="dept_id">
        </association>
    </resultMap>

    <!--public User findUserByIdStep(int id);-->
    <select id="findUserByIdStep" resultMap="user_dept_step">
        select * from user where id =#{id};
    </select>

分步查询可以开启延迟加载

	 <!-- 可以使用延迟加载（懒加载）；(按需加载)
	 	User==>Dept：
	 		我们每次查询User对象的时候，都将一起查询出来。
	 		部门信息在我们使用的时候再去查询；
	 		分段查询的基础之上加上两个配置：
	  -->      
        
        <!-- 开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>

查询部门的同时查询出部门所有的用户

Dept.java 给部门添加属性

public class Dept {
    private Integer id;
    private String deptName;
    // 一个部门有多个用户
    private List<User> users;
}

第一种方法

 <!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则  -->
    <resultMap id="dept_user" type="com.hcl.domain.Dept">
        <id column="d_id" property="id"></id>
        <result column="dept_name" property="deptName"></result>
        <!--
            collection定义关联集合类型的属性的封装规则
            ofType:指定集合里面元素的类型
        -->
        <collection property="users" ofType="com.hcl.domain.User">
            <id column="id" property="id"></id>
            <result column="username" property="username"></result>
            <result column="password" property="password"></result>
            <result column="name" property="name"></result>
        </collection>
    </resultMap>

    <!-- public Dept findDeptAndAllUserById(int id);-->
    <select id="findDeptAndAllUserById" resultMap="dept_user">
        select d.id d_id,d.dept_name,u.id,u.username,u.password,u.name,u.dept_id
        from dept d
        left join user u
        on d.id = u.dept_id
        where d.id = #{id}
    </select>

第二种方法（分布查询）

1. 通过部门id 查询出所在部门的全部信息

2.通过部门id 查询所有用户

UserMapper.xml

<mapper namespace="com.hcl.dao.UserMapper">    
    <!--public List<User> findUsersByDeptId();-->
    <select id="findUsersByDeptId" resultType="com.hcl.domain.User">
        select * from user where dept_id=#{id}
    </select>
</mapper>

DeptMapper.xml

    <!-- collection：分段查询 -->
    <resultMap id="dept_user_step" type="com.hcl.domain.Dept">
        <id column="id" property="id"></id>
        <result column="dept_name" property="deptName"></result>
        <!--
        流程：使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性
        -->
        <collection property="users" select="com.hcl.dao.UserMapper.findUsersByDeptId"
                    column="id">
        </collection>
    </resultMap>

    <!--public Dept findDeptByIdStep(int id);-->
    <select id="findDeptByIdStep" resultMap="dept_user_step">
        select * from dept where id = #{id}
    </select>

扩展

	<!-- 扩展：多列的值传递过去：
			将多列的值封装map传递；
			column="{key1=column1,key2=column2}"
		fetchType="lazy"：表示使用延迟加载；
				- lazy：延迟
				- eager：立即
	 -->