allbet gmaing代理:深入Mybatis源码——执行流程

2020-07-08 33 views 0

扫一扫用手机浏览

前言

上一篇剖析Mybatis是若何加载剖析XML文件的,本篇紧接上文,剖析Mybatis的剩余两个阶段:署理封装SQL执行

正文

署理封装

Mybatis有两种方式挪用Mapper接口:

private static SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);

// 第一种
try (SqlSession session = sqlMapper.openSession(TransactionIsolationLevel.SERIALIZABLE)) {
  Blog blog = session.selectOne("org.apache.ibatis.domain.blog.mappers.BlogMapper.selectBlogWithPostsUsingSubSelect", 1);
}

// 第二种
try (SqlSession session = sqlMapper.openSession()) {
  AuthorMapper mapper = session.getMapper(AuthorMapper.class);
  Author author = mapper.selectAuthor(101);
}

从上面代码可以看到无论是哪一种首先都要建立SqlSessionFactory工具,然后通过这个工具拿到SqlSession工具。在早期版本中只能通过该工具的增删改挪用Mapper接口,很明显这种方式可读性很差,难以维护,写起来也庞大,以是后面谷歌最先维护Mybatis后,重新封装提供了第二种方式直接挪用Mapper接口。不外本质上第二种是在第一种的基础之上实现的,以是下面就以第二种为主举行剖析,进入到getMapper方式:

  public <T> T getMapper(Class<T> type) {
    return configuration.<T>getMapper(type, this);
  }

  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }

  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    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);
    }
  }

mapperRegistry工具在上一篇剖析过,是在剖析xml中的mapper节点时注册进去的,而这个工具中缓存了Mapper接口和对应的署理工厂的映射,以是getMapper的焦点就是通过这个工厂去建立署理工具:

  public T newInstance(SqlSession sqlSession) {
	 //每次挪用都市建立新的MapperProxy工具
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

然后通过Mapper接口挪用时首先就会挪用到MapperProxyinvoke方式:

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {//若是是Object自己的方式不增强
        return method.invoke(this, args);
      } else if (isDefaultMethod(method)) {
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    //从缓存中获取mapperMethod工具,若是缓存中没有,则建立一个,并添加到缓存中
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    //挪用execute方式执行sql
    return mapperMethod.execute(sqlSession, args);
  }

  private MapperMethod cachedMapperMethod(Method method) {
    return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
  }

首先从缓存中拿到MapperMethod工具,这个工具封装了SQL语句的类型、命名空间、入参、返回类型等信息,然后通过它的execute方式挪用SqlSession的增删查改方式:

  public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    //凭据sql语句类型以及接口返回的参数选择挪用差别的
    switch (command.getType()) {
      case INSERT: {
    	Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.insert(command.getName(), param));
        break;
      }
      case UPDATE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.update(command.getName(), param));
        break;
      }
      case DELETE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.delete(command.getName(), param));
        break;
      }
      case SELECT:
        if (method.returnsVoid() && method.hasResultHandler()) {//返回值为void
          executeWithResultHandler(sqlSession, args);
          result = null;
        } else if (method.returnsMany()) {//返回值为聚集或者数组
          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);
          result = sqlSession.selectOne(command.getName(), param);
          if (method.returnsOptional() &&
              (result == null || !method.getReturnType().equals(result.getClass()))) {
            result = OptionalUtil.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本质上是门面模式的体现,其本质上是通过Executor执行器组件实现的,在该组件中界说了所有接见数据库的方式:

  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      //从configuration中获取要执行的sql语句的设置信息
      MappedStatement ms = configuration.getMappedStatement(statement);
      //通过executor执行语句,并返回指定的效果集
      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();
    }
  }

Executor工具是在获取SqlSession时建立的:

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

  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
    	//获取mybatis设置文件中的environment工具
      final Environment environment = configuration.getEnvironment();
      //从environment获取transactionFactory工具
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      //建立事务工具
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      //凭据设置建立executor
      final Executor executor = configuration.newExecutor(tx, execType);
      //建立DefaultSqlSession
      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();
    }
  }

TransactionFactory是我们在xml中设置的transactionManager属性,可选的属性有JDBC和Managed,然后凭据我们的设置建立事务工具,之后才是建立Executor工具。

  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 {
      executor = new SimpleExecutor(this, transaction);
    }
    //若是有<cache>节点,通过装饰器,添加二级缓存的能力
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    //通过interceptorChain遍历所有的插件为executor增强,添加插件的功效
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

Executor有三个基本的实现类:

  • BatchExecutor:批处置执行器,执行批量更新、插入等操作。
  • ReuseExecutor:可重用执行器,缓存并重用Statement(Statement、PreparedStatement、CallableStatement)。
  • SimpleExecutor:默认使用的执行器,每次执行都市建立 新的Statement

这三个执行器都继续了自抽象的BaseExecutor,同时若是开启了二级缓存功效,在这里还会装饰一个CachingExecutor为其添加二级缓存的能力。另外还要注重在这段代码的最后另有阻挡器举行了包装,也就是扩展插件的实现 ,关于这部分内容在一篇举行剖析。

SQL执行

二级缓存的代码很简朴,这里直接略过,以是直接进入到BaseExecutor.query方式:

  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
	//获取sql语句信息,包罗占位符,参数等信息
    BoundSql boundSql = ms.getBoundSql(parameter);
    //拼装缓存的key值
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
 }

  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {//检查当前executor是否关闭
      throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {//非嵌套查询,而且FlushCache设置为true,则需要清空一级缓存
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;//查询条理加一
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;//查询以及缓存
      if (list != null) {
    	 //针对挪用存储历程的效果处置
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
    	 //缓存未掷中,从数据库加载数据
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
    
    
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {//延迟加载处置
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {//若是当前sql的一级缓存设置为STATEMENT,查询完既清空一集缓存
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

首先从一级缓存localCache内里拿,若是没有,才真正地接见数据库,并将返回效果存入到一级缓存中。

  private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    localCache.putObject(key, EXECUTION_PLACEHOLDER);//在缓存中添加占位符
    try {
      //挪用抽象方式doQuery,方式查询数据库并返回效果,可选的实现包罗:simple、reuse、batch
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      localCache.removeObject(key);//在缓存中删除占位符
    }
    localCache.putObject(key, list);//将真正的效果工具添加到一级缓存
    if (ms.getStatementType() == StatementType.CALLABLE) {//若是是挪用存储历程
      localOutputParameterCache.putObject(key, parameter);//缓存输出类型效果参数
    }
    return list;
  }

这里的doQuery是子类实现的,即模板模式,以SimpleExecutor为例:

  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();//获取configuration工具
      //建立StatementHandler工具,
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      //StatementHandler工具建立stmt,并使用parameterHandler对占位符举行处置
      stmt = prepareStatement(handler, ms.getStatementLog());
      //通过statementHandler工具挪用ResultSetHandler将效果集转化为指定工具返回
      return handler.<E>query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }

通读这里的代码我们可以发现,Executor自己是不会接见到数据库,而是作为指挥官,指挥三个小弟做事:

  • StatementHandler:建立PreparedStatementStatementCallableStatement工具。
  • ParameterHandler:在StatementHandler组织函数中建立,对预编译的 SQL 语句举行参数设置。
  • ResultSetHandler:在StatementHandler组织函数中建立,对数据库返回的效果集(ResultSet)举行封装,返回用户指定的实体类型。

上面三个工具都是在configuration.newStatementHandler方式中建立的,然后挪用prepareStatement拿到合适的Statement,若是是预编译的还会举行参数设置:

  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    //获取connection工具的动态署理,添加日志能力;
    Connection connection = getConnection(statementLog);
    //通过差别的StatementHandler,行使connection建立(prepare)Statement
    stmt = handler.prepare(connection, transaction.getTimeout());
    //使用parameterHandler处置占位符
    handler.parameterize(stmt);
    return stmt;
  }

若是在DEBUG模式下拿到的Connection工具是ConnectionLogger,这就和第一篇的内容串联起来了。之后再通过query方式挪用execute执行SQL语句,并使用ResultSetHandler处置效果集:

  public List<Object> handleResultSets(Statement stmt) throws SQLException {
    ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
    //用于保留效果集工具
    final List<Object> multipleResults = new ArrayList<>();

    int resultSetCount = 0;
    //statment可能返回多个效果集工具,这里先取出第一个效果集
    ResultSetWrapper rsw = getFirstResultSet(stmt);
    //获取效果集对应resultMap,本质就是获取字段与java属性的映射规则
    List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);//效果集和resultMap不能为空,为空抛出异常
    while (rsw != null && resultMapCount > resultSetCount) {
     //获取当前效果集对应的resultMap
      ResultMap resultMap = resultMaps.get(resultSetCount);
      //凭据映射规则(resultMap)对效果集举行转化,转换成目的工具以后放入multipleResults中
      handleResultSet(rsw, resultMap, multipleResults, null);
      rsw = getNextResultSet(stmt);//获取下一个效果集
      cleanUpAfterHandlingResultSet();//清空nestedResultObjects工具
      resultSetCount++;
    }
    //获取多效果集。多效果集一样平常出现在存储历程的执行,存储历程返回多个resultset,
    //mappedStatement.resultSets属性列出多个效果集的名称,用逗号支解;
    //多效果集的处置不是重点,暂时不剖析
    String[] resultSets = mappedStatement.getResultSets();
    if (resultSets != null) {
      while (rsw != null && resultSetCount < resultSets.length) {
        ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
        if (parentMapping != null) {
          String nestedResultMapId = parentMapping.getNestedResultMapId();
          ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
          handleResultSet(rsw, resultMap, null, parentMapping);
        }
        rsw = getNextResultSet(stmt);
        cleanUpAfterHandlingResultSet();
        resultSetCount++;
      }
    }

    return collapseSingleResultList(multipleResults);
  }

这里最终就是通过反射模块以及Configuration类中的result相关设置举行效果映射:

  private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
    try {
      if (parentMapping != null) {//处置多效果集的嵌套映射
        handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
      } else {
        if (resultHandler == null) {//若是resultHandler为空,实例化一个人默认的resultHandler
          DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
          //对ResultSet举行映射,映射效果暂存在resultHandler中
          handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
          //将暂存在resultHandler中的映射效果,填充到multipleResults
          multipleResults.add(defaultResultHandler.getResultList());
        } else {
          //使用指定的rusultHandler举行转换
          handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
        }
      }
    } finally {
      // issue #228 (close resultsets)
      //挪用resultset.close()关闭效果集
      closeResultSet(rsw.getResultSet());
    }
  }

  public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    if (resultMap.hasNestedResultMaps()) {//处置有嵌套resultmap的情形
      ensureNoRowBounds();
      checkResultHandler();
      handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    } else {//处置没有嵌套resultmap的情形
      handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    }
  }

  private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
      throws SQLException {
	//建立效果上下文,所谓的上下文就是专门在循环中缓存效果工具的
    DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
    //1.凭据分页信息,定位到指定的纪录
    skipRows(rsw.getResultSet(), rowBounds);
    //2.shouldProcessMoreRows判断是否需要映射后续的效果,现实照样翻页处置,制止跨越limit
    while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
      //3.进一步完善resultMap信息,主要是处置鉴别器的信息
      ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
      //4.读取resultSet中的一行纪录并举行映射,转化并返回目的工具
      Object rowValue = getRowValue(rsw, discriminatedResultMap);
      //5.保留映射效果工具
      storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
    }
  }

  private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {
    final ResultLoaderMap lazyLoader = new ResultLoaderMap();
    //4.1 凭据resultMap的type属性,实例化目的工具
    Object rowValue = createResultObject(rsw, resultMap, lazyLoader, null);
    if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
      //4.2 对目的工具举行封装获得metaObjcect,为后续的赋值操作做好准备
      final MetaObject metaObject = configuration.newMetaObject(rowValue);
      boolean foundValues = this.useConstructorMappings;//取得是否使用组织函数初始化属性值
      if (shouldApplyAutomaticMappings(resultMap, false)) {//是否使用自动映射
    	 //4.3一样平常情形下 autoMappingBehavior默认值为PARTIAL,对未明确指定映射规则的字段举行自动映射
        foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, null) || foundValues;
      }
       //4.4 映射resultMap中明确指定需要映射的列
      foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, null) || foundValues;
      foundValues = lazyLoader.size() > 0 || foundValues;
      //4.5 若是没有一个映射乐成的属性,则凭据<returnInstanceForEmptyRow>的设置返回null或者效果工具
      rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
    }
    return rowValue;
  }
  • 自动映射
  private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {
	//获取resultSet中存在的,然则ResultMap中没有明确映射的列,填充至autoMapping中
    List<UnMappedColumnAutoMapping> autoMapping = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);
    boolean foundValues = false;
    if (!autoMapping.isEmpty()) {
      //遍历autoMapping,通过自动匹配的方式为属性复制
      for (UnMappedColumnAutoMapping mapping : autoMapping) {
    	//通过typeHandler从resultset中拿值
        final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
        if (value != null) {
          foundValues = true;
        }
        if (value != null || (configuration.isCallSettersOnNulls() && !mapping.primitive)) {
          // gcode issue #377, call setter on nulls (value is not 'found')
          //通过metaObject给属性赋值
          metaObject.setValue(mapping.property, value);
        }
      }
    }
    return foundValues;
  }
  • 指定映射
  private boolean applyPropertyMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, ResultLoaderMap lazyLoader, String columnPrefix)
      throws SQLException {
	//从resultMap中获取明确需要转换的列名聚集
    final List<String> mappedColumnNames = rsw.getMappedColumnNames(resultMap, columnPrefix);
    boolean foundValues = false;
    //获取ResultMapping聚集
    final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
    for (ResultMapping propertyMapping : propertyMappings) {
      String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);//获得列名,注重前缀的处置
      if (propertyMapping.getNestedResultMapId() != null) {
        // the user added a column attribute to a nested result map, ignore it
    	//若是属性通过另外一个resultMap映射,则忽略
        column = null;
      }
      if (propertyMapping.isCompositeResult()//若是是嵌套查询,column={prop1=col1,prop2=col2}
          || (column != null && mappedColumnNames.contains(column.toUpperCase(Locale.ENGLISH)))//基本类型映射
          || propertyMapping.getResultSet() != null) {//嵌套查询的效果
    	//获得属性值
        Object value = getPropertyMappingValue(rsw.getResultSet(), metaObject, propertyMapping, lazyLoader, columnPrefix);
        // issue #541 make property optional
        //获得属性名称
        final String property = propertyMapping.getProperty();
        if (property == null) {//属性名为空跳出循环
          continue;
        } else if (value == DEFERED) {//属性名为DEFERED,延迟加载的处置
          foundValues = true;
          continue;
        }
        if (value != null) {
          foundValues = true;
        }
        if (value != null || (configuration.isCallSettersOnNulls() && !metaObject.getSetterType(property).isPrimitive())) {
          // gcode issue #377, call setter on nulls (value is not 'found')
          //通过metaObject为目的工具设置属性值
          metaObject.setValue(property, value);
        }
      }
    }
    return foundValues;
  }

反射实例化工具的代码对照长,但逻辑都对照清晰,上面的要害流程代码也都加上了注释,读者可自行参照源码阅读。

总结

Mybatis焦点原理就剖析完了,相对照Spring源码简朴了许多,但代码的优雅度和优异的设计头脑一点也不亚于Spring,也是异常值得我们好好学习掌握的。不外这3篇只是剖析了Mybaits的焦点执行原理,另外另有插件怎么扩展、阻挡器会阻挡哪些方式以及Mybatis和Spring的整合又是怎么实现的呢?读者们可以好好思索下,谜底将在下一篇揭晓。

,

欧博allbet注册

欢迎进入欧博allbet注册(Allbet Game):www.aLLbetgame.us,欧博官网是欧博集团的官方网站。欧博官网开放Allbet注册、Allbe代理、Allbet电脑客户端、Allbet手机版下载等业务。

Sunbet网站内容转载自互联网,如有侵权,联系Sunbet删除。

本文链接地址:http://www.caac-feixingjia.com/post/996.html

相关文章

发表评论