devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

javaee之MyBatis框架1_javaee企业实验报告初识mybatis框架

作者：很楠不爱3 | 2024-05-05 23:40:42

赞

踩

javaee企业实验报告初识mybatis框架

什么是MyBatis框架

先来说一下，什么是框架，框架就是不断升级的半成品软件

框架主要解决的问题：就是应用自身的设计与具体实现解耦，重点放到应用自身的设计上，而不是具体技术实现，具体的技术实现是由底层支撑的

下面说一下什么是ORM思想

  

JDBC编程分析

贴一段之前的JDBC处理代码

上面容易存在的问题：

 MyBatis框架的一个快速入门

一、前期的一个准备工作

 先从官网下载相关MyBatis的一个jar包

 

然后里面有个文档

 

打开文档就可以看到MyBatis的maven坐标

 下面我们先来创建一个maven工程

我采用的是无骨架创建maven

 下面来修改一下pom.xml

添加一个<packaging>jar</packaging> ,创建一个打包方式默认也是jar包

然后还需要去添加mybatis的相关依赖

这个坐标会从镜像仓库下载到本地仓库，具体镜像仓库从什么位置下载，得看你的配置文件，我的是在这

 

 然后左边就会出现mybatis的jar包

下面我们可能还需要一些其他依赖，比如mysql连接jar包，junit测试jar包等等

 因为mybatis是操作数据库的，所以我们现在去在数据库里面创建一个测试库和一张测试表

这个sql我直接贴在这

  1. DROP TABLE IF EXISTS `user`;
  2.  
  3. CREATE TABLE `user` (
  4.   `id` int(11) NOT NULL auto_increment,
  5.   `username` varchar(32) NOT NULL COMMENT '用户名称',
  6.   `birthday` datetime default NULL COMMENT '生日',
  7.   `sex` char(1) default NULL COMMENT '性别',
  8.   `address` varchar(256) default NULL COMMENT '地址',
  9.   PRIMARY KEY  (`id`)
  10. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  11.  
  12.  
  13.  
  14. insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (41,'老王','2018-02-27 17:47:08','男','北京'),(42,'小二王','2018-03-02 15:09:37','女','北京金燕龙'),(43,'小二王','2018-03-04 11:34:34','女','北京金燕龙'),(45,'传智播客','2018-03-04 12:04:06','男','北京金燕龙'),(46,'老王','2018-03-07 17:37:26','男','北京'),(48,'小马宝莉','2018-03-08 11:44:00','女','北京修正');
  15.  
  16.  
  17.  
  18. DROP TABLE IF EXISTS `account`;
  19.  
  20. CREATE TABLE `account` (
  21.   `ID` int(11) NOT NULL COMMENT '编号',
  22.   `UID` int(11) default NULL COMMENT '用户编号',
  23.   `MONEY` double default NULL COMMENT '金额',
  24.   PRIMARY KEY  (`ID`),
  25.   KEY `FK_Reference_8` (`UID`),
  26.   CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
  27. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  28.  
  29.  
  30.  
  31. insert  into `account`(`ID`,`UID`,`MONEY`) values (1,41,1000),(2,45,1000),(3,41,2000);
  32.  
  33.  
  34.  
  35. DROP TABLE IF EXISTS `role`;
  36.  
  37. CREATE TABLE `role` (
  38.   `ID` int(11) NOT NULL COMMENT '编号',
  39.   `ROLE_NAME` varchar(30) default NULL COMMENT '角色名称',
  40.   `ROLE_DESC` varchar(60) default NULL COMMENT '角色描述',
  41.   PRIMARY KEY  (`ID`)
  42. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  43.  
  44.  
  45.  
  46. insert  into `role`(`ID`,`ROLE_NAME`,`ROLE_DESC`) values (1,'院长','管理整个学院'),(2,'总裁','管理整个公司'),(3,'校长','管理整个学校');
  47.  
  48.  
  49.  
  50. DROP TABLE IF EXISTS `user_role`;
  51.  
  52. CREATE TABLE `user_role` (
  53.   `UID` int(11) NOT NULL COMMENT '用户编号',
  54.   `RID` int(11) NOT NULL COMMENT '角色编号',
  55.   PRIMARY KEY  (`UID`,`RID`),
  56.   KEY `FK_Reference_10` (`RID`),
  57.   CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `role` (`ID`),
  58.   CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
  59. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  60.  
  61. insert  into `user_role`(`UID`,`RID`) values (41,1),(45,1),(41,2);
  62.  
  63.

 现在我要把这些信息导入到数据库里面

先在数据库里面创建一个mybatis1数据库名

 因为我是要把这个sql里面所有代码导入到数据库里面，它是直接放在d:\盘下面的

所以去到数据库操作

 

然后我们去看一下user表

数据导入没问题。 准备工作也做完了

二、mysql相关环境搭建

1.先来创建与user表相关的类，注意数据库的字段名字与类的属性名字必须保证一致

User.java

  1. package com.itheima.domain;
  2.  
  3. import java.io.Serializable;
  4. import java.util.Date;
  5.  
  6. /**
  7.  * @author 黑马程序员
  8.  * @Company http://www.ithiema.com
  9.  */
  10. public class User implements Serializable{
  11.  
  12.     private Integer id;
  13.     private String username;
  14.     private Date birthday;
  15.     private String sex;
  16.     private String address;
  17.  
  18.     public Integer getId() {
  19.         return id;
  20.     }
  21.  
  22.     public void setId(Integer id) {
  23.         this.id = id;
  24.     }
  25.  
  26.     public String getUsername() {
  27.         return username;
  28.     }
  29.  
  30.     public void setUsername(String username) {
  31.         this.username = username;
  32.     }
  33.  
  34.     public Date getBirthday() {
  35.         return birthday;
  36.     }
  37.  
  38.     public void setBirthday(Date birthday) {
  39.         this.birthday = birthday;
  40.     }
  41.  
  42.     public String getSex() {
  43.         return sex;
  44.     }
  45.  
  46.     public void setSex(String sex) {
  47.         this.sex = sex;
  48.     }
  49.  
  50.     public String getAddress() {
  51.         return address;
  52.     }
  53.  
  54.     public void setAddress(String address) {
  55.         this.address = address;
  56.     }
  57.  
  58.     @Override
  59.     public String toString() {
  60.         return "User{" +
  61.                 "id=" + id +
  62.                 ", username='" + username + '\'' +
  63.                 ", birthday=" + birthday +
  64.                 ", sex='" + sex + '\'' +
  65.                 ", address='" + address + '\'' +
  66.                 '}';
  67.     }
  68. }

 下面去做一个操作表的dao层

IUserDao.java

  1. package com.pxx.dao;
  2.  
  3. import com.pxx.domain.User;
  4.  
  5. import java.util.List;
  6.  
  7. public interface IUserDao {
  8.  
  9.     /**
  10.      * 查询所有操作
  11.      * @return
  12.      */
  13.     List<User> findAll();
  14. }

下面去resources下面弄一个MyBatis的xml配置文件

这个文件名字叫啥无所谓，一般就叫SqlMapConifg.xml

 既然是xml文档，就肯定要有一个dtd约束

这个约束我把它放到下面

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE configuration  
  3.   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
  4.   "http://mybatis.org/dtd/mybatis-3-config.dtd">

然后我们把SqlMapConfig.xml拿过来

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5.  
  6. <!--MyBatis的主体配置文件-->
  7. <configuration>
  8.     <!--这相当于是配置mysql的环境-->
  9.     <!--这个default默认，随便写但是与下面的id要配一致-->
  10.     <environments default="mysql">
  11.         <environment id="mysql">
  12.             <!--配置事务类型-->
  13.             <transactionManager type="JDBC"></transactionManager>
  14.             <!--配置数据源连接池-->
  15.             <dataSource type="POOLED">
  16.                 <!--配置连接数据库的4个基本信息-->
  17.                 <property name="driver" value="com.mysql.jdbc.Driver"/>
  18.                 <property name="url" value="jdbc:mysql:/// mybatis1"/>
  19.                 <property name="username" value="root"/>
  20.                 <property name="password" value="5201314"/>
  21.             </dataSource>
  22.         </environment>
  23.     </environments>
  24.  
  25.     <!--指定一下映射文件的位置，也就是每一个dao的独立配置文件-->
  26.     <mappers>
  27.         <!--这个文件的位置肯定是在resources里面
  28.         同时每一个包与Dao文件包必须一致
  29.         比如com.pxx.dao.IUserDao(这个是dao文件位置)
  30.         那么在resource里面IUserDao.xml位置就在
  31.         com.pxx.dao.IuserDao.xml
  32.         -->
  33.         <mapper resource="com.pxx.dao.IUserDao.xml"/>
  34.     </mappers>
  35. </configuration>

 然后在去创建dao的配置文件

那么引入一下映射文件的dtd文档约束

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper  
  3.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
  4.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

 看一下IUserDao.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5.  
  6. <!--配置每一个相应dao层的方法,写上相应dao的全类名-->
  7. <mapper namespace="com.pxx.dao.IUserDao">
  8.     <!--Id代表方法名称 resultType:代表值类型
  9.     这里写上它的全类名 -->
  10.     <select id="findAll" resultType="com.pxx.domain.User">
  11.         select * from user
  12.     </select>
  13. </mapper>

 下面针对于上面的环境搭建与配置进行一下总结

 MyBatis的入门案例

一、运行案例

首先配置文件中有一个log4j.properties先把它放到resources下面，先不管它作用是啥

然后在maven的test里面，创建一个测试相关的java文件

 这里直接上MybatisTest代码

MybatisTest.java

  1. package com.pxx.test;
  2.  
  3. import com.pxx.dao.IUserDao;
  4. import com.pxx.domain.User;
  5. import org.apache.ibatis.io.Resources;
  6. import org.apache.ibatis.session.SqlSession;
  7. import org.apache.ibatis.session.SqlSessionFactory;
  8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  9.  
  10. import java.io.IOException;
  11. import java.io.InputStream;
  12. import java.util.List;
  13.  
  14. public class MybatisTest {
  15.     public static void main(String[] args) throws IOException {
  16.         //1.读取配置文件
  17.         //这个Resources是Mytais给我们提供的一个类，直接加载资源文件
  18.         InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
  19.         //2.创建SqlSessionFactory工厂
  20.         SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
  21.         SqlSessionFactory factory = builder.build(in);
  22.         //3.使用工厂生产SqlSession对象，这个可以理解为dao的实现类
  23.         SqlSession session = factory.openSession();
  24.         //4.使用SqlSession创建Dao接口的代理对象
  25.         IUserDao userDao = session.getMapper(IUserDao.class);
  26.         //5.使用代理对象执行方法
  27.         List<User> users = userDao.findAll();
  28.         for(User user : users) {
  29.             System.out.println(user);
  30.         }
  31.  
  32.         //释放资源
  33.         session.close();
  34.         in.close();
  35.     }
  36. }

上面代码一运行，就给报了一个错误

这里大致就是说，找不到IUserDao.xml

 然后我去检测了一下SqlMapConfig.xml的主体配置

上面路径分割不应该用点来分割，应该用反斜线或者正斜线来分割路径

运行结果：

 二、mybatis入门案例中的设计模式分析

 三、mybatis基于注解的入门案例

重新创建一个Maven工程，然后再把之前的文件与pom.xml里面的内容给导入到新项目中

 1.把这个位置的IUserDao.xml文件移除

2.在dao上面配置Select的注解

 3.同时去修改Mybatis的主体配置文件

 之前这种方式按照目录方式寻找文件，现在改成按照package的方式寻找文件

 

 运行结果：

项目里面我们都是讲究简洁，文件能少就少，所以我们一般不会写dao的实现类，当然了Mybatis也还是支持自己写dao的实现类自己来用的。

说一下原理：

先去看这个地方

既然就是说如果自己写实现类，那么创建Dao这个代理对象这步，基本上就可以不要了。

而是可以通过如下方式调用

session.selectList(String statement)调用sql语句给我们返回一个b比如我们需要的LIst集合对象 

 当然上面的调用是在UserDaoImpl中进行的

上面就可以实现DaoImpl的调用，但是这个的话，就必须配上每一个Dao的xml配置文件

 

自定义mybatis框架

首先我们要想一个问题就是：

mybatis在使用代理dao的方式实现增删改查时做什么事呢？
        只有两件事：
            第一：创建代理对象
            第二：在代理对象中调用selectList

一、执行查询所有分析 

 上面这些操作都是去解析配置文件，那么解析配置文件用到的技术就是解析xml的技术

此时我们就用dom4j来解析xml技术

大致操作如下

 

 二、创建代理对象的分析

 

三、自定义mybatis编码操作

先来观察几个类

1.

2. 

3. 

 4.

下面开始正式编码

1.先把一个项目复制过来，然后在pom.xml中把Mybatis框架给删除掉，基本框架搭好

 

所有数据全部导入，删除mybatis包坐标 

 然后就变成了什么也没有

先来创建Resources这个加载类

Resources.java

  1. package com.pxx.mybatis.io;
  2.  
  3. import java.io.InputStream;
  4.  
  5. /**
  6.  * 使用类加载器读取配置文件的类
  7.  */
  8. public class Resources {
  9.     public static InputStream getResourceAsStream(String filePath) {
  10.         return Resources.class.getClassLoader().getResourceAsStream(filePath);
  11.     }
  12.  
  13.  
  14. }

 下面再来创建SqlSessionFactoryBuilder类与SqlSessionFactory接口、SqlSession接口

SqlSessionFactoryBuilder.java
  1. package com.pxx.mybatis.sqlsession;
  2.  
  3. import java.io.InputStream;
  4.  
  5. /**
  6.  *
  7.  * 创建一个SqlSessionFactoryBuilder对象
  8.  */
  9. public class SqlSessionFactoryBuilder {
  10.     //里面也写上相应的方法
  11.     public SqlSessionFactory build(InputStream config) {
  12.         return null;
  13.     }
  14. }
 SqlSessionFactory.java
  1. package com.pxx.mybatis.sqlsession;
  2.  
  3. public interface SqlSessionFactory {
  4.     //用于打开一个新的SqlSession对象
  5.     SqlSession openSession();
  6. }
 SqlSession.java
  1. package com.pxx.mybatis.sqlsession;
  2.  
  3. /**
  4.  * 自定义Mybatis中和数据库交互的核心类
  5.  * 它里面可以创建dao接口的代理对象
  6.  */
  7. public interface SqlSession {
  8.     //泛型这个是先声明<T>,在使用T,声明在使用之前
  9.  
  10.     /**
  11.      * gengju 根据参数创建代理对象
  12.      * @param daoInterfaceClass
  13.      * @param <T>
  14.      * @return
  15.      */
  16.     <T> T getMapper(Class<T> daoInterfaceClass);
  17.  
  18.     void close();
  19. }

然后把上面所有类在MybatisTest当中一导入，基本框架文件就搭好了

 2.解析XML的工具类介绍

这个工具类，我直接贴在下面

XMLConfigBuilder

  1. package com.itheima.mybatis.utils;
  2.  
  3. //import com.itheima.mybatis.annotations.Select;
  4.  
  5. import com.itheima.mybatis.annotations.Select;
  6. import com.itheima.mybatis.cfg.Configuration;
  7. import com.itheima.mybatis.cfg.Mapper;
  8. import com.itheima.mybatis.io.Resources;
  9. import org.dom4j.Attribute;
  10. import org.dom4j.Document;
  11. import org.dom4j.Element;
  12. import org.dom4j.io.SAXReader;
  13.  
  14. import java.io.IOException;
  15. import java.io.InputStream;
  16. import java.lang.reflect.Method;
  17. import java.lang.reflect.ParameterizedType;
  18. import java.lang.reflect.Type;
  19. import java.util.HashMap;
  20. import java.util.List;
  21. import java.util.Map;
  22.  
  23. /**
  24.  * @author 黑马程序员
  25.  * @Company http://www.ithiema.com
  26.  *  用于解析配置文件
  27.  */
  28. public class XMLConfigBuilder {
  29.  
  30.  
  31.  
  32.     /**
  33.      * 解析主配置文件，把里面的内容填充到DefaultSqlSession所需要的地方
  34.      * 使用的技术：
  35.      *      dom4j+xpath
  36.      */
  37.     public static Configuration loadConfiguration(InputStream config){
  38.         try{
  39.             //定义封装连接信息的配置对象（mybatis的配置对象）
  40.             Configuration cfg = new Configuration();
  41.  
  42.             //1.获取SAXReader对象
  43.             SAXReader reader = new SAXReader();
  44.             //2.根据字节输入流获取Document对象
  45.             Document document = reader.read(config);
  46.             //3.获取根节点
  47.             Element root = document.getRootElement();
  48.             //4.使用xpath中选择指定节点的方式，获取所有property节点
  49.             List<Element> propertyElements = root.selectNodes("//property");
  50.             //5.遍历节点
  51.             for(Element propertyElement : propertyElements){
  52.                 //判断节点是连接数据库的哪部分信息
  53.                 //取出name属性的值
  54.                 String name = propertyElement.attributeValue("name");
  55.                 if("driver".equals(name)){
  56.                     //表示驱动
  57.                     //获取property标签value属性的值
  58.                     String driver = propertyElement.attributeValue("value");
  59.                     cfg.setDriver(driver);
  60.                 }
  61.                 if("url".equals(name)){
  62.                     //表示连接字符串
  63.                     //获取property标签value属性的值
  64.                     String url = propertyElement.attributeValue("value");
  65.                     cfg.setUrl(url);
  66.                 }
  67.                 if("username".equals(name)){
  68.                     //表示用户名
  69.                     //获取property标签value属性的值
  70.                     String username = propertyElement.attributeValue("value");
  71.                     cfg.setUsername(username);
  72.                 }
  73.                 if("password".equals(name)){
  74.                     //表示密码
  75.                     //获取property标签value属性的值
  76.                     String password = propertyElement.attributeValue("value");
  77.                     cfg.setPassword(password);
  78.                 }
  79.             }
  80.             //取出mappers中的所有mapper标签，判断他们使用了resource还是class属性
  81.             List<Element> mapperElements = root.selectNodes("//mappers/mapper");
  82.             //遍历集合
  83.             for(Element mapperElement : mapperElements){
  84.                 //判断mapperElement使用的是哪个属性
  85.                 Attribute attribute = mapperElement.attribute("resource");
  86.                 if(attribute != null){
  87.                     System.out.println("使用的是XML");
  88.                     //表示有resource属性，用的是XML
  89.                     //取出属性的值
  90.                     String mapperPath = attribute.getValue();//获取属性的值"com/itheima/dao/IUserDao.xml"
  91.                     //把映射配置文件的内容获取出来，封装成一个map
  92.                     Map<String,Mapper> mappers = loadMapperConfiguration(mapperPath);
  93.                     //给configuration中的mappers赋值
  94.                     cfg.setMappers(mappers);
  95.                 }else{
  96.                     System.out.println("使用的是注解");
  97.                     //表示没有resource属性，用的是注解
  98.                     //获取class属性的值
  99.                     String daoClassPath = mapperElement.attributeValue("class");
  100.                     //根据daoClassPath获取封装的必要信息
  101.                     Map<String,Mapper> mappers = loadMapperAnnotation(daoClassPath);
  102.                     //给configuration中的mappers赋值
  103.                     cfg.setMappers(mappers);
  104.                 }
  105.             }
  106.             //返回Configuration
  107.             return cfg;
  108.         }catch(Exception e){
  109.             throw new RuntimeException(e);
  110.         }finally{
  111.             try {
  112.                 config.close();
  113.             }catch(Exception e){
  114.                 e.printStackTrace();
  115.             }
  116.         }
  117.  
  118.     }
  119.  
  120.     /**
  121.      * 根据传入的参数，解析XML，并且封装到Map中
  122.      * @param mapperPath    映射配置文件的位置
  123.      * @return  map中包含了获取的唯一标识（key是由dao的全限定类名和方法名组成）
  124.      *          以及执行所需的必要信息（value是一个Mapper对象，里面存放的是执行的SQL语句和要封装的实体类全限定类名）
  125.      */
  126.     private static Map<String,Mapper> loadMapperConfiguration(String mapperPath)throws IOException {
  127.         InputStream in = null;
  128.         try{
  129.             //定义返回值对象
  130.             Map<String,Mapper> mappers = new HashMap<String,Mapper>();
  131.             //1.根据路径获取字节输入流
  132.             in = Resources.getResourceAsStream(mapperPath);
  133.             //2.根据字节输入流获取Document对象
  134.             SAXReader reader = new SAXReader();
  135.             Document document = reader.read(in);
  136.             //3.获取根节点
  137.             Element root = document.getRootElement();
  138.             //4.获取根节点的namespace属性取值
  139.             String namespace = root.attributeValue("namespace");//是组成map中key的部分
  140.             //5.获取所有的select节点
  141.             List<Element> selectElements = root.selectNodes("//select");
  142.             //6.遍历select节点集合
  143.             for(Element selectElement : selectElements){
  144.                 //取出id属性的值      组成map中key的部分
  145.                 String id = selectElement.attributeValue("id");
  146.                 //取出resultType属性的值  组成map中value的部分
  147.                 String resultType = selectElement.attributeValue("resultType");
  148.                 //取出文本内容            组成map中value的部分
  149.                 String queryString = selectElement.getText();
  150.                 //创建Key
  151.                 String key = namespace+"."+id;
  152.                 //创建Value
  153.                 Mapper mapper = new Mapper();
  154.                 mapper.setQueryString(queryString);
  155.                 mapper.setResultType(resultType);
  156.                 //把key和value存入mappers中
  157.                 mappers.put(key,mapper);
  158.             }
  159.             return mappers;
  160.         }catch(Exception e){
  161.             throw new RuntimeException(e);
  162.         }finally{
  163.             in.close();
  164.         }
  165.     }
  166.  
  167.     /**
  168.      * 根据传入的参数，得到dao中所有被select注解标注的方法。
  169.      * 根据方法名称和类名，以及方法上注解value属性的值，组成Mapper的必要信息
  170.      * @param daoClassPath
  171.      * @return
  172.      */
  173.     private static Map<String,Mapper> loadMapperAnnotation(String daoClassPath)throws Exception{
  174.         //定义返回值对象
  175.         Map<String,Mapper> mappers = new HashMap<String, Mapper>();
  176.  
  177.         //1.得到dao接口的字节码对象
  178.         Class daoClass = Class.forName(daoClassPath);
  179.         //2.得到dao接口中的方法数组
  180.         Method[] methods = daoClass.getMethods();
  181.         //3.遍历Method数组
  182.         for(Method method : methods){
  183.             //取出每一个方法，判断是否有select注解
  184.             boolean isAnnotated = method.isAnnotationPresent(Select.class);
  185.             if(isAnnotated){
  186.                 //创建Mapper对象
  187.                 Mapper mapper = new Mapper();
  188.                 //取出注解的value属性值
  189.                 Select selectAnno = method.getAnnotation(Select.class);
  190.                 String queryString = selectAnno.value();
  191.                 mapper.setQueryString(queryString);
  192.                 //获取当前方法的返回值，还要求必须带有泛型信息
  193.                 Type type = method.getGenericReturnType();//List<User>
  194.                 //判断type是不是参数化的类型
  195.                 if(type instanceof ParameterizedType){
  196.                     //强转
  197.                     ParameterizedType ptype = (ParameterizedType)type;
  198.                     //得到参数化类型中的实际类型参数
  199.                     Type[] types = ptype.getActualTypeArguments();
  200.                     //取出第一个
  201.                     Class domainClass = (Class)types[0];
  202.                     //获取domainClass的类名
  203.                     String resultType = domainClass.getName();
  204.                     //给Mapper赋值
  205.                     mapper.setResultType(resultType);
  206.                 }
  207.                 //组装key的信息
  208.                 //获取方法的名称
  209.                 String methodName = method.getName();
  210.                 String className = method.getDeclaringClass().getName();
  211.                 String key = className+"."+methodName;
  212.                 //给map赋值
  213.                 mappers.put(key,mapper);
  214.             }
  215.         }
  216.         return mappers;
  217.     }
  218.  
  219.  
  220.  
  221.  
  222.  
  223.  
  224.  
  225. }

这个文档的作用，就是解析xml文档，然后把信息封装到之前的一个Map映射类里面，然后传递给selectList方法调用。

文档放过去之后，有很多红色的部分，需要处理一下

 

首先我们需要一个Configuration对象

 

Configuration.java

  1. package com.pxx.mybatis.cfg;
  2.  
  3. /**
  4.  * 这个也就是Mybatis中的主体配置信息
  5.  * 里面会设置什么URL driver username password这些数据
  6.  * 库连接的相应信息
  7.  */
  8. public class Configuration {
  9.     private String driver;
  10.     private String url;
  11.     private String username;
  12.     private String password;
  13.  
  14.     private Map<String,Mapper> mappers = new HashMap<String,Mapper>();
  15.  
  16.     public Map<String, Mapper> getMappers() {
  17.         return mappers;
  18.     }
  19.  
  20.     public void setMappers(Map<String, Mapper> mappers) {
  21.         this.mappers.putAll(mappers);//此处需要使用追加的方式
  22.     }
  23.  
  24.     public String getDriver() {
  25.         return driver;
  26.     }
  27.  
  28.     public void setDriver(String driver) {
  29.         this.driver = driver;
  30.     }
  31.  
  32.     public String getUrl() {
  33.         return url;
  34.     }
  35.  
  36.     public void setUrl(String url) {
  37.         this.url = url;
  38.     }
  39.  
  40.     public String getUsername() {
  41.         return username;
  42.     }
  43.  
  44.     public void setUsername(String username) {
  45.         this.username = username;
  46.     }
  47.  
  48.     public String getPassword() {
  49.         return password;
  50.     }
  51.  
  52.     public void setPassword(String password) {
  53.         this.password = password;
  54.     }
  55. }

问题解析：

 

这里为什么采用this.mappers.putAll(mappers)？为什么不是this.mappers= mappers

 去看一下XMLConfigBuilder.java里面

 上面获取的就是这个里面的信息

在mappers里面可不止一个mapper，也就是说可能不止一个IUserDao.xml文件，有很多，如果不用putAll的方式，后面解析出来的Dao.xml文件信息就会覆盖前面

 这个Mapper里面其实存放的就是这个部分的信息

 

 然后我们需要一个Mapper类

Mapper.java

  1. package com.pxx.mybatis.cfg;
  2.  
  3. /**
  4.  * 封装执行的sql语句和结果类的全类名
  5.  */
  6. public class Mapper {
  7.  
  8.     private String queryString;//sql
  9.     private String resultType;//实体类的全限定类名
  10.  
  11.     public String getQueryString() {
  12.         return queryString;
  13.     }
  14.  
  15.     public void setQueryString(String queryString) {
  16.         this.queryString = queryString;
  17.     }
  18.  
  19.     public String getResultType() {
  20.         return resultType;
  21.     }
  22.  
  23.     public void setResultType(String resultType) {
  24.         this.resultType = resultType;
  25.     }
  26. }

 上面还需要引入两个jar包的依赖坐标

这样一引入，然后重新导包就可以了

  1. package com.pxx.mybatis.utils;
  2.  
  3. //import com.itheima.mybatis.annotations.Select;
  4.  
  5.  
  6. import com.pxx.mybatis.cfg.Configuration;
  7. import com.pxx.mybatis.cfg.Mapper;
  8. import com.pxx.mybatis.io.Resources;
  9. import org.dom4j.Attribute;
  10. import org.dom4j.Document;
  11. import org.dom4j.Element;
  12. import org.dom4j.io.SAXReader;
  13.  
  14.  
  15. import java.io.IOException;
  16. import java.io.InputStream;
  17. import java.lang.reflect.Method;
  18. import java.lang.reflect.ParameterizedType;
  19. import java.lang.reflect.Type;
  20. import java.util.HashMap;
  21. import java.util.List;
  22. import java.util.Map;
  23.  
  24. /**
  25.  * @author 黑马程序员
  26.  * @Company http://www.ithiema.com
  27.  *  用于解析配置文件
  28.  */
  29. public class XMLConfigBuilder {
  30.  
  31.  
  32.  
  33.     /**
  34.      * 解析主配置文件，把里面的内容填充到DefaultSqlSession所需要的地方
  35.      * 使用的技术：
  36.      *      dom4j+xpath
  37.      */
  38.     public static Configuration loadConfiguration(InputStream config){
  39.         try{
  40.             //定义封装连接信息的配置对象（mybatis的配置对象）
  41.             Configuration cfg = new Configuration();
  42.             //1.获取SAXReader对象
  43.             SAXReader reader = new SAXReader();
  44.             //2.根据字节输入流获取Document对象
  45.             Document document = reader.read(config);
  46.             //3.获取根节点
  47.             Element root = document.getRootElement();
  48.             //4.使用xpath中选择指定节点的方式，获取所有property节点
  49.             List<Element> propertyElements = root.selectNodes("//property");
  50.             //5.遍历节点
  51.             for(Element propertyElement : propertyElements){
  52.                 //判断节点是连接数据库的哪部分信息
  53.                 //取出name属性的值
  54.                 String name = propertyElement.attributeValue("name");
  55.                 if("driver".equals(name)){
  56.                     //表示驱动
  57.                     //获取property标签value属性的值
  58.                     String driver = propertyElement.attributeValue("value");
  59.                     cfg.setDriver(driver);
  60.                 }
  61.                 if("url".equals(name)){
  62.                     //表示连接字符串
  63.                     //获取property标签value属性的值
  64.                     String url = propertyElement.attributeValue("value");
  65.                     cfg.setUrl(url);
  66.                 }
  67.                 if("username".equals(name)){
  68.                     //表示用户名
  69.                     //获取property标签value属性的值
  70.                     String username = propertyElement.attributeValue("value");
  71.                     cfg.setUsername(username);
  72.                 }
  73.                 if("password".equals(name)){
  74.                     //表示密码
  75.                     //获取property标签value属性的值
  76.                     String password = propertyElement.attributeValue("value");
  77.                     cfg.setPassword(password);
  78.                 }
  79.             }
  80.             //取出mappers中的所有mapper标签，判断他们使用了resource还是class属性
  81.             List<Element> mapperElements = root.selectNodes("//mappers/mapper");
  82.             //遍历集合
  83.             for(Element mapperElement : mapperElements){
  84.                 //判断mapperElement使用的是哪个属性
  85.                 Attribute attribute = mapperElement.attribute("resource");
  86.                 if(attribute != null){
  87.                     System.out.println("使用的是XML");
  88.                     //表示有resource属性，用的是XML
  89.                     //取出属性的值
  90.                     String mapperPath = attribute.getValue();//获取属性的值"com/pxx/dao/IUserDao.xml"
  91.                     //把映射配置文件的内容获取出来，封装成一个map
  92.                     Map<String, Mapper> mappers = loadMapperConfiguration(mapperPath);
  93.                     //给configuration中的mappers赋值
  94.                     cfg.setMappers(mappers);
  95.                 }else{
  96.                     //注解我们暂时不用
  97.                     //先把注解注释掉
  98.                     /*System.out.println("使用的是注解");
  99.                     //表示没有resource属性，用的是注解
  100.                     //获取class属性的值
  101.                     String daoClassPath = mapperElement.attributeValue("class");
  102.                     //根据daoClassPath获取封装的必要信息
  103.                     Map<String,Mapper> mappers = loadMapperAnnotation(daoClassPath);
  104.                     //给configuration中的mappers赋值
  105.                     cfg.setMappers(mappers);*/
  106.                 }
  107.             }
  108.             //返回Configuration
  109.             return cfg;
  110.         }catch(Exception e){
  111.             throw new RuntimeException(e);
  112.         }finally{
  113.             try {
  114.                 config.close();
  115.             }catch(Exception e){
  116.                 e.printStackTrace();
  117.             }
  118.         }
  119.  
  120.     }
  121.  
  122.     /**
  123.      * 根据传入的参数，解析XML，并且封装到Map中
  124.      * @param mapperPath    映射配置文件的位置
  125.      * @return  map中包含了获取的唯一标识（key是由dao的全限定类名和方法名组成）
  126.      *          以及执行所需的必要信息（value是一个Mapper对象，里面存放的是执行的SQL语句和要封装的实体类全限定类名）
  127.      */
  128.     private static Map<String,Mapper> loadMapperConfiguration(String mapperPath)throws IOException {
  129.         InputStream in = null;
  130.         try{
  131.             //定义返回值对象
  132.             Map<String,Mapper> mappers = new HashMap<String,Mapper>();
  133.             //1.根据路径获取字节输入流
  134.             in = Resources.getResourceAsStream(mapperPath);
  135.             //2.根据字节输入流获取Document对象
  136.             SAXReader reader = new SAXReader();
  137.             Document document = reader.read(in);
  138.             //3.获取根节点
  139.             Element root = document.getRootElement();
  140.             //4.获取根节点的namespace属性取值
  141.             String namespace = root.attributeValue("namespace");//是组成map中key的部分
  142.             //5.获取所有的select节点
  143.             List<Element> selectElements = root.selectNodes("//select");
  144.             //6.遍历select节点集合
  145.             for(Element selectElement : selectElements){
  146.                 //取出id属性的值      组成map中key的部分
  147.                 String id = selectElement.attributeValue("id");
  148.                 //取出resultType属性的值  组成map中value的部分
  149.                 String resultType = selectElement.attributeValue("resultType");
  150.                 //取出文本内容            组成map中value的部分
  151.                 String queryString = selectElement.getText();
  152.                 //创建Key
  153.                 String key = namespace+"."+id;//这个就是selectList的具体语法，找到这个方法
  154.                 //创建Value
  155.                 Mapper mapper = new Mapper();
  156.                 mapper.setQueryString(queryString);
  157.                 mapper.setResultType(resultType);
  158.                 //把key和value存入mappers中
  159.                 mappers.put(key,mapper);
  160.             }
  161.             return mappers;
  162.         }catch(Exception e){
  163.             throw new RuntimeException(e);
  164.         }finally{
  165.             in.close();
  166.         }
  167.     }
  168.  
  169.     /**
  170.      * 根据传入的参数，得到dao中所有被select注解标注的方法。
  171.      * 根据方法名称和类名，以及方法上注解value属性的值，组成Mapper的必要信息
  172.      * @param daoClassPath
  173.      * @return
  174.      *//*
  175.     private static Map<String,Mapper> loadMapperAnnotation(String daoClassPath)throws Exception{
  176.         //定义返回值对象
  177.         Map<String,Mapper> mappers = new HashMap<String, Mapper>();
  179.         //1.得到dao接口的字节码对象
  180.         Class daoClass = Class.forName(daoClassPath);
  181.         //2.得到dao接口中的方法数组
  182.         Method[] methods = daoClass.getMethods();
  183.         //3.遍历Method数组
  184.         for(Method method : methods){
  185.             //取出每一个方法，判断是否有select注解
  186.             boolean isAnnotated = method.isAnnotationPresent(Select.class);
  187.             if(isAnnotated){
  188.                 //创建Mapper对象
  189.                 Mapper mapper = new Mapper();
  190.                 //取出注解的value属性值
  191.                 Select selectAnno = method.getAnnotation(Select.class);
  192.                 String queryString = selectAnno.value();
  193.                 mapper.setQueryString(queryString);
  194.                 //获取当前方法的返回值，还要求必须带有泛型信息
  195.                 Type type = method.getGenericReturnType();//List<User>
  196.                 //判断type是不是参数化的类型
  197.                 if(type instanceof ParameterizedType){
  198.                     //强转
  199.                     ParameterizedType ptype = (ParameterizedType)type;
  200.                     //得到参数化类型中的实际类型参数
  201.                     Type[] types = ptype.getActualTypeArguments();
  202.                     //取出第一个
  203.                     Class domainClass = (Class)types[0];
  204.                     //获取domainClass的类名
  205.                     String resultType = domainClass.getName();
  206.                     //给Mapper赋值
  207.                     mapper.setResultType(resultType);
  208.                 }
  209.                 //组装key的信息
  210.                 //获取方法的名称
  211.                 String methodName = method.getName();
  212.                 String className = method.getDeclaringClass().getName();
  213.                 String key = className+"."+methodName;
  214.                 //给map赋值
  215.                 mappers.put(key,mapper);
  216.             }
  217.         }
  218.         return mappers;
  219.     }*/
  220.  
  221.  
  222. }

 3.创建两个默认实现类并分析两个类之间的关系

在之前先来看这几个类之间实现关系图

再来引入两个工具类：

上面两个页面的代码贴一下

DataSourceUtil

  1. package com.pxx.mybatis.utils;
  2.  
  3.  
  4. import com.pxx.mybatis.cfg.Configuration;
  5.  
  6. import java.sql.Connection;
  7. import java.sql.DriverManager;
  8.  
  9. /**
  10.  * @author 黑马程序员
  11.  * @Company http://www.ithiema.com
  12.  * 用于创建数据源的工具类
  13.  */
  14. public class DataSourceUtil {
  15.  
  16.     /**
  17.      * 用于获取一个连接
  18.      * @param cfg
  19.      * @return
  20.      */
  21.     public static Connection getConnection(Configuration cfg){
  22.         try {
  23.             Class.forName(cfg.getDriver());
  24.             return DriverManager.getConnection(cfg.getUrl(), cfg.getUsername(), cfg.getPassword());
  25.         }catch(Exception e){
  26.             throw new RuntimeException(e);
  27.         }
  28.     }
  29. }

 Executor

  1. package com.pxx.mybatis.utils;
  2.  
  3.  
  4. import com.pxx.mybatis.cfg.Mapper;
  5.  
  6. import java.beans.PropertyDescriptor;
  7. import java.lang.reflect.Method;
  8. import java.sql.Connection;
  9. import java.sql.PreparedStatement;
  10. import java.sql.ResultSet;
  11. import java.sql.ResultSetMetaData;
  12. import java.util.ArrayList;
  13. import java.util.List;
  14.  
  15. /**
  16.  * @author 黑马程序员
  17.  * @Company http://www.ithiema.com
  18.  * 负责执行SQL语句，并且封装结果集
  19.  */
  20. public class Executor {
  21.  
  22.     public <E> List<E> selectList(Mapper mapper, Connection conn) {
  23.         PreparedStatement pstm = null;
  24.         ResultSet rs = null;
  25.         try {
  26.             //1.取出mapper中的数据
  27.             String queryString = mapper.getQueryString();//select * from user
  28.             String resultType = mapper.getResultType();//com.itheima.domain.User
  29.             Class domainClass = Class.forName(resultType);
  30.             //2.获取PreparedStatement对象
  31.             pstm = conn.prepareStatement(queryString);
  32.             //3.执行SQL语句，获取结果集
  33.             rs = pstm.executeQuery();
  34.             //4.封装结果集
  35.             List<E> list = new ArrayList<E>();//定义返回值
  36.             while(rs.next()) {
  37.                 //实例化要封装的实体类对象
  38.                 E obj = (E)domainClass.newInstance();
  39.  
  40.                 //取出结果集的元信息：ResultSetMetaData
  41.                 ResultSetMetaData rsmd = rs.getMetaData();
  42.                 //取出总列数
  43.                 int columnCount = rsmd.getColumnCount();
  44.                 //遍历总列数
  45.                 for (int i = 1; i <= columnCount; i++) {
  46.                     //获取每列的名称，列名的序号是从1开始的
  47.                     String columnName = rsmd.getColumnName(i);
  48.                     //根据得到列名，获取每列的值
  49.                     Object columnValue = rs.getObject(columnName);
  50.                     //给obj赋值：使用Java内省机制（借助PropertyDescriptor实现属性的封装）
  51.                     PropertyDescriptor pd = new PropertyDescriptor(columnName,domainClass);//要求：实体类的属性和数据库表的列名保持一种
  52.                     //获取它的写入方法
  53.                     Method writeMethod = pd.getWriteMethod();
  54.                     //把获取的列的值，给对象赋值
  55.                     writeMethod.invoke(obj,columnValue);
  56.                 }
  57.                 //把赋好值的对象加入到集合中
  58.                 list.add(obj);
  59.             }
  60.             return list;
  61.         } catch (Exception e) {
  62.             throw new RuntimeException(e);
  63.         } finally {
  64.             release(pstm,rs);
  65.         }
  66.     }
  67.  
  68.  
  69.     private void release(PreparedStatement pstm,ResultSet rs){
  70.         if(rs != null){
  71.             try {
  72.                 rs.close();
  73.             }catch(Exception e){
  74.                 e.printStackTrace();
  75.             }
  76.         }
  77.  
  78.         if(pstm != null){
  79.             try {
  80.                 pstm.close();
  81.             }catch(Exception e){
  82.                 e.printStackTrace();
  83.             }
  84.         }
  85.     }
  86. }

好了，现在来上业务代码

DefaultSqlSession.java

  1. package com.pxx.mybatis.sqlsession.defaults;
  2.  
  3. import com.pxx.mybatis.cfg.Configuration;
  4. import com.pxx.mybatis.cfg.Mapper;
  5. import com.pxx.mybatis.sqlsession.SqlSession;
  6. import com.pxx.mybatis.utils.DataSourceUtil;
  7. import com.pxx.mybatis.utils.Executor;
  8.  
  9. import java.lang.reflect.InvocationHandler;
  10. import java.lang.reflect.Method;
  11. import java.lang.reflect.Proxy;
  12. import java.sql.Connection;
  13. import java.util.Map;
  14.  
  15. public class DefaultSqlSession implements SqlSession {
  16.  
  17.     //这里需要拿到配置信息与连接信息
  18.     //后面用于创建代理对象
  19.     private Configuration cfg;
  20.     private Connection connection;
  21.  
  22.     public DefaultSqlSession(Configuration cfg) {
  23.         this.cfg = cfg;
  24.         connection = DataSourceUtil.getConnection(cfg);
  25.     }
  26.  
  27.     //这里用JDk的动态代理增强，哪一个接口进来就给它进行增强
  28.     public <T> T getMapper(Class<T> daoInterfaceClass) {
  29.        return  (T)Proxy.newProxyInstance(daoInterfaceClass.getClassLoader(),
  30.                new Class[]{daoInterfaceClass}, new InvocationHandler() {
  31.                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  32.                        //这里就是具体的方法增强
  33.                        //拿到每一个Dao封装的全类名，id方法名等相关信息
  34.                        //大致就是这样:ccom.pxx.pxx.IUserDao.findall->sql语句
  35.                        Map<String,Mapper> mappers = cfg.getMappers();
  36.                        //先来获取接口的方法名字
  37.                        String methodName = method.getName();
  38.                        //获取方法所在类的名称
  39.                        String className = method.getDeclaringClass().getName();
  40.                        //4.获取mappers中的Mapper对象
  41.                        //3.组合key
  42.                        String key = className+"."+methodName;
  43.                        Mapper mapper = mappers.get(key);
  44.                        //5.判断是否有mapper
  45.                        if(mapper == null){
  46.                            throw new IllegalArgumentException("传入的参数有误");
  47.                        }
  48.                        return new Executor().selectList(mapper,connection);
  49.                    }
  50.                });
  51.     }
  52.  
  53.     public void close() {
  54.         if(connection != null) {
  55.             try {
  56.                 connection.close();
  57.             } catch (Exception e) {
  58.                 e.printStackTrace();
  59.             }
  60.         }
  61.     }
  62. }

再来看一下DefaultSqlSessionFactory.java

  1. package com.pxx.mybatis.sqlsession.defaults;
  2.  
  3. import com.pxx.mybatis.cfg.Configuration;
  4. import com.pxx.mybatis.sqlsession.SqlSession;
  5. import com.pxx.mybatis.sqlsession.SqlSessionFactory;
  6.  
  7. public class DefaultSqlSessionFactory implements SqlSessionFactory {
  8.     private Configuration cfg;
  9.  
  10.     public DefaultSqlSessionFactory(Configuration cfg){
  11.         this.cfg = cfg;
  12.     }
  13.  
  14.     public SqlSession openSession() {
  15.         return new DefaultSqlSession(cfg);
  16.     }
  17. }

再来看一下SqlSessionFactoryBuilder.java

  1. package com.pxx.mybatis.sqlsession;
  2.  
  3. import com.pxx.mybatis.cfg.Configuration;
  4. import com.pxx.mybatis.sqlsession.defaults.DefaultSqlSessionFactory;
  5. import com.pxx.mybatis.utils.XMLConfigBuilder;
  6.  
  7. import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
  8. import java.io.InputStream;
  9.  
  10. /**
  11.  *
  12.  * 创建一个SqlSessionFactoryBuilder对象
  13.  */
  14. public class SqlSessionFactoryBuilder {
  15.     //里面也写上相应的方法
  16.     public SqlSessionFactory build(InputStream config) {
  17.         //把Mybatis的主体配置信息放到Configuration里面
  18.         Configuration cfg = XMLConfigBuilder.loadConfiguration(config);
  19.         return new DefaultSqlSessionFactory(cfg);
  20.     }
  21. }

运行结果：

 4.实现基于注解配置查询所有

就是把上面的代码重构一下

1.去修改SqlMapConfig.xml的内容

把它变成class

 

2.修改IUserDao.java的内容 

加上一个Select注解，注意之前有Mybatis框架给我们提供这样一个注解类，现在没有，所以这个Select这个注解接口我们必须自己写

 

select.java

 

  1. package com.pxx.mybatis.annotations;
  2.  
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  7.  
  8. @Retention(RetentionPolicy.RUNTIME)
  9. @Target(ElementType.METHOD)
  10. public @interface Select {
  11.     /**
  12.      * 配置sql语句
  13.      */
  14.     String value();
  15. }

然后再去改Dao文件

 然后我们要去修改XMLConfigBuilder文件，因为之前我把利用注解读取xml信息的部分给注释了

测试运行一把就ok

好了，Mybatis第一篇先说到这 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/541422
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号