深入理解Webpack核心模块Tapable钩子[异步版]

cocoer 2019-07-01

接上一篇文章 深入理解Webpack核心模块WTApable钩子(同步版)

tapable中三个注册方法

  • 1 tap(同步) 2 tapAsync(cb) 3 tapPromise(注册的是Promise)

tapable中对三个触发方法

  • 1 call 2 callAsync 3 promise

这一章节 我们将分别实现异步的Async版本和Promise版本

异步钩子
  • AsyncParallelHook
  • AsyncParallelHook的Promise版本
  • AsyncSeriesHook
  • AsyncSeriesHook的Promise版本
  • AsyncSeriesWaterfallHook
  • AsyncSeriesWaterfallHook的Promise版本

异步的钩子分为并行和串行的钩子，并行是指 等待所有并发的异步事件执行之后再执行最终的异步回调。
而串行是值 第一步执行完毕再去执行第二步，以此类推，直到执行完所有回调再去执行最终的异步回调。

AsyncParallelHook

AsyncParallelHook是异步并行的钩子，上代码:

const { AsyncParallelHook } = require('tapable');

class Hook{
    constructor(){
        this.hooks = new AsyncParallelHook(['name']);
    }
    tap(){
        /** 异步的注册方法是tapAsync() 
         * 并且有回调函数cb.
        */
        this.hooks.tapAsync('node',function(name,cb){
            setTimeout(()=>{
                console.log('node',name);
                cb();
            },1000);
        });
        this.hooks.tapAsync('react',function(name,cb){
            setTimeout(()=>{
                console.log('react',name);
                cb();
            },1000);
        });
    }
    start(){
        /** 异步的触发方法是callAsync() 
         * 多了一个最终的回调函数 fn.
        */
        this.hooks.callAsync('call end.',function(){
            console.log('最终的回调');
        });
    }
}

let h = new Hook();

h.tap();/** 类似订阅 */
h.start();/** 类似发布 */

/* 打印顺序：
    node call end.
    react call end.
    最终的回调
*/

等待1s后，分别执行了node call end和react callend 最后执行了最终的回调fn.

手动实现：

class AsyncParallelHook{
    constructor(args){ /* args -> ['name']) */
        this.tasks = [];
    }
    /** tap接收两个参数 name和fn */
    tap(name,fn){
        /** 订阅:将fn放入到this.tasks中 */
        this.tasks.push(fn);
    }
    start(...args){
        let index = 0;
        /** 通过pop()获取到最后一个参数 
         * finalCallBack() 最终的回调
         */
        let finalCallBack = args.pop();
        /** 箭头函数绑定this */
        let done = () => {
            /** 执行done() 每次index+1 */
            index++;
            if(index === this.tasks.length){
                /** 执行最终的回调 */
                finalCallBack();
            }
        }
        this.tasks.forEach((task)=>{
            /** 执行每个task，传入我们给定的done回调函数 */
            task(...args,done);
        });
    }
}

let h = new AsyncParallelHook(['name']);

/** 订阅 */
h.tap('react',(name,cb)=>{
    setTimeout(()=>{
        console.log('react',name);
        cb();
    },1000);
});
h.tap('node',(name,cb)=>{
    setTimeout(()=>{
        console.log('node',name);
        cb();
    },1000);
});
/** 发布 */
h.start('end.',function(){
    console.log('最终的回调函数');
});

/* 打印顺序：
    react end.
    node end.
    最终的回调函数
*/
AsyncParallelHook的Promise版本
const { AsyncParallelHook } = require('tapable');

class Hook{
    constructor(){
        this.hooks = new AsyncParallelHook(['name']);
    }
    tap(){
        /** 这里是Promsie写法 
         * 注册事件的方法为tapPromise 
        */
        this.hooks.tapPromise('node',function(name){
            return new Promise((resolve,reject)=>{
                setTimeout(()=>{
                    console.log('node',name);
                    resolve();
                },1000);
            });
        });
        this.hooks.tapPromise('react',function(name){
            return new Promise((resolve,reject)=>{
                setTimeout(()=>{
                    console.log('react',name);
                    resolve();
                },1000);
            });
        });
    }
    start(){
        /** 
         * promsie最终返回一个prosise 成功resolve时
         * .then即为最终回调
        */
        this.hooks.promise('call end.').then(function(){
            console.log('最终的回调');
        });
    }
}

let h = new Hook();

h.tap();
h.start();

/* 打印顺序：
    node call end.
    react call end.
    最终的回调
*/

这里钩子还是AsyncParallelHook钩子，只是写法变成了promise的写法，去掉了回调函数cb().变成了成功时去resolve().其实用Promise可以更好解决异步并行的问题，因为Promise的原型方法上有个all()方法，它的作用就是等待所有promise执行完毕后再去执行最终的promise。我们现在去实现它:

class SyncHook{
    constructor(args){ 
        this.tasks = [];
    }
    tapPromise(name,fn){
        this.tasks.push(fn);
    }
    promise(...args){
        /** 利用map方法返回一个新数组的特性 */
        let tasks = this.tasks.map((task)=>{
            /** 每一个task都是一个Promise */
            return task(...args);
        });
        /** Promise.all() 等待所有Promise都执行完毕 */
        return Promise.all(tasks);
    }
}

let h = new SyncHook(['name']);

/** 订阅 */
h.tapPromise('react',(name)=>{
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{
            console.log('react',name);
            resolve();
        },1000);
    });
});
h.tapPromise('node',(name)=>{
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{
            console.log('node',name);
            resolve();
        },1000);
    });
});
/** 发布 */
h.promise('end.').then(function(){
    console.log('最终的回调函数');
});

/* 打印顺序：
    react end.
    node end.
    最终的回调函数
*/
AsyncSeriesHook

AsyncSeriesHook是异步串行的钩子， 串行，我们刚才说了， 它是一步步去执行的，下一步执行依赖上一步执行是否完成，手动实现:

const { AsyncSeriesHook } = require('tapable');

class Hook{
    constructor(){
        this.hooks = new AsyncSeriesHook(['name']);
    }
    tap(){
        /** 异步的注册方法是tapAsync() 
         * 并且有回调函数cb.
        */
        this.hooks.tapAsync('node',function(name,cb){
            setTimeout(()=>{
                console.log('node',name);
                cb();
            },1000);
        });
        this.hooks.tapAsync('react',function(name,cb){
            /** 此回调要等待上一个回调执行完毕后才开始执行 */
            setTimeout(()=>{
                console.log('react',name);
                cb();
            },1000);
        });
    }
    start(){
        /** 异步的触发方法是callAsync() 
         * 多了一个最终的回调函数 fn.
        */
        this.hooks.callAsync('call end.',function(){
            console.log('最终的回调');
        });
    }
}

let h = new Hook();

h.tap();
h.start();

/* 打印顺序：
    node call end.
    react call end. -> 1s后打印
    最终的回调 -> 1s后打印
*/

AsyncParallelHook和AsyncSeriesHook的区别是AsyncSeriesHook是串行的异步钩子，也就是说它会等待上一步的执行 只有上一步执行完毕了 才会开始执行下一步。而AsyncParallelHook是并行异步 AsyncParallelHook 是同时并发执行。 ok.手动实现 AsyncSeriesHook:

class AsyncParallelHook{
    constructor(args){ /* args -> ['name']) */
        this.tasks = [];
    }
    /** tap接收两个参数 name和fn */
    tap(name,fn){
        /** 订阅:将fn放入到this.tasks中 */
        this.tasks.push(fn);
    }
    start(...args){
        let index = 0;
        let finalCallBack = args.pop();
        /** 递归执行next()方法 直到执行所有task
         * 最后执行最终的回调finalCallBack()
         */
        let next = () => {
            /** 直到执行完所有task后 
             * 再执行最终的回调 finalCallBack()
             */
            if(index === this.tasks.length){
                return finalCallBack();
            }
            /** index++ 执行每一个task 并传入递归函数next
             * 执行完每个task后继续递归执行下一个task
             * next === cb，next就是每一步的cb回调
            */
            this.tasks[index++](...args,next);
        }
        /** 执行next() */
        next();
    }
}

let h = new AsyncParallelHook(['name']);

/** 订阅 */
h.tap('react',(name,cb)=>{
    setTimeout(()=>{
        console.log('react',name);
        cb();
    },1000);
});
h.tap('node',(name,cb)=>{
    setTimeout(()=>{
        console.log('node',name);
        cb();
    },1000);
});
/** 发布 */
h.start('end.',function(){
    console.log('最终的回调函数');
});

/* 打印顺序：
    react end.
    node end. -> 1s后打印
    最终的回调函数 -> 1s后打印
*/
AsyncSeriesHook的Promise版本
const { AsyncSeriesHook } = require('tapable');

class Hook{
    constructor(){
        this.hooks = new AsyncSeriesHook(['name']);
    }
    tap(){
        /** 这里是Promsie写法 
         * 注册事件的方法为tapPromise 
        */
        this.hooks.tapPromise('node',function(name){
            return new Promise((resolve,reject)=>{
                setTimeout(()=>{
                    console.log('node',name);
                    resolve();
                },1000);
            });
        });
        this.hooks.tapPromise('react',function(name){
            /** 等待上一步 执行完毕之后 再执行 */
            return new Promise((resolve,reject)=>{
                setTimeout(()=>{
                    console.log('react',name);
                    resolve();
                },1000);
            });
        });
    }
    start(){
        /** 
         * promsie最终返回一个prosise 成功resolve时
         * .then即为最终回调
        */
        this.hooks.promise('call end.').then(function(){
            console.log('最终的回调');
        });
    }
}

let h = new Hook();

h.tap();
h.start();

/* 打印顺序：
    node call end.
    react call end. -> 1s后打印
    最终的回调 -> 1s后打印
*/

手动实现AsyncSeriesHook的Promise版本

class AsyncSeriesHook{
    constructor(args){ 
        this.tasks = [];
    }
    tapPromise(name,fn){
        this.tasks.push(fn);
    }
    promise(...args){
        /** 1 解构 拿到第一个first
         * first是一个promise
         */
        let [first, ...others] = this.tasks;
        /** 4 利用reduce方法 累计执行
         * 它最终返回的是一个Promsie
         */
        return others.reduce((l,n)=>{
            /** 1 下一步的执行依赖上一步的then */
            return l.then(()=>{
                /** 2 下一步执行依赖上一步结果 */
                return n(...args);
            });
        },first(...args));
    }
}

let h = new AsyncSeriesHook(['name']);

/** 订阅 */
h.tapPromise('react',(name)=>{
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{
            console.log('react',name);
            resolve();
        },1000);
    });
});
h.tapPromise('node',(name)=>{
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{
            console.log('node',name);
            resolve();
        },1000);
    });
});
/** 发布 */
h.promise('end.').then(function(){
    console.log('最终的回调函数');
});

/* 打印顺序：
    react end.
    node end. -> 1s后打印
    最终的回调函数 -> 1s后打印
*/

最后一个AsyncSeriesWaterfallHook：

AsyncSeriesWaterfallHook

AsyncSeriesWaterfallHook 异步的串行的瀑布钩子，首先 它是一个异步串行的钩子，同时 它的下一步依赖上一步的结果返回：

const { AsyncSeriesWaterfallHook } = require('tapable');

class Hook{
    constructor(){
        this.hooks = new AsyncSeriesWaterfallHook(['name']);
    }
    tap(){
        this.hooks.tapAsync('node',function(name,cb){
            setTimeout(()=>{
                console.log('node',name);
                /** 第一次参数是err, 第二个参数是传递给下一步的参数 */
                cb(null,'第一步返回第二步的结果');
            },1000);
        });
        this.hooks.tapAsync('react',function(data,cb){
            /** 此回调要等待上一个回调执行完毕后才开始执行 
             *  并且 data 是上一步return的结果.
            */
            setTimeout(()=>{
                console.log('react',data);
                cb();
            },1000);
        });
    }
    start(){
        this.hooks.callAsync('call end.',function(){
            console.log('最终的回调');
        });
    }
}

let h = new Hook();

h.tap();
h.start();

/* 打印顺序：
    node call end.
    react 第一步返回第二步的结果
    最终的回调
*/

我们可以看到 第二步依赖了第一步返回的值， 并且它也是串行的钩子，实现它：

class AsyncParallelHook{
    constructor(args){ /* args -> ['name']) */
        this.tasks = [];
    }
    /** tap接收两个参数 name和fn */
    tap(name,fn){
        /** 订阅:将fn放入到this.tasks中 */
        this.tasks.push(fn);
    }
    start(...args){
        let index = 0;
        /** 1 拿到最后的最终的回调 */
        let finalCallBack = args.pop();
        let next = (err,data) => {
            /** 拿到每个task */
            let task = this.tasks[index];
            /** 2 如果没传task 或者全部task都执行完毕
             * return 直接执行最终的回调finalCallBack()
             */
            if(!task) return finalCallBack();

            if(index === 0){
                /** 3 执行第一个task
                 * 并传递参数为原始参数args
                 */
                task(...args, next);
            }else{
                /** 4 执行处第二个外的每个task
                 * 并传递的参数 data
                 *  data ->‘传递给下一步的结果’
                 */
                task(data, next);
            }
            index++;
        }
        /** 执行next() */
        next();
    }
}

let h = new AsyncParallelHook(['name']);

/** 订阅 */
h.tap('react',(name,cb)=>{
    setTimeout(()=>{
        console.log('react',name);
        cb(null,'传递给下一步的结果');
    },1000);
});
h.tap('node',(name,cb)=>{
    setTimeout(()=>{
        console.log('node',name);
        cb();
    },1000);
});
/** 发布 */
h.start('end.',function(){
    console.log('最终的回调函数');
});

/* 打印顺序：
    react end.
    node 传递给下一步的结果
    最终的回调函数
*/
AsyncSeriesWaterfallHook的Promise版本
const { AsyncSeriesWaterfallHook } = require('tapable');

class Hook{
    constructor(){
        this.hooks = new AsyncSeriesWaterfallHook(['name']);
    }
    tap(){
        this.hooks.tapPromise('node',function(name){
            return new Promise((resolve,reject)=>{
                setTimeout(()=>{
                    console.log('node',name);
                    /** 在resolve中把结果传给下一步 */
                    resolve('返回给下一步的结果');
                },1000);
            });
        });
        this.hooks.tapPromise('react',function(name){
            return new Promise((resolve,reject)=>{
                setTimeout(()=>{
                    console.log('react',name);
                    resolve();
                },1000);
            });
        });
    }
    start(){
        this.hooks.promise('call end.').then(function(){
            console.log('最终的回调');
        });
    }
}

let h = new Hook();

h.tap();
h.start();

/* 打印顺序：
    node call end.
    react 返回给下一步的结果
    最终的回调
*/

用Promsie实现很简单，手动实现它吧:

class AsyncSeriesHook{
    constructor(args){ 
        this.tasks = [];
    }
    tapPromise(name,fn){
        this.tasks.push(fn);
    }
    promise(...args){
        /** 1 解构 拿到第一个first
         * first是一个promise
         */
        let [first, ...others] = this.tasks;
        /** 2 利用reduce方法 累计执行
         * 它最终返回的是一个Promsie
         */
        return others.reduce((l,n)=>{
            return l.then((data)=>{
                /** 3 将data传给下一个task 即可 */
                return n(data);
            });
        },first(...args));
    }
}

let h = new AsyncSeriesHook(['name']);

/** 订阅 */
h.tapPromise('react',(name)=>{
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{
            console.log('react',name);
            resolve('promise-传递给下一步的结果');
        },1000);
    });
});
h.tapPromise('node',(name)=>{
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{
            console.log('node',name);
            resolve();
        },1000);
    });
});
/** 发布 */
h.promise('end.').then(function(){
    console.log('最终的回调函数');
});

/* 打印顺序：
    react end.
    node promise-传递给下一步的结果
    最终的回调函数
*/

ok.至此，我们把tapable的钩子全部解析并手动实现完毕。写文章不易，喜欢的话给个赞或者start～
代码在github上：mock-webpack-tapable

cocoer

cocoer

相关推荐

Vue生命周期（详解版，会持续补充！！！）

Vue的生命周期通俗来讲就是我们用Vue写的网页在浏览器运行起来之后，我们写的代码要在内存里执行。这个实例从创建一直到我们关掉浏览器这个实例消亡，这一段时间里，Vue这个框架干了啥，Vue的实例做了啥，先做啥，后做啥，这一系列事情的关系是怎样的，这就是Vu

luvhl / 0评论 2020-06-12

2、react-生命周期1※※※

生命周期： 一个人的生命周期：从出生到去世 出生得那一刻就是当前这一个人特性固定下来得那一刻：实例化期 出生了之后生长知道死的那一刻：生存期 去世了：销毁期 所以对于一个组件来说它的生命周期是三个时期：实例化期、生存期和销毁期 实

luvhl / 0评论 2020-06-08

ReactDefaultBatchingStrategy源码

// 原型继承Transaction的某构造函数的实例将拥有perform方法。// 实现功能为，method函数执行前后，调用成对的前置钩子initialize、及后置钩子close；initialize为close提供参数

涓涓溪流 / 0评论 2017-02-04

webpack4 源码解析（三）——tapable

在解析webpack4 的 Compiler 模块前，我们先要解析以下它赖以实现的也是webpack的核心依赖模块tapable。tapable 简而言之，就是一个注册钩子函数的模块。我们知道，webpack之所以强大，靠的就是丰富的插件系统，不管你有什么

SUDevops / 0评论 2019-09-05

深入理解Webpack核心模块Tapable钩子[同步版]

tapable是webpack的核心依赖库 想要读懂webpack源码 就必须首先熟悉tapableok.下面是webapck中引入的tapable钩子 由此可见 在webpack中tapable的重要性。} = require;这些钩子可分为同步的钩子和

Handy / 0评论 2019-07-01

面试官常问——vue篇

这是因为箭头函数绑定了父级上下文，因此this与你期待的vue实例不同,this.fetchTodos的行为未定义。beforeCreate 在实例初始化之后,数据观测和 event/watcher事件配置之前被调用。然而，挂载阶段还没开始，$el属性目

dantesite / 0评论 2019-07-01

snabbdom源码解析（五） 钩子

方便外部做一些处理。元素从父节点删除时触发，和destory略有不同，remove只影响到被移除节点中最顶层的节点

mojianc / 0评论 2019-06-30

svn钩子函数(HOOK)的使用-win平台

%SVNLOOK% log %REPOS% -t %TXN% | findstr ".........." > nul. echo 不允许空日志，提交中断!exit 1自动更新同步服务器站点目录的代码1. 首先在版本库的hooks

LargebeaR / 0评论 2019-06-29

ReactDefaultBatchingStrategy源码

// 原型继承Transaction的某构造函数的实例将拥有perform方法。// 实现功能为，method函数执行前后，调用成对的前置钩子initialize、及后置钩子close；initialize为close提供参数

芋道源码 / 0评论 2017-02-04

Vue中父子组件生命周期执行顺序初探

如今前端框架都流行组件化，页面元素都可以使用组件进行高度概括，那么处理组件之间的关系就如同处理页面架构一样重要。正确理解组件之间的关系，才能让代码按照我们与预料方式工作。0 问题描述同react，vue组件也有一套完整的生命周期，不同阶段有不同的分工。总体

sanlingwu / 0评论 2019-06-28

Vue源码学习之callHook钩子函数

Vue实例在不同的生命周期阶段，都调用了callHook方法。比如在实例初始化的时候调用callHook和callHook。这里的"beforeCreate","created"状态并非随意定义，而是来自于Vue内部

小桥流水XY / 0评论 2019-06-28

Vue--手把手教你撸一个 beforeEnter 钩子函数

为什么要自造beforeEnter钩子函数？所以但我点击返回时，单词列表要展示所有单词用户掌握的最新情况。当然，对于上面的场景是比较少的，但是beforeEnter钩子函数的存在还是有必要的。};对于该混入对象，使用全局或者局部混入都是可行的。

游戏人日常 / 0评论 2019-06-27

vue-router 导航钩子

vue-router 提供的导航钩子主要用来拦截导航，让它完成跳转或取消。执行效果依赖 next 方法的调用参数。如果全部钩子执行完了，则导航的状态就是 confirmed （确认的）。如果浏览器的 URL 改变了，那么 URL 地址会重置到 from 路

89701933 / 0评论 2019-06-21

开发WordPress插件

WordPress插件允许你对原有的网站进行修改和增强功能，而不必修改WordPress的核心程序，本文就简单介绍一下如何开发一个自己的Wordpress插件。一个好的习惯在是插件目录下建立一个空的index.php，这个文件的作用的防止网站输出这个目录的

一味 / 0评论 2019-06-21

jquery中钩子函数总结——jquery的另类扩展

下面是我对这篇文章重点做一个整理。jquery中如下函数有钩子函数，可以对函数属性进行自定义操作。它们分别是attr(),prop(),val()和css()，同时还可以对selector的伪类实现自定义。// convert value to a boo

zhangyang0 / 0评论 2012-08-08

android 上的API函数钩子，利用CydiaHook实现

发布将近一年了，最近发现还是有些人需要的，github上也有些人fork了。利用CydiaSubstrateSDK开发，可以HOOKjava层或NATIVE层API接口。写代码的初衷是因为有个app，需要保存数据到SD卡上，并且app里面有判断SD挂载的状

kkcode / 0评论 2016-09-05

详解Vue源码学习之callHook钩子函数

Vue实例在不同的生命周期阶段，都调用了callHook方法。比如在实例初始化的时候调用callHook和callHook。这里的"beforeCreate","created"状态并非随意定义，而是来自于Vue内部

如狼 / 0评论 2018-07-25

Vue路由钩子之afterEach beforeEach的区别详解

<router-link :to="{ name: 'product', params: { id : 1 }}">User</router-link>. this.$router.push // 命名的路由的

87457702 / 0评论 2018-07-15

Vue手把手教你撸一个 beforeEnter 钩子函数

为什么要自造beforeEnter钩子函数？所以但我点击返回时，单词列表要展示所有单词用户掌握的最新情况。当然，对于上面的场景是比较少的，但是beforeEnter钩子函数的存在还是有必要的。};对于该混入对象，使用全局或者局部混入都是可行的。

xiaorulou / 0评论 2018-04-24

vue-router 导航钩子的具体使用方法

vue-router 提供的导航钩子主要用来拦截导航，让它完成跳转或取消。执行效果依赖 next 方法的调用参数。如果全部钩子执行完了，则导航的状态就是 confirmed （确认的）。next('/') 或者 next: 跳转到一个不同的地址。并且给每一

89477009 / 0评论 2017-08-31

Linux下用内存管理器的钩子函数跟踪内存泄漏

作为Linux下的C程序员，我总是习惯在单元测试通过之后，再用valgrind把程序跑一下，看看有没有内存泄漏和内存越界等问题。可惜的是，有时valgrind并不能很好的工作，像基于DirectFB的多进程程序在valgrind下是跑不起的, 这时我们可以

hcr / 0评论 2009-12-20

python学习之hook钩子的原理和使用

钩子函数、注册函数、回调函数，他们的概念其实是一样的。钩子函数，顾名思义，就是把我们自己实现的hook函数在某一时刻挂接到目标挂载点上。hook的概念在windows的消息响应机制里面体现的尤为明显。可能我们大家有写过windows桌面相关的程序，里面有各

LHpython / 0评论 2018-10-25

实例讲解Ruby中的钩子方法及对方法调用添加钩子

钩子方法有些类似事件驱动装置，可以在特定的事件发生后执行特定的回调函数，这个回调函数就是钩子方法(更形象的描述: 钩子方法可以像钩子一样，勾住一个特定的事件。)，在Rails中before\after函数就是最常见的钩子方法。Class#inherited

platoon / 0评论 2016-06-04

详解vue-router导航守卫

当做Vue-cli项目的时候需要在路由跳转前做一些验证，比如登录验证，是网站中的普遍需求。对此，vue-router 提供的 beforeEach可以方便地实现全局导航守卫。组件内部的导航守卫函数使用相同，只是函数名称不同。钩子，早期编程可能有个概念叫句柄

80437700 / 0评论 2019-01-19

解析WordPress中函数钩子hook的作用及基本用法

WordPress 的插件机制实际上只的就是这个 Hook 了，它中文被翻译成钩子，允许你参与 WordPress 核心的运行，是一个非常棒的东西，下面我们来详细了解一下它。钩子分为两种，一种叫做动作，还有一种叫做过滤器。动作的理念是让你在一种情况或者一个

PHP100 / 0评论 2019-03-28

模板模式和钩子函数

一.什么是模板模式?定义一个操作中的算法的骨架，而将一些步骤延迟到子类中,模板方法使得子类可以不改变一个算法的结构就能重新定义该算法的某些特定步骤。最后将方法汇总构成一个不可改变的模板方法。封装性好,复用性好,屏蔽细节,便于维护这几大优点;不同的实现都需要

稀土 / 0评论 2018-05-06

3-8 Linux系统中防火墙的框架简单分析

Netfilter提供了一个抽象、通用化的框架，该框架定义的一个子功能的实现就是包过滤子系统。Netfilter框架包含以下五部分：。在这几个点中，协议栈将把数据报及钩子函数标号作为参数调用netfilter框架。

网上冲浪 / 0评论 2016-11-24

Linux系统中防火墙的框架分析

Netfilter提供了一个抽象、通用化的框架，该框架定义的一个子功能的实现就是包过滤子系统。Netfilter框架包含以下五部分：。在这几个点中，协议栈将把数据报及钩子函数标号作为参数调用netfilter框架。

操作系统 / 0评论 2016-11-17