MyBatis学习笔记
MyBatis
ORMapping：Object Relationship Mapping 对象关系映射java
对象指面向对象mysql
关系指关系型数据库sql
Java到MySQL的映射，开发者能够以面向对象的思想来管理数据库数据库
如何使用
- 新建Maven工程，pom.xml
<dependencies>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.11</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.6</version>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
</resource>
</resources>
</build>
- 新建数据表
use mybatis; create table t_account( id int primary key auto_increment, username varchar(11), password varchar(11), age int )
- 新建数据表对应的实体类Account
package com.janeroad.entity;
import lombok.Data;
[@Data](https://my.oschina.net/difrik)
public class Account {
private long id;
private String username;
private String password;
private int age;
}
- 建立MyBatis的配置文件config.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>
<!--配置MyBatis运行环境 -->
<environments default="development">
<environment id="development">
<!-- 配置JDBC事务管理 -->
<transactionManager type="JDBC"></transactionManager>
<!-- POOLED配置JDBC数据源链接池 -->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver">
</property>
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis?
useUnicode=true&characterEncoding=UTF-8">
</property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</dataSource>
</environment>
</environments>
</configuration>
使用原生接口apache
一、MyBatis框架须要开发者自定义SQL语句，写在Mapper.xml文件中，实际开发中，会为每一个实体类建立对应的Mapper.xml，定义管理该对象数据的SQLapi
<?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.janeroad.mapper.AccoutMapper">
<insert id="save" parameterType="com.janeroad.entity.Account">
insert into t_account(username,password,age) values(#{username},# {password},#{age})
</insert>
</mapper>
-
namespace一般设置为文件所在包+文件名的形式缓存
-
insert标签表示执行添加操做session
-
select标签表示执行查询操做mybatis
-
update标签表示执行更新操做app
-
delete标签表示执行删除操做
-
id是实际调用MyBatis方法时须要用到的参数
-
parameterType是调用对应方法时参数的数据类型
二、全局配置文件config.xml中加入 注册AccountMapper.xml
<!--注册AccountMapper.xml -->
<mappers>
<mapper resource="com/southwind/mapper/AccountMapper.xml"></mapper>
</mappers>
三、调用MyBatis的原生接口执行添加操做
public class Test {
public static void main(String[] args) {
//加在MyBatis配置文件
InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("config.xml");
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
String statement = "com.janeroad.mapper.AccoutMapper.save";
Account account = new Account(1L,"张三","123123",22);
sqlSession.insert(statement,account);
sqlSession.commit();
}
}
经过Mapper代理实现自定义接口
- 自定义接口，定义相关业务方法
- 编写与方法相对应的Mapper.xml
一、自定义接口
package com.janeroad.repository;
import com.janeroad.entity.Account;
import java.util.List;
public interface AccountRepository {
public int save(Account account);
public int update(Account account);
public int deleteById(long id);
public List<Account> findAll();
public Account findById(long id);
public Account findByName(String name);
public Account findById2(Long id);
public Account findByNameAndAge(String name,int age);
public int count();
public Integer count2();
public String findNameByID(long id);
}
二、建立接口对应的Mapper.xml，定义接口方法对应的SQL语句
statement标签可根据SQL执行的业务选择insert、delete、update、select
MyBatis框架会根据规则自动建立接口实现类的代理对象
规则：
- Mapper.xml中namespace为接口的全类名
- Mapper.xml中statement的id为接口中对应的方法名
- Mapper.xml中statement的parameterType和接口中对应方法的参数类型一致
- Mapper.xml中statement的和接口中对应方法的返回值类型一致
<?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.janeroad.repository.AccountRepository">
<insert id="save" parameterType="com.janeroad.entity.Account">
insert into t_account(username,password,age) values(#{username},# {password},#{age})
</insert>
<update id="update" parameterType="com.janeroad.entity.Account">
update t_account set username = #{username},password = #{password},
age = #{age} where id = #{id}
</update>
<delete id="deleteById" parameterType="long">
delete from t_account where id = #{id}
</delete>
<select id="findAll" resultType="com.janeroad.entity.Account">
select * from t_account
</select>
<select id="findById" parameterType="long" resultType="com.janeroad.entity.Account">
select * from t_account where id = #{id}
</select>
</mapper>
三、在config.xml中注册AccountRepository.xml
<!--注册AccountMapper.xml -->
<mappers>
<mapper resource="com/janeroad/mapper/AccountMapper.xml"></mapper>
<mapper resource="com/janeroad/repository/AccountRepository.xml"></mapper>
</mappers>
四、调用接口的代理对象完成相关的业务操做
package com.janeroad.test;
import com.janeroad.repository.AccountRepository;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.InputStream;
public class Test2 {
public static void main(String[] args) {
InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("config.xml");
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
//获取实现接口的代理对象
AccountRepository accountRepository = sqlSession.getMapper(AccountRepository.class);
//添加对象（增）
// Account account = new Account(2,"李四","123123",23);
// accountRepository.save(account)
// sqlSession.commit();
//查询所有对象（查）
// List<Account> list = accountRepository.findAll();
// for (Account account:list){
// System.out.println(account);
// }
// sqlSession.close();
//经过id查询对象
// Account account = accountRepository.findById(4L);
// System.out.println(account);
// sqlSession.close();
//修改对象（改）
// Account account = accountRepository.findById(4L);
// account.setUsername("小明");
// account.setPassword("000");
// account.setAge(18);
// int result = accountRepository.update(account);
// sqlSession.commit();
// System.out.println(result);
// sqlSession.close();
//经过ID删除对象（删）
int result = accountRepository.deleteById(4L);
System.out.println(result);
sqlSession.commit();
sqlSession.close();//关闭资源
}
}
Mapper.xml
- statement标签：select、update、insert分别对应查询、修改、删除、添加操做
- parameterType：参数数据类型
一、基本数据类型，经过id查询Account
<select id="findById" parameterType="long" resultType="com.janeroad.entity.Account">
select * from t_account where id = #{id}
</select>
二、String类型，经过name查询Account
<select id="findByName" parameterType="java.lang.String" resultType="com.janeroad.entity.Account">
select * from t_account where username = #{username}
</select>
三、包装类，经过id查询Account
<select id="findById2" parameterType="java.lang.Long" resultType="com.janeroad.entity.Account">
select * from t_account where id = #{id}
</select>
四、多个参数，经过name和age查询Account
<select id="findByNameAndAge" resultType="com.janeroad.entity.Account">
select * from t_account where username = #{arg0} and age = #{arg1}
</select>
五、Java Bean
<update id="update" parameterType="com.janeroad.entity.Account">
update t_account set username = #{username},password = #{password},
age = #{age} where id = #{id}
</update>
- resultType：结果类型
一、基本数据类型，统计Account总数
<select id="count" resultType="int"> select count(id) from t_account </select>
二、包装类，统计Account总数
<select id="count2" resultType="java.lang.Integer"> select count(id) from t_account </select>
三、String类型，经过id查询Account的name
<select id="findNameByID" resultType="java.lang.String">
select username from t_account where id = #{id}
</select>
四、Java Bean
<select id="findById" parameterType="long" resultType="com.janeroad.entity.Account">
select * from t_account where id = #{id}
</select>
级联查询
- 一对多
Student
package com.janeroad.entity;
import lombok.Data;
[@Data](https://my.oschina.net/difrik)
public class Student {
private long id;
private String name;
private Classes classes;
}
Classes
package com.janeroad.entity;
import lombok.Data;
import java.util.List;
[@Data](https://my.oschina.net/difrik)
public class Classes {
private long id;
private String name;
private List<String> students;
}
StudentRepository
package com.janeroad.repository;
import com.janeroad.entity.Student;
public interface StudentRepository {
public Student findById(long id);
}
StudentRepository.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.janeroad.repository.StudentRepository">
<resultMap id="studentMap" type="com.janeroad.entity.Student">
<id column="id" property="id"></id>
<result column="name" property="name"></result>
<association property="classes" javaType="com.janeroad.entity.Classes">
<id column="cid" property="id"></id>
<result column="cname" property="name"></result>
</association>
</resultMap>
<select id="findById" parameterType="long" resultMap="studentMap">
select s.id ,s.name ,c.id as cid,c.name as cname from student s,classes c where s.id=#{id} and s.cid=c.id
</select>
</mapper>
ClassesRepository
package com.janeroad.repository;
import com.janeroad.entity.Classes;
public interface ClassesRepository {
public Classes findById(long id);
}
ClassesRepository.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.janeroad.repository.ClassesRepository">
<resultMap id="classesMap" type="com.janeroad.entity.Classes">
<id column="cid" property="id"></id>
<result column="cname" property="name"></result>
<collection property="students" ofType="com.janeroad.entity.Student">
<id column="id" property="id"/>
<result column="name" property="name"/>
</collection>
</resultMap>
<select id="findById" parameterType="long" resultMap="classesMap">
select s.id ,s.name ,c.id as cid,c.name as cname from student s,classes c where c.id=#{id} and s.cid=c.id
</select>
</mapper>
- 多对多
Customer
package com.janeroad.entity;
import lombok.Data;
import java.util.List;
[@Data](https://my.oschina.net/difrik)
public class Customer {
private long id;
private String name;
private List<Goods> goods;
}
Goods
package com.janeroad.entity;
import lombok.Data;
import java.util.List;
[@Data](https://my.oschina.net/difrik)
public class Goods {
private long id;
private String name;
private List<Customer> customers;
}
CustomerRepository
package com.janeroad.repository;
import com.janeroad.entity.Customer;
public interface CustomerRepository {
public Customer findById(long id);
}
CustomerRepository.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.janeroad.repository.CustomerRepository">
<resultMap id="customerMap" type="com.janeroad.entity.Customer">
<id column="cid" property="id"></id>
<result column="cname" property="name"></result>
<collection property="goods" ofType="com.janeroad.entity.Goods">
<id column="gid" property="id"/>
<result column="gname" property="name"/>
</collection>
</resultMap>
<select id="findById" parameterType="long" resultMap="customerMap">
select c.id cid ,c.name cname,g.id gid,g.name gname from customer c,goods g ,customer_goods cg
where c.id=#{id}
</select>
</mapper>
GoodsRepository
package com.janeroad.repository;
import com.janeroad.entity.Goods;
public interface GoodsRepository {
public Goods findById(long id);
}
GoodsRepository.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.janeroad.repository.GoodsRepository">
<resultMap id="goodsMap" type="com.janeroad.entity.Goods">
<id column="gid" property="id"></id>
<result column="gname" property="name"></result>
<collection property="customers" ofType="com.janeroad.entity.Customer">
<id column="cid" property="id"/>
<result column="cname" property="name"/>
</collection>
</resultMap>
<select id="findById" parameterType="long" resultMap="goodsMap">
select c.id cid ,c.name cname,g.id gid,g.name gname from customer c,goods g ,customer_goods cg
where g.id=#{id}
and cg.cid=c.id
and cg.gid=g.id
</select>
</mapper>
逆向工程
MyBatis框架须要：实体类、自定义Mapper接口、Mapper.xml
传统的开发中上述的三个组件须要开发者手动建立，逆向工程能够帮助开发者来自动建立三个组件，减轻开发者的工做量，提升工做效率。
如何使用
MyBatis Generator ，简称MBG，是一个专门为MyBatis框架开发者定制的代码生成器，可自动生成MyBatis框架所需的实体类、Mapper接口、Mapper.xml，支持基本的CRUD操做，可是一些相对复杂的SQL须要开发者本身来完成。
- 新建Maven工程，pom.xml
<dependencies>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.11</version>
</dependency>
<dependency>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-core</artifactId>
<version>1.3.2</version>
</dependency>
</dependencies>
- 建立MBG配置文件generatorConfig.xml
一、jdbcConnection配置数据库链接信息
二、javaModelGenerator配置JavaBean的生成策略
三、sqlMapGenerator配置SQL映射文件生成策略
四、JavaClientGenerator配置Mapper接口的生成策略
五、table配置目标数据表（tableName：表名，domainObjectName：JavaBean类名）
<?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>
<context id="testTables" targetRuntime="MyBatis3">
<jdbcConnection
driverClass="com.mysql.cj.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/mybatis? useUnicode=true&characterEncoding=UTF-8"
userId="root"
password="123456"></jdbcConnection>
<javaModelGenerator targetPackage="com.janeroad.entity"
targetProject="./src/main/java"></javaModelGenerator>
<sqlMapGenerator targetPackage="com.janeroad.repository"
targetProject="./src/main/java"></sqlMapGenerator>
<javaClientGenerator type="XMLMAPPER" targetPackage="com.janeroad.repository" targetProject="./src/main/java"></javaClientGenerator>
<table tableName="t_user" domainObjectName="User"></table>
</context>
</generatorConfiguration>
- 建立Generator执行类
package com.janeroad.test;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.exception.InvalidConfigurationException;
import org.mybatis.generator.exception.XMLParserException;
import org.mybatis.generator.internal.DefaultShellCallback;
import java.io.File;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> warings = new ArrayList<String>();
boolean overwrite = true;
String genCig = "/generatorConfig.xml";
File configFile = new File(Main.class.getResource(genCig).getFile());
ConfigurationParser configurationParser = new ConfigurationParser(warings);
Configuration configuration = null;
try {
configuration = configurationParser.parseConfiguration(configFile);
} catch (IOException e) {
e.printStackTrace();
} catch (XMLParserException e) {
e.printStackTrace();
}
DefaultShellCallback callback = new DefaultShellCallback(overwrite);
MyBatisGenerator myBatisGenerator = null;
try {
myBatisGenerator = new MyBatisGenerator(configuration,callback,warings);
} catch (InvalidConfigurationException e) {
e.printStackTrace();
}
try {
myBatisGenerator.generate(null);
} catch (SQLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
MyBatis延迟加载
- 什么是延迟加载？
延迟加载也叫懒加载、惰性加载，使用延迟加载能够提升程序的运行效率，针对于数据持久层的操做，在某些特定的状况下去访问特定的数据库，在其余状况下能够不访问某些表，从必定程度上减小了Java应用与数据库的交互次数。
查询学生和班级的时候，学生和班级是两张不一样的表，若是当前需求只须要获取学生的信息，那么查询学生单表便可，若是须要经过学生获取对应的班级信息，则必须查询两张表。
不一样的业务需求，须要查询不一样的表，根据具体的业务需求来动态减小数据表查询的工做就是延迟加载。
- 在config.xml中开启延迟加载
<settings>
<!-- 打印SQL-->
<setting name="logImpl" value="STDOUT_LOGGING" />
<!-- 开启延迟加载-->
<setting name="lazyLoadingEnabled" value="true"/>
</settings>
- 将多表关联查询拆分红多个单表查询
StudentRepository
public Student findByIdLazy(long id);
StudentRepository.xml
<resultMap id="studentMapLazy" type="com.janeroad.entity.Student">
<id column="id" property="id"></id>
<result column="name" property="name"></result>
<association property="classes" javaType="com.janeroad.entity.Classes"
select="com.janeroad.repository.ClassesRepository.findByIdLazy" column="cid"></association>
</resultMap>
<select id="findByIdLazy" parameterType="long" resultMap="studentMapLazy">
select * from student where id =#{id}
</select>
ClassesRepository
public Classes findByIdLazy(long id);
ClassesRepository.xml
<select id="findByIdLazy" parameterType="long" resultType="com.janeroad.entity.Classes">
select * from classes where id=#{id}
</select>
MyBatis缓存
- 什么是MyBatis缓存
使用缓存能够减小Java应用与数据库的交互次数，从而提高程序的运行效率。好比查询出id=1的对象，第一次查询出以后会自动将该对象将保存到缓存中，当下一次查询时，直接从缓存中取出对象便可，无需再次访问数据库
- MyBatis缓存分类
一、一级缓存：Sqlsession级别，默认开启，而且不能关闭。
操做数据库时须要建立SqlSession对象，在对象中有一个HashMap用于存储缓存数据，不一样的SqlSession之间缓存数据区域是互不影响的。
一级缓存的做用域是SqlSession范围的，当在同一个SqlSession中执行两次相同的SQL语句时，第一次执行完毕会将结果保存到缓存中，第二次查询时直接从缓存中获取。
须要注意的是，若是SqlSession执行了DML操做（insert、update、delete），MyBatis必须将缓存清空以保证数据的准确性。
二、二级缓存：Mapper级别，默认关闭，能够开启。
使用二级缓存时，多个SqlSession使用同一个Mapper的SQL语句操做数据库，获得的数据会存在二级缓存区，一样是使用HashMap进行数据存储，相比较于一级缓存，二级缓存的范围更大，多个SqlSession能够共用二级缓存，二级缓存是跨SqlSession的。
二级缓存是多个SqlSession共享的，其做用域是Mapper的同一个namespace，不一样的SqlSession两次执行相同的namespace下的SQL语句，参数也相等，则第一次执行成功以后会将数据保存到二级缓存中，第二次可直接从二级缓存中取出数据
代码
- 一级缓存
package com.janeroad.test;
import com.janeroad.entity.Account;
import com.janeroad.repository.AccountRepository;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.InputStream;
public class Test4 {
public static void main(String[] args) {
InputStream inputStream=Test.class.getClassLoader().getResourceAsStream("config.xml");
SqlSessionFactoryBuilder sqlSessionFactoryBuilder=new SqlSessionFactoryBuilder();
SqlSessionFactory sqlSessionFactory=sqlSessionFactoryBuilder.build(inputStream);
SqlSession sqlSession=sqlSessionFactory.openSession();
AccountRepository accountRepository=sqlSession.getMapper(AccountRepository.class);
//验证一级缓存
Account account=accountRepository.findById(1L);
System.out.println(account);
Account account1=accountRepository.findById(1L);
System.out.println(account1);
//若是关闭SqlSession则会抛出异常关闭后必须从新建立一个，sql语句就没法再从缓存中读取，sql语句会执行两次
// sqlSession.close();
// sqlSession=sqlSessionFactory.openSession();
// accountRepository=sqlSession.getMapper(AccountRepository.class);
// Account account1=accountRepository.findById(1L);
// System.out.println(account1);
}
}
- 二级缓存
一、MyBatis自带的二级缓存
- config.xml中配置开启二级缓存
<settings>
<!-- 打印SQL-->
<setting name="logImpl" value="STDOUT_LOGGING" />
<!-- 开启延迟加载-->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 开启二级缓存-->
<setting name="cacheEnabled" value="true"/>
</settings>
- Mapper.xml中配置二级缓存
<cache></cache>
- 实体类实现序列化接口
package com.janeroad.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account implements Serializable {
private long id;
private String username;
private String password;
private int age;
}
二、ehcache 二级缓存
- pom.xml添加相关依赖
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-ehcache</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache-core</artifactId>
<version>2.4.3</version>
</dependency>
- 添加ehcache.xml
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
<diskStore/>
<defaultCache
maxElementsInMemory="1000"
maxElementsOnDisk="10000000"
eternal="false"
overflowToDisk="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU">
</defaultCache>
</ehcache>
- config.xml中配置开启二级缓存
<settings>
<!-- 打印SQL-->
<setting name="logImpl" value="STDOUT_LOGGING" />
<!-- 开启延迟加载-->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 开启二级缓存-->
<setting name="cacheEnabled" value="true"/>
</settings>
- Mapper.xml中配置二级缓存
<cache type="org.mybatis.caches.ehcache.EhcacheCache">
<!--缓存建立以后，最后一次访问缓存的时间至缓存失效的时间间隔 -->
<property name="timeToIdleSeconds" value="3600"/>
<!--缓存自建立时间起至失效的时间间隔 -->
<property name="timeToLiveSeconds" value="3600"/>
<!--缓存的回收策略，LRU 表示移除近期使用最少的对象 -->
<property name="memoryStoreEvictionPolicy" value="LRU"/>
</cache>
- 实体类不须要实现序列化接口
package com.janeroad.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account {
private long id;
private String username;
private String password;
private int age;
}
MyBatis动态SQL
使用动态SQL可简化代码的开发，减小开发者的工做量，程序能够自动根据业务参数来决定SQL的组成
- if标签
<select id="findByAccount" parameterType="com.janeroad.entity.Account" resultType="com.janeroad.entity.Account">
select * from t_account where
<if test="id!=0">
id = #{id}
</if>
<if test="username!=null">
and username = #{username}
</if>
<if test="password!=null">
and password = #{password}
</if>
<if test="age!=0">
and age = #{age}
</if>
</select>
if 标签能够自动根据表达式的结果来决定是否将对应的语句添加到SQL中，若是条件不成立则不添加，若是条件成立则添加。
- where标签
<select id="findByAccount" parameterType="com.janeroad.entity.Account" resultType="com.janeroad.entity.Account">
select * from t_account
<where>
<if test="id!=0">
id = #{id}
</if>
<if test="username!=null">
and username = #{username}
</if>
<if test="password!=null">
and password = #{password}
</if>
<if test="age!=0">
and age = #{age}
</if>
</where>
</select>
where标签能够自动判断是否要删除语句块中的and关键字，若是检测到where直接跟and拼接，则自动删除and，一般状况下if和where结合起来使用
- choose、when标签
<select id="findByAccount" parameterType="com.janeroad.entity.Account" resultType="com.janeroad.entity.Account">
select * from t_account
<where>
<choose>
<when test="id!=0">
id = #{id}
</when>
<when test="username!=null">
username = #{username}
</when>
<when test="password!=null">
password = #{password}
</when>
<when test="age!=0">
age = #{age}
</when>
</choose>
</where>
</select>
- trim标签
trim标签中的prefix和suffix属性会被用于生成实际的SQL语句，会和标签内部的语句进行拼接，若是语句先后出现了prefixOverrides或suffixOverrides属性中指定的值，MyBatis框架会自动将其删除
<select id="findByAccount" parameterType="com.janeroad.entity.Account" resultType="com.janeroad.entity.Account">
select * from t_account
<trim prefix="where" prefixOverrides="and">
<if test="id!=0">
id = #{id}
</if>
<if test="username!=null">
and username = #{username}
</if>
<if test="password!=null">
and password = #{password}
</if>
<if test="age!=0">
and age = #{age}
</if>
</trim>
</select>
- set标签
set标签用于update操做，会自动根据参数选择生成SQL语句（减小没必要要的SQL赋值）
<update id="update" parameterType="com.janeroad.entity.Account">
update t_account
<set>
<if test="username!=null">
username = #{username},
</if>
<if test="password!=null">
password = #{password},
</if>
<if test="age!=0">
age = #{age}
</if>
</set>
where id = #{id}
</update>
- foreach标签
foreach标签能够迭代生成一系列值，这个标签主要用于SQL的in语句
（等于一次调用屡次的findById方法，调出数据，须要先在account实体类里定义一个Long类型的 ids集合，在经过account.setIds()方法赋值给ids集合 ）
<select id="findByIds" parameterType="com.janeroad.entity.Account" resultType="com.janeroad.entity.Account">
select * from t_account
<where>
<foreach collection="ids" open="id in (" close=")" item="id"
separator=",">
#{id}
</foreach>
</where>
</select>
PS：四天学完MVC，两天学完Mybatis，累死了，之后要多复习几遍！！
相关文章
- 1. MyBatis学习笔记
- 2. Mybatis学习笔记
- 3. MyBatis（学习笔记）
- 4. mybatis 学习笔记
- 5. mybatis学习笔记
- 6. myBatis学习笔记
- 7. MyBatis学习笔记（三）
- 8. MyBatis项目学习笔记
- 9. （二）MyBatis学习笔记-HelloWorld
- 10. Mybatis学习笔记1
- 更多相关文章...
- • 您已经学习了 XML Schema，下一步学习什么呢？ - XML Schema 教程
- • 我们已经学习了 SQL，下一步学习什么呢？ - SQL 教程
- • Tomcat学习笔记（史上最全tomcat学习笔记）
- • 适用于PHP初学者的学习线路和建议
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. MyBatis学习笔记
- 2. Mybatis学习笔记
- 3. MyBatis（学习笔记）
- 4. mybatis 学习笔记
- 5. mybatis学习笔记
- 6. myBatis学习笔记
- 7. MyBatis学习笔记（三）
- 8. MyBatis项目学习笔记
- 9. （二）MyBatis学习笔记-HelloWorld
- 10. Mybatis学习笔记1