MyBatis执行Sql的流程分析

news2025/1/13 3:10:02

目录

举例

openSession的过程

Executor

简单总结

获取Mapper的流程

Mapper方法的执行流程

doQuery方法

简单总结


举例

public class App {
    public static void main(String[] args) {
        String resource = "mybatis-config.xml";
        Reader reader;
        try {
            //将XML配置文件构建为Configuration配置类
            reader = Resources.getResourceAsReader(resource);
            // 通过加载配置文件流构建一个SqlSessionFactory  DefaultSqlSessionFactory
            SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
            // 数据源 执行器  DefaultSqlSession
            SqlSession session = sqlMapper.openSession();
            try {
                // 执行查询 底层执行jdbc
                //User user = (User)session.selectOne("com.tuling.mapper.selectById", 1);

                UserMapper mapper = session.getMapper(UserMapper.class);
                System.out.println(mapper.getClass());
                User user = mapper.selectById(1L);
                System.out.println(user.getUserName());
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                session.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

之前提到拿到sqlSession之后就能进行各种CRUD操作了,所以我们就从sqlSession.getMapper这个方法开始分析,看下整个Sql的执行流程是怎么样的。

openSession的过程

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

openSessionFromDataSource方法

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      /**
       * 获取环境变量
       */
      final Environment environment = configuration.getEnvironment();
      /**
       * 获取事务工厂
       */
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      /**
       * 创建一个sql执行器对象
       * 一般情况下 若我们的mybaits的全局配置文件的cacheEnabled默认为true就返回
       * 一个cacheExecutor,若关闭的话返回的就是一个SimpleExecutor
       */
      final Executor executor = configuration.newExecutor(tx, execType);
      /**
       * 创建返回一个DeaultSqlSessoin对象返回
       */
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

创建一个sql语句执行器对象 

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    /**
     * 判断执行器的类型
     * 批量的执行器
     */
    if (ExecutorType.BATCH == executorType) {
      executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
      //可重复使用的执行器
      executor = new ReuseExecutor(this, transaction);
    } else {
      //简单的sql执行器对象
      executor = new SimpleExecutor(this, transaction);
    }
    //判断mybatis的全局配置文件是否开启缓存
    if (cacheEnabled) {
      //把当前的简单的执行器包装成一个CachingExecutor
      executor = new CachingExecutor(executor);
    }
    /**
     * TODO:调用所有的拦截器对象plugin方法
     */
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

Executor

分类

Executor分成两大类,一类是CacheExecutor,另一类是普通Executor。

普通Executor又分为三种基本的Executor执行器,SimpleExecutor、ReuseExecutor、BatchExecutor。

  • SimpleExecutor:每执行一次update或select,就开启一个Statement对象,用完立刻关闭Statement对象。
  • ReuseExecutor:执行update或select,以sql作为key查找Statement对象,存在就使用,不存在就创建,用完后,不关闭Statement对象,而是放置于Map内,供下一次使用。简言之,就是重复使用Statement对象。
  • BatchExecutor:执行update(没有select,JDBC批处理不支持select),将所有sql都添加到批处理中(addBatch()),等待统一执行(executeBatch()),它缓存了多个Statement对象,每个Statement对象都是addBatch()完毕后,等待逐一执行executeBatch()批处理。与JDBC批处理相同。

作用范围:Executor的这些特点,都严格限制在SqlSession生命周期范围内。

CacheExecutor其实是封装了普通的Executor,(能看到源码里面包装了一层)和普通的区别是在查询前先会查询缓存中是否存在结果,如果存在就使用缓存中的结果,如果不存在还是使用普通的Executor进行查询,再将查询出来的结果存入缓存。

到此为止,我们已经获得了SqlSession,拿到SqlSession就可以执行各种CRUD方法了。

简单总结

  • 拿到SqlSessionFactory对象后,会调用SqlSessionFactory的openSesison方法,这个方法会创建一个Sql执行器(Executor),这个Sql执行器会代理你配置的拦截器方法。
  • 获得上面的Sql执行器后,会创建一个SqlSession(默认使用DefaultSqlSession),这个SqlSession中也包含了Configration对象,所以通过SqlSession也能拿到全局配置;
  • 获得SqlSession对象后就能执行各种CRUD方法了

获取Mapper的流程

进入sqlSession.getMapper方法,会发现调的是Configration对象的getMapper方法:

 UserMapper mapper = session.getMapper(UserMapper.class);
@Override
  public <T> T getMapper(Class<T> type) {
    // 这个sqlsession就是调用的对象
    return configuration.getMapper(type, this);
  }
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    //mapperRegistry实质上是一个Map,里面注册了启动过程中解析的各种Mapper.xml
    //mapperRegistry的key是接口的Class类型
    //mapperRegistry的Value是MapperProxyFactory,用于生成对应的MapperProxy(动态代理类)
    return mapperRegistry.getMapper(type, sqlSession);
}

进入getMapper方法:

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    /**
     * 直接去缓存knownMappers中通过Mapper的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 {
      /**
       * 通过MapperProxyFactory来创建我们的实例
       */
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }
knownMappers里面信息

你再去看就会发现,初始化configuration这个类的时候,就把所有的mapper类放到mapperRegistry里面去了,里面也有knownMappers这个属性

public void addMappers(String packageName, Class<?> superType) {
    mapperRegistry.addMappers(packageName, superType);
  }

进入MapperProxyFactory的newInstance方法:

public T newInstance(SqlSession sqlSession) {
    /**
     * 创建我们的代理对象
     */
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    /**
     * 创建我们的Mapper代理对象返回
     */
    return newInstance(mapperProxy);
  }

newInstance(mapperProxy)

真正的动态代理实现

第一个参数就是你写的mapper接口需要的类加载器,接口的类数组

protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

mapperProxy

public class MapperProxy<T> implements InvocationHandler, Serializable {

实现invocationHandler主要就是要调用invoke方法

你会看到这个mapperProxy初始化的时候有很多参数

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

因为mapperInterface表示接口的类,肯定要用,另外两个一个是执行sql的,一个是缓存使用的 

获取Mapper的流程总结如下:

Mapper方法的执行流程

下面是动态代理类MapperProxy,调用Mapper接口的所有方法都会先调用到这个代理类的invoke方法(注意由于Mybatis中的Mapper接口没有实现类,所以MapperProxy这个代理对象中没有委托类,也就是说MapperProxy干了代理类和委托类的事情)。好了下面重点看下invoke方法。

@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 (method.isDefault()) {   //是否接口的默认方法
        /**
         * 调用我们的接口中的默认方法
         */
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    /**
     * 真正的进行调用,做了二个事情
     * 第一步:把我们的方法对象封装成一个MapperMethod对象(带有缓存作用的)
     */
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    /**
     *通过sqlSessionTemplate来调用我们的目标方法
     * 那么我们就需要去研究下sqlSessionTemplate是什么初始化的
     * 我们知道spring 跟mybatis整合的时候,进行了偷天换日
     * 把我们mapper接口包下的所有接口类型都变为了MapperFactoryBean
     * 然后我们发现实现了SqlSessionDaoSupport,我们还记得在整合的时候,
     * 把我们EmployeeMapper(案例class类型属性为MapperFactoryBean)
     * 的注入模型给改了,改成了by_type,所以会调用SqlSessionDaoSupport
     * 的setXXX方法进行赋值,从而创建了我们的sqlSessionTemplate
     * 而在实例化我们的sqlSessionTemplate对象的时候,为我们创建了sqlSessionTemplate的代理对象
     *     this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),
            new Class[] { SqlSession.class }, new SqlSessionInterceptor());
     */
    return mapperMethod.execute(sqlSession, args);
  }

cachedMapperMethod方法

private MapperMethod cachedMapperMethod(Method method) {
    /**
     * 相当于这句代码.jdk8的新写法
     * if(methodCache.get(method)==null){
     *     methodCache.put(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()))
     * }
     */
    return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
  }

MapperProxy的invoke方法非常简单,主要干的工作就是创建MapperMethod对象或者是从缓存中获取MapperMethod对象。获取到这个对象后执行execute方法。

所以这边需要进入MapperMethod的execute方法:这个方法判断你当前执行的方式是增删改查哪一种,并通过SqlSession执行相应的操作。(后面的就以sqlSession.selectOne这种方式进行分析~)

public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    /**
     * 判断我们执行sql命令的类型
     */
    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()) {
          //返回值是一个List
          result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {
          //返回值是一个map
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
          //返回游标
          result = executeForCursor(sqlSession, args);
        } else {
          //查询返回单个

          /**
           * 解析我们的参数
           */
          Object param = method.convertArgsToSqlCommandParam(args);
          /**
           * 通过调用sqlSessionTemplate来执行我们的sql
           * 第一步:获取我们的statmentName(com.tuling.mapper.EmployeeMapper.findOne)
           * 然后我们就需要重点研究下SqlSessionTemplate是怎么来的?
           * 在mybatis和spring整合的时候,我们偷天换日了我们mapper接口包下的所有的
           * beandefinition改成了MapperFactoryBean类型的
           * MapperFactoryBean<T> extends SqlSessionDaoSupport的类实现了SqlSessionDaoSupport
           * 那么就会调用他的setXXX方法为我们的sqlSessionTemplate赋值
           *
           */
          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;
  }

sqlSession.selectOne方法会调到DefaultSqlSession的selectList方法。这个方法获取了MappedStatement对象,并最终调用了Executor的query方法。

selectOne方法

@Override
  public <T> T selectOne(String statement, Object parameter) {
    // Popular vote was to return null on 0 results and throw exception on too many.
    /**
     * 这里selectOne调用也是调用selectList方法
     */
    List<T> list = this.selectList(statement, parameter);
    //若查询出来有且有一个一个对象,直接返回要给
    if (list.size() == 1) {
      return list.get(0);
    } else if (list.size() > 1) {
      /**
       * 查询的有多个,那么久抛出我们熟悉的异常
       * Expected one result (or null) to be returned by selectOne(), but found: " + list.size()
       */
      throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
    } else {
      return null;
    }
  }
@Override
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      /**
       * 第一步:通过我们的statement去我们的全局配置类中获取MappedStatement
       */
      MappedStatement ms = configuration.getMappedStatement(statement);
      /**
       * 通过执行器去执行我们的sql对象
       * 第一步:包装我们的集合类参数
       * 第二步:一般情况下是executor为cacheExetory对象
       */
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

然后,通过一层一层的调用(这边省略了缓存操作的环节,会在后面的文章中介绍),最终会来到doQuery方法, 这儿咱们就随便找个Excutor看看doQuery方法的实现吧,我这儿选择了SimpleExecutor:

运行时参数

doQuery方法

public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      //内部封装了ParameterHandler和ResultSetHandler
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      stmt = prepareStatement(handler, ms.getStatementLog());
      //StatementHandler封装了Statement, 让 StatementHandler 去处理
      return handler.<E>query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }

接下来,咱们看看StatementHandler 的一个实现类 PreparedStatementHandler(这也是我们最常用的,封装的是PreparedStatement), 看看它使怎么去处理的:

public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
     //到此,原形毕露, PreparedStatement, 这个大家都已经滚瓜烂熟了吧
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    //结果交给了ResultSetHandler 去处理,处理完之后返回给客户端
    return resultSetHandler.<E> handleResultSets(ps);
  }

到此,整个调用流程结束

简单总结

这边结合获取SqlSession的流程,做下简单的总结:

  • SqlSessionFactoryBuilder解析配置文件,包括属性配置、别名配置、拦截器配置、环境(数据源和事务管理器)、Mapper配置等;解析完这些配置后会生成一个Configration对象,这个对象中包含了MyBatis需要的所有配置,然后会用这个Configration对象创建一个SqlSessionFactory对象,这个对象中包含了Configration对象;
  • 拿到SqlSessionFactory对象后,会调用SqlSessionFactory的openSesison方法,这个方法会创建一个Sql执行器(Executor组件中包含了Transaction对象),这个Sql执行器会代理你配置的拦截器方法。
  • 获得上面的Sql执行器后,会创建一个SqlSession(默认使用DefaultSqlSession),这个SqlSession中也包含了Configration对象和上面创建的Executor对象,所以通过SqlSession也能拿到全局配置;
  • 获得SqlSession对象后就能执行各种CRUD方法了。

以上是获得SqlSession的流程,下面总结下本博客中介绍的Sql的执行流程:

  • 调用SqlSession的getMapper方法,获得Mapper接口的动态代理对象MapperProxy,调用Mapper接口的所有方法都会调用到MapperProxy的invoke方法(动态代理机制);
  • MapperProxy的invoke方法中唯一做的就是创建一个MapperMethod对象,然后调用这个对象的execute方法,sqlSession会作为execute方法的入参;
  • 往下,层层调下来会进入Executor组件(如果配置插件会对Executor进行动态代理)的query方法,这个方法中会创建一个StatementHandler对象,这个对象中同时会封装ParameterHandler和ResultSetHandler对象。调用StatementHandler预编译参数以及设置参数值,使用ParameterHandler来给sql设置参数。

Executor组件有两个直接实现类,分别是BaseExecutor和CachingExecutor。CachingExecutor静态代理了BaseExecutor。Executor组件封装了Transction组件,Transction组件中又分装了Datasource组件。

  • 调用StatementHandler的增删改查方法获得结果,ResultSetHandler对结果进行封装转换,请求结束。

Executor、StatementHandler 、ParameterHandler、ResultSetHandler,Mybatis的插件会对上面的四个组件进行动态代理。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/379531.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

专享策略04 | 商品通用套利模型(二)

量化策略开发&#xff0c;高质量社群&#xff0c;交易思路分享等相关内容 『正文』 ˇ 大家好&#xff0c;去年我们推出了一款套利模型专享策略No.2 | 套利策略-自动换仓-出场加速. 截至到今天创出新高。 大家比较缺少套利&#xff0c;截面&#xff0c;盘口等类型的策略。因此…

「TCG 规范解读」PC 平台相关规范(1)

可信计算组织&#xff08;Ttrusted Computing Group,TCG&#xff09;是一个非盈利的工业标准组织&#xff0c;它的宗旨是加强在相异计算机平台上的计算环境的安全性。TCG于2003年春成立&#xff0c;并采纳了由可信计算平台联盟&#xff08;the Trusted Computing Platform Alli…

SpringBoot集成Knife4j接口管理工具

SpringBoot集成Knife4j接口管理工具1、导入依赖包2、配置Knife4j3、放行Knife4j的请求4、使用Knife4j注解5、实现效果平时开发项目都用的是Swagger2或者Swagger3&#xff0c;但是这两个UI看起来不是很舒服&#xff0c;今天看到了Knife4j&#xff0c;它对Swagger进行了增强&…

华为OD机试题【和最大子矩阵】用 C++ 进行编码 (2023.Q1)

最近更新的博客 华为od 2023 | 什么是华为od,od 薪资待遇,od机试题清单华为OD机试真题大全,用 Python 解华为机试题 | 机试宝典【华为OD机试】全流程解析+经验分享,题型分享,防作弊指南华为od机试,独家整理 已参加机试人员的实战技巧文章目录 最近更新的博客使用说明和最大…

3.ffmpeg命令行环境搭建、ffmpeg命令行初步了解

在上章,我们讲过: ffmpeg.exe: 主要用于转码或者剪切的应用程序, 也可以从url/现场音频/视频源抓取输入源ffplay.exe: 主要用于播放视频的应用程序,该应用程序源码是开源的,我们后面章节会去源码分析ffprobe.exe: 主要用于分析视频码流的应用程序, 可以获取媒体文件的详细信息,…

Jupyterlab 学习与测试笔记

前言本篇博客主要解决阿里云服务器上Jupyterlab配置方面的一些问题。1、安装完无法启动Jupyterlab首先声明&#xff0c;我在Anaconda3安装过程中已经设置了将安装相关的Python&#xff0c;ipython&#xff0c;Jupyter等添加到环境变量。但是一开始安装完&#xff0c;直接在命令…

从计费出账加速的设计谈周期性业务的优化思考

1号恐惧症 你有没有这样的做IT的朋友&#xff1f;年纪轻轻&#xff0c;就头发花白或者秃顶&#xff0c;然后每个月周期性的精神不振&#xff0c;一到月底&#xff0c;就有明显的焦虑。如果有&#xff0c;他可能就是运营商行业做计费运营的&#xff0c;请对他好点&#xff0c;特…

【LeetCode】剑指 Offer(12)

目录 题目&#xff1a;剑指 Offer 30. 包含min函数的栈 - 力扣&#xff08;Leetcode&#xff09; 题目的接口&#xff1a; 解题思路&#xff1a; 代码&#xff1a; 过啦&#xff01;&#xff01;&#xff01; 写在最后&#xff1a; 题目&#xff1a;剑指 Offer 30. 包含m…

【Node.js算法题】数组去重、数组删除元素、数组排序、字符串排序、字符串反向、字符串改大写 、数组改大写、字符替换

文章目录前言数组去重数组删除元素数组排序字符串排序字符串反向字符串改大写数组改大写字符替换字符替换运行结果&#xff1a; ![在这里插入图片描述](https://img-blog.csdnimg.cn/8ac1c15e6f0944cdb8ca50bcb844182a.png)总结前言 本期文章是js的一些算法题&#xff0c;包括…

FreeRTOS入门(07):流缓冲区 消息缓冲区

文章目录目的基础说明流缓冲区相关函数使用演示消息缓冲区相关函数使用演示总结目的 缓冲区是操作系统中常见的一种用于任务间数据传递的机制。这篇文章将对FreeRTOS中相关内容做个介绍。 本文代码测试环境见前面的文章&#xff1a;《FreeRTOS入门&#xff08;01&#xff09;…

Flink:The generic type parameters of ‘Collector‘ are missing 类型擦除

类型擦除问题处理报错日志描述问题描述报错解决其他方法方法一&#xff1a;TypeInformation方法二&#xff1a;TypeHint报错日志描述 报错日志&#xff1a; The generic type parameters of Collector are missing. In many cases lambda methods dont provide enough informa…

双边滤波和交叉双边滤波

什么是双边滤波 双边滤波是一种局部的、非线性的、非迭代的滤波技术&#xff0c;它将经典的低通滤波器与边缘停止函数相结合&#xff0c;当像素之间的强度差较大时&#xff0c;边缘停止函数会衰减滤波器的核心。由于同时考虑了相邻像素的灰度相似度和几何贴近度&#xff0c;滤…

使用开源httpworkshop执行http api测试与资源下载

平时我们在涉及HTTP开发时&#xff0c;会使用postman做api测试&#xff0c;优点是界面友好&#xff1b;平时我们写爬虫查找网络资源一般使用python编写脚本&#xff0c;优点是脚本支持的功能灵活&#xff1b;其实网络上做HTTP测试的工具和产品特别的多&#xff0c;但是都是做好…

锐捷(十六)mpls vxn option c 带RR场景

一 实验拓扑二 实验需求如图模拟R1在北京&#xff0c;R10在上海&#xff0c;要求二者之间用loopback口进行通信由于公司机密性质&#xff0c;要求二者需要使用mpls vxn 虚拟专线的方式进行通信本实验采取option c带RR的方式模拟通信左边AS100&#xff0c;右边AS200&#xff0c;…

19万字智慧城市总体规划与设计方案word

【版权声明】本资料来源网络&#xff0c;知识分享&#xff0c;仅供个人学习&#xff0c;请勿商用。【侵删致歉】如有侵权请联系小编&#xff0c;将在收到信息后第一时间删除&#xff01;完整资料领取见文末&#xff0c;部分资料内容&#xff1a; 1.1.1 感知基础设施 感知基础设…

数据库三大范式和个人看法

三大范式图解概括 第一范式(1NF) 确保数据库表字段的原子性 会存在数据冗余过大&#xff0c;插入异常&#xff0c;删除异常&#xff0c;修改异常的问题 举例&#xff1a; 某个字段name&#xff1a;‘西瓜 1566666‘ 依照第一范式就需要拆分成 name:‘西瓜’ ,phone:1566666’ …

房产营销、地产中介如何高效低成本获客?

数字化对企业而言&#xff0c;机遇和挑战并存。房产企业可借助数字化加强日益扩大的业务规模和业务领域管理&#xff0c;以提升管理效率&#xff0c;降低管理难度&#xff1b;基于数字化技术加强客户的服务体验&#xff0c;进而收集多业态客户和场景数据&#xff0c;拓展创新业…

计算机组成原理(2.1)--系统总线

目录 一、总线基本知识 1.总线 2.总线的信息传送 3.分散连接图 4.注 二、总线结构的计算机举例 1.面向 CPU 的双总线结构框图 2.单总线结构框图 3.以存储器为中心的双总线结构框图 三、总线的分类 1.片内总线 2.系统总线 &#xff08;板级总线或板间总线&#…

【leetcode】寻找重复数

题目链接&#xff1a;寻找重复数https://leetcode.cn/problems/find-the-duplicate-number/ 方法一&#xff1a;快慢指针 因为只有一个数字是重复的&#xff0c;且一个数字正好对应一个唯一的下标&#xff0c;所以可以将数组抽象为一个链表&#xff0c;假定数组为{1,2,3,4,5,…

Java内置队列和高性能队列Disruptor

一、队列简介 队列是一种特殊的线性表&#xff0c;遵循先入先出、后入后出&#xff08;FIFO&#xff09;的基本原则&#xff0c;一般来说&#xff0c;它只允许在表的前端进行删除操作&#xff0c;而在表的后端进行插入操作&#xff0c;但是java的某些队列运行在任何地方插入删…