1、框架概述
1.1 框架的理解
1.1.1 什么是框架
框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法;另一种定义认为，框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。
简而言之，框架其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。
1.1.2 框架要解决的问题
框架要解决的最重要的一个问题是技术整合的问题，在 J2EE 的 框架中，有着各种各样的技术，不同的软件企业需要从 J2EE 中选择不同的技术，这就使得软件企业最终的应用依赖于这些技术，技术自身的复杂性和技术的风险性将会直接对应用造成冲击。而应用是软件企业的核心，是竞争力的关键所在，因此应该将应用自身的设计和具体的实现技术解耦。这样，软件企业的研发将集中在应用的设计上，而不是具体的技术实现，技术实现是应用的底层支撑，它不应该直接对应用产生影响。
框架一般处在低层应用平台（如 J2EE ）和高层业务逻辑之间的中间层。
1.1.3 软件开发的分层重要性
框架的重要性在于它实现了部分功能，并且能够很好的将低层应用平台和高层业务逻辑进行了缓和。为了实现软件工程中的“高内聚、低耦合”。把问题划分开来各个解决，易于控制，易于延展，易于分配资源。我们常见的MVC 软件设计思想就是很好的分层思想。
通过分层更好的实现了各个部分的职责，在每一层将再细化出不同的框架，分别解决各层关注的问题。
1.1.4 分层开发下的常见框架
常见的 JavaEE 开发框架：
1 、解决数据的持久化问题的框架：MyBatis
作为持久层的框架，还有一个封装程度更高的框架就是Hibernate，但这个框架因为各种原因目前在国内的流行程度下降太多，现在公司开发也越来越少使用。目前使用 Spring Data 来实现数据持久化也是一种趋势。
2、解决WEB层的MVC框架：Spring MVC
3、解决技术整合问题的框架：Spring
1.1.5 MyBatis框架概述
mybatis是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。
mybatis通过 xml 或注解的方式将要执行的各种statement配置起来，并通过java对象和statement 中sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射为 java 对象并返回。
采用 ORM 思想解决了实体和数据库映射的问题，对 jdbc进行了封装，屏蔽了 jdbc api 底层访问细节，使我们不用与 jdbc api 打交道，就可以完成对数据库的持久化操作。
1.2 JDBC编程分析
1.2.1 jdbc访问数据库的标准流程
public class aaa {
public static void main(String[] args) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
//加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//通过驱动管理类获取数据库链接
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", "root", " root");
//定义 sql 语句 ?表示占位符
String sql = "select * from user where username = ?";
//获取预处理 statement
preparedStatement = connection.prepareStatement(sql);
//设置参数，第一个参数为 sql 语句中参数的序号（从 1 开始），第二个参数为设置的参数值
preparedStatement.setString(1, "王五");
//向数据库发出 sql 执行查询，查询出结果集
resultSet = preparedStatement.executeQuery();
//遍历查询结果集
while (resultSet.next()) {
System.out.println(resultSet.getString("id") + resultSet.getString(" username"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//释放资源
if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (preparedStatement != null) {
try {
preparedStatement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
1.2.2 jdbc问题分析
1、数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。
2、Sql 语句在代码中硬编码，造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变 java代码。
3、使用 preparedStatement 向占有位符号传参数存在硬编码，因为 sql 语句的 where 条件不一定，可能多也可能少，修改 sql 还要修改代码，系统不易维护。
4、对结果集解析存在硬编码（查询列名），sql 变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成 pojo 对象解析比较方便。
直接jdbc访问数据库存在以上问题，那么MyBatis框架就是来解决这些问题，使得开发简洁方便。
2、Mybatis快速入门
2.1 开发前的准备
MyBatis官网：https://mybatis.org/mybatis-3/getting-started.html
下载mybatis-xxx.zip或者使用maven时加入坐标。
2.2 搭建MyBatis开发环境
2.2.1 maven工程添加MyBatis坐标
在 pom.xml 文件中添加 Mybatis3.4.5 的坐标，如下：
<dependencies>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
</dependencies>
2.2.3 编写User实体类
public class User implements Serializable {
private Integer id;
private String username;
private String address;
private String sex;
private Date birthday;
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", address='" + address + '\'' +
", sex='" + sex + '\'' +
", birthday=" + birthday +
'}';
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
2.2.4 编写持久层接口UserDao
public interface UserDao {
/**
* 查询所有
* @return
*/
List<User> findAll();
}
2.2.5 编写UserDao的映射文件UserDao.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">
<!--namespace:指明是哪一个接口-->
<!--id:指明接口的哪一个方法-->
<!--resultType:指明哪个类来封装访问数据库返回的数据-->
<mapper namespace="cn.klb.domain.dao.UserDao">
<select id="findAll" resultType="cn.klb.domain.User">
select * from user;
</select>
</mapper>
2.2.6 编写SqlMapConfig.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>
<!--配置环境-->
<environments default="mysql">
<!--配置sql环境-->
<environment id="mysql">
<!--配置事务-->
<transactionManager type="JDBC"></transactionManager>
<!--配置连接池-->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/db1"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<!--配置映射文件-->
<mappers>
<mapper resource="cn/klb/dao/UserDao.xml"></mapper>
</mappers>
</configuration>
2.2.7 编写测试类
public class MybatisTest {
private InputStream in = null;
private SqlSessionFactory factory = null;
private SqlSession sqlSession = null;
private UserDao userDao = null;
@Before
public void init() throws Exception{
//1.读取配置文件，生成字节输入流
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.获取SqlSessionFactory
factory = new SqlSessionFactoryBuilder().build(in);
//3.获取SqlSession对象
sqlSession = factory.openSession();
//4.获取dao代理对象
userDao = sqlSession.getMapper(UserDao.class);
}
@After
public void destroy() throws Exception{
sqlSession.commit();
sqlSession.close();
in.close();
}
/**
* 测试查询所有
*/
@Test
public void testFindAll(){
List<User> users = userDao.findAll();
for (User user : users) {
System.out.println(user);
}
}
}
2.2.8 小结
不使用框架的时候，对于持久层的操作，一般是创建xxxDao接口，定义要操作的方法，然后创建一个xxxDaoImpl的实现类，在实现类中进行jdbc一系列操作。MyBatis的作用就是把实现接口这个工作给做了，我们只需要提供访问数据库的地址、账号密码、sql语句、访问后的数据封装到哪个类等信息即可。
使用MyBatis操作持久层比直接jdbc操作简单。我们要提供的：SqlMapConfig.xml文件、User类、UserDao接口、UserDao.xml文件。
SqlMapConfig.xml文件：提供连接数据库的相关信息；
UserDao.xml文件：告诉框架要实现哪个接口的哪个方法、sql语句是什么、封装类是哪个；
User类：访问数据库返回的记录封装在User类中；
UserDao接口：框架要去实现的接口。
提供了这四个东西，使用的时候就可以按照固定格式进行使用。
通过快速入门示例，发现使用 MyBatis是非常容易的一件事情，因为只需要编写 Dao 接口并且按照MyBatis要求编写两个配置文件，就可以实现功能。远比我们之前的 jdbc 方便多了。（使用注解之后将变得更为简单，只需要编写一个 MyBatis配置文件就够了。）
但是，这里面包含了许多细节，比如为什么会有工厂对象（SqlSessionFactory）,为什么有了工厂之后还要有构建者对象（SqlSessionFactoryBuilder），为什么 UserDao.xml 在创建时有位置和文件名的要求等等。
这些问题在自定义 MyBatis框架中层层剥离进行学习。
自定义 Mybatis 框架，不是让我们自己去写个 MyBatis，而是让我们能更好了了解MyBatis内部是怎么执行的，在以后的开发中能更好的使用 MyBatis框架，同时对它的设计理念（设计模式）有一个认识。
2.3 使用注解的MyBatis使用
2.3.1 在持久层接口中添加注解
public interface UserDao {
/**
* 查询所有
* @return
*/
@Select("select * from user")
List<User> findAll();
}
2.3.2 修改SqlMapConfig.xml
在mapper标签中，删除resource属性，改为class属性，作用是告诉MyBatis映射配置的位置，也就是要实现的接口的全限定类名。
<mappers>
<mapper class="com.itheima.dao.IUserDao"/>
</mappers>
然后删除UserDao.xml文件即可。
3、自定义简单的MyBatis框架
3.1 分析
3.1.1 涉及的知识点
工厂模式、构造者模式、代理模式、反射、自定义注解、注解的反射、xml解析、数据库元数据、元数据的反射等。
3.1.2 分析流程
3.2 前期准备
3.2.1 创建maven工程并引入相关坐标
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.1.6</version>
</dependency>
</dependencies>
此处不要包含MyBatis的包，因为现在是模仿它。
3.2.2 引入工具类
public class XMLConfigBuilder {
/**
* 解析主配置文件，把里面的内容填充到DefaultSqlSession所需要的地方
* 使用的技术：
* dom4j+xpath
*/
public static Configuration loadConfiguration(InputStream config) {
try {
//定义封装连接信息的配置对象（mybatis的配置对象）
Configuration cfg = new Configuration();
//1.获取SAXReader对象
SAXReader reader = new SAXReader();
//2.根据字节输入流获取Document对象
Document document = reader.read(config);
//3.获取根节点
Element root = document.getRootElement();
//4.使用xpath中选择指定节点的方式，获取所有property节点
List<Element> propertyElements = root.selectNodes("//property");
//5.遍历节点
for (Element propertyElement : propertyElements) {
//判断节点是连接数据库的哪部分信息
//取出name属性的值
String name = propertyElement.attributeValue("name");
if ("driver".equals(name)) {
//表示驱动
//获取property标签value属性的值
String driver = propertyElement.attributeValue("value");
cfg.setDriver(driver);
}
if ("url".equals(name)) {
//表示连接字符串
//获取property标签value属性的值
String url = propertyElement.attributeValue("value");
cfg.setUrl(url);
}
if ("username".equals(name)) {
//表示用户名
//获取property标签value属性的值
String username = propertyElement.attributeValue("value");
cfg.setUsername(username);
}
if ("password".equals(name)) {
//表示密码
//获取property标签value属性的值
String password = propertyElement.attributeValue("value");
cfg.setPassword(password);
}
}
//取出mappers中的所有mapper标签，判断他们使用了resource还是class属性
List<Element> mapperElements = root.selectNodes("//mappers/mapper");
//遍历集合
for (Element mapperElement : mapperElements) {
//判断mapperElement使用的是哪个属性
Attribute attribute = mapperElement.attribute("resource");
if (attribute != null) {
System.out.println("使用的是XML");
//表示有resource属性，用的是XML
//取出属性的值
String mapperPath = attribute.getValue();//获取属性的值"cn/klb/dao/UserDao.xml"
//把映射配置文件的内容获取出来，封装成一个map
Map<String, Mapper> mappers = loadMapperConfiguration(mapperPath);
//给configuration中的mappers赋值
cfg.setMappers(mappers);
} else {
/*
System.out.println("使用的是注解");
//表示没有resource属性，用的是注解
//获取class属性的值
String daoClassPath = mapperElement.attributeValue("class");
//根据daoClassPath获取封装的必要信息
Map<String,Mapper> mappers = loadMapperAnnotation(daoClassPath);
//给configuration中的mappers赋值
cfg.setMappers(mappers);
*/
}
}
//返回Configuration
return cfg;
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
try {
config.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 根据传入的参数，解析XML，并且封装到Map中
* @param mapperPath 映射配置文件的位置
* @return map中包含了获取的唯一标识（key是由dao的全限定类名和方法名组成）
* 以及执行所需的必要信息（value是一个Mapper对象，里面存放的是执行的SQL语句和要封装的实体类全限定类名）
*/
private static Map<String, Mapper> loadMapperConfiguration(String mapperPath) throws IOException {
InputStream in = null;
try {
//定义返回值对象
Map<String, Mapper> mappers = new HashMap<String, Mapper>();
//1.根据路径获取字节输入流
in = Resources.getResourceAsStream(mapperPath);
//2.根据字节输入流获取Document对象
SAXReader reader = new SAXReader();
Document document = reader.read(in);
//3.获取根节点
Element root = document.getRootElement();
//4.获取根节点的namespace属性取值
String namespace = root.attributeValue("namespace");//是组成map中key的部分
//5.获取所有的select节点
List<Element> selectElements = root.selectNodes("//select");
//6.遍历select节点集合
for (Element selectElement : selectElements) {
//取出id属性的值 组成map中key的部分
String id = selectElement.attributeValue("id");
//取出resultType属性的值 组成map中value的部分
String resultType = selectElement.attributeValue("resultType");
//取出文本内容 组成map中value的部分
String queryString = selectElement.getText();
//创建Key
String key = namespace + "." + id;
//创建Value
Mapper mapper = new Mapper();
mapper.setQueryString(queryString);
mapper.setResultType(resultType);
//把key和value存入mappers中
mappers.put(key, mapper);
}
return mappers;
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
in.close();
}
}
}
public class Executor {
public <E> List<E> selectList(Mapper mapper, Connection conn) {
PreparedStatement pstm = null;
ResultSet rs = null;
try {
//1.取出mapper中的数据
String queryString = mapper.getQueryString();//select * from user
String resultType = mapper.getResultType();//com.itheima.domain.User
Class domainClass = Class.forName(resultType);
//2.获取PreparedStatement对象
pstm = conn.prepareStatement(queryString);
//3.执行SQL语句，获取结果集
rs = pstm.executeQuery();
//4.封装结果集
List<E> list = new ArrayList<E>();//定义返回值
while(rs.next()) {
//实例化要封装的实体类对象
E obj = (E)domainClass.newInstance();
//取出结果集的元信息：ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
//取出总列数
int columnCount = rsmd.getColumnCount();
//遍历总列数
for (int i = 1; i <= columnCount; i++) {
//获取每列的名称，列名的序号是从1开始的
String columnName = rsmd.getColumnName(i);
//根据得到列名，获取每列的值
Object columnValue = rs.getObject(columnName);
//给obj赋值：使用Java内省机制（借助PropertyDescriptor实现属性的封装）
PropertyDescriptor pd = new PropertyDescriptor(columnName,domainClass);//要求：实体类的属性和数据库表的列名保持一种
//获取它的写入方法
Method writeMethod = pd.getWriteMethod();
//把获取的列的值，给对象赋值
writeMethod.invoke(obj,columnValue);
}
//把赋好值的对象加入到集合中
list.add(obj);
}
return list;
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
release(pstm,rs);
}
}
private void release(PreparedStatement pstm,ResultSet rs){
if(rs != null){
try {
rs.close();
}catch(Exception e){
e.printStackTrace();
}
}
if(pstm != null){
try {
pstm.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
}
public class DataSourceUtil {
public static Connection getConnection(Configuration cfg) {
try {
Class.forName(cfg.getDriver());
return DriverManager.getConnection(cfg.getUrl(), cfg.getUsername(), cfg.getPassword());
}catch (Exception e){
throw new RuntimeException(e);
}
}
}
总共三个工具类：XMLConfigBuilder、Executor和DataSourceUtil。分别用于解析xml配置文件、执行sql语句和获取连接对象。
3.2.3 编写SqlMapConfig.xml文件
<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" ></property>
<property name="url" value="jdbc:mysql:///eesy" ></property>
<property name="username" value="root"></property>
<property name="password" value="1234"></property>
</dataSource>
</environment>
</environments>
</configuration>
注意：此处我们直接使用的是 mybatis 的配置文件，但是由于我们没有使用 mybatis 的 jar 包，所以要把配置文件的约束删掉否则会报错（如果电脑能接入互联网，不删也行）。
3.2.4 编写读取配置文件的类
public class Resources {
/**
* 根据传入的参数，获取一个字节输入流
* @param filePath
* @return
*/
public static InputStream getResourceAsStream(String filePath) {
return Resources.class.getClassLoader().getResourceAsStream(filePath);
}
}
3.2.5 编写Mapper类
public class Mapper {
private String queryString; // SQL语句
private String resultType; // 实体类的全限定类名
public String getQueryString() {
return queryString;
}
public void setQueryString(String queryString) {
this.queryString = queryString;
}
public String getResultType() {
return resultType;
}
public void setResultType(String resultType) {
this.resultType = resultType;
}
}
Mapper类用于携带要执行的sql语句和要封装的类的全限定类名。
3.2.6 编写Configuration配置类
public class Configuration {
private String Driver;
private String Url;
private String Username;
private String Password;
private Map<String,Mapper> mappers = new HashMap<String,Mapper>();
public Map<String, Mapper> getMappers() {
return mappers;
}
public void setMappers(Map<String, Mapper> mappers) {
// Mappers = mappers;
this.mappers.putAll(mappers); // 此处要追加，不能覆盖
}
public String getDriver() {
return Driver;
}
public void setDriver(String driver) {
Driver = driver;
}
public String getUrl() {
return Url;
}
public void setUrl(String url) {
Url = url;
}
public String getUsername() {
return Username;
}
public void setUsername(String username) {
Username = username;
}
public String getPassword() {
return Password;
}
public void setPassword(String password) {
Password = password;
}
}
Configuration配置类用于携带登陆数据库所需要的信息。
3.2.7 编写User实体类
public class User implements Serializable {
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", birthday=" + birthday +
", sex='" + sex + '\'' +
", address='" + address + '\'' +
'}';
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
User实体类用于封装数据库读取到的记录。
3.3 基于XML的自定义简单MyBatis框架
3.3.1 编写持久层接口和对应的xml文件
UserDao 接口：
public interface UserDao {
/**
* 查询所有操作
* @return
*/
List<User> findAll();
}
UserDao.xml文件：
<?xml version="1.0" encoding="UTF-8"?>
<mapper namespace="cn.klb.dao.UserDao">
<!--配置查询所有-->
<select id="findAll" resultType="cn.klb.domain.User">
select * from user;
</select>
</mapper>
3.3.2 编写构建者类
public class SqlSessionFactoryBuilder {
/**
* 根据参数的字节输入流构建一个SqlSessionFactory工厂
* @param config
* @return
*/
public SqlSessionFactory build(InputStream config) {
Configuration cfg = XMLConfigBuilder.loadConfiguration(config);
return new DefaultSqlSessionFactory(cfg);
}
}
3.3.3 编写SqlSessionFactory接口和实现类
public interface SqlSessionFactory {
SqlSession openSession();
}
---- 分割线 ----
public class DefaultSqlSessionFactory implements SqlSessionFactory {
private Configuration cfg;
public DefaultSqlSessionFactory(Configuration cfg) {
this.cfg = cfg;
}
@Override
public SqlSession openSession() {
return new DefaultSqlSession(cfg);
}
}
3.3.4 编写SqlSession接口和实现类
public interface SqlSession {
<T> T getMapper(Class<T> daoInterfaceClass);
void close();
}
---- 分割线 ----
public class DefaultSqlSession implements SqlSession {
private Configuration cfg;
private Connection conn;
public DefaultSqlSession(Configuration cfg) {
this.cfg = cfg;
this.conn = DataSourceUtil.getConnection(cfg);
}
@Override
public <T> T getMapper(Class<T> daoInterfaceClass) {
return (T) Proxy.newProxyInstance(daoInterfaceClass.getClassLoader(),
new Class[]{daoInterfaceClass},
new MapperProxv(cfg.getMappers(), conn));
}
public <E> List<E> selectList(String statement){
Mapper mapper = cfg.getMappers().get(statement);
return new Executor().selectList(mapper,conn);
}
@Override
public void close() {
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
3.3.5 编写用于创建Dao接口代理对象的类
public class MapperProxv implements InvocationHandler {
private Map<String, Mapper> mappers;
private Connection conn;
public MapperProxv(Map<String, Mapper> mappers, Connection conn) {
this.mappers = mappers;
this.conn = conn;
}
/**
* 用于对被代理对象方法的增强
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//1.获取方法名
String methodName = method.getName();
//2.获取方法所在的类名
String className = method.getDeclaringClass().getName();
//3.组合key
String key = className + "." + methodName;
//4.获取mappers中的Mapper对象
Mapper mapper = mappers.get(key);
//5判断是否有mapper
if (mapper == null) {
throw new IllegalArgumentException("传入参数有误");
}
//6.调用工具类查询所有
return new Executor().selectList(mapper, conn);
}
}
3.3.6 运行测试类
public class MybatisTest {
public static void main(String[] args)throws Exception {
//1.读取配置文件
InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.创建SqlSessionFactory工厂
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
//3.使用工厂生产SqlSession对象
SqlSession session = factory.openSession();
//4.使用SqlSession对象创建Dao接口的代理对象
UserDao userDao = session.getMapper(UserDao.class);
//5.使用代理对象执行方法
List<User> users = userDao.findAll();
for(User user:users){
System.out.println(user);
}
//6.释放资源
session.close();
in.close();
}
}
149
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
