MyBatis初体验(二)

两种使用方式

原始Dao开发方式

Mapper.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">
<mapper namespace="userMapper">
    <select id="findAll" resultType="com.tzt.domain.User">
        select * from user
    </select>
</mapper>

Dao接口

public interface UserDao {
	//查询全部
    public List<User> findAll();
}

Dao实现类

public class UserDaoImpl implements UserDao {
    private SqlSessionFactory sqlSessionFactory;
	//有参构造,想要创建一个dao层的实现类对象必须传进一个sqlSessionFactory对象进来
    public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
    }
    @Override
    public List<User> findAll() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        List<User> userList = sqlSession.selectList("userMapper.findAll");
        sqlSession.close();
        return userList;
    }
}

Dao测试类

public class TestMybatisCRUD {
    SqlSessionFactory sessionFactory;
    @Before
    public void init(){
        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("SqlMapConfig.xml");
        sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }
    @Test
    public void testFindAll(){
        UserDao userDao = new UserDaoImpl(sessionFactory);
        List<User> userList = userDao.findAll();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

Mapper动态代理方式

省略了编写dao接口实现类

使用规则

• Mapper映射文件的namespace必须是dao接口(mybatis中叫mapper接口)的全限类名
• Mapper映射文件中的子标签id必须是dao接口中的方法名称(方法名一般不重复)
• xml文件与接口包路径一致
• 配置文件和dao接口的名称必须一致

Mapper.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">
<mapper namespace="com.itheima.dao.UserDao">
    <select id="findAll" resultType="com.tzt.domain.User">
        select * from user
    </select>
</mapper>

Dao接口

public interface UserDao {
	//查询全部
    public List<User> findAll();
}

Dao测试类

public void testFindAll(){
    InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("SqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //获取Dao接口的动态代理对象
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    List<User> userList = userDao.findAll();
    for (User user : userList) {
        System.out.println(user);
    }
    sqlSession.close();
}

使用分析

Mybatis解决原生jdbc编程的问题

• 在SqlMapConfig.xml中配置数据连接池来管理数据库连接。解决了频繁创建、释放数据库连接造成系统资源浪费的问题
• Sql变动不再需要改变java代码，解决了不易维护的问题
• 自动将Java对象映射至Sql语句。解决了硬编码的问题，不用再与占位符一一对应
• 自动将Sql执行结果映射至Java对象。解决了结果集解析困难的问题

实现类中用到的各种对象

• SqlSessionFactoryBuilder:创建SqlSessionFacoty，一旦创建完成就不需要SqlSessionFactoryBuilder了，因为SqlSession是通过SqlSessionFactory生产，所以可以将SqlSessionFactoryBuilder当成一个工具类使用，最佳使用范围是方法范围即方法体内局部变量;

• SqlSessionFactory:是一个接口，接口中定义了openSession的不同重载方法，SqlSessionFactory的最佳使用范围是整个应用运行期间，一旦创建后可以重复使用，通常以单例模式管理SqlSessionFactory。

• SqlSession:是一个面向用户的接口，其中封装了对数据库的操作，如：增删改查等。每个线程都应该有它自己的SqlSession实例。SqlSession的实例不能共享使用，它也是线程不安全的（因为SqlSession底层对应的是Connection连接）。因此最佳的范围是请求或方法范围。

全局配置文件SqlMapConfig.xml

标签名	含义
*properties?,	引入属性文件
settings?,	设置mybatis框架的核心(全局配置参数 )
*typeAliases?,	类型别名操作
typeHandlers?,	类型转换操作
objectFactory?,	对象工厂
objectWrapperFactory?,
reflectorFactory?,
plugins?,	插件-- ssm综合练习：分页插件
environments?,	环境，数据源
databaseIdProvider?,
*mappers?	引入映射配置文件

? : 一个或零个
, : 必须按照此顺序编写
| : 只能选一个

jdbc.properties

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

<?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>
    <!--先配置属性再引用属性(会被引用的同名属性覆盖)：${属性名}	ognl表达式(Struts2) 不是el表达式-->
    <properties resource="jdbc.properties"><!--引入外部的属性文件-->
    	<property name="driver" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </properties>
    <typeAliases><!--类型别名操作-->
        <!--指定某类型的别名
            type: 全限类名
            alias:对应的别名
            别名在应用时不用注意大小写
		    在映射文件中用别名
        -->
        <typeAlias type="com.itheima.domain.User" alias="user"></typeAlias>
        <!--引入此包中所有的类型，别名就是简单类名-->
        <package name="com.itheima.domain"></package>
    </typeAliases>
    <environments default="development">
        <environment id="development">
        	<!--事务管理：jdbc-->
            <transactionManager type="JDBC"/>
            <!--数据源(数据库连接池)
                type:连接池的类型
                    POOLED :连接池
                    UNPOOLED : 非连接池配置, 每次都是获取一个连接，释放连接
                    JNDI: 引用其他服务连接池配置-->
            <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>
    <!--引入映射配置文件-->
    <mappers>
        <!--resource： 配置的是相对路径-->
        <mapper resource="com/tzt/mapper/UserMapper.xml"/>

        <!--动态代理对象中使用-->
        <!--关联的dao的接口对象,通过接口对象可以映射到映射配置文件-->
        <mapper class="com.tzt.dao.UserDao"></mapper>
        <!--配置的绝对路径:了解-->
        <mapper url="file:///F:\ideaworkspace\src\main\resources\com\itheima\mapper\UserMapper.xml"></mapper>
        <!--推荐使用配置-->
        <!--必须遵守的原则：配置文件的namespace必须是接口的全限类名
                         配置文件和dao接口必须在同一个包中
                         配置文件和dao接口的名称必须一致-->
        <package name="com.itheima.dao"></package>
    </mappers>
</configuration>

映射文件Mapper.xml

parameterType

简单类型: 直接用#{}或者${value}取
包装类型: #{属性名},多属性时可以自定义包装类(QueryVo)
Map: #{Map的键}
多个参数: 不用配置parameterType,直接传{param1},{param2},…

resultMap

类中的属性名与数据库中的列名不一致需要做结果映射

<!--结果映射标签
            id:唯一的标志
            type: 对应的类型是什么-->
    <resultMap id="userList" type="user">
        <!--主键的映射-->
        <!--property: 对应pojo类型中的属性名
            column； 对应数据表的列名-->
        <id property="id" column="uid"></id>
    </resultMap>
    <!--注意resultType变为resultMap-->
    <select id="findAll" resultMap="userList">
        select * from user
    </select>

事务问题

在JDBC中:

• 事务1：获取到连接后，设置连接不能自动自动提交
• 事务2：sql执行完之后，需要提交执行
• 事务3：如果出现异常，事务回滚
• 事务4：设置连接为自动提交:状态还原

在MyBatis中: 获得的连接池对象默认状态是不自动提交,通过sqlSession.commit提交事务,也可通过sqlSessionFactory.openSession(true)获得一个可以自动提交的连接池对象

if&where&sql片段&foreach

<?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.tzt.dao.UserDao">
    <resultMap id="users" type="user">
        <id column="uid" property="id"/>
    </resultMap>
    <!--sql片段：把在该配置文件中经常写的sql语句，提取出来, 需要使用的地方可以直接引用-->
    <sql id="findAll">
        select * from user
    </sql>
    <select id="findByCondition" resultMap="users" parameterType="user">
        <!--ref: references: 关联-->
        <include refid="findAll"/>
        <!--where标签处理第一个and-->
        <where>
            <!--if标签判断条件参数-->
            <if test="username!=null">
                and username like "%"#{username}"%"
            </if>
            <if test="address!=null">
                and address = #{address}
            </if>
        </where>
    </select>
    <delete id="del" parameterType="int[]">
        DELETE FROM user WHERE
        <!--list,array-->
        <foreach collection="array" open="uid IN (" close=")" separator="," item="uid">
            #{uid}
        </foreach>
    </delete>
</mapper>

多表查询一对一

定义一个新的pojo

    //重新定义pojo,继承Account,将user里面的属性重新添加进来
    public class UserAccount extends Account{
        private Integer uid;
        private String username;
        private String address;
        private String password;
        private Date birthday;
    }

    <select id="findAll" resultType="UserAccount">
    	SELECT * FROM account a,USER u WHERE a.u_id=u.uid
    </select>

将pojo作为属性

    //将User作为属性封装到Account中
    public class Account {
        private Integer id;
        private String name;
        private Float money;
        private Integer u_id;
        private User user;
    }

第一种方式

    <resultMap id="accounts" type="account">
        <!--pojo与表相同的属性可写可省略-->
        <result property="user.id" column="uid"/>
        <result property="user.username" column="username"/>
        <result property="user.password" column="password"/>
        <result property="user.address" column="address"/>
        <result property="user.birthday" column="birthday"/>
    </resultMap>
    <select id="findAll2" resultMap="accounts">
        SELECT * FROM account a,USER u WHERE a.u_id=u.uid
    </select>

第二种方式

通过association标签映射user的属性： 只能映射一个对象,最为常用

    <resultMap id="accounts3" type="account">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="money" column="money"/>
        <result property="u_id" column="u_id"/>
        <association property="user" javaType="User">
            <id property="id" column="uid"/>
            <result property="username" column="username"/>
            <result property="password" column="password"/>
            <result property="address" column="address"/>
            <result property="birthday" column="birthday"/>
        </association>
    </resultMap>
    <select id="findAll3" resultMap="accounts3">
        SELECT * FROM account a,USER u WHERE a.u_id=u.uid
    </select>

多表查询一对多

将’多’封装到一个集合中,再将这个集合作为属性封装到’一’中

    public class User {
        private Integer id;
        private String username;
        private String address;
        private String password;
        private Date birthday;
        private List<Account> accountList;
    }

    <resultMap id="users" type="user">
        <id property="id" column="uid"/>
        <result property="username" column="username"/>
        <result property="password" column="password"/>
        <result property="address" column="address"/>
        <result property="birthday" column="birthday"/>
        <!--collection标签	accountList: 属性名
            ofType: 集合中包含的对象类型是account类型-->
        <collection property="accountList" ofType="account">
            <id property="id" column="id"/>
            <result property="name" column="name"/>
            <result property="money" column="money"/>
            <result property="u_id" column="u_id"/>
        </collection>
    </resultMap>
    <select id="findAll4" resultMap="users">
        SELECT * FROM account a,USER u WHERE a.u_id=u.uid
    </select>

多表查询多对多

中间表的创建

    create table user_role(
    	uid int ,
    	rid int ,
    	-- 联合主键：两列互为主键, 两列不能同时相同
    	primary key(uid ,rid),
    	foreign key(uid) REFERENCES user(uid),
    	foreign key(rid) REFERENCES role(id)
    )

与一对多一样,主pojo内添加一个集合并写入toString方法,运用两次左查询

SELECT u.*,r.* FROM USER u LEFT JOIN user_role ur ON u.uid = ur.uid LEFT JOIN role r ON ur.rid = r.id

延迟加载一对一

延迟加载:用到数据时才会加载,不用不加载,也称懒加载
优点:先单表查询,需要时再进行关联查询,可以提高数据库性能,因为单表查询比多表查询要快
缺点:由于用到时才会进行查询,在大批量数据查询时,等待时间变长,用户体验下降
本案例中,由于一个账户只能拥有一个用户,Account表作为主表

    <mapper namespace="com.tzt.dao.AccountDao">
        <resultMap id="accounts" type="account">
            <!--映射user的属性:推荐使用的
                property: 对应的属性
                javaType:属性对应的类型
                column：属性对应的列名: 将column对应的值传递给某个方法
                select: 需要对应的方法:mapperId(全限类名+方法名)
                fetchType: eager :立即加载
                           lazy:延迟加载-->
            <association property="user" javaType="User" column="u_id" select="com.tzt.dao.UserDao.findById" fetchType="lazy"/>
        </resultMap>
        <select id="findAll" resultMap="accounts">
            SELECT * FROM account
        </select>
    </mapper>

需要重新建造映射文件和对应的方法接口,相当于重新进行了一次映射

延迟加载一对多

一个用户拥有多个账户,User作为主表

    <mapper namespace="com.tzt.dao.UserDao">
    <resultMap id="users" type="User">
        <id column="uid" property="id"/>
        <!--映射accountList属性-->
        <collection property="accountList" ofType="Account" column="uid" select="com.tzt.dao.AccountDao.findByUid" fetchType="lazy"/>
    </resultMap>
    <select id="findAll" resultMap="users">
        SELECT * FROM user
    </select>
    </mapper>

延迟加载在核心配置文件中的设置

    <configuration>
        <properties resource="jdbc.properties"></properties>
        <!--配置mybatis框架-->
        <settings>
            <!--开启了全局延迟加载-->
            <!--如果需要关闭延迟加载： 某个关联对像配置fetchType = eager  -->
            <setting name="lazyLoadingEnabled" value="true"/>
            <!--4.1以下版本默认为ture,需要设置为false-->
            <setting name="aggressiveLazyLoading" value="false"></setting>
        </settings>
        <!--别名映射-->
        <typeAliases>
            <package name="com.tzt.domain"></package>
        </typeAliases>
        <environments default="development"></environments>
        <!--配置文件映射-->
        <mappers>
            <package name="com.tzt.dao"></package>
        </mappers>
    </configuration>

MyBatis缓存

一级缓存

一级缓存: 默认开启的：session级别的缓存, 只有当前session可以使用
在连续两次查询数据库时，第一个查询执行了sql语句，第二次查询没有执行sql语句
在执行增删改操作后会清空缓存
sqlSession.clearCache():可以清空缓存 [close()方法也可以]

二级缓存

二级缓存: 应用级别的(SqlSessionFactory级别的)
在核心配置文件中开启二级缓存

    <configuration>
        <properties resource="jdbc.properties"></properties>
        <settings>
            <!--开启延迟加载-->
            <setting name="lazyLoadingEnabled" value="true"/>
            <!--开启二级缓存-->
            <setting name="cacheEnabled" value="true"/>
        </settings>
        <!--别名映射-->
        <typeAliases>
            <package name="com.tzt.domain"></package>
        </typeAliases>
    </configuration>

在需要执行二级缓存的映射文件中添加二级缓存开关

    <mapper namespace="com.itheima.dao.AccountDao">
        <!--开启本配置文件的二级缓存-->
        <cache></cache>-------------------------------->配置级别开启,整个映射文件都开启了缓存
        <!--useCache true： 开启该方法的二级缓存-------- >方法级别的开启关闭,某个方法不需要时可以关闭
            useCache false：关闭该方法的二级缓存-->
        <select id="findAll" resultMap="accounts" useCache="true">
            select * from account
        </select>
    </mapper>

需要存储到二级缓存中的pojo对象必须序列化
需要持久化的对象都需要序列化public class Account implements Serializable {}
在两次session中可以获取到缓存
如果执行增删改操作后，提交 – 会清空该namespace的缓存
流程： 执行第一次查询-- sqlSession关闭后 – 会将数据存储到二级缓存中(Map:namespace.sql语句, value: 对象) [close()即提交缓存到二级缓存区]
执行第二次查询 – sqlSession可以从二级缓存中获取，(Map?namespace.sql语句, value: 对象)
拥有重大缺陷:关联映射改变的时候,检测不到变化,运行结果还是二级缓存里的内容