mybatis相关

最新推荐文章于 2023-03-10 17:42:32 发布

可爱的建城

最新推荐文章于 2023-03-10 17:42:32 发布

阅读量157

点赞数

分类专栏： ssm框架文章标签： mybatis

本文链接：https://blog.csdn.net/qq_38623340/article/details/104752560

版权

ssm框架专栏收录该内容

3 篇文章 0 订阅

订阅专栏

mybatis

1.mybatis环境搭建

在dao和domain包下分别创建UserDao接口和User类（以User为例）
在UserDao中定义一个List<User> findAll();方法

若采用注解的方式，则需要在方法上加@Select(select * from user)注解（括号内写具体的sql语句）
在resources目录下创建SqlMapConfig.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="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
          	<!--配置连接数据库的四大参数-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///zzx"/>
                <property name="username" value="root"/>
                <property name="password" value="123"/>
            </dataSource>
        </environment>
    </environments>
  
    <mappers>
        <!--配置UserDao配置文件的映射(包结构必须与dao接口的包结构一致)
				如果使用注解，则此处的resource属性需替换为class属性指定UserDao的全限定类名
				<mapper class="com.zzx.dao.UserDao"/>-->
        <mapper resource="com/zzx/dao/UserDao.xml"/>
    </mappers>
</configuration>

在resources目录下创建UserDao的配置文件UserDao.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必须是UserDao接口的全限定类名-->
<mapper namespace="com.zzx.dao.UserDao">
    <!--此处的id值为dao中定义的方法的名称，resultType为查询返回结果集的JavaBean类型-->
    <select id="findAll" resultType="com.zzx.domain.User">
        SELECT * FROM user
    </select>
</mapper>

测试代码

//读取配置文件
InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
//创建SqlSessionFactory工厂
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory build = builder.build(in);
//使用SqlSessionFactory生成sqlSession对象
SqlSession sqlSession = build.openSession();
//使用SqlSessionFactory创建Dao接口的代理对象
UserDao userDao = sqlSession.getMapper(UserDao.class);
//使用代理对象执行方法
List<User> users = userDao.findAll();
for (User user : users) {
    System.out.println(user);
}
//释放资源,非常重要！！！
sqlSession.close();
in.close();

1.1.也可以采用dao实现类的方式来搭建环境

1.1.1.USerDaoImpl

public class UserDaoImpl implements UserDao {
    private SqlSessionFactory factory;
    
    //定义构造方法规定创建对象时需要传递factory对象，将factory传递给成员变量factory
    public UserDaoImpl(SqlSessionFactory factory){
        this.factory = factory;
    }
    
    public List<User> findAll(){
        //使用工厂创建session对象
        SqlSession session = factory.openSession();
        //使用session执行查询所有方法
        //此处selectList()方法所需要的参数是原来UserDao.xml配置文件中的namespace值加上方法名
        List<User> users = session.selectList("com.zzx.dao.UserDao.findAll");
        session.close();
        //返回结果
        return users;
    }
}

1.1.2.功能实现

//读取配置文件
InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
//创建SqlSessionFactory工厂
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(in);
//使用SqlSessionFactory生成sqlSession对象
//SqlSession sqlSession = build.openSession();
//使用SqlSessionFactory创建Dao接口的代理对象，此处无需创建Dao的代理对象了，因为采用Dao实现类的方式来实现功能
//UserDao userDao = sqlSession.getMapper(UserDao.class);
//创建实现类对象时需传入工厂对象
UserDao userDao = new UserDaoImpl(factory);
//使用实现类对象执行方法
List<User> users = userDao.findAll();
for (User user : users) {
    System.out.println(user);
}
//释放资源
//sqlSession.close();
in.close();

2.mybatis的增删改查

2.1.增

在dao接口中新增方法void saveUser(User user);
在UserDao.xml中新增Insert配置

<insert id="saveUser" parameterType="com.zzx.domain.User">
    <!--新增用户时，由于id是数据库自动增长实现的，因此并没有向user对象中封装id信息，可以通过以下sql语句来查询新增用户的id值，其中：
	keyProperty是实体类（User）中的id名称
	keyColumn是对应数据库中的列名
	resultType是返回的结果集的类型
	order是指定在查询用户之前或者之后执行该查询id的语句-->
	<selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
		SELECT LAST_INSERT_ID();
	</selectKey>
    <!--此处sql语句中#{}中的内容必须与domian中User类中get方法名一致，无需与字段名一致-->
    INSERT INTO user(username,birthday,sex,address) values (#{username},#{birthday},#{sex},#{address})
</insert>

调用saveUser()方法

User user = new User();
user.setUsername("小张");
user.setBirthday(new Date());
user.setSex("帅哥");
user.setAddress("上园头村草");

//保存操作之前id值为null
System.out.println(user.getId());
//将user对象作为参数传递给saveUser()
userDao.saveUser(user);
//保存操作之后查询得到结果id值为52
System.out.println(user.getId());

2.2.删

在dao接口中新增方法void deleteUser(Integer id);
在UserDao.xml中新增delete配置

<!--此处的parameterType还可以使用Int，java.lang.Integer-->
<delete id="deleteUser" parameterType="Integer">
    <!--当方法只有一个参数时，此处#{}的内容其实是没有任何要求的，它仅仅表示一个占位符-->
	DELETE FROM user WHERE id=#{id}
</delete>

调用deleteUser()方法

userDao.deleteUser(51);

2.3.改

在dao接口中新增方法void updateUser(User user);
在UserDao.xml中新增update配置

<update id="updateUser" parameterType="com.zzx.domain.User">
        UPDATE user SET username=#{username},birthday=#{birthday},sex=#{sex},address=#{address} WHERE id=#{id}
</update>

调用updateUser()方法

User user = new User();
//由于sql语句中写的是根据id更新User信息，因此此处需要给User对象设置Id属性
user.setId(51);
user.setUsername("小张");
user.setBirthday(new Date());
user.setSex("帅哥");
user.setAddress("上园头村草");

userDao.updateUser(user);

2.4.查

2.4.1.根据id查询

在dao接口中新增方法User findById(Integer id);
在UserDao.xml中新增select配置

<!--此处需要设置参数的值parameterType和返回值的全限定类名resultType-->
<select id="findById" parameterType="Integer" resultType="com.zzx.domain.User">
	SELECT * FROM user WHERE id=#{id}
</select>

调用findById()方法

User user = userDao.findById(45);
System.out.println(user);

2.4.2.根据名字模糊查询

在dao接口中新增方法List<User> findByName(String name);
在UserDao.xml中新增select配置

<select id="findByName" parameterType="java.lang.String" resultType="com.zzx.domain.User">
    <!--此处的sql语句有两种写法，另一种写法则是在sql语句中直接添加%符号，而不需要在调用方法时候在关键字前后添加%，注意：此处的{}前是$而不是#！！！但是一般还是采用不加%的-->
    <!--SELECT * FROM user WHERE username LIKE '%${value}%'-->
	SELECT * FROM user WHERE username LIKE #{name}
</select>

调用findByName()方法

List<User> users = userDao.findByName("%王%");
for (User user : users) {
	System.out.println(user);
}

3.实体类的字段名称和数据库中的列名不一致时的解决方案

增删改操作：只需要将sql语句中#{}内的值改成与实体类中的字段一致
查询操作：由于实体类中字段名与数据库中列名不一致，因此数据无法全部封装，只有userName可以被封装进结果集，原因是在windows系统下，mysql数据库不区分大小写

实体类User.class

private Integer userId;
private String userName;
private Date userBirthday;
private String userSex;
private String userAddress;

3.1.两种解决查询操作的方案

在编写sql语句时加上别名，使其与实体类中的字段名称一致

此方法的执行效率较高，但是修改所有的查询语句，比较麻烦

<select id="findAll" resultType="com.zzx.domain.User">
	SELECT id as userId, username as userName, address as userAddress, sex as userSex, birthday as userBirthday FROM user
</select>

在UserDao.xml中**（mapper标签内）**新增一个查询结果的列名和实体类的属性名的对应关系

由于要多解析一段xml标签，所以此方法的效率会较第一种方法低，但是只需将select标签中的resultType属性修改为resultMap属性，比较方便

<resultMap id="userMap" type="com.zzx.domain.User">
    <!--主键字段的对应-->
    <id property="userId" column="id"></id>
    <!--非主键字段的对应-->
    <result property="userName" column="username"></result>
    <result property="userBirthday" column="birthday"></result>
    <result property="userSex" column="sex"></result>
    <result property="userAddress" column="address"></result>
</resultMap>
<!--将此处select标签内的resultType属性替换为resultMap属性，值为userMap，即与上面定义的resultMap的id一致-->
<!--resultType="com.zzx.domain.User"-->
<select id="findAll" resultMap="userMap">
	SELECT * FROM user
</select>

4.properties标签的使用

可以在dataSource标签外定义properties标签来设置连接数据库的四大参数，在property中引用即可

<?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>
    <properties>
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///zzx"/>
        <property name="username" value="root"/>
        <property name="password" value="123"/>
    </properties>
    
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <!--此处property的value用${}替换-->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/zzx/dao/UserDao.xml"/>
    </mappers>
</configuration>

引用外部配置文件，将jdbcConfig.properties文件放在resources根目录下

<?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>
    <properties resource="jdbcConfig.properties">
        <!--<property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///zzx"/>
        <property name="username" value="root"/>
        <property name="password" value="123"/>-->
    </properties>
    
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <!--此处property中${}内的值必须与配置文件中的键一致-->
                <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/zzx/dao/UserDao.xml"/>
    </mappers>
</configuration>

5.typeAliases标签和package标签的使用

<typeAliases>
	<!--typeAlias用于配置别名。type属性指定的是实体类全限定类名。alias属性指定别名，当指定了别名就不再区分大小写 
	<typeAlias type="com.zzx.domain.User" alias="user"></typeAlias>-->

    <!-- 用于指定要配置别名的包，当指定之后，该包下的实体类都会注册别名，并且类名就是别名，不再区分大小写-->
    <package name="com.zzx.domain"></package>
</typeAliases>

在SqlMapConfig.xml中添加该包扫描配置后，增删改查标签内的parameterType只需要写类名**（User）**即可

也可以在mappers标签内配置扫描dao接口的包，这样则无需再一个一个的配置dao接口了

<mappers>
    <package name="com.zzx.dao"/>
</mappers>

6.mybatis中的事务

6.1.什么是事务

事务中的多个操作，要么完全成功，要么完全失败！不可能存在成功一半的情况！

6.2.事务的四大特性ACID

原子性（Atomicity）：事务中所有操作是不可再分割的原子单位。事务中所有操作要么全部执行成功，要么全部执行失败。
一致性（Consistency）：事务执行后，数据库状态与其它业务规则保持一致。如转账业务，无论事务执行成功与否，参与转账的两个账号余额之和应该是不变的。
隔离性（Isolation）：隔离性是指在并发操作中，不同事务之间应该隔离开来，使每个并发中的事务不会相互干扰。
持久性（Durability）：一旦事务提交成功，事务中所有的数据操作都必须被持久化到数据库中，即使提交事务后，数据库马上崩溃，在数据库重启时，也必须能保证通过某种机制恢复数据。

6.3.不考虑隔离性会产生的3个问题

脏读（dirty read）：读到另一个事务的未提交更新数据，即读取到了脏数据；
不可重复读（unrepeatable read）：对同一记录的两次读取不一致，因为另一事务对该记录做了修改；
幻读（虚读）（phantom read）：对同一张表的两次查询不一致，因为另一事务插入了一条记录；

6.4.解决办法：四种隔离级别

SERIALIZABLE（串行化）
- 不会出现任何并发问题，因为它是对同一数据的访问是串行的，非并发访问的；
- 性能最差；
REPEATABLE READ（可重复读）（MySQL）
- 防止脏读和不可重复读，不能处理幻读问题；
- 性能比SERIALIZABLE好；
READ COMMITTED（读已提交数据）（Oracle）
- 防止脏读，没有处理不可重复读，也没有处理幻读；
- 性能比REPEATABLE READ好；
READ UNCOMMITTED（读未提交数据）
- 可能出现任何事务并发问题；
- 性能最好；

7.动态SQL语句

7.1.`if`标签

在Dao中新增方法：List<User> findUserByCondition(User user);

在UserDao.xml中新增select标签

<!--由于在SqlMapConfig.xml中配置了包扫描，因此此处的parameterType的值只需填写类名即可-->
<select id="findUserByCondition" resultMap="userMap" parameterType="user">
    SELECT * FROM user WHERE 1=1
    <if test="username != null">
        AND username=#{username}
    </if>
</select>

测试查询代码

User user = new User();
user.setUsername("小张");

List<User> users = userDao.findUserByCondition(user);
for (User u : users) {
	System.out.println(u);
}

7.2.`where`标签

当有多个条件时，一直使用if标签显然是很麻烦的，因此可以选择使用where标签

将select标签改造一下

<select id="findUserByCondition" resultMap="userMap" parameterType="user">
    SELECT * FROM user
    <where>
        <if test="username != null">
            AND username=#{username}
        </if>
        <if test="sex != null">
            AND sex=#{sex}
        </if>
    </where>
</select>

测试查询代码

User user = new User();
user.setUsername("小张");
user.setSex("帅哥");

List<User> users = userDao.findUserByCondition(user);
for (User u : users) {
	System.out.println(u);
}

7.3.`foreach`标签

新增一个queryVo类

public class QueryVo {
    private User user;
    private List<Integer> ids;

    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    public List<Integer> getIds() {
        return ids;
    }
    public void setIds(List<Integer> ids) {
        this.ids = ids;
    }
}

在UserDao.xml中编写sql语句

<select id="findUserInIds" resultMap="userMap" parameterType="queryVo">
    SELECT * FROM user
    <where>
        <!--注意：当if中为多条件时，并且关系应用and而不是&& -->
        <if test="ids != null and ids.size()>0">
            <foreach collection="ids" open="and id in (" close=")" item="id" separator=",">
                <!--此处#{}内的值应与foreach标签中的item值一致-->
                #{id}
            </foreach>
        </if>
    </where>
</select>

测试查询

QueryVo vo = new QueryVo();
List<Integer> list = new ArrayList<Integer>();
list.add(46);
list.add(48);
list.add(52);
list.add(53);
vo.setIds(list);
List<User> users = userDao.findUserInIds(vo);

for (User user : users) {
    System.out.println(user);
}

8.mybatis的多表查询

8.1.一对一查询

在Account类中添加User的映射

private User user;

public User getUser() {
    return user;
}

public void setUser(User user) {
    this.user = user;
}

在AccountDao接口中定义List<Account> findAll();方法

在AccountDao.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.zzx.dao.AccountDao">
    <!--定义封装account和user的resultMap-->
    <resultMap id="accountUserMap" type="account">
        <!--此处column使用aid的原因是sql语句中给该主键列设置了别名aid，此处的column值应与sql语句中一致-->
        <id property="id" column="aid"/>
        <result property="uid" column="uid"/>
        <result property="money" column="money"/>
        <!--一对一的关系映射，配置封装user的内容-->
        <!--此处应该给定封装的User的类型，在javaType中定义-->
        <association property="user" column="uid" javaType="user">
            <id property="id" column="id"/>
            <result property="username" column="username"/>
            <result property="birthday" column="birthday"/>
            <result property="sex" column="sex"/>
            <result property="address" column="address"/>
        </association>
    </resultMap>

    <select id="findAll" resultMap="accountUserMap">
        SELECT u.*,a.id as aid,a.uid,a.money FROM account a,user u WHERE u.id = a.uid;
    </select>

</mapper>

查询测试

List<Account> accounts = accountDao.findAll();
for (Account account : accounts) {
    System.out.println(account);
    System.out.println(account.getUser());
}

8.2.一对多查询

在User类中添加Account的映射

private List<Account> accounts;

public List<Account> getAccounts() {
    return accounts;
}

public void setAccounts(List<Account> accounts) {
    this.accounts = accounts;
}

改造UserDao中的List<User> findAll();方法

在UserDao.xml中修改配置

<resultMap id="userAccountMap" type="user">
    <id property="id" column="id"/>
    <result property="username" column="username"/>
    <result property="birthday" column="birthday"/>
    <result property="sex" column="sex"/>
    <result property="address" column="address"/>
    <!--ofType的含义是User类中accounts集合中的对象为account-->
    <collection property="accounts" ofType="account">
        <!--由于sql语句中使用了别名，所以此处account表中的id列名应为aid-->
        <id property="id" column="aid"/>
        <result property="uid" column="uid"/>
        <result property="money" column="money"/>
    </collection>
</resultMap>

<!--此处使用左外连接-->
<select id="findAll" resultMap="userAccountMap">
    SELECT * FROM user u LEFT OUTER JOIN account a ON u.id = a.uid
</select>

查询测试

List<User> users = userDao.findAll();
for (User user : users) {
    System.out.println(user);
    System.out.println(user.getAccounts());
}

8.3.多对多查询

创建角色表和中间表

- CREATE TABLE `role` (
    `ID` int(11) NOT NULL COMMENT '编号',
    `ROLE_NAME` varchar(30) default NULL COMMENT '角色名称',
    `ROLE_DESC` varchar(60) default NULL COMMENT '角色描述',
    PRIMARY KEY  (`ID`)
  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

  insert  into `role`(`ID`,`ROLE_NAME`,`ROLE_DESC`) values 
  (1,'院长','管理整个学院'),
  (2,'总裁','管理整个公司'),
  (3,'校长','管理整个学校');

#中间表
CREATE TABLE `user_role` (
  `UID` int(11) NOT NULL COMMENT '用户编号',
  `RID` int(11) NOT NULL COMMENT '角色编号',
  PRIMARY KEY  (`UID`,`RID`),
  KEY `FK_Reference_10` (`RID`),
  CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `role` (`ID`),
  CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert  into `user_role`(`UID`,`RID`) values (41,1),(45,1),(41,2);

//创建对应的实体类
package com.zzx.domain;

import java.util.List;

public class Role {
    private Integer roleId;
    private String roleName;
    private String roleDesc;

    //多对多的关系映射：一个角色可以赋予多个用户
    private List<User> users;

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

    public Integer getRoleId() {
        return roleId;
    }

    public void setRoleId(Integer roleId) {
        this.roleId = roleId;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public String getRoleDesc() {
        return roleDesc;
    }

    public void setRoleDesc(String roleDesc) {
        this.roleDesc = roleDesc;
    }

    @Override
    public String toString() {
        return "Role{" +
                "roleId=" + roleId +
                ", roleName='" + roleName + '\'' +
                ", roleDesc='" + roleDesc + '\'' +
                '}';
    }
}

在RoleDao.xml中配置

<resultMap id="roleMap" type="role">
    <!--此处id标签内的column的值与sql语句中对应-->
    <id property="roleId" column="rid"/>
    <result property="roleName" column="role_name"/>
    <result property="roleDesc" column="role_desc"/>
    <collection property="users" ofType="user">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="address" column="address"/>
    </collection>
</resultMap>

<select id="findAll" resultMap="roleMap">
    SELECT u.*,r.id AS rid,r.role_name,r.role_desc FROM role r
    LEFT OUTER JOIN user_role ur ON r.id = ur.rid
    LEFT OUTER JOIN user u ON u.id = ur.uid
</select>

查询测试

List<Role> roles = roleDao.findAll();
for (Role role : roles) {
    System.out.println(role);
    System.out.println(role.getUsers());
}

用户到角色的多对多就只是sql语句以及resultMap有少许变换，这里不再详细说明

9.mybatis的延迟加载

9.1.一对一的延迟加载

更改AccountDao.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.zzx.dao.AccountDao">
    <!--定义封装account和user的resultMap-->
    <resultMap id="accountUserMap" type="account">
        <!--此处column使用aid的原因是sql语句中给该主键列设置了别名aid，此处的column值应与sql语句中一致-->
        <id property="id" column="aid"/>
        <result property="uid" column="uid"/>
        <result property="money" column="money"/>
        <!--一对一的关系映射，配置封装user的内容-->
        <!--此处应该给定封装的User的类型，在javaType中定义-->
        <association property="user" column="uid" javaType="user" select="com.zzx.dao.UserDao.findById">
        </association>
    </resultMap>

    <select id="findAll" resultMap="accountUserMap">
        SELECT * FROM account
    </select>

</mapper>

在SqlMapConfig.xml文件中配置打开延迟加载

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

测试查询

List<Account> accounts = accountDao.findAll();
for (Account account : accounts) {
    System.out.println(account);
    System.out.println(account.getUsers());
}

9.2.一对多的延迟加载

…

10.mybatis中的缓存

10.1.什么是缓存

存在于内存中的临时数据

10.2.为什么使用缓存

减少和数据库的交互次数，提高执行效率

10.3.什么样的数据可以使用缓存

10.3.1.适用于缓存：

经常查询且不经常改变的
数据的正确与否对最终的结果影响不大的

10.3.2.不适用于缓存

经常改变的数据
数据的正确与否对最终结果的影响很大的
例如：商品的库存，银行的汇率，股市的牌价

10.4.mybatis中的一级缓存和二级缓存

10.4.1.一级缓存（一级缓存默认是开启的）：

它指的是Mybatis中SqlSession对象的缓存。

当我们执行查询之后，查询的结果会同时存入到SqlSession为我们提供一块区域中。

该区域的结构是一个Map。当我们再次查询同样的数据，mybatis会先去sqlsession中查询是否有，有的话直接拿出来用。

当SqlSession对象消失时，mybatis的一级缓存也就消失了。

也可以通过slqSession.clearCache()来清空一级缓存
当调用sqlSession的修改，添加，删除，commit(),close()等方法时，就会清空以及缓存

10.4.2.二级缓存：

它指的是Mybatis中SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。

二级缓存的使用步骤：

第一步：让Mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）

<settings>
	<setting name="cacheEnable" value="true"/>
</settings>

第二步：让当前的映射文件支持二级缓存（在IUserDao.xml中配置：新增cache标签即可）

<cache/>

第三步：让当前的操作支持二级缓存（在select标签中配置，新增useCache标签，值为true）

<select id="findById" parameterType="INT" resultType="user" useCache="true">
	select * from user where id =#{uid}
</select>

11.mybatis的注解开发

11.1.注解开发单表操作

SqlMapConfig.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>
    <!--引入外部配置文件-->
    <properties resource="jdbcConfig.properties"/>
    <!--配置别名-->
    <typeAliases>
        <package name="com.zzx.domain"/>
    </typeAliases>
    <!--配置环境-->
    <environments default="mysql">
        <environment id="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>
    </environments>
    <!--指定带有注解的dao接口所在位置-->
    <mappers>
        <package name="com.zzx.dao"/>
    </mappers>
</configuration>

UserDao接口以及方法上的注解

@Select("select * from user")
List<User> findAll();

查询测试

InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(in);
SqlSession sqlSession = build.openSession(true);
UserDao userDao = sqlSession.getMapper(UserDao.class);
List<User> users = userDao.findAll();
for (User user : users) {
    System.out.println(user);
}
sqlSession.close();
in.close();

11.2.mybatis注解建立实体类属性和数据库表中列的对应关系

当实体类的字段名称与表中列名不一致时，mybatis中提供了一个@Results注解

@Select("select * from user")
//Results有一个id属性，设置其值可以让其他查询方法来引用该Results
@Results(id = "userMap", value = {
    //此处没有像xml配置文件中ResultMap一样分别使用id和result标签将主键和其他列区分开，而是使用了一个id属性，当其值为true时，说明该列是主键。
    @Result(id = true, property = "userId", column = "id"),
    @Result(property = "userName", column = "username"),
    @Result(property = "userAddress", column = "address"),
    @Result(property = "userSex", column = "sex"),
    @Result(property = "userBirthday", column = "birthday")
})
List<User> findAll();

@Select("select * from user where id=#{id}")
//引用上面定义的Results
@ResultMap(value = {"userMap"})
User findById(Integer userId);

@Select("select * from user where username like #{username}")
@ResultMap(value = {"userMap"})
List<User> findUserByName(String username);

11.3.注解开发复杂多表查询

一对多

@Select("select * from account")
//Results有一个id属性，设置其值可以让其他查询方法来引用该Results
@Results(id = "accountMap", value = {
    @Result(id = true, property = "id", column = "id"),
    @Result(property = "uid", column = "uid"),
    @Result(property = "money", column = "money"),
    @Result(property = "user", column = "uid",
            //此处select属性的内容为调用上面的UserDao的findById()方法，fetchType为配置立即加载
           one = @One(select = "com.zzx.dao.UserDao.findById", fetchType = FetchType.EAGER)))
})
List<User> findAll();

多对多

只需将@Result注解内的one = @One属性改为many = @Many，并将其值改为对应的方法即可

可爱的建城

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
mybatis相关

mybatis1.mybatis环境搭建在dao和domain包下分别创建UserDao接口和User类*（以User为例）*在UserDao中定义一个**List<User> findAll();**方法若采用注解的方式，则需要在方法上加@Select(select * from user)注解**（括号内写具体的sql语句）**在resources目录下创建S...
复制链接

扫一扫