MyBatis
1. MyBatis 简介
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis 。2013年11月迁移到Github。
iBATIS一词来源于“internet”和“abatis”的组合,是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAOs)
MyBatis虽然改变了名字,但是实际的内核还是ibatis
MyBatis以高轻量级闻名于全球,提出以注入SQL的方式来管理持久化,让整个项目在数据库操作这块与SQL语言完全解耦,所以深受开发人员的喜爱
mybatis是一款高轻量级的基于ORM(对象关系映射)半自动化的持久层框架,它更加关注原生sql的编写,在实际开发过程中能够实现sql语句与业务代码的完全的解耦。它还支持强大的sql查询、存储过程、高级映射、缓存机制。还支持强大的基于OGNL动态sql的编写。
2. Maven MyBatis搭建
基础脚手架效果如图:
需要配置的几项内容:
(1).pom文件
(2).mybatis.xml文件
(3).pojo类
(4).数据库映射XML
(5).创建数据库操作对应的接口
(6).控制器
第一项,配置pom文件,需要加入两个maven包,一个是数据库连接驱动,一个是mybatis
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.31</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency>
第二项,添加mybatis.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>
<settings>
<!--当返回行的所有列都是空时,MyBatis默认返回null-->
<setting name="returnInstanceForEmptyRow" value="true"/>
<!--显示sql语句-->
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
<environments default="development">
<environment id="development">
<!--使用了 JDBC 的提交和回滚设置,它依赖于从数据源得到的连接来管理事务作用域-->
<transactionManager type="JDBC"/>
<!-- mybatis提供了3种数据源类型,分别是:POOLED,UNPOOLED,JNDI -->
<!-- POOLED 表示支持JDBC数据源连接池 -->
<!-- UNPOOLED 表示不支持数据源连接池 -->
<!-- JNDI 表示支持外部数据源连接池 -->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/gxa"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<mappers>
<!-- 映射文件方式1,一个一个的配置
<mapper resource="cn/thinknovo/pojo/UserMapper.xml"/>-->
<!-- 映射文件方式2,自动扫描包内的Mapper接口与配置文件 -->
<package name="cn/thinknovo/pojo"/>
</mappers>
</configuration>
第三项,pojo类,创建一个类名与数据库相同,属性名和数据库字段名相同的pojo对象。
第四项,数据库映射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一般定义为 包名+类名 -->
<mapper namespace="cn.thinknovo.pojo.UserMapper">
<select id="selectUser" resultType="cn.thinknovo.pojo.User">
select * from user;
</select>
<insert id="insertUser" parameterType="cn.thinknovo.pojo.User">
insert into user values (#{id},#{username},#{password});
</insert>
</mapper>
第五项,定义数据库操作接口,这里需要注意的是,mybatis以此接口为调用入口,通过此接口对应的方法来检查并对应mapper.xml文件中的增删改查
public interface UserMapper {
// 方法名、参数类型、返回类型要和mapper.xml文件中的id相同
List<User> selectUser();
void insertUser(User user);
}
第六项,创建控制器–测试
public class MybatisConsole {
public static void main(String[] args) {
try {
Reader reader = Resources.getResourceAsReader("mybatis.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
SqlSession session = sqlSessionFactory.openSession();
UserMapper userMapper = session.getMapper(UserMapper.class);
List<User> userList = userMapper.selectUser();
System.out.println(userList);
session.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
至此,基础脚手架搭建完成
3. Mapper.xml文件的注册和自动扫描
在mybatis.xml文件中,可以直接使用package的方式来完成自动扫描,这样以后就不需要一个个的添加mapper.xml文件了
<mappers>
<!-- 映射文件方式1,一个一个的配置
<mapper resource="cn/thinknovo/pojo/UserMapper.xml"/>-->
<!-- 映射文件方式2,自动扫描包内的Mapper接口与配置文件 -->
<package name="cn/thinknovo/pojo"/>
</mappers>
4.解决后台提示找不到对应xml文件
Idea默认找不到对应的xml配置路径,在pom文件的build标签中,加入resource标签如下代码:
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
</resource>
</resources>
5.两种处理操作数据库的方式
(1).通过session得到对应的Mapper接口对象,然后由此对象调用对应的操作方法,例如:
Reader reader = Resources.getResourceAsReader("mybatis.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
SqlSession session = sqlSessionFactory.openSession();
UserMapper userMapper = session.getMapper(UserMapper.class);
List<User> userList = userMapper.selectUser();
System.out.println(userList);
(2).通过session直接调用接口中对应的操作方法
// 第一个参数对应接口中的方法名
session.selectList("selectUser");
(PS:注意在这里接口文件和Mapper.xml文件是必须的,缺一不可,可以通过删除对应的文件来测试执行结果。)
6.关闭自动提交事务
这里注意,只有执行增、删、改的时候,才需要提交事务,查询是不需要事务的,在操作完对应的增删改之后,执行session.commit();
PS:注意,mybatis默认事务就关闭了自动提交,可以通过接口查看
7.Xml配置方式的增删改查
首先配置mapper.xml文件
<!-- namespace一般定义为 包名+文件名 -->
<mapper namespace="cn.thinknovo.pojo.UserMapper">
<select id="selectUser" resultType="cn.thinknovo.pojo.User">
select * from user;
</select>
<insert id="insertUser" parameterType="cn.thinknovo.pojo.User">
insert into user values (#{id},#{username},#{password});
</insert>
<update id="updateUser" parameterType="cn.thinknovo.pojo.User">
update user set username=#{username},password=#{password} where id=#{id};
</update>
<delete id="deleteUser" parameterType="java.lang.String">
delete from user where id=#{id};
</delete>
</mapper>
然后在修改接口代码
public interface UserMapper {
// 方法名、参数类型、返回类型要和mapper.xml文件中的id相同
List<User> selectUser();
void insertUser(User user);
void updateUser(User user);
void deleteUser(String id);
}
在控制器中调用接口中指定的四个方法,就可以完成基本的增删改查
在控制器中调用接口中指定的四个方法,就可以完成基本的增删改查
8.多参数传递
在项目中,多参数传递更多的是基于pojo对象,或者map结构传递,但是也可能有需要多个形式参数传递,比如这样:
UserMapper.insertUserByPassword("think12345","54321");
这种情况,配置文件需要做对应的处理,改成下面的样子:
<insert id="insertUserByPassword" parameterType="java.lang.String">
insert into user values(null,#{param1},#{param2});
</insert>
param1代表获取第一个形式参数,依次类推
param1代表获取第一个形式参数,依次类推
也可以这样:
<insert id="insertUserByPassword" parameterType="java.lang.String">
insert into user values(null,#{arg0},#{arg1});
</insert>
arg0代表获取第一个形式参数,依次类推
arg0代表获取第一个形式参数,依次类推
如果有更多的这样的形式参数,就递增数字,比如第三个就是parma3或者arg2,在动态配置sql的时候,根据需要可以任意调换顺序,比如可以换成下面的效果:
<insert id="insertUserByPassword" parameterType="java.lang.String">
insert into user values(null,#{arg1},#{arg0});
</insert>
arg0还是代表第一个参数,arg1还是代表第二个参数,不受影响。
arg0还是代表第一个参数,arg1还是代表第二个参数,不受影响。
还可以这样写:
在接口中声明方法
/**
* mybatis 把参数转换为 map 了,其中@Param("key") 参数内
容就是 map 的 value
* @param name
* @param pwd
* @return
*/
List<User> selByNamePwd(@Param("name") String
userName,@Param("pwd") String userPwd);
在 mapper.xml 中添加
#{} 里面写@Param(“内容”)参数中内容
<!-- 当多参数时,不需要写 parameterType -->
<select id=" selByNamePwd" resultType="User" >
select * from User where name=#{name} and pwd=#{pwd}
</select>
9.Java中的Map结构传递
如果在项目中需要多参数传递,更建议大家使用java.util.map的结构传递,这也是大部分项目使用的方式,mybatis会根据key来对应获取value值,设置的传递类型还是parameterType,比如这样:
<insert id="insertUserByUserAndPassword" parameterType="map">
insert into user values(null,#{username},#{password});
</insert>
10.Map结构传递
如果要定义为map结构传递,需要在mybatis.xml中定义map的结构方式,比如这样:
<parameterMap id="userMap" type="cn.thinknovo.pojos.User">
<parameter property="username" javaType="java.lang.String"/>
<parameter property="password" javaType="java.lang.String"/>
</parameterMap>
这里的id就是map引入的名字,我们在传递参数类型设定为map以后就可以使用,比如:
<insert id="insertUserByUserAndPassword2" parameterMap="userMap" >
insert into user values(null,#{username},#{password});
</insert>
11.注解的使用
删除mapper.xml文件,然后在接口文件中通过注解的方式添加sql语句
public interface UserMapper {
// 方法名、参数类型、返回类型要和mapper.xml文件中的id相同
@Select("select * from user")
List<User> selectUser();
@Insert("insert into user values (#{id},#{username},#{password})")
void insertUser(User user);
@Update("update user set username=#{username},password=#{password} where id=#{id}")
void updateUser(User user);
@Delete("delete from user where id=#{id}")
void deleteUser(String id);
}
注意,我们现在可以删除mybatis.xml中的mapper标签,我们也可以在mybatis.xml文件中添加的mapper标签,不再需要resource属性,而是class属性,如下:
<!-- 在配置文件中 关联包下的 接口类-->
<mappers>
<mapper class="c.thinknovo.mybatis3.UserMapper"/>
</mappers>
12.动态SQL的if使用 – 非常重要
根据不同的条件执行不同的结果
<select id="selectUser" resultType="cn.thinknovo.pojo.User" parameterType="cn.thinknovo.pojo.User">
select * from user
<if test="username != null">
where username=#{username}
</if>
</select>
在配置文件中添加动态的if语句,如果传递过来的user对象中,username不等于null,那么追加条件查询
13.动态SQL的where使用
如果我们有多个条件需要添加,但是有可能一个条件都不满足,那么这时候使用上面的方式就会出现问题,所以我们还需要在if外部添加一个where标签
<select id="selectUser" resultType="cn.thinknovo.pojo.User" parameterType="cn.thinknovo.pojo.User">
select * from user
<where>
<if test="username != null">
username=#{username}
</if>
<if test="password != null">
and password=#{password}
</if>
</where>
</select>
可以看到,where包含了两个if,而第一个if中没有and,where标签会自动检查状态,如果标签返回的第一个匹配内容是以 and或or 开头的,则会自动删除and或者or ,然后再追加where
14.动态SQL的choose when使用
<select id="selectUser" resultType="cn.thinknovo.pojo.User" parameterType="cn.thinknovo.pojo.User">
select * from user where password='888888'
<where>
<choose>
<when test="username != null">
AND username=#{username}
</when>
<when test="password != null">
AND password=#{password}
</when>
<otherwise>
AND id=#{id}
</otherwise>
</choose>
<where>
</select>
Choose when 类似于java中的switch case,任中只会走一个,一般是在有一个条件固定的情况下,需要额外不确定的条件时,使用choose的方式
15.逆向工程mybatis-generator-maven-plugin
(1)首先修改pom文件为下面的内容,需要注意configurationFile标签是对应mybatis-generator的路径和文件名,修改为自己想要的,其余不做修改:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.thinknovo</groupId>
<artifactId>mybatis002</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<name>mybatis002 Maven Webapp</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency>
<dependency>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-core</artifactId>
<version>1.3.6</version>
</dependency>
</dependencies>
<build>
<finalName>mybatis002</finalName>
<pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
<plugins>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.0.0</version>
</plugin>
<!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.20.1</version>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>3.2.0</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
<plugin>
<!--Mybatis-generator插件,用于自动生成Mapper和POJO-->
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.6</version>
<configuration>
<!--配置文件的位置-->
<configurationFile>src\main\resources\mybatis-generator-config.xml</configurationFile>
<verbose>true</verbose>
<overwrite>true</overwrite>
</configuration>
<executions>
<execution>
<id>Generate MyBatis Artifacts</id>
<goals>
<goal>generate</goal>
</goals>
</execution>
</executions>
<dependencies>
<dependency>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-core</artifactId>
<version>1.3.6</version>
</dependency>
</dependencies>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
(2)接着添加mybatis-generator-config.xml文件,注意修改
(1)classPathEntry为自己的数据库连接池jar包物理路径
(2)jdbcConnection为自己的数据库连接参数
(3)javaModelGenerator为实体类生成的位置 修改targetPackage和targetProject
(4)sqlMapGenerator为*Mapper.xml 文件的位置 修改targetPackage和targetProject
(5)javaClientGenerator为Mapper 接口文件的位置 修改targetPackage和targetProject
(6)table为表对应内容,多表就配置多个,tableName表名 domainObjectName类名
完整配置如下:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE generatorConfiguration PUBLIC
"-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" >
<generatorConfiguration>
<!-- 本地数据库驱动程序jar包的全路径 -->
<classPathEntry location="C:\Users\Administrator\.m2\repository\mysql\mysql-connector-java\5.1.46\mysql-connector-java-5.1.46.jar"/>
<!-- 指定mybatis版本 -->
<context id="context" targetRuntime="MyBatis3">
<commentGenerator>
<property name="suppressAllComments" value="false"/>
<property name="suppressDate" value="true"/>
</commentGenerator>
<!-- 数据库的相关配置 -->
<jdbcConnection driverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/hiber"
userId="root"
password="thinknovo"/>
<!--指定生成的类型为java类型,避免数据库中number等类型字段 -->
<javaTypeResolver>
<property name="forceBigDecimals" value="false"/>
</javaTypeResolver>
<!-- 实体类生成的位置 修改targetPackage和targetProject-->
<javaModelGenerator targetPackage="cn.thinknovo.test" targetProject="src/main/java">
<property name="enableSubPackages" value="false"/>
<property name="trimStrings" value="true"/>
</javaModelGenerator>
<!-- *Mapper.xml 文件的位置 修改targetPackage和targetProject-->
<sqlMapGenerator targetPackage="cn.thinknovo.test" targetProject="src/main/java">
<property name="enableSubPackages" value="false"/>
</sqlMapGenerator>
<!-- Mapper 接口文件的位置 修改targetPackage和targetProject-->
<javaClientGenerator targetPackage="cn.thinknovo.test" targetProject="src/main/java"
type="XMLMAPPER">
<property name="enableSubPackages" value="false"/>
</javaClientGenerator>
<!-- 相关表的配置 多表就配置多个 tableName表名 domainObjectName类名 -->
<table tableName="user" domainObjectName="User" enableCountByExample="false"
enableDeleteByExample="false" enableSelectByExample="false"
enableUpdateByExample="false"/>
</context>
</generatorConfiguration>
(3)接着在idea右上角,点击edit
(4)开始配置mybatis-generator-maven-plugin运行
(5)输入运行命令mybatis-generator:generate -e
(6)点击保存,现在可以看到一个运行方式了,点击运行就可以自动得到内容了
(7)运行生成对应的文件
16.一对一映射
类似于hibernate中的创建办法,模拟一个人员对应一个学号,创建两个pojo实体类,下面代码省略了set、get方法
(1)第一个类是Iren人员类
public class Iren {
private long id;
private String renyuanname;
private long xuehaoid;
private Ixuehao ixuehao; // 添加一个学号类的对象
(2)第二个类是Ixuehao学号类
public class Ixuehao {
private long id;
private String xuehao;
(3)创建一个Irenmapper.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一般定义为 包名+文件名 -->
<mapper namespace="cn.thinknovo.mybatis.pojo.IrenMapper">
<select id="selectIren" resultMap="getOneToOneMap">
select t1.id,t1.renyuanname,t1.xuehaoid,t2.id,t2.xuehao
from iren t1,ixuehao t2
where t1.xuehaoid = t2.id;
</select>
<resultMap id="getOneToOneMap" type="cn.thinknovo.mybatis.pojo.Iren">
<id property="id" column="id"/>
<result property="renyuanname" column="renyuanname"/>
<result property="xuehaoid" column="xuehaoid"/>
<association property="ixuehao" javaType="cn.thinknovo.mybatis.pojo.Ixuehao">
<id property="id" column="id"/>
<result property="xuehao" column="xuehao"/>
</association>
</resultMap>
</mapper>
PS:这里使用到了resultMap标签,此标签中创建一对一的映射关系,在其中的id标签代表主键,result标签代表普通字段,association标签代表映射关系类
PS:这里使用到了resultMap标签,此标签中创建一对一的映射关系,在其中的id标签代表主键,result标签代表普通字段,association标签代表映射关系类
(4)创建一个Irenmapper接口
public interface IrenMapper {
List<Iren> selectIren();
}
(5)创建一个Console测试
public static void main(String[] args) {
try {
Reader reader = Resources.getResourceAsReader("mybatis.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
SqlSession session = sqlSessionFactory.openSession(false);
IrenMapper irenMapper = session.getMapper(IrenMapper.class);
List<Iren> list = irenMapper.selectIren();
System.out.println(list.size());
for(Iren iren : list) {
System.out.println(iren.getRenyuanname());
System.out.println(iren.getIxuehao().getXuehao());
}
session.close();
} catch (IOException e) {
e.printStackTrace();
}
}
(6)反向一对一处理
在Ixuehao类中创建Iren的对象,然后创建对应的Ixuehao的mapper接口和xml文件,在配置resultMap时,把前面配置的两个表的参数互换,就可以实现反向一对一。
<select id="selectIxuehao" resultMap="getOneToOneMap">
select t1.id,t1.renyuanname,t1.xuehaoid,t2.id,t2.xuehao
from iren t1,ixuehao t2
where t1.xuehaoid = t2.id;
</select>
<resultMap id="getOneToOneMap" type="cn.thinknovo.mybatis.pojo.Ixuehao">
<id property="id" column="id"/>
<result property="xuehao" column="xuehao"/>
<association property="iren" javaType="cn.thinknovo.mybatis.pojo.Iren">
<id property="id" column="id"/>
<result property="renyuanname" column="renyuanname"/>
<result property="xuehaoid" column="xuehaoid"/>
</association>
</resultMap>
17.一对多映射
基于班级和学生的关系建立映射,set、get方法省略
(1)第一个类是Iclass班级类
public class Iclass {
private long id;
private String cname;
private List<Istudent> list; // 这个班级中所有的学生
(2)第二个类是Istudent学生类
public class Istudent {
private long id;
private String sname;
private long cid;
(3)创建IclassMapper.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一般定义为 包名+文件名 -->
<mapper namespace="cn.thinknovo.mybatis.pojo.IclassMapper">
<select id="selectIclass" resultMap="getOneToManyMap">
select t1.id,t1.cname,t2.id id2,t2.sname,t2.cid
from iclass t1,istudent t2
where t1.id = t2.cid and t1.id=4;
</select>
<resultMap id="getOneToManyMap" type="cn.thinknovo.mybatis.pojo.Iclass">
<id property="id" column="id"/>
<result property="cname" column="cname"/>
<collection property="list" ofType="cn.thinknovo.mybatis.pojo.Istudent">
<id property="id" column="id2"/>
<result property="sname" column="sname"/>
<result property="cid" column="cid"/>
</collection>
</resultMap>
</mapper>
PS:这里注意的是,一对多使用的collection标签,并且mybatis自身bug,导致,当两张表的主键同名时,list中只有一个对象,解决这个问题的办法是把其中一个主键id改一个别名
PS:这里注意的是,一对多使用的collection标签,并且mybatis自身bug,导致,当两张表的主键同名时,list中只有一个对象,解决这个问题的办法是把其中一个主键id改一个别名
(4)创建一个Iclassmapper接口
public interface IclassMapper {
Iclass selectIclass();
}
(5)创建一个Console测试
public static void main(String[] args) {
try {
Reader reader = Resources.getResourceAsReader("mybatis.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
SqlSession session = sqlSessionFactory.openSession(false);
IclassMapper iclassMapper = session.getMapper(IclassMapper.class);
Iclass iclass = iclassMapper.selectIclass();
System.out.println(iclass.getCname());
System.out.println(iclass.getList());
for(Istudent istudent : iclass.getList()) {
System.out.println(istudent.getSname());
}
session.close();
} catch (IOException e) {
e.printStackTrace();
}
}
(6)反向多对一处理
在mybatis里面其实没有多对一的说法,多对一只能看做是一对一,所以我们需要在Istudent中增加Iclass对象:
public class Istudent {
private long id;
private String sname;
private long cid;
private Iclass iclass; // 增加班级对象
创建一个IstudentMapper.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一般定义为 包名+文件名 -->
<mapper namespace="cn.thinknovo.mybatis.pojo.IstudentMapper">
<select id="selectIstudent" resultMap="getOneToOneMap">
select t1.id,t1.cname,t2.id id2,t2.sname,t2.cid
from iclass t1,istudent t2
where t1.id = t2.cid and t2.id=2;
</select>
<resultMap id="getOneToOneMap" type="cn.thinknovo.mybatis.pojo.Istudent">
<id property="id" column="id2"/>
<result property="sname" column="sname"/>
<result property="cid" column="cid"/>
<association property="iclass" javaType="cn.thinknovo.mybatis.pojo.Iclass">
<id property="id" column="id"/>
<result property="cname" column="cname"/>
</association>
</resultMap>
</mapper>
PS:这里使用到的是一对一的处理法则,所以使用的一对一的标签association
PS:这里使用到的是一对一的处理法则,所以使用的一对一的标签association
然后创建IstudentMapper接口,编写测试类完成,这里省略…
18.多对多映射
还是基于订购商品操作,一个用户可以对应多个商品,一个商品可以对应多个订单,其实在mybatis实现多对多映射操作,类似于一对多映射,只是SQL编写的相对复杂一些,因为涉及到了中间表。
(1)第一个类是Ishangpin商品的类
public class Ishangpin {
private long id;
private String shangpinname;
private List<Igoumai> list; // list代表多个购买者
(2)第二个类是Igoumai购买者的类
public class Igoumai {
private long id;
private String goumainame;
(3)创建IshangpinMapper.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一般定义为 包名+文件名 -->
<mapper namespace="cn.thinknovo.mybatis.pojo.IshangpinMapper">
<select id="selectIshangpin" resultMap="getManyToManyMap">
select
t1.shangpinid,
t1.goumaiid,
t2.id,
t2.goumainame,
t3.id id2,
t3.shangpinname
from
idingdan t1,
igoumai t2,
ishangpin t3
where t1.goumaiid=t2.id and t1.shangpinid=t3.id and t1.shangpinid=6;
</select>
<resultMap id="getManyToManyMap" type="cn.thinknovo.mybatis.pojo.Ishangpin">
<id property="id" column="id2"/>
<result property="shangpinname" column="shangpinname"/>
<collection property="list" ofType="cn.thinknovo.mybatis.pojo.Igoumai">
<id property="id" column="id"/>
<result property="goumainame" column="goumainame"/>
</collection>
</resultMap>
</mapper>
PS:这个配置文件中有多处需要注意的地方,1.查看SQL的编写,三表关联查询;2.resultMap中涉及的还是collection标签;3.两张表的id主键的名字不能相同,必须保证其中一个是别名
PS:这个配置文件中有多处需要注意的地方,1.查看SQL的编写,三表关联查询;2.resultMap中涉及的还是collection标签;3.两张表的id主键的名字不能相同,必须保证其中一个是别名
(4)创建一个IshangpinMapper接口
public interface IshangpinMapper {
List<Ishangpin> selectIshangpin();
}
(5)创建一个Console测试
IshangpinMapper ishangpinMapper = session.getMapper(IshangpinMapper.class);
List<Ishangpin> list = ishangpinMapper.selectIshangpin();
System.out.println(list);
System.out.println(list.get(0).getShangpinname());
System.out.println(list.get(0).getList());
System.out.println(list.get(0).getList().get(0).getGoumainame());
(6)反向多对多处理
原理和上述一致,只需要在购买者中的增加商品的list,并且配置购买者的mapper接口和XML文件即可。
19.缓存
一级缓存SqlSession
- 应用程序和数据库交互的过程是一个相对比较耗时的过程
- 缓存存在的意义:让应用程序减少对数据库的访问,提升程序运行效率
- MyBatis 中默认 SqlSession 缓存开启
3.1 同一个 SqlSession 对象调用同一个时,只有第一次访问数据库,第一次之后把查询结果缓存到SqlSession缓存区(内存)中
3.2 缓存的是 statement 对象.(简单记忆必须是用一个是用一个),在 myabtis 时一个对应一个 statement 对象
3.3 有效范围必须是同一个 SqlSession 对象
缓存流程:
步骤一: 先去缓存区中找是否存在 statement
步骤二:返回结果
步骤三:如果没有缓存 statement 对象,去数据库获取数据
步骤四:数据库返回查询结果
步骤五:把查询结果放到对应的缓存区中
二级缓存SqlSessionFactory 缓存
有效范围:同一个 factory 内哪个 SqlSession 都可以获取
什么时候使用二级缓存:当数据频繁被使用,很少被修改
使用二级缓存步骤:
步骤一:在 mapper.xml 中添加
步骤二:如果不写 readOnly=”true”需要把实体类序列化
<cache readOnly=” true”></ cache >
步骤三:当 SqlSession 对象 close()时或 commit()时会把 SqlSession 缓存的数据刷(flush)到 SqlSessionFactory 缓存区中
ngpin();
System.out.println(list);
System.out.println(list.get(0).getShangpinname());
System.out.println(list.get(0).getList());
System.out.println(list.get(0).getList().get(0).getGoumainame());
(6)反向多对多处理
原理和上述一致,只需要在购买者中的增加商品的list,并且配置购买者的mapper接口和XML文件即可。
## 缓存
### 一级缓存SqlSession
1. 应用程序和数据库交互的过程是一个相对比较耗时的过程
2. 缓存存在的意义:让应用程序减少对数据库的访问,提升程序运行效率
3. MyBatis 中默认 SqlSession 缓存开启
3.1 同一个 SqlSession 对象调用同一个<select>时,只有第一次访问数据库,第一次之后把查询结果缓存到SqlSession缓存区(内存)中
3.2 缓存的是 statement 对象.(简单记忆必须是用一个是用一个<select>),在 myabtis 时一个<select>对应一个 statement 对象
3.3 有效范围必须是同一个 SqlSession 对象
缓存流程:
步骤一: 先去缓存区中找是否存在 statement
步骤二:返回结果
步骤三:如果没有缓存 statement 对象,去数据库获取数据
步骤四:数据库返回查询结果
步骤五:把查询结果放到对应的缓存区中
### 二级缓存SqlSessionFactory 缓存
有效范围:同一个 factory 内哪个 SqlSession 都可以获取
什么时候使用二级缓存:当数据频繁被使用,很少被修改
使用二级缓存步骤:
步骤一:在 mapper.xml 中添加
步骤二:如果不写 readOnly=”true”需要把实体类序列化
<cache readOnly=” true”></ cache >
步骤三:当 SqlSession 对象 close()时或 commit()时会把 SqlSession 缓存的数据刷(flush)到 SqlSessionFactory 缓存区中