前言

上文说道咱们拿到了构建modlule的factory，和依赖等要害数据，通过addModuleTree通过factorizeQueue的管制走到了factory.create。这个时候就开始了reslove过程。
本文次要剖析，NormalModuleFactory 外部 beforeResolve,factorize,resolve, afterResolve 这几个钩子。

配置文件

本文围绕的配置文件如下：

module.exports = {  mode: 'production',  entry: './src/index.js',  output: {    filename: 'main.js',    path: path.resolve(__dirname, 'dist'),  },  module: {    rules: [      {        test: /\.(js?|tsx?|ts?)$/,        use: [            {                loader: 'babel-loader',            },        ],    },    ]  },  resolve: {    extensions: ['.js', '.ts'],    alias: {      demo: path.resolve(__dirname, 'src/second'),    },  },};

factory.create

入口从factory.create开始，这里的 factory 是之前 addModuleTree 获取到的 NormalModuleFactory

NormalModuleFactory 先触发了其外部的 beforeResolve 钩子，而后在回调里执行了 factorize 钩子函数。
factorize 钩子内有又调用了resolve。

这里看起来比拟绕，简略解释一下：
钩子的调用程序，就像是这样。
beforeResolve -> factorize -> resolve

• beforeResolve 没找到之前注册过的中央，看起来什么都没干，也有可能是我没找到
• factorize 之前在 ExternalModuleFactoryPlugin插件中注册过，这里会解决下external的信息。
• resolve 钩子注册在 NormalModuleFactory 外部，用于解析这个module，生成对应的loader和依赖信息，这里的重点就在resolve

resolve

getLoaderResolver

进来的第一步resolve 钩子先调用了this.getResolver("loader") 返回loaderResolver，这个能够了解为是解析loader的办法。
简略过一下分为以下几步：

• 调用到了 ResolverFactory里的get办法
• 判断是否有对应类型的缓存
• 创立 resolveOptions,
• 调用 require("enhanced-resolve").ResolverFactory 创立了一个 resolver，而后返回 NormalModuleFactory继续执行代码。

const loaderResolver = this.getResolver("loader");

loaderResolver裸露了一个resolver办法，用于解析loader。

normalResolver

接着往下走，略过一些判断，间接走到了defaultResolve这个办法，这里会依据webpack配置文件中的resolve选项,生成一个 normalResolver。同样的，这个normalResolver也是require("enhanced-resolve").ResolverFactory的实例，也暴露出了一个resolve办法。

const normalResolver = this.getResolver(    "normal",    dependencyType        ? cachedSetProperty(            resolveOptions || EMPTY_RESOLVE_OPTIONS,            "dependencyType",            dependencyType      )    : resolveOptions);

接下来会把这个normalResolver 和一些上下文信息传给resolveResource办法，这里最终会调用到node_modules/enhanced-resolve/lib/Resolver.js的doResolve。

this.resolveResource(    contextInfo,    context,    unresolvedResource,    normalResolver,    resolveContext,    (err, resolvedResource, resolvedResourceResolveData) => {        if (err) return continueCallback(err);        if (resolvedResource !== false) {            resourceData = {                resource: resolvedResource,                data: resolvedResourceResolveData,                ...cacheParseResource(resolvedResource)            };        }        continueCallback();    });

而后依据doResolve返回的resolvedResource和resolvedResourceResolveData一起拼装成resourceData。咱们在后续解析loader的时候还会用到这个。

resourceData数据结构

解析loader

在resolvedResource的回调里继续执行

const result = this.ruleSet.exec({    resource: resourceDataForRules.path,    realResource: resourceData.path,    resourceQuery: resourceDataForRules.query,    resourceFragment: resourceDataForRules.fragment,    scheme,    assertions,    mimetype: matchResourceData    ? ""    : resourceData.data.mimetype || "",    dependency: dependencyType,    descriptionData: matchResourceData    ? undefined    : resourceData.data.descriptionFileData,    issuer: contextInfo.issuer,    compiler: contextInfo.compiler,    issuerLayer: contextInfo.issuerLayer || ""});

这里会依据配置文件里的rules失去须要的loader，这个例子里，咱们的result是

接下来会通过这个result的遍历，生成useLoadersPost, useLoaders, useLoadersPre。
而后调用resolveRequestArray失去postLoaders, normalLoaders, preLoaders。

this.resolveRequestArray(  contextInfo,  this.context,  useLoaders,  loaderResolver,  resolveContext,  (err, result) => {    normalLoaders = result;    continueCallback(err);  });

以后例子并没有postLoaders和preLoaders，这里只有normalLoaders。resolveRequestArray外部调用loaderResolver.resolve解析useLoaders,最初后果就是把result里的loader替换成了对应的实在文件地址。

{  ident:undefined  loader:'/Users/csy/Code/webpack5/node_modules/babel-loader/lib/index.js'  options:undefined}

生成回调数据

最初在continueCallback解决下曾经生成好的数据，首先是对loader的合并。把postLoaders, normalLoaders, preLoaders这几个合并。而后assign一下data.createData, 这个data来自于钩子的入口传入的data。

Object.assign(data.createData, {    layer:        layer === undefined ? contextInfo.issuerLayer || null : layer,    request: stringifyLoadersAndResource(        allLoaders,        resourceData.resource    ),    userRequest,    rawRequest: request,    loaders: allLoaders,    resource: resourceData.resource,    context:        resourceData.context || getContext(resourceData.resource),    matchResource: matchResourceData        ? matchResourceData.resource        : undefined,    resourceResolveData: resourceData.data,    settings,    type,    parser: this.getParser(type, settings.parser),    parserOptions: settings.parser,    generator: this.getGenerator(type, settings.generator),    generatorOptions: settings.generator,    resolveOptions});

这里着重讲一下getParser和getGenerator, 这两个办法返回的是对应文件的解析器和构建模板的办法。依照以后示例，返回的是JavascriptParser和JavascriptGenerator。

而后这个createData将被用于createModule。
在执行完NormalModuleFactory的afterResolve钩子后

const createData = resolveData.createData;this.hooks.createModule.callAsync(//something)

reslove完结了，行将开始下一步，创立module!

小结

• module resolve 流程用于取得各 loader 和模块的绝对路径等信息。
• 在 resolver钩子里，先通过 enhanced-resolve 获取 loaderResolver，提供 resolve 办法
• 在 defaultResolve 办法里，获取 normalResolver, 提供 resolve 办法。
• 解析 unresolvedResource，失去文件的绝对路径等信息
• 依据rules失去 loader
• 应用 loaderResolver 失去loader的绝对路径等信息
• 合并 loader, 拼接数据，
• 调用 NormalModuleFactory的afterResolve钩子，完结 resolve 流程。