Q: 什麼是食物?
A: 食物通常以碳水化合物、脂肪、蛋白質或水構成,能夠藉由進食或是飲用爲人類或者生物提供營養或愉悅的物質。
食物的來源可以是植物、動物或者其他界的生物,例如真菌,亦或發酵產品像是酒精。
生物攝取食物後,被生物的細胞同化,提供能量,維持生命及刺激成長。
前段時間討論到Java中的回調函數時,提到了面向切面(Aspect Oriented Programming)編程。它是一種程序設計思維,常常與面向對象(Object Oriented Programming)編程相比較,但是也常常被單獨拎出來討論。
OOP的誕生源自於人類與生俱來的分類抽象能力,回想一下,讀小學的你,是否就能輕而易舉地分辨“零食”和“正餐”的區別呢?零食美味而充滿誘惑,但是對於你來說昂貴,而且吃太多存在捱罵的風險,相對的,正餐則略顯的無聊和平淡,但是在你餓了的時候往往能讓你的肚子不會咕咕叫。
於是自然而然你就可以將它們的共同點抽象出來,比如它們可以被食用,但是它們的味道、價格、食用時間乃至“副作用”之類的都不太一樣。它們中相同的屬性,就可以分配給一個只對這些相同的屬性敏感的父元素。而不同的部分,就單獨分配給父元素下屬的不同的子元素。這樣一來,子元素就不光含有自己的屬性,也擁有了父元素的所有屬性。
所以現在名詞解釋對你來說,會不會變得更容易呢?
面向切面
現在你知道了,事物中對於某些相同屬性的抽象,構成了面向對象的基石。
來寫一個簡單的OOP的例子
// JavaScript ES6
class Person {
constructor(name) {
this.name = name;
}
greeting() {
console.log(`hello, my name is ${this.name}, `);
}
}
class Engineer extends Person {
constructor(name, level) {
super(name);
this.level = level;
}
// override
greeting() {
super.greeting();
console.log(`a ${this.level} Engineer.`);
}
}
class Architect extends Engineer {
constructor(name, level) {
super(name, level);
}
design(work) {
console.log(`right now, i\`m ${work}.`);
}
playGames(game, platform) {
console.log(`${this.name} is playing ${game} on ${platform} now.`);
}
}
let ted = new Architect('Ted', 'Junior');
ted.greeting();
ted.design('painting some blueprints');
>>>
hello, my name is Ted,
a Junior Engineer.
right now, i'm painting some blueprints.
侵入式切面
假設我們想要在對象 Person
的所有方法執行前,加入一段邏輯。我們有什麼好辦法呢?
代理函數是個很好的選擇,我們在進行具體的業務調用時,直接調用一個代理函數就行了。
function before(person, fn, ...args) {
console.log('something running before');
return fn.apply(person, args);
}
函數 before
,將我們要調用的函數包裹起來,然後我們只需要這樣調用這個代理函數,就能在其中的某個部分中添加邏輯。
before(ted, ted.design, 'painting some blueprints');
上面的全局函數,還可以直接添加進對象中,防止被不必要的類或者方法使用。
Person.prototype.before = function (fn, ...args) {
console.log('do sthing before');
return fn.call(this, args);
};
ted.before(ted.design, 'painting some blueprints');
雖然這種形式大體上能解決我們的需求,但是這種寫法,仍然破壞了對象原有的調用形式。
// 原來的調用形式
ted.greeting();
ted.playingGames('DotA2', 'PC');
ted.design('painting some blueprints');
// 代理函數的調用形式
ted.before(ted.greeting);
ted.before(ted.playingGames, 'DotA2', 'PC');
ted.before(ted.design, 'painting some blueprints');
清一色的 before
函數,不僅寫起來頭暈,而且當你要改動的時候,所有調用這個代理函數的地方都要進行改動。這並不是我們想要的。
非侵入式切面
代理函數幫我們執行了函數,雖然能按照我們的期望執行程序,但我們更希望它直接返回函數給我們,這樣我們就無須費勁心思地去到處修改舊代碼,同時往代碼中添加了新的功能。
function before(originTarget, fn) {
return function (...args) {
console.log('do sthing before');
return fn.apply(originTarget, args);
};
}
ted.playGames = before(ted, ted.playGames);
// 正常調用
ted.playGames('DotA2', 'PC');
以上代碼還可以寫成更加通用的寫法
function before (clazz, fn) {
return function (...args) {
console.log(`now time: ${new Date()}`);
return clazz.prototype[fn].apply(this, args);
}
}
ted.greeting = before(Person, 'greeting');
// 正常調用
ted.greeting();
程序中那些無法通過父元素所聚合的共同屬性,但是又切實地影響到了程序的寫作——這種時候,切面編程就能發揮出它的用處。它將業務中的相同的部分抽象出來,組成一個個可拆卸的業務組件。面向對象通過繼承和多態的縱軸讓代碼鬆耦合,而面向切面則是在業務並行展開的水平線上讓代碼鬆耦合。
中間件
提起AOP,總免不了讓人想到Java Spring框架中的監聽器、攔截器、過濾器。它們是典型的AOP編程思想的結晶——一條正常的程序流,被幾個中間件攔截檢查。
這啓發了我們,在程序設計上的一條新思路:程序暴露出一段執行流,並且給開發者一把剪刀。它們可以隨意在允許的範圍內剪開程序,並織入想要執行的內容。最後這一段執行流合重新合併起來,收入程序的深處。
簡單模擬一箇中間件設計
// 切入點函數隊列
let fns = [];
// 切點計數
let fnCounter = 0;
// 啓動函數
function main() {
next();
}
// 執行下一個函數
function next() {
let fn = fns[fnCounter++]; // 取出函數數組裏的下一個函數
if (!fn) { // 如果函數不存在,return
return;
}
fn(next); // 否則,執行下一個函數
}
// 將自定義的函數推入函數隊列
function processer(fn) {
fns.push(fn);
}
function loginCheck(next) {
if (...)
next();
else
return;
}
function characterFilter(next) {
// doing some character filtering
next();
}
function mainService() {
// 主業務
console.log('some main services');
}
processer(characterFilter);
processer(loginCheck);
processer(mainService);
main(); // 模擬程序啓動
原文地址: https://code.evink.me/2018/07/post/Aspect-Oriented-Programming/