Breaking News: Grepper is joining You.com. Read the official announcement!

spring aspect

Innocent Iguana answered on January 8, 2023 Popularity 8/10 Helpfulness 4/10

answer spring aspect

related aspect spring boot

spring aspect

Comment

- Adds global behavior to the application
- Re-usable block of code that can be injected into the application during runtime
- Leverages AspectJ
- Byte code modification (Runtime interweaving)
- Dynamic proxy-based
- Common applications
    - logging and tracing
    - Transaction management
    - Caching
    - Security
- Parts of Spring Aspect
    - Join Point : 
        - Represents these specific points in the execution of a program where advice can be applied.
        - Business logic where aspect can be applied 
        - You apply the aspect here
    - Pointcut : 
        - Specifies certain conditions or criteria that define when certain pieces of code (advice) should be executed.
        - Select the joinpoint for the cross-cutting concern 
        - This is the trigger of aspect 
        - signature: `designator("returntype packageName.className.methodName(argument)" )`
        - common designators : 
            - `execution` (expression for matching method execution), 
            - `within` (expression for matching within certain type), 
            - `target` (expression for matching specific type), 
            - `@annotation` (expression for matching specific annotation)
    - Advice : 
        - Represents the actual code or instructions that need to be executed when the conditions specified by the pointcut are met.
        - The code that is applied to the join point when it is selected by the pointcut (cross-cutting concern )
        - This is the aspected behavior itself

Popularity 8/10 Helpfulness 4/10 Language java

Source: Grepper

Tags: aspect java spring

Link to this answer
Share Copy Link

Contributed on Feb 25 2024

Innocent Iguana

0 Answers Avg Quality 2/10

Closely Related Answers

aspect spring boot

Comment

@AspectJ refers to a style of declaring aspects as regular Java classes annotated with Java 5 annotations.

The @AspectJ style was introduced by the AspectJ project as part of the AspectJ 5 release.

Spring 2.0 interprets the same annotations as AspectJ 5, using a library supplied by AspectJ for pointcut parsing and matching.

The AOP runtime is still pure Spring AOP though, and there is no dependency on the AspectJ compiler or weaver.

package com.xyz.someapp;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class SystemArchitecture {

  /**
   * A join point is in the web layer if the method is defined
   * in a type in the com.xyz.someapp.web package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.someapp.web..*)")
  public void inWebLayer() {}

  /**
   * A join point is in the service layer if the method is defined
   * in a type in the com.xyz.someapp.service package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.someapp.service..*)")
  public void inServiceLayer() {}

  /**
   * A join point is in the data access layer if the method is defined
   * in a type in the com.xyz.someapp.dao package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.someapp.dao..*)")
  public void inDataAccessLayer() {}

  /**
   * A business service is the execution of any method defined on a service
   * interface. This definition assumes that interfaces are placed in the
   * "service" package, and that implementation types are in sub-packages.
   * 
   * If you group service interfaces by functional area (for example, 
   * in packages com.xyz.someapp.abc.service and com.xyz.def.service) then
   * the pointcut expression "execution(* com.xyz.someapp..service.*.*(..))"
   * could be used instead.
   *
   * Alternatively, you can write the expression using the 'bean'
   * PCD, like so "bean(*Service)". (This assumes that you have
   * named your Spring service beans in a consistent fashion.)
   */
  @Pointcut("execution(* com.xyz.someapp.service.*.*(..))")
  public void businessService() {}
  
  /**
   * A data access operation is the execution of any method defined on a 
   * dao interface. This definition assumes that interfaces are placed in the
   * "dao" package, and that implementation types are in sub-packages.
   */
  @Pointcut("execution(* com.xyz.someapp.dao.*.*(..))")
  public void dataAccessOperation() {}

}

https://docs.spring.io/spring-framework/docs/3.0.x/spring-framework-reference/html/aop.html

Popularity 9/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: aspect as

Link to this answer
Share Copy Link

Contributed on Jan 08 2023

Anjali Sharma

0 Answers Avg Quality 2/10

spring aspect

Contents

More Related Answers

spring aspect

Closely Related Answers

aspect spring boot

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.