පහත දැක්වෙන පරිදි නිර්මාණය කර ඇති වෙනත් කෙනෙකුගේ කේතයක් ඔබ භාවිතා කළ යුතු යැයි සිතන්න:
class Messy {
String concat(String param, String str) { /* ... */ }
boolean contains(String param, String s) { /* ... */ }
boolean isEmpty(String param) { /* ... */ }
boolean matches(String param, String regex) { /* ... */ }
boolean startsWith(String param, String prefix) { /* ... */ }
}
ඔබගේ කේතය එය මත රඳා පවතින බව පහත දැක්වෙන ආකාරයට පෙනේ යැයි දැන් සිතන්න:
String process(String param) {
Messy messy = new Messy();
if (messy.contains(param, "whatever")) {
return messy.concat(param, "-contains");
}
if (messy.isEmpty(param)) {
return messy.concat(param, "-empty");
}
if (messy.matches(param, "[whatever]")) {
return messy.concat(param, "-matches");
}
if (messy.startsWith(param, "whatever")) {
return messy.concat(param, "-startsWith");
}
return messy.concat(param, "-whatever");
// WTF do I really need to repeat bloody "param" 9 times above?
}
... සහ ඔබේ යෙදුමට අවශ්ය නොවන පරාමිතීන් නැවත නැවත භාවිතා කිරීම ඉවත් කිරීම සඳහා, විශේෂයෙන් භාවිතා කිරීම පහසු කිරීමට ඔබට අවශ්ය බව.
හරි, ඒ නිසා ඔබ දූෂණ විරෝධී තට්ටුවක් තැනීමට පටන් ගන්න.
පළමු දෙය නම් ඔබේ “ප්‍රධාන කේතය” Messyකෙලින්ම යොමු නොවන බවට වග බලා ගැනීමයි . නිදසුනක් ලෙස, ඔබ යැපීම් කළමනාකරණය සකස් කරන්නේ ප්‍රවේශ Messyවීමට උත්සාහ කිරීම සම්පාදනය කිරීමට අසමත් වන ආකාරයට ය.
දෙවනුව, ඔබ කැපවූ "ස්තර" මොඩියුලයක් නිර්මාණය කරන අතර එය ඔබට ප්‍රවේශ වන එකම Messyක්‍රමය වන අතර එය ඔබට වඩා හොඳ අර්ථයක් ලබා දෙන අයුරින් ඔබේ "ප්‍රධාන කේතයට" නිරාවරණය කරයි.
ස්ථර කේතය පහත පරිදි වේ:
class Reasonable { // anti-corruption layer
String param;
Messy messy = new Messy();
Reasonable(String param) {
this.param = param;
}
String concat(String str) { return messy.concat(param, str); }
boolean contains(String s) { return messy.contains(param, s); }
boolean isEmpty() { return messy.isEmpty(param); }
boolean matches(String regex) { return messy.matches(param, regex); }
boolean startsWith(String prefix) { return messy.startsWith(param, prefix); }
}
එහි ප්‍රති As ලයක් ලෙස, ඔබේ “ප්‍රධාන කේතය” අවුල් වන්නේ නැත Messy, Reasonableඒ වෙනුවට පහත පරිදි භාවිතා කරයි:
String process(String param) {
Reasonable reasonable = new Reasonable(param);
// single use of "param" above and voila, you're free
if (reasonable.contains("whatever")) {
return reasonable.concat("-contains");
}
if (reasonable.isEmpty()) {
return reasonable.concat("-empty");
}
if (reasonable.matches("[whatever]")) {
return reasonable.concat("-matches");
}
if (reasonable.startsWith("whatever")) {
return reasonable.concat("-startsWith");
}
return reasonable.concat("-whatever");
}
සටහන තවමත් අවුල් ජාලාවක් ඇති Messyනමුත් මෙය දැන් සාධාරණ ලෙස ගැඹුරින් සැඟවී ඇති Reasonableඅතර එමඟින් ඔබේ “ප්‍රධාන කේතය” සාධාරණ ලෙස පිරිසිදුව හා දූෂණයෙන් තොර වන අතර ඒවා සෘජුවම භාවිතා කිරීමෙන් ගෙන එනු ඇත Messy.
ඉහත උදාහරණය පදනම් වී ඇත්තේ c2 විකියේ දී Anticorrupt Layer පැහැදිලි කර ඇති ආකාරය මත ය :
ඔබේ යෙදුම තුළ දත්ත සමුදායක් හෝ වෙනත් යෙදුමක් සමඟ ගනුදෙනු කිරීමට අවශ්ය නම්, ඔබේම යෙදුම තුළ ඔබට අවශ්ය ආකෘතියට නුසුදුසු හෝ අදාළ කළ නොහැකි නම්, එම ආකෘතියට සහ ඔබේ භාෂාවට පරිවර්තනය කිරීමට AnticorruptLayer භාවිතා කරන්න.
සටහන උදාහරණය හිතාමතාම සරල කර ensed නීභවනය කර පැහැදිලි කිරීම කෙටියෙන් තබා ගනී.
දූෂණ විරෝධී ස්තරය පිටුපස ආවරණය කිරීම සඳහා ඔබට විශාල API අවුල් ජාලයක් තිබේ නම්, එම ප්‍රවේශයම අදාළ වේ: පළමුව, ඔබේ “ප්‍රධාන කේතය” දූෂිත දේට සෘජුව හා දෙවනුව ප්‍රවේශ නොවන බවට වග බලා ගන්න , එය වඩාත් පැහැදිලි ආකාරයකින් නිරාවරණය කරන්න ඔබගේ භාවිත සන්දර්භය තුළ පහසුය.
ඉහත සරල කළ උදාහරණයකින් ඔබ්බට ඔබේ ස්තරය “පරිමාණය” කරන විට, ඔබේ API පහසු කිරීම සුළුපටු කාර්යයක් නොවන බව සැලකිල්ලට ගන්න. ක් ආයෝජනය උත්සාහයක් කිරීමට ලේයරය නිවැරදි මාර්ගය නිර්මාණය , එහි අපේක්ෂිත භාවිතය තහවුරු ඒකකය පරීක්ෂණ ආදිය
වෙනත් වචන වලින් කිවහොත්, ඔබේ API සැබවින්ම සැඟවී ඇති එකකට වඩා වැඩි දියුණු කිරීමක් බවට වග බලා ගන්න, ඔබ තවත් දූෂණ ස්ථරයක් හඳුන්වා නොදෙන බවට වග බලා ගන්න.
සම්පූර්ණත්වය සඳහා, ඇඩැප්ටරය සහ මුහුණත මේ හා අදාළ රටාවන් අතර සියුම් නමුත් වැදගත් වෙනසක් සැලකිල්ලට ගන්න . එහි නමෙන් දැක්වෙන පරිදි, ප්‍රති- දූෂිත ස්තරය උපකල්පනය කරන්නේ යටින් පවතින ඒපීඅයි හි ගුණාත්මක ගැටළු ඇති බවයි ("දූෂිත") සහ සඳහන් කර ඇති ගැටළු වලින් ආරක්ෂාවක් ලබා දීමට අදහස් කරයි.
ඔබට එය මේ ආකාරයෙන් සිතිය හැකිය: පුස්තකාල නිර්මාණකරුවා Reasonableඒ වෙනුවට එහි ක්‍රියාකාරිත්වය නිරාවරණය කිරීම වඩා හොඳ යැයි ඔබට සාධාරණීකරණය කළ හැකි නම් Messy, මෙයින් අදහස් කරන්නේ ඔබ ප්‍රති-දූෂණ ස්ථරයේ වැඩ කරමින්, ඔවුන්ගේ කාර්යය කරමින්, ඔවුන්ගේ සැලසුම් වැරදි නිවැරදි කරන බවයි.
ඊට ප්‍රතිවිරුද්ධව, ඇඩැප්ටරය සහ ෆැසෙඩ් යටි සැලසුමේ ගුණාත්මකභාවය පිළිබඳ උපකල්පන නොකරයි. මේවා ඔබේ විශේෂිත අවශ්‍යතා සඳහා අනුවර්තනය කරමින් ආරම්භ කිරීම සඳහා හොඳින් සැලසුම් කර ඇති API වෙත යෙදිය හැකිය.
ඇත්ත වශයෙන්ම, ඇඩැප්ටරය සහ ෆැසෙඩ් වැනි රටා යටින් පවතින කේතය හොඳින් සැලසුම් කර ඇතැයි අපේක්ෂා කිරීම වඩාත් tive ලදායී විය හැකිය. ඔබට එය මේ ආකාරයෙන් සිතිය හැකිය: හොඳින් සැලසුම් කරන ලද කේතය විශේෂිත භාවිත අවස්ථා සඳහා කරකැවීම එතරම් අපහසු නොවිය යුතුය. ඔබේ ඇඩැප්ටරයේ සැලසුම බලාපොරොත්තු වූවාට වඩා වැඩි උත්සාහයක් ගත යුතු බව පෙනේ නම්, මෙයින් ඇඟවෙන්නේ යටින් පවතින කේතය කෙසේ හෝ “දූෂිත” බවයි. එවැනි අවස්ථාවකදී, ඔබට කාර්යය වෙන් කිරීම අදියරයන් ලෙස සලකා බැලිය හැකිය: පළමුව, යටින් පවතින API නිසි ලෙස ව්‍යුහාත්මක ආකාරයකින් ඉදිරිපත් කිරීම සඳහා ප්‍රතිවෛරස් ස්ථරයක් ස්ථාපිත කරන්න, ඊළඟට, එම ආරක්ෂණ ස්ථරයට ඉහළින් ඔබේ ඇඩැප්ටරය / මුහුණත සැලසුම් කරන්න.