源于http://www.2cto.com/kf/201301/185841.html
1、问题
问题：想要添加日志记录、性能监控、安全监测
2、最初解决方案
2.1、最初解决方案
缺点：太多重复代码，且紧耦合
2.2、抽象类进行共性设计，子类进行个性设计，此处不讲解，缺点一荣俱荣，一损俱损
2.3、使用装饰器模式/代理模式改进的解决方案
装饰器模式：动态地给一个对象添加一些额外的职责。就增加功能来说， 装饰器模式相比生成子类更为灵活。
代理模式：为其他对象提供一种代理以控制对这个对象的访问。
缺点：紧耦合，每个业务逻辑需要一个装饰器实现或代理
2.4、JDK动态代理解决方案（比较通用的解决方案）
Java代码
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//1.记录日志 2.时间统计开始 3.安全检查
Object retVal = method.invoke(target, args);
//4.时间统计结束
return retVal;
}
public static Object proxy(Object target) {
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), new MyInvocationHandler(target));
}
}
[java]
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//1.记录日志 2.时间统计开始 3.安全检查
Object retVal = method.invoke(target, args);
//4.时间统计结束
return retVal;
}
public static Object proxy(Object target) {
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), new MyInvocationHandler(target));
}
}
编程模型
Java代码
//proxy 在其上调用方法的代理实例
//method 拦截的方法
//args 拦截的参数
Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object retVal=null;
//预处理
//前置条件判断
boolean ok = true;
if(!ok) {//不满足条件
throw new RuntimeException("你没有权限");
}
else {//反射调用目标对象的某个方法
retVal = method.invoke(target, args);
}
//后处理
return retVal;
}
[java]
//proxy 在其上调用方法的代理实例
//method 拦截的方法
//args 拦截的参数
Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object retVal=null;
//预处理
//前置条件判断
boolean ok = true;
if(!ok) {//不满足条件
throw new RuntimeException("你没有权限");
}
else {//反射调用目标对象的某个方法
retVal = method.invoke(target, args);
}
//后处理
return retVal;
}
缺点：使用麻烦，不能代理类，只能代理接口
CGLIB动态代理解决方案（比较通用的解决方案）
Java代码
public class MyInterceptor implements MethodInterceptor {
private Object target;
public MyInterceptor(Object target) {
this.target = target;
}
@Override
public Object intercept(Object proxy, Method method, Object[] args,
MethodProxy invocation) throws Throwable {
//1.记录日志 2.时间统计开始 3.安全检查
Object retVal = invocation.invoke(target, args);
//4.时间统计结束
return retVal;
}
public static Object proxy(Object target) {
return Enhancer.create(target.getClass(), new MyInterceptor(target));
}
}
[java]
public class MyInterceptor implements MethodInterceptor {
private Object target;
public MyInterceptor(Object target) {
this.target = target;
}
@Override
public Object intercept(Object proxy, Method method, Object[] args,
MethodProxy invocation) throws Throwable {
//1.记录日志 2.时间统计开始 3.安全检查
Object retVal = invocation.invoke(target, args);
//4.时间统计结束
return retVal;
}
public static Object proxy(Object target) {
return Enhancer.create(target.getClass(), new MyInterceptor(target));
}
}
编程模型
Java代码
//proxy 在其上调用方法的代理实例 method拦截的方法 args 拦截的参数
//invocation 用来去调用被代理对象方法的
@Override
public Object intercept(Object proxy, Method method, Object[] args,
MethodProxy invocation) throws Throwable {
//预处理
//前置条件判断
boolean ok = true;
if(!ok) {//不满足条件
throw new RuntimeException("出错了");
}
else {//调用目标对象的某个方法
Object retVal = invocation.invoke(target, args);
}
//后处理
return retVal;
}
[java]
//proxy 在其上调用方法的代理实例 method拦截的方法 args 拦截的参数
//invocation 用来去调用被代理对象方法的
@Override
public Object intercept(Object proxy, Method method, Object[] args,
MethodProxy invocation) throws Throwable {
//预处理
//前置条件判断
boolean ok = true;
if(!ok) {//不满足条件
throw new RuntimeException("出错了");
}
else {//调用目标对象的某个方法
Object retVal = invocation.invoke(target, args);
}
//后处理
return retVal;
}
优点：能代理接口和类
缺点：使用麻烦，不能代理final类
动态代理本质
本质：对目标对象增强
最终表现为类（动态创建子类），看手工生成（子类）还是自动生成（子类）
代理限制：
只能在父类方法被调用之前或之后进行增强（功能的修改），不能在中间进行修改，要想在方法调用中增强，需要ASM(java 字节码生成库)
其他动态代理框架
jboss：javassist （hibernate 3.3中默认为javassist）
（hibernate 3.3之前中默认为cglib）
2.5、AOP解决方案（通用且简单的解决方案）
Java代码
@Aspect
public class PayEbiAspect {
@Pointcut(value="execution(* pay(..))")
public void pointcut() {}
@Around(value="pointcut()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
//1.记录日志
//2.时间统计开始
//3.安全检查
Object retVal = pjp.proceed();//调用目标对象的真正方法
//4.时间统计结束
return retVal;
}
}
[java]
@Aspect
public class PayEbiAspect {
@Pointcut(value="execution(* pay(..))")
public void pointcut() {}
@Around(value="pointcut()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
//1.记录日志
//2.时间统计开始
//3.安全检查
Object retVal = pjp.proceed();//调用目标对象的真正方法
//4.时间统计结束
return retVal;
}
}
编程模型
Java代码
//2 切入点
@Pointcut(value="execution(* *(..))")
public void pointcut() {}
//3 拦截器的interceptor
@Around(value="pointcut()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
Object retVal=null;
//预处理
//前置条件判断
boolean ok = true;
if(!ok) {//不满足条件
throw new RuntimeException("你没有权限");
}
else {//调用目标对象的某个方法
retVal = pjp.proceed();
}
//后处理
return retVal;
}
[java]
//2 切入点
@Pointcut(value="execution(* *(..))")
public void pointcut() {}
//3 拦截器的interceptor
@Around(value="pointcut()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
Object retVal=null;
//预处理
//前置条件判断
boolean ok = true;
if(!ok) {//不满足条件
throw new RuntimeException("你没有权限");
}
else {//调用目标对象的某个方法
retVal = pjp.proceed();
}
//后处理
return retVal;
}
缺点：依赖AOP框架
AOP入门
概念：
n关注点：可以认为是所关注的任何东西，比如上边的支付组件；
n关注点分离：将问题细化为单独部分，即可以理解为不可再分割的组件，如上边的日志组件和支付组件；
n横切关注点：会在多个模块中出现，使用现有的编程方法，横切关注点会横越多个模块，结果是使系统难以设计、理解、实现和演进，如日志组件横切于支付组件。
织入：横切关注点分离后，需要通过某种技术将横切关注点融合到系统中从而完成需要的功能，因此需要织入，织入可能在编译期、加载期、运行期等进行。
nAOP是什么(Aspect Oriented Programming)
AOP是一种编程范式，提供从另一个角度来考虑程序结构以完善面向对象编程（OOP）。
AOP为开发者提供了一种描述横切关注点的机制，并能够自动将横切关注点织入到面向对象的软件系统中，从而实现了横切关注点的模块化。
AOP能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任，例如事务处理、日志管理、权限控制等，封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。
nAOP能干什么，也是AOP带来的好处
1：降低模块的耦合度
2：使系统容易扩展
3：设计决定的迟绑定：使用AOP,设计师可以推迟为将来的需求作决定，因为它
可以把这种需求作为独立的方面很容易的实现。
4：更好的代码复用性
AOP基本概念
连接点（Joinpoint）：
表示需要在程序中插入横切关注点的扩展点，连接点可能是类初始化、方法执行、方法调用、字段调用或处理异常等等，Spring只支持方法执行连接点，在AOP中表示为“在哪里做”；
切入点（Pointcut）：
选择一组相关连接点的模式，即可以认为连接点的集合，Spring支持perl5正则表达式和AspectJ切入点模式，Spring默认使用AspectJ语法，在AOP中表示为“在哪里做的集合”；
增强（Advice）：或称为增强
在连接点上执行的行为，增强提供了在AOP中需要在切入点所选择的连接点处进行扩展现有行为的手段；包括前置增强（before advice）、后置增强 (after advice)、环绕增强 （around advice），在Spring中通过代理模式实现AOP，并通过拦截器模式以环绕连接点的拦截器链织入增强 ；在AOP中表示为“做什么”；
方面/切面（Aspect）：
横切关注点的模块化，比如上边提到的日志组件。可以认为是增强、引入和切入点的组合；在Spring中可以使用Schema和@AspectJ方式进行组织实现；在AOP中表示为“在哪里做和做什么集合”；
目标对象（Target Object）：
需要被织入横切关注点的对象，即该对象是切入点选择的对象，需要被增强的对象，从而也可称为“被增强对象”；由于Spring AOP 通过代理模式实现，从而这个对象永远是被代理对象，在AOP中表示为“对谁做”；
AOP代理（AOP Proxy）：
AOP框架使用代理模式创建的对象，从而实现在连接点处插入增强（即应用切面），就是通过代理来对目标对象应用切面。在Spring中，AOP代理可以用JDK动态代理或CGLIB代理实现，而通过拦截器模型应用切面。
织入（Weaving）：
织入是一个过程，是将切面应用到目标对象从而创建出AOP代理对象的过程，织入可以在编译期、类装载期、运行期进行。
引入（inter-type declaration）：
也称为内部类型声明，为已有的类添加额外新的字段或方法，Spring允许引入新的接口（必须对应一个实现）到所有被代理对象（目标对象）, 在AOP中表示为“做什么（新增什么）”；
AOP的Advice类型
前置增强（Before advice）：
在某连接点之前执行的增强，但这个增强不能阻止连接点前的执行（除非它抛出一个异常）。
后置返回增强（After returning advice）：
在某连接点正常完成后执行的增强：例如，一个方法没有抛出任何异常，正常返回。
后置异常增强（After throwing advice）：
在方法抛出异常退出时执行的增强。
后置最终增强（After (finally) advice）：
当某连接点退出的时候执行的增强（不论是正常返回还是异常退出）。
环绕增强（Around Advice）：
包围一个连接点的增强，如方法调用。这是最强大的一种增强类型。 环绕增强可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。
相关推荐
本示例将简要介绍如何在Spring应用中实现AOP，通过实际的代码示例帮助理解其工作原理。 首先，我们要理解AOP的核心概念。AOP是一种编程范式，它允许开发者定义“切面”（Aspects），这些切面封装了特定的关注点，如...
Spring AOP（面向切面编程）是Spring框架的核心特性之一，它允许开发者在不修改源代码的情况下，通过...这个例子提供了学习Spring AOP实际操作的宝贵资源，通过阅读源码和运行测试，你将对Spring AOP有更全面的认识。
现在，我们回到主题——"springaop依赖的jar包"。在Spring 2.5.6版本中，使用Spring AOP通常需要以下核心jar包： - `spring-aop.jar`：这是Spring AOP的核心库，包含了AOP相关的类和接口。 - `spring-beans.jar`：...
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
接下来，我们通过一个简单的Spring AOP示例来加深对上述概念的理解。假设我们需要在调用某个公共方法前记录日志，我们可以定义一个`BeforeAdvice`，并在目标方法上应用此通知。 ```java package com.example.aop; ...
**Spring AOP 实现机制详解** Spring AOP（面向切面编程）是Spring框架的核心特性之一，它允许程序员在不修改源代码的...通过深入理解Spring AOP的实现机制，我们可以更好地利用这一强大的工具，优化我们的应用程序。
Spring AOP，即Spring的面向切面编程模块，是Spring框架的重要组成部分，它允许开发者在不修改源代码的情况下，对程序进行横切关注点的处理，如日志、事务管理等。实现这一功能，主要依赖于三个核心的jar包：aop...
SpringAOP通过使用动态代理技术，实现对目标对象方法调用的拦截，并根据切面定义的切点将增强应用到相应的连接点上。开发者只需要编写切面逻辑，无需修改业务代码，可以更清晰地分离关注点，并提高代码的复用性和可...
在`springAop1`这个压缩包中，可能包含了一个简单的应用示例，展示了如何定义一个切面类，以及如何在该类中定义通知方法。例如，我们可能会看到一个名为`LoggingAspect`的类，其中包含了`@Before`注解的方法，用于在...
1. **概念理解**：AOP 是一种编程范式，它将关注点分离，让通用的横切关注点（如日志、事务管理）与业务逻辑解耦。在 Spring 中，切面可以通过注解或 XML 配置定义。 2. **通知类型**：包括前置通知（Before）、...
通过深入理解并熟练运用Spring AOP，开发者可以编写更加模块化、可维护的代码，减少重复的工作，并提高系统的整体设计质量。在实际项目中，结合源码阅读和相关工具，能进一步提升对Spring AOP的掌握和运用水平。
Spring AOP，即Spring的面向切面编程模块，是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下对程序进行扩展和增强的方法。在Java应用中，AOP主要用于日志记录、性能统计、安全控制、事务管理等方面...
Spring AOP提供了对@AspectJ注解的支持，这是一种声明式的方式来定义切面。@AspectJ是一种类型级别的切面语言，它允许我们使用Java类和方法来表示切面，而不是使用XML配置。使用@AspectJ，我们可以更直观地编写和...
3. spring-aspects-4.1.6.RELEASE.jar：这个jar文件包含了Spring对AspectJ的集成支持。AspectJ是一个全面的面向切面编程(AOP)框架，它可以编译时或运行时织入切面。Spring Aspects提供了与AspectJ的无缝集成，使得...
在讨论Spring AOP（面向切面编程）时，首先需要理解几个核心概念。Spring AOP 是Spring框架提供的一个功能模块，它允许开发者将横切关注点（cross-cutting concerns）从业务逻辑中解耦出来，通过在方法调用前后进行...
在IT行业中，Spring AOP（面向切面编程）是一种强大的工具，它允许我们在不修改代码的情况下，对应用程序的特定部分进行拦截和增强。这在性能监控、日志记录、...结合源码学习，可以提升对Spring AOP机制的深入理解。
Spring框架是Java开发中不可或缺的一部分，它主要由两个核心组件构成：IoC（Inversion of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）。本笔记将深入探讨这两个概念以及它们在Spring中...
Spring AOP，全称为Aspect Oriented Programming，是Spring框架中的一个重要模块，主要负责处理系统中的...文件"5.SpringAOP_01"和"6.SpringAOP_02"很可能是课程的分阶段内容，涵盖了从基础概念到进阶实践的详细讲解。
Spring AOP（面向切面编程）是Spring框架的重要组成部分，它允许程序员在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行拦截和处理。这为日志、事务管理、性能监控等提供了方便。本示例提供了一种...
Spring AOP，全称Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为应用程序提供了声明式的企业级服务，如...通过对该项目的深入学习，你将能够更好地理解和掌握Spring AOP的实战应用。