{"id":632,"date":"2020-09-27T05:10:40","date_gmt":"2020-09-27T02:10:40","guid":{"rendered":"https:\/\/aliyargunes.space\/blog\/?p=632"},"modified":"2020-09-27T05:10:40","modified_gmt":"2020-09-27T02:10:40","slug":"aspect-oriented-programming-notes-2-setting-up-aop-dependencies-and-declaring-aspects-advices-pointcuts","status":"publish","type":"post","link":"https:\/\/aliyargunes.com.tr\/blog\/aspect-oriented-programming-notes-2-setting-up-aop-dependencies-and-declaring-aspects-advices-pointcuts\/","title":{"rendered":"Aspect Oriented Programming Notes #2: Setting Up AOP Dependencies and Declaring Aspects, Advices, Pointcuts"},"content":{"rendered":"\n
\"\"<\/a><\/figure><\/div>\n\n\n\n

An aspect<\/strong> is a Java class that modularizes a set of concerns (e.g., logging or transaction management) that cuts across multiple types and objects. Java classes that modularize such concerns are decorated with the @Aspect<\/code> annotation. In AOP terminology, aspects are also complemented by advices<\/strong>, which in themselves have pointcuts<\/strong>. <\/p>

An advice<\/strong> is a simple Java method with one of the advice annotations. AspectJ supports five types of advice annotations: <\/p>

@Before<\/code>, @After<\/code>, @AfterReturning<\/code>, @AfterThrowing,<\/code> and @Around<\/code>. <\/p>

A pointcut<\/strong> is an expression that looks for types and objects on which to apply the aspect\u2019s advices.<\/p>Spring 5 Recipes: A Problem-Solution Approach, Marten Deinum, Daniel Rubio, and Josh Long, APress Springer, 2017<\/cite><\/blockquote>\n\n\n\n

For testing the aspects write a simple calculator interface like this:<\/p>\n\n\n

\npublic interface ArithmeticCalculator {\n\n\tpublic double add(double a, double b);\n\tpublic double sub(double a, double b);\n\tpublic double mul(double a, double b);\n\tpublic double div(double a, double b);\n\n}\n<\/pre><\/div>\n\n\n
Then implementation of this interface:<\/p>\n\n\n\n\n\n\n
\nimport org.springframework.stereotype.Component;\n\n@Component("arithmeticCalculator")\npublic class ArithmeticCalculatorImpl implements ArithmeticCalculator {\n\n\t@Override\n\tpublic double add(double a, double b) {\n\t\tdouble result = a + b;\n\t\tSystem.out.println(a + " + " + b + " = " + result);\n\t\treturn result;\n\t}\n\n\t@Override\n\tpublic double sub(double a, double b) {\n\t\tdouble result = a - b;\n\t\tSystem.out.println(a + " - " +\n\t\t b + " = " + result);\n\t\treturn result;\n\t}\n\n\t@Override\n\tpublic double mul(double a, double b) {\n\t\tdouble result = a * b;\n\t\tSystem.out.println(a + " * " +\n\t\t b + " = " + result);\n\t\treturn result;\n\t}\n\n\t@Override\n\tpublic double div(double a, double b) {\n\t\tif (b == 0) {\n\t\t\tthrow new IllegalArgumentException("Division by zero");\n\t\t\t}\n\t\t\tdouble result = a \/ b;\n\t\t\tSystem.out.println(a + " \/ " + b + " = " + result);\n\t\t\treturn result;\n\t}\n\n}\n<\/pre><\/div>\n\n\n
And a Unit Calculator interface for convert the unit:<\/p>\n\n\n
\npublic interface UnitCalculator {\n\n\tpublic double kilogramToPound(double kilogram);\n\tpublic double kilometerToMile(double kilometer);\n\n}\n<\/pre><\/div>\n\n\n
And implementation of this interface:<\/p>\n\n\n
\nimport org.springframework.stereotype.Component;\n\n@Component("unitCalculator")\npublic class UnitCalculatorImpl implements UnitCalculator {\n\n\t@Override\n\tpublic double kilogramToPound(double kilogram) {\n\t\tdouble pound = kilogram * 2.2;\n\t\tSystem.out.println(kilogram + " kilogram = " + pound + " pound");\n\t\treturn pound;\n\t}\n\n\t@Override\n\tpublic double kilometerToMile(double kilometer) {\n\t\tdouble mile = kilometer * 0.62;\n\t\tSystem.out.println(kilometer + " kilometer = " + mile + " mile");\n\t\treturn mile;\n\t}\n\n}\n<\/pre><\/div>\n\n\n
For testing the aspects you need to have these dependencies:<\/p>\n\n\n
\n<dependency>\n    \t<groupId>org.aspectj<\/groupId>\n    \t<artifactId>aspectjweaver<\/artifactId>\n    \t<optional>true<\/optional>\n<\/dependency>\n\t\t\n<dependency>\n    \t<groupId>org.aspectj<\/groupId>\n    \t<artifactId>aspectjrt<\/artifactId>\n    \t<optional>true<\/optional>\n<\/dependency>\n<\/pre><\/div>\n\n\n
The first we need to do in order to have an aspect is write that aspect:<\/p>\n\n\n
\nimport java.util.Arrays;\n\nimport org.aspectj.lang.JoinPoint;\nimport org.apache.commons.logging.Log;\nimport org.apache.commons.logging.LogFactory;\nimport org.aspectj.lang.annotation.Aspect;\nimport org.aspectj.lang.annotation.Before;\nimport org.springframework.stereotype.Component;\n\n@Aspect\n@Component\npublic class CalculatorLoggingAspect {\n\t\n\tprivate Log log = LogFactory.getLog(this.getClass());\n\t\n\t@Before("execution(* ArithmeticCalculator.add(..))")\n\tpublic void logBefore() {\n\t\tlog.info("The method add() begins.");\n\t}\n\n}\n<\/pre><\/div>\n\n\n
This pointcut expression:<\/p>\n\n\n
\n"execution(* ArithmeticCalculator.add(..))"\n<\/pre><\/div>\n\n\n
matches the add()<\/code> method execution of the ArithmeticCalculator<\/code> interface. The preceding wildcard in this expression matches any modifier (public, protected, and private) and any return type. The two dots in the argument list match any number of arguments.<\/p>\n\n\n\n
\"\"<\/a><\/figure><\/div>\n\n\n\n
Next, create a Spring configuration to scan all POJOs, including the POJO calculator implementation and aspect and including the @EnableAspectJAutoProxy<\/code> annotation. To enable annotation support in the Spring IoC container, you have to add @EnableAspectJAutoProxy<\/code> to your configuration classes.<\/p>\n\n\n
\nimport org.springframework.context.annotation.ComponentScan;\nimport org.springframework.context.annotation.Configuration;\nimport org.springframework.context.annotation.EnableAspectJAutoProxy;\n\n@Configuration\n@EnableAspectJAutoProxy\n@ComponentScan\npublic class CalculatorConfiguration {\n\n}\n<\/pre><\/div>\n\n\n
Now we can test our first Aspect with this test class:<\/p>\n\n\n
\nimport org.junit.jupiter.api.Test;\nimport org.springframework.context.ApplicationContext;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\nclass AspectTest {\n\n\t@Test\n\tvoid test() {\n\t\tApplicationContext context = new AnnotationConfigApplicationContext(CalculatorConfiguration.class);\n\t\t\t\t\n\t\t\t\tArithmeticCalculator arithmeticCalculator =\n\t\t\t\tcontext.getBean("arithmeticCalculator", ArithmeticCalculator.class);\n\t\t\t\tarithmeticCalculator.add(1, 2);\n\t\t\t\tarithmeticCalculator.sub(4, 3);\n\t\t\t\tarithmeticCalculator.mul(2, 3);\n\t\t\t\tarithmeticCalculator.div(4, 2);\n\t\t\t\tUnitCalculator unitCalculator = context.getBean("unitCalculator", UnitCalculator.class);\n\t\t\t\tunitCalculator.kilogramToPound(10);\n\t\t\t\tunitCalculator.kilometerToMile(5);\n\t}\n\n}\n<\/pre><\/div>\n\n\n
And this is console output of our test:<\/p>\n\n\n
\nThe method add() begins.\n1.0 + 2.0 = 3.0\n4.0 - 3.0 = 1.0\n2.0 * 3.0 = 6.0\n4.0 \/ 2.0 = 2.0\n10.0 kilogram = 22.0 pound\n5.0 kilometer = 3.1 mile\n<\/pre><\/div>\n\n\n
If you want to use an advice that runs before every method you can add this advice to the aspect:<\/p>\n\n\n
\n@Before("execution(* *.*(..))")\n\tpublic void logBeforeAll(JoinPoint joinPoint) {\n\t\tlog.info("This is logBeforeAll! The method " + joinPoint.getSignature().getName()\n\t\t\t\t+ "() begins with " + Arrays.toString(joinPoint.getArgs()));\n\t}\n<\/pre><\/div>\n\n\n
The execution points matched by a pointcut<\/strong> are called join points<\/strong> (in this case the pointcut<\/strong> is “execution(* *.<\/em>*(..))<\/code>“). In this term, a pointcut<\/strong> is an expression to match a set of join points<\/strong>, while an advice<\/strong> is the action to take at a particular join point<\/strong>.
For your advice to access the detail of the current join point, you can declare an argument of type JoinPoint<\/code> in your advice method. Then, you can get access to join point details such as the method name and argument values. Now, you can expand your pointcut<\/strong> to match all methods by changing the class name and method name to wildcards.<\/p>\n\n\n\n
The output looks like this:<\/p>\n\n\n
\nThis is logBeforeAll! The method add() begins with [1.0, 2.0] \n1.0 + 2.0 = 3.0\nThis is logBeforeAll! The method sub() begins with [4.0, 3.0] \n4.0 - 3.0 = 1.0\nThis is logBeforeAll! The method mul() begins with [2.0, 3.0]\n2.0 * 3.0 = 6.0\nThis is logBeforeAll! The method div() begins with [4.0, 2.0]\n4.0 \/ 2.0 = 2.0\nThis is logBeforeAll! The method kilogramToPound() begins with [10.0]\n10.0 kilogram = 22.0 pound\nThis is logBeforeAll! The method kilometerToMile() begins with [5.0]\n5.0 kilometer = 3.1 mile\n<\/pre><\/div>\n\n\n
@After Advice<\/h2>\n\n\n\n
An after advice is executed after a join point finishes and is represented by a method annotated with @After, whenever it returns a result or throws an exception.<\/p>\n\n\n\n
@AfterReturning Advice<\/h2>\n\n\n\n
An after advice is executed regardless of whether a join point returns normally or throws an exception. If you would like to perform logging only when a join point returns, you should replace the after advice with an after returning advice.<\/p>\n\n\n\n
@AfterThrowing Advice<\/h2>\n\n\n\n
An after throwing advice is executed only when an exception is thrown by a join point.<\/p>\n\n\n\n
@Around Advice<\/h2>\n\n\n\n
It gains full control of a join point, so you can combine all the actions of the preceding advices into one single advice. You can even control when, and whether, to proceed with the original join point execution.<\/p>\n\n\n\n
A common rule for choosing an advice type is to use the least powerful one that can satisfy your requirements.<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"
An aspect is a Java class that modularizes a set of concerns (e.g., logging or transaction management) that cuts across multiple types and objects. Java classes that modularize such concerns are decorated with the @Aspect annotation. In AOP terminology, aspects … Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":675,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[94,8],"tags":[101,103,104,105,102,98,97,100,99,96],"class_list":["post-632","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-spring-framework","category-works","tag-after","tag-afterreturning","tag-afterthrowing","tag-around","tag-before","tag-advice","tag-aspect-oriented-programming","tag-join-points","tag-pointcuts","tag-spring-framework"],"_links":{"self":[{"href":"https:\/\/aliyargunes.com.tr\/blog\/wp-json\/wp\/v2\/posts\/632"}],"collection":[{"href":"https:\/\/aliyargunes.com.tr\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/aliyargunes.com.tr\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/aliyargunes.com.tr\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/aliyargunes.com.tr\/blog\/wp-json\/wp\/v2\/comments?post=632"}],"version-history":[{"count":44,"href":"https:\/\/aliyargunes.com.tr\/blog\/wp-json\/wp\/v2\/posts\/632\/revisions"}],"predecessor-version":[{"id":681,"href":"https:\/\/aliyargunes.com.tr\/blog\/wp-json\/wp\/v2\/posts\/632\/revisions\/681"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/aliyargunes.com.tr\/blog\/wp-json\/wp\/v2\/media\/675"}],"wp:attachment":[{"href":"https:\/\/aliyargunes.com.tr\/blog\/wp-json\/wp\/v2\/media?parent=632"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/aliyargunes.com.tr\/blog\/wp-json\/wp\/v2\/categories?post=632"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/aliyargunes.com.tr\/blog\/wp-json\/wp\/v2\/tags?post=632"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}