mybatis的总结1

最新推荐文章于 2024-08-21 23:39:15 发布

赵宪福

最新推荐文章于 2024-08-21 23:39:15 发布

阅读量219

点赞数

分类专栏： SSM框架文章标签： mybatis 知识点

本文链接：https://blog.csdn.net/qq_35336425/article/details/82828472

版权

SSM框架专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Mybatis笔记
学习过的持久层框架：DBUtils , Hibernate

Mybatis就是类似于hibernate的orm持久层框架。

为什么学Mybatis?

目前最主流的持久层框架为hibernate与mybatis，而且国内目前情况使用Mybatis的公司比hibernate要多。
Hibernate学习门槛不低，要精通门槛更高。门槛高在怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate缓存与数据加载策略方面需要你的经验和能力都很强才行。国内目前前的情况精通hibernate技术大牛非常少。
sql优化方面，Hibernate的查询会将表中的所有字段查询出来，这一点会有性能消耗。当然了，Hibernate也可以自己写HQL来指定需要查询的字段，但这样就破坏了Hibernate开发的简洁性。说得更深入一些，如果有个查询要关联多张表，比如5张表，10张表时，而且，我们要取的字段只是其中几张表的部分字段。这时用hibernate时就会显得非常力不从心。就算用hibernate的sqlquery，后续的维护工作也会让人发狂。
1 JDBC编程回顾与存在的问题分析
1.1 开发步骤：
导入数据脚本，在课前资料中有
创建工程，导入mysql jar包
编码
1.2 Jdbc访问数据库的过程：
//加载数据库驱动
//创建数据库连接
//创建statement
//设置sql语句
//设置查询参数
//执行查询，得到ResultSet
//解析结果集ResultSet
//释放资源

1.3 Jdbc存在的问题：

频繁创建和打开、关闭数据连接，太消耗资源
Sql语句存在硬编码，不利于维护
Sql参数设置硬编码，不利于维护
结果集获取与遍历复杂，存在硬编码，不利于维护，期望能够查询后返回一个java对象
2 Mybatis介绍
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。
Mybatis是面向sql的持久层框架，他封装了jdbc访问数据库的过程，我们开发，只需专注于sql语句本身的拼装，其它复杂的过程全部可以交给mybatis去完成。
Mybatis也是属于面向接口进行编程的，每一个Mapper就是一个接口，他的实现类就是需要写SQL语句的xmL文件，这个xml文件其实就是它的实现类，
我们如何创建实现类对象，然后调用方法呢？
就是利用获取mapper接口的字节码文件，然后利用动态代理，创建一个动态的代理对象，我们利用这个代理对象去调他的方法，然后执行这个接口下面的方法，这样的话，不仅解耦了，并且xml只书写了SQL语句
3 映射关系：
映射：就是一一对应的关系，比如map中的key和value。数学中函数，我们将变量传入进去，然后得到其对应的函数值就是一对映射关系。
mybatis所需要的映射文件包含三部分：
SQL
映射规则
POJO
mybatis<—- pojo—->注解 SQL_Mapper —->数据
应用程序—->对象<—- 接口 xml映射文件 <—-库
mybatis的基本构成
.SqlSessionFactoryBuilder(构造器)：他会根据配置信息或者代码来生成SqlSessionFactory(工厂接口)。
.SqlSessionFactory：依靠工厂来生成SqlSession(会话)。
.SqlSession：是一个既可以发送SQL去执行并返回结果，也可以获取Mapper接口。
.Sql Mapper：他是MyBatis新设计的组件，他是由一个java接口和xml文件(或者注解)构成的。需要给出对应的SQL和映射规则，
他负责发送SQL去执行，并返回执行结果。
4 Mybaits入门
4.1 工程搭建
导入依赖jar包，
数据库的表结构，进行配置
配置mybatis-Config.xml
配置log4j.properties
建立pojo到工程目录下
配置sql查询的映射文件
加载映射文件，进行测试
4.2 完成需求
4.2.1 单表的需求列表
User findUserById(int id);
多个参数的话，需要注意：

User findUserByIdAndName(@Param(“id”) int id, @Param(“name”) String name);
List findAllUser();
void addUser(User user);
void delete(User user);
void update(User user);
4.2.2 数据库的表结构，进行创建

4.2.3 配置数据源
#MySQL数据源配置
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/heimatest
jdbc.username=root
jdbc.password=123456

#Oracle数据源配置
#orcl.driver=oracle.jdbc.OracleDriver
#orcl.url=jdbc:oracle:thin:@localhost:1521:orcl
#orcl.username=scott
#orcl.password=123456

4.2.4 mybatis-Config.xml的配置

<?xml version="1.0" encoding="UTF-8" ?>

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

<!--
  2、settings包含很多重要的设置项
  setting:用来设置每一个设置项
     name：设置项名
     value：设置项取值
-->

<!--这个是驼峰命名法，是为了将SQL查询到的数据和对应的javaBean进行一一映射的时候，忽略属性名的大小写格式-->
<settings>
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
<!-- 3、typeAliases：别名处理器：可以为我们的java类型起别名
     别名不区分大小写

–>

    <!-- 2、package:为某个包下的所有类批量起别名
            name：指定包名（为当前包以及下面所有的后代包的每一个类都起一个默认别名（类名小写），）
    -->
    <package name="com.itheima.mybatis.pojo"/>

    <!-- 3、批量起别名的情况下，使用@Alias注解为某个类型指定新的别名 -->
</typeAliases>

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

        dataSource：数据源;
           type:数据源类型;UNPOOLED(UnpooledDataSourceFactory)
                    |POOLED(PooledDataSourceFactory)
                    |JNDI(JndiDataSourceFactory)
           自定义数据源：实现DataSourceFactory接口，type是全类名
   -->
<!--这里定义默认使用MySQL的环境-->
<environments default="dev_mysql">
    <!--配置mysql的环境-->
    <environment id="dev_mysql">
        <!-- 配置JDBC事务控制，由mybatis进行管理 -->
        <transactionManager type="JDBC">
        </transactionManager>
        <!-- 配置数据源，采用mybatis连接池 -->
        <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>
    <!--配置Oracle的环境-->
    <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>
<!-- 5、databaseIdProvider：支持多数据库厂商的；
 type="DB_VENDOR"：VendorDatabaseIdProvider
     作用就是得到数据库厂商的标识(驱动getDatabaseProductName())，mybatis就能根据数据库厂商标识来执行不同的sql;
     MySQL，Oracle，SQL Server,xxxx

–>

<!-- 将我们写好的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.itheima.mybatis.dao"/>   最常用-->

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

4.2.5 log4j.properties的配置：

Global logging configuration

log4j.rootLogger=DEBUG, stdout

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

4.2.6 UserMapper.xml的SQL映射文件：

<?xml version="1.0" encoding="UTF-8"?>

<!--
User findUserById(int id);
User findUserByIdAndName(int id,String name);
List<User> findAllUser();
void addUser(User user);
void delete(User user);
void update(User user);
-->
<!--查询的时候必须指定返回值的类型，增删改可以不指定，增删改需要指定传入参数的类型-->
<!--在调用方法传入的参数为map，我们直接可以写属性名

list的话我们可以直接用索引指定属性，传入的是一个对象，我们直接用其属性名–>

select * from user where id=#{id}

select * from user where id=#{id} and name=#{name}

<!--resultType的取值：如果返回值是一个集合类型，我们需要写集合中元素的类型-->

<select id="findAllUser" databaseId="mysql" resultType="com.itheima.mybatis.pojo.User">
    SELECT * from user
</select>

<!-- parameterType：参数类型，可以省略，

获取自增主键的值：
mysql支持自增主键，自增主键值的获取，mybatis也是利用statement.getGenreatedKeys()；
useGeneratedKeys=“true”；使用自增主键获取主键值策略
keyProperty；指定对应的主键属性，也就是mybatis获取到主键值以后，将这个值封装给javaBean的哪个属性
–>

<!–
keyProperty:查出的主键值封装给javaBean的哪个属性
order=“BEFORE”:当前sql在插入sql之前运行
resultType:查出的数据的返回值类型

    BEFORE运行顺序：
        先运行selectKey查询id的sql；查出id值封装给javaBean的id属性
        在运行插入的sql；就可以取出id属性对应的值-->
    <selectKey keyProperty="id" order="BEFORE" resultType="Integer">
        <!-- 编写查询主键的sql语句 -->
        <!-- BEFORE-->
    </selectKey>
    select EMPLOYEES_SEQ.nextval from dual
    <!-- 插入时的主键是从序列中拿到的 -->
    <!-- BEFORE:-->
    insert into user(id,name,password,sex) values (null,#{name},#{password},#{sex})
</insert>

<insert id="addUser" databaseId="mysql" parameterType="com.itheima.mybatis.pojo.User" useGeneratedKeys="true"
        keyProperty="id">
    insert into user(id,name,password,sex) values (null,#{name},#{password},#{sex})
</insert>

<!--void delete(User user);-->
<delete id="delete" parameterType="com.itheima.mybatis.pojo.User">
    DELETE from user where id =#{id}
</delete>

<!--void update(User user);-->
<update id="update" parameterType="com.itheima.mybatis.pojo.User">
    update user set name=#{name},password=#{password},sex=#{sex} where id=#{id}
</update>

4.2.7 创建pojo实体类对象
package com.itheima.mybatis.pojo;

/**

@ClassName:User
@Despriction: //pojo 映射类，与数据库中的表对应
@Author:zhaoxianfu
@Date:Created 2018/8/5 20:55
@Version1.0
**/
public class User {
private int id ;
private String name;
private String password;
private String sex;

public User() {
}

public User(int id, String name, String password, String sex) {
this.id = id;
this.name = name;
this.password = password;
this.sex = sex;
}

public User(String name, String password, String sex) {
this.name = name;
this.password = password;
this.sex = sex;
}

public int getId() {
return id;
}

public void setId(int 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 String getSex() {
return sex;
}

public void setSex(String sex) {
this.sex = sex;
}

@Override
public String toString() {
return “User{” +
“id=” + id +
“, name=’” + name + ‘’’ +
“, password=’” + password + ‘’’ +
“, sex=’” + sex + ‘’’ +
‘}’;
}
}
4.2.8 创建测试类测试
package com.itheima.mybatis.test;

import com.itheima.mybatis.dao.UserMapper;
import com.itheima.mybatis.pojo.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;
import java.util.List;

/**

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

// 抽取获得一个连接的工厂类型的方法
public SqlSessionFactory getSqlSessionFactory() throws IOException {
String resource=“mybatis-Config.xml”;
InputStream resourceAsStream = Resources.getResourceAsStream(resource);
return new SqlSessionFactoryBuilder().build(resourceAsStream);
}

@Test
public void test01() throws IOException {
    String resource="mybatis-Config.xml";
    InputStream resourceAsStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

// 这个方式是获取一次与数据库的连接，可以对数据库进行操作，相当于connection,以后需要线程连接池
SqlSession sqlSession = sqlSessionFactory.openSession();
// 创建一个代理对象，会对应去找其对应的映射mapper配置文件
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 会自动找对应映射的mapper配置文件的id为方法名的SQL语句
User user = userMapper.findUserById(1);
System.out.println(user);
// sqlSession是线程不安全的，必须进行关闭
sqlSession.close();
}

@Test
public void test02() throws IOException {
    String resource="mybatis-Config.xml";
    InputStream resourceAsStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

// 这个方式是获取一次与数据库的连接，可以对数据库进行操作，相当于connection,以后需要线程连接池
SqlSession sqlSession = sqlSessionFactory.openSession();
// 创建一个代理对象，会对应去找其对应的映射mapper配置文件
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 会自动找对应映射的mapper配置文件的id为方法名的SQL语句
User user = userMapper.findUserByIdAndName(2, “女孩子”);
System.out.println(user);
sqlSession.close();
}

@Test
public void test03() throws IOException {
    SqlSession sqlSession = getSqlSessionFactory().openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    List<User> allUser = userMapper.findAllUser();
    System.out.println(allUser);
    sqlSession.close();
}

@Test
public void test04() throws IOException {
    String resource="mybatis-Config.xml";
    InputStream resourceAsStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = new User("re21r","1324256","1");
    userMapper.addUser(user);

// System.out.println(1111111111);
// mybatis需要手动提交
sqlSession.commit();
System.out.println(user.getId());
sqlSession.close();
}

@Test
public void test05() throws IOException {
    String resource="mybatis-Config.xml";
    InputStream resourceAsStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = new User(2,"中国","24524","1");
    userMapper.update(user);

// System.out.println(1111111111);
// mybatis需要手动提交
sqlSession.commit();
sqlSession.close();
}
/**
* 测试增删改
* 1、mybatis允许增删改直接定义以下类型返回值
* Integer、Long、Boolean、void
* 2、我们需要手动提交数据
* sqlSessionFactory.openSession();=》手动提交
* sqlSessionFactory.openSession(true);=》自动提交
* @throws IOException
*/

@Test
public void test06() throws IOException {
    String resource="mybatis-Config.xml";
    InputStream resourceAsStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = new User();
    user.setId(21);
    userMapper.delete(user);

// System.out.println(1111111111);
// mybatis需要手动提交
sqlSession.commit();
sqlSession.close();
}
}

4.2.9 可以进行抽取SqlSessionFactoryUtils工具类，共SqlSessionFactory创建过程（可以选择抽取）

/**

SqlSessionFactory工具类
@author Steven

*/
public class SqlSessionFactoryUtils {

/**
 * 单例SqlSessionFactory
 */
private static SqlSessionFactory sqlSessionFactory;

static {
	// 创建SqlSessionFactoryBuilder对象
	SqlSessionFactoryBuilder sfb = new SqlSessionFactoryBuilder();
	try {
		// 查找配置文件创建输入流
		InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
		// 加载配置文件，创建SqlSessionFactory对象
		sqlSessionFactory = sfb.build(inputStream);
	} catch (IOException e) {
		e.printStackTrace();
	}
}

/**
 * 获取单例SqlSessionFactory
 * @return
 */
public static SqlSessionFactory getSqlSessionFactory() {
	return sqlSessionFactory;
}

}
4.2.10 接口方法中参数个数
当参数个数为一个的时候：不论其里面参数类型，都可以用属性名进行获取
在调用方法传入的参数为map，我们直接可以写属性名
list的话我们可以直接用索引指定属性，
传入的是一个对象，我们直接用其属性名
参数个数为多个时候：需要起别名，在接口处定义@param(“别名”)，然后在SQL配置文件中获取param1，依次取值。

第一种方式：以Map的方式当做参数传递

4.2.11 #{}和${}的区别和使用方式：

4.2.12 ResultType自动映射:
ResultType属于自动封装的类型，要求的是数据库中的javaBean需要对应。

1.返回值为一个list集合的对象，我们设定返回值的类型为集合中元素的类型
List findAllUser();

<!—第二步：.封装数据的规则：–>

 <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指定的属性
 	 -->

<!—第三步：根据第一步查询出来d_id部门表中查询查询自己所属部门的信息，然后封装到这个JavaBean的属性dept这另一个JavaBean上 -->

<!—第一步：.进行分步去查询：–>

 <select id="getEmpByIdStep" resultMap="MyEmpByStep">
 	select * from tbl_employee where id=#{id}
 </select>

另外一个mapper.xml文件的查询语句

select id,dept_name from tbl_dept where id=#{id}

4.2.14.5.1 懒加载，按需加载（利用association进行分步查询时使用，需要在全局配置文件配置两个setting标签内容）：
4.2.14.5.1.1 使用场景：分段查询的基础之上加上两个配置：
分步查询时候有两个sql语句：第二个依赖第一个查询出来的结果。
好处：可以省略不必要的SQL语句对数据库的操作。
比如分步查询的时候是需要另个sql语句的：
情况一：如果我们在业务层用到是这个整个的javaBean对象，那么就会执行这两个sql语句。
情况二：如果我们在业务层调用需要的是第一个sql语句查询出来的结果，那么第二个sql语句就不会执行，节省了查询sql语句对数据库操作的使用，
情况三：如果我们需要第二个sql语句查询出来的结果，那么两个sql语句都会执行的。
4.2.14.5.1.2 全局文件中配置内容

	<setting name="lazyLoadingEnabled" value="true"/>
	<setting name="aggressiveLazyLoading" value="false"/>

4.2.14.6 封装集合方式一：使用collection标签定义关联的集合类型的属性封装规则（直接根据一个SQL语句）
直接根据一个sql语句查询出来所有的字段，统计进行了对应的封装。

4.2.14.7 封装集合方式二: 使用collection标签定义关联的集合类型的属性分步查询，可以实现懒加载：（多个SQL语句，）
员工mapper.xml里面的SQL语句

部门mapper.xml里面的SQL语句

4.2.14.7.1 执行步骤：
1.首先根据传入进来的部门id进行查询出来这个部门的信息，然后对查询出来的信息进行封装。封装了两个属性
2.然后根据部门id调用员工表里面定义的方法继续去员工表里面去查询员工的信息（返回值为一个集合），然后对查询出来的数据coollection进行封装。封装第三个属性，list集合
3.最终返回的是我们利用两个sql语句查询出来的所有的结果，封装到一个JavaBean实体类上，根据resultMap标签指定的type类型。
4.2.14.7.2 扩展：
把从第一个sql语句中得到的多列的值传递到之后的sql语句中，需要用以下用法：

4.2.14.8 Discriminator鉴别器

4.2.14.9 调用方法时内置参数
调用Mapper方法的时候传递到sql配置文件过来的参数，不只是用传递过来的参数可以用来判断，两个内置参数也是可以进行使用。

_databaseId是数据库使用的是什么，就执行什么数据库环境下的SQL语句，和SQL语句中设置属性databaseId=”mysql”的作用是一样的。

4.2.15 Mybatis入门小结与Mybatis架构图

5 Mybatis Dao开发方式
5.1 Dao需求
根据用户ID查询用户信息
根据用户名查找用户列表
添加用户
5.2 原始Dao开发方法
5.2.1 使用原有的user映射文件，不需修改

5.2.2 新建个UserDao接口
public interface UserDao {

/**根据用户ID查询用户信息
 * @param id
 * @return
 */
User getUserById(Integer id);

/**
 * 根据用户名查找用户列表
 * @param name
 * @return
 */
List<User> getUserByUserName(String name);

/**
 * 添加用户
 * @param user
 */
void insertUser(User user);

}
5.2.3 新建个UserDaoImpl接口实现类
public class UserDaoImpl implements UserDao {

@Override
public User getUserById(Integer id) {
	SqlSession sqlSession = SqlSessionFactoryUtils.getSqlSessionFactory().openSession();
	User user = sqlSession.selectOne("user.getUserById", id);
	sqlSession.close();
	return user;
}

@Override
public List<User> getUserByUserName(String name) {
	SqlSession sqlSession = SqlSessionFactoryUtils.getSqlSessionFactory().openSession();
	List<User> list = sqlSession.selectList("user.getUserByName", name);
	sqlSession.close();
	return list;
}

@Override
public void insertUser(User user) {
	SqlSession sqlSession = SqlSessionFactoryUtils.getSqlSessionFactory().openSession();
	sqlSession.insert("user.insertUser", user);
	sqlSession.commit();
	sqlSession.close();
}

}

5.2.4 使用dao测试

public class UserDaoTest {

@Test
public void testGetUserById() {
	UserDao userDao = new UserDaoImpl();
	User user = userDao.getUserById(30);
	System.out.println(user);
}

@Test
public void testGetUserByUserName() {
	UserDao userDao = new UserDaoImpl();
	List<User> list = userDao.getUserByUserName("张");
	for (User user : list) {
		System.out.println(user);
	}
}

@Test
public void testInsertUser() {
	UserDao userDao = new UserDaoImpl();
	User user = new User();
	user.setUsername("张飞3");
	user.setAddress("深圳市黑马");
	user.setBirthday(new Date());
	user.setSex("1");
	userDao.insertUser(user);
}

}
5.3 官方推荐，接口动态代理
5.3.1 动态代理dao开发规则

namespace必需是接口的全路径名
接口的方法名必需与映射文件的sql id一致
接口的输入参数必需与映射文件的parameterType类型一致
接口的返回类型必须与映射文件的resultType类型一致
5.3.2 动态代理dao开发步骤
创建UserMapper.xml映射文件(把原来的user.xml复制按开发规则要求修改一下)
创建UserMapper接口(把原来的UserDao.java复制按开发规则要求修改一下)
加载UserMapper.xml
测试动态代理Dao

public class UserMapperTest {

@Test
public void testGetUserById() {
	// 加载配置得到SqlSession
	SqlSession sqlSession = SqlSessionFactoryUtils.getSqlSessionFactory().openSession();
	// 获取代理对象
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	// 查询数据
	User user = userMapper.getUserById(30);
	System.out.println(user);
	// 关闭资源
	sqlSession.close();
}

@Test
public void testGetUserByUserName() {
	SqlSession sqlSession = SqlSessionFactoryUtils.getSqlSessionFactory().openSession();
	// 获取代理对象
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	// 查询数据
	List<User> list = userMapper.getUserByName("张");
	for (User user : list) {
		System.out.println(user);
	}
	// 关闭资源
	sqlSession.close();
}

@Test
public void testInsertUser() {
	SqlSession sqlSession = SqlSessionFactoryUtils.getSqlSessionFactory().openSession();
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	User user = new User();
	user.setUsername("张飞飞");
	user.setAddress("深圳市黑马");
	user.setBirthday(new Date());
	user.setSex("1");
	userMapper.insertUser(user);
	// 提交事务
	sqlSession.commit();
	// 关闭资源
	sqlSession.close();
}

}
6 SqlMapConf.xml配置

6.1 properties
6.1.1 属性核心文件配置

<properties resource="jdbc.properties">
	<property name="jdbc.username" value="root1"/>
	<property name="jdbc.password" value="root"/>
</properties>

6.1.2 jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root
6.2 typeAliases
mybatis默认支持java基本数据类型的别名识别详细参考教案。

自定义别名

6.3 mappers

	<!-- 第二种方式，class扫描器要求：
		 1、映射文件与接口同一目录下
		 2、映射文件名必需与接口文件名称一致
	 -->
	<!-- <mapper class="com.itheima.mybatis.mapper.UserMapper"/> -->
	
	<!-- 第三种方式，包扫描器要求(推荐使用此方式)：
		 1、映射文件与接口同一目录下
		 2、映射文件名必需与接口文件名称一致
	-->
	<package name="com.itheima.mybatis.mapper"/>