自定义Mybatis框架

项目结构:

    

https://files-cdn.cnblogs.com/files/mkl7/ownMybatis.zip

1. 创建maven工程并引入坐标:

<?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.mkl</groupId>
    <artifactId>ownMybatis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <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>
        </dependency>
        <!--dom4j是一个Java的XML API，是jdom的升级品，用来读写XML文件的。-->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <!--Jaxen是一个Java编写的开源的XPath库。
        这是适应多种不同的对象模型，包括DOM，XOM，dom4j和JDOM。
        也可以作为适配器，转换Java字节代码或XML的Java bean为xml，
        从而使您可以使用XPath查询这些树了。-->
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.6</version>
        </dependency>
    </dependencies>

</project>

2. 创建实体类User

package com.mkl.domain;

import java.io.Serializable;
import java.util.Date;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:12:34
 */

public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String 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;
    }

    @Override
    public String toString () {
        return "User{" +
                "id=" + id +
                ", username=‘" + username + ‘\‘‘ +
                ", birthday=" + birthday +
                ", sex=‘" + sex + ‘\‘‘ +
                ", address=‘" + address + ‘\‘‘ +
                ‘}‘;
    }
}

3. 编写DAO层接口

package com.mkl.dao;

import com.mkl.domain.User;

import java.util.List;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:12:48
 * 用户的持久层接口
 */

public interface IUserDao {

    /**
     * 查询所有用户
     */
    List<User> findAll();
}

4.编写主配置文件SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <environments default="MySql">
        <environment default="MySql">
            <transactionManager type="JDBC">
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver" />
                    <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatisdb" />
                    <property name="username" value="root" />
                    <property name="password" value="root" />
                </dataSource>
            </transactionManager>
        </environment>
    </environments>

    <mappers>
        <mapper resource="com/mkl/dao/IUserDao.xml"></mapper>
    </mappers>
</configuration>

5. 编写映射配置文件, 注意目录  IUserDao.xml

<?xml version="1.0" encoding="utf-8" ?>
<mapper namespace="com.mkl.dao.IUserDao">
    <selsect id="findAll" resultType="com.mkl.domain.User">
        select * from user
    </selsect>
</mapper>

6. 编写映射配置文件对应的实体类

package com.mkl.config;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:01
 */

public class Mapper {
    private String SQL;  //sql语句
    private String resultType; //返回值类型

    public String getSQL () {
        return SQL;
    }

    public void setSQL (String SQL) {
        this.SQL = SQL;
    }

    public String getResultType () {
        return resultType;
    }

    public void setResultType (String resultType) {
        this.resultType = resultType;
    }
}

7. 编写主配置文件对应的实体类

package com.mkl.config;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:01
 */

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 String getDriver () {
        return driver;
    }

    public void setDriver (String driver) {
        this.driver = driver;
    }

    public String getUrl () {
        return url;
    }

    public void setUrl (String url) {
        this.url = url;
    }

    public String getUsername () {
        return username;
    }

    public void setUsername (String username) {
        this.username = username;
    }

    public String getPassword () {
        return password;
    }

    public void setPassword (String password) {
        this.password = password;
    }

    public Map<String, Mapper> getMappers () {
        return mappers;
    }

    public void setMappers (Map<String, Mapper> mappers) {
        this.mappers = mappers;
    }
}

8. 编写Resources用于读取配置文件    使用类加载器读取配置文件的类

　　根据传入的filePath参数,读取文件,获取字节输入流,并返回

package com.mkl.mybatis.io;

import java.io.InputStream;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:08
 * 使用类加载器读取配置文件的类
 */

public class Resources {

    /**
     * 根据传入的参数,读取文件,获取字节输入流
     * @param filePath
     * @return
     */
    public  static InputStream getResourceAsStream(String filePath){
        return Resources.class.getClassLoader ().getResourceAsStream (filePath);
    }
}

9. 创建与数据库交互的核心接口  :  SqlSession    它里面可以创建DAO接口的代理对象

package com.mkl.mybatis.sqlsession;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:17
 * 自定义Mybatis中与数据库交互的核心类
 * 它里面可以创建DAO接口的代理对象
 */

public interface SqlSession {

    /**
     * 根据参数创建dao接口的代理对象
     * @param daoInterfaceClass
     * @param <T>
     * @return
     */
    <T> T getMapper(Class<T> daoInterfaceClass);

    /**
     * 释放资源
     */
    void close();
}

9.1 编写SqlSession的实现类DefaultSqlSession

　　实现类DefaultSqlSession中的类成员变量:

　　　　private Configuration cfg;

　　　　　　cfg通过构造方法传入

　　　　private Connection connection;

　　　　　　connection通过在构造方法中, 使用创建数据源的工具类来获取一个连接

　　在实现类中获取dao接口的实现类,使用Proxy.newProxyInstance      动态代理

　　其参数:

　　　　类加载器使用和被代理对象相同的类加载器   daoInterfaceClass.getClassLoader()

　　　　代理类的接口列表   字节码数组   new Class[]{daoInterfaceClass}

　　　　InvocationHandler : 用于提供增强的代码   new MapperProxy(cfg.getMappers(),connection)

　　　　　　此处自己编写实现类MapperProxy实现InvocationHandler接口

　　　　　　该实现类就是用于对方法进行增强的，我们的增强其实就是调用Executor执行器的selectList方法

　　　　　　　　 (Executor: 用于实现 SQL 语句的执行，主要是调用 JDBC 来实现 SQL 语句的执行)

　　　　　　在增强(invoke方法)中:

　　　　　　　　需要获取代理类调用的方法名称和方法所在类的全限定类名

　　　　　　　　　　method.getName();

　　　　　　　　　　method.getDeclaringClass().getName();

　　　　　　　　对以上两者进行组合   得到 key

　　　　　    　　　　key =　className+"."+methodName

　　　　　　　　然后从   主配置文件对应的实体类(Configuration)中   存贮的  映射配置文件的实体类的Map(mappers)中

　　　　　　　　　　(该Configuration的一个实例cfg存储在DefaultSqlSession中,为类成员变量, 通过DefaultSqlSession类的构造方法传入,

　　　　　　　　　　cfg.getMappers()作为参数,将获取到的mappers传给MapperProxy的实例)

　　　　　　　　根据key  获取dao层接口的对应的  映射文件的实体类mapper ,      mapper中封装着执行的SQL语句和结果类型的全限定类名

　　　　

　　　　　　　　然后调用工具类执行查询所有    将获取到的mapper和数据库连接conn  做参数传进去   并将结果返回

　　　　　　　　return new Executor().selectList(mapper,conn);

9.1.1编写DefaultSqlSession

package com.mkl.mybatis.sqlsession.defaults;

import com.mkl.config.Configuration;
import com.mkl.mybatis.Utils.DataSourceUtil;
import com.mkl.mybatis.proxy.MapperProxy;
import com.mkl.mybatis.sqlsession.SqlSession;

import java.lang.reflect.Proxy;
import java.sql.Connection;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:28
 */

public class DefaultSqlSession implements SqlSession {
    private Configuration cfg;
    private Connection conn;

    public DefaultSqlSession (Configuration cfg) {
        this.cfg =
        conn= DataSourceUtil.getConnection (cfg);
    }

    /**
     * 根据参数创建代理对象
     * @param daoInterfaceClass
     * @param <T>
     * @return
     */
    public <T> T getMapper (Class<T> daoInterfaceClass) {
        return (T)Proxy.newProxyInstance (daoInterfaceClass.getClassLoader (),
                new Class[]{daoInterfaceClass},new MapperProxy (cfg.getMappers (),conn));
    }

    public void close () {
　　　　　if(conn!=null){　　　　　　try{　　　　　　　　conn.close();　　　　　　}catch(Exeception e){　　　　　　　　e.printStackTrace();　　　　　　}　　　　　}
}

9.1.2编写MapperProxy

package com.mkl.mybatis.proxy;

import com.mkl.config.Mapper;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.util.Map;
import java.util.concurrent.Executor;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:15:17
 */

public class MapperProxy implements InvocationHandler {
    private Connection conn;
    private Map<String, Mapper> mappers;

    public MapperProxy (Map<String, Mapper> mappers, Connection conn) {
            this.conn = conn;
            this.mappers = mappers;
    }

    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.通过key获取mappers中的mapper对象
        Mapper mapper = mappers.get (key);
        //5. 判断是否有mapper
        if (mapper==null){
            throw  new IllegalArgumentException ("参数有误,为获取到对应的mapper");
        }
        //6. 调用工具类执行查询所有
        return new Executor ().selectList(mapper,conn);
    }
}

9.1. 3编写用于创建数据源的工具类,用于获取连接

package com.mkl.mybatis.Utils;

import com.mkl.config.Configuration;

import java.sql.Connection;
import java.sql.DriverManager;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:52
 * 用于创建数据源的工具类
 */

public class DataSourceUtil {

    /**
     * 用于获取一个连接
     * @param config
     * @return
     */
    public static Connection getConnection (Configuration config){
        try {
            Class.forName (config.getDriver ());//加载驱动
            //获取连接并返回
            return DriverManager.getConnection (config.getUrl (),config.getUsername (),config.getPassword ());
        }catch (Exception e){
            throw  new RuntimeException (e);
        }
    }
}

9.1.4 编写Executor  负责执行SQL语句，并且封装结果集

package com.mkl.mybatis.Utils;

import com.mkl.config.Mapper;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:15:28
 */

public class Executor {
    public <E>List<E> selectList(Mapper mapper, Connection conn){
        PreparedStatement pstm=null;
        ResultSet rs=null;
        try {
            //1. 取出mapper中的数据
            String SQL=mapper.getSQL (); //select *from user
            String resultType=mapper.getResultType ();//com.mlk.domain.User
            Class domainClass=Class.forName (resultType);
            //2. 获取PreparedStatement对象
            pstm= conn.prepareStatement (SQL);
            //3. 执行SQL语句 获取结果集
            rs= pstm.executeQuery ();
            //4. 封装结果集
            List<E> list=new ArrayList<E> ();//定义返回值
            while (rs.next ()){
                //实例化要封装的实体类对象
                E obj= (E)domainClass.newInstance ();

                //取出结果集的元信息
                ResultSetMetaData resultSetMetaData= rs.getMetaData ();
                //取出总列数
                int columnCount= resultSetMetaData.getColumnCount ();
                //遍历
                for (int i=1;i<=columnCount;i++) {
                    //获取每列的名称, 列名的序号是从1开始的
                    String columnName=resultSetMetaData.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 ();
            }
        }
    }
}

10. 编写工厂接口:  SqlSessionFactory   创建SqlSession对象

提供返回值SqlSession 的openSession方法

package com.mkl.mybatis.sqlsession;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:17
 */

public interface SqlSessionFactory {

    /**
     * 用于打开一个新的SqlSession对象
     */
    SqlSession openSession();
}

10.1 编写工厂接口 SqlSessionFactory的实现类  DefaultSqlSessionFactory

package com.mkl.mybatis.sqlsession.defaults;

import com.mkl.config.Configuration;
import com.mkl.mybatis.sqlsession.SqlSession;
import com.mkl.mybatis.sqlsession.SqlSessionFactory;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:29
 */

public class DefaultSqlSessionFactory implements SqlSessionFactory {

    private Configuration configuration;

    public DefaultSqlSessionFactory (Configuration configuration) {
        this.configuration = configuration;
    }

    /**
     *  用于打开一个新的SqlSession对象
     * @return
     */
    public SqlSession openSession () {
        return new DefaultSqlSession (configuration);
    }
}

11. 编写SqlSessionFactoryBuilder  用于构建SqlSessionFactory工厂

　　根据传入的字节输入流参数, 读取主配置文件, 并返回主配置文件对应的实体类
　　根据此主配置文件的实体类, 创建SqlSessionFactory工厂并返回

package com.mkl.mybatis.sqlsession;

import com.mkl.config.Configuration;
import com.mkl.mybatis.Utils.XMLConfigBuilder;
import com.mkl.mybatis.sqlsession.defaults.DefaultSqlSessionFactory;

import java.io.InputStream;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:16
 * 用于创建一个SqlSessionFactory对象
 */

public class SqlSessionFactoryBuilder {

    /**
     * 根据传入的字节输入流, 读取主配置文件, 并返回主配置文件对应的实体类
     * 根据此主配置文件的实体类, 创建SqlSessionFactory工厂并返回
     * @param config
     * @return
     */
    public SqlSessionFactory build(InputStream config){
        Configuration configuration= XMLConfigBuilder.loadConfiguration (config);
        return  new DefaultSqlSessionFactory(coniguration);
    }
}

11.1XMLConfigBuilder用于解析配置文件

package com.mkl.mybatis.Utils;

import com.mkl.config.Configuration;
import com.mkl.config.Mapper;
import com.mkl.mybatis.io.Resources;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 *  用于解析配置文件
 */
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);
                }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.setSQL (queryString);
                mapper.setResultType(resultType);
                //把key和value存入mappers中
                mappers.put(key,mapper);
            }
            return mappers;
        }catch(Exception e){
            throw new RuntimeException(e);
        }finally{
            in.close();
        }
    }

    /**
     * 根据传入的参数，得到dao中所有被select注解标注的方法。
     * 根据方法名称和类名，以及方法上注解value属性的值，组成Mapper的必要信息
     * @param daoClassPath
     * @return
     */
    //private static Map<String,Mapper> loadMapperAnnotation(String daoClassPath)throws Exception{
    //    //定义返回值对象
    //    Map<String,Mapper> mappers = new HashMap<String, Mapper>();
    //
    //    //1.得到dao接口的字节码对象
    //    Class daoClass = Class.forName(daoClassPath);
    //    //2.得到dao接口中的方法数组
    //    Method[] methods = daoClass.getMethods();
    //    //3.遍历Method数组
    //    for(Method method : methods){
    //        //取出每一个方法，判断是否有select注解
    //        boolean isAnnotated = method.isAnnotationPresent(Select.class);
    //        if(isAnnotated){
    //            //创建Mapper对象
    //            Mapper mapper = new Mapper();
    //            //取出注解的value属性值
    //            Select selectAnno = method.getAnnotation(Select.class);
    //            String queryString = selectAnno.value();
    //            mapper.setQueryString(queryString);
    //            //获取当前方法的返回值，还要求必须带有泛型信息
    //            Type type = method.getGenericReturnType();//List<User>
    //            //判断type是不是参数化的类型
    //            if(type instanceof ParameterizedType){
    //                //强转
    //                ParameterizedType ptype = (ParameterizedType)type;
    //                //得到参数化类型中的实际类型参数
    //                Type[] types = ptype.getActualTypeArguments();
    //                //取出第一个
    //                Class domainClass = (Class)types[0];
    //                //获取domainClass的类名
    //                String resultType = domainClass.getName();
    //                //给Mapper赋值
    //                mapper.setResultType(resultType);
    //            }
    //            //组装key的信息
    //            //获取方法的名称
    //            String methodName = method.getName();
    //            String className = method.getDeclaringClass().getName();
    //            String key = className+"."+methodName;
    //            //给map赋值
    //            mappers.put(key,mapper);
    //        }
    //    }
    //    return mappers;
    //}

}

12. 编写测试类

package com.mkl.test;

import com.mkl.dao.IUserDao;
import com.mkl.domain.User;
import com.mkl.mybatis.io.Resources;
import com.mkl.mybatis.sqlsession.SqlSession;
import com.mkl.mybatis.sqlsession.SqlSessionFactory;
import com.mkl.mybatis.sqlsession.SqlSessionFactoryBuilder;

import java.io.InputStream;
import java.util.List;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:16:39
 */

public class MybatisTest {
    public static void main (String[] args) {
        //1. 读取配置文件
        InputStream in= Resources.getResourceAsStream ("SqlMapConfig.xml");
        //2. 根据配置文件使用构建者创建SqlSessionFactory
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder=new SqlSessionFactoryBuilder ();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build (in);
        //3. 使用工厂打开一个SqlSession
        SqlSession sqlSession=sqlSessionFactory.openSession ();
        //4. 使用SqlSession获取dao接口的代理对象
        IUserDao userDao=sqlSession.getMapper (IUserDao.class);
        //5. 使用代理对象执行方法
        List<User> users=userDao.findAll ();
        for (User user:users){
            System.out.println (user);
        }
        //6. 释放资源
        sqlSession.close ();
    }
}

原文地址：https://www.cnblogs.com/mkl7/p/10737346.html

时间： 2024-07-31 02:14:25

自定义Mybatis框架的相关文章

如何自定义MyBatis框架

MyBatis入门到自定义MyBatis框架 第一个 MyBatis 程序(XML配置) 在上一篇中,简单总结了一下原生 JDBC 的一些局限性,同时引出了 MyBatis 这个框架,算较为详细的整理如何搭建 MyBatis 的工作环境 这一篇,我们在开篇,现在搭建好工作环境的基础上,开始我们的第一个例程,但是,简单的让程序跑起来以后,我们却要讲解如何自定义 MyBatis 框架,它的意义是什么呢? 虽然第一个例程虽然比较简单,但是其中有很多点却是容易引起疑惑的,例如为什么用工厂模式后还有构建者

阶段3 1.Mybatis_03.自定义Mybatis框架_3.自定义mybatis的编码-根据测试类中缺少的创建接口和类

先认识一下这几个类.Resources是一个class SqlSessionFactoryBuilder 创建新项目 复制相关的依赖 复制之前的代码 复制到当前项目的src下 把Mybits的依赖删除掉 删除Mbits依赖后,就相当于没有Mybits的内容了. 新建类Resources 之类就可以把Resources的包导入进来了.就是我们自己新建的类 Resources Resources类里面创建方法getResourceAsStream 方法内是三步: 1.拿到类的字节码 2.获取字节码的

阶段3 1.Mybatis_03.自定义Mybatis框架_5.自定义Mybatis的编码-创建两个默认实现类并分析类之间的关系

把XMLConfigBuilder的包名补全 这样我们就可以调用里面的loadConfiguration方法了 创建工厂实现类 实现SqlSessionFactory的接口 实现接口里面的方法 把cfg作为参数传递给SqlSessionFactory的实现类 在实现类里面,提供一个Configration的对象,通过构造方法传递进来. Configuration里面包含了链接数据库的信息,以及执行的SQL语句 创建SqlSession实现类 工厂实现类里面把cfg传递到SqlSession的实现

阶段3 1.Mybatis_04.自定义Mybatis框架基于注解开发_3 基于注解的自定义再分析

这里只需要 一是连接数据库的 二是映射的 注解是class的方式  dom4j技术获取xml的数据,这是xml的方式获取的下面几个关键的点 注解的方式回去dao类里面的几个主要的信息 User黄色的部门就是要封装到哪里的数据.基于注解的开发,如何拿到User是最关键的 设计注解和泛型相关的知识 最终得到class的名称 原文地址:https://www.cnblogs.com/wangjunwei/p/11306401.html

阶段3 1.Mybatis_04.自定义Mybatis框架基于注解开发_2 回顾自定义mybatis的流程分析

原文地址:https://www.cnblogs.com/wangjunwei/p/11306369.html

myBatis框架之入门(一)

什么是框架 框架就是一个架子,表演节目,舞台已经搭建好,表演什么节目,看自己的需求了. 框架是一个半成品,对于Java语言来说,框架就是封装了别人的代码.在框架的基础上我们在进一步开发,拿来主义. 框架解决什么问题 解决的是技术整合问题.软件开发环境和规模都很大,不可能任何一个项目的代码都从零开始,此时就需要一个非常优秀的框架把基础技术整合完毕,我们在他的基础上进一步开发.提高性能,易扩展,易维护,最终提高整个团队的开发效率. 什么时候使用框架 企业级大型项目开发,避免大炮打蚊子. 怎么使用框架

Mybatis框架(9)---Mybatis自定义插件生成雪花ID做为表主键项目

Mybatis自定义插件生成雪花ID做为主键项目 先附上项目项目GitHub地址 spring-boot-mybatis-interceptor 有关Mybatis雪花ID主键插件前面写了两篇博客作为该项目落地的铺垫. 1.Mybatis框架---Mybatis插件原理 2.java算法---静态内部类实现雪花算法 该插件项目可以直接运用于实际开发中,作为分布式数据库表主键ID使用. 一.项目概述 1.项目背景 在生成表主键ID时,我们可以考虑主键自增 或者 UUID,但它们都有很明显的缺点 主

MyBatis框架知识整理

MyBatis框架 一.介绍: MyBatis实际上是Ibatis3.0版本以后的持久化层框架[也就是和数据库打交道的框架]! 和数据库打交道的技术有: 原生的JDBC技术---> Spring的JdbcTemplate技术 这些工具都是提供简单的SQL语句的执行,但是和我们这里学的MyBatis框架还有些不同,框架是一整套的东西,例如事务控制,查询缓存,字段映射等等. 我们用原生JDBC操作数据库的时候都会经过: 编写sql---->预编译---->设置参数----->执行sql

Hibernate框架与Mybatis框架的对比

学习了Hibernate和Mybatis,但是一直不太清楚他们两者的区别的联系,今天在网上翻了翻,就做了一下总结,希望对大家有帮助! 原文:http://blog.csdn.net/firejuly/article/details/8190229 第一章     Hibernate与MyBatis Hibernate 是当前最流行的O/R mapping框架,它出身于sf.net,现在已经成为Jboss的一部分. Mybatis 是另外一种优秀的O/R mapping框架.目前属于apache的