mybatis学习系列二
1 参数处理(封装map过程)(23)
1.1)F5进入断点:Employee employee1=mapper.selectEmployeeByMap(map);
1.2)进入MapperProxy的invoke方法,跟踪到mapperMethod.execute(sqlSession, args);
1.3)进入MapperMethod的execute方法,可以看到增删改查均有对应case:
Object result;
switch (command.getType()) {
case INSERT: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.insert(command.getName(), param));
break;
}
1.4)进入method.convertArgsToSqlCommandParam(args);方法--》 paramNameResolver.getNamedParams(args);
1.5)ParamNameResolver类的关键方法:
/**
* <p>
* A single non-special parameter is returned without a name.<br />
* Multiple parameters are named using the naming rule.<br />
* In addition to the default names, this method also adds the generic names (param1, param2,
* ...).
* </p>
*/
public Object getNamedParams(Object[] args) {
final int paramCount = names.size();
//为null或0个参数直接返回null
if (args == null || paramCount == 0) {
return null;
//单个参数且没有param注解:args[0];直接返回
} else if (!hasParamAnnotation && paramCount == 1) {
return args[names.firstKey()];
//多个参数或有param注解
} else {
final Map<String, Object> param = new ParamMap<Object>();
int i = 0;
//遍历names集合:{0=id,1=lastName,2=2}
for (Map.Entry<Integer, String> entry : names.entrySet()) {
//封装效果:{id:args[0],lastName:args[1],2=args[2]}
param.put(entry.getValue(), args[entry.getKey()]);
// add generic param names (param1, param2, ...)
final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
// ensure not to overwrite parameter named with @Param
//除了按注解方式保存外,额外将每个参数也保存到map中,使用新的key:param1,...,paramN
if (!names.containsValue(genericParamName)) {
param.put(genericParamName, args[entry.getKey()]);
}
i++;
}
return param;
}
}
(@Param(“id”) Integer id,@Param(“lastName”) String lastName)
ParamNameResolver解析参数封装map的:
1、names:{0=id,1=lastName}构造器时即确定好
确定流程:
1)获取每个param注解参数的@Param值:id,lastName;赋值给name
2)每次解析一个参数给map中保存信息:(key:参数索引,value:name的值)
Name的值:
标注了param注解则为注解的值
没有标注:
1)全局配置:isUseActualParamName :name=参数名
2)Name=map.size()相当于当前元素的索引{0=id,1=lastName,2=2}
2参数处理#与$区别(24,25)
获取参数方法 |
作用 |
备注 |
# |
#{}; 1)一般用法:以预编译形式,将参数设置到sql中,类似于preparedstatement;防止sql注入 2)更丰富用法: 规定参数规则:javaType,jdbcType,mode(存储过程),numericScale,resultmap,typehandler,jdbctypename,expression(未来准备支持的) 其中jdbcType在某种特定条件下设置(数据为null时,有些数据库可能不能识别mybatis对null的默认处理,如oracle(会报错)。因为mybatis对所有的null都映射为原生jdbc的other类型,由于全局配置中,jdbcTypeForNull=other而oracle不支持 |
占位符? 大部分情况下使用# 可在全局配置文件中配置 jdbcTypeForNull设置为null <setting name=”jdbcTypeForNull” value=”NULL”/> |
$ |
${}:取出的值直接拼接sql中,会有安全问题 |
原生jdbc不支持占位符的地方: 1)查询表名(分表操作,如按年份分表拆分) Select * from ${year}_salary where ***; 2)排序(order) Select * from salary order by ${name} ${order}; |
示例:
select * from myemployeee where id = ${id}
and last_name=#{lastName}
对应执行情况:
select * from myemployeee where id = 2
and last_name=?
Parameters:test(string)
3select 返回list(26)
<select id="selectEmployeeByName" resultType="com.mybatis.bean.Employee">
select * from myemployeee where last_name=#{lastName}
</select>
//返回list
List<Employee> selectEmployeeByName(String name);
3select 返回封装为map(27)
单条记录
<!-- 返回封装为map -->
<select id="selectEmployeeMap" resultType="map">
select * from myemployeee where last_name=#{lastName}
</select>
//返回map(单个)
Map<String,Object> selectEmployeeMap(String name);
Map<String,Object> returnMap= mapper.selectEmployeeMap("test");
System.out.println(returnMap);
多条记录:
<!-- 返回封装为map,多条 -->
<select id="selectEmployeeMaps" resultType="com.mybatis.bean.Employee">
select * from myemployeee where last_name like #{lastName}
</select>
//返回map(多条) Map<Integer,Employee> 键:主键;值:Employee
@MapKey("id") //通过@MapKey注解封装map时使用指定属性作为key
Map<Integer,Employee> selectEmployeeMaps(String name);
Map<Integer,Employee> returnMap2= mapper.selectEmployeeMaps("%test%");
System.out.println(returnMap2);
也可以将id改为lastName使用名字作为key。
返回结果:
{test3=com.mybatis.bean.Employee@c81cdd1, test=com.mybatis.bean.Employee@1fc2b765}
4select resultMap自定义结果映射规则(28)
<!-- 自定义结果映射规则
type: 自定义规则的java类型
id:该映射的唯一标识,方便映射
-->
<resultMap type="com.mybatis.bean.Employee" id="resultMap">
<!-- column:数据库列;property:javabean属性 -->
<id column="id" property="id" jdbcType="INTEGER"/>
<result column="last_name" property="lastName" jdbcType="VARCHAR"/>
<!-- 其他不指定的列会自动封装 -->
</resultMap>
//返回list
List<Employee> selectEmployeeByName(String name);
List<Employee> selectEmployeeByName = mapper.selectEmployeeByName("test");
System.out.println(selectEmployeeByName);
5select resultMap关联查询(级联属性)(30)
联合查询:级联属性封装结果集
1) bean对象
public class Employee {
private Integer id;
private String lastName;
private String email;
private String gender;
private MyDept myDept;
public class MyDept {
private Integer deptno;
private String dname;
private String dbSource;
2) mybatis xml文件配置
<resultMap type="com.mybatis.bean.Employee" id="DeptResultMap">
<!-- column:数据库列;property:javabean属性 -->
<id column="id" property="id" jdbcType="INTEGER"/>
<result column="last_name" property="lastName" jdbcType="VARCHAR"/>
<!-- 其他不指定的列会自动封装 -->
<result column="deptno" property="myDept.deptno"/>
<result column="dname" property="myDept.dname"/>
<result column="db_source" property="myDept.dbSource"/>
</resultMap>
<select id="selectEmployeeAndDept" resultMap="DeptResultMap">
select e.id,e.last_name,e.email,e.gender
,d.deptno,d.dname,d.db_source
from myemployeee e,mydept d where e.dept_id=d.deptno and e.id = #{id}
</select>
3)测试
Map<String,Object> map=new HashMap<String,Object>();
map.put("id", 1);
map.put("lastName","test");
// List<Employee> selectEmployeeByName = mapper.selectEmployeeByName("test");
Employee selectEmployeeAndDept = mapper.selectEmployeeAndDept(1);
System.out.println(selectEmployeeAndDept.getMyDept().getDbSource()+"=="+selectEmployeeAndDept.getMyDept().getDname());
6select resultMap关联查询(association)(31)
1) Xml
<resultMap type="com.mybatis.bean.Employee" id="DeptResultMap2">
<!-- column:数据库列;property:javabean属性 -->
<id column="id" property="id" jdbcType="INTEGER"/>
<result column="last_name" property="lastName" jdbcType="VARCHAR"/>
<!-- 其他不指定的列会自动封装 -->
<!-- assocation可以指定联合的javabean对象
property=dept,指定哪个属性是联合的对象
javatype:指定整个属性对象的类型,不能省略 -->
<association property="myDept" javaType="com.mybatis.bean.MyDept">
<id column="deptno" property="deptno"/>
<result column="dname" property="dname"/>
<result column="db_source" property="dbSource"/>
</association>
</resultMap>
2)测试
Map<String,Object> map=new HashMap<String,Object>();
map.put("id", 1);
map.put("lastName","test");
// List<Employee> selectEmployeeByName = mapper.selectEmployeeByName("test");
Employee selectEmployeeAndDept = mapper.selectEmployeeAndDept(1);
System.out.println(selectEmployeeAndDept.getMyDept().getDbSource()+"=="+selectEmployeeAndDept.getMyDept().getDname());
7select resultMap关联查询(association分步查询)(32)
1)创建mapper文件
public interface MyDeptMapper {
//查询
MyDept getMyDeptById(Integer id);
}
2)创建xml文件
<mapper namespace="com.mybatis.dao.MyDeptMapper">
<select id="getMyDeptById" resultType="com.mybatis.bean.MyDept">
select * from mydept d where d.deptno=#{deptno}
</select>
</mapper>
3)employee.xml文件中
<!-- 分步查询
1、根据员工id查询员工信息
2、根据员工信息中id查询部门信息
3、部门设置到员工中-->
<resultMap type="com.mybatis.bean.Employee" id="DeptResultByStep">
<!-- column:数据库列;property:javabean属性 -->
<id column="id" property="id" jdbcType="INTEGER"/>
<result column="last_name" property="lastName" jdbcType="VARCHAR"/>
<!-- 其他不指定的列会自动封装 -->
<!-- assocation定义关联对象的封装规则
property:指定关联的对象
select:表明当前属性是调用select指定的方法查出的结果
column:指定哪一列的值传给这个方法
流程:使用select指定的方法(传入column指定的这列参数的值)
查出对象,并封装给property指定的属性
-->
<association property="myDept" select="com.mybatis.dao.MyDeptMapper.getMyDeptById"
column="dept_id" >
</association>
</resultMap>
<select id="selectEmployeeAndDept" resultMap="DeptResultByStep">
select * from myemployeee where id = #{id}
</select>
3)测试
Employee selectEmployeeAndDept = mapper.selectEmployeeAndDept(1);
System.out.println(selectEmployeeAndDept.getMyDept().getDbSource()+"=="+selectEmployeeAndDept.getMyDept().getDname());
8select resultMap关联查询(association分步查询,延迟加载)(33)
默认为全加载,可在全局配置文件中配置
<settings>
<!-- 设置懒加载 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- name:设置项名,value:设置项值 -->
<setting name="mapUnderscoreToCamelCase" value="true"/><!--映射数据库下划线-java bean驼峰命名规则 -->
</settings>
9select resultMap关联查询(collection关联集合封装规则)(34)
上面association是针对一对一情况(一个员工对应一个部门),查询一对多(一个部门下所有员工信息)情况使用collection。
1)javabean配置
public class MyDept {
private Integer deptno;
private String dname;
private String dbSource;
private List<Employee> employees;
2)mapper接口
public interface MyDeptMapper {
//查询
MyDept getMyDeptById(Integer id);
//查询(带员工)
MyDept getMyDeptAndEmployeeById(Integer id);
}
3)xml配置
<resultMap type="com.mybatis.bean.MyDept" id="DeptAndEmployeeResultMap">
<id column="deptno" property="deptno"/>
<result column="db_source" property="dbSource"/>
<result column="dname" property="dname"/>
<!--
collection:定义关联集合类型的属性的封装规则
ofType:指定集合里面元素的类型
collection中的属性对应employee属性
-->
<collection property="employees" ofType="com.mybatis.bean.Employee">
<!-- 定义这个集合中元素的封装规则 -->
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="dept_id" property="deptId"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
<result column="dept_id" property="deptId"/>
</collection>
</resultMap>
<select id="getMyDeptAndEmployeeById" resultMap="DeptAndEmployeeResultMap">
select d.*,e.* from mydept d,myemployeee e where d.deptno=e.dept_id and d.deptno=#{deptno}
</select>
注意!需要的属性必须列出,否则为null。
如:
<collection property="employees" ofType="com.mybatis.bean.Employee">
<!-- 定义这个集合中元素的封装规则 -->
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="dept_id" property="deptId"/>
<!-- <result column="email" property="email"/>
<result column="gender" property="gender"/>
<result column="dept_id" property="deptId"/> -->
</collection>
对应输出结果:
test null null 1
test3 null null 4
属性列出后输出结果:
test test@com.cm 男 1
test3 test3@com.cm 男 4
10select resultMap关联查询(collection分步查询)(35)
1) Employmapper.xml
<select id="selectEmployeeByDeptno" resultType="com.mybatis.bean.Employee">
select * from myemployeee where dept_id = #{deptno}
</select>
2) Mydeptmapper.xml
<!-- 分步查询 -->
<resultMap type="com.mybatis.bean.MyDept" id="DeptAndEmployeeByStepResultMap">
<id column="deptno" property="deptno"/>
<result column="db_source" property="dbSource"/>
<result column="dname" property="dname"/>
<!--
collection:定义关联集合类型的属性的封装规则
ofType:指定集合里面元素的类型
collection中的属性对应employee属性
-->
<collection property="employees" select="com.mybatis.dao.EmployeeMapper.selectEmployeeByDeptno" column="deptno">
</collection>
</resultMap>
<select id="getMyDeptAndEmployeeStepById" resultMap="DeptAndEmployeeByStepResultMap">
select * from mydept d where d.deptno=#{deptno}
</select>
3) 接口MyDeptMapper
public interface MyDeptMapper {
//查询
MyDept getMyDeptById(Integer id);
//查询(带员工)
MyDept getMyDeptAndEmployeeById(Integer id);
//查询(带员工),分步查询
MyDept getMyDeptAndEmployeeStepById(Integer id);
}
4) 测试
//collection测试
MyDeptMapper mapper=session.getMapper(MyDeptMapper.class);
MyDept myDeptAndEmployeeById = mapper.getMyDeptAndEmployeeStepById(1);
if (null!=myDeptAndEmployeeById && !myDeptAndEmployeeById.getEmployees().isEmpty()) {
for(Employee e:myDeptAndEmployeeById.getEmployees()) {
System.out.println(e.getLastName()+" "+e.getEmail()+" "+e.getGender()+" "+e.getId());
}
}
11select resultMap关联查询(collection分步查询传递多列值)(36)
多列传值,将多列的值封装map传递column=”{key1=column1,key2=column2}”
fetchType=”lazy”表示使用延迟加载
-lazy:延迟;-eager:立即
<collection property="employees" select="com.mybatis.dao.EmployeeMapper.selectEmployeeByDeptno"
column="deptno" fetchType="lazy">
</collection>
11select resultMap关联查询discriminator鉴别器(37)
鉴别器:mybatis可以使用discriminator判断某列的值,然后根据某列值改变封装行为。
示例:
Employee:查出女生就把部门信息查询出来,否则不查询。
1)修改employeemapper
<resultMap type="com.mybatis.bean.Employee" id="DeptResultByStep">
<!-- column:数据库列;property:javabean属性 -->
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="gender" property="gender"/>
<!-- 其他不指定的列会自动封装 -->
<!-- assocation定义关联对象的封装规则
property:指定关联的对象
select:表明当前属性是调用select指定的方法查出的结果
column:指定哪一列的值传给这个方法
流程:使用select指定的方法(传入column指定的这列参数的值)
查出对象,并封装给property指定的属性
-->
<!-- column:指定判定的列名
javatype:列值对应的java类型 -->
<discriminator javaType="string" column="gender">
<!-- 女生resultType:指定封装的结果类型 -->
<case value="女" resultType="com.mybatis.bean.Employee">
<association property="myDept" select="com.mybatis.dao.MyDeptMapper.getMyDeptById"
column="dept_id" >
</association>
</case>
<case value="男" resultType="com.mybatis.bean.Employee">
<id column="id" property="id"/>
<result column="gender" property="gender"/>
<result column="last_name" property="lastName" jdbcType="VARCHAR"/>
</case>
</discriminator>
</resultMap>
2)测试类
//discriminator鉴别器
EmployeeMapper mapper=session.getMapper(EmployeeMapper.class);
Employee employee1=mapper.selectEmployeeAndDept(4);
System.out.println(employee1.getLastName()+" "+employee1.getEmail());
12动态sql(38-39)
OGNL(object graph navigation language)对象图导航语言(apache)。类似el,sqel等表达式
1)Mapper
//返回map
List<Map<String,Object>> selectEmployeeByMap(@Param("employee") Map<String,Object> map);
2) Xml
<!-- 返回封装为map
动态sql:
特殊子父需要使用转义字符
-->
<select id="selectEmployeeByMap" resultType="map">
select * from myemployeee where
1=1
<if test=" null != employee.lastName and employee.lastName != '' ">
and last_name like CONCAT('%',#{employee.lastName,jdbcType=VARCHAR},'%')
</if>
<if test="null!=employee.id and employee.id != '' ">
and id=#{employee.id,jdbcType=INTEGER}
</if>
</select>
3) 测试
Map<String,Object> map=new HashMap<String,Object>();
// map.put("id", 1);
map.put("lastName","test");
EmployeeMapper mapper=session.getMapper(EmployeeMapper.class);
List<Map<String,Object>> selectEmployeeByMap = mapper.selectEmployeeByMap(map);
System.out.println(selectEmployeeByMap.toString());
报错:
Caused by: java.sql.SQLException: Parameter index out of range (1 > number of parameters, which is 0).
原因:sql语句like查询为
and last_name like'%#{employee.lastName,jdbcType=VARCHAR}%'
导致报错,修改为concat即可
13动态sql-where查询条件(40)
1)xml修改
<where>
<if test=" null != employee.lastName and employee.lastName != '' ">
and last_name like CONCAT('%',#{employee.lastName,jdbcType=VARCHAR},'%')
</if>
<if test="null!=employee.id and employee.id != '' ">
and id=#{employee.id,jdbcType=INTEGER}
</if>
</where>
2)测试
Map<String,Object> map=new HashMap<String,Object>();
// map.put("id", 1);
map.put("lastName","test");
EmployeeMapper mapper=session.getMapper(EmployeeMapper.class);
List<Map<String,Object>> selectEmployeeByMap = mapper.selectEmployeeByMap(map);
System.out.println(selectEmployeeByMap.toString());
14动态sql-trim自定义字符串截取(41)
后面多出的and或or,where标签不能解决
1)xml文件
<!-- trim自定义字符串截取
prefix:前缀,给拼串后的整个字符串加一个前缀
prefixOverrides:前缀覆盖,去掉整个字符串前面多余字符
suffix:后缀,给拼串后的整个字符串加一个后缀
suffixOverrides:后缀覆盖,去掉整个字符串后面多余的字符
-->
<trim prefix="where" prefixOverrides="and" suffixOverrides="and">
<if test=" null != employee.lastName and employee.lastName != '' ">
and last_name like CONCAT('%',#{employee.lastName,jdbcType=VARCHAR},'%')
</if>
<if test="null!=employee.id and employee.id != '' ">
and id=#{employee.id,jdbcType=INTEGER}
</if>
</trim>
</select>
2)测试
Map<String,Object> map=new HashMap<String,Object>();
// map.put("id", 1);
map.put("lastName","test");
EmployeeMapper mapper=session.getMapper(EmployeeMapper.class);
List<Map<String,Object>> selectEmployeeByMap = mapper.selectEmployeeByMap(map);
System.out.println(selectEmployeeByMap.toString());
15动态sql-choose分支选择(42)
If:判断
Choose:(when,otherwise):分支选择,switch-case
如果带了id就用id查,如果带了lastname就用lastname查,只选择一个
Trim:字符串截取
Where
Set:封装修改
Forearch:
1)xml修改
<!-- choose 分支选择
只选择一个
-->
<where>
<choose>
<when test=" null != employee.lastName and employee.lastName != '' ">
last_name like CONCAT('%',#{employee.lastName,jdbcType=VARCHAR},'%')
</when>
<when test=" null!=employee.id and employee.id != '' ">
id=#{employee.id,jdbcType=INTEGER}
</when>
<otherwise>
gender='男'
</otherwise>
</choose>
</where>
</select>
16动态sql-set与if结合的动态更新(43)
1)set方式
<update id="updateEmp" parameterType="com.mybatis.bean.Employee">
update myemployeee mm
<set>
<if test="lastName !=null and lastName!='' ">
mm.last_name=#{lastName,jdbcType=VARCHAR},
</if>
<if test="email !=null and email !='' ">
mm.email=#{email,jdbcType=VARCHAR},
</if>
<if test="gender !=null and gender !='' ">
mm.gender=#{gender,jdbcType=VARCHAR}
</if>
</set>
where mm.id=#{id,jdbcType=INTEGER}
</update>
2)trim方式
<trim prefix="set" suffixOverrides=",">
<if test="lastName !=null and lastName!='' ">
mm.last_name=#{lastName,jdbcType=VARCHAR},
</if>
<if test="email !=null and email !='' ">
mm.email=#{email,jdbcType=VARCHAR},
</if>
<if test="gender !=null and gender !='' ">
mm.gender=#{gender,jdbcType=VARCHAR},
</if>
</trim>
where mm.id=#{id,jdbcType=INTEGER}
</update>
17动态sql-forearch遍历集合(44)
Collection:指定要遍历的集合
List类型的参数会特殊处理在map中,map的key就叫list
Item:将当前遍历出来的元素赋值给指定变量。
#{变量名}即可取出
1)Xml
<!-- 根据list查询 -->
<select id="selectEmployeeByIds" resultMap="resultMap" >
select * from myemployeee
<!-- collection:指定要遍历的集合
list类型的参数会特殊处理封装在map中,map的key即叫list
item:将当前遍历出的元素赋值给指定的变量
#{变量名}即可取出变量的值(即当前遍历出的元素)
index:索引,遍历list时为索引;遍历map时表示map的key(item是值)
-->
where id in
<foreach collection="list" item="item" open="("
separator="," close=")">
#{item,jdbcType=INTEGER}
</foreach>
</select>
2)Javabean
public Employee(Integer id, String lastName, String email, String gender,Integer deptId) {
super();
this.id = id;
this.lastName = lastName;
this.email = email;
this.gender = gender;
this.deptId=deptId;
}
3)测试
//list查询
EmployeeMapper mapper=session.getMapper(EmployeeMapper.class);
List<Integer> ids=new ArrayList<Integer>();
ids=Arrays.asList(1,2,3);
List<Employee> selectEmployeeByIds = mapper.selectEmployeeByIds(ids);
for(Employee e:selectEmployeeByIds) {
System.out.println(e.toString());
}
或者
<foreach collection="list" item="item" open="where id in ("
separator="," close=")">
#{item,jdbcType=INTEGER}
</foreach>
18动态sql-forearch批量插入的2种方式(45)
1)Xml
<!-- 方式一:直接list对象
addEmps(List<Employee> emps)
Insert into (),(),()
-->
<!-- insert into myemployeee(last_name,email,gender,dept_id)
values
<foreach collection="list" item="emp" separator=",">
(#{emp.lastName,jdbcType=VARCHAR},#{emp.email,jdbcType=VARCHAR},
#{emp.gender,jdbcType=VARCHAR},#{emp.deptId,jdbcType=INTEGER})
</foreach> -->
2)Mapper
//批量插入
Integer addEmps(List<Employee> emps);
3)测试
//批量插入
EmployeeMapper mapper=session.getMapper(EmployeeMapper.class);
List<Employee> emps=new ArrayList<Employee>();
emps.add(new Employee(null,"addemps1","addemps1@qq.com","男",1));
emps.add(new Employee(null,"addemps2","addemps2@qq.com","女",2));
System.out.println(mapper.addEmps(emps));
方式二:
<!-- 方式二:封装为map
addEmps(@Param("emps") List<Employee> emps);
-->
insert into myemployeee(last_name,email,gender,dept_id)
values
<foreach collection="emps" item="emp" separator=",">
(#{emp.lastName,jdbcType=VARCHAR},#{emp.email,jdbcType=VARCHAR},
#{emp.gender,jdbcType=VARCHAR},#{emp.deptId,jdbcType=INTEGER})
</foreach>
方式三:一次执行多个语句
<!-- 方式三:封装为map,且使用;分割为多个插入语句,
一次执行多个语句;
需要配置连接属性:&allowMultiQueries=true
jdbc.url=jdbc:mysql://localhost:3306/mytest?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&useSSL=false&serverTimezone=GMT%2B8&allowMultiQueries=true
addEmps(@Param("emps") List<Employee> emps);
-->
<foreach collection="emps" item="emp" separator=";">
insert into myemployeee(last_name,email,gender,dept_id)
values
(#{emp.lastName,jdbcType=VARCHAR},#{emp.email,jdbcType=VARCHAR},
#{emp.gender,jdbcType=VARCHAR},#{emp.deptId,jdbcType=INTEGER})
</foreach>
以上为mysql情况下;下面为oracle批量插入
oracle批量插入
注意:oracle不支持values(),(),()
Oracle使用
Begin
Insert into myemployeee(last_name,email,gender,dept_id)
Values (#{emp.lastName,jdbcType=VARCHAR},#{emp.email,jdbcType=VARCHAR},
#{emp.gender,jdbcType=VARCHAR},#{emp.deptId,jdbcType=INTEGER});
Insert into myemployeee(last_name,email,gender,dept_id)
Values (#{emp.lastName,jdbcType=VARCHAR},#{emp.email,jdbcType=VARCHAR},
#{emp.gender,jdbcType=VARCHAR},#{emp.deptId,jdbcType=INTEGER});
End;
包括在begin和end中间
mybatis学习系列二的更多相关文章
- MyBatis学习系列二——增删改查
目录 MyBatis学习系列一之环境搭建 MyBatis学习系列二——增删改查 MyBatis学习系列三——结合Spring 数据库的经典操作:增删改查. 在这一章我们主要说明一下简单的查询和增删改, ...
- MyBatis学习系列三——结合Spring
目录 MyBatis学习系列一之环境搭建 MyBatis学习系列二——增删改查 MyBatis学习系列三——结合Spring MyBatis在项目中应用一般都要结合Spring,这一章主要把MyBat ...
- MyBatis学习系列一之环境搭建
目录 MyBatis学习系列一之环境搭建 MyBatis学习系列二——增删改查 MyBatis学习系列三——结合Spring 学习一个新的知识,首先做一个简单的例子使用一下,然后再逐步深入.MyBat ...
- MyBatis学习 之 二、SQL语句映射文件(2)增删改查、参数、缓存
目录(?)[-] 二SQL语句映射文件2增删改查参数缓存 select insert updatedelete sql parameters 基本类型参数 Java实体类型参数 Map参数 多参数的实 ...
- MyBatis学习 之 二、SQL语句映射文件(1)resultMap
目录(?)[-] 二SQL语句映射文件1resultMap resultMap idresult constructor association联合 使用select实现联合 使用resultMap实 ...
- 【转】MyBatis学习总结(二)——使用MyBatis对表执行CRUD操作
[转]MyBatis学习总结(二)——使用MyBatis对表执行CRUD操作 上一篇博文MyBatis学习总结(一)——MyBatis快速入门中我们讲了如何使用Mybatis查询users表中的数据, ...
- Maven学习系列二(1-5)
Maven学习系列二(1-5) 本文转自 QuantSeven 博客,讲解精炼易懂,适合入门,链接及截图如下 http://www.cnblogs.com/quanyongan/category/47 ...
- mybatis入门系列二之输入与输出参数
mybatis入门系列二之详解输入与输出参数 基础知识 mybatis规定mapp.xml中每一个SQL语句形式上只能有一个@parameterType和一个@resultType 1. 返回 ...
- scrapy爬虫学习系列二:scrapy简单爬虫样例学习
系列文章列表: scrapy爬虫学习系列一:scrapy爬虫环境的准备: http://www.cnblogs.com/zhaojiedi1992/p/zhaojiedi_python_00 ...
随机推荐
- Linux - 查看命令所属的软件包
这里以查看netstat命令所属的软件包为例. CentOS:利用yum provides命令 netstat命令所属的软件包为net-tools [root@CentOS7 ~]# yum prov ...
- vue项目中在同一页面多次引入同一个echarts图表的自适应问题
在父组件页面引入两次该图表子组件显示的效果: 由于是百分比宽高,所以在窗口发生变化时,需要让图表也跟着自适应,所以才出现了本次讨论的问题啦. 先看下完整的图表子组件代码(在父组件就是直接引入,不需要传 ...
- Java 基础学习总结(一)抽象类和接口
接触java的时间不是很长,以前对抽象类和接口的定义和区别也是模糊不清,最近拿起学校的教程读了起来,也参阅了网上的博客大神理解和总结,于是决定自己按照自己的理解来总结一下. 抽象类(半成品) 一般 ...
- 爬虫--工具安装Jupyter anaconda
anaconda https://www.anaconda.com/download http://docs.anaconda.com/anaconda/user-guide/getting-star ...
- epel安装第三方扩展源后,运行yum报错的解决方案
yum安装报错:Cannot retrieve metalink for repository: epel. Please verify its path and try again 解决方法: 一句 ...
- Java:类与对象概念
什么是类? 怎样定义一个类? 什么是对象,类和对象之间是什么关系,怎样创建一个对象? 对象引用和对象在内存中是如何分配的? 什么是类? 1. 类是具有相同的属性和功能的事物的抽象的集合,在面向对象 ...
- 喜大普奔,SITE4J网站上线啦
喜大普奔,SITE4J网站上线啦: 你懂的:https://peterchenhdu.club/
- 使用crypt配置Basic Auth登录认证
简介 Basic Auth用于服务端简单的登录认证,通常使用服务器Nginx.Apache本身即可完成.比如我们要限定某个域名或者页面必须输入用户名.密码才能登录,但又不想使用后端开发语言,此时Bas ...
- SQL 必知必会·笔记<5>创建计算字段
字段(field) 基本上与列(column)的意思相同,经常互换使用,不过数据库列一 般称为列,而术语字段通常与计算字段一起使用. 拼接(concatenate) 将值联结到一起(将一个值附加到另一 ...
- JavaWeb学习 (十三)————JSP
一.什么是JSP? JSP全称是Java Server Pages,它和servle技术一样,都是SUN公司定义的一种用于开发动态web资源的技术. JSP这门技术的最大的特点在于,写jsp就像在写h ...