Mybatis 实现原理

最新推荐文章于 2023-06-21 23:22:10 发布
最新推荐文章于 2023-06-21 23:22:10 发布
阅读量198 收藏
点赞数
分类专栏： mybatis 实现原理 mybatis 源码分析 mybatis 工作方式 文章标签： orm mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38766734/article/details/115305756
版权

MyBatis 实现原理

  1. 读取 mybatis 配置信息，并创建 SqlSessionFactory 对象。

    通过 SqlSessionFactoryBuilder 对象构建 SqlSessionFactory：

    public SqlSessionFactory build(InputStream inputStream) {
    return build(inputStream, null, null);
}

public SqlSessionFactory build(InputStream inputStream, String environment) {
    return build(inputStream, environment, null);
}

public SqlSessionFactory build(InputStream inputStream, Properties properties) {
    return build(inputStream, null, properties);
}

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
        // 拿到 XML 解析对象
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        // 将解析对象解析为 Configuration 对象，并构建 SqlSessionFactory 对象
        return build(parser.parse());
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
        ErrorContext.instance().reset();
        try {
            inputStream.close();
        } catch (IOException e) {
            // Intentionally ignore. Prefer previous error.
        }
    }
}

public SqlSessionFactory build(Configuration config) {
    // 通过默认实现类构建 SqlSessionFactory
    return new DefaultSqlSessionFactory(config);
}

  2. 通过 SqlSessionFactory 对象开启会话，获取 SqlSession 对象，默认开启事务（因为自动提交缺省值为 false）。

    @Override
public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}

@Override
public SqlSession openSession(boolean autoCommit) {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, autoCommit);
}

@Override
public SqlSession openSession(ExecutorType execType) {
    return openSessionFromDataSource(execType, null, false);
}

@Override
public SqlSession openSession(TransactionIsolationLevel level) {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), level, false);
}

@Override
public SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level) {
    return openSessionFromDataSource(execType, level, false);
}

@Override
public SqlSession openSession(ExecutorType execType, boolean autoCommit) {
    return openSessionFromDataSource(execType, null, autoCommit);
}

@Override
public SqlSession openSession(Connection connection) {
    return openSessionFromConnection(configuration.getDefaultExecutorType(), connection);
}

@Override
public SqlSession openSession(ExecutorType execType, Connection connection) {
    return openSessionFromConnection(execType, connection);
}

    上面这些重载方法中，默认都是开启事务的，除了允许设置 autoCommit 属性值的方法我们可以通过调用可以修改为自动提交。

  3. 通过 SqlSession API 来与数据库交互（交互方式有两种）。

    1. 通过 SqlSession 对象调用 selectList, selectOne, insert, update, delete 等等的方法来与数据库交互，其中在调用方法中有一个很重要的参数就是 statement，指的是在 mapper.xml 中你定义的标签的 id 转换为 Mapper 接口中的方法。这种方式通过 statement 参数获取到指定的 MappedStatement 对象，然后再使用 MappedStatement 对象去取执行底层的 select, update（insert, update, delete 均为 update）。

      这种方式没有使用动态代理。 具体可以查看一下 XMLStatementBuilder 这个类中的 parseStatementNode() 方法。

    2. 通过 SqlSession 对象调用 getMapper 方法来获取我们在程序中定义的 Mapper 接口，再使用 Mapper 接口中的方法与数据库交互。这种方式使用了动态代理。

      在使用 SqlSession 对象调用 getMapper 方法的时候，会调用默认实现类 DefaultSqlSession 中的 getMapper 方法，其内部使用的是 Configuration 对象的 getMapper 方法：

      // 该方法为 DefaultSqlSession 的方法
@Override
public <T> T getMapper(Class<T> type) {
    return configuration.getMapper(type, this);
}

      跟进看一下 Configuration 对象的 getMapper 方法：

      // 该方法为 Configuration 的方法
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
}

      跟进看一下 MapperRegistry 对象的 getMapper 方法：

      // 用于映射接口与代理工厂的关系
private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();

// 该方法为 MapperRegistry 的方法
@SuppressWarnings("unchecked")
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    // 在这里可以看到要获取一个 MapperProxyFactory 对象，也就是 Mapper 代理工厂对象
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
        throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
        return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
        throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
}

      看到这里应该也很好奇，什么时候改变的 knownMappers 的堆内存（准确来说这里的关注点是堆数据是何时改变的，即何时做的 put 操作）：

      // 先来看一下 MapperRegistry 对象的其他方法
public <T> boolean hasMapper(Class<T> type) {
    return knownMappers.containsKey(type);
}

public <T> void addMapper(Class<T> type) {
    if (type.isInterface()) {
        if (hasMapper(type)) {
            throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
        }
        boolean loadCompleted = false;
        try {
            knownMappers.put(type, new MapperProxyFactory<>(type));
            // It's important that the type is added before the parser is run
            // otherwise the binding may automatically be attempted by the
            // mapper parser. If the type is already known, it won't try.
            MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
            parser.parse();
            loadCompleted = true;
        } finally {
            if (!loadCompleted) {
                knownMappers.remove(type);
            }
        }
    }
}

/**
 * @since 3.2.2
 */
public void addMappers(String packageName, Class<?> superType) {
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
    for (Class<?> mapperClass : mapperSet) {
        addMapper(mapperClass);
    }
}

/**
 * @since 3.2.2
 */
public void addMappers(String packageName) {
    addMappers(packageName, Object.class);
}

/**
 * @since 3.2.2
 */
public Collection<Class<?>> getMappers() {
    return Collections.unmodifiableCollection(knownMappers.keySet());
}

      在 XMLConfigBuilder 类中：

      // XMLConfigBuilder 中的方法
// 看到这里，回溯一下整体步骤1 中，构建 SqlSessionFactory 对象的时候调用了该方法
public Configuration parse() {
    if (parsed) {
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}
// 在 parse 方法中调用了该方法，用于解析 Configuration 对象
private void parseConfiguration(XNode root) {
    try {
        //issue #117 read properties first
        propertiesElement(root.evalNode("properties"));
        Properties settings = settingsAsProperties(root.evalNode("settings"));
        loadCustomVfs(settings);
        loadCustomLogImpl(settings);
        typeAliasesElement(root.evalNode("typeAliases"));
        pluginElement(root.evalNode("plugins"));
        objectFactoryElement(root.evalNode("objectFactory"));
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        reflectorFactoryElement(root.evalNode("reflectorFactory"));
        settingsElement(settings);
        // read it after objectFactory and objectWrapperFactory issue #631
        environmentsElement(root.evalNode("environments"));
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        typeHandlerElement(root.evalNode("typeHandlers"));
        // 注意这里，这里是配置文件中解析 mappers 的配置
        mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
}
// 解析 mappers 标签的具体实现
private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
            if ("package".equals(child.getName())) {
                String mapperPackage = child.getStringAttribute("name");
                configuration.addMappers(mapperPackage);
            } else {
                String resource = child.getStringAttribute("resource");
                String url = child.getStringAttribute("url");
                String mapperClass = child.getStringAttribute("class");
                // 下面要根据不同的配置形式来调用之前所说的 addMapper 的方法
                if (resource != null && url == null && mapperClass == null) {
                    ErrorContext.instance().resource(resource);
                    InputStream inputStream = Resources.getResourceAsStream(resource);
                    // Configuration 中的 addMapper 内部调用的是 MapperRegistry 的 addMapper
                    // 而 Configuration 中的 addMapper 方法在两个类中使用，分别是 XMLConfigBuilder 与 XMLMapperBuilder
                    // XMLMapperBuilder 的具体调用就在 parse 方法中
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                    // 在 parse 方法中调用 addMapper
                    mapperParser.parse();
                } else if (resource == null && url != null && mapperClass == null) {
                    ErrorContext.instance().resource(url);
                    InputStream inputStream = Resources.getUrlAsStream(url);
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
                    // 在 parse 方法中调用 addMapper
                    mapperParser.parse();
                } else if (resource == null && url == null && mapperClass != null) {
                    Class<?> mapperInterface = Resources.classForName(mapperClass);
                    // 在 mapper 标签的 mapperClass 属性指定时，调用 addMapper
                    configuration.addMapper(mapperInterface);
                } else {
                    throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
                }
            }
        }
    }
}

      下面来具体看一下 XMLMapperBuilder 中的 parse 方法：

      // XMLMapperBuilder 中的方法
public void parse() {
    if (!configuration.isResourceLoaded(resource)) {
        configurationElement(parser.evalNode("/mapper"));
        configuration.addLoadedResource(resource);
        // 在未加载 mapper 标签的 resource 属性时，需要绑定 XML 与 Mapper 接口的关系
        bindMapperForNamespace();
    }

    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
}
// 绑定 XML 与 Mapper 的方法实现
private void bindMapperForNamespace() {
    String namespace = builderAssistant.getCurrentNamespace();
    if (namespace != null) {
        Class<?> boundType = null;
        try {
            boundType = Resources.classForName(namespace);
        } catch (ClassNotFoundException e) {
            //ignore, bound type is not required
        }
        if (boundType != null) {
            if (!configuration.hasMapper(boundType)) {
                // Spring may not know the real resource name so we set a flag
                // to prevent loading again this resource from the mapper interface
                // look at MapperAnnotationBuilder#loadXmlResource
                configuration.addLoadedResource("namespace:" + namespace);
                // 如果 Configuration 对象中不包含反射的 Mapper 接口，则调用 addMapper
                configuration.addMapper(boundType);
            }
        }
    }
}

      那么接下来的任务就是看一下 MapperProxyFactory 是如何创建 MapperProxy 对象的就 OK 了：

      public class MapperProxyFactory<T> {

    private final Class<T> mapperInterface;
    private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<>();

    public MapperProxyFactory(Class<T> mapperInterface) {
        this.mapperInterface = mapperInterface;
    }

    public Class<T> getMapperInterface() {
        return mapperInterface;
    }

    public Map<Method, MapperMethod> getMethodCache() {
        return methodCache;
    }

    @SuppressWarnings("unchecked")
    protected T newInstance(MapperProxy<T> mapperProxy) {
        // 这里用到了 JDK 的动态代理
        return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
    }

    // 通过 SqlSession 对象创建 MapperProxy 对象
    public T newInstance(SqlSession sqlSession) {
        // methodCache 交由代理类维护
        final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
        return newInstance(mapperProxy);
    }

}

      下面来看看 MapperProxy 这个代理类：

      // 使用 JDK 动态代理
public class MapperProxy<T> implements InvocationHandler, Serializable {

    private static final long serialVersionUID = -6424540398559729838L;
    private final SqlSession sqlSession;
    private final Class<T> mapperInterface;
    private final Map<Method, MapperMethod> methodCache;

    public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
        this.sqlSession = sqlSession;
        this.mapperInterface = mapperInterface;
        this.methodCache = methodCache;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            // 判断调用的是不是 Object 中定义的方法，toString，hashCode 这类。是的话直接放行。
            if (Object.class.equals(method.getDeclaringClass())) {
                return method.invoke(this, args);
            } else if (method.isDefault()) {
                return invokeDefaultMethod(proxy, method, args);
            }
        } catch (Throwable t) {
            throw ExceptionUtil.unwrapThrowable(t);
        }
        final MapperMethod mapperMethod = cachedMapperMethod(method);
        return mapperMethod.execute(sqlSession, args);
    }

    private MapperMethod cachedMapperMethod(Method method) {
        // 如果 method 不存在就构建一个新的 MapperMethod 对象返回
        return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
    }

    private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)
        throws Throwable {
        final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
            .getDeclaredConstructor(Class.class, int.class);
        if (!constructor.isAccessible()) {
            constructor.setAccessible(true);
        }
        final Class<?> declaringClass = method.getDeclaringClass();
        return constructor
            .newInstance(declaringClass,
                         MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
                         | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)
            .unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);
    }
}

      下面看一下 MapperMethod 对象的 execute 方法：

      private final SqlCommand command;
private final MethodSignature method;

public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
    this.command = new SqlCommand(config, mapperInterface, method);
    this.method = new MethodSignature(config, mapperInterface, method);
}

public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    // 具体执行 sql 返回结果
    switch (command.getType()) {
        case INSERT: {
            Object param = method.convertArgsToSqlCommandParam(args);
            // 这里可以看到最终调用的还是 SqlSession 的方法
            result = rowCountResult(sqlSession.insert(command.getName(), param));
            break;
        }
        case UPDATE: {
            Object param = method.convertArgsToSqlCommandParam(args);
            // 这里可以看到最终调用的还是 SqlSession 的方法
            result = rowCountResult(sqlSession.update(command.getName(), param));
            break;
        }
        case DELETE: {
            Object param = method.convertArgsToSqlCommandParam(args);
            // 这里可以看到最终调用的还是 SqlSession 的方法
            result = rowCountResult(sqlSession.delete(command.getName(), param));
            break;
        }
        case SELECT:
            if (method.returnsVoid() && method.hasResultHandler()) {
                executeWithResultHandler(sqlSession, args);
                result = null;
            } else if (method.returnsMany()) {
                // 方法内部调用的也是 SqlSession 中的方法
                result = executeForMany(sqlSession, args);
            } else if (method.returnsMap()) {
                // 方法内部调用的也是 SqlSession 中的方法
                result = executeForMap(sqlSession, args);
            } else if (method.returnsCursor()) {
                // 方法内部调用的也是 SqlSession 中的方法
                result = executeForCursor(sqlSession, args);
            } else {
                Object param = method.convertArgsToSqlCommandParam(args);
                // 这里可以看到最终调用的还是 SqlSession 的方法
                result = sqlSession.selectOne(command.getName(), param);
                if (method.returnsOptional()
                    && (result == null || !method.getReturnType().equals(result.getClass()))) {
                    result = Optional.ofNullable(result);
                }
            }
            break;
        case FLUSH:
            // 这里可以看到最终调用的还是 SqlSession 的方法
            result = sqlSession.flushStatements();
            break;
        default:
            throw new BindingException("Unknown execution method for: " + command.getName());
    }
    if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
        throw new BindingException("Mapper method '" + command.getName()
                                   + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
    }
    return result;
}
Best Wu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis缓存实现原理
大唐雨夜的博客
03-28 1652
Mybatis缓存 mybatis提供了对缓存的支持，分为一级缓存和二级缓存，可以通过下图来理解： ①、一级缓存是SqlSession级别的缓存，默认开启。不同的sqlSession之间的缓存数据区域（HashMap）是互相不影响的。 ②、二级缓存是mapper级别的缓存，基于mapper文件的namespace，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。 一级缓存 ⼀级缓存到底是什么？⼀级缓存什么时候被创建
MyBatis-实现过程详细操作步骤
chenxingxingxing的博客
03-15 4291
《深入理解mybatis原理》 MyBatis的架构设计以及实例分析
热门推荐
我的程序人生(亦山札记)
11-04 17万+
MyBatis是目前非常流行的ORM框架，它的功能很强大，然而其实现却比较简单、优雅。本文主要讲述MyBatis的架构设计思路，并且讨论MyBatis的几个核心部件，然后结合一个select查询实例，深入代码，来探究MyBatis的实现。
Mybatis实现步骤
weixin_51904054的博客
03-22 716
1.创建表table, 表属性id, name,email,address,pwd。 2.创建maven模板方法。 3.修改pom.xml文件(导入依赖，在<build>中加入资源插件)。 4.pojo目录中创建一个完整的实例类(实例类的属性就是表的字段名)。 5.在持久层(Dao)定义一个接口，用于实现操作数据库的方法。 6.在持久层(Dao)同样创建一个 配置映射文件mapper.xml （由于绑定上面的接口，写sql语句）。一张表一个配置映射文件。mybatis目的是将sql语句
MyBatis 的介绍及简单功能的实现与演示
最新发布
weixin_58697177的博客
06-21 232
MyBatis 是一款非常好的持久层框架, 它支持自定义 SQL、存储过程以及高级映射。MyBatis 去除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects，普通老式 Java 对象) 为数据库中的记录。简单来说 MyBatis 是更简单完成程序和数据库交互的工具，也就是更简单的操作和读取数据库工具。
MyBatis接口的简单实现原理分析
08-30
里仅仅举个简单例子来说明原理，不是完全针对MyBatis的，这种思想我们也可以应用在其他地方。地mybatis接口实现原理感兴趣的朋友一起看看吧
mybatis原理.xmind
06-09
该思维导图主要是对MyBatis原理知识进行了整理，通过对底层的分析，能够实现手写一个实现核心功能的简单MyBats，内容包括MyBatis整体架构和流程的分析、SQL的解析过程、手写解析流程、手写执行流程、看源码、MyBatis...
mybatis原理概述入门教程
09-01
主要介绍了在今天这篇博文中，我将要介绍一下mybatis的框架原理，以及mybatis的入门程序，实现用户的增删改查，她有什么优缺点以及mybatis和hibernate之间存在着怎么样的关系，大家这些问题一起通过本文学习吧
MyBatis缓存实现原理及代码实例解析
09-07
主要介绍了MyBatis缓存实现原理及代码实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
mybatis接口实现原理共2页.pdf.zip
10-30
mybatis接口实现原理共2页.pdf.zip
MyBatis的实现逻辑
m0_59902592的博客
01-29 184
（4）动态代理对象执行数据库的操作，由 SqlSession 执行相应的方法，在他的内部调用 Executor 执行器去执行数据库的相关操作。（1）在 MyBatis 的初始化过程中，会生成一个 Configuration 全局配置对象，里面包含了所有初始化过程中生成对象。（3）通过 SqlSession 可以获取到 Mapper 接口对应的动态代理对象，去执行数据库的相关操作。（5）在 Executor 执行器中，会进行相应的处理，将数据库执行结果返回。
mybatis详细教程
秋风渡人
11-17 2227
Mybatis 是一个优秀的持久层框架,是对JDBC操作数据库的过程进行了封装.
Mybatis原理——执行原理详解
保暖透气大裤衩LeoLee的博客
03-24 2021
概述 JDBC的执行流程可以大致分为： 获得连接 预编译sql 设置参数 执行sql Mybatis执行原理大致分为： 动态代理MapperProxy sql会话Sqlsession 执行器Executor JDBC处理器StatementHandler 图中JDBC圈起来的部分就对应了sql具体的执行过程，属于Mybatis执行器范围内。本文主要针对sql会话与执行器来展开讨论。 Mybatis的执行过程 Mybatis使用门面模式提供了统一的门面接口API： 基本的AP.
深入详解Mybatis的架构原理与6大核心流程
mikechen的互联网架构
02-14 4091
MyBatis 是 Java 生态中非常著名的一款 ORM 框架，目前在一线互联网大厂中应用广泛，Mybatis已经成为了一个必会框架。 如果你想要进入一线大厂，能够熟练使用 MyBatis 开发已经是一项非常基本的技能，同时大厂也更希望自己的开发人员深入了解 MyBatis 框架的原理和核心实现。 从这个角度看，理解 MyBatis 原理，阅读 MyBatis核心源码，这样更有利于提高职场竞争力。 在深入了解Mybatis的源码之前，我们先了解一下Mybatis的整体架构和工作原理，这样有助于我们在阅读.
【MyBatis】插件原理（二）：插件实现逻辑分析
A minor
12-19 237
MyBatis 的插件可以在不修改原来的代码的情况下，通过拦截的方式，改变四大核心对象的行为，比如处理参数，处理SQL，处理结果。 第一个问题：不修改对象的代码，怎么对对象的行为进行修改，比如说在原来的方法前面做一点事情，在原来的方法后面做一点事情？ 答案：大家很容易能想到用代理模式，这个也确实是MyBatis插件的原理。 第二个问题：我们可以定义很多的插件，那么这种所有的插件会形成一个链路，比如我们提交一个休假申请，先是项目经理审批，然后是部门经理审批，再是HR审批，再到总经理审批，怎么实现层层的
mybatis运行原理详解
只为成功找方法 不为失败找借口
05-07 3415
第一部分：项目结构 user_info表：没什么好说的就3个字段 User实体类: @Data public class User { private Long id; private String name; private Integer age; } mapper:UserMapper 为根据id查询用户信息 public interface UserMapper { User selectUserById(Integer id); } UserMa
【mybatis原理工作原理】
qq_33700648的博客
04-26 1294
文章目录mybatis原理： mybatis原理： mybatis的工作原理就是：先封装sql，接着调用jdbc操作数据库，最后把数据库返回的表结果封装成java类。 通过代码实现jdbc查询操作： mybatis-config.xml类 <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://myba
mybatis实现原理深度理解
zchlove137的博客
06-08 1976
先放一张图，让大家简单认识一下： 1、解析xml的时候 首先，Mybatis在初始化SqlSessionFactoryBean的时候，找到mapperLocations路径去解析里面所有的XML文件 2、创建sqlsource Mybatis会把每个SQL标签封装成SqlSource对象。然后根据SQL语句的不同，又分为动态SQL和静态SQL。其中，静态SQL包含一段String类型的...
mybatis实现原理
java1993666的博客
11-28 291
《深入理解mybatis原理》 MyBatis的架构设计以及实例分析 http://blog.csdn.net/luanlouis/article/details/40422941

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值