पेश है एओपी

प्रोग्रामिंग प्रतिमान

आईटी विकास की आधुनिक दुनिया में, लेखन कार्यक्रमों के लिए बहुत सारे अलग-अलग दृष्टिकोण हैं। इसलिए, उदाहरण के लिए, किसी को कार्यक्रम को कार्यों के अनुक्रम के रूप में प्रस्तुत करना पसंद है, जबकि किसी का मानना ​​है कि कार्यक्रम वस्तुओं का एक सेट होना चाहिए जो एक दूसरे के साथ संवाद करते हैं। इन विचारों और अवधारणाओं के संयोजन से कार्यक्रम की लेखन शैली का एक प्रकार बनता है, जिसे आमतौर पर प्रोग्रामिंग प्रतिमान कहा जाता है ।

प्रत्येक प्रतिमान की अपनी विशेषताएं होती हैं, हालांकि, मुख्य कारक जो उन्हें अलग करता है वह कार्यक्रम की मूल इकाई की अवधारणा है। यहाँ सबसे लोकप्रिय हैं:

• निर्देश (अनिवार्य प्रोग्रामिंग, FORTRAN / C / PHP),
• समारोह (कार्यात्मक प्रोग्रामिंग, हास्केल / लिस्प / एफ # / स्काला),
• प्रोटोटाइप (प्रोटोटाइप प्रोग्रामिंग, जावास्क्रिप्ट),
• ऑब्जेक्ट (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग, C ++ / Java),
• तथ्य (तार्किक प्रोग्रामिंग, PROLOG)।

यह ध्यान देने योग्य है कि सामान्य मामले में, प्रोग्रामिंग भाषा विशिष्ट रूप से उपयोग किए जाने वाले प्रतिमान को निर्धारित नहीं करती है: एक ही पीएचपी में, आप अनिवार्य और ऑब्जेक्ट-ओरिएंटेड प्रोग्राम दोनों लिख सकते हैं।

इस लेख में मैं अपेक्षाकृत युवा, लेकिन अत्यंत, मेरी राय में, उपयोगी प्रोग्रामिंग प्रतिमान - पहलू-उन्मुख प्रोग्रामिंग के बारे में बात करना चाहता हूं।

एओपी मूल बातें

वैक्यूम में कुछ गोलाकार सेवा पर विचार करें (उदाहरण के लिए, एक वेब सेवा) जो निम्नलिखित विधि को लागू करती है:

public BookDTO getBook(Integer bookId) {
BookDTO book = bookDAO.readBook(bookId);
return book;
}

यह विधि काफी सरल और स्पष्ट है: किसी पुस्तक की जानकारी को उसके पहचानकर्ता द्वारा पढ़ना। लेकिन आइए सोचते हैं, यहां क्या कमी है? सबसे पहले, हमें लॉगिंग के बारे में सोचना चाहिए - इसके बिना, जैसा कि आप स्वयं समझते हैं, एक वेब सेवा में आप कहीं भी नहीं जा सकते हैं:

public BookDTO getBook(Integer bookId) {
LOG.debug( "Call method getBook with id " + bookId);

BookDTO book = bookDAO.readBook(bookId);

LOG.debug( "Book info is: " + book.toString());
return book;
}

इसके बाद, आपको अपवाद हैंडलिंग को लागू करने की आवश्यकता है (अंतर्निहित परतों के अपवाद को छिपाते हुए, सेवा परत को संबंधित अपवाद वापस करने के लिए):

public BookDTO getBook(Integer bookId) throws ServiceException {
LOG.debug( "Call method getBook with id " + bookId);
BookDTO book = null ;

try {
book = bookDAO.readBook(bookId);
} catch(SQLException e) {
throw new ServiceException(e);
}

LOG.debug( "Book info is: " + book.toString());
return book;
}

इसके अलावा, एक्सेस अधिकारों की जाँच करना न भूलें:

public BookDTO getBook(Integer bookId) throws ServiceException, AuthException {
if (!SecurityContext.getUser().hasRight("GetBook"))
throw new AuthException("Permission Denied");

LOG.debug( "Call method getBook with id " + bookId);
BookDTO book = null ;

try {
book = bookDAO.readBook(bookId);
} catch (SQLException e) {
throw new ServiceException(e);
}

LOG.debug( "Book info is: " + book.toString());
return book;
}

इसके अलावा, यह काम के परिणाम को कैश करने के लिए समझ में आता है:

public BookDTO getBook(Integer bookId) throws ServiceException, AuthException {
if (!SecurityContext.getUser().hasRight( "GetBook" ))
throw new AuthException( "Permission Denied" );

LOG.debug( "Call method getBook with id " + bookId);
BookDTO book = null ;
String cacheKey = "getBook:" + bookId;

try {
if (cache.contains(cacheKey)) {
book = (BookDTO) cache.get(cacheKey);
} else {
book = bookDAO.readBook(bookId);
cache.put(cacheKey, book);
}
} catch (SQLException e) {
throw new ServiceException(e);
}

LOG.debug( "Book info is: " + book.toString());
return book;
}

आप इस पद्धति को सुधारना जारी रख सकते हैं, लेकिन एक शुरुआत के लिए - पर्याप्त है। हमारे सुधार के दौरान, हमें मूल आकार से 10 गुना (2 से 20 LOC तक) एक विधि प्राप्त हुई। सबसे दिलचस्प बात यह है कि इसमें व्यापारिक तर्क का आयतन नहीं बदला है - यह अभी भी वही 1 पंक्ति है। कोड के बाकी आवेदन की कुछ सामान्य उपयोगिता कार्यक्षमता को लागू करता है: लॉगिंग, त्रुटि से निपटने, अभिगम नियंत्रण, कैशिंग, और इसी तरह।

सिद्धांत रूप में, सेवा की कार्यक्षमता के साथ व्यापार तर्क को इंटरलाकिंग करना इतना डरावना नहीं है जब तक कि आपका आवेदन छोटा न हो। हालांकि, कार्यक्रम जितना जटिल होता है, उतनी ही सावधानी से आपको इसकी वास्तुकला को सामान्य रूप से देखना चाहिए और विशेष रूप से समग्र कार्यक्षमता को उजागर करना चाहिए। इसीलिए, प्रोग्रामिंग भाषाओं के विकास का अवलोकन करते हुए, पहले हम फ़ंक्शन, फिर मॉड्यूल, फिर ऑब्जेक्ट्स की उपस्थिति देखते हैं। हालांकि, अभ्यास से पता चलता है कि कुछ सामान्य कार्यक्षमता को उजागर करने के लिए, उपरोक्त प्रतिमान पर्याप्त नहीं हैं। इस तरह की कार्यक्षमता को "पास-थ्रू" या "बिखरा हुआ" कहा जाता है, क्योंकि इसके कार्यान्वयन वास्तव में आवेदन के विभिन्न हिस्सों में बिखरे हुए हैं। क्रॉस-कटिंग कार्यक्षमता के उदाहरण, जैसा कि हमने ऊपर देखा, वे हैं:

• प्रवेश,
• लेनदेन प्रसंस्करण
• त्रुटि से निपटने
• प्राधिकरण और अधिकारों का सत्यापन,
• कैशिंग
• अनुबंध प्रोग्रामिंग के तत्व।

पहलू-उन्मुख प्रोग्रामिंग (एओपी) का मुख्य उद्देश्य अंत-टू-एंड कार्यक्षमता का संशोधन है, इसका आवंटन पहलुओं में है । ऐसा करने के लिए, AOP की अवधारणा का समर्थन करने वाली भाषाएं एंड-टू-एंड कार्यक्षमता को उजागर करने के लिए निम्नलिखित टूल को लागू करती हैं:

• पहलू - एक मॉड्यूल या वर्ग जो अंत-टू-एंड कार्यक्षमता को लागू करता है। एक पहलू कुछ स्लाइस द्वारा परिभाषित जॉइन पॉइंट्स पर सलाह देकर बाकी कोड के व्यवहार को बदल देता है। कार्यक्षमता को लागू करने के लिए एक पहलू का भी उपयोग किया जा सकता है;
• सलाह - अतिरिक्त तर्क - कोड जिसे कनेक्शन बिंदु से बुलाया जाना चाहिए। टिप को पहले, बाद में या एक सम्मिलित बिंदु के बजाय प्रदर्शन किया जा सकता है;
• जॉइन पॉइंट (ज्वाइन पॉइंट) - प्रोग्राम का एक पॉइंट जिसे निष्पादित किया जा रहा है (मेथड कॉल, ऑब्जेक्ट क्रिएशन, वैरिएबल एक्सेस), जहाँ सलाह लागू की जानी चाहिए;
• स्लाइस (पॉइंटकट) - कनेक्शन बिंदुओं का एक सेट। एक स्लाइस निर्धारित करता है कि क्या दिए गए कनेक्शन बिंदु किसी दिए गए टिप पर फिट बैठता है;
• परिचय - वर्ग संरचना और / या विदेशी कोड में पहलू कार्यक्षमता जोड़ने के लिए वंशानुक्रम पदानुक्रम में परिवर्तन;
• लक्ष्य - जिस पर युक्तियाँ लागू की जाएंगी;
• बुनाई - प्रासंगिक पहलुओं के साथ वस्तुओं को जोड़ना (संभवतः संकलन, लोडिंग या प्रोग्राम निष्पादन के चरण में)।

केस स्टडी (AspectJ)

पहलू भाषा जावा भाषा के लिए एक पहलू उन्मुख विस्तार / रूपरेखा है। फिलहाल, यह शायद सबसे लोकप्रिय और विकासशील एओपी इंजन है।

इसकी मदद से लॉगिंग के पहलू के कार्यान्वयन पर विचार करें:

@Aspect
public class WebServiceLogger {
private final static Logger LOG =
Logger.getLogger(WebServiceLogger. class );

@Pointcut( "execution(* example.WebService.*(..))" )
public void webServiceMethod() { }

@Pointcut( "@annotation(example.Loggable)" )
public void loggableMethod() { }

@Around( "webServiceMethod() && loggableMethod()" )
public Object logWebServiceCall(ProceedingJoinPoint thisJoinPoint) {
String methodName = thisJoinPoint.getSignature().getName();
Object[] methodArgs = thisJoinPoint.getArgs();

LOG.debug( "Call method " + methodName + " with args " + methodArgs);

Object result = thisJoinPoint.proceed();

LOG.debug( "Method " + methodName + " returns " + result);

return result;
}
}

पहला कदम सेवा विधियों के लॉगिंग का एक पहलू बनाना है - वेबसर्वर लोजर वर्ग, जो कि ऐस्पेक्ट अनाउंसमेंट के साथ चिह्नित है। अगला, जंक्शन बिंदुओं के दो स्लाइस को परिभाषित किया गया है: webServiceMethod (WebService वर्ग से संबंधित विधि के लिए कॉल) और loggableMethod (@Loggable एनोटेशन के साथ चिह्नित विधि के लिए कॉल)। अंत में, एक टिप घोषित की जाती है (logWebServiceCall पद्धति), जिसे ( लगभग एनोटेशन) कनेक्शन बिंदुओं के बजाय निष्पादित किया जाता है जो स्लाइस को संतुष्ट करता है ("webServiceMethod () && loggableMethod ()"))।

परिषद कोड में, वर्तमान विधि (कनेक्शन बिंदु), विधि की शुरुआत के लॉगिंग, अनुरोधित विधि के सीधे कॉलिंग, लॉगिंग और काम के परिणाम को वापस करने के बारे में जानकारी प्राप्त की जाती है।

AspectJ में कनेक्शन बिंदुओं के समर्थित स्लाइस की काफी बड़ी मात्रा है। निम्नलिखित मुख्य हैं:

• निष्पादन (स्थिर * com.xyz .. *। * (..)) - com.xyz पैकेज में किसी भी स्थिर विधि के कोड का निष्पादन;
• कॉल (शून्य MyInterface। * (..)) - किसी भी विधि के लिए कॉल जो MyInterface इंटरफ़ेस से शून्य देता है;
• initialization (MyClass || MyOtherClass) - MyClass या MyOtherClass वर्ग का आरंभीकरण;
• स्थैतिककरण (MyClass + &&! MyClass) - एक वर्ग का स्थैतिक आरंभीकरण जिसका नाम MyClass से शुरू होता है, लेकिन MyClass से नहीं;
• हैंडलर (ArrayOutOfBoundsException) - अपवाद हैंडलर का निष्पादन ArrayOutOfBoundsException;
• get / set (स्थिर int MyClass.x) - वर्ग MyClass की संपत्ति x पढ़ें / लिखें;
• यह / लक्ष्य (MyClass) - प्रकार MyClass के ऑब्जेक्ट के अनुरूप कनेक्शन बिंदु का निष्पादन;
• args (Integer) - एक कनेक्शन बिंदु का निष्पादन जिस पर Integer प्रकार का एक तर्क उपलब्ध है;
• अगर (thisJoinPoint.getKind ()। बराबर ("कॉल")) - सभी कनेक्शन बिंदुओं से मेल खाता है जिस पर दी गई अभिव्यक्ति सत्य है;
• भीतर / भीतर (MyClass) - किसी दिए गए वर्ग के कोड में पाए गए सभी कनेक्शन बिंदुओं से मेल खाता है;
• cflow / cflowbelow (कॉल (शून्य MyClass.test ())) - निर्दिष्ट स्लाइस के निष्पादन थ्रेड में सामना किए गए सभी कनेक्शन बिंदुओं से मेल खाता है;
• @annotation (MyAnnotation) - एक जॉइन्ट पॉइंट को एक्सेक्यूट करें जिसका टारगेट @MyAnnotation annation से चिह्नित है।

युक्तियों के लिए, उनकी संख्या बहुत छोटी है, लेकिन वे पूरी तरह से सभी आवश्यक कई स्थितियों को कवर करते हैं:

• इससे पहले - ज्वाइन पॉइंट को निष्पादित करने से पहले बोर्ड शुरू करें,
• लौटने के बाद - कनेक्शन बिंदु के सामान्य निष्पादन के बाद बोर्ड शुरू करें,
• फेंकने के बाद - ज्वाइन पॉइंट के निष्पादन के दौरान एक अपवाद को फेंकने के बाद सलाह शुरू करें,
• के बाद - कनेक्शन बिंदु के किसी भी निष्पादन के बाद बोर्ड को लॉन्च करें,
• लगभग - एक सम्मिलित बिंदु को निष्पादित करने के बजाय एक परिषद शुरू करना (एक सम्मिलित बिंदु का निष्पादन परिषद के अंदर बुलाया जा सकता है)

आप आधिकारिक दस्तावेज के संबंधित अनुभाग [ 1 , 2 ] में AspectJ डिजाइनों के बारे में अधिक पढ़ सकते हैं।

AspectJ पहलुओं का उपयोग करने के लिए, उन्हें एक विशेष AJC संकलक का उपयोग करके मुख्य वर्गों में संकलित और सिलना होगा ।

उत्पाद मुफ्त है। ग्रहण लाइसेंस के तहत वितरित किया गया।

केस स्टडी (पोस्टशेयर)

PostSharp .NET प्लेटफॉर्म के लिए एक पहलू-उन्मुख रूपरेखा है। .NET के लिए अन्य AOP कार्यान्वयन हैं, हालाँकि, PostSharp साइट से तुलना करके, यह वह है जो प्रमुख स्थान रखता है।

अपवाद हैंडलिंग के पहलू का वर्णन करने के लिए इसका उपयोग करने पर विचार करें। पहला कदम एक ऐसा वर्ग बनाना है जो प्रासंगिक पहलू का विस्तार करता है:

public class ExceptionDialogAttribute : OnExceptionAspect
{
public override void OnException(MethodExecutionEventArgs eventArgs)
{
string message = eventArgs.Exception.Message;
Window window = Window.GetWindow((DependencyObject)eventArgs.Instance);
MessageBox.Show(window, message, "Exception" );
eventArgs.FlowBehavior = FlowBehavior.Continue;
}
}

स्पष्ट रूप से, पोस्टशार्प शब्दावली में पहलू हैं, जैसा कि हम देख सकते हैं, एओपी शब्दावली में एक पहलू और सलाह।

इस पहलू के लिए चौराहे के बिंदुओं का एक टुकड़ा निर्दिष्ट करने के लिए, विधानसभा सेटिंग फ़ाइल में निम्नलिखित पंक्ति जोड़ें (AssemblyInfo.cs):

[assembly: ExceptionDialog ( AttributeTargetTypes= "Example.WorkflowService.*" ,
AttributeTargetMemberAttributes = AttributeTargetElements.Public )]

या, ExceptionDialog विशेषता के साथ स्पष्ट रूप से आपकी रुचि के तरीकों को चिह्नित करें:

[ExceptionDialog]
public BookDTO GetBook(Integer bookId)

यह सब है: अब संबंधित विधियों में फेंके गए सभी अपवादों को बनाए गए पहलू द्वारा नियंत्रित किया जाएगा।

इस तथ्य के कारण कि PostSharp आंशिक रूप से सलाह और पहलू की अवधारणाओं को चित्रित करता है, बाद वाले के पास काफी कम है। विवरण प्रलेखन में पाया जा सकता है। निम्नलिखित मुख्य हैं:

• OnMethodBoundary / OnMethodInvocation - विधि को कॉल करें (प्रारंभ, अंत, निकास, अपवाद के साथ बाहर निकलें);
• OnFieldAccess - संपत्ति तक पहुंच;
• OnException - अपवाद हैंडलिंग;
• रचना - कोड इंजेक्शन;

काम करने के लिए, PostSharp को एक कंपाइलर और एक लाइब्रेरी की आवश्यकता होती है, जिसे प्रोजेक्ट से जोड़ा जाना चाहिए। सिलाई के निर्माण के बाद के निर्माण पर आधारित प्रसंस्करण बायोटेक पर आधारित है।

उत्पाद का भुगतान किया जाता है। एक सामुदायिक संस्करण है।

सिद्धांत से अभ्यास तक

और इसलिए, हमने देखा कि आपके आवेदन में एंड-टू-एंड कार्यक्षमता के "ब्रैकेट्स को बाहर रखने" की समस्या को कितनी खूबसूरती से और प्रभावी ढंग से हल किया जा सकता है। हालांकि, यह सब एक सिद्धांत है। अभ्यास में, ज़ाहिर है, सब कुछ थोड़ा अलग है :)

सबसे पहले, दोनों मामलों में, संकलन के लिए और पहलुओं की "बुनाई" के लिए, आपको एक विशेष संकलक का उपयोग करना होगा और परियोजना के साथ अतिरिक्त पुस्तकालयों को खींचना होगा। ऐसा लगता है कि यह कोई समस्या नहीं है: कंपाइलर को आसानी से पर्यावरण में डाउनलोड और एकीकृत किया जा सकता है (उदाहरण के लिए, मावेन का उपयोग करते समय, पहलू-मावेन-प्लग-इन प्लग को जोड़ने के लिए कार्य कम हो जाएगा), और बहुत सारी निर्भरता एक सामान्य बात है, कम से कम जावा अनुप्रयोगों के लिए। (एक ही मावेन का उपयोग करके हल किया गया)। हालांकि, परियोजना में कुछ ऐसा शामिल करने की आवश्यकता है जिसके लिए एक अलग संकलन की आवश्यकता होती है, और यहां तक ​​कि व्यापक वितरण भी नहीं होता है, अक्सर सभी संभावित लाभों के बावजूद, डेवलपर्स को डराता है।

इस स्थिति में, स्प्रिंग फ्रेमवर्क [ 1 , 2 ] समस्या का समाधान बन सकता है। इस ढांचे के कई फायदे हैं, लेकिन इस लेख के ढांचे के भीतर हम इसके एओपी घटक में रुचि रखते हैं। स्प्रिंग फ्रेमवर्क प्रॉक्सी पार्टी (JDK डायनेमिक प्रॉक्सी, CGLIB) बनाकर तीसरे पक्ष के पुस्तकालयों का उपयोग किए बिना शुद्ध जावा (C #) में AOP कार्यक्षमता को सीमित करता है। दूसरे शब्दों में, स्प्रिंग एओपी में, आप केवल "विधि निष्पादन" प्रकार के सम्मिलित बिंदुओं का उपयोग कर सकते हैं। हालांकि, जैसा कि अभ्यास से पता चलता है, यह प्रतिबंध महत्वपूर्ण भूमिका नहीं निभाता है, क्योंकि अधिकांश समस्याओं को हल करने के लिए, इस प्रकार के कनेक्शन बिंदुओं की आवश्यकता होती है।

इसके अलावा, स्प्रिंग फ्रेमवर्क @AspectJ एनोटेशन का उपयोग करते हुए अनुप्रयोगों के कॉन्फ़िगरेशन का समर्थन करता है, साथ ही पहलुओं का एकीकरण सीधे एस्पेक्टज का उपयोग करके संकलित करता है।

हमारी कंपनी में हम स्प्रिंग AOP का उपयोग करते हैं। स्प्रिंग फ्रेमवर्क की अन्य योग्यता को ध्यान में रखते हुए, मेरी राय में, यह AOP के साथ काम करने के लिए सबसे लोकप्रिय और सुविधाजनक मंच है, जो इसके लोकप्रियकरण और विकास में महत्वपूर्ण योगदान देता है।

सारांश

संक्षेप में, मैं AOP के बारे में तीन मुख्य विचारों को उजागर करना चाहता हूं:

• AOP का मुख्य लक्ष्य "कोष्ठक" (एंड-टू-एंड) कार्यक्षमता "कोष्ठक से बाहर" (अंत-टू-एंड कार्यक्षमता का संशोधन) को हटाना है;
• जावा के लिए, AOP AspectJ परियोजना के माध्यम से उपलब्ध है। .NET के लिए PostSharp के माध्यम से;
• एओपी का सबसे सरल और सबसे सिद्ध कार्यान्वयन स्प्रिंग एओपी है।

संबंधित लिंक

• विकिपीडिया: प्रोग्रामिंग प्रतिमान
• विकिपीडिया: पहलू ओरिएंटेड प्रोग्रामिंग
• AspectJ वेबसाइट
• PostSharp वेबसाइट
• स्प्रिंग एओपी प्रलेखन
• AOP @ कार्य: AOP मिथकों और वास्तविकता