Spring Framework Basic 13강 AOP 개요 | T아카데미

Summary

This script offers an in-depth exploration of Aspect-Oriented Programming (AOP) in the context of Spring Framework. It delves into AOP's core concepts, such as separating cross-cutting concerns from core business logic, utilizing key terms like advice, pointcut, and join point. The tutorial covers the internal workings of Spring AOP with AspectJ, including the setup process and the distinction between XML and annotation-based configurations. It also touches on the installation of the AspectJ and Spring AOP libraries, providing a foundational understanding for developers looking to implement AOP in their applications.

Takeaways

• 📘 AOP (Aspect-Oriented Programming) is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns, such as logging and security, from the main business logic.
• 🔍 Spring AOP is a framework that implements AOP concepts and is built on the AOP Alliance library, which needs to be included in the project dependencies.
• 🔧 Core and additional functionalities are terms used in AOP, where core functionality refers to the main business logic, and additional functionalities are those that support the core, like logging and security.
• 📌 Aspects in AOP are a combination of advice (the additional functionality) and pointcut (where the advice should be applied), encapsulating the cross-cutting concerns into a modular form.
• 🎯 Advice is the code that defines the additional functionality to be applied to the target, and pointcuts determine where this advice should be applied within the target object.
• 🎯 Join points are points in the execution of the program where additional behavior can be inserted, typically method executions in Spring AOP.
• 🔄 Weaving is the process of applying aspects to the target objects to insert the additional behavior at specific join points without affecting the core functionality.
• 🛡️ Spring AOP uses proxy-based AOP, creating a proxy object around the target object to intercept method calls and apply the advice at runtime.
• 📝 Spring AOP supports two types of advice: before advice (pre-processing) that runs before the target method, and after advice (post-processing) that runs after the target method.
• 🛠️ Spring AOP can be implemented in two ways: using XML configuration with aspectj classes or using annotations to define aspects, pointcuts, and advice.
• 📚 The script includes a practical guide on how to install the AOP Alliance and Spring AOP libraries, as well as how to configure them in a project using Maven.

Q & A

What is the main concept of Aspect-Oriented Programming (AOP) discussed in the script?

The main concept of AOP discussed in the script is the separation of concerns in an application, specifically the separation of core business logic from additional functionalities such as logging and security.

What are the two main types of functionalities in AOP as mentioned in the script?

The two main types of functionalities in AOP are core functionality, which encapsulates the business logic, and additional functionality, which includes auxiliary features like logging and security.

What is the term used to describe the additional functionalities in AOP?

The term used to describe the additional functionalities in AOP is 'advice'.

What is the role of 'advice' in AOP?

In AOP, 'advice' defines the additional functionalities that are applied to the core functionality. It determines what additional behavior is injected into the core functionality at certain join points.

What is a 'join point' in the context of AOP?

A 'join point' in AOP is a specific point in the execution of the program, such as a method call or field access, where additional behavior can be inserted.

What is the term used to define where the advice should be applied in AOP?

The term used to define where the advice should be applied in AOP is 'pointcut'.

What is the combination of advice and pointcut called in AOP?

The combination of advice and pointcut is called an 'aspect' in AOP.

What is the term used to describe the process of inserting additional behavior into the core functionality in AOP?

The term used to describe the process of inserting additional behavior into the core functionality in AOP is 'weaving'.

What is the main feature of Spring AOP as discussed in the script?

The main feature of Spring AOP discussed in the script is that it supports proxy-based AOP and only supports method join points.

What are the two implementation methods of Spring AOP mentioned in the script?

The two implementation methods of Spring AOP mentioned in the script are XML-based configuration using aspectj classes and annotation-based configuration using @AspectJ annotations.

How is the 'aspect' defined in Spring AOP?

In Spring AOP, an 'aspect' is defined by combining advice with a pointcut, which determines where the advice should be applied to the core functionality.