MyBatis初体验(二)

两种使用方式

原始Dao开发方式

Mapper.xml映射文件

<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映射文件

<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

<configuration>
    
    <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>
        
        <typeAlias type="com.itheima.domain.User" alias="user">typeAlias>
        
        <package name="com.itheima.domain">package>
    typeAliases>
    <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>
    
    <mappers>
        
        <mapper resource="com/tzt/mapper/UserMapper.xml"/>

        
        
        <mapper class="com.tzt.dao.UserDao">mapper>
        
        <mapper url="file:///F:\ideaworkspace\src\main\resources\com\itheima\mapper\UserMapper.xml">mapper>
        
        
        <package name="com.itheima.dao">package>
    mappers>
configuration>

映射文件Mapper.xml

parameterType

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

resultMap

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

    <resultMap id="userList" type="user">
        
        
        <id property="id" column="uid">id>
    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

<mapper namespace="com.tzt.dao.UserDao">
    <resultMap id="users" type="user">
        <id column="uid" property="id"/>
    resultMap>
    
    <sql id="findAll">
        select * from user
    sql>
    <select id="findByCondition" resultMap="users" parameterType="user">
        
        <include refid="findAll"/>
        
        <where>
            
            <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
        
        <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">
        
        <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 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">
            
            <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"/>
        
        <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>
        
        <settings>
            
            
            <setting name="lazyLoadingEnabled" value="true"/>
            
            <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>-------------------------------->配置级别开启,整个映射文件都开启了缓存
        
        <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: 对象)
拥有重大缺陷:关联映射改变的时候,检测不到变化,运行结果还是二级缓存里的内容