Mybatis(Ibatis)基础

Mybatis配置


第一步:导入jdbc的jar(mysql-connector-5.0.3-bin.jar)
第二步:导入mybatis的jar(mybatis-3.2.8.jar)
第三步:创建数据库、表
mysql> create database mybatis;
Query OK, 1 row affected (0.01 sec)
mysql> use mybatis;
Database changed
mysql>create table tb_user(
id int(11) primary key auto_increment,
name varchar(18) Default null,
sex char(2) default null,
age int(11) default null
);
第四步:持久化对象POJO--User.java
public class User {
//用户标识
private Integer id;
//用户名称
private String name;
//用户年龄
private Integer age;
//用户性别
private String sex;
//无参构造器
public User() {
// TODO Auto-generated constructor stub
super();
}
//有参构造器
public User(String name, String sex, int age) {
// TODO Auto-generated constructor stub
super();
this.name = name;
this.sex = sex;
this.age = age;
}
//省略setter和getter方法
}
第五步:UserMapper.xml映射文件(命名规则:POJO+Mapper.xml)



mapper.dtd">





INSERT INTO
TB_USER(name,sex,age)
VALUES(#{name},#{sex},#{age})


第六步:数据库连接池



"http://mybatis.org/dtd/mybatis-3-config.dtd">
















/>










第七步:Test.java的实现增、删改查
public static void main(String[] args) throws IOException {
// 读取mybatis-config.xml文件
InputStream inputStream = Resources
.getResourceAsStream("mybatis-config.xml");
// 初始化Mybatis,创建sqlSessionFactory实例
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
.build(inputStream);
// 创建Session实例
SqlSession session = sqlSessionFactory.openSession();
User user = new User("admin", "2", 26);
// 插入数据namespace+id
session.insert("anlemusic.cn.mapper.UserMapper.save", user);
// 提交事务
session.commit();
// 关闭session
session.close();
}
+----+-------+------+------+
| id | name  | sex  | age  |
+----+-------+------+------+
|  1 | admin | 2    |   26 |由此可见,添加成功了




深入Mybitas
SqlSessionFactory:它是单个数据库映射关系经过编译后的内存镜像,该实例可以通过


SqlSessionFactoryBuilder对象从配置文件中来获得SqlSessionFactory的实例,且以此为核心
常用方法:SqlSession openSession 创建SqlSession对象


SqlSession:它类似Connection,该实例不可被共享,不能放在一个类的静态字段甚至实例字段中,开启


之后,应该确保使用finally块来关闭它
常用方法:int insert(String statement)


namespace+id,返回SQL所影响的行数(如:插入了一行,则影响一行)
int insert(String statement,Object parameter)


namespace+id,插入时所需要的参数,返回SQL所影响的行数
int update(String statement)


namespace+id,返回SQL所影响的行数
int update(String statement,Object parameter)


namespace+id,更新时所需要的参数,返回SQL所影响的行数
int delete(String statement)


namespace+id,返回SQL所影响的行数
int delete(String statement,Object parameter)


namespace+id,删除时所需要的参数,返回SQL所影响的行数
T selectOne(String statement)


namespace+id,返回SQL语句查询结果的泛型对象(本方法只支持一条返回结果)
T selectOne(String statement,Object parameter)


namespace+id,查询时需要的参数,返回SQL语句查询结果的泛型对象(本方法只支持一条返回结果)
List selectList(String statement)


namespace+id,返回SQL语句查询结果的泛型对象的集合
List selectList(String statement,Object parameter)


namespace+id,查询时需要的参数,返回SQL语句查询结果的泛型对象的集合
List selectList(String statement,Object parameter,RowBounds 


rowBounds)
namespace+id,查询时需要的参数,RowBounds对象用于分页,内含有两个属性:offset当前页数,limit当前页显示


多少条数据,返回SQL语句查询结果的泛型对象的集合
Map selectMap(String statement,String mapKey)


namespace+id,返回数据的其中一个列名,返回MAP对象集合
Map selectMap(String statement,Object parameter,String 


mapKey)
namespace+id,查询时需要的参数,返回数据的其中一个列名,返回MAP对象集合
Map selectMap(String statement,Object parameter,String 


mapKey,RowBounds rowBounds)
namespace+id,查询时需要的参数,返回数据的其中一个列名,RowBounds对象用于分页,返回MAP对象集合
void select(String statement,ResultHandler handler)


namespace+id,ResultHandler对象用来处理查询返回复杂的结果集,通常用于多表查询
void select(String statement,Object parameter,ResultHandler handler)


namespace+id,查询时需要的参数,ResultHandler对象用来处理查询返回复杂的结果集,通常用于多表查询
void select(String statement,Object parameter,RowBounds 


rowBounds,ResultHandler handler)
namespace+id,查询时需要的参数,RowBounds对象用于分页,ResultHandler对象用来处理查询返回复杂的结果集


,通常用于多表查询
void commit()


提交事务
void rollback()


回滚事务
void close()


关闭SqlSession对象
Connection getConnection()


获取JDBC的数据库连接对象
T getMapper(Class type)


返回mapper接口的代理对象,该对象关联了SqlSession对象,type是Mapper的接口类型,可通过该方法操作数据库




Mybatis配置文件详解:
Mybatis的配置文件包含了影响Mybatis行为的信息,文档的结构
configuration 顶层配置
settings 设置
properties 属性
typeAliases 类型命名
typeHandlers 类型处理器
objectFactory 对象工厂
plugins 插件
environments 环境
environment 环境变量
transactionManager 事务管理器
dataSource 数据源
property 参数属性
databaseIdProvider 数据库厂商标识
mappers 映射器






settings 设置



参数 描述 有效值


默认值
cacheEnabled 映射器中配置的缓存全局开关 true|false


true
lazyLoadingEnabled 延迟加载全局开关,开则延迟 true|false


false
aggressiveLazyLoading 启用则延迟加载对象完整加载,反之按需加载 true|false


true
multipleResultSetsEnab 是否允许单一语句返回多结果集(需要兼容驱动) true|false


true
useColumnLabel 使用列标签代替列名 true|false


true
useGeneratedKeys 允许JDBC支持自动生成主键(需要驱动兼容) true|false


false
autoMappingBehavior 指定Mybatis应如何自动映射列到字段或属性 NONE取消自动映射|PARTIAL


只会自动映射没有定义映射的结果集|FULL会自动映射复杂的结果集 PARTIAL
autoMappingUnknown ColumnBehavior 找不到Mapping时候 NONE:什么都不做|WARNING输出警告|


FAILING映射失败,抛出SqlSessionException NONE
defaultExecutorType 配置默认的执行器 SIMPLE普通的执行器|REUSE执行器会


重用预处理语句|BATCH执行器将重用语句并执行批量更新 SIMPLE
defaultStatementTimeout 设置超时时间,驱动等待数据库响应秒数 interger


没有设置
defaultFetchSize 默认返回的结果集大小 interger


没有设置
safeRowBoundsEnabled 允许在嵌套语句中使用分页 true|false


false
mapUnderscoreToCameICase 是否开启自动驼峰式命名规则映射 true|false


false
localCacheScope 利用缓存机制,防止循环引用和加上重复嵌套查询 SESSION缓存会话中


执行的所有查询|STATEMENT本地会话仅用在语句执行上,对相同SqlSession的不同调用将不会共享数据


SESSION
jdbcTypeForNull 没有为参数提供特定的JDBC类型时,某些驱动需要指定列的类型


NULL|VARCHAR|OTHER OTHER
lazyLoadTriggerMethods 指定那个对象的方法触发一次延迟加载 方法名的list集合


equals.clone,hashCode,toString
defaultScriptingLanguage 指定动态SQL生成的默认语言 一个类型别名或者


完全限定名 org.apache.ibatis.scripting.xmltagsXMLDynamicLanguageDriver
callSettersOnNulls 指定结果集中值为null时是否调用映射对象的setter  true|false


false
logPrefix 指定MyBatis增加到日志名称的前缀 String


没有设置
logImpl 指定MuBatis所用日志的具体实现,未定义时将自动寻找 SLF4J|


LOG4J|LOG4J2|JDK_LOGGING|COMMONS_LOGGING|STDOUT_LOGGING|NO_LOGGING
proxyFactory 指定MyBatis创建具有延迟加载能力的对象所用到的代理工具 CGLIB|


JAVASSIST JAVASSIST(MyBatis 3.3 or above)






properties 属性(灵活配置)
db.properties的java属性文件
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/mybatis
username=root
password=root

















typeAliases 类型命名(为java类型设置短的名字,存在意义仅用于来减少完全限定名的冗余)
mybatis-config.xml设置后





UserMapper.xml可用





或者注解法:在User.java上注解
@Alias("users")//不写则是user
public class User


mybatis-config.xml中






Mybatis默认的别名
别名 映射的类型
_byte byte
_long long
_short short
_int int
_integer int
_double double
_float float
_boolean boolean
string String
byte Byte
long Long
short Short
int Integer
integer Integer
double Double
float Float
boolean Boolean
date Date
bigdecimal BigDecimal
object Object
map Map
hashmap HashMap
list List
arraylist ArrayList
collection Collection
iterator Iterator








typeHandlers 类型处理器





handler(类型处理器) javaType(java类型) jdbcType(jdbc类型


)
BooleanTypeHandler java.lang.Boolean,boolean 数据库兼容的


Boolean
ByteTypeHandler java.lang.Byte,byte 数据库兼容的


NUMERIC|BYTE
ShortTypeHandler java.lang.Short,short 数据库兼容的


NUMERIC|SHORT INTEGER
IntegerTypeHandler java.lang.Integer,int 数据库兼容的


NUMERIC|INTEGER
LongTypeHandler java.lang.Long,long 数据库兼容的


NUMERIC|LONG INTEGER
FloatTypeHandler java.lang.Float,float 数据库兼容的


NUMERIC|FLOAT
DoubleTypeHandler java.lang.Double,double 数据库兼容的


NUMERIC|DOUBLE
BigDecimalTypeHandler java.math.BigDecimal 数据库兼容的


NUMERIC|DECIMAL
StringTypeHandler java.lang.String CHAR、VARCHAR
ClobReaderTypeHandler java.io.Reader
ClobTypeHandler java.lang.String CLOB、LONGVARCHAR
NStringTypeHandler java.lang.String NVARCHAR、NCHAR
NClobTypeHandler java.lang.String NCLOB
BlobInputStreamTypeHandler java.io.InputStream
ByteArrayTypeHandler byte[] 数据库兼容的字节


流类型
BlobTypeHandler byte[]


BLOB,LONGVARBINARY
DateTypeHandler java.util.Date TIMESTAMP
DateOnlyTypeHandler java.util.Date DATE
TimeOnlyTypeHandler java.util.Date TIME
SqlTimestampTypeHandler java.sql.Timestamp TIMESTAMP
SqlDateTypeHandler java.sql.Date DATE
SqlTimeTypeHandler java.sql.Time TIME
ObjectTypeHandler Any OTHER或未指定类型
EnumTypeHandler Enumeration Type VARCHAR,任何兼容


的字符串类型,存储枚举的名称
EnumOrdinalTypeHandler Enumeration Type 任何兼容的NUMERIC


或DOUBLE类型,存储枚举的索引






objectFactory 对象工厂


//在MyBatis配置文件中配置自定义的对象工厂





public class ZjFactory extends DefaultObjectFactory {
//自定义工厂对象
@Override//处理默认构造方法
public T create(Class type) {
// TODO Auto-generated method stub
return super.create(type);
}
@Override//处理带参的构造方法
public T create(Class type, List> constructorArgTypes,
List constructorArgs) {
// TODO Auto-generated method stub
return super.create(type, constructorArgTypes, constructorArgs);
}
@Override//可以用来配置ObjectFactory
public void setProperties(Properties properties) {
// TODO Auto-generated method stub
super.setProperties(properties);
}
@Override//判断类型
public boolean isCollection(Class type) {
// TODO Auto-generated method stub
return super.isCollection(type);
}
}






environments 环境
environment 环境变量

//默认的default="development" 默认环境一定要匹


配定义的其中一个环境ID
//默认的id="development" 环境ID可随意命名,


建议简介而有意义

//比如,type="JDBC" 有两种类型的事务


管理器JDBC(使用了jdbc提交和回滚设置)、MANAGED(什么都不做,将管理事务交给容器)

//
//
//


//比如,type="POOLED|UNPOOLED|JNDI"













POOLED:利用数据库池,将jdbc链接对象组织起来,避免了创建新的链接和实例时需要的验证等


时间
全部属性:driver 这是JDBC驱动的Java类的完


全限定名
url 这是JDBC的数据库连接URL地



username 登陆数据库的用户名
password 登陆数据库的密码
defaultTransactionIsoIationLevel 默认的链接事务隔离级别
poolMaximumActiveConnections 在任意时间可以存在的活动


链接数量,默认是10
poolMaximumIdleConnections 任意时间可能存在的空闲连


接数
poolMaximumCheckoutTime 在被强制返回之前,池中链接


被检出时间,默认20秒
poolTimeToWait 链接时常超过20s,会给连接


池打印日志,并尝试获取新的链接
poolPingQuery 发送到数据库的侦测查询,用


来检验链接是否正常工作,并准备接受请求
poolPingEnabled 是否启用侦测查询,如开启,


必须使用一个可执行的SQL语句,设置poolPingQuery属性,最好是快的sql语句
poolPingConnectionsNotUsedFor 配置poolPingQuery使用的频


率,上述为true时,默认为0,每一时刻都被侦测

UNPOOLED:每次请求时打开和关闭连接,对性能没有要求的可以使用此
全部属性:driver 这是JDBC驱动的Java类的完


全限定名
url 这是JDBC的数据库连接URL地



username 登陆数据库的用户名
password 登陆数据库的密码
defaultTransactionIsoIationLevel 默认的链接事务隔离级别

JNDI:这个适用于EJB或者应用服务器这类容器中使用
全部属性:initial_context 用来在InitialContext中寻


找上下文
data_source 引用数据源实例位置的上下


文路径,配置了上述,则会在其返回的上下文中寻找,反之则在InitialContext中寻找










mappers 映射器




















深入Mapper XML映射文件
SQL映射文件常用的元素:  select------映射查询语句
insert------映射插入语句
update------映射更新语句
delete------映射删除语句
sql---------可被其他语句引用的可重用语句块
ceche-------给定命名空间的缓存配置
cache-ref---其他命名空间缓存配置的引用
resultMap---最复杂也是最强大的元素,用来描述如何从数据库结果集中加


载对象
parameterMap(已废弃,老式风格的参数映射)


select元素属性描述:
id 引用这条语句所用的唯一标识符号
parameterType 传入参数类的完全限定名或别名,默认是unset(依赖驱动).不配置的情况下


可通过TypeHandler推断出具体传入的语句参数
resultType 返回参数类的完全限定名或别名,如是集合类型,则使用集合包含的类型.还


可以配置resultMap,但不能同时配置
resultMap 外部resultMap的命名引用,结果集映射.返回时还可以配置resultType,但


不能同时配置
flushCache 默认是false,打开则任何语句被调用,都会导致本地缓存或者二级缓存被清



useCache 在select元素当中默认是true,将会导致本条语句的结果被二级缓存
timeout 抛出异常之前等待数据库返回请求结果的秒数,默认unset(依赖驱动)
fechSize 尝试影响返回的结果行数,默认为unset(依赖驱动)
statementType 默认值为:PREPARED(PreparedStatement),还有STATEMENT(Statement)、


CALLABLE(CallableStatement).JDBC的使用方式
resultSetType 结果集的类型,FORWARD_ONLY、SCROLL_SENSITIVE、SCROLL_INSENSITIVE,


默认为unset(依赖驱动)
databaseld 如果配置了databaseidProvider,Mybatis会加载所有的不带databaseid或


匹配当前databaseid的语句,如果带或者不带的都有,则不带的会被忽略
resultOrdered 默认为false,适用于嵌套结果,如果为true,则假设包含了嵌套结果集或是


分组了
resultSets 这个设置对多结果集的情况适用,它将列出语句执行后返回的结果集,并给


每个结果集一个名称,名称用逗号分开


insert、update、delete:大多数元素的属性和select一致,特有属性描述如下:
useGeneratedKeys (insert和update)默认为false,使用JDBC的getGeneratedKeys方法来获取


主键//比如Mysql|SQL Server自动生成主键,则可以useGeneratedKeys=true
keyProperty (insert和update)默认为unset,使用JDBC的getGeneratedKeys方法的返回


值或者通过insert语句的selectKey子元素设置它的键值.希望得到多个生成的列,也可以是逗号分隔的属性名称


列表
KeyColumn (insert和update)通过生成的键值设置表中的列名


Oracle不支持自动生成主键的JDBC驱动来说,可调用下面的方式


select
SEQUENCE_TB_USER.nextval as id from dual

insert into
TB_USER(id,username,password,email,address) values
(#{id}, #{username}, #{password}, #{email}, #{address})



selectKey查找主键的属性:
keyProperty 设置的目标属性,一般设置为id,多列时用逗号隔开id1,id2
keyColumn 匹配属性返回结果集中的列名称,多列则逗号分开
resultType 结果的类型,多列则可以使用一个包含期望属性的Object或者一个Map
order 可以被设置为BEFORE或者AFTER,如果前者,则首先选择主键,反之首先插入


语句
statementType 默认值为:PREPARED(PreparedStatement),还有STATEMENT(Statement)、


CALLABLE(CallableStatement).JDBC的使用方式




SQL的使用:
select * from tb_user where id='1'





一般会写一个工厂类型:
/** 自己的工厂类型 **/
public class SessionFactorys {
private static SqlSessionFactory sqlSessionFactory = null;
// 初始化创建sessionFactory对象
static {
try {
// 读取mybatis-config.xml配置文件
InputStream inputStream = Resources
.getResourceAsStream("mybatis-config.xml");
sqlSessionFactory = new SqlSessionFactoryBuilder()
.build(inputStream);
} catch (Exception e) {
// TODO: handle exception
System.out.println("创建会话工厂失败");
}
}
// 获取SqlSession对象的静态方法
public static SqlSession getSqlSession() {
return sqlSessionFactory.openSession();
}
// 获取SqlSessionFactory静态方法
public static SqlSessionFactory getSqlSessionFactory() {
return sqlSessionFactory;
}
// 获取session,并关闭
public static void close(SqlSession session) {
// TODO Auto-generated method stub
session.commit();
session.close();
System.out.println("已关闭");
}
}//可利用此增删改查






ResultMaps:告诉Mybatis将从结果集中取出的数据转换成开发者所需要的对象
创建俩张表
create table tb_clazz(
id int primary key auto_increment,
code varchar(18)
)
insert into tb_clazz(code) values('1');
insert into tb_clazz(code) values('2');


create table tb_student(
id int primary key auto_increment,
name varchar(18),
sex char(3),
age int,
clazz_id int,
foreign key (clazz_id) references tb_clazz(id)
);
例一、map类型


xml



java
List> usersUser = session
.selectList("anlemusic.cn.mapper.UserMapper.sele");
for (Map map : usersUser) {
System.out.println(map);
}
结果:
{id=1, sex=2, age=26, name=admin}
{id=2, sex=2, age=26, name=admin}
{id=3, sex=2, age=26, name=admin}
{id=4, sex=2, age=26, name=admin}
{id=5, sex=2, age=26, name=admin}
{id=6, sex=2, age=26, name=admin}


例二、一般不建议用map集合,下面使用resultMap试试,还有更复杂的情况
create table tb_user(
user_id INT PRIMARY KEY AUTO_INCREMENT,
user_name varchar(12),
user_ses varchar(12),
user_age int
)
List usersUser = session
.selectList("anlemusic.cn.mapper.UserMapper.sele");
for (User user : usersUser) {
System.out.println(user.toString());
}











例三、多表查询,返回的对象不一致
前言
association元素属性如下:
column 表示数据库表的列名,一般为外键
property 返回类型的Student的属性名clazz
javaType java代表的类型,如anlemusic.cn.domain.User
select 表示执行一条查询语句,将查询到的语句,封装到property中去


collection元素属性如下:
property 返回类型Clazzs的属性名Student
javaType 该属性对应的类型名称,ArrayList
ofType 表示集合当中的类型,Students
column 使用id作为参数进行之后的select语句
select 表示执行一条查询语句,将查询到的语句,封装到property中去


第一步:xml









select="selectClazzWithId" />






第二步:java
Clazz.java
private Integer id;
private String code;
Student.java
private Integer id;
private String name;
private String sex;
private Integer age;
private Clazz clazz;
Tests.java
SqlSession session = SessionFactorys.getSqlSession();
List students = session
.selectList("anlemusic.cn.mapper.UserMapper.selectStudent");
for (Student student : students) {
System.out.println(student);
}
查询后
Student [id=1, name=name, sex=2, age=18, clazz=Clazz [id=1, code=1536]]
Student [id=2, name=name, sex=2, age=18, clazz=Clazz [id=2, code=1535]]
Student [id=3, name=name, sex=2, age=18, clazz=Clazz [id=1, code=1536]]
Student [id=4, name=name, sex=2, age=18, clazz=Clazz [id=2, code=1535]]


反过来,如果查询一个班级的人数呢?
第一步:xml



ofType="students" select="selectstudentWithId" />









第二步:java
Students.java
private Integer id;
private String name;
private String sex;


Clazzs.java
private Integer id;
private String code;
private List student;
private Integer age;
Tests.java
List students = session
.selectList("anlemusic.cn.mapper.UserMapper.selectStudent");
for (Clazzs student : students) {
System.out.println(student);
}
查询后
Clazzs [id=1, code=1536, students=[Students [id=1, name=name, sex=2, age=18], Students [id=3, 


name=name, sex=2, age=18]]]
Clazzs [id=2, code=1535, students=[Students [id=2, name=name, sex=2, age=18], Students [id=4, 


name=name, sex=2, age=18]]]
Clazzs [id=3, code=1534, students=[]]
Clazzs [id=4, code=1533, students=[]]










*************************************************一对一关联


*************************************************
首先创建两个表:人和身份证号
create table tb_card(
id int primary key auto_increment,
code varchar(18)
);
insert into tb_card values(null,'421125199702020311');
create table tb_person(
id int primary key auto_increment,
name varchar(18),
sex char(18),
age int,
card_id int unique,
foreign key (card_id) references tb_card(id)
);
insert into tb_person values('javk','男',23,1);




CardMappers.xml








PersonMappers.xml








select="anlemusic.cn.mapper.CardMappers.selectCardById" />




PersonMappers接口
public interface PersonMappers {
/**
* 根据id查询Person 方法名和参数必须和xml文件中的id和parameterType属性一致

* @param id
* @return Person对象
* **/
Person selectPersonById(Integer id);
}


Test.java
PersonMappers per = session.getMapper(PersonMappers.class);
Person pers = per.selectPersonById(2);
System.out.println(pers);
System.out.println(pers.getCard());


Person [id=2, name=javks, sex=nv, age=23, card_id=null, card=Card [id=2, 


code=421125199702020312]]
Card [id=2, code=421125199702020312]






*************************************************一对多关联|多对一关联


*************************************************
首先创建两个表学生和班级,多个学生对于一个班级,一个班级对应多个学生,都是一对多的关系
create table tb_clazz(
id int primary key auto_increment,
code varchar(18),
name varchar(18)
);
insert into tb_clazz(code,name) values('1','1536');
insert into tb_clazz(code,name) values('2','1535');


create table tb_student(
id int primary key auto_increment,
name varchar(18),
sex char(13),
age int,
clazz_id int,
foreign key (clazz_id) references tb_clazz(id)
);
insert into tb_student values(null,'name','2',18,1);


因为本实例需要懒加载,故除了Mybatis还需要添加两个包:cglib-2.2.2.jar、asm-3.3.1.jar
mybatis-config.xml中









Student.java
private Integer id;
private String name;
private String sex;
private Integer age;
private Clazz clazzs;


Clazz.java
private Integer id;
private String code;
private String name;
private List students;//以上tostring皆无需带形参(clazzs|students)


UserMapper.xml中








ofType="student" 


select="anlemusic.cn.mapper.StudentMapper.selectStudentByClazzId"
fetchType="lazy">







对应的接口java
public interface UserMapper {
/**
* 根据id查询班级信息
* **/
Clazz selectClazzById(Integer id);
}
StudentMappers.xml中





















对应的接口java
public interface StudentMapper {
/**
* 根据id查询学生信息
* **/
Student selectStudentById(Integer id);
}


Test.java中
UserMapper userMapper = session.getMapper(UserMapper.class);
Clazz clazz = userMapper.selectClazzById(1);
System.out.println(clazz.toString());
StudentMapper studentMapper = session.getMapper(StudentMapper.class);
Student student = studentMapper.selectStudentById(1);
System.out.println(student.toString());
Clazz [id=1, code=1, name=1536, students=[Student [id=1, name=name, sex=2, age=18, clazz=Clazz 


[id=1, code=null, name=name, students=null]], Student [id=3, name=name, sex=2, age=1, clazz=Clazz 


[id=3, code=null, name=name, students=null]], Student [id=4, name=name, sex=2, age=12, 


clazz=Clazz [id=4, code=null, name=name, students=null]]]]
Student [id=1, name=1536, sex=2, age=18, clazz=Clazz [id=1, code=1, name=1536, students=null]]










*************************************************多对多关联


*************************************************
因为本实例需要懒加载,故除了Mybatis还需要添加两个包:cglib-2.2.2.jar、asm-3.3.1.jar
首先创建三张表:用户、商品、订单;还有中间表一张
create table tb_user(
id int primary key auto_increment,
username varchar(18),
loginname varchar(19),
password varchar(18),
phone varchar(18),
address varchar(18)
);


create table tb_article(
id int primary key auto_increment,
name varchar(18),
price double,
remark varchar(18)
);


create table tb_order(
id int primary key auto_increment,
code varchar(32),
total double,
user_id int,
foreign key (user_id) references tb_user(id)
);


create table tb_item(
order_id int,
article_id int,
amount int,
primary key (order_id,article_id),
foreign key (order_id) references tb_order(id),
foreign key (article_id) references tb_article(id)
);


插入信息


UserMapper.xml











ofType="order" 


select="anlemusic.cn.mapper.OrderMapper.selectOrderByUserId"
fetchType="lazy">









public interface UserMapper {
User selectUserById(Integer id);
}


private Integer id;// id
private String username;// 用户名
private String loginname;// 登陆名
private String password;// 密码
private String phone;// 电话
private String address;// 收货地址
private List orders;// 用户与订单为一对多的关系


OrderMapper.xml
















ofType="article" 


select="anlemusic.cn.mapper.ArticleMapper.selectArticleByOrderId"
fetchType="lazy">











public interface OrderMapper {
Order selectOrderById(Integer id);
}


private Integer id;// id
private String code;// 订单编号
private Double total;// 订单总金额、
private User user;// 订单与用户为一对一的关系
private List
articles;// 订单和商品是多对多,一个订单可以对应多个


ArticleMapper.xml






private Integer id;// 商品id,主键
private String name;// 商品名称
private Double price;// 商品价格
private String remark;// 商品描述
private List orders;// 商品和订单的关系,多对多


Test.java
OrderMapper orderMapper = session.getMapper(OrderMapper.class);
Order order = orderMapper.selectOrderById(1);
System.out.println(order);
UserMapper userMapper = session.getMapper(UserMapper.class);
User user = userMapper.selectUserById(1);
System.out.println(user);






##########################################动态SQL包含的元素:if、choose(when、otherwise)、where、


set、foreach、bind##########################################
条件判断、情况判断、与where关键词相关的查找语句、set主要用于多判断更新、循环查找、创建变量绑定到


上下文
create table tb_employee(
id int(11) PRIMARY key auto_increment,
loginname varchar(18),
password varchar(18),
name varchar(18) default null,
sex char(2) default null,
age int(11) default null,
phone varchar(21),
sal double,
state varchar(18)
);



##########################################if##########################################
xml

resultType="employee">
select * from tb_employee where state = '32'



and id = #{id}


and loginname=#{loginname} and password =#{password}


and sex='s'






##########################################where##########################################








##########################################set##########################################
接口方法
void updateEmployeeIfNecessary(Employee employee);
一般方法
EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
Employee employee = new Employee(1, "l", "p", "n", "s", 3, "21", 3.2,
"s");
employeeMapper.updateEmployeeIfNecessary(employee);

update tb_employee


loginname=#{loginname},
password=#{password},
name=#{name},
sex=#{sex},
phone=#{phone},
sal=#{sal},
state=#{state},

where id = #{id}








##########################################foreach##########################################
接口方法
List selectEmployeeIn(List list);
一般方法
EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
List ids= new ArrayList();
ids.add(1);ids.add(3);
List employees = employeeMapper.selectEmployeeIn(ids);
for (Employee employee : employees) {
System.out.println(employee);
}









##########################################bind##########################################
接口方法
List selectEmployeeLikeName(Employee employee);
一般方法
EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
Employee employee = new Employee();
employee.setLoginname("o");
List employees = employeeMapper.selectEmployeeLikeName(employee);
for (Employee employeess : employees) {
System.out.println(employeess);
}














Mybatis缓存机制:一级缓存(SqlSession级别的缓存,同SqlSession中数据共享)、二级缓存(mapper级别的缓存,


多个SqlSession数据共享)


一级缓存是Session级别的缓存(默认开启)示例如下:
UsersMapper.xml






UsersMapper.java
public interface UsersMapper {
User selectUserById(Integer id);
}




UsersMapper usersMapper = session.getMapper(UsersMapper.class);
User user = usersMapper.selectUserById(1);
System.out.println(user.toString());
User users = usersMapper.selectUserById(1);
System.out.println(users.toString());
仅仅查询了一次
==>  Preparing: select * from tb_user where id=? 
[DEBUG]2017年-12月-17日  18:22:28,807  位置:org.apache.ibatis.logging.jdbc.BaseJdbcLogger.debug


(BaseJdbcLogger.java:139)
==> Parameters: 1(Integer)
[DEBUG]2017年-12月-17日  18:22:28,823  位置:org.apache.ibatis.logging.jdbc.BaseJdbcLogger.debug


(BaseJdbcLogger.java:139)
<==      Total: 1
User [id=1, username=javk, loginname=java, password=123456, phone=12321231231, address=guangz, 


orders=null]
User [id=1, username=javk, loginname=java, password=123456, phone=12321231231, address=guangz, 


orders=null]
换成2后,查询了两次
==>  Preparing: select * from tb_user where id=? 
[DEBUG]2017年-12月-17日  18:22:52,987  位置:org.apache.ibatis.logging.jdbc.BaseJdbcLogger.debug


(BaseJdbcLogger.java:139)
==> Parameters: 1(Integer)
[DEBUG]2017年-12月-17日  18:22:53,002  位置:org.apache.ibatis.logging.jdbc.BaseJdbcLogger.debug


(BaseJdbcLogger.java:139)
<==      Total: 1
User [id=1, username=javk, loginname=java, password=123456, phone=12321231231, address=guangz, 


orders=null]
[DEBUG]2017年-12月-17日  18:22:53,003  位置:org.apache.ibatis.logging.jdbc.BaseJdbcLogger.debug


(BaseJdbcLogger.java:139)
==>  Preparing: select * from tb_user where id=? 
[DEBUG]2017年-12月-17日  18:22:53,004  位置:org.apache.ibatis.logging.jdbc.BaseJdbcLogger.debug


(BaseJdbcLogger.java:139)
==> Parameters: 2(Integer)
[DEBUG]2017年-12月-17日  18:22:53,004  位置:org.apache.ibatis.logging.jdbc.BaseJdbcLogger.debug


(BaseJdbcLogger.java:139)
<==      Total: 1
User [id=2, username=jk, loginname=jasa, password=123456, phone=12321231231, address=hg, 


orders=null]






二级缓存是mapper级别的缓存(手动开启)示例如下:
mybatis-ehcache-1.0.2.jar
ehcache-core-2.6.5.jar
slf4j-api-1.6.1.jar
导入二级缓存包
mybatis-config.xml




UsersMapper.xml






eviction 收回策略,默认为LRU
LRU(最近最少使用的策略) 移除最长时间不被使用的对象
FIFO(先进先出策略) 按照对象进入缓存的顺序来移除它们
SOFT(软引用策略) 移除基于垃圾回收器状态和软引用规则的对象
WEAK(弱引用策略) 更积极地移除基于垃圾收集器状态和弱引用规则的对象
flushInterval 刷新间隔,单位毫秒
size 缓存条目,可以设置为任意正整数,默认为1024
readOnly 只读,设置为true,只读,设置为false,可读写,默认为false


还需要让映射的java对象实现java.io.Serializable接口的序列化和反序列化操作(不论父类或子类)
public class User implements Serializable


public interface UsersMapper extends Serializable{
User selectUserById(Integer id);


void deleteUserById(Integer id);
}







delete from tb_user
where id = #{id}




SqlSession session = SessionFactorys.getSqlSession();
UsersMapper usersMapper = session.getMapper(UsersMapper.class);
User user = usersMapper.selectUserById(1);
System.out.println(user);
usersMapper.deleteUserById(2);
// commit提交
session.commit();
// 删除再查询
User users = usersMapper.selectUserById(1);
System.out.println(users);
SessionFactorys.close(session);//还可以不同session共享数据












###############################################Mybatis注解


###############################################
常用的Annotation注解:
使用注解时,一定要对应操作,否则select和其他操作的注解执行方法不一样
Select 映射查询的SQL语句
SelectProvider Select语句的动态映射,允许指定一个类名和一个方法在


执行时返回运行的查询语句.参数:type类的完全限定名称、method该类的方法名
Insert 映射插入的SQL语句
InsertProvider Insert语句的动态映射,允许指定一个类名和一个方法在


执行时返回运行的查询语句.参数:type类的完全限定名称、method该类的方法名
Update 映射更新的SQL语句
UpdateProvider Update语句的动态映射,允许指定一个类名和一个方法在


执行时返回运行的查询语句.参数:type类的完全限定名称、method该类的方法名
Delete 映射删除的SQL语句
DeleteProvider Delete语句的动态映射,允许指定一个类名和一个方法在


执行时返回运行的查询语句.参数:type类的完全限定名称、method该类的方法名
Result 列和属性上的单独映射.参数:id(布尔值,是否被用于主


键映射)、column、property、javaType、jdbcType、typeHandler、one(单独的联系,和association相似)、


many(对集合而言,和collection相似)
Results 多个结果映射(Result)列表
Options 附加配置选项,参数:
boolean useCache()、
boolean flushCache()、
ResultSetType resultSetType()、
StatementType statementType()、
int fetchSize()、
int timeout()、
boolean useGeneratedKeys()、
String keyProperty()、String keyColumn();
One 复杂类型的单独属性值映射,必须指定select属性,表示


已映射的SQL语句的完全限定名称
Many 复杂类型的单独属性值映射,必须指定select属性,表示


已映射的SQL语句的完全限定名称
Param 当映射器需要多个参数时,这个注解可以被应用于映射器


方法参数来给每个参数取一个名字,@Param("id")代表#{id}






增删改查实例:
第一步,映射接口或包名

//需添加


javassist-3.17.1-GA.jar


第二步,书写接口类
public interface UsersMapper {
/** 查询 **/
@Select("select * from tb_user where id=#{id}")
@Results({ @Result(id = true, column = "id", property = "id"),
@Result(column = "username", property = "username"),
@Result(column = "loginname", property = "loginname"),
@Result(column = "password", property = "password"),
@Result(column = "phone", property = "phone"),
@Result(column = "address", property = "address") })
User selectUserById(@Param("id") Integer id);


/** 删除 **/
@Delete("delete from tb_user where id = #{id}")
int deleteUserById(@Param("id") Integer id);


/** 查询全部 **/
@Select("select * from tb_user")
List selectAllUser();


/** 增加 **/
@Insert("insert into tb_user values(#{id},#{username},#{loginname},#{password},#


{phone},#{address})")
@Options(useGeneratedKeys = true, keyProperty = "#id")
int saveUser(User user);


/** 改 **/
@Update("update tb_user set username=#{username},loginname=#{loginname},password=#


{password},phone=#{phone},address=#{address} where id=#{id}")
int modifyUser(User user);
}


第三步,实行增删改查
UsersMapper usersMapper = session.getMapper(UsersMapper.class);
//增加
User user = new User(null, "usernames", "用户名", "密码",
"电话号码", "手机号码");
System.out.println(usersMapper.saveUser(user));
//删除
usersMapper.deleteUserById(3);
//改
User s = new User(1, "用户名", "登陆名", "密码", "电话", "收获地址");
usersMapper.modifyUser(s);
//查
System.out.println(usersMapper.selectUserById(1));
List ss = new ArrayList();
ss = usersMapper.selectAllUser();
for (User user2 : ss) {
System.out.println(user2);
}
==>  Preparing: insert into tb_user values(?,?,?,?,?,?) 
<==    Updates: 1
==>  Preparing: delete from tb_user where id = ? 
<==    Updates: 1
==>  Preparing: update tb_user set username=?,loginname=?,password=?,phone=?,address=? where id=? 
<==    Updates: 1
==>  Preparing: select * from tb_user where id=? 
User [id=1, username=用户名, loginname=登陆名, password=密码, phone=电话, address=收获地址]
==>  Preparing: select * from tb_user 
User [id=1, username=用户名, loginname=登陆名, password=密码, phone=电话, address=收获地址]
User [id=2, username=usernames, loginname=loginname, password=password, phone=dianhua, 


address=shouhdiz]
User [id=4, username=usernames, loginname=用户名, password=密码, phone=电话号码, address=手机号码


]




%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%注解法一对一%%%%%%%%%%%%%%%%%%%%%%%%


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
mybatis-config.xml




Person.java映射类
public class Person {
private Integer id;
private String name;
private String sex;
private Integer age;
private Card card;
}
Card.java映射类
public class Card {
private Integer id;
private String code;
}
PersonMapper.java接口类
public interface PersonMapper {
/** 根据id查询 **/
@Select("select * from tb_person where id = #{id}")
@Results({
@Result(id = true, column = "id", property = "id"),
@Result(column = "name", property = "name"),
@Result(column = "sex", property = "sex"),
@Result(column = "age", property = "age"),
@Result(column = "card_id", property = "card", one = @One(select = 


"anlemusic.cn.mapper.CardMapper.selectCardById", fetchType = FetchType.EAGER))
})//列名称,映射类名称,对一查询地址带上接口+方法名,是否延迟加载
Person selectPersonById(Integer id);
}
CardMapper.java接口类
package anlemusic.cn.mapper;
import org.apache.ibatis.annotations.Select;
import anlemusic.cn.domain.Card;
public interface CardMapper {
/** 根据id查询card的参数 **/
@Select("select * from tb_card where id = #{id}")
Card selectCardById(Integer id);
}
Tests测试类
PersonMapper personMapper = session.getMapper(PersonMapper.class);
Person person = personMapper.selectPersonById(1);
System.out.println(person);
破旧的控制台
Person [id=1, name=javk, sex=nan, age=23, card=Card [id=1, code=421125199702020311]]




%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%注解法一对多%%%%%%%%%%%%%%%%%%%%%%%%


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Student.java映射类
public class Student{
private Integer id;
private String name;
private String sex;
private Integer age;
private Clazz clazzs;
}
Clazz.java映射类
public class Clazz{
private Integer id;
private String code;
private String name;
private List students;
}


StudentMapper.java接口类
public interface StudentMapper {
/** 根据班级id查询所有班级学生 **/
@Select("select * from tb_student where clazz_id = #{id}")
@Results({ @Result(id = true, column = "id", property = "id"),
@Result(column = "name", property = "name"),
@Result(column = "sex", property = "sex"),
@Result(column = "age", property = "age"), })
List selectClazzById(Integer id);
}
ClazzMapper.java接口类
public interface ClazzMapper {
/** 根据id查询班级信息 **/
@Select("select * from tb_clazz where id = #{id}")
@Results({
@Result(id = true, column = "id", property = "id"),
@Result(column = "code", property = "code"),
@Result(column = "name", property = "name"),
@Result(column = "id", property = "students", many = @Many(select = 


"anlemusic.cn.mapper.StudentMapper.selectClazzById", fetchType = FetchType.LAZY)) })
Clazz selectById(Integer id);
}


Tests测试类
ClazzMapper clazzMapper = session.getMapper(ClazzMapper.class);
Clazz clazz = clazzMapper.selectById(1);
System.out.println(clazz);
List student = clazz.getStudents();
for (Student student2 : student) {
System.out.println(student2);
}
破旧的控制台
Clazz [id=1, code=1, name=1536]
Student [id=1, name=name, sex=2, age=18, clazzs=null]
Student [id=3, name=name, sex=2, age=1, clazzs=null]
Student [id=4, name=name, sex=2, age=12, clazzs=null]






%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%注解法多对多%%%%%%%%%%%%%%%%%%%%%%%%


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
/** 这是一个用户类 **/
public class User implements Serializable {
private static final long serialVersionUID = -5662130226863639970L;
private Integer id;// id
private String username;// 用户名
private String loginname;// 登陆名
private String password;// 密码
private String phone;// 电话
private String address;// 收货地址
}


/** 这是一个订单表 **/
public class Order implements Serializable {
private static final long serialVersionUID = 7703472760206539047L;
private Integer id;// id
private String code;// 订单编号
private Double total;// 订单总金额、
private User user;// 订单与用户为一对一的关系
private List
articles;// 订单和商品是多对多,一个订单可以对应多个
}


/** 这是一个商品的表 **/
public class Article implements Serializable {
private static final long serialVersionUID = 8726800702685715564L;
private Integer id;// 商品id,主键
private String name;// 商品名称
private Double price;// 商品价格
private String remark;// 商品描述
private List orders;// 商品和订单的关系,多对多
}


public interface OrderMapper {
/** 根据商品id查询商品 **/
@Select("select * from tb_order where id = #{id}")
@Results({ @Result(id = true, column = "id", property = "id"),
@Result(column = "code", property = "code"),
@Result(column = "total", property = "total"),
@Result(column = "user_id", property = "user",one=@One


(select="anlemusic.cn.mapper.UserMapper.selectUserById",fetchType=FetchType.EAGER)),
@Result(column = "id", property = "articles",many=@Many


(select="anlemusic.cn.mapper.ArticleMapper.selectByOrderId",fetchType=FetchType.LAZY)) })
Order selectOrderById(Integer id);
}


public interface UserMapper {
/**根据用户id查询用户**/
@Select("select * from tb_user where id = #{id}")
User selectUserById(Integer id);


}


public interface ArticleMapper {
/** 根据订单id查询多个商品 **/
@Select("select * from tb_article where id in(select article_id from tb_item where 


order_id = #{id})")
List
selectByOrderId(Integer id);
}


OrderMapper orderMapper = session.getMapper(OrderMapper.class);
Order order = orderMapper.selectOrderById(1);
System.out.println(order);
List
student = order.getArticles();
for (Article student2 : student) {
System.out.println(student2);
}


Order [id=1, code=bhbhbhbh, total=122.3, 用户为=User [id=1, username=用户名, loginname=登陆名, 


password=密码, phone=电话, address=收获地址], articles=[Article [id=1, name=javk, price=12.3, 


remark=guangz, orders=null], Article [id=2, name=javk, price=15.3, remark=gwe, orders=null], 


Article [id=3, name=javk, price=11.3, remark=gwe, orders=null]]]
Article [id=1, name=javk, price=12.3, remark=guangz, orders=null]
Article [id=2, name=javk, price=15.3, remark=gwe, orders=null]
Article [id=3, name=javk, price=11.3, remark=gwe, orders=null]




%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%注解法动态SQL%%%%%%%%%%%%%%%%%%%%%%%


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SelectProvider、InsertProvider、UpdateProvider、DeleteProvider来帮助我们构建动态SQL语句,Mybatis提


供了一个SQL工具类org.apache.ibatis.jdbc.SQL
该类不使用字符串拼接的方式,并会以适合的空格前缀和后缀来构造SQL语句,该类常用方法如下:


public T SELECT(String columns) 开始或追加select子句,通常是逗号分


隔的列表的列
public T FROM(String table) 启动或追加from子句,通常是表名
public T JOIN(String join) 向join添加一个新的查询条件,通常为


表,也包括连接返回的结果集
public T INNER_JOIN(String join) 同JOIN,连接方式是内链接
public T LEFT_OUTER_JOIN(String join) 同JOIN,链接方式是左外连接
public T RIGHT_OUTER_JOIN(String join) 同JOIN,链接方式是右外连接
public T WHERE(String conditions) 追加一个新的where子句条件,可以多


次调用
public T OR() 使用or拆分当前where子句条件,可多


次调用
public T AND() 使用and拆分当前where子句条件,可多


次调用
public T GROUP_BY(String columns) 追加一个新的Group by子句元素
public T HAVING(String conditions) 追加一个新的Having字句条件
public T ORDER_BY(String columns) 追加一个ORDER BY子句元素
public T INSERT_INTO(String tableName) 启动insert语句插入到指定表
public T VALUES(String columns, String values) 追加的insert语句,第一个参数是要插


入的列,第二个参数是要插入的值
public T DELETE_FROM(String table) 启动DELETE语句,并制定表删除
public T UPDATE(String table) 启动一个更新语句,并指定表更新
public T SET(String sets) 追加一个更新语句set列表


实例:动态SQL查询
public class Employee implements Serializable{
private static final long serialVersionUID = 5487271870862334461L;
private Integer id;
private String loginname;
private String password;
private String name;
private String sex;
private Integer age;
private String phone;
private Double sal;
private String state;
}


public interface EmployeeMapper {
/** 动态查询,拼接的类+方法名称 **/
@SelectProvider(type=EmployeeDynaSqlProvider.class,method="selectWhitParam")
List selectWhitParam(Map param);
}


public class EmployeeDynaSqlProvider {
public String selectWhitParam(final Map param) {
// TODO Auto-generated method stub
return new SQL() {
{
SELECT("*");
FROM("tb_employee");
if (param.get("id") != null) {
WHERE("id=#{id}");
}
if (param.get("loginname") != null) {
WHERE("loginname=#{loginname}");
}
if (param.get("password") != null) {
WHERE("password=#{password}");
}
if (param.get("name") != null) {
WHERE("name=#{name}");
}
if (param.get("sex") != null) {
WHERE("sex=#{sex}");
}
if (param.get("age") != null) {
WHERE("age=#{age}");
}
if (param.get("phone") != null) {
WHERE("phone=#{phone}");
}
if (param.get("sal") != null) {
WHERE("sal=#{sal}");
}
if (param.get("state") != null) {
WHERE("state=#{state}");
}
}
}.toString();
}
}


EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
Map param = new HashMap();
param.put("state", "s");
List list = employeeMapper.selectWhitParam(param);
for (Employee employee : list) {
System.out.println(employee);
}

Employee [id=1, loginname=l, password=p, name=n, sex=s, age=12, phone=21, sal=3.2, state=s]
注释param.put("state", "s");后
Employee [id=1, loginname=l, password=p, name=n, sex=s, age=12, phone=21, sal=3.2, state=s]
Employee [id=2, loginname=loginname, password=password, name=name, sex=s, age=12, phone=122122, 


sal=23.0, state=32]
Employee [id=3, loginname=loginname, password=password, name=name, sex=s, age=12, phone=12212, 


sal=3.0, state=3]


也可以用Employee传递参数,改一下三个地方即可
Employee employee = new Employee(null, null, null, null, null, null,null, null, "s");
List list = employeeMapper.selectWhitParams(employee);


@SelectProvider(type = EmployeeDynaSqlProvider.class, method = "selectWhitParams")
List selectWhitParams(Employee employee);


if (employee.getId() != null) {WHERE("id=#{id}");}


实例:动态SQL插入
public String insertWhitParam(final Employee employee) {
// TODO Auto-generated method stub
return new SQL() {
{
INSERT_INTO("tb_employee");
if (employee.getLoginname() != null) {
VALUES("loginname", "#{loginname}");
}
if (employee.getPassword() != null) {
VALUES("password", "#{password}");
}
if (employee.getName() != null) {
VALUES("name", "#{name}");
}
if (employee.getSex() != null) {
VALUES("sex", "#{sex}");
}
if (employee.getAge() != null) {
VALUES("age", "#{age}");
}
if (employee.getPhone() != null) {
VALUES("phone", "#{phone}");
}
if (employee.getSal() != null) {
VALUES("sal", "#{sal}");
}
if (employee.getState() != null) {
VALUES("state", "#{state}");
}
}
}.toString();
}




实例:动态SQL更改
{
UPDATE("tb_employee");
if (employee.getLoginname() != null) {
SET("loginname = #{loginname}");
}
if (employee.getPassword() != null) {
SET("password = #{password}");
}
if (employee.getName() != null) {
SET("name = #{name}");
}
if (employee.getSex() != null) {
SET("sex = #{sex}");
}
if (employee.getAge() != null) {
SET("age = {age}");
}
if (employee.getPhone() != null) {
SET("phone = #{phone}");
}
if (employee.getSal() != null) {
SET("sal = #{sal}");
}
if (employee.getState() != null) {
SET("state = #{state}");
}
WHERE(" id = #{id} ");
}
}.toString();


实例:动态SQL删除
return new SQL() {
{
DELETE_FROM("tb_employee");
if (param.get("id") != null) {
WHERE("id=#{id}");
}
if (param.get("loginname") != null) {
WHERE("loginname=#{loginname}");
}
if (param.get("password") != null) {
WHERE("password=#{password}");
}
if (param.get("name") != null) {
WHERE("name=#{name}");
}
if (param.get("sex") != null) {
WHERE("sex=#{sex}");
}
if (param.get("age") != null) {
WHERE("age=#{age}");
}
if (param.get("phone") != null) {
WHERE("phone=#{phone}");
}
if (param.get("sal") != null) {
WHERE("sal=#{sal}");
}
if (param.get("state") != null) {
WHERE("state=#{state}");
}
}
}.toString();






//至此,Mybatis已经完成













你可能感兴趣的:(基础,原创笔记)