框架介绍
框架技术
框架(Framework)
- 是一个应用程序的半成品提供可重用的公共结构
- 按一定规则组织的一组组件
分析优势
- 不用再考虑公共问题
- 专心在业务实现上
- 结构统一,易于学习、维护
- 新手也可写出好程序
主流框架
Struts
- MVC 设计模式的实现
- 拦截器
- 可变和可重用的标签
HIBERNATE
- ORM,简化数据库操作
- DAO 层
Spring
- 依赖注入容器 /AOP 实现
- 声明式事务
- 简化 JavaEE 应用黏合剂,将大家组装到一起
Spring MVC
- 结构最清晰的 MVC Model2 实现
- 高度可配置,支持多种视图技术
- 定制化开发
MyBatis
- 半自动化的 ORM 实现
- DAO 层
- 动态 SQL
- 小巧灵活、简单易学
持久化与ORM
- 持久化:程序数据在瞬时状态和持久状态间转换的过程
ORM(Object Relational Mapping):对象-关系映射
- ?编写程序的时候,以面向对象的方式处理数据
- ?保存数据的时候,却以关系型数据库的方式存储
ORM 解决方案包含下面四个部分
- ?在持久化对象上执行基本的增、删、改、查操作对持久化对象提供一种查询语言或者 API
- ?对象关系映射工具
- ?提供与事务对象交互、执行检查、延迟加载以及其他优化功能
MyBatis
MyBatis 简介
- MyBatis 前身是 iBatis,本是 Apache 的一个开源的项目
官方网站
- ORM 框架
- 实体类和 SQL 语句之间建立映射关系
特点
- ?基于 SQL 语法,简单易学
- ?能了解底层封装过程
- ?SQL 语句封装在配置文件中,便于统一管理与维护,降低程序的耦合度
- ?方便程序代码调试
搭建 MyBatis 框架
- 使用 MyBatis 的开发步骤
- 下载
mybatis-3.2.2.jar
包并导入工程 - 编写 MyBatis 核心配置文件(
configuration.xml
) - 创建实体类:POJO
- DAO层—SQL映射文件(
mapper.xml
) 创建测试类
- ?读取全局(核心)配置文件
mybatis-config.xml
- ?创建
SqlSessionFactory
对象,读取配置文件 - ?创建
SqlSession
对象 - ?调用
mapper
文件进行数据操作
- ?读取全局(核心)配置文件
编写核心配置文件
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> <!-- 引入database.properties文件 --> <properties resource="database.properties"/> <settings> <setting name="logImpl" value="LOG4J"/> </settings> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"></transactionManager> <dataSource type="POOLED"> <property name="driver" value="${driver}"/> <property name="url" value="${url}"/> <property name="username" value="${user}"/> <property name="password" value="${password}"/> </dataSource> </environment> </environments> <!-- 将mapper文件加入到配置文件中 --> <mappers> <mapper resource="cn/linyer/dao/user/UserMapper.xml"/> </mappers> </configuration>
编写 SQL 映射文件
<?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="cn.linyer.dao.user.UserMapper">
<!--查询用户表的记录数-->
<select id="count" resultType="int">
select count(1) as count from users
</select>
</mapper>
编写 JUnit 测试类
package cn.linyer.dao.user;
import java.io.IOException;
import java.io.InputStream;
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 org.apache.log4j.Logger;
import org.junit.Before;
import org.junit.Test;
public class UserMapperTest {
private Logger logger = Logger.getLogger(UserMapperTest.class);
@Before
public void setUp() throws Exception {
}
@Test
public void test() {
String resource="MyBatis-config.xml";
int count=0;
SqlSession sqlSession=null;
try {
//1 获取mybatis-config.xml的输入流
InputStream is = Resources.getResourceAsStream(resource);
//2 创建Sq1SessionFactory
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
//3 创建sqlSession
sqlSession = factory.openSession();
//4 调用mapper文件来对数据进行操作,必须将mapper文件引入到mybatis-config.xml中
count = sqlSession.selectOne("cn.linyer.dao.user.UserMapper.count");
logger.debug("UserMapperTest count---->"+count);
} catch (IOException e) {
e.printStackTrace();
} finally {
sqlSession.close();
}
}
}
MyBatis 与 JDBC 对比
JDBC
Class.forName("com. mysql. jdbc. Driver"); Connection connection = DriverManager.getConnection(url, user, password); String sql = "select count(*) as count from smbms_user"; Statement st = connection.createStatement(); Resultset rs = st.executeQuery(sql); if(rs.next()){ int count = rs.getInt("count"); }
MyBatis
<mapper namespace="cn.linyer.dao.user.UserMapper"> <select id="count" resultType="int"> select count(1) as count from smbms_user </select> </mapper>
优点
- ?与 JDBC 相比,减少了 50% 以上的代码量
- ?最简单的持久化框架、小巧并简单易学
- ?SQL 代码从程序代码中彻底分离,可重用
- ?提供XML标签,支持编写动态 SQL
- ?提供映射标签,支持对象与数据库的 ORM 字段关系映射
缺点
- ?SQL语句编写工作量大,对开发人员有一定要求
- ?数据库移植性差
- MyBatis 专注于 SQL 本身,是一个足够灵活的 DAO 层解决方案
- 适用于性能要求较高或者需求多变的互联网项目
MyBatis 基本要素
MyBatis 的核心接口和类
- ?
SqlSessionFactoryBuilder
- ?
SqlSessionFactory
?
SqlSession
mybatis-config.xml
系统核心配置文件
- ?
mapper.xml
SQL映射文件
核心对象
[SqlSessionFactoryBuilder] --> |build方法| --> [SqlSessionFactory] --> |openSession方法| --> SqlSession]
SqlSessionFactoryBuilder
- ?用过即丢,其生命周期只存在于方法体内
- ?可重用其来创建多个
SqlSessionFactory
实例 ?负责构建
SqlSessionFactory
,并提供多个build
方法的重载build(InputStream inputStream,String environment,Properties properties) build(Reader reader,String environment,Properties properties) build(Configuration config)
配置信息以三种形式提供给
SqlSessionFactory
的 build 方法:- ?
InputStream
(字节流) - ?
Reader
(字符流) - ?
Configuration
(类)
- ?
读取XML文件构造方式:
String resource = "mybatis-config.xml"; InputStream is = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
SqlSessionFactory
- ?
SqlSessionFactory
是每个 MyBatis 应用的核心 ?作用:创建
SqlSession
实例SqlSession session = sqlSessionFactory.openSession(boolean autoCommit);
autoCommit
:true
:关闭事务控制(默认)false
:开启事务控制- ?作用域:Application
- ?生命周期与应用的生命周期相同
?单例
- ?存在于整个应用运行时,并且同时只存在一个对象实例
- ?
工具类
- 静态代码块,以保证
SqlSessionFactory
只被创建一次 创建
MyBatisUtils.java
package cn.linyer.utils; import java.io.IOException; import java.io.InputStream; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; public class MyBatisUtils { private static SqlSessionFactory factory; static { try { InputStream is = Resources.getResourceAsStream("MyBatis-config.xml"); factory = new SqlSessionFactoryBuilder().build(is); } catch (IOException e) { e.printStackTrace(); } } public static SqlSession createSqlSession() { return factory.openSession(false); } public static void closeSqlSession(SqlSession sqlSession) { if(null != sqlSession) { sqlSession.clearCache(); } } }
测试类
package cn.linyer.dao.user; import org.apache.ibatis.session.SqlSession; import org.apache.log4j.Logger; import org.junit.Before; import org.junit.Test; import cn.linyer.utils.MyBatisUtils; public class UserMapperTest { private Logger logger = Logger.getLogger(UserMapperTest.class); @Before public void setUp() throws Exception { } @Test public void test() { int count=0; SqlSession sqlSession=null; try { sqlSession = MyBatisUtils.createSqlSession(); count = sqlSession.selectOne("cn.linyer.dao.user.UserMapper.count"); logger.debug("UserMapperTest count---->"+count); } catch (Exception e) { e.printStackTrace(); } finally { MyBatisUtils.closeSqlSession(sqlSession); } } }
SqlSession
- 包含了执行 SQL 所需的所有方法
- 对应一次数据库会话,会话结束必须关闭
线程级别,不能共享
- ==关闭
SqlSession
非常重要,必须要确保在finally
代码块中正常关闭== - 在
SqlSession
里可以执行多次SQL语句,但一旦关闭了SqlSession
就需要重新创建
- ==关闭
SqlSession
的获取方式String resource = "mybatis-config.xml"; InputStream is = Resources.getResourceAsStream(resource); SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is); SqlSession sqlSession = factory.openSession();
SqlSession
的两种使用方式- ?通过
SqlSession
实例直接运行映射的SQL语句 - ?基于
Mapper
接口方式操作数据
- ?通过
实践
非集成环境下的最佳实践
?
SqlSessionFactoryBuilder
- ?用过即丢,推荐作用域在方法体内
?
SqlSessionFactory
- ?最佳作用域范围:应用的全局作用域
- ?生命周期应与应用的生命周期相同
?
SqlSession
- ?线程级
- ?一个
request
请求期间
核心配置文件
configuration
configuration
配置 ==(注意元素节点顺序)==- ?
properties
可以配置在 Java 属性配置文件中 - ?
settings
修改 MyBatis 在运行时的行为方式 - ?
typeAliases
为 Java 类型命名一个别名(简称) - ?
typeHandlers
类型处理器 - ?
objectFactory
对象工厂 - ?
plugins
插件 - ?
environments
环境 ?
environment
环境变量- ?
transactionManager
事务管理器 - ?
dataSource
数据源
- ?
- ?
mappers
映射器
- ?
properties
配置
properties
元素的两种方式- ?通过外部指定的方式 (
database.properties
),实现动态配置 - ?直接配置为 XML,实现动态配置
- ?通过外部指定的方式 (
通过外部指定的方式 (
database.properties
),实现动态配置- ?配置
properties
的resource
指定
<properties resource="database.properties"/> ...... <dataSource type="POOLED"> <property name="driver" value="${driver}"/> <property name="url" value="${url}"/> <property name="username" value="${user}"/> <property name="password" value="${password}"/> </dataSource>
- ?配置
直接配置为 XML,实现动态配置
?配置
property
的name
和value
<properties> <property name="driver" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://127.0.0.1:3306/book"/> <property name="user" value="root"/> <property name="password" value="123456"/> </properties> ...... <dataSource type="POOLED"> <property name="driver" value="${driver}"/> <property name="url" value="${url}"/> <property name="username" value="${user}"/> <property name="password" value="${password}"/> </dataSource>
settings
- 用来修改 MyBatis 运行时的行为方式
主要是 MyBatis 的一些全局配置属性的设置
<settings> <!--是否启用延迟加载--> <setting name="lazyLoadingEnabled" value="false"/> </settings>
设置项 | 描述 | 允许值 | 默认值 |
---|---|---|---|
cacheEnabled | 对在此配置文件下的所有cache 进行全局性开/关设置 | true / false | true |
lazyLoadingEnabled | 全局性设置懒加载。如果设为false ,则所有相关联的都会被初始化加载 | true / false | true |
autoMappingBehavior | MyBatis对于resultMap 自动映射匹配级别 | NONE / PARTIAL / FULL | PARTIAL |
......(9个) | ...... | ...... | ...... |
typeAliases
- 类型别名
仅仅只关联 XML 配置,简写冗长的 Java 类名
<typeAliases> <typeAlias alias="user" type="cn.smbms.pojo.User"/> </typeAliases>
<typeAliases> <package name="cn.smbms.pojo"/> </typeAliases>
environments
- 表示配置 MyBatis 的多套运行环境,将 SQL 映射到多个不同的数据库上
子元素节点:
environment
,但是必须指定其中一个默认运行环境(通过default
指定)每个
SqlSessionFactory
实例只能选择==一个==运行环境
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${user}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
<environment id="test">
...
</environment>
</environments>
transactionManager
:事务管理器?
JDBC
和MANAGED
(托管)<transactionManager type="[ JDBC | MANAGED]"/>
dataSource
- ?
dataSource
元素使用基本的JDBC
数据源接口来配置JDBC
连接对象的资源 ?有三种内建的数据源类型
?
POOLED
使用池的概念<dataSource type="[ UNPOOLED | POOLED | JNDI ]">
- ?
mappers
- 映射器,定义 SQL 映射语句
- 须在配置中引用
mapper
映射文件 - 方式一:使用类资源路径获取资源
<!--将mapper映射文件加入到系统核心配置文件中-->
<mappers>
<mapper resource="cn/smbms/dao/user/UserMapper.xml"/>
</mappers>
- 方式二:使用 URL 获取资源
<mappers>
<mapper url="file:///E:/sqlmappers/UserMapper.xml"/>
<mapper url="file:///E:/sqlmappers/ProviderMapper.xml"/>
<mappers>
SQL映射文件
SQL 映射的 XML 文件
- MyBatis 真正的强大在于映射语句,专注于SQL,功能强大,SQL映射的配置却是相当简单
- SQL映射文件的几个顶级元素(按照定义的顺序)
语句 | 含义 |
---|---|
mapper | namespace 命名空间 |
cache | 配置给定命名空间的缓存 |
cache-ref | 从其他命名空间引用缓存配置 |
resultMap | 用来描述数据库结果集和对象的对应关系 |
sql | 可以重用的SQL块,也可以被其他语句引用 |
insert | 映射插入语句 |
update | 映射更新语句 |
delete | 映射删除语句 |
select | 映射查询语句 |
DAO 层接口方法常见的返回类型
- ?Java对象、Map、List 等复杂数据类型
?int
- ?(增、删、改)更新操作时,影响的数据行数
MyBatis 参数入参
- ?使用
@Param
注解进行参数的传递 - ?封装成对象入参
- ?使用
mapper
namespace
:命名空间- ?
namespace
和子元素的id
联合保证唯一,区别不同的mapper
?绑定 DAO 接口
- ?
namespace
的命名必须跟某个接口同名 ?接口中的方法与映射文件中 SQL 语句
id
一一对应<mapper namespace="cn.smbms.dao.user.UserMapper"> <select id="getUserList" ...> ...... </select> </mapper>
- ?
- ?
select
select
是 MyBatis 中最常用的元素之一select
语句有很多属性可以详细配置每一条语句?
id
- ?命名空间中唯一的标识符
- ?接口中的方法与映射文件中的 SQL 语句
id
一一对应
?
parameterType
- ?传入 SQL 语句的参数类型的完全限定名或别名
?基础数据类型
- ?
int
、String
、Date
等 - ?只能传入一个,通过
#{参数名}
即可获取传入的值
- ?
?复杂数据类型
- ?Java 实体类、Map 等
- ?通过
#{属性名}
或者#{Map的key}
即可获取传入值
?
resultType
- ?SQL 语句返回值类型的完整类名或别名
<select id="getUserListByUserName" parameterType="string" resultType="user">
select * from users where userName
like CONCAT ('%',#{userName},'%')
</select>
- ❗支持==基础数据类型==和==复杂数据类型==❗
- ❗大小写==不==敏感❗
- 参数传递:
#{参数名}
JDBC 代码:
string sql = "select * from users where userName like CONCAT ('%',?,'%')";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1,userName);
注意❗:数据库字段名与 JavaBean 的属性名一致❗
resultMap
- 描述如何将结果集映射到 Java 对象
<resultMap type="User" id="userList">
<result property="id" column="id"/>
<result property="userCode" column="userCode"/>
<result property="userName" column="userName"/>
<result property="userRole" column="userRole"/>
<result property="userRoleName" column="roleName"/>
</resultMap>
<select id="getUserList" resultMap="userList" parameterType="User">
select u.*,r.roleName
from smbms_user u,smbms_role r
where u.userName like CONCAT('%',#{userName},'%')
and u.userRole=#{userRole} and u.userRole=r.id
</select>
<select id="getUserList" ?resultMap?="userList" parameterType="User">
❗❗一个外部 resultMap ? 的id,表示返回结果映射到哪一个resultMap❗❗
========================================================================
<result property="userRoleName" column=?"roleName"?/>
❗❗ 从数据库中查询的列名或者别名 ? ❗❗
resultMap
对比resultType
?
resultType
:直接表示返回类型- ?基础数据类型
- ?复杂数据类型
?
resultMap
:对外部resultMap
的引用?应用场景
- ?数据库字段信息与对象属性不一致
- ?复杂的联合查询,自由控制映射结果
- ?二者不能同时存在,本质上都是
Map
数据结构?
resultMap
自动映射匹配前提:字段名与属性名一致resultMap
的自动映射级别(autoMappingBehavior
)?
PARTIAL
(默认):自动匹配所有属性<settings> <setting name="autoMappingBehavior" value="NONE"/> </settings>
insert
id
parameterType
注意:
insert
、update
、delete
元素均 ==没有==resultType
属性
<insert id="add" parameterType="User">
insert into smbms_user(userCode,userName,userPassword)
values(#{userCode),#{userName),#{userPassword))
</insert>
update
id
parameterType
对象入参
<update id="modify" parameterType="User">
update smbms_user
set userCode=#{userCode},userName=#{userName},userPassword=#{userPassword)
where id=#{id)
</update>
多参数入参
public interface UserMapper {
public int updatePwd(@Param("id")int id,@Param("password")String password);
}
<update id="updatePwd">
update users
set password=#{password}
where id=#{id}
</update>
delete
id
parameterType
<delete id="deleteUserByld" parameterType="int">
delete from smbms_user
where id=#{id}
</delete>
使用 resultMap
实现 高级 结果映射
resultMap
属性- ?
id
:resultMap的唯一标识 - ?
type
:Java 实体类
- ?
resultMap
子元素- ?
id
:一般对应数据库中该行的主键 id,设置此项可提高 MyBatis 性能 - ?
result
:映射到 JavaBean 的某个 “简单类型”属性 - ?
association
:映射到 JavaBean 的某个 “复杂类型”属性,比如 JavaBean类 - ?
collection
:映射到 JavaBean 的某个 “复杂类型”属性,比如 集合
- ?
association
- 复杂的类型关联,==一对一==
内部嵌套
- ?映射一个嵌套 JavaBean 属性
属性
- ?
property
:映射数据库列的实体对象的属性 - ?
javaType
:完整 Java 类名或者别名 - ?
resultMap
:引用外部resultMap
- ?
子元素
- ?
id
?
result
- ?
property
:映射数据库列的实体对象的属性 - ?
column
:数据库列名或者别名
- ?
- ?
<resultMap type="User" id="userRoleResult">
<id property="id" column="id"/>
<result property="userCode" column="userCode"/>
<result property="userName" column="userName"/>
<result property="userRole" column="userRole"/>
<association property="role" javaType="Role">
<id property="id" column="r_id"/>
<result property="rolecode" column="rolecode"/>
<result property="roleName" column="roleName"/>
</association>
</resultMap>
<select id="getUserlistByRoleId" parameterType="Integer" resultMap="userRoleResult">
select u.*,r.id as r_id,r.roleCode,r.roleName
from smbms_user u,smbms_role r
where u.userRole=#{userRole} and u.userRole=r.id
</select>
collection
- 复杂类型集合,==一对多==
内部嵌套
- ?映射一个嵌套结果集到一个列表
属性
- ?
property
:映射数据库列的实体对象的属性
- ?
ofType
:完整 Java 类名或者别名(集合所包括的类型) - ?
resultMap
:引用外部resultMap
- ?
子元素
- ?
id
?
result
- ?
property
:映射数据库列的实体对象的属性 - ?
column
:数据库列名或者别名
- ?
- ?
<resultMap type="Address" id="addressResult">
<id property="id" column="a_id"/>
<result property="contact" column="contact"/>
<result property="addressDesc" column="addressDesc"/>
<result property="postcode" column="postcode"/>
<result property="tel" column="tel"/>
</resultMap>
<resultMap type="User" id="userAddressResult">
<id property="id" column="id"/>
<result property="usercode" column="usercode"/>
<result property="userName" column="userName"/>
<collection property="addresslist" ofType="Address" resultMap="addressResult"/>
</resultMap>
<select id="getAddresslistByUserId" resultMap="userAddressResult" parameterType="Integer">
select u.*,a.id as a_id,a.contact,a.addressDesc,a.tel,a.postcode
from smbms_user u,smbms _address a
where u.id=a.userId and u.id=#{id}
</select>
resultMap
自动映射(autoMappingBehavior
)的三个匹配级别NONE
:禁止自动匹配PARTIAL
(默认):自动匹配所有属性,内部嵌套除外FULL
:自动匹配所有
MyBatis 缓存
- 一级缓存
二级缓存的配置
- MyBatis 的全局
cache
配置
- MyBatis 的全局
第一种:在 MyBatis XML 中配置
<settings> <setting name="cacheEnabled" value="true"/> </settings>
第二种:在 Mapper XML 文件中设置缓存,默认情况下:未开启
<cache eviction="FIFO" flushlnterval="60000" size="512" readOnly="true"/>
在 Mapper XML 文件配置支持
cache
后,若需要对个别查询进行调整,可以单独设置cache
<select id="selectAll" resultType="Emp" useCache="true">
动态 SQL
- 基于 OGNL 表达式
- 使用动态 SQL 完成多条件查询等逻辑实现
用于实现动态 SQL 的元素主要有
- ?
if
- ?
trim
- ?
where
- ?
set
- ?
choose
(when
、otherwise
) - ?
foreach
- ?
if
<select id="getUserList" resultMap="userlist">
select u.*,r.roleName from smbms_user u,smbms_role r
where u.userRole=r.id
<if test="userRole!=null">
and userRole=#{userRole}
</if>
<if test="userName!=null and userName!=''">
and userName like CONCAT('%',#{userName},'%')
</if>
</select>
where
- 简化 SQL 语句中
where
条件判断 智能处理
and
和or
<select id="getUserlist" resultType="User"> select * from smbms_user <where> <if test="userName!=null and userName!=''"> and userName like CONCAT('%',#{userName},'%') </if> <if test="userRole!=null"> and userRole=#{userRole} </if> </where> </select>
set
<update id="modify" parameterType="user">
update smbms_user
<set>
<if test="usercode!=null">userCode=#{userCode},</if>
<if test="userName!=nulL">userName=#{userName},</if>
<if test="userPassword!=null">userPas sword=#{userPassword},</if>
<if test="gender!=null">gender=#{gender},</if>
<if test="birthday !=null">birthday=#{birthday},</if>
<if test="phone!=nulL">phone=#{phone},</if>
<if test="address!=null">address=#{address},</if>
<if test="userRolel!=null">userRole=#{userRole},</if>
<if test="userCode!=nulL">modifyBy=#{modifyBy},</if>
<if test="userCode !=nulL">modifyDate=#{modifyDate},</if>
</set>
where id=#{id}
</update>
trim
属性
- ?
prefix
- ?
suffix
- ?
prefixOverrides
- ?
suffixOverrides
- ?
- 更灵活的去除多余关键字
替代
where
<select id="getUserlist" resultType="User"> select * from smbms_user <trim prefix="where" prefixoverrides="and / or"> <if test="userName!=null and userName!=''"> and userName like CONCAT('%',#{userName},'%') </if> <if test="userRole!=null"> and userRole=#{userRole} </if> </trim> </select>
<update id="modify" parameterType="User"> update smbms_user <trim prefix="set" suffixOverrides="," suffix="where id=#{id}"> <if test="userCode!=null">userCode=#{userCode},</if> <if test="userName!=null">userCode=#{userName },</if> <if test="userPassword!=null">userPassword=#{userPassword },</if> </trim> </update>
foreach
- 迭代一个集合,通常用于
in
条件 属性
- ?
item
别名 - ?
index
位置 ?
collection
:必须指定- ?
list
- ?
array
- ?
map-key
- ?
- ?
open
开始符号 - ?
separator
间隔符号 - ?
close
结束符号
- ?
单参数入参:
<resultMap type="User" id="userMapByRole">
<id property="id" column="id"/>
<result property="userCode" column="userCode"/>
<result property="userName" column="userName"/>
</resultMap>
<select id="getUserByRoleId_foreach_array" resultMap="userMapByRole">
select * from smbms_user where userRole in
<foreach collection="array" item="roleIds" open="(" separator="," close=")">
#{roleIds}
</foreach>
</select>
多参数入参:
public List<User> getUserByConditionMap_foreach_map(Map<String,Object> conditionMap);
<select id="getUserByConditionMap_foreach_map" resultMap="userMapByRole">
select * from smbms_user where
gender=#{gender}
and userRole in
<foreach collection=" roleIds" item="roleMap" open="(" separator="," close=")">
#{roleMap}
</foreach>
</select>
choose
(when
、otherwise
)
- 相当于Java中
switch
语句 - 当
when
有条件满足的时候,就跳出choose
<choose>
<when test="条件1">...</when>
<when test="条件2">...</when>
<when test="条件3">...</when>
...
<otherwise>...</otherwise>
</choose>
MyBatis 入参类型
基本类型
key
:变量名value
:变量值
数组
key
:"array"value
:该数组
对象
key
:对象的属性名键值不变value
:对象的属性值
List
key
: "list"value
:该List
Map
键值不变
❗❗ ==无论== 入参是何种类型,MyBatis 都会将其放入在一个 ==Map== 中❗❗
MyBatis 实现分页功能
分页—DAO层实现
limit
(起始位置,页面容量)
查询用户列表的方法增加2个参数:
from
pageSize
public List<User> getuserList(@Param("userName")string userName, @Param("userRole")Integer roleId, @Param("from")Integer currentPageNo, @Param("pagesize")Integer pagesize);
<select id="getUserlist" resultMap="userlist"> select u.* from smbms user_u, smbms_role r where u.userRole=r.id <if test="userName!=null and userName!=''"> and userName like CONCAT('%',#{userName},'%') </if> <if test="userRole!=null"> and userRole=#{userRole} </if> order by creationDate DESC limit #{from},#{pageSize} </select>
评论 (0)