Mybatisソースコード分析1

その他 2020-04-18 21:55:10 訪問数: null

もっとエキサイティングなコンテンツが私の独立したブログにアクセスできます

最も単純なコードから始めて、mybatisの一般的なワークフローを分析します。次に、コードの詳細からmybatisのいくつかの特性を分析します。

基本的なコード例

public class test {
  public static void main(String[] args) throws IOException{
    String resource = "example/mybatis-config.xml";
    // 加载配置文件 并构建SqlSessionFactory对象
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
    // 从SqlSessionFactory对象中获取 SqlSession对象
    SqlSession sqlSession = factory.openSession();
    // 执行操作
    User user=new User();
    user.setId(1);
    Object u= (User)sqlSession.selectOne("getUser", user);
    System.out.println(u.toString());
    // 关闭SqlSession
    sqlSession.close();
  }
}

Userクラスは、実際にはID、ユーザー名、パスワードのみを持つpojoです。コードは貼り付けません。
もちろん、mybatisには対応するSQLコードが必要です。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="example.Dao.UserMapper">
  <select id="getUser" parameterType="int" resultType="example.Pojo.User">
        select * from user where id= #{id}
    </select>
</mapper>

フレームワークに不可欠な構成もあります。

<?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>
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis_study?useUnicode=true"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="example/UserMapper.xml"/>
  </mappers>
</configuration>

このコードは貼り付けられています。mybatisの実行プロセスを分析するための例として、このコードを見てみましょう。

プロセス分析を実行する

SqlSessionFactoryの作成プロセス

有効なコードの最初の行はこのInputStream inputStream = Resources.getResourceAsStream(resource);場所、Resourcesつまりツールクラスであり、その役割はさまざまなリソースファイルのロードを容易にすることです。内部での実装方法は問題ではありません。つまり、このコード行は、構成ファイルを読み込むだけです。

私たちのハイライトは実際にはこのコード行です。 SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
このコード行を2つの部分に分割しました。最初の部分はnew SqlSessionFactoryBuilder()これを説明する必要がないことです。この部分の役割はSqlSessionFactoryBuilderオブジェクトを作成することです。2番目の部分はオブジェクトのSqlSessionFactory build(Reader reader)メソッドを呼び出すことです。このメソッドこのメソッドは実際には別のオーバーロードされたメソッドを実際に呼び出します。その具体的な実装は次のとおりです。

 public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        reader.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }

このコードは、他のことを考慮しない場合、渡された構成ファイルを使用してreader（呼び出しがnullの場合、後者の2つのパラメーターが渡されます）、XMLConfigBuilderオブジェクトを作成します。次に、オブジェクトのparse()メソッドを呼び出し、オブジェクトを取得し、Configurationオブジェクトを使用しConfiguration、build(Configuration cofig)メソッドを使用して、SqlSessionFactoryオブジェクトを作成し、オブジェクトを返しSqlSessionFactoryます。

以下では、これらの3つのステップの実行内容について説明します。

  • ステップ1：XMLConfigBuilderオブジェクトを作成します。
    シンプルで新しいように見えますが、オブジェクトが作成され、実際にはかなり複雑です。さまざまなオーバーロードされたコンストラクターがレイヤーごとに呼び出され、最終的にこのコンストラクターに到達しました。
  private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
  //创建一个空的Configuration对象，实例化了XMLConfigBuilder对象
    super(new Configuration());
    ErrorContext.instance().resource("SQL Mapper Configuration");
    //对属性各种赋值
    //我们配置时分离出的Properties文件中的信息，就是在这里进入到mybatis的
    this.configuration.setVariables(props);
    this.parsed = false;
    this.environment = environment;
    //parser就是用来解析XML文件的，在之前的构造器中，已经将配置文件的inputStream设置到该对象中去了
    this.parser = parser;
  }

基本的にすべてのコンストラクターが行うのは属性への値の割り当てであるため、XMLConfigBuilderそこにある属性とその役割の波を分析する必要があります。

//下面三个是继承自父类BaseBuilder中的属性

    /**
    * 存储基础配置信息的一个对象
    */
    protected final Configuration configuration; 
    /**
    * 故名思意，就是存储各种类型的别名的一个对象
    */
    protected final TypeAliasRegistry typeAliasRegistry;
    
    /**
    * 存储各种类型的类型处理器的对象
    */
    protected final TypeHandlerRegistry typeHandlerRegistry;


    /**
    * 标记该配置文件是否已经解析过
    */
    private boolean parsed;
    
    /**
    * 解析器模块，配置文件就由它进行解析
    */
    private final XPathParser parser;
    private String environment;
    
    /**
    * 默认反射工厂实现
    */
    private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();
  • 2番目のステップ：XMLConfigBuilderオブジェクトのConfiguration parse()メソッドを使用してオブジェクトを取得しConfigurationます。
    このメソッドの実装は次のとおりです。
  public Configuration parse() {
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;//将该配置文件标记为已解析
    
    //对配置文件中的configuration节点下的所有属性进行解析，并将解析到的信息封装到
    //XMLConfigBuilder对象的configuration属性中。
    parseConfiguration(parser.evalNode("/configuration"));
    //将填充好各种值的configuration返回
    return configuration;
  }

このコードを読んだ後、2番目の部分は実際には構成ファイルのconfigurationノードの下の情報を解析XMLConfigBuilderし、configurationオブジェクトの属性を初期化して、初期化を返すことであることがわかりますconfiguration。

  • 3番目のステップ：configurationパラメーターとして取得した完全な構成情報を使用してSqlSessionFactory build(Configuration config)、SqlSessionFactoryオブジェクトをビルドするメソッドを呼び出します

最初にこのメソッドを呼び出します。

  public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

このメソッドは、SqlSessionFactoryインターフェース実装クラスをインスタンス化しますDefaultSqlSessionFactory。
具体的なインスタンス化プロセスは次のとおりです。

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

非常にシンプルですがconfiguration、DefaultSqlSessionFactoryオブジェクトに渡されます。
この時点で、SqlSessionFactoryオブジェクトは正常に作成されています。
しかし、ここでは、非常に重要なリンクを見落としているようです。UserMapperx.xmlファイルconfigurationは、構成ファイルのノードをどのように処理しますか？

SqlSessionFactoryを作成するときにMapper.xmlを処理する方法は？

Mapper.xmlファイルがどのように処理されるかを知るには、まずそれが処理される場所を見つける必要があります。
前に我々の分析ではSqlSessionFactory、作成プロセスの時間、私たちは分析する必要があるメソッドを、この方法では、構成ファイルの構文解析されていると思います。次に、Mapper.xmlファイルの処理もこの場所から開始します。で、重要なメソッドの呼び出し、次のように、その実現があります。XMLConfigBuilderConfiguration parse()
Configuration parse()void parseConfiguration(XNode root)

 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");
          if (resource != null && url == null && mapperClass == null) {
            ErrorContext.instance().resource(resource);
            InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            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.");
          }
        }
      }
    }
  }

このメソッドは非常に複雑に見えますが、少なくとも少しの情報を得ることができ
ます。マッパー構成を作成するには3つの方法があります。

  <mappers>
    <mapper url=""/>
    <mapper class=""/>
    <mapper resource=""/>
  </mappers>

このメソッドは非常に複雑に見えますが、マッパーファイルを取得し、XMLMapperBuilderオブジェクトを作成し、マッパーファイルを解析するという3つのことだけです。

  • ステップ1：構成情報に基づいて各ノードで指定されたマッパーファイルを取得するマッパー
    構成を例にとると、
    InputStream inputStream = Resources.getResourceAsStream(resource);
    さまざまなリソースファイルをロードするために強力なResourcesツールクラスを使用しています。

  • ステップ2：XMLMapperBuilderオブジェクトを作成します。
    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
    作成 XMLMapperBuilderのプロセスは、基本的にインスタンス化して、パラメータにさまざまな値を注入することです。

  • ステップ3：対応するマッパーノードを分析する
    mapperParser.parse();

このメソッドの具体的な実装は次のとおりです。

  public void parse() {
    if (!configuration.isResourceLoaded(resource)) { //如果没有解析过
        //解析每个mapper节点中的信息
      configurationElement(parser.evalNode("/mapper"));
      //将当前文件加入已解析文件集合
      configuration.addLoadedResource(resource);
      //将mapper和命名空间进行绑定
      //本质就是将命名空间所对应的类和mapper文件都加入configuration中
      bindMapperForNamespace();
    }

    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
  }

この部分には多くの詳細が含まれていますが、mybatisでのマッパーの書き込み方法に精通している場合は、マッパーに多くのタグがあり、書き込み方法が比較的複雑であることがわかります。準備したら波を分析します。

SqlSession作成プロセス

これまでの努力の結果、SqlSessionFactory目的を達成しました。次に、SqlSessionオブジェクトを作成する必要があります。このプロセスは、次のコード行で完了します。
SqlSession sqlSession = factory.openSession();
具体的な実装は次のとおりです。

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

この方法には非常に重要な方法があります。

  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);
      //创建执行器
      final Executor executor = configuration.newExecutor(tx, execType);
      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();
    }
  }

このメソッドのポイントは、トランザクションオブジェクトを取得してエグゼキュータを作成することです。
アクチュエータ作成の具体的な実装は次のとおりです。

  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);
    }
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

この方法を観察すると、最初に得られる情報は、3種類のアクチュエーターがあるということです。それらは次のとおりです
。ExecutorType.SIMPLE：このタイプは他に何も実行せず、ステートメントごとにPreparedStatementを作成します
ExecutorType.REUSE：このタイプはPreparedStatementsを再利用します。
ExecutorType.BATCH：このタイプは、このタイプのバッチで更新されます。アクションを理解しやすくするには、その中のselectステートメントを区別する必要があります。

例として、ExecutorType.SIMPLEタイプを取り上げて、アクチュエーターを作成するときに行われることのいくつかを見てみましょう。
executor = new SimpleExecutor(this, transaction);
このコード行は基本的に、呼び出されSimpleExecutorた親クラスのBaseExecutorコンストラクターです。
具体的な実装は次のとおりです。

  protected BaseExecutor(Configuration configuration, Transaction transaction) {
    this.transaction = transaction;
    this.deferredLoads = new ConcurrentLinkedQueue<>();
    this.localCache = new PerpetualCache("LocalCache");
    this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
    this.closed = false;
    this.configuration = configuration;
    this.wrapper = this;
  }

いくつかの重要なプロパティがコンストラクターに注入されています。中でもキーはtransaction属性であり、このオブジェクトには、データベース接続の取得、送信、ロールバックなど、データベースを直接操作するための一連のメソッドが含まれています。
インターフェイスは次のとおりです。

public interface Transaction {

  /**
   * Retrieve inner database connection.
   * @return DataBase connection
   * @throws SQLException
   */
  Connection getConnection() throws SQLException;

  /**
   * Commit inner database connection.
   * @throws SQLException
   */
  void commit() throws SQLException;

  /**
   * Rollback inner database connection.
   * @throws SQLException
   */
  void rollback() throws SQLException;

  /**
   * Close inner database connection.
   * @throws SQLException
   */
  void close() throws SQLException;

  /**
   * Get transaction timeout if set.
   * @throws SQLException
   */
  Integer getTimeout() throws SQLException;

}

さっそく分析に戻りましょうSqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit)。
コンストラクタを取得したら作成できますSqlSession。
具体的な実装は次のコード行です。
return new DefaultSqlSession(configuration, executor, autoCommit);
呼び出されたコンストラクタの具体的な実装は次のとおりです。

  public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
    this.configuration = configuration;
    this.executor = executor;
    this.dirty = false;
    this.autoCommit = autoCommit;
  }

構成情報をアクチュエータでカプセル化することにより、SqlSession

SqlSessionがデータベースを操作する方法

例としてクエリを見てみましょう：

Object u= (User)sqlSession.selectOne("getUser", user);

具体的な実装は次のとおりです。

  public <T> T selectOne(String statement, Object parameter) {
    // Popular vote was to return null on 0 results and throw exception on too many.
    List<T> list = this.selectList(statement, parameter);
    if (list.size() == 1) {
      return list.get(0);
    } else if (list.size() > 1) {
      throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
    } else {
      return null;
    }
  }

このコードから、このコードがこのコードの主な役割であることがわかり List<T> list = this.selectList(statement, parameter);ます。残りのコードは戻り値を処理するために使用されます。

次に、波のselectList(statement, parameter)具体的な実現を分析します。

  public <E> List<E> selectList(String statement, Object parameter) {
    return this.selectList(statement, parameter, RowBounds.DEFAULT);
  }
  
  //最终调用了这个重载实现
    public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
        /*MappedStatement就是对sql语句和相关配置信息的封装，
        基本上执行一个sql所需的信息，MappedStatement中都有*/
      MappedStatement ms = configuration.getMappedStatement(statement);
      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();
    }
  }

このコードでは、最初にすべての情報をカプセル化するMappedStatementオブジェクトを取得してSQLを実行し、次にexecutorを呼び出してSQLを実行します。
ただし、executorを呼び出す前に、受信パラメーターも処理します。パラメーターをwrapCollection(parameter)
処理するためのコードは非常に単純です。パラメーターを処理するためのロジックは、基本的には複雑なパラメータータイプの一種のマークです。通常のオブジェクトは処理されません。

  private Object wrapCollection(final Object object) {
    if (object instanceof Collection) {
      StrictMap<Object> map = new StrictMap<>();
      map.put("collection", object);
      if (object instanceof List) {
        map.put("list", object);
      }
      return map;
    } else if (object != null && object.getClass().isArray()) {
      StrictMap<Object> map = new StrictMap<>();
      map.put("array", object);
      return map;
    }
    return object;
  }

すべての準備作業の準備が整ったら、クエリを実行するのはエグゼキュータです。

  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
  //可以理解为对sql信息的进一步处理，更加接近jdbc
    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 parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
      //尝试从缓存中读取
    Cache cache = ms.getCache();
    if (cache != null) {
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
        //缓存中，查询结果为空，就继续查询
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    return delegate.query(ms, parameterObject, 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) {
      throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      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) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }
  
  //从数据库中查询的实现
    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 {
    //进行查询
      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;
  }
  
  
  
    public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
    //获取configuration对象
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }
  
  
    public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    return resultSetHandler.handleResultSets(ps);
  }
  
  
    public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    //这里的sql就是可以执行的sql了
    String sql = boundSql.getSql();
    
    statement.execute(sql);
    //对查询的结果集进行处理
    return resultSetHandler.handleResultSets(statement);
  }

この部分も非常に複雑ですが、今後は波を勉強してブログを書いていきます。

おすすめ

転載: www.cnblogs.com/zofun/p/12728006.html
おすすめ
TIOBE 5 月リスト: Fortran がトップ 10 に「復活」
GCC 14.1 发布
ランキング
Linuxの一般的なコマンドの緊急対応
FPGAの設計者は、5つの基本的なスキルです
Javaの研究では、2019年6月12日ノート
Golang底层原理剖析之内存逃逸
VIM - Viは、プログラマーのテキストエディタを改善しました
魔法書（MagicTable）入門チュートリアルは、CADの一括転送複数のテーブルExcelをExcelを回し--CAD
mockitoとの望ましくないモック
EVE-NG MPLS L2VPN BGP pw -- スタティック ルート、スタティック mpls lsp
抵抗性タッチスクリーンドライバ（II）
PHP 安装扩展 Api Version 和扩展extensions路径不匹配的问题
アーカイブ
もっと
2024-05-08(18)
2024-05-07(34)
2024-05-06(6)
2024-05-05(0)
2024-05-04(18)
2024-05-03(8)
2024-05-02(0)
2024-05-01(4)
2024-04-30(35)
2024-04-29(5)

コードワールド

© 2018 codetd.com