mybatis
mybatis
第⼀章介绍
1. 三层架构
界⾯层：和⽤户打交道的，接收⽤户的请求参数，显⽰处理结果的。（jsp ，html ，servlet）
业务逻辑层：接收了界⾯层传递的数据，计算逻辑，调⽤数据库，获取数据
数据访问层：就是访问数据库，执⾏对数据的查询，修改，删除等等的。
三层对应的包
界⾯层： controller包（servlet）
业务逻辑层： service 包（XXXService类）
数据访问层： dao包（XXXDao类）
三层中类的交互
⽤户使⽤界⾯层--> 业务逻辑层--->数据访问层（持久层）-->数据库（mysql）
三层对应的处理框架
界⾯层---servlet---springmvc（框架）
业务逻辑层---service类--spring（框架）
数据访问层---dao类--mybatis（框架）
2.框架
框架是⼀个舞台，⼀个模版
模版：
1. 规定了好⼀些条款，内容。
2. 加⼊⾃⼰的东西
框架是⼀个模块
1.框架中定义好了⼀些功能。这些功能是可⽤的。
2.可以加⼊项⽬中⾃⼰的功能，这些功能可以利⽤框架中写好的功能。
框架是⼀个软件，半成品的软件，定义好了⼀些基础功能，需要加⼊你的功能就是完整的。
基础功能是可重复使⽤的，可升级的。
框架特点：
1. 框架⼀般不是全能的，不能做所有事情
2. 框架是针对某⼀个领域有效。特长在某⼀个⽅⾯，⽐如mybatis做数据库操作强，但是他不能做其它的。
3. 框架是⼀个软件
mybatis框架
⼀个框架，早期叫做ibatis, 代码在github。
mybatis是 MyBatis SQL Mapper Framework for Java （sql映射框架）
1）sql mapper :sql映射
可以把数据库表中的⼀⾏数据映射为⼀个java对象。
⼀⾏数据可以看做是⼀个java对象。操作这个对象，就相当于操作表中的数据
2） Data Access Objects（DAOs） : 数据访问，对数据库执⾏增删改查。
mybatis提供了哪些功能：
1. 提供了创建Connection ,Statement, ResultSet的能⼒，不⽤开发⼈员创建这些对象了
2. 提供了执⾏sql语句的能⼒，不⽤你执⾏sql
3. 提供了循环sql，把sql的结果转为java对象， List集合的能⼒
while (rs.next()) {
Student stu = new Student();
stu.Int("id"));
stu.String("name"));
stu.Int("age"));
//从数据库取出数据转为 Student 对象，封装到 List 集合
stuList.add(stu);
}
4.提供了关闭资源的能⼒，不⽤你关闭Connection, Statement, ResultSet
开发⼈员做的是：提供sql语句
最后是：开发⼈员提供sql语句--mybatis处理sql---开发⼈员得到List集合或java对象（表中的数据）
总结：
mybatis是⼀个sql映射框架，提供的数据库的操作能⼒。增强的JDBC,
使⽤mybatis让开发⼈员集中精神写sql就可以了，不必关⼼Connection,Statement,ResultSet
的创建，销毁，sql的执⾏。
第⼆章：主要类介绍
1 主要类的介绍
1） Resources： mybatis中的⼀个类，负责读取主配置⽂件
InputStream in = ResourceAsStream("l");
2) SqlSessionFactoryBuilder : 创建SqlSessionFactory对象，
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//创建SqlSessionFactory对象
SqlSessionFactory factory = builder.build(in);
3）SqlSessionFactory ：重量级对象，程序创建⼀个对象耗时⽐较长，使⽤资源⽐较多。
在整个项⽬中，有⼀个就够⽤了。
SqlSessionFactory：接⼝，接⼝实现类： DefaultSqlSessionFactory
SqlSessionFactory作⽤：获取SqlSession对象。SqlSession sqlSession = factory.openSession();
openSession()⽅法说明：
1. openSession() ：⽆参数的，获取是⾮⾃动提交事务的SqlSession对象
2. openSession(boolean): openSession(true) 获取⾃动提交事务的SqlSession.
openSession(false) ⾮⾃动提交事务的SqlSession对象
4)SqlSession:
SqlSession接⼝：定义了操作数据的⽅法例如 selectOne() ,selectList() ,insert(),update(), delete(), commit(), rollback()
param name SqlSession接⼝的实现类DefaultSqlSession。
使⽤要求： SqlSession对象不是线程安全的，需要在⽅法内部使⽤，在执⾏sql语句之前，使⽤openSession()获取SqlSession对象。 在执⾏完sql语句后，需要关闭它，执⾏SqlSession.close(). 这样能保证他的使⽤是线程安全的。
代码部分
1//测试⽅法
2 @Test
3public void testInsert() throws IOException {
4//访问,mybatis获取student数据
5//1.定义mybatis主配置⽂件的名称，从根⽬录开始
6 String config="l";
7//读取这个config表⽰的内容
8 InputStream in= ResourceAsStream(config);
9//3.创建SqlSessionFactoryBuilder对象
10 SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
11//4，创建SqlSessionFactory对象
12 SqlSessionFactory factory=builder.build(in);
13//5.{重要}获取SqlSession对象，从SqlSessionFactory获取SqlSession
14 SqlSession sqlSession=factory.openSession();
15//6.{重要}执⾏要执⾏的sql语句的标识,sql映射⽂件中的namespace+"."+标识的id
16 String sqlId="pt.dao.StudentDao"+"."+"insertstudent";
17//7.执⾏sql语句，通过sqlId到语句
18 Student student=new Student();
19//student.setId(4);
20 student.setName("张飞");
21 student.setEmail("zhangfei@qq");
22 student.setAge(33);
23int nums = sqlSession.insert(sqlId,student);
24
25//mybatis默认不是⾃动提交事务的，所以在insert,update,delete之后要⼿动提交事务
26 sqlSessionmit();
27//8.输出结果
28 System.out.println("执⾏insert的结果="+nums);
29//9.关闭sqlSession
30 sqlSession.close();
31 }
View Code
第三章：动态代理
1. 动态代理：使⽤Mapper(dao接⼝.class) 获取这个dao接⼝的对象
2. 传⼊参数：从java代码中把数据传⼊到mapper⽂件的sql语句中。
1）parameterType ：写在mapper⽂件中的⼀个属性。表⽰dao接⼝中⽅法的参数的数据类型。
例如StudentDao接⼝
public Student selectStudentById(Integer id)
parameterType他的值是java类型数据类型的全限定名称或mybatis定义的别名
例如:parameterType="java.lang.Integer"
或: parameterType="int"
不是强制的,mybatis通过反射可以⾃⼰获取,⼀般不⽤写
2) ⼀个简单类型的参数：
简单类型： mybatis把java的基本数据类型和String都叫简单类型。
在mapper⽂件获取简单类型的⼀个参数的值，使⽤ #{任意字符}
接⼝：public Student selectStudentById(Integer id)
mapper:select id,name, email,age from student where id=#{studentId}
3) 多个参数，使⽤@Param命名参数
接⼝ public List<Student> selectMulitParam(@Param("myname") String name, @Param("myage") Integer age)
使⽤ @Param("参数名") String name
mapper⽂件：
<select>
select * from student where name=#{myname} or age=#{myage}
</select>
4) 多个参数，使⽤java对象
语法 #{属性名}
vo: value object , 放⼀些存储数据的类。⽐如说提交请求参数， name ,age
现在想把name ,age 传给⼀个service 类。
vo: view object , 从servlet把数据返回给浏览器使⽤的类，表⽰显⽰结果的类。
pojo: 普通的有set， get⽅法的java类。普通的java对象
Servlet --- StudentService( addStudent( MyParam param) )
entity（domain域）: 实体类，和数据库中的表对应的类，
(1).
定义⽅法，多个参数，利⽤java对象作为⽅法的参数
* 使⽤对象语法:
* 使⽤对象语法:
* #{属性名,javaType=类型名称,jdbcType=数据类型} 很少⽤
* javaType=类型名称，在java中的数据类型
* jdbcType=数据类型，在数据库的数据类型
* 例如:#{paramName,javaType=java.lang.String,jdbcType=VARCHAR}
* 简化:#{属性名}，上述mybatis反射机制会⾃动获取，不⽤提供
(2).多个参数-简单类型，按位置查询
mybatis.3.4之前，使⽤#{0},
mybatis.3.4之后，使⽤#{arg0},
(3).多个参数，使⽤Map存放多个值
5) # 和 $
select id,name, email,age from student where id=#{studentId}
# 的结果： select id,name, email,age from student where id=?
select id,name, email,age from student where id=${studentId}
$ 的结果：select id,name, email,age from student where id=1001
String sql="select id,name, email,age from student where id=" + "1001";
使⽤的Statement对象执⾏sql，效率⽐PreparedStatement低。
$：可以替换表名或者列名，你能确定数据是安全的。可以使⽤$
# 和 $区别
1. #使⽤？在sql语句中做站位的，使⽤PreparedStatement执⾏sql，效率⾼
2. #能够避免sql注⼊，更安全。
3. $不使⽤占位符，是字符串连接⽅式，使⽤Statement对象执⾏sql，效率低
4. $有sql注⼊的风险，缺乏安全性。
5. $：可以替换表名或者列名
3. mybatis的输出结果
mybatis执⾏了sql语句，得到java对象。
1）resultType结果类型，指sql语句执⾏完毕后，数据转为的java对象， java类型是任意的。 result
Type结果类型的它值
1. 类型的全限定名称
2. 类型的别名，例如 java.lang.Integer别名是int
2. 类型的别名，例如 java.lang.Integer别名是int
处理⽅式：
1. mybatis执⾏sql语句，然后mybatis调⽤类的⽆参数构造⽅法，创建对象。
2. mybatis把ResultSet指定列值付给同名的属性。
<select id="selectMultiPosition" resultType="com.bjpowernode.domain.Student">
select id,name, email,age from student
</select>
对等的jdbc
ResultSet rs = executeQuery(" select id,name, email,age from student" )
()){
Student student = new Student();
student.Int("id"));
student.String("name"))
}
2) 定义⾃定义类型的别名
1）在mybatis主配置⽂件中定义，使<typeAlias>定义别名
2）可以在resultType中使⽤⾃定义别名
3）resultMap：结果映射，指定列名和java对象的属性对应关系。
1）你⾃定义列值赋值给哪个属性
2）当你的列名和属性名不⼀样时，⼀定使⽤resultMap
resultMap和resultType不要⼀起⽤，⼆选⼀
代码部分
1//Dao
2//返回⼀个值
3int countStudent();
4//返回map
5 Map<Object,Object> selectMapById(Integer id);
6//使⽤resultMap定义映射关系
7 List<Student> selectAllStudents();
8//列名和属性名不⼀致时，第⼀种⽅法
9 List<MyStudent> selectAllMyStudents();
10//列名和属性名不⼀致，第⼆种⽅法
11 List<MyStudent> selectDiffColProperty();
12//第⼀种模糊查询，在java代码中指定 like的内容
13 List<Student> selectLikeOne(String name);
14//第⼆种⽅式,name就是李值，在mapper中拼接 like "%"李"%"
15 List<Student> selectLikeTwo(String name);
1 <!--sql执⾏后返回⼀⾏⼀列--> <!--resultType="int"全限定名称，也可以是 resultType="java.lang.Integer"-->
2 <select id="countStudent" resultType="int">
3 select count(*) from student
4 </select>
5 <!--返回Map
6 1)列名是map的key，列值是map的value
7 2)只能最多返回⼀⾏记录，否则会报错
8 -->
9 <select id="selectMapById" resultType="java.util.HashMap">
10 select id,name,age from student where id=#{stuid}
11 </select>
12 <!--使⽤resultMap
13 1)先定义resultMap
14 2)在select标签，使⽤resultMap来引⽤1的定义
15 -->
16 <!--定义resultMap
17 id:⾃定义名称
18 type:java类型全限定名称
19 -->
20 <resultMap id="studentMap" type="pt.domain.Student">
21 <!--列名和属性的关系-->
22 <!--主键列，使⽤id标签-->
23 <id column="id" property="id"/>
24 <!--⾮主键列-->
25 <result column="name" property="name"/>
26 <result column="email" property="email"/>
27 <result column="age" property="age"/>
28 </resultMap>
29 <select id="selectAllStudents" resultMap="studentMap">
30 select id,name,email,age from student
31 </select>
32
33<!--列名和属性名不⼀致时-->
34 <resultMap id="MyStudentMap" type="pt.domain.MyStudent">
35 <!--列名和属性的关系-->
36 <!--主键列，使⽤id标签-->
37 <id column="id" property="stuId"/>
38 <!--⾮主键列-->
39 <result column="name" property="stuName"/>
40 <result column="email" property="stuEmail"/>
41 <result column="age" property="stuAge"/>
42 </resultMap>
43 <select id="selectAllMyStudents" resultMap="MyStudentMap">
43 <select id="selectAllMyStudents" resultMap="MyStudentMap">
44 select id,name,email,age from student
45 </select>
46 <!--列名和属性名不⼀致，第⼆种⽅法
47 resultType原则是同名的列值赋值给同名的属性值
48所有使⽤列别名(java对象的属性名)
49 -->
50 <select id="selectDiffColProperty" resultType="pt.domain.MyStudent">
51 select id as stuId,name as stuName,email as stuEmail,age as stuAge from student
52 </select>
53 <!-- 第⼀种 like java代码中指定 like内容--> //String name="%刘%";
54 <select id="selectLikeOne" resultType="pt.domain.Student">
55 select id,name,email,age from student where name like#{name}
56 </select>
57 <!-- 第⼆种 like,name就是李值，在mapper中拼接 like "%" 李" %"-->
58 <select id="selectLikeTwo" resultType="pt.domain.Student">
59 select id,name,email,age from student where name like "%" #{name} "%"
60 </select>
第四章动态sql
动态sql: sql的内容是变化的，可以根据条件获取到不同的sql语句。
主要是where部分发⽣变化。
动态sql的实现，使⽤的是mybatis提供的标签， <if> ,<where>,<foreach>
1)<if>是判断条件的，
语法<if test="判断java对象的属性值">
部分sql语句
</if>
2)<where> ⽤来包含多个<if>的，当多个if有⼀个成⽴的， <where>会⾃动增加⼀个where关键字， 并去掉 if中多余的 and ，or等。
3）<foreach> 循环java中的数组，list集合的。主要⽤在sql的in语句中。
学⽣id是 1001,1002,1003的三个学⽣
select * from student where id in (1001,1002,1003)
4）sql代码⽚段，就是复⽤⼀些语法
步骤
1.先定义 <sql id="⾃定义名称唯⼀"> sql语句，表名，字段等 </sql>
2.再使⽤， <include refid="id的值" />
代码部分
1//Dao
2//动态sql，使⽤java对象作为参数 and
3 List<Student> selectStudentIf(Student student);
4//动态sql,or
5 List<Student>selectStudentIfOr(Student student);
6
7//where
8 List<Student>selectStudentWhere(Student student);
9//foreach ⽤法1 集合放简单类类型
10 List<Student> selectForeachOne(List<Integer> idlist);
11//foreach,⽤法2，集合放对象
12 List<Student> selectForeachTwo(List<Student> stulist);
13//使⽤PageHelper分页数据
14 List<Student> selectAll();
1 <mapper namespace="pt.dao.StudentDao">
2 <!--⾃定义sql⽚段-->
3 <sql id="studentSql">
4 select id,name,email,age from student
5
6 </sql>
7
8 <!--if
9 &st+"使⽤参数java对象的属性值作为判断条件，语法为：属性=xxx值"
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论