Weaving织入部分：Advice ： 需要添加的功能，例如日志功能、权限功能等，以及什么时候添加（目标方法执行前、后、异常等时候）。Join-point ： 目标类中能够添加功能的地方！Pointcut ： 指定目标类中添加功能的地方！因为不可能给所有Join-point织入Advice！（Spring AOP仅限于方法，因为它基于代理实现。其他的框架还可以针对字段添加功能！了解就行。）需要注意的是，Advice定义了什么时候做、做什么，而Pointcut则定义了在哪里做。Aspect = Advices + Pointcuts     // Aspect可以认为是一堆Advice的类，且其中指定了每个Advice执行的Pointcut。

Introduction引入部分：暂无

Spring对AOP的支持有四种形式：① 经典的Spring基于代理的AOP。② 纯POJO aspect。③ @AspectJ注解驱动的aspect。④ 注入的AspectJ aspect。
以上，前三种是Spring自有AOP的变体，由于都是基于代理，所以，仅限于方法拦截！！！

execution(* concert.Performance.perform(..)) && within(concert.*)     // 这里就定义了一个pointcut，而且仅限于被concert包下的aspect使用。   

例如：execution(* concert.Performance.perform()) and bean('woodstock')    这里就定义了一个woodstock的pointcut。
例如：execution(* concert.Performance.perform()) and !bean('woodstock')    注意这里！！！很有意思的用法。

@Component  // 这个是必须的！！
@Aspect
public class Audience {@Before("execution(** concert.Performance.perform(..))")    // 该注解声明了silenceCellPhones()需要应用到的Pointcut。public void silenceCellPhones() {System.out.println("Silencing cell phones");}@Before("execution(** concert.Performance.perform(..))")public void takeSeats() {System.out.println("Taking seats");}@AfterReturning("execution(** concert.Performance.perform(..))")public void applause() {System.out.println("CLAP CLAP CLAP!!!");}@AfterThrowing("execution(** concert.Performance.perform(..))")public void demandRefund() {System.out.println("Demanding a refund");}
}

@Component  // 这个是必须的！！！
@Aspect
public class Audience {@Pointcut("execution(** concert.Performance.perform(..))")public void perform(){};    // 必须要定义一个方法，用于承载pointcut！
// 其他的正常代码，略
}    

package aop.performance;/*** 用这个演示join-point和pointcut。* perform()就是join-point！* * @author Larry*/
public interface Performance {void perform();
}

package aop.performance;
import org.springframework.stereotype.Component;@Component
public class PerformanceImpl implements Performance{@Overridepublic void perform() {System.out.println(this.getClass()+"正在演出~~~");}
}

package aop;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;/*** 用Audience类来掩饰AspectJ 5的注解用法。* * @author Larry**/
@Component
@Aspect
public class Audience {@Before("execution(** aop.performance.Performance.perform(..))")public void takeSeat() {System.out.println("演出之前要入座~");}@Before("execution(** aop.performance.Performance.perform(..))")public void silenceCellPhones() {System.out.println("演出之前要静音~");}@After("execution(** aop.performance.Performance.perform(..))")public void applause() {System.out.println("演出之后要鼓掌！");}// TODO: 貌似不能这样用？？而且会导致大BUG！！！阻止访问Pointcut！！！见下面//@Around("execution(** aop.performance.Performance.perform(..))")public void greet() {System.out.println("演出前后要致意~");    }@AfterReturning("execution(** aop.performance.Performance.perform(..))")public void leave() {System.out.println("结束后，goodbye~");}@AfterThrowing("execution(** aop.performance.Performance.perform(..))")public void demandRefund(){System.out.println("退钱！！！");}//上面，不好的地方是每次都要写相同的pointcut！解决办法如下：@Pointcut("execution(** aop.performance.Performance.perform(..))")public void perform(){}// 这样就定义了一个pointcut：performance()，然后就可以直接使用了！如下：@Before("perform()")public void wave(){System.out.println("挥挥手~");}// TODO: 务必注意，@Around必须手动调用Pointcut，否则会阻止对Pointcut的访问！！！@Around("perform()")public void greet2(ProceedingJoinPoint jp) {try {System.out.println("演出前后要致意~A");    jp.proceed();//TODO:这里还可以调用带参数的！System.out.println("演出前后要致意~B");    } catch (Throwable e) {e.printStackTrace();}}
}

package aop;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import aop.performance.PerformanceImpl;@Configuration
@ComponentScan(basePackageClasses={ Audience.class,PerformanceImpl.class,AudienceB.class,IntroductionEncoreable.class })
@EnableAspectJAutoProxy    //激活AspectJ
public class JavaConfig {}

package aop.test;import java.util.Arrays;import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.core.env.Environment;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import aop.JavaConfig;
import aop.performance.Performance;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { JavaConfig.class })
public class PerformanceAOPTest {@AutowiredEnvironment env;@AutowiredApplicationContext ac;@AutowiredPerformance p;@Testpublic void run() {String[] activeProfiles = env.getActiveProfiles();System.out.println("activeProfiles的长度"+activeProfiles.length);for (String string : activeProfiles) {System.out.println("activeProfiles:" + string);}System.out.println("-------------------------------------");String applicationName = ac.getApplicationName();System.out.println("applicationName："+applicationName);String[] beanDefinitionNames = ac.getBeanDefinitionNames();String beans = Arrays.toString(beanDefinitionNames);System.out.println("applicationContext中的beans："+beans);
}@Testpublic void run1() {p.perform();    // 注意有没有激活AspectJ！}
}

@Around("performance()")
public void watchPerformance(ProceedingJoinPoint jp) {try {System.out.println("Silencing cell phones");   // 相当于@BeforeSystem.out.println("Taking seats");  // 相当于@Beforejp.proceed();    // 【】【】这个，就是调用pointcut。可能忘记调用，也可能重复调用。。。System.out.println("CLAP CLAP CLAP!!!");  // 相当于@After 【奇怪，那@AfterReturning呢】} catch (Throwable e) {System.out.println("Demanding a refund");   // 相当于@AfterThrowing}
}

// 样式
execution(* soundsystem.CompactDisc.playTrack(int)) && args(trackNumber)

/*    注意，这里实现的功能是统计trackNumber的播放次数！*/@Aspect
@Component
public class TrackCounter {private Map<Integer, Integer> trackCounts = new HashMap<Integer, Integer>();

// 定义Pointcut@Pointcut("execution(* soundsystem.CompactDisc.playTrack(int)) && args(trackNumber)")public void trackPlayed(int trackNumber) {}　// Advice　@Before("trackPlayed(trackNumber)")        // trackNumber就是pointcut方法的形参名！！！public void countTrack(int trackNumber) {int currentCount = getPlayCount(trackNumber);trackCounts.put(trackNumber, currentCount + 1);}　// 普通的方法　public int getPlayCount(int trackNumber) {return trackCounts.containsKey(trackNumber) ? trackCounts.get(trackNumber) : 0;}
}

package aop.performance;/*** Encore，加演。延长演出的意思。* @author Larry**/
public interface Encoreable {void performEncore();
}

package aop.performance;import org.springframework.stereotype.Component;@Component
public class EncoreableImpl implements Encoreable{@Overridepublic void performEncore() {System.out.println("加演一场~~~");}
}

package aop;import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;
import org.springframework.stereotype.Component;
import aop.performance.Encoreable;
import aop.performance.EncoreableImpl;/*** AOP应用之Introduction，就是给对象（bean）添加功能，类似js之类的动态语言给对象添加方法。。* @author Larry**/
@Component
@Aspect
public class IntroductionEncoreable {@DeclareParents(value="aop.performance.Performance+",defaultImpl=EncoreableImpl.class)   // 稍后讲public static Encoreable encoreable; // 先引入需要引入的方法所在的接口
}

package aop;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;import aop.performance.PerformanceImpl;@Configuration
@ComponentScan(basePackageClasses={ PerformanceImpl.class,IntroductionEncoreable.class })
@EnableAspectJAutoProxy    //激活AspectJ
public class JavaConfig {}

package IntroductionEncoreable;import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;import aop.JavaConfig;
import aop.performance.Encoreable;
import aop.performance.Performance;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes={JavaConfig.class})
public class IntroductionAOPTest {@AutowiredApplicationContext ac;@AutowiredPerformance p;@Testpublic void run1(){((Encoreable)p).performEncore(); // 通过类型强转调用Introduction的方法！！！
    }
}

<aop:config><aop:aspect ref="audience"><aop:pointcut id="performance" expression="execution(** aop.performance.Performance.perform(..))" /><aop:before pointcut-ref="performance"  method="silenceCellPhones"/><aop:before pointcut-ref="performance" method="takeSeats"/><aop:after-returning pointcut-ref="performance" method="applause"/><aop:after-throwing pointcut-ref="performance" method="demandRefund"/></aop:aspect>
</aop:config>   

package aop;import org.aspectj.lang.ProceedingJoinPoint;public class Audience {public void greet3(ProceedingJoinPoint jp) {try {System.out.println("演出前后要致意~A");    jp.proceed(); // TODO:这里还可以调用带参数的！System.out.println("演出前后要致意~B");    } catch (Throwable e) {e.printStackTrace();}}
}

<aop:config><aop:aspect ref="audience"><aop:pointcut id="performance" expression="execution(** aop.performance.Performance.perform(..))" />   <aop:around pointcut-ref="performance" method="greet3"/></aop:aspect>
</aop:config>

<aop:aspect><aop:declare-parents types-matching="aop.performance.Performance+" implement-interface="aop.performance.Encoreable" default-impl="aop.performance.DefaultEncoreable" />
</aop:aspect>

<bean id="encoreableDelegate" class="aop.performance.DefaultEncoreable" />
<aop:aspect><aop:declare-parents types-matching="aop.performance.Performance+" implement-interface="aop.performance.Encoreable" delegate-ref="encoreableDelegate" />
</aop:aspect>