การเขียนโปรแกรมเชิงกว้างคืออะไร?

ฉันเข้าใจการเขียนโปรแกรมเชิงวัตถุและได้เขียนโปรแกรม OO มาเป็นเวลานาน ผู้คนดูเหมือนจะพูดคุยเกี่ยวกับการเขียนโปรแกรมเชิงกว้าง แต่ฉันไม่เคยเรียนรู้ว่ามันคืออะไรหรือใช้งานอย่างไร กระบวนทัศน์พื้นฐานคืออะไร?

คำถามนี้เกี่ยวข้อง แต่ไม่ได้ถาม:

การเขียนโปรแกรมเชิงมุมมองกับการเขียนโปรแกรมเชิงวัตถุ

AOP แก้ไขปัญหาความกังวลข้ามซึ่งเป็นรหัสชนิดใด ๆ ที่ทำซ้ำในวิธีการที่แตกต่างกันและโดยปกติจะไม่สามารถ refactored ในโมดูลของตนเองเช่นการบันทึกหรือการตรวจสอบ ดังนั้นด้วย AOP คุณสามารถปล่อยสิ่งนั้นออกจากรหัสหลักและกำหนดในแนวตั้งดังนี้:

function mainProgram()
{ 
   var x =  foo();
   doSomethingWith(x);
   return x;
}

aspect logging
{ 
    before (mainProgram is called):
    { 
       log.Write("entering mainProgram");
    }

    after (mainProgram is called):
    { 
       log.Write(  "exiting mainProgram with return value of "
                  + mainProgram.returnValue);
    }
 } 

aspect verification
{ 
    before (doSomethingWith is called):
    { 
       if (doSomethingWith.arguments[0] == null) 
       { 
          throw NullArgumentException();
       }

       if (!doSomethingWith.caller.isAuthenticated)
       { 
          throw Securityexception();
       }
    }
 }

จากนั้นผู้ประกอบการด้านใช้ในการรวบรวมรหัสลงในนี้

function mainProgram()
{ 
   log.Write("entering mainProgram");

   var x = foo();   

   if (x == null) throw NullArgumentException();
   if (!mainProgramIsAuthenticated()) throw Securityexception();
   doSomethingWith(x);   

   log.Write("exiting mainProgram with return value of "+ x);
   return x;
} 

น่าเสียดายที่มันยากที่จะทำให้ AOP มีประโยชน์จริง ๆ ในองค์กรขนาดกลางขนาดใหญ่ปกติ (การสนับสนุนบรรณาธิการ, ความรู้สึกควบคุม, ความจริงที่ว่าคุณเริ่มต้นด้วยสิ่งที่ไม่สำคัญจึงนำไปสู่รหัสเน่า, ผู้คนจะกลับบ้านไปกับครอบครัวของพวกเขา ฯลฯ )

ฉันใส่ความหวังในการเขียนโปรแกรมเชิงประกอบซึ่งเป็นสิ่งที่สมจริงมากขึ้น มันเชื่อมต่อกับแนวคิดยอดนิยมมากมายและให้สิ่งที่ยอดเยี่ยมแก่คุณ

ดูการนำไปปฏิบัติที่จะเกิดขึ้นที่นี่: qi4j.org/

PS ที่จริงแล้วฉันคิดว่าหนึ่งในความงามที่มี AOP ก็คือส้นเท้าข้อเท้า: มันไม่ใช่การล่วงล้ำทำให้ผู้คนไม่สนใจมันถ้าพวกเขาทำได้ดังนั้นมันจะได้รับการปฏิบัติเหมือนเป็นเรื่องรองในองค์กรส่วนใหญ่

คัดลอกจากสำเนาที่ซ้ำกันเพื่อความสมบูรณ์ (Einstein):

ตัวอย่างคลาสสิคคือความปลอดภัยและการบันทึก แทนที่จะเขียนโค้ดในแอปพลิเคชันของคุณเพื่อบันทึกการเกิดขึ้นของ x หรือตรวจสอบวัตถุ z สำหรับการควบคุมการเข้าถึงการรักษาความปลอดภัยมีการควบคุมภาษา "นอกแบนด์" ของรหัสปกติซึ่งสามารถฉีดระบบรักษาความปลอดภัยหรือเข้าสู่กิจวัตร วิธีการดังกล่าวถึงแม้ว่ารหัสของคุณจะไม่ให้มัน - มันได้รับการดูแล

ตัวอย่างที่ชัดเจนมากขึ้นคือระบบปฏิบัติการที่ให้การควบคุมการเข้าถึงไฟล์ โปรแกรมซอฟต์แวร์ไม่จำเป็นต้องตรวจสอบข้อ จำกัด ในการเข้าถึงเพราะระบบที่รองรับนั้นใช้งานได้

หากคุณคิดว่าคุณต้องการ AOP ในประสบการณ์ของฉันคุณต้องลงทุนเวลาและความพยายามในการจัดการ meta-data ที่เหมาะสมภายในระบบของคุณโดยให้ความสำคัญกับการออกแบบโครงสร้าง / ระบบที่ดี

คัดลอกมาจาก Spring in Action

AOP มักถูกกำหนดให้เป็นเทคนิคที่ส่งเสริมการแยกข้อกังวลในระบบซอฟต์แวร์ ระบบประกอบด้วยส่วนประกอบหลายส่วนแต่ละชิ้นมีหน้าที่การใช้งานเฉพาะ แต่บ่อยครั้งที่องค์ประกอบเหล่านี้ยังมีความรับผิดชอบเพิ่มเติมนอกเหนือจากหน้าที่หลักของพวกเขา บริการของระบบเช่นการบันทึกการจัดการธุรกรรมและความปลอดภัยมักจะหาทางเข้าไปยังส่วนประกอบที่มีความรับผิดชอบหลักเป็นอย่างอื่น บริการระบบเหล่านี้มักถูกเรียกว่าข้อกังวลต่อกันเนื่องจากมีแนวโน้มที่จะตัดชิ้นส่วนหลายชิ้นในระบบ

คัดลอกมาจากที่ซ้ำกันเพื่อความสมบูรณ์ (Buzzer):

คุณลักษณะคลาสและเมธอดใน. NET เป็นรูปแบบของการเขียนโปรแกรมแบบเชิงกว้าง คุณตกแต่งชั้นเรียน / วิธีการของคุณด้วยคุณสมบัติ เบื้องหลังจะเป็นการเพิ่มโค้ดให้กับคลาส / วิธีการของคุณที่ทำหน้าที่เฉพาะของแอททริบิวต์ ตัวอย่างเช่นการทำเครื่องหมายคลาสที่ทำให้เป็นอนุกรมสามารถทำให้มันเป็นอนุกรมโดยอัตโนมัติสำหรับการจัดเก็บหรือส่งไปยังระบบอื่น แอ็ตทริบิวต์อื่นอาจทำเครื่องหมายคุณสมบัติบางอย่างว่าไม่สามารถทำให้เป็นอนุกรมได้และสิ่งเหล่านี้จะถูกละเว้นโดยอัตโนมัติจากวัตถุที่เป็นอนุกรม การทำให้เป็นอันดับเป็นสิ่งที่นำมาใช้โดยรหัสอื่น ๆ ในระบบและนำไปใช้กับชั้นเรียนของคุณโดยการประยุกต์ใช้คุณลักษณะ "การกำหนดค่า" (การตกแต่ง)

AOP สามารถใช้เพื่อดำเนินการที่ไม่เกี่ยวข้องกับตรรกะทางธุรกิจของแอปของคุณเช่นการบันทึกการแคชเป็นต้นการกระทำเหล่านี้สามารถแยกส่วนของแอพของคุณจากนั้นนำมาใช้ซ้ำตลอดทั้งแอปพลิเคชัน โดยปกติจะมีสองวิธีในการบรรลุเป้าหมายนี้ การฉีดโค้ดโดยอัตโนมัติโดย preprocessor ก่อน / หลังเมธอดหรือการแนบคลาสพร็อกซีที่ขัดขวางการเรียกเมธอดและจากนั้นสามารถเรียกใช้สิ่งต่าง ๆ ก่อน / หลังการเรียกเมธอด

นี่คือตัวอย่างใน. Net มันใช้คลาสพร็อกซีในการสกัดกั้นการโทรวิธีและรันรหัสก่อนหลังหลังจากการโทรวิธี saif

Aspect Oriented Programming (AOP) ใน. NET Core และ C # โดยใช้ AutoFac และ DynamicProxy

มีตัวอย่างของ AOP มันใช้ spring AOP เป็นตัวอย่าง ตัวอย่างนี้เข้าใจได้ง่าย

เฟรมเวิร์ก Spring AOP (การเขียนโปรแกรมเชิง Aspect) ใช้เพื่อแยกส่วนข้อกังวลแบบตัดขวางในแง่มุมต่างๆ พูดง่ายๆคือมันเป็นเพียงตัวดักเพื่อดักจับกระบวนการบางอย่างเช่นเมื่อมีการเรียกใช้เมธอด Spring AOP สามารถขโมยวิธีการดำเนินการและเพิ่มฟังก์ชันการทำงานเพิ่มเติมก่อนหรือหลังการเรียกใช้เมธอด

การอ้างอิง: http://www.mkyong.com/spring/spring-aop-examples-advice/

AOP เป็นวิธีที่จะทำให้แอปพลิเคชันของคุณเป็นโมดูลได้อย่างมีประสิทธิภาพยิ่งขึ้นสำหรับการใช้งานที่ครอบคลุมหลายขอบเขต AOP เป็นอีกวิธีหนึ่งในการสรุปคุณสมบัติเหล่านี้และติดตาม Single Responsiblity ด้วยการย้ายข้อกังวลแบบตัดขวางเหล่านี้ (การบันทึกการจัดการข้อผิดพลาด ฯลฯ ) ออกจากส่วนประกอบหลักของแอปพลิเคชันของคุณ เมื่อใช้อย่างเหมาะสม AOP สามารถนำไปสู่ระดับที่สูงขึ้นของการบำรุงรักษาและการขยายในใบสมัครของคุณเมื่อเวลาผ่านไป