Aspect-oriented Programming with Spring In this chapter, we will discuss the problems with using the object-oriented programming (OOP) methodology in developing enterprise applications, and how to solve these problems using aspect-oriented programming (AOP). You will learn the different terminology in AOP. Then, we will take a look at AOP support in Spring. We will look at defining and creating pointcuts. We will also discuss advice and their declarations using XML and annotation. We will learn about proxies and be introduced to AspectJ. The list of topics covered in this chapter is as follows: • Problems with OOP in developing applications • Introduction to AOP • AOP terminology • AOP support in Spring • XML schema-based configuration [ 1 ] Aspect-oriented Programming with Spring The problem with OOP in developing applications Before we look into OOP, remember that, in the C programming language, we use procedural language. In C, we break down complex programs into few procedures. Each procedure specifies the step the program must take, in order to reach a desired state. The main procedure in the C programming language relates all other procedures as black box and calls other procedures without having information about how they are implemented. Main Procedure-B Procedure-A Procedure-C Procedure-D Procedure-E Procedural language The problem with procedural language is that if it consists of a complex design, then we will have a greater number of procedures and dependencies between procedures accordingly. So we opted for a better design to solve the problem using OOP. We encapsulated the data and associated functions inside a class that will form the blueprint. OOP can handle very complex programs. [ 2 ] Chapter 10 object A object B Data Data Function Function ... ... logMessage() OOP logMessage() ... Communication ... other Function other Function object C Data Function ... logMessage() ... other Function Common procedure across different objects in OOP OOP language uses many features present in procedural language. In OOP, we don't think of function when we are trying to solve a problem by writing code; we think of individual entities as objects and we would write objects. Each object has member variable and methods. OOP looks good until now, but here is the problem: not all the tasks that you would want your program to do can be classified as objects. OOP allows us to modularize concerns into distinct packages, classes, and methods. Sometimes, it is difficult to place some concerns within methods or classes as they cross the class' and packages' boundaries. Let's take an example of security, which is a cross-cutting concern. Even though displaying and managing employees on the employee list page is the main purpose of the employee package in the payroll system, it needs to implement security in order to authenticate and authorize users to add and delete employees in the list. Other packages will also need to have the security functionality to protect the Create-Update-Delete functions of employees in the list. [ 3 ] Aspect-oriented Programming with Spring One way to handle this requirement is to create a separate object for it. So we can have a security method to perform authentication and authorization within a new object called UserSecurity object. Then, other objects will not have that method anymore. Whenever a security method needs to be called, it would reference the UserSecurity object. So, in this design, the UserSecurity object will appear as an important object, as every other object that needs security is dependent on this UserSecurity object, which is not really a part of our business problem as it's just performing a support role, rather than a business role. So, the main problem with OOP is that it has too many relationships to crosscutting objects. Crosscutting objects refers to objects that concern other objects in your problem domain. There are two types of concerns we generally have: the first is the primary concern, which is the core code itself, and then there is a secondary concern, for example, the payroll system with its payroll service, employee service, and HR service, is a primary concern. Adding security, transaction management, and logging are all secondary concerns, also called crosscutting concerns. Core concern Security g n uttiern cc Transaction sn so oc r C Logging PayrollService HRService EmployeeService AOP is not just a feature that Spring provides; in fact it's a programming model itself. An aspect refers to a crosscutting concern, such as security, transaction, or logging, which is typically scattered across class hierarchies, and enables the modularization of concerns in the system. The class is the key unit of modularity in OOP, whereas the aspect is the key unit of modularity in AOP. [ 4 ] Chapter 10 Introduction to aspect-oriented programming Aspect-oriented programming (AOP) is a promising technology to separate crosscutting concerns, something that is usually hard to do in OOP. AOP refers to the programming paradigm that isolates supporting functions from the main program's business logic. It is used to provide declarative enterprise services in Spring, especially as a replacement for EJB declarative services. Application objects do what they're supposed to do—perform business logic—and nothing more. They are not responsible for (or even aware of) other system concerns, such as logging, security, auditing, locking, and event handling. AOP is the methodology of applying middleware services such as security services, transaction management services, and so on, to a Spring application. Let us consider a payroll management application (as shown in the following figure) where there will be employee service, HR service, and payroll service, which will perform some functional requirements in the system, such as adding/ updating employee details, removing employees, browsing through employee-wise salary details, and many more functions. Implementing business functionality also requires taking care of non-functional requirements, such as role-based access to UI, maintaining logging details, and so on. AOP leaves the application component to focus on business functionality. Here, the core application implements business functionality and is covered with layers of functionality, such as security, logging, and transaction, provided by AOP: [ 5 ] Aspect-oriented Programming with Spring You can add or remove aspects, as required, without changing any code. You can use the IoC container to configure the Spring aspects. Spring AOP includes advisors that contain advice and pointcuts filtering. Source Code Source Code aspect Weaver Complier ... ... Complier Without AOP With AOP As shown in the preceding diagram, without AOP, we have source code that is given to the compiler and got executable. But with AOP, we now have source code and aspect, which are injected together as return in weaved class, which is given to the compiler which gives us executable. AOP terminology Before we discuss AOP and its usage further, you should learn its terminology. Joinpoint A joinpoint refers to a point in the execution flow of an application, such as class initialization, object instantiation, method invocation, field access, or throwing an exception. Aspect code can be inserted at a joinpoint to add a new behavior into the application. The crosscutting concern is automatically added before/after a joinpoint by AOP. As shown in the following diagram, we have methods within applications where the advice needs to be applied. S is the point before the method execution and E is the point after the method execution. These points are called joinpoints where the advices will be applied: [ 6 ] Chapter 10 Transaction Manager Advisor S Method E S Method E S Method E Joinpoints ADVICE Advisor Logger Advice Advice represents code that is executed at a joinpoint. It includes API invocation to the system-wide concern. As shown in the preceding diagram, we want to log the details of each and every method before it is invoked in the application, so we will choose the joinpoint S that is points before the method. Then, we also want to apply transaction functionality to all the methods before and after method execution. Here, Logger and Transaction Manager are called advisors and the code from advisor that is executed at these joinpoints is called advice. There are different types of advice: • Before advice: Before advice is executed before a joinpoint. Using it, we can execute the advisor code before the method is invoked. • After-returning advice: After-returning advice is used to apply advice after the method successfully finishes its execution. • Throws advice: During execution, when a method throws an exception, throws-advice can be applied. • Around advice: Before and after a method execution, around-advice can be applied. [ 7 ] Aspect-oriented Programming with Spring Pointcut A pointcut represents a collection of joinpoints that specify where an advice is to be applied. For instance, in the preceding diagram, the collection of the joinpoints S and E would be a pointcut. The next step after identifying the joinpoints in the system is to apply the aspect. Instead of applying an aspect for each and every joinpoint, we can use pointcut to apply the aspect. For example, in the payroll system, the executions of all methods in classes that accept employeeId as a parameter can be considered to be pointcuts. Aspect The combination of pointcut and advice is referred to as an aspect, which is a crosscutting functionality that should be included in the application. Introduction An introduction allows you to introduce new methods or attributes to existing classes without having to change them, giving them a new behavior and state. By using an introduction, a specific interface can be implemented to an object, without needing that object's class to implement the interface explicitly. Target A target is either a class you write or a third-party class that is advised to add custom behavior. The target object is referred to as the advice object. Proxy Proxy represents an object that is created after an advice is applied to the target object. [ 8 ] Chapter 10 Weaving Weaving is the process of inserting aspects into the application at the appropriate point. The weaving can take place at different stages in the target class's lifetime: • Compile time: Injecting the byte code of the advice into the joinpoint during the compile time is called compile time weaving. • Classload time: This injects the byte code at the when the class is loaded. During this, the byte code is injected into the loaded class to have the advice code at the joinpoint. • Runtime – Spring way: The target object is shielded with the proxy bean, which is created by the Spring Framework. Whenever the caller calls the method on the target bean, the Spring Framework invokes the proxy and applies advices to the target method. Once the method execution is over, Spring applies advices to the target method again, if required, and the response returns to the caller. Spring uses this kind of weaving. Runtime weaving is an effective method as it keeps code clean: Caller Proxy Target Weaver The weaver is the actual processor that performs the weaving. [ 9 ] Aspect-oriented Programming with Spring AOP implementations AOP is implemented by a variety of frameworks, as explained here: • AspectJ: AspectJ is well known in AOP language; it provides specialized syntax to express concerns. It also provides tools to add a concern into the system and enables crosscutting concern and modularization, such as logging, error checking and handling, and so on. It can be downloaded from http:// www.eclipse.org/aspectj/downloads.php, where we can get the latest version of the jar file. In this book, we have used the latest version of AspectJ, which is 1.8. Double-clicking the downloaded jar file will automatically launch the installation window, where we will need to specify the installation directory by clicking on Next, as shown in the following screenshot: From the C:\aspectj1.8\lib folder, we can find aspectjrt.jar and aspectjweaver.jar, which we can add in the classpath of the project. • JBoss AOP: JBoss provides its own AOP implementation known as JBoss AOP, which is a pure Java implementation. • Spring AOP: Spring provides its own implementation of AOP, which is slightly different from the AspectJ implementation. Let's discuss AOP support in the Spring Framework. [ 10 ]