Mybatis学习，自定义Mybatis的基本实现

Mybatis学习，自定义Mybatis

1.创建maven项目，在pom.xml中导入需要的依赖

  <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </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>

2.写主配置文件SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务类型-->
            <transactionManager type="JDBC"/>
            <!--配置数据源-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url"
                          value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;useJDBCCompliantTimezoneShift=true&amp;serverTimezone=Asia/Shanghai"/>
                <property name="username" value="root"/>
                <property name="password" value="991226abc"/>
            </dataSource>
        </environment>
    </environments>
    <!--指定映射配置文件的位置，即每个dao独立的配置文件-->
    <mappers>
        <mapper resource="com/lzl/dao/UserDao.xml"/>
    </mappers>
</configuration>

3.写UserDao.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<mapper namespace="com.lzl.dao.UserDao">
    <!--配置查询所有，指明封装的类-->
    <select id="findAll" resultType="com.lzl.module.User">
        select * from user
    </select>
</mapper>

4.写Resource类，用于获取配置文件的输入流

/**
 * @Description 本类功能:获取配置文件输入流的方法，通过自身的类加载器获取配置文件的流
 * @Author LZL
 * @Date 2020.10.29-16:00
 */
public class Resources {
    public static InputStream getResourceAsStream(String filePath){
        return Resources.class.getClassLoader().getResourceAsStream(filePath);
    }
}

5.创建SqlSessionFactoryBuilder类，用于创建SqlSessionFactory工厂，我用了一个工具类XMLConfigBuilder解析配置文件得到配置文件对象Configuration,再返回建造的SqlSessionFactory对象

/**
 * @Description 本类功能:SQL session factory的构建者，用于创建sqlsessionfactory工厂
 * @Author LZL
 * @Date 2020.10.29-16:04
 */
public class SqlSessionFactoryBuilder {
    public SqlSessionFactory build(InputStream inputStream){
        Configuration configuration= XMLConfigBuilder.loadConfiguration(inputStream);
        System.out.println("创建工厂");
        return new SqlSessionFactoryImpl(configuration);
    }
}

5.1工具类XMLConfigBuilder

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();//获取属性的值"com/itheima/dao/IUserDao.xml"
                    //把映射配置文件的内容获取出来，封装成一个map
                    Map<String,Mapper> mappers = loadMapperConfiguration(mapperPath);
                    //给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();
        }
    }

6.创建SqlSessionFactory接口，其中有创建SqlSession的openSession()方法

public interface SqlSessionFactory {
    SqlSession openSession();
}

6.1创建接口的实现类SqlSessionFactoryImpl,实现open session方法

/**
 * @Description 本类功能:SQL session factory的实现类
 * @Author LZL
 * @Date 2020.10.29-16:32
 */
public class SqlSessionFactoryImpl implements SqlSessionFactory {
    private Configuration cfg;

    public SqlSessionFactoryImpl(Configuration configuration) {
        System.out.println("我是工厂，我被创建了");
        this.cfg = configuration;
    }

    //用于创建一个操作数据库对象
    public SqlSession openSession() {
        return new SqlSessionImpl(cfg);
    }
}

7.创建SqlSession接口，其中有getMapper方法返回代理对象，daoInterfaceClass即为要增强的UserDao接口

/**
 * @Description 本类功能:声明SQL session对象的两个方法，获取mapper对象和关闭流
 * @Author LZL
 * @Date 2020.10.29-16:07
 */
public interface SqlSession {
    <T> T getMapper(Class<T> daoInterfaceClass);
    void close();
}

7.1创建SqlSession接口的实现类，用于返回增强后的代理对象MapperProxy,数据库连接由DataSourceUtil工具类提供

/**
 * @Description 本类功能:SQL session的实现类，可以创建代理对象并返回
 * @Author LZL
 * @Date 2020.10.29-16:36
 */
public class SqlSessionImpl implements SqlSession {
    private Configuration cfg;
private Connection connection;
    public SqlSessionImpl(Configuration cfg) {
        System.out.println("我是SQL session我被创建了");
        this.cfg=cfg;
        connection= DataSourceUtil.getConnection(cfg);
    }

    /**
     * 用于创建代理对象
     * @param daoInterfaceClass
     * @param <T>
     * @return
     */
    public <T> T getMapper(Class<T> daoInterfaceClass) {
        System.out.println("创建代理对象");
              return (T) Proxy.newProxyInstance(daoInterfaceClass.getClassLoader(),new Class[]{daoInterfaceClass},new MapperProxy(cfg.getMappers(),connection));
    }

    /**
     * 释放资源
     */
    public void close() {
        if(connection!=null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

7.2DataSourceUtil工具类

public class DataSourceUtil {
    public static Connection getConnection(Configuration cfg) {
        try {
            Class.forName(cfg.getDriver());
            Connection connection = DriverManager.getConnection(cfg.getUrl(), cfg.getUsername(), cfg.getPassword());
            if (connection != null) {
                System.out.println("我获取到了数据库连接");
                return connection;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return null;
    }
}

8.创建代理对象类MapperProxy,实现方法findAll,通过传入的mappers,再反射得到要执行方法的全名，com.lzl.com.dao.UserDao.findAll，在mappers中找到对应的Mapper对象，使用Excutor工具类的selectList方法执行sql语句，返回结果

/**
 * @Description 本类功能:UserDao的代理对象，用于增强UserDao的findAll方法，实现findAll方法
 * @Author LZL
 * @Date 2020.10.29-16:40
 */
public class MapperProxy implements InvocationHandler {
    private Map<String ,Mapper> mappers;
    private Connection connection;
    public MapperProxy(Map<String, Mapper> mappers,Connection connection) {
        this.mappers=mappers;
        this.connection=connection;
    }

    /**
     * 用于对方法进行增强，调用findAll
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("我是反射增强方法，我被执行了");
        String methodName=method.getName();
        String className=method.getDeclaringClass().getName();
        String key=className+"."+methodName;
        Mapper mapper=mappers.get(key);
        if(mapper==null){
            throw new IllegalArgumentException("传入参数有误");
        }
        //调用
        return new Executor().selectList(mapper,connection);
    }
}

8.1Executor工具类的select List方法

 public <E> List<E> selectList(Mapper mapper, Connection conn) {
        System.out.println("我是select list我被执行了");
        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);
        }
    }

9.测试类MybatisTest

public class MyBatisTest {
    public static void main(String[] args) throws IOException {
        //读取配置文件
        InputStream inputStream= Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SQlsessionFactory工厂
        SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory=builder.build(inputStream);
        //使用工厂生产sqlSession对象
        SqlSession sqlSession=sqlSessionFactory.openSession();
        //使用SQlSession创建dao接口的代理对象
        UserDao userDao=sqlSession.getMapper(UserDao.class);
        //使用代理对象执行方法
        List<User> users=userDao.findAll();
        for (User user : users) {
            System.out.println(user.toString());
        }
        //释放资源
        sqlSession.close();
        inputStream.close();
    }
}

程序截图：