MyBatis是一个实现了数据持久化的开源框架,简单理解就是对JDBC进行封装
SQL语句写在XML里面,从程序代码中分离,降低耦合度,但是SQL语句编写工作量大,依赖于底层数据库,不能随意更换
ORMapping: Object Relationship Mapping 对象关系映射
对象指⾯向对象
关系指关系型数据库
Java 到 MySQL 的映射,开发者可以以⾯向对象的思想来管理数据库。
如何使⽤
新建 Maven ⼯程,pom.xml
<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.0modelVersion>
<groupId>com.southwindgroupId>
<artifactId>aimybatisartifactId>
<version>1.0-SNAPSHOTversion>
<properties>
<maven.compiler.source>8maven.compiler.source>
<maven.compiler.target>8maven.compiler.target>
properties>
<dependencies>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.4.5version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>8.0.13version>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<version>1.18.6version>
dependency>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.12version>
dependency>
dependencies>
<build>
<resources>
<resource>
<directory>src/main/javadirectory>
<includes>
<include>**/*.xmlinclude>
includes>
resource>
resources>
build>
project>
新建数据表
use mybatis;
create table t_account(
id int primary key auto_increment,
username varchar(11),
password varchar(11),
age int
)
新建数据表对应的实体类Account
package com.southwind.entity;
import lombok.Data;
@Data
public class Account {
private long id;
private String username;
private String password;
private int age;
}
在resources中创建 MyBatis 的配置⽂件 config.xml,⽂件名可⾃定义
DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC">transactionManager>
<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&serverTimezone=UTC&useSSL=false">property>
<property name="username" value="root">property>
<property name="password" value="199810">property>
dataSource>
environment>
environments>
configuration>
1、MyBatis 框架需要开发者⾃定义 SQL 语句,写在 Mapper.xml ⽂件中,实际开发中,会为每个实体类创建对应的 Mapper.xml ,定义管理该对象数据的 SQL。
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.southwind.mapper.AccountMapper">
<insert id="save" parameterType="com.southwind.entity.Account">
-- sql语句 因为Account已经变成对象,添加的数据只要从Account类中调用即可,#{}可以直接调用类对象
insert into t_account(username,password,age) values (#{username},#{password},#{age})
insert>
mapper>
2、在全局配置⽂件 confifig.xml 中注册 AccountMapper.xml
DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC">transactionManager>
<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&serverTimezone=UTC">property>
<property name="username" value="root">property>
<property name="password" value="199810">property>
dataSource>
environment>
environments>
<mappers>
<mapper resource="com/southwind/mapper/AccountMapper.xml">mapper>
mappers>
configuration>
3、调⽤ MyBatis 的原⽣接⼝执⾏添加操作。
public class Test {
public static void main(String[] args) {
//加载MyBatis的配置文件
//先读取配置文件为数据流
InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("config.xml");
System.out.println(inputStream);
//1.先实例化 sql会话工厂建造类 SqlSessionFactoryBuilder
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
//2.通过建造类Builder以 inputStream数据流为对象 创建 sql会话工厂 sqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
//3.通过工厂对象的openSession()方法创建 SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
//statement为即将要加载的AccountMapper.xml中的sql语句位置信息
String statement = "com.southwind.mapper.AccountMapper.save";
//实例化实体类对象
Account account = new Account(1,"张三","123123",22);
//把statement位置和account对象都传进去
sqlSession.insert(statement,account);
//提交事务
sqlSession.commit();
}
}
package com.southwind.repository;
import com.southwind.entity.Account;
import java.util.List;
public interface AccountRepository {
public int save(Account account);//增
public int update(Account account);//改
public long deleteById(long id);//通过id删除对象
public List<Account> findAll();//查询所有结果
public Account fondById(long id);通过id查询结果
}
2、创建接⼝对应的 Mapper.xml,定义接⼝⽅法对应的 SQL 语句。
statement 标签可根据 SQL 执⾏的业务选择 insert、delete、update、select。
MyBatis 框架会根据规则⾃动创建接⼝实现类的代理对象。
规则:
Mapper.xml 中 namespace 为接⼝的全类名。
Mapper.xml 中 statement 的 id 为接⼝中对应的⽅法名。
Mapper.xml 中 statement 的 parameterType 和接⼝中对应⽅法的参数类型⼀致。
Mapper.xml 中 statement 的 resultType 和接⼝中对应⽅法的返回值类型⼀致。
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.southwind.repository.AccountRepository">
<insert id="save" parameterType="com.southwind.entity.Account">
insert into t_account(username,password,age) values(#{username},#{password},#{age})
insert>
<update id="update" parameterType="com.southwind.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.southwind.entity.Account">
select * from t_account
select>
<select id="findById" parameterType="long" resultType="com.southwind.entity.Account">
select * from t_account where id = #{id}
select>
mapper>
3、在 confifig.xml 中注册 AccountRepository.xml
<mappers>
<mapper resource="com/southwind/mapper/AccountMapper.xml">mapper>
<mapper resource="com/southwind/repository/AccountRepository.xml">mapper>
mappers>
4.创建一个MyBatisUtils工具类专门写配置代码
package com.southwind.utils;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
public class MyBatisUtils {
private static SqlSessionFactory sqlSessionFactory;
static {
String resource = "config.xml";
try {
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
//返回一个sqlsession对象
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession();
}
}
5、调⽤接⼝的代理对象完成相关的业务操作
package com.southwind.test;
import com.southwind.entity.Account;
import com.southwind.repository.AccountRepository;
import com.southwind.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
/****通过 Mapper 代理实现⾃定义接⼝**
* 1.实体类Account
* 2.repository中创建接口及其方法
* 3.接口同包下创建mapper动态代理
* 4.在resources资源中配置config.xml
* 5.创建调⽤接⼝的代理对象完成相关的业务操作
*/
public class Test2 {
@Test
public void testAccount(){
//通过MyBatisUtils调用配置文件获取一个SqlSession对象
SqlSession sqlSession = MyBatisUtils.getSqlSession();
///通过反射获取实现接口的代理对象
AccountRepository accountRepository = sqlSession.getMapper(AccountRepository.class);
//代理对象可以直接对mapper进行操作
//添加
Account account = new Account(4L,"张三","222222",22);
int result = accountRepository.save(account);//返回影响的行数
System.out.println("影响了"+result+"行");
sqlSession.commit();
//通过id查找
account = accountRepository.findById(7L);
System.out.println(account);
//关闭
sqlSession.close();
}
}
1、基本数据类型,通过 id 查询 Account
<select id="findById" parameterType="long" resultType="com.southwind.entity.Account">
select * from t_account where id = #{id}
select>
2、String 类型,通过 name 查询 Account
<select id="findByName" parameterType="java.lang.String" resultType="com.southwind.entity.Account">
select * from t_account where username = #{username}
select>
3、包装类,通过 id 查询 Account
<select id="findById2" parameterType="java.lang.Long" resultType="com.southwind.entity.Account">
select * from t_account where id = #{id}
select>
4、多个参数,通过 name 和 age 查询 Account(parameterType只允许有一个,而name和age分别是String和int类型,所以干脆不写parameterType)(param和arg都可以按顺序读取参数,但是param从1开始,arg从0开始)
<select id="findByNameAndAge" resultType="com.southwind.entity.Account">
select * from t_account where username = #{arg0} and age = #{arg1}
select>
5、Java Bean(参数对象类型)
<update id="update" parameterType="com.southwind.entity.Account">
update t_account set username = #{username},password = #{password},age = #{age} where id = #{id}
update>
resultType:结果类型
1、基本数据类型,统计 Account 总数
<select id="count" resultType="int">
select count(id) from t_account
select>
2、包装类,统计 Account 总数
<select id="count2" resultType="java.lang.Integer">
select count(id) from t_account
select>
4、Java Bean
<select id="findById" parameterType="long" resultType="com.southwind.entity.Account">
select * from t_account where id = #{id}
select>
⼀对多
Student
package com.southwind.entity;
import lombok.Data;
@Data
public class Student {
private long id;
private String name;
private Classes classes;
}
Classes
package com.southwind.entity;
import lombok.Data;
import java.util.List;
@Data
public class Classes {
private long id;
private String name;
private List<Student> students;
}
StudentRepository
package com.southwind.repository;
import com.southwind.entity.Student;
public interface StudentRepository {
public Student findById(long id);
}
StudentRepository.xml
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.southwind.repository.StudentRepository">
<resultMap id="studentMap" type="com.southwind.entity.Student">
<id column="id" property="id">id>
<result column="name" property="name">result>
<association property="classes" javaType="com.southwind.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.southwind.repository;
import com.southwind.entity.Classes;
public interface ClassesRepository {
public Classes findById(long id);
}
ClassesRepository.xml
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.southwind.repository.Classesrepository">
<resultMap id="classesMap" type="com.southwind.entity.Classes">
<id column="cid" property="id">id>
<result column="cname" property="name">result>
<collection property="students" ofType="com.southwind.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.southwind.entity;
import lombok.Data;
import java.util.List;
@Data
public class Customer {
private long id;
private String name;
private List<Goods> goods;
}
Goods
package com.southwind.entity;
import lombok.Data;
import java.util.List;
@Data
public class Goods {
private long id;
private String name;
private List<Customer> customers;
}
CustomerRepository
package com.southwind.repository;
import com.southwind.entity.Customer;
public interface CustomerRepository {
public Customer findById(long id);
}
CustomeRepository.xml
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.southwind.repository.CustomeRepository">
<resultMap id="customerMap" type="com.southwind.entity.Customer">
<id column="cid" property="id">id>
<result column="cname" property="name">result>
<collection property="goods" ofType="com.southwind.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} and cg.cid = c.id and cg.gid = g.id;
select>
mapper>
GoodsRepository
package com.southwind.repository;
import com.southwind.entity.Goods;
public interface GoodsRepository {
public Goods findById(long id);
}
GoodsRepository.xml
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.southwind.repository.GoodsRepository">
<resultMap id="goodsMap" type="com.southwind.entity.Goods">
<id column="gid" property="id"/>
<result column="gname" property="name"/>
<collection property="customers" ofType="com.southwind.entity.Customer">
<id column="cid" property="id"/>
<result column="cname" property="name"/>
collection>
resultMap>
<select id="findById" 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=3 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 需要开发者⾃⼰来完成。
<dependencies>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.4.5version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>8.0.11version>
dependency>
<dependency>
<groupId>org.mybatis.generatorgroupId>
<artifactId>mybatis-generator-coreartifactId>
<version>1.3.2version>
dependency>
dependencies>
1、jdbcConnection 配置数据库连接信息。
2、javaModelGenerator 配置 JavaBean 的⽣成策略。
3、sqlMapGenerator 配置 SQL 映射⽂件⽣成策略。
4、javaClientGenerator 配置 Mapper 接⼝的⽣成策略。
5、table 配置⽬标数据表(tableName:表名,domainObjectName:JavaBean 类名)。
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&useSSL=false&serverTimezone=UTC"
userId="root"
password="199810">
jdbcConnection>
<javaModelGenerator targetPackage="com.southwind.entity" targetProject="./src/main/java">javaModelGenerator>
<sqlMapGenerator targetPackage="com.southwind.repository" targetProject="./src/main/java">sqlMapGenerator>
<javaClientGenerator type="XMLMAPPER" targetPackage="com.southwind.repository" targetProject="./src/main/java">javaClientGenerator>
<table tableName="t_user" domainObjectName="User">table>
context>
generatorConfiguration>
配置逆向工程时在connectionURL中要加上serverTimezone=UTC且不能在中文路径下
package 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<>();
Boolean overwrite = true;
// 配置文件路径
String genCig = "/generatorConfig.xml";
// 根据配置文件创建一个file
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 throwables) {
throwables.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
延迟加载也叫懒加载、惰性加载,使⽤延迟加载可以提⾼程序的运⾏效率,针对于数据持久层的操作,在某些特定的情况下去访问特定的数据库,在其他情况下可以不访问某些表,从⼀定程度上减少了 Java应⽤与数据库的交互次数。
(在级联查询中只需要查询其中一张表时用延迟加载)
(比如前端页面显示学生姓名,id,当点击班级后才显示班级信息,后端是把学生和班级表级联了,但是只显示一个表信息)查询学⽣和班级的时,学⽣和班级是两张不同的表,如果当前需求只需要获取学⽣的信息,那么查询学⽣单表即可,如果需要通过学⽣获取对应的班级信息,则必须查询两张表。不同的业务需求,需要查询不同的表,根据具体的业务需求来动态减少数据表查询的⼯作就是延迟加载。
在 confifig.xml 中开启延迟加载
<settings>
<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.southwind.entity.Student">
<id column="id" property="id"></id>
<result column="name" property="name"></result>
<association property="classes" javaType="com.southwind.entity.Classes" select="com.southwind.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.southwind.entity.Classes">
select * from classes where id = #{id}
select>
使⽤缓存可以减少 Java 应⽤与数据库的交互次数,从⽽提升程序的运⾏效率。⽐如查询出 id = 1 的对象,第⼀次查询出之后会⾃动将该对象保存到缓存中,当下⼀次查询时,直接从缓存中取出对象即可,⽆需再次访问数据库。
1、⼀级缓存:SqlSession 级别,默认开启,并且不能关闭。
操作数据库时需要创建 SqlSession 对象,在对象中有⼀个 HashMap ⽤于存储缓存数据,不同的SqlSession 之间缓存数据区域是互不影响的。
⼀级缓存的作⽤域是 SqlSession 范围的,当在同⼀个 SqlSession 中执⾏两次相同的 SQL 语句事,第⼀次执⾏完毕会将结果保存到缓存中,第⼆次查询时直接从缓存中获取。需要注意的是,如果 SqlSession 执⾏了 DML 操作(insert、update、delete),MyBatis 必须将缓存清空以保证数据的准确性。
2、⼆级缓存:Mapper 级别,默认关闭,可以开启。
使⽤⼆级缓存时,多个 SqlSession 使⽤同⼀个 Mapper 的 SQL 语句操作数据库,得到的数据会存在⼆级缓存区,同样是使⽤ HashMap 进⾏数据存储,相⽐较于⼀级缓存,⼆级缓存的范围更⼤,多个SqlSession 可以共⽤⼆级缓存,⼆级缓存是跨 SqlSession 的。
⼆级缓存是多个 SqlSession 共享的,其作⽤域是 Mapper 的同⼀个 namespace,不同的 SqlSession
两次执⾏相同的 namespace 下的 SQL 语句,参数也相等,则第⼀次执⾏成功之后会将数据保存到⼆级缓存中,第⼆次可直接从⼆级缓存中取出数据。
代码
package com.southwind.test;
import com.southwind.entity.Account;
import com.southwind.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);//第一次执行sql语句
System.out.println(account);
//sqlSession.close();
//注释打开就会创建一个新的sqlSession,会重新执行sql语句
//sqlSession = sqlSessionFactory.openSession();
//accountRepository = sqlSession.getMapper(AccountRepository.class);
Account account1 = accountRepository.findById(1L);//虽然再次调用了一次findById方法,但是原来的数据已经存到了sqlSession中,一共只执行了一次sql语句
System.out.println(account1);
}
}
⼆级缓存
1、MyBatis ⾃带的⼆级缓存
confifig.xml 配置开启⼆级缓存
<settings>
<setting name="logImpl" value="STDOUT_LOGGING" />
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="cacheEnabled" value="true"/>
settings>
<cache>cache>
package com.southwind.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;
}
2、ehcache ⼆级缓存
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatis-ehcacheartifactId>
<version>1.0.0version>
dependency>
<dependency>
<groupId>net.sf.ehcachegroupId>
<artifactId>ehcache-coreartifactId>
<version>2.4.3version>
dependency>
<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>
<settings>
<setting name="logImpl" value="STDOUT_LOGGING" />
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="cacheEnabled" value="true"/>
settings>
<cache type="org.mybatis.caches.ehcache.EhcacheCache">
<property name="timeToIdleSeconds" value="3600"/>
<property name="timeToLiveSeconds" value="3600"/>
<property name="memoryStoreEvictionPolicy" value="LRU"/>
cache>
package com.southwind.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;
}
使⽤动态 SQL 可简化代码的开发,减少开发者的⼯作量,程序可以⾃动根据业务参数来决定 SQL 的组
成。
<select id="findByAccount" parameterType="com.southwind.entity.Account" resultType="com.southwind.entity.Account">
select * from t_account where
<if test="id!=0">
id = #{id}
if>
<if test="username!=null">
and username = #{username}
if>
-- 后台没有setPassword时,默认把password=null,不执行下面语句即不加password=?条件
<if test="password!=null">
and password = #{password}
if>
<if test="age!=0">
and age = #{age}
if>
select>
if 标签可以⾃动根据表达式的结果来决定是否将对应的语句添加到 SQL 中,如果条件不成⽴则不添加,
如果条件成⽴则添加。
<select id="findByAccount" parameterType="com.southwind.entity.Account" resultType="com.southwind.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 拼接(即id为null,没有添加id=?语句,直接跟and username = ?语句,where and不是sql语法),则⾃动删除 and,通常情况下 if 和 where 结合起来使⽤。
<select id="findByAccount" parameterType="com.southwind.entity.Account" resultType="com.southwind.entity.Account">
select * from t_account
<where>
<choose>
<when test="id!=0">
id = #{id}
when>
<when test="username!=null">
and username = #{username}
when>
<when test="password!=null">
and password = #{password}
when>
<when test="age!=0">
and age = #{age}
when>
choose>
where>
select>
trim 标签中的 prefix 和 suffix 属性会被⽤于⽣成实际的 SQL 语句,会和标签内部的语句进⾏拼接,如果语句前后出现了 prefixOverrides 或者 suffixOverrides 属性中指定的值,MyBatis 框架会⾃动将其删除。
<select id="findByAccount" parameterType="com.southwind.entity.Account"
resultType="com.southwind.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>
<select id="findByAccount" parameterType="com.southwind.entity.Account"
resultType="com.southwind.entity.Account">
select * from t_account S where
<trim prefix="and(" prefixOverrides="AND|OR" suffix=")">
<if test="policyType.indexOf('province')>=0">
or 1 = 1
if>
<if test="age!=0">
or age = #{age}
if>
trim>
select>
prefix=“where” where拼接,prefixOverrides=“and” and删除
set 标签
set 标签⽤于 update 操作,会⾃动根据参数选择⽣成 SQL 语句。
<update id="update" parameterType="com.southwind.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 标签可以迭代⽣成⼀系列值,这个标签主要⽤于 SQL 的 in 语句。
<select id="findByIds" parameterType="com.southwind.entity.Account" resultType="com.southwind.entity.Account">
-- select * from t_account where id in (1,2,4,6)
select * from t_account
<where>
<foreach collection="ids" open="id in (" close=")" item="id" separator=",">
#{id}
foreach>
where>
<select id="findByIds" parameterType="com.southwind.entity.Account" resultType="com.southwind.entity.Account">
-- select * from t_account where BRACE_COMPANY in (1,2,4,6)
select * from t_account
<where>
<if test="braceCompanys != null and braceCompanys.length > 0">
AND BRACE_COMPANY IN
<foreach item="item" collection="braceCompanys" index="index" open="(" separator="," close=")">
#{item}
foreach>
<if test="supportContents != null and supportContents.length">
and
<foreach collection="supportContents" item="item" index="index" open="(" close=")" separator="or">
INSTR( S.SUPPORT_CONTENT , #{item} ) > 0
foreach>
if>
if>
<if test='dimension != null and dimension == "ICT_SUPPORT_DIMENSION_1"'>
AND DIMENSION LIKE '%' || #{dimension,jdbcType=VARCHAR} || '%'
if>
where>
select>
collection:代表ids集合
“id in (” 数据前的 ")"数据后的
item="id"每次取出来的一个变量名为id
separator=","中间用逗号分隔