Mybatis

最新推荐文章于 2024-02-26 23:49:15 发布
最新推荐文章于 2024-02-26 23:49:15 发布
阅读量263 收藏
点赞数
分类专栏： Mybatis 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_31289993/article/details/110082599
版权
提出几个问题：
1.mybatis通过接口即可以实现对数据库的访问，是不是很神奇？
2.什么时候解析  mybatis-config.xml 呢？
3.什么时候解析  xxxmapper.xml 呢？
4.什么时候生成代理类呢？
5.生成代理类的具体方法？
 

核心概念

     SqlSessionFactoryBuilder(构造器)： 它可以从XML、注解或者手动配置Java代码来创建SqlSessionFactory。
    SqlSessionFactory: 用于创建SqlSession (会话) 的工厂
    SqlSession: SqlSession是Mybatis最核心的类，可以用于执行语句、提交或回滚事务以及获取映射器Mapper的接口
    SQL Mapper： 它是由一个Java接口和XML文件（或注解）构成的，需要给出对应的SQL和映射规则，它负责发送SQL去执行，并返回结果
 

举例

//sql语句
CREATE TABLE  user(
  id int,
  name VARCHAR(255) not NULL ,
  age int ,
  PRIMARY KEY (id)
)ENGINE =INNODB DEFAULT CHARSET=utf8;

//java实体类
@Data
public class User {
    private int id;
    private int age;
    private String name;
    @Override
    public String toString() {
        return "User{" + "id=" + id +", age=" + age +", name='" + name + '\'' +'}';
    }
}
 

//配置mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--全局配置文件的根元素-->
<configuration>
    <!--enviroments表示环境配置，可以配置成开发环境(development)、测试环境(test)、生产环境(production)等-->
    <environments default="development">
        <environment id="development">
            <!--transactionManager： 事务管理器，属性type只有两个取值：JDBC和MANAGED-->
            <transactionManager type="MANAGED" />
            <!--dataSource: 数据源配置-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/test"/>
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
    <!--mappers文件路径配置-->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

//mapper接口
public interface UserMapper {
    User selectById(int id);
}
 
 
//xml文件 
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace属性表示命令空间，不同xml映射文件namespace必须不同-->
<mapper namespace="com.pjmike.mybatis.UserMapper">
    <select id="selectById" parameterType="int"
            resultType="com.pjmike.mybatis.User">
             SELECT id,name,age FROM user where id= #{id}
       </select>
</mapper>

 

//测试类 
public class MybatisTest {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            sqlSessionFactory = new SqlSessionFactoryBuilder()
                    .build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            User user = userMapper.selectById(1);
            System.out.println("User : " + user);
        }
    }
}
// 结果：
User : User{id=1, age=21, name='pjmike'}

 

解答第一步的问题：

2.什么时候解析 mybatis-config.xml 呢？

回忆一下示例代码
 
     
private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            sqlSessionFactory = new SqlSessionFactoryBuilder()
                    .build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
使用 new SqlSessionFactoryBuilder().build方法创建sqlSessionFactory工厂
//inputStream = Resources.getResourceAsStream("mybatis-config.xml")
public SqlSessionFactory build(InputStream inputStream) {
  return build(inputStream, null, null);
}

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
  try {
    XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
    return build(parser.parse());
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error building SqlSession.", e);
  } finally {
    ErrorContext.instance().reset();
    try {
      inputStream.close();
    } catch (IOException e) {
    }
  }
}
 
这里是真正解析 mybatis-config.xml的位置
//对于mybatis的全局配置文件的解析，相关解析代码位于XMLConfigBuilder的parse()方法中 

public Configuration parse() {
  if (parsed) {
    throw new BuilderException("Each XMLConfigBuilder can only be used once.");
  }
  parsed = true;
  parseConfiguration(parser.evalNode("/configuration")); //configuration是mybatis-config.xml的根节点
  return configuration; 
}
//解析mybatis-config.xml类
private void parseConfiguration(XNode root) {
  try {
    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);
    environmentsElement(root.evalNode("environments"));
    databaseIdProviderElement(root.evalNode("databaseIdProvider"));
    typeHandlerElement(root.evalNode("typeHandlers"));
    //该方法是对全局配置文件中mappers属性的解析  
    //mybatis-config.xml-> <mappers> <mapper resource="mapper/UserMapper.xml"/> </mappers>
    mapperElement(root.evalNode("mappers"));
  } catch (Exception e) {
    throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
  }
}

 

3.什么时候解析 xxxMapper.xml 呢？


/**
 * <mappers>
 *   <mapper resource="mapper/UserMapper.xml"/>
 * </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 {
        //mybatis-config.xml-> <mappers> <mapper resource="mapper/UserMapper.xml"/> </mappers>
        String resource = child.getStringAttribute("resource");
        String url = child.getStringAttribute("url");
        String mapperClass = child.getStringAttribute("class");
        if (resource != null && url == null && mapperClass == null) {
          ErrorContext.instance().resource(resource);
          InputStream inputStream = Resources.getResourceAsStream(resource);   //这里是mapper/UserMapper.xml的resource
          XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
          //方法就是XMLMapperBuilder对Mapper映射器文件进行解析，可与XMLConfigBuilder进行类比
          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());
          mapperParser.parse();
        } else if (resource == null && url == null && mapperClass != null) {
          Class<?> mapperInterface = Resources.classForName(mapperClass);
          configuration.addMapper(mapperInterface);
        } else {
          throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
        }
      }
    }
  }
 
解析xxxmapper.xml: mapperElement(root.evalNode("mappers"));
//XMLMapperBuilder.parse() 方法就是XMLMapperBuilder对Mapper映射器文件进行解析，可与XMLConfigBuilder进行类比 


/**
*<mapper namespace="com.pjmike.mybatis.UserMapper">
*    <select id="selectById" parameterType="int"
*            resultType="com.pjmike.mybatis.User">
*            SELECT id,name,age FROM user where id= #{id}
*    </select>
*</mapper>
*/


public void parse() {
  if (!configuration.isResourceLoaded(resource)) {
    configurationElement(parser.evalNode("/mapper")); //解析映射文件的根节点mapper元素
    configuration.addLoadedResource(resource);
    bindMapperForNamespace(); //重点方法，这个方法内部会根据namespace属性值，生成动态代理类
  }
  parsePendingResultMaps();
  parsePendingCacheRefs();
  parsePendingStatements();
}

/**
 * context 里是xml的所有内容
 * 该方法主要用于将mapper文件中的元素信息，比如insert、select这等信息解析到MappedStatement对象，并保存到Configuration类中的     
 * mappedStatements属性中，以便于后续动态代理类执行CRUD操作时能够获取真正的Sql语句信息
*/
private void configurationElement(XNode context) {
  try {
    String namespace = context.getStringAttribute("namespace");
    if (namespace == null || namespace.isEmpty()) {
      throw new BuilderException("Mapper's namespace cannot be empty");
    }
    builderAssistant.setCurrentNamespace(namespace);
    cacheRefElement(context.evalNode("cache-ref"));
    cacheElement(context.evalNode("cache"));
    parameterMapElement(context.evalNodes("/mapper/parameterMap"));
    resultMapElements(context.evalNodes("/mapper/resultMap"));
    sqlElement(context.evalNodes("/mapper/sql"));
    //用于解析insert、select这类元素信息，并将其封装成MappedStatement对象
    buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
  } catch (Exception e) {
    throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
  }
}

 

4.什么时候生成代理类呢？

动态代理类的生成
/*
* 该方法是核心方法，它会根据mapper文件中的namespace属性值，为接口生成动态代理类
* 将代理类放入mapper里
*/ 
private void bindMapperForNamespace() {
    //获取mapper元素的namespace属性值
    String namespace = builderAssistant.getCurrentNamespace();
    if (namespace != null) {
      Class<?> boundType = null;
      try {
        // 获取namespace属性值对应的Class对象，即dao接口class
        boundType = Resources.classForName(namespace);
      } catch (ClassNotFoundException e) {
        //如果没有这个类，则直接忽略，这是因为namespace属性值只需要唯一即可，并不一定对应一个XXXMapper接口
        //没有XXXMapper接口的时候，我们可以直接使用SqlSession来进行增删改查
      }
      if (boundType != null) {
        if (!configuration.hasMapper(boundType)) {
          configuration.addLoadedResource("namespace:" + namespace);
          //如果namespace属性值有对应的Java类，调用Configuration的addMapper方法，将其添加到MapperRegistry中
          configuration.addMapper(boundType);
        }
      }
    }
  }

 

这里提到了Configuration的addMapper方法，实际上Configuration类里面通过MapperRegistry对象维护了所有要生成动态代理类的XxxMapper接口信息，可见Configuration类确实是相当重要一类 
public class Configuration {
    ...
    protected MapperRegistry mapperRegistry = new MapperRegistry(this);
    ...
    public <T> void addMapper(Class<T> type) {
      mapperRegistry.addMapper(type);
    }
    public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
      return mapperRegistry.getMapper(type, sqlSession);
    }
    ...
}

 

其中两个重要的方法：getMapper()和addMapper()
getMapper(): 用于创建接口的动态类
addMapper(): mybatis在解析配置文件时，会将需要生成动态代理类的接口注册到其中
 
1. Configuration#addMappper()
Configuration将addMapper方法委托给MapperRegistry的addMapper进行的，源码如下 
public <T> void addMapper(Class<T> type) {
    // 这个class必须是一个接口，因为是使用JDK动态代理，所以需要是接口，否则不会针对其生成动态代理
    if (type.isInterface()) {
      if (hasMapper(type)) {
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
        // 生成一个MapperProxyFactory，用于之后生成动态代理类
        knownMappers.put(type, new MapperProxyFactory<>(type));
        //以下代码片段用于解析我们定义的XxxMapper接口里面使用的注解，这主要是处理不使用xml映射文件的情况
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

 

MapperRegistry内部维护一个映射关系，每个接口对应一个MapperProxyFactory（生成动态代理工厂类）
 private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();
这样便于在后面调用MapperRegistry的getMapper()时，直接从Map中获取某个接口对应的动态代理工厂类，然后再利用工厂类针对其接口生成真正的动态代理类。
 
2. Configuration#getMapper()

Configuration的getMapper()方法内部就是调用MapperRegistry的getMapper()方法，源代码如下：


  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    //根据Class对象获取创建动态代理的工厂对象MapperProxyFactory
    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);
    }
  }
 
5.生成代理类的具体方法 ？- - MapperProxyFactory.newInstance

从上面可以看出，创建动态代理类的核心代码就是在MapperProxyFactory.newInstance方法中，源码如下：


  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  } 
  protected T newInstance(MapperProxy<T> mapperProxy) {
    //这里使用JDK动态代理，通过Proxy.newProxyInstance生成动态代理类
    // newProxyInstance的参数：类加载器、接口类、InvocationHandler接口实现类
    // 动态代理可以将所有接口的调用重定向到调用处理器InvocationHandler，调用它的invoke方法
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }
 
这里的InvocationHandler接口的实现类是MapperProxy，其源码如下
  
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类中定义的方法，直接通过反射调用即可
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      } else if (isDefaultMethod(method)) {
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    //调用XxxMapper接口自定义的方法，进行代理
    //首先将当前被调用的方法Method构造成一个MapperMethod对象，然后掉用其execute方法真正的开始执行。
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }
  private MapperMethod cachedMapperMethod(Method method) {
    return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
  }
  ...
}

 

最终的执行逻辑在于MapperMethod类的execute方法，源码如下


public class MapperMethod {
  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;
    switch (command.getType()) {
      //insert语句的处理逻辑
      case INSERT: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.insert(command.getName(), param));
        break;
      }
      //update语句的处理逻辑
      case UPDATE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.update(command.getName(), param));
        break;
      }
      //delete语句的处理逻辑
      case DELETE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.delete(command.getName(), param));
        break;
      }
      //select语句的处理逻辑
      case SELECT:
        if (method.returnsVoid() && method.hasResultHandler()) {
          executeWithResultHandler(sqlSession, args);
          result = null;
        } else if (method.returnsMany()) {
          result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
          result = executeForCursor(sqlSession, args);
        } else {
          Object param = method.convertArgsToSqlCommandParam(args);
          //调用sqlSession的selectOne方法
          result = sqlSession.selectOne(command.getName(), param);
          if (method.returnsOptional()
              && (result == null || !method.getReturnType().equals(result.getClass()))) {
            result = Optional.ofNullable(result);
          }
        }
        break;
      case FLUSH:
        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;
  }
  ...
}
 
在MapperMethod中还有两个内部类，SqlCommand和MethodSignature类，在execute方法中首先用switch case语句根据SqlCommand的getType()方法，判断要执行的sql类型，比如INSET、UPDATE、DELETE、SELECT和FLUSH，然后分别调用SqlSession的增删改查等方法
 

1.mybatis通过接口即可以实现对数据库的访问，是不是很神奇？

调用接口，其实是访问mybatis生成的代理类，具体调用getMapper方法的地方： 


UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

public class DefaultSqlSession implements SqlSession {
  private final Configuration configuration;
  private final Executor executor;
  @Override
  public <T> T getMapper(Class<T> type) {
    return configuration.getMapper(type, this);
  }
  ...
}

 

所以getMapper方法的大致调用逻辑链是：
SqlSession#getMapper() —> Configuration#getMapper() —>   MapperRegistry#getMapper() —> MapperProxyFactory#newInstance() —> Proxy#newProxyInstance()
我们通过SqlSession的getMapper方法获得接口代理来进行CRUD操作，其底层还是依靠的是SqlSession的使用方法。
 
原理图：
 
参考资料：
Mybatis3源码分析(21)-Mapper实现-动态代理
ashan
12-25 2081
当定义好一个Mapper接口(UserDao)里，我们并不需要去实现这个类，但sqlSession.getMapper()最终会返回一个实现该接口的对象。这个对象是Mybatis利用jdk的动态代理实现的。这里将介绍这个代理对象的生成过程及其方法的实现过程。 Mapper代码对象的生成过程 DefaultSqlSession.getMapp()方法最终会调用MapperRegistry.get
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
Mybatis实现动态代理,动态SQL
09-07
Mybatis+JDBC实现的动态代理,动态SQL，步骤较为详细：1）接口绑定方案；2）实现查询：方法参数为多个基本类型；3）动态SQL；4）缓存
MyBatis动态代理
weixin_30633405的博客
12-31 169
------------------------siwuxie095 MyBatis 动态代理 1、MyBatis 动态代理 是指 MyBatis 通过 JDK 动态代理机制动态生成代理类 和代理对象 「代理对象 即 代理类的对象」 2...
Mybatis中的动态代理
qq_63217107的博客
05-16 1144
DynamicProxy 为什么使用动态代理？ 当接口中的实现方法发生改变的时候，那么实现接口的实现类也会随之而改变 代理对象发生改变，测试程序也要发生改变，一切都要随之发生改变 可以使用动态代理解决这个问题 代理对象在程序运行的过程中动态在内存中构建，可以灵活的进行业务功能的切换 JDK动态代理 目标对象必须实现业务接口 JDK代理对象不需要实现业务接口 JDK动态代理的对象在程序运行前不存在，在程序运行是动态的在内存中构建
MyBatis之【动态代理】
weixin_48485216的博客
05-09 1475
一、代理模式 1、什么是代理模式 （1）目标对象不可访问，通过代理对象增强功能访问。 2、代理模式的作用 （1）控制目标对象的访问 （2）增强功能 3、代理模式的分类 （1）静态代理 （2）动态代理： ①JDK动态代理 ②CGLib动态代理 4、代理的实现方式 （1）静态代理实现 （2）动态代理的实现分为JDK动态代理和CGLib动态代理 二、静态代理 1、静态代理的特点 （1）目标对象和代理对象实现同一个业务接口 （2）目标对象必须实现接口 （3）代理对象在程序运行前就
IDEA的MyBatis插件两个
最新发布
03-07
本篇文章将详细介绍两个针对MyBatis框架的IntelliJ IDEA插件——MyBatisCodeHelper-Pro和MybatisX，它们都是为了提升MyBatis开发体验而设计的。 首先，我们来看MyBatisCodeHelper-Pro。这款插件是专为MyBatis开发者...
idea插件MybatisX-1.6.1
02-23
MybatisX是一款针对IntelliJ IDEA的高效MyBatis开发插件，版本为1.6.1。这个插件旨在简化MyBatis框架在IDEA中的使用，提高开发效率，帮助开发者快速完成与MyBatis相关的各种任务。下面将详细介绍这款插件的主要功能...
MyBatis-Flex： 一个优雅的 MyBatis 增强框架
08-04
MyBatis-Flex： 一个优雅的 MyBatis 增强框架。很轻量，MyBatis-Flex 整个框架只依赖 MyBatis，再无其他任何第三方依赖。只增强，MyBatis-Flex 支持 CRUD、分页查询、多表查询、批量操作，但不丢失 MyBatis 原有的...
# MybatisLog sql日志 Free-Mybatis 插件
06-01
MybatisLog是一款针对Mybatis框架的日志插件，Free-Mybatis则是它的扩展，两者结合为开发者提供了强大的SQL日志追踪功能。在开发过程中，理解并优化SQL查询是提升应用程序性能的关键步骤，而MybatisLog与Free-...
MyBatis中的动态代理
m0_56336875的博客
07-04 1037
MyBatis
mybatis——动态代理
mooonk的博客
07-09 340
一、动态代理实现CRUD 在开发项目中，我们可以通过接口快速的找到对应的方法，但是引入mybatis之后我们不要接口就可以实现数据库的连接以及数据操作，现在通过动态代理，在接口中写数据库操作的方法，对应的和接口名相同名称的xml文件中的数据操作相当于对接口中方法的实现。 作用过程 接口和xml文件必须在同一个包下，之后在mybatis.xml中可以直接通过包名来加载xml文件（前提是必须实现动态代理，必须有接口，接口名和xml文件名必须相同，xml文件中的mapper的namespace属性值必须为接口全
MyBatis的动态代理
Rocky balboa
02-26 1158
假设有一个表示接口的 Class 对象（有可能只包含一个接口，) 它的确切类型在编译时无法知道。这确实有些难度。要想构造一个实现这些接口的类，就需要使用 newlnstance 方法或反射找出这个类的构造器。但是， 不能实例化一个接口，需要在程序处于运行状态时定义一个新类。为了解决这个问题， 有些程序将会生成代码；将这些代码放置在一个文件中；调用编译器；然后再加载结果类文件。很自然， 这样做的速度会比较慢，并且需要将编译器与程序放在一起。而代理机制则是一种更好的解决方案。
MyBatis 动态代理
shizhiqian0021的博客
06-16 295
MyBatis 动态代理 MyBatis 框架的动态代理是通过两个步骤完成的： 加载配置文件时，通过扫描到的接口类创建代理工厂类，并将其依次放到一个 Map 中： 大致的创建动态代理类的流程图如下： MapperRegistry.class public <T> void addMapper(Class<T> type) { if (type.isInterface()) { if (hasMapper(type)) { thr
mybatis动态代理
qq_41904699的博客
10-11 299
Mybatis动态代理代码文件结构资源类User表操作代码xml别名配置pojo包装类对象查询结果集手动映射 代码文件结构 文件结构 使用规则 Mybatis动态代理开发，目的是简化开发，只需要写dao层的接口，不需要写实现类 持久层包名dao改为mapper mapper包下定义接口，！不用实现类，Mybatis框架自动生成接口的实现类对象 定义接口UserMapper，查询所有数据的方法（抽象） UserMapper.xml配置文件，配置user表的sql语句 配置文件必须和接口在同一文件夹下 配置
Mybatis动态代理实现
weixin_51270766的博客
06-21 384
动态代理存在的意义在三层架构中，业务逻辑层要通过接口访问数据访问层的功能，动态代理可以实现。动态代理实现规范：1）UsersMapper.xml文件与UsersMapper.java的接口必须同一个目录下2）UserMapper.xml文件与UserMapper.java的接口的文件名必须一致，后缀不管3）UserMapper.xml文件中标签的id值与UserMapper.java的接口中方法的名称完全一致4）UserMapper.xml文件中标签的paramType的属性值与UserMapper.jav
mybatis的动态代理
weixin_51656756的博客
10-15 197
mybatis的动态代理     为什么要使用动态代理：         不使用动态代理，我们需要有个 String sqlId=“org.example.dao.StudentDao”+"."+“selectStudent”;语句来确定是哪个mapper标签，要执行哪个方法，但是如果要使用动态代理，就不要需要有这句话，通过创建动态代理对象，调用对象的方法，就能知道要执行哪条sql &nb
【MyBatis】MyBatis动态代理
Super_Powerbank的博客
02-08 967
文章目录MyBatis动态代理1、代理模式（1）JDK自带的动态代理（2）CGLib动态代理2、MyBatis中动态代理 MyBatis动态代理 在MyBatis的使用过程中，我们经常使用的是通过getMapper方法获取代理对象，形如：StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);方式，从而进行对接口的动态代理。 1、代理模式 动态代理其实是代理模式的一种，而代理模式其实是Java当中的一种设计模式。其结构如图所示：
SpringBoot与Mybatis整合完全指南
根据给定的文件信息，以下是关于Spring Boot整合MyBatis的知识点总结： ### Spring Boot整合MyBatis知识点总结 #### 1. Spring Boot简介 Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值