If you are using Spring framework, it is easy to implement Spring AOP. Ease of implementation comes with some limitations like you can only use aspects with spring managed beans and only methods can be used as pointcuts. Another limitation is that you cannot apply aspects for method calling another in same class. Whereas AspectJ does not have these limitations.

The reason behind this is the way Spring and AspectJ implements AOP. Spring uses runtime weaving whereas AspectJ uses load time weaving. Spring implements proxy based approach. Where it adds a proxy wrapper aound your class, and every call to the class method, has to go through the proxy wrapper.

AspectJ implement load time waving by actually manipulating the bytecode using its compiler while class is loaded to JVM.

References:
http://kamalmeet.com/tag/aop-2/
https://en.wikipedia.org/wiki/AspectJ
http://stackoverflow.com/questions/26325732/spring-aop-with-aspectj-load-time-weaving
http://www.springindepth.com/book/aop-load-time-weaving.html
http://stackoverflow.com/questions/1606559/spring-aop-vs-aspectj

In last few posts on AOP I have mentioned basics of AOP, and some sample implementations- http://kamalmeet.com/category/aop/

I will discuss some formal AOP terms here

JoinPoint: A well defined point in execution of a application. A point where something is happening in the applicaiton. For example when a method is called, an object is instantiation, an exception is being thrown etc.

Advice: The code that is to be executed at a particular joinpoint.

Pointcut: Collection of joinpoints where advice has to be applied.

A very good explanation of joinpoint & pointcut- http://stackoverflow.com/questions/15447397/spring-aop-whats-the-difference-between-joinpoint-and-pointcut

Aspect: Combination of pointcuts and advice, programmed in a class. For example see loginaspect class

Weaving: When do we add aspects to actual code- compile time, run time (Spring), load time (AspectJ)

Target Object: object whose execution flow is modified by an AOP process.

Introduction: Process by which you modify target object, by declaring additional methods or fields.

Types of advice:

Before: Before starting the execution

After: After completion of execution

After Throwing: After an exception is thrown

After Returning: After normal execution (no exception thrown)

Around: Before and After execution

Refer: http://docs.spring.io/spring/docs/4.0.1.RELEASE/spring-framework-reference/htmlsingle/#aop-introduction-defn

For basics of AOP refer

http://kamalmeet.com/aop/aspect-oriented-programming/
http://kamalmeet.com/aop/aspect-oriented-programming-implementation/

Here is a simple logging example using aspectj

package com.my.aspect;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * This is class implementing logging aspect. This is a generic class which can
 * be embedded into any piece of code for implementing logging.
 * 
 * @author kamalmeet
 * @version 1.0
 */
@Component
@Aspect
public class LoggingAspect {

	private static final Logger LOG = Logger.getLogger(LoggingAspect.class);;
	

	private static final String POINT_CUT = "execution(* com.my.package.*.*(..))";

	/**
	 * This method is used to log action before entering into point-cut method.
	 * 
	 * @param joinPoint
	 */
	// @Before(POINT_CUT)
	@Before(POINT_CUT)
	public void logBefore(JoinPoint joinPoint) {
		LOG.info("Entering function: "+ joinPoint.getSignature());
		
	}

	/**
	 * This method is used to log action after returning from point-cut method.
	 * 
	 * @param joinPoint
	 */
	@AfterReturning(POINT_CUT)
	public void logAfterReturing(JoinPoint joinPoint) {
		LOG.info("Exiting successfully from function: "+
				joinPoint.getSignature());
	}

	/**
	 * This method is used to log error in case some exception condition
	 * occurred in the given point-cut method.
	 * 
	 * @param joinPoint
	 */
	@AfterThrowing(POINT_CUT)
	public void logAfterThrowing(JoinPoint joinPoint) {
		LOG.error("Exiting with exception thrown from function: "+
				joinPoint.getSignature());
	}
}