Chủ đề này không dễ dàng và hiếm khi được sử dụng trực tiếp, nhưng nhiều khuôn khổ và công nghệ sử dụng nó một cách bí mật. Và tất nhiên, đôi khi trong các cuộc phỏng vấn, bạn có thể được yêu cầu mô tả một cách chung chung đây là loại quái vật gì và nó có thể được áp dụng ở đâu. Vì vậy, chúng ta hãy xem các khái niệm cơ bản và một số ví dụ đơn giản về AOP trong Java . Bây giờ, AOP là viết tắt của lập trình hướng theo khía cạnh, là một mô hình nhằm tăng tính mô đun của các phần khác nhau của ứng dụng bằng cách tách biệt các mối quan tâm xuyên suốt. Để thực hiện điều này, hành vi bổ sung được thêm vào mã hiện có mà không thực hiện thay đổi đối với mã gốc. Nói cách khác, chúng ta có thể coi nó như là treo chức năng bổ sung lên trên các phương thức và lớp mà không thay đổi mã đã sửa đổi. Tại sao điều này là cần thiết? Sớm muộn gì chúng ta cũng kết luận rằng cách tiếp cận hướng đối tượng điển hình không phải lúc nào cũng có thể giải quyết hiệu quả một số vấn đề nhất định. Và khi thời điểm đó đến, AOP sẽ giải cứu và cung cấp cho chúng tôi các công cụ bổ sung để xây dựng ứng dụng. Và các công cụ bổ sung có nghĩa là tăng tính linh hoạt trong phát triển phần mềm, có nghĩa là có nhiều tùy chọn hơn để giải quyết một vấn đề cụ thể.
Áp dụng AOP
Lập trình hướng khía cạnh được thiết kế để thực hiện các nhiệm vụ xuyên suốt, có thể là bất kỳ mã nào có thể được lặp lại nhiều lần bằng các phương pháp khác nhau, không thể cấu trúc hoàn chỉnh thành một mô-đun riêng biệt. Theo đó, AOP cho phép chúng tôi giữ phần này bên ngoài mã chính và khai báo theo chiều dọc. Một ví dụ là sử dụng chính sách bảo mật trong một ứng dụng. Thông thường, bảo mật chạy qua nhiều yếu tố của một ứng dụng. Hơn nữa, chính sách bảo mật của ứng dụng nên được áp dụng như nhau cho tất cả các phần hiện có và mới của ứng dụng. Đồng thời, chính sách bảo mật đang sử dụng có thể tự phát triển. Đây là nơi hoàn hảo để sử dụng AOP . Ngoài ra, một ví dụ khác là đăng nhập. Có một số lợi thế khi sử dụng phương pháp AOP để ghi nhật ký thay vì thêm chức năng ghi nhật ký theo cách thủ công:-
Mã để ghi nhật ký dễ dàng thêm và xóa: tất cả những gì bạn cần làm là thêm hoặc xóa một vài cấu hình của một số khía cạnh.
-
Tất cả mã nguồn để ghi nhật ký được giữ ở một nơi, vì vậy bạn không cần phải tìm kiếm thủ công tất cả những nơi mã nguồn được sử dụng.
-
Mã ghi nhật ký có thể được thêm vào bất cứ đâu, cho dù trong các phương thức và lớp đã được viết hay trong chức năng mới. Điều này làm giảm số lỗi mã hóa.
Ngoài ra, khi xóa một khía cạnh khỏi cấu hình thiết kế, bạn có thể chắc chắn rằng tất cả mã theo dõi đã biến mất và không có gì bị bỏ sót.
- Các khía cạnh là mã riêng biệt có thể được cải thiện và sử dụng lại nhiều lần.
AOP cũng được sử dụng để xử lý ngoại lệ, lưu vào bộ nhớ đệm và trích xuất chức năng nhất định để có thể sử dụng lại.
Nguyên tắc cơ bản của AOP
Để tiến xa hơn trong chủ đề này, trước tiên chúng ta hãy tìm hiểu các khái niệm chính của AOP. Lời khuyên — Logic hoặc mã bổ sung được gọi từ một điểm nối. Lời khuyên có thể được thực hiện trước, sau hoặc thay vì điểm tham gia (thêm về chúng bên dưới). Các loại lời khuyên có thể :-
Before — loại lời khuyên này được khởi chạy trước khi các phương thức đích, tức là các điểm tham gia, được thực thi. Khi sử dụng các khía cạnh làm lớp, chúng tôi sử dụng chú thích @B Before để đánh dấu lời khuyên là đến trước. Khi sử dụng các khía cạnh dưới dạng tệp .aj , đây sẽ là phương thức before() .
- Sau — lời khuyên được thực thi sau khi hoàn tất việc thực hiện các phương thức (điểm nối), cả trong quá trình thực thi bình thường cũng như khi đưa ra một ngoại lệ.
Khi sử dụng các khía cạnh làm lớp, chúng ta có thể sử dụng chú thích @after để chỉ ra rằng đây là lời khuyên xuất hiện sau đó.
Khi sử dụng các khía cạnh dưới dạng tệp .aj , đây là phương thức after() .
-
Sau khi quay lại - lời khuyên này chỉ được thực hiện khi phương thức đích kết thúc bình thường, không có lỗi.
Khi các khía cạnh được biểu diễn dưới dạng các lớp, chúng ta có thể sử dụng chú thích @AfterReturning để đánh dấu lời khuyên là đang thực thi sau khi hoàn thành thành công.
Khi sử dụng các khía cạnh dưới dạng tệp .aj , đây sẽ là phương thức after() trả về (Object obj) .
-
Sau khi Ném — lời khuyên này dành cho các trường hợp khi một phương thức, nghĩa là, điểm nối, đưa ra một ngoại lệ. Chúng tôi có thể sử dụng lời khuyên này để xử lý một số loại thực thi không thành công (ví dụ: khôi phục toàn bộ giao dịch hoặc ghi nhật ký với mức theo dõi được yêu cầu).
Đối với các khía cạnh của lớp, chú thích @afterThrowing được sử dụng để chỉ ra rằng lời khuyên này được sử dụng sau khi đưa ra một ngoại lệ.
Khi sử dụng các khía cạnh dưới dạng tệp .aj , đây sẽ là phương thức ném after() (Ngoại lệ e) .
-
Xung quanh — có lẽ là một trong những loại lời khuyên quan trọng nhất. Nó bao quanh một phương thức, nghĩa là, một điểm nối mà chúng ta có thể sử dụng, ví dụ, chọn có thực hiện hay không thực hiện một phương thức điểm nối đã cho.
Bạn có thể viết mã tư vấn chạy trước và sau khi phương pháp điểm nối được thực thi.
Lời khuyên xung quanh chịu trách nhiệm gọi phương thức điểm nối và các giá trị trả về nếu phương thức trả về một cái gì đó. Nói cách khác, trong lời khuyên này, bạn có thể chỉ cần mô phỏng hoạt động của một phương thức đích mà không cần gọi nó và trả về bất kỳ thứ gì bạn muốn làm kết quả trả về.
Các khía cạnh được cung cấp dưới dạng các lớp, chúng tôi sử dụng chú thích @Around để tạo lời khuyên bao bọc một điểm nối. Khi sử dụng các khía cạnh ở dạng tệp .aj , phương thức này sẽ là phương thức around() .
-
Kết hợp thời gian biên dịch — nếu bạn có mã nguồn của khía cạnh và mã mà bạn sử dụng khía cạnh đó, thì bạn có thể biên dịch trực tiếp mã nguồn và khía cạnh đó bằng cách sử dụng trình biên dịch AspectJ;
-
Dệt sau biên dịch (dệt nhị phân) — nếu bạn không thể hoặc không muốn sử dụng các biến đổi mã nguồn để dệt các khía cạnh vào mã, bạn có thể lấy các lớp hoặc tệp jar đã biên dịch trước đó và đưa các khía cạnh vào chúng;
-
Dệt thời gian tải - đây chỉ là dệt nhị phân bị trì hoãn cho đến khi trình nạp lớp tải tệp lớp và xác định lớp cho JVM.
Cần có một hoặc nhiều bộ tải lớp dệt để hỗ trợ điều này. Chúng hoặc được cung cấp rõ ràng bởi thời gian chạy hoặc được kích hoạt bởi một "tác nhân dệt".
Ví dụ trong Java
Tiếp theo, để hiểu rõ hơn về AOP , chúng ta sẽ xem xét các ví dụ nhỏ kiểu "Xin chào thế giới". Ngay lập tức, tôi sẽ lưu ý rằng các ví dụ của chúng tôi sẽ sử dụng dệt thời gian biên dịch . Trước tiên, chúng ta cần thêm phần phụ thuộc sau vào tệp pom.xml của mình :<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.9.5</version>
</dependency><build>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>aspectj-maven-plugin</artifactId>
<version>1.7</version>
<configuration>
<complianceLevel>1.8</complianceLevel>
<source>1.8</source>
<target>1.8</target>
<showWeaveInfo>true</showWeaveInfo>
<<verbose>true<verbose>
<Xlint>ignore</Xlint>
<encoding>UTF-8</encoding>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>test-compile</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>Ví dụ số 1
Hãy tạo một lớp Main . Trong đó, chúng ta sẽ có một điểm vào và một phương thức in tên đã truyền trên bàn điều khiển:public class Main {
public static void main(String[] args) {
printName("Tanner");
printName("Victor");
printName("Sasha");
}
public static void printName(String name) {
System.out.println(name);
}
}public aspect GreetingAspect {
pointcut greeting() : execution(* Main.printName(..));
before() : greeting() {
System.out.print("Hi, ");
}
}@Aspect
public class GreetingAspect{
@Pointcut("execution(* Main.printName(String))")
public void greeting() {
}
@Before("greeting()")
public void beforeAdvice() {
System.out.print("Hi, ");
}
}- @Aspect chỉ ra rằng lớp này là một khía cạnh;
- @Pointcut("execution(* Main.printName(String))") là điểm cắt được kích hoạt cho tất cả các lệnh gọi tới Main.printName với đối số đầu vào có loại là String ;
- @B Before("greeting()") là lời khuyên được áp dụng trước khi gọi mã được chỉ định trong điểm dừng hello() .
Ví dụ số 2
Giả sử chúng ta có một số phương thức thực hiện một số thao tác cho khách hàng và chúng ta gọi phương thức này từ main :public class Main {
public static void main(String[] args) {
performSomeOperation("Tanner");
}
public static void performSomeOperation(String clientName) {
System.out.println("Performing some operations for Client " + clientName);
}
}@Aspect
public class TransactionAspect{
@Pointcut("execution(* Main.performSomeOperation(String))")
public void executeOperation() {
}
@Around(value = "executeOperation()")
public void beforeAdvice(ProceedingJoinPoint joinPoint) {
System.out.println("Opening a transaction...");
try {
joinPoint.proceed();
System.out.println("Closing a transaction...");
}
catch (Throwable throwable) {
System.out.println("The operation failed. Rolling back the transaction...");
}
}
}public static void performSomeOperation(String clientName) throws Exception {
System.out.println("Performing some operations for Client " + clientName);
throw new Exception();
}Ví dụ số 3
Trong ví dụ tiếp theo của chúng tôi, hãy làm điều gì đó như đăng nhập vào bảng điều khiển. Trước tiên, hãy xem Main , nơi chúng tôi đã thêm một số logic nghiệp vụ giả:
public class Main {
private String value;
public static void main(String[] args) throws Exception {
Main main = new Main();
main.setValue("<some value>");
String valueForCheck = main.getValue();
main.checkValue(valueForCheck);
}
public void setValue(String value) {
this.value = value;
}
public String getValue() {
return this.value;
}
public void checkValue(String value) throws Exception {
if (value.length() > 10) {
throw new Exception();
}
}
}@Aspect
public class LogAspect {
@Pointcut("execution(* *(..))")
public void methodExecuting() {
}
@AfterReturning(value = "methodExecuting()", returning = "returningValue")
public void recordSuccessfulExecution(JoinPoint joinPoint, Object returningValue) {
if (returningValue != null) {
System.out.printf("Successful execution: method — %s method, class — %s class, return value — %s\n",
joinPoint.getSignature().getName(),
joinPoint.getSourceLocation().getWithinType().getName(),
returningValue);
}
else {
System.out.printf("Successful execution: method — %s, class — %s\n",
joinPoint.getSignature().getName(),
joinPoint.getSourceLocation().getWithinType().getName());
}
}
@AfterThrowing(value = "methodExecuting()", throwing = "exception")
public void recordFailedExecution(JoinPoint joinPoint, Exception exception) {
System.out.printf("Exception thrown: method — %s, class — %s, exception — %s\n",
joinPoint.getSignature().getName(),
joinPoint.getSourceLocation().getWithinType().getName(),
exception);
}
}- Khi phương thức có giá trị trả về — if (returningValue! = Null) {
- Khi không có giá trị trả về — other {
Bạn có thể đọc về các ngoại lệ và xử lý ngoại lệ trong các bài viết này: Ngoại lệ trong Java và Ngoại lệ: nắm bắt và xử lý . Đó là tất cả cho tôi ngày hôm nay. Hôm nay chúng ta đã làm quen với AOP , và bạn có thể thấy rằng con quái vật này không đáng sợ như một số người nghĩ. Tạm biệt tất cả mọi người!