本文主要介绍了MyBatis中资源文件xxxDao.xml的增删改查语句规范，包括如何在主配置文件中注册以及对应的测试类test.java的编写注意事项。
一 ： 在主资源文件 注册完毕的配置资源文件 xxxDao.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.rdz.dao.StudentDao">
<select id="getTotal" resultType="int">
select count(*) from tbl_student
</select>
<select id="getAll" resultType="student">
select * from tbl_student
</select>
<insert id="save">
insert into tbl_student(id,name,age) values(#{id},#{name},#{age})
</insert>
<select id="getById" parameterType="java.lang.String"
resultType="com.rdz.domain.Student">
select * from tbl_student where id=#{id}
</select>
<select id="select1" parameterType="String" resultType="Student">
select * from tbl_student where id=#{id}
</select>
<select id="select2" parameterType="int" resultType="Student">
select * from tbl_student where age=#{age}
</select>
<select id="select3" parameterType="Student" resultType="Student">
select * from tbl_student where id=#{id}
</select>
<select id="select4" parameterType="Student" resultType="Student">
select * from tbl_student where name=#{name} and age=#{age}
</select>
<select id="select5" parameterType="map" resultType="Student">
select * from tbl_student where name=#{name123} and age=#{age}
</select>
<select id="select6" resultType="Student">
select * from tbl_student where id='${value}'
</select>
<select id="select7" resultType="Student">
select * from tbl_student where name like '%${value}%'
</select>
<select id="select8" resultType="Student">
select * from tbl_student where name like #{name}
</select>
<!--
注意如下使用方式一定是 '%'空格#{name}空格'%'
空格不能省略掉
-->
<select id="select9" resultType="Student">
select * from tbl_student where name like '%' #{name} '%'
</select>
<select id="select10" resultType="int">
select count(*) from tbl_student
</select>
<select id="select11" resultType="String">
select name from tbl_student
</select>
<select id="select13" resultType="map">
select * from tbl_student where id=#{id}
</select>
<select id="select14" resultType="map">
select * from tbl_student
</select>
<select id="select15" resultType="Student">
select
id,
fullname as name,
age
from tbl_student
</select>
<!--
resultMap:该标签是用来配置 数据库表字段和java类属性的一一匹配的配置项
type:配置的是domain类型
id：resultMap标签的唯一标识，将来通过id来找到指定的resultMap
-->
<resultMap type="Student" id="stuMap">
<!--
id标签是用来配置主键的
result标签是用来配置普通字段信息的
property：配置类中的属性名
column：配置表中的字段名
对于我们现在的需求，学生表有一个主键，两个普通字段
配置的方式就是要使用一个id标签，两个result标签
-->
<id property="id" column="id"/>
<result property="name" column="fullname"/>
<result property="age" column="age"/>
</resultMap>
<select id="select16" resultMap="stuMap">
select * from tbl_student
</select>
<select id="select17" resultType="Student">
select * from tbl_student
<!--
where标签：
如果没有查询条件，则不拼接where关键字
如果有查询条件，则拼接where关键字
where在拼接的过程中，会自动的屏蔽掉第一个查询条件前面的 连接符and/or
if标签：判断查询条件是否存在
如果判断条件为true，则执行if标签对中的内容
如果判断条件为false，则不执行if标签对中的内容
-->
<where>
<!-- 如果name不为null，同时不为空串，则将name作为查询条件 -->
<if test="name!=null and name!=''">
and name like '%' #{name} '%'
</if>
<!-- 如果address不为null，同时不为空串，则将address作为查询条件 -->
<if test="address!=null and address!=''">
and address like '%' #{address} '%'
</if>
</where>
</select>
<select id="select18" resultType="Student">
select * from tbl_student where id in
<!--
collection:传递进来的数量类型
array表示数组
list表示集合
item:设置每一次遍历出来的元素，在foreach标签对中使用的时候，需要套用在#{}中
-->
<foreach collection="array" item="id" open="(" close=")" separator=",">
#{id}
</foreach>
</select>
<sql id="sql1">
select * from tbl_student
</sql>
<select id="select19" resultType="Student">
<include refid="sql1"/> where id=#{id}
</select>
</mapper>
二 测试类文件 test.java
在这里插入代码片
public class Test3 {
public static void main(String[] args) {
StudentDao studentDao = SqlSessionUtil.getSession().getMapper(StudentDao.class);
//1.测试：parameterType 使用基本数据类型为参数(附加String类型) 为sql语句传递一个String
类型参数
/*Student s = studentDao.select1("A0001");
System.out.println(s);*/
//2.测试：parameterType 使用基本数据类型为参数(附加String类型) 为sql语句传递一个int
类型参数
/*List<Student> sList = studentDao.select2(23);
for(Student s:sList){
System.out.println(s);
}*/
//注意：parameterType属性是可以省略掉的
//注意：以上两组测试，不论是传递一个基本数据类型int，还是传递一个String类型，
sql语句接收参数使用的#{}里面的标识符可以随便写
//虽然以上可以随便写，但是在开发中#{}中的标识符要保持为字段的名字
//3.测试：parameterType 使用引用数据类型（domain）为参数
/*Student s = new Student();
s.setId("A0001");
Student s1 = studentDao.select3(s);
System.out.println(s1);*/
//注意：以上测试，我们传递引用数据类型（domain）为参数，#{}中的标识符不能随便写，
标识符必须是domian中的属性名
//使用引用数据类型（domian）为参数最大的目的是能够为sql语句同时传递多个参数
//4.测试：parameterType 使用引用数据类型（domain）为参数 同时为sql语句传递多个条件
/*Student s = new Student();
s.setName("wyf");
s.setAge(23);
List<Student> sList = studentDao.select4(s);
for(Student s1:sList){
System.out.println(s1);
}*/
//5.测试：parameterType 使用map为参数类型
//当我们为sql语句传递多个参数的时候，我们可以使用测试4的domain引用类型，也可以使用map类型
//我们的实际项目开发有可能会出现这样一种情况，我们要为sql语句传递的参数，
不在一个domian中，此时我们就会想到使用map
/*Map<String,Object> map = new HashMap<String,Object>();
map.put("name123","wyf");
map.put("age",23);
List<Student> sList = studentDao.select5(map);
for(Student s1:sList){
System.out.println(s1);
}*/
//传递map类型参数到sql语句中，#{}中的标识符不能随便写，标识符必须是map中的key
//在我们的实际项目开发中，我们必须得知道如何为sql语句传递参数，使用基本数据类型参数，
引用类型参数，map类型的参数
//在实际项目开发中，parameterType属性省略掉就可以了
//6.测试: #{}和${}的区别 传递一个String类型参数，以${}的形式来接收参数
//如果使用${}接收参数，${}中的标识符必须叫value
/*Student s = studentDao.select6("A0001");
System.out.println(s);*/
//7.测试: #{}和${}的区别 使用${}执行like模糊查询
/*List<Student> sList = studentDao.select7("y");
for(Student s1:sList){
System.out.println(s1);
}*/
//8.测试: #{}和${}的区别 使用#{}执行like模糊查询 方式1
//问题：参数会参与sql语句的语法
/*List<Student> sList = studentDao.select8("%y%");
for(Student s1:sList){
System.out.println(s1);
}*/
//9.测试: #{}和${}的区别 使用#{}执行like模糊查询 方式2
/*List<Student> sList = studentDao.select9("y");
for(Student s1:sList){
System.out.println(s1);
}*/
//10.测试：resultType 返回int类型 查询所有的记录数
/*int total = studentDao.select10();
System.out.println(total);*/
/*
* 注意：
* 在使用sql语句的标签中
* parameterType可以省略掉
* resultType一定不能省略，否则报错
*/
//11.测试：resultType 返回String类型 查询学生姓名信息列表
/*List<String> sList = studentDao.select11();
for(String name:sList){
System.out.println(name);
}*/
//12.测试：resultType 返回domain 以上很多测试都是返回domain，就不重新测试了
//13.测试：resultType 返回map 查询单条记录
/*
*
* 分析：
*
* 都是根据id查单条记录，sql语句一模一样
*
* 我们之前的操作是这样的，返回Student
* <select id="select1" resultType="Student">
select * from tbl_student where id=#{id}
</select>
* 我们查询表中的信息id name age信息
* 系统会根据返回值得类型创建一个对象，来封装这些查询出来的信息
* Student s = new Student();
* s.setId("A0001");
* s.setName("wyf");
* s.setAge(23);
* 将s对象返回，我们直接接收就可以了
* 我们是这样接收的
* Student s = 执行sql语句;
* 以上操作的单条记录
* 如果操作的是多条记录呢？
* Student s1 = new Student();
* s.setId("A0001");
* s.setName("wyf");
* s.setAge(23);
*
* Student s2 = new Student();
* s.setId("A0002");
* s.setName("lh");
* s.setAge(24);
*
* s3..
* ...
* s7
* List<Student> sList = new ArrayList<Student>();
* sList.add(s1);
* sList.add(s2);
* sList.add(..);
* sList.add(s7);
* 我们的接收方式为：
* List<Student> sList = 执行sql语句;
*
*
*
* 我们现在的操作是这样的，返回map
* <select id="select13" resultType="map">
select * from tbl_student where id=#{id}
</select>
* 我们查询表中的信息id name age信息
* 系统会根据返回值的类型创建一个Map对象，来保存这些查询出来的信息
* map是以字段名为key，查询出来的字段信息为value保存这些信息
* Map<String,Object> map = new HashMap<String,Object>();
* map.put("id","A0001");
* map.put("name","wyf");
* map.put("age",23);
* map保存完信息后，返回给我们的java程序，我们直接接收这个map就可以了
* 我们的接收方式为
* Map<String,Object> map = 执行sql语句;
* 如果返回多条记录呢？
* Map<String,Object> map1 = new HashMap<String,Object>();
* map.put("id","A0001");
* map.put("name","wyf");
* map.put("age",23);
* Map<String,Object> map2 = new HashMap<String,Object>();
* map.put("id","A0002");
* map.put("name","lh");
* map.put("age",24);
* Map<String,Object> map3 = new HashMap<String,Object>();
* map.put("id","A0003");
* map.put("name","hzt");
* map.put("age",24);
* ...
* ..
* map7
* List<Map<String,Object>> mapList = new ArrayList<>();
* mapList.add(map1);
* mapList.add(map2);
* ...
* mapList.add(map7);
*
*
*
*/
/*Map<String,Object> map = studentDao.select13("A0001");
Set<String> set = map.keySet();
for(String key:set){
System.out.println("key:" + key);
System.out.println("value:" + map.get(key));
}*/
//14.测试：resultType 返回map 查询多条记录
/*List<Map<String,Object>> mapList = studentDao.select14();
for(Map<String,Object> map : mapList){
Set<String> set = map.keySet();
for(String key:set){
System.out.println("key:" + key);
System.out.println("value:" + map.get(key));
}
System.out.println("---------------------");
}*/
/*
*
* 当我们返回的记录的信息，使用domain封装不了的时候，我们会想到使用map来接收返回值
*
* 例如：需求：
* 在班级中，查询每一个名字对应的数量
* 叫zs的有多少人
* 叫ls的有多少人
* ...
* //分组之后，select关键字的后面，只能查询什么信息？？？
* 可以查询分组字段
* 可以查询聚合函数
*
* resultType="Student" X
* resultType="map" √
*
* select
*
* name,
* count(*)
*
* from tbl_student
* group by name
*
*
*
*/
//15.测试：resultType 当查询字段名和pojo(domain)属性名不一致时的解决方案
//处理方式1：起别名
/*List<Student> sList = studentDao.select15();
for(Student s1:sList){
System.out.println(s1);
}*/
//16.测试：resultType 当查询字段名和pojo(domain)属性名不一致时的解决方案
//处理方式2：使用resultMap的方式
/*List<Student> sList = studentDao.select16();
for(Student s1:sList){
System.out.println(s1);
}*/
/*
* 以上两种形式，在实际项目开发中的应用：
*
* 如果是单个的字段信息或者是少量的字段信息，属性和字段的名称不一样，
* 使用起别名的方式赋值比较方便
* 如果是出现了大量的字段信息，属性和字段的名称不一样，
* 我们不可能每一次查询都会重新为不一致的字段命名别名，
* 太麻烦，我们会考虑使用resutlMap的形式
*
* Student
* id
* name
* age
*
* tbl_student
* tbl_id
* tbl_name
* tbl_age
*
*
*/
//17.测试：动态sql where标签+if标签
/*Student s = new Student();
s.setName("y");
s.setAddress("a");
List<Student> sList = studentDao.select17(s);
for(Student s1:sList){
System.out.println(s1);
}*/
//18.测试：动态sql foreach标签
//查询id为A0001，A0002，A0003这3个id对应学员的详细信息
/*String ids[] = {"A0001","A0002","A0003"};
List<Student> sList = studentDao.select18(ids);
for(Student s1:sList){
System.out.println(s1);
}*/
//19.测试 sql片段
/*
* sql片段：
*
* 当我们的程序中出现了大量的重复的sql语句的时候，尤其重复率高而且复杂的子查询，
* 每一次用的时候，sql代码会很多，应用很麻烦
* 所以我们可以将这些代码保存到指定的sql片段中，每一次我们在使用到这些复率高而且复杂的
* 子查询的时候，我们引入sql片段就可以了
*
* 在实际项目开发中，sql片段应用并不多
* sql片段引用的少，没有意义
* sql片段引用的多，会造成sql语句的可读性的降低
*
*
*
*/
Student s = studentDao.select19("A0001");
System.out.println(s);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
