文章目录
- 1.三层架构
- 2.三层架构请求的处理流程
- 3.为什么要使用三层架构
- 4.三层架构模式和框架
- 5.框架
- 6.框架解决的问题
- 7.JDBC访问数据库的优缺点
- 8.MyBatis框架
- 具体实现
- 2.2概念
MyBatis框架
第一章 框架简述
1.三层架构
mvc:web开发中，使用mvc架构模式。m:数据，v:视图，c:控制器
c 控制器：接受请求，调用service对象，显示请求的处理结果。当前使用servlet作为控制器
v 试图： 现在使用jsp，html，css,js。显示请求的处理结果，把m中数据显示出来。
m 数据： 来自数据库mysql，来自文件，来自网络。
mvc作用：
1）.实现解耦合
2）.让mvc各负其职
3）使系统扩展更好。更容易维护。
三层架构
1.界面层（视图层）：接受用户请求，调用service，显示请求的处理结果的。包含了jsp,html,servlet等对象。
2.业务逻辑层：处理业务逻辑，使用算法处理数据的。把数据返回给界面层。对应的是service包，和包中的很多的
XXXService类。例如：StudentService，OderService,ShopService.
3.持久层（数据库访问层）：访问数据库，或者读取文件，访问网络。获取数据。对应的包是dao。dao包中很多的StudentDao，OderDao,ShopDao等等.
2.三层架构请求的处理流程
用户发起请求 -> 界面层 ->业务逻辑层 ->持久层->数据库（mysql）
3.为什么要使用三层架构
1.结构清晰、耦合度低、各层分工明确。
2.可维护性高，可拓展性高。
3.有利于标准化。
4.开发人员可以只关注整个结构中的其中某一层的功能实现。
5.有利于各层逻辑的复用。
4.三层架构模式和框架
每一层对应着一个框架
1.界面层----SpringMVC框架
2.业务层—Spring框架
3.持久层—MyBatis框架
5.框架
1）.什么是框架（framework）
框架就是一个软件，完成了部分的功能。软件中的类和类之间的方法调用都已经规定好了。通过这些可以完成某些功能。框架看做是模板。
框架是可以升级的，改造的。框架是安全的。
框架是对某一个方面有用的，不是全能的。
6.框架解决的问题
1）框架能实现技术的整合。
2）提高开发的效率。降低难度。
7.JDBC访问数据库的优缺点
优点：
1.直观，好理解。
缺点：
1.创建很多对象 Connection,Statement,ResultSet
2.注册驱动
3.执行sql语句
4.把ResultSet转为Student，List集合。
5.关闭资源
6.sql语句和业务逻辑代码混在一起。
8.MyBatis框架
什么是mybatis：是一个持久层框架，原名ibatis,2013年改名MyBatis,MyBatis可以操作数据库，对数据库执行增删改查。看做是高级的jdbc。解决jdbc的缺点。
MyBatis可以做什么？
1）注册驱动
2）创建jdbc中使用的Connection,Statement,ResultSet
3)执行sql语句，得到ResultSet
4）处理ResultSet，把记录集中的数据转为Java对象，同时还能把Java对象放入到List集合。
5）关闭资源。
6）实现sql语句和java代码的解耦合。
MyBatis官网：https://mybatis.org/mybatis-3/zh/index.html
第二章 MyBatis入门
这一部分首先不完全借助框架来实现查询2.1-2.4
最后最大化的利用框架简化操作2.5
2.1第一个例子
实现步骤：
1.创建student表（id,name,email,age）
2.新建maven项目
3.修改pom.xml
1)加入MyBatis依赖，mysql驱动，junit
2)在<*build>加入资源插件
4.创建实体类Student，定义属性，属性名和列名保持一致。
5.创建Dao接口，定义操作数据库的方法。
6.创建xml文件（mapper文件），写sql语句。
mybatis框架推荐把sql语句和java代码分开。
mapper文件：定义和dao接口在同一目录，一个表一个mapper文件。
7.创建mybatis的主配置文件（xml文件）：有一个，放在resources目录下
1）定义创建连接实例的数据源（DataSource）对象
2）指定其他mapper文件的位置。
8.创建测试的内容。
使用main方法，测试mybatis访问数据库
也可以使用junit访问数据库。
只问耕耘，不问收获
具体实现
3.Maven的pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!-- 当前项目的坐标-->
<groupId>com.bjpowernode</groupId>
<artifactId>ch01-first</artifactId>
<version>1.0</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<!--依赖列表-->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!--mybatis依赖 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.1</version>
</dependency>
<!-- mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.9</version>
</dependency>
</dependencies>
<build>
<!--资源插件： 处理src/main/java目录中的xml-->
<resources>
<resource>
<directory>src/main/java</directory><!--所在的目录-->
<includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
<!-- 指定jdk的版本，我们已经指定过来，所以现在就不需要-->
<!-- <plugins>-->
<!-- <plugin>-->
<!-- <artifactId>maven-compiler-plugin</artifactId>-->
<!-- <version>3.1</version>-->
<!-- <configuration>-->
<!-- <source>1.8</source>-->
<!-- <target>1.8</target>-->
<!-- </configuration>-->
<!-- </plugin>-->
<!-- </plugins>-->
</build>
</project>
5.创建Dao接口，定义操作数据库的方法。
Java下的domain层写Student类，dao层写StudentDao接口。同一目录下写StudentDao.xml
package com.sunny.dao;
import com.sunny.domain.Student;
public interface StudentDao {
//查询一个学生
Student selectStudentById(Integer id);
}
6.创建xml文件（mapper文件），写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="com.sunny.dao.StudentDao">
<!-- <select id="selectBlog" resultType="Blog">
select * from Blog where id = #{id}
</select>-->
<!-- 查询一个学生Student
<select>:表示查询操作，里面是select语句
id:要执行的sql语句的唯一标识，是一个自定义字符串。
推荐使用dao接口中的方法名称
resultType:告诉mybatis，执行sql语句，把数据赋值给哪个类型的java对象。
resultType的值现在使用的java对象的全限定名称
#{studentId}:占位符，表示从java程序中传入过来的数据。
-->
<select id="selectStudentById" resultType="com.bjpowernode.domain.Student">
select id,name,email,age from student where id= #{studentId}
</select>
<!-- 添加insert
insert into student values (1003,"李峰","lifeng@qq,com",26)
如果传入给mybatis是一个java对象，使用#{属性名}获取此属性值。
属性值放到#{}占位符的位置,mybatis执行此属性对应的getXXX().
例如#{id},执行getId()
-->
<insert id="insertStudent">
insert into student values (#{id},#{name },#{email},#{age})
</insert>
</mapper>
<!--
1.约束文件
http://mybatis.org/dtd/mybatis-3-mapper.dtd
约束文件的作用：定义和限制当前文件中可以使用的标签和属性，以及标签出现的顺序
2.mapper是根标签
namespace： 命名空间，必须有值，不能为空。唯一值。
推荐使用Dao接口的全限定名称。
作用： 参与识别sql语句的作用。
3.在mapper里面可以写<insert>,<update>,<delete>,<select>等标签。
<insert> 里面是 insert语句，表示执行的insert操作。
<update> 里面是 update语句
<delete> 里面是 delete语句
<select> 里面是 select语句
-->
7.创建mybatis的主配置文件（xml文件）：有一个，放在resources目录下
?useUnicode=true&characterEncoding=utf-8
<?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>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<!-- 配置数据源：创建Connection对象-->
<dataSource type="POOLED">
<!-- driver:驱动的内容-->
<property name="driver" value="com.mysql.jdbc.Driver"/>
<!-- 连接数据库的url-->
<property name="url" value="jdbc:mysql://localhost:3306/springdb?useUnicode=true&
characterEncoding=utf-8"/>
<!-- 用户名-->
<property name="username" value="root"/>
<!-- 密码-->
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<!-- 指定其他mapper文件的位置：
其他mapper文件目的 是找到其他文件的sql语句。
-->
<mappers>
<!--
使用mapper的resource属性指定mapper文件的路径。
这个路径是从target/classes路径开启的。
使用注意：
resource = mapper文件的路径，使用/分割路径
一个mapper resource 指定一个mapper文件
-->
<mapper resource="com/bjpowernode/dao/StudentDao.xml"/>
<!-- <mapper resource="com/bjpowernode/dao/OrderDao.xml"/>-->
<!-- <mapper resource="com/bjpowernode/dao/UserDao.xml"/>-->
</mappers>
</configuration>
在test文件下测试代码
package com.sunny;
import com.bjpowernode.domain.Student;
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.junit.Test;
import java.io.IOException;
import java.io.InputStream;
public class MyTest {
//测试mybatis执行sql语句
@Test
public void testSelectStudentById() throws IOException {
// 调用mybatis某个对象的方法，执行mapper文件中的sql语句。
// mybatis核心类： SqlSessionFactory
// 1.定义mybatis主配置文件的位置，从类路径开始的相对路径
String config = "mybatis.xml";
// 2.读取主配置文件。使用mybatis框架中的Resources类
InputStream inputStream = Resources.getResourceAsStream(config);
// 3.创建SqlSessionFactory对象，使用SqlSessionFactoryBuilder类
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
// 4.获取SqlSession对象
SqlSession session = factory.openSession();
// 5.指定要执行的sql语句的id
// sql的id = namespace+“.”+<select>|update|insert|delete标签的id属性值。
String sqlId="com.bjpowernode.dao.StudentDao"+"."+"selectStudentById";
// 6.通过SqlSession的方法，执行sql语句。
Student student = session.selectOne(sqlId);
System.out.println("使用mybatis查询一个学生"+student);
// 7.关闭SqlSession对象
session.close();
}
@Test
public void testSelectStudentById2() throws IOException {
// 调用mybatis某个对象的方法，执行mapper文件中的sql语句。
// mybatis核心类： SqlSessionFactory
// 1.定义mybatis主配置文件的位置，从类路径开始的相对路径
String config = "mybatis.xml";
// 2.读取主配置文件。使用mybatis框架中的Resources类
InputStream inputStream = Resources.getResourceAsStream(config);
// 3.创建SqlSessionFactory对象，使用SqlSessionFactoryBuilder类
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
// 4.获取SqlSession对象
SqlSession session = factory.openSession();
// 5.指定要执行的sql语句的id
// sql的id = namespace+“.”+<select>|update|insert|delete标签的id属性值。
String sqlId="com.bjpowernode.dao.StudentDao"+"."+"selectStudentById";
// 6.通过SqlSession的方法，执行sql语句。
Student student = session.selectOne(sqlId,1002);
System.out.println("使用mybatis查询一个学生"+student);
// 7.关闭SqlSession对象
session.close();
}
@Test
public void testInsertStudent() throws IOException {
String config = "mybatis.xml";
InputStream inputStream = Resources.getResourceAsStream(config);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session = factory.openSession();
String sqlId="com.bjpowernode.dao.StudentDao"+"."+"insertStudent";
// 6.通过SqlSession的方法，执行sql语句。
Student student = new Student();
student.setId(1005);
student.setName("张飞");
student.setEmail("zhangfei@qq.com");
student.setAge(26);
int rows = session.insert(sqlId,student);
System.out.println("使用mybatis添加一个学生，rows="+rows);
// mybatis默认执行sql语句是 手工提交事务模式，在做insert，update，delete后需要提交事务。
session.commit();
// 7.关闭SqlSession对象
session.close();
}
@Test
public void testAutoCommitInsertStudent() throws IOException {
String config = "mybatis.xml";
InputStream inputStream = Resources.getResourceAsStream(config);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session = factory.openSession(true);
String sqlId="com.bjpowernode.dao.StudentDao"+"."+"insertStudent";
// 6.通过SqlSession的方法，执行sql语句。
Student student = new Student();
student.setId(1007);
student.setName("小乔");
student.setEmail("zhangfei@qq.com");
student.setAge(26);
int rows = session.insert(sqlId,student);
System.out.println("使用mybatis添加一个学生，rows="+rows);
// 7.关闭SqlSession对象
session.close();
}
}
使用mybatis查询一个学生Student实体的信息{id=1001, name='李四', email='sunny@qq.com', age=21}
Process finished with exit code 02.2概念
1.自动提交：当你的sql语句执行完毕后，提交事务。数据库更新操作直接保存到数据库。
在mybatis.xml文件中加入
<configuration>
<!-- 设置日志-->
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
可选的值有：SLF4J、LOG4J、LOG4J2、JDK_LOGGING、COMMONS_LOGGING、STDOUT_LOGGING、NO_LOGGING
这是控制台的一次打印过程
Opening JDBC Connection
Created connection 161960012.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@9a7504c]
//把自动提交功能关闭了；
//再执行sql语句
==> Preparing: select id,name,email,age from student where id= ?
//占位符会变成一个问号 参数值
//参数值
==> Parameters: 1002(Integer)
//列
<== Columns: id, name, email, age
//列对应的行值
<== Row: 1002, 张三, zhangs@qq.com, 22
//本次查询出一行记录。
<== Total: 1
//我自己的代码输出
使用mybatis查询一个学生Student实体的信息{id=1002, name='张三', email='zhangs@qq.com', age=22}
//重新将自动提交设置为真，关闭连接，把连接放到连接池中。
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@9a7504c]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@9a7504c]
Returned connection 161960012 to pool.
Process finished with exit code 0
2.手动提交事务：在你需要提交事务的位置，执行方法，提交事务或者回顾事务。
容易出现的问题
idea有时候没用将xml拷贝到target中。
解决方法：
1.Build一下
2.maven - clean - compile
3.重启idea File-> Invalidate Cacher/Restart
4.手工把文件拷贝过去。
2.3 MyBatis的一些重要对象
1）Resources:mybatis框架中的对象，一个作用读取主配置信息。
InputStream inputStream = Resources.getResourceAsStream(config);
2)SqlSessionFactoryBuilder:负责创建SqlSessionFactory对象
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
3)SqlSessionFactory:重要对象
SqlSessionFactory是重量级对象：创建此对象需要使用更多的资源和时间。重量级对象在项目中有一个就可以了。
SqlSessionFactory接口：作用SqlSession的工厂，就是创建SqlSession对象。
DefaultSqlSessionFactory实现类
public class DefaultSqlSessionFactory implements SqlSessionFactory{}SqlSessionFactory接口中的方法
openSession():获取一个默认的SqlSession对象，默认是需要手工提交事务的。
openSession(boolean):boolean表示是否自动提交事务。
true:创建一个自动提交事务的SqlSession
false:等同于没有参数的openSession。
4）SqlSession对象
SqlSession对象是通过SqlSessionFactory获取的。SqlSession本身是接口。
DefaultSqlSession:实现类
public class DefaultSqlSession implements SqlSession {}SqlSession作用是提供了大量的执行sql语句的方法：
selectOne:执行sql语句，最多得到一行记录，多于1行是错误的。
selectList:执行sql语句，返回多行数据。
selectMap:执行sql语句的，得到一个Map结果。
insert：执行insert语句。
update：执行update语句。
delete：执行delete语句。
commit：提交事务。
rollback：回滚事务。
注意：SqlSession对象不是线程安全的，使用的步骤：
①：在方法的内部，执行sql语句之前，先获取SqlSession对象
②：调用SqlSession的方法，执行sql语句。
③：关闭SqlSession对象，执行SqlSession.close()
2.4 idea工具类和模板功能
1.创建模板
File->Settings->Editer ->File and Templates ->File->+添加自定义模板
接口配置文件模板内容 mybatis-mapper.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="dao接口的全限定名称">
<!-- 使用insert，update,delete,select标签写sql语句-->
</mapper>
主配置文件模板
<?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>
<!-- 设置日志-->
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<!-- 配置数据源：创建Connection对象-->
<dataSource type="POOLED">
<!-- driver:驱动的内容-->
<property name="driver" value="com.mysql.jdbc.Driver"/>
<!-- 连接数据库的url-->
<property name="url" value="jdbc:mysql://localhost:3306/springdb?useUnicode=true&
characterEncoding=utf-8"/>
<!-- 用户名-->
<property name="username" value="root"/>
<!-- 密码-->
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="自己的接口xml文件"/>
</mappers>
</configuration>
2.工具类
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 java.io.IOException;
import java.io.InputStream;
/*
* 工具类：创建sqlSession对象
* */
public class MyBatisUtil {
private static SqlSessionFactory factory = null;
/*
* 静态代码块可以让当前这个类在虚拟机加载的时候，把SqlSessionFactory创建一次就行了。
* */
static{
String config ="mybatis.xml";
try {
InputStream inputStream = Resources.getResourceAsStream(config);
factory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
// 创建方法，获取SqlSession对象
public static SqlSession getSqlSession(){
SqlSession session = null;
if(factory!=null){
session = factory.openSession();//openSession(true);
}
return session;
}
}
测试类
public class MyTest {
@Test
public void testSelectById(){
// 1.获取SqlSession
SqlSession session= MyBatisUtil.getSqlSession();
// 2.指定sqlId
String sqlId = "com.bjpowernode.dao.StudentDao.selectById";
// 3.执行SqlSession的方法，表示执行Sql语句
Student student = session.selectOne(sqlId,1001);
System.out.println("查询结果==="+student);
// 4.关闭SqlSession对象
session.close();
}
@Test
public void testSelectStudents(){
// 1.获取SqlSession
SqlSession session= MyBatisUtil.getSqlSession();
// 2.指定sqlId
String sqlId = "com.bjpowernode.dao.StudentDao.selectStudents";
// 3.执行SqlSession的方法，表示执行Sql语句
List<Student> students = session.selectList(sqlId);
for(Student stu:students){
System.out.println("student====="+stu);
}
// 4.关闭SqlSession对象
session.close();
}
@Test
public void testInsetStudent(){
// 1.获取SqlSession
SqlSession session= MyBatisUtil.getSqlSession();
// 2.指定sqlId
String sqlId = "com.bjpowernode.dao.StudentDao.insertStudent";
// 3.执行SqlSession的方法，表示执行Sql语句
Student student = new Student();
student.setId(1008);
student.setName("东皇");
student.setEmail("donghuang@qq.com");
student.setAge(30);
int rows = session.insert(sqlId,student);
session.commit();
System.out.println("insert的行数===="+rows);
// 4.关闭SqlSession对象
session.close();
}
}3.dao执行sql
用一个类实现接口
import com.bjpowernode.dao.StudentDao;
import com.bjpowernode.domain.Student;
import com.bjpowernode.utils.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import java.util.List;
public class StudentDaoImpl implements StudentDao {
// ctrl+o
public StudentDaoImpl() {
super();
}
@Override
public Student selectById(Integer id) {
SqlSession session = MyBatisUtil.getSqlSession();
String sqlId = "com.bjpowernode.dao.StudentDao.selectById";
Student student = session.selectOne(sqlId,1001);
session.close();
return student;
}
@Override
public List<Student> selectStudents() {
// 1.获取SqlSession
SqlSession session= MyBatisUtil.getSqlSession();
// 2.指定sqlId
String sqlId = "com.bjpowernode.dao.StudentDao.selectStudents";
// 3.执行SqlSession的方法，表示执行Sql语句
List<Student> students = session.selectList(sqlId);
// 4.关闭SqlSession对象
session.close();
return students;
}
@Override
public int insertStudent(Student student) {
// 1.获取SqlSession
SqlSession session= MyBatisUtil.getSqlSession();
// 2.指定sqlId
String sqlId = "com.bjpowernode.dao.StudentDao.insertStudent";
// 3.执行SqlSession的方法，表示执行Sql语句
int rows = session.insert(sqlId,student);
session.commit();
System.out.println("insert的行数===="+rows);
// 4.关闭SqlSession对象
session.close();
return rows;
}
}
测试方法
public class MyTest2 {
/*
*SqlSession session= MyBatisUtil.getSqlSession();
String sqlId = "com.bjpowernode.dao.StudentDao.selectById";
*
*
* 测试方法中：调用dao的方法
* Student student = dao.selectById(1001);
* 1)dao：通过反射能得到 全限定类型名称
* dao是Student类型的，全限定com.bjpowernode.dao.StudentDao
* 2）selectById:dao中的方法名称， 方法名称就是mapper文件中标签的id
* 通过dao.selectById()得到 sqlId="com.bjpowernode.dao.StudentDao.selectById";
*
* 3)确定调用SqlSession的哪个方法
* 1.根据dao接口的方法返回中，如果返回是一个对象，例如Student,调用SqlSession.selectOne();
* 如果dao接口的方法返回List,调用SqlSession的 selectList();
*
* 2.根据mapper文件中的标签，如果标签是<insert>,调用SqlSession.insert()方法
*
* mybatis框架，发现使用dao的方法调用能确定 执行sql语句的必要信息，mybatis简化dao对象的实现。
* 由mybatis框架在程序执行期间，根据你的Dao接口，创建一个内存中的接口的实现类的对象。
* mybatis把这个技术叫做代理技术（动态代理，dao的动态代理）。
*
* dao代理技术：由mybatis创建StudentDao接口的实现类Proxy(StudentDaoImpl),使用框架创建的StudentDaoImpl代替
* 你自己手工实现的StudentDaoImpl类的功能，不能开发人员写dao接口的实现类。
*
* 使用dao的代理要求
* 1.mapper文件中的namespace:必须是dao接口的全限定名称
* 2.mapper文件中标签的id是dao接口中的方法名称（一摸一样的）
* */
@Test
public void testSelectOne(){
// 要使用dao的方法
// 接口类型 变量 = new 接口的实现类（）；
StudentDao dao = new StudentDaoImpl();
Student student = dao.selectById(1001);
System.out.println("通过dao执行方法，得到的对象==="+student);
}
@Test
public void testSelectStudents(){
StudentDao dao=new StudentDaoImpl();
List<Student> students = dao.selectStudents();
students.forEach(stu-> System.out.println("stu="+stu));
}
@Test
public void testInsert(){
StudentDao dao = new StudentDaoImpl();
Student student = new Student();
student.setId(1009);
student.setName("周瑜");
student.setEmail("zhouqiang@qq.com");
student.setAge(28);
dao.insertStudent(student);
}
}2.5 dao代理
1.mybatis提供代理：
mybatis创建Dao接口的实现类对象，完成对sql语句的执行。mybatis创建一个对象代替你的dao实现类功能。
2.使用mybatis代理的要求：
1）mapper文件中的namespace一定dao接口的全限定名称。
2）mapper文件中标签的id是dao接口方法名称。
3.mybatis代理的实现方式
使用SqlSession对象的方法getMapper(dao.class)
例如：现在有StudentDao接口。
SqlSession session = MyBatisUtils.getSqlSession();
StudentDao dao = session.getMapper(StudentDao.class);
Student student = dao.selectById(1001);
//上面代码中
StudentDao dao = session.getMapper(StudentDao.class);
//等同于
StudentDao dao = new StudentDaoImpl();
public class MyTest {
@Test
public void testSelectById(){
// 1.获取SqlSession
SqlSession session= MyBatisUtil.getSqlSession();
// 2.获取dao的代理
StudentDao dao = session.getMapper(StudentDao.class);
Student student = dao.selectById(1005);
System.out.println("student = "+ student);
// 3.关闭SqlSession对象
session.close();
}
@Test
public void testSelectStudents(){
SqlSession session = MyBatisUtil.getSqlSession();
StudentDao dao = session.getMapper(StudentDao.class);
System.out.println("dao==="+dao.getClass());
// dao===class com.sun.proxy.$Proxy2 代理类型。代替了实现类的功能。
List<Student> students = dao.selectStudents();
students.forEach(stu-> System.out.println("stu="+stu));
session.close();
}
}public class MyTest {
@Test
public void testSelectById(){
// 1.获取SqlSession
SqlSession session= MyBatisUtil.getSqlSession();
// 2.获取dao的代理
StudentDao dao = session.getMapper(StudentDao.class);
Student student = dao.selectById(1005);
System.out.println("student = "+ student);
// 3.关闭SqlSession对象
session.close();
}
@Test
public void testSelectStudents(){
SqlSession session = MyBatisUtil.getSqlSession();
StudentDao dao = session.getMapper(StudentDao.class);
System.out.println("dao==="+dao.getClass());
// dao===class com.sun.proxy.$Proxy2 代理类型。代替了实现类的功能。
List<Student> students = dao.selectStudents();
students.forEach(stu-> System.out.println("stu="+stu));
session.close();
}
}
