`

Spring AOP

阅读更多
AOP的实现原理
  • 编译期:切面在编译期织入,不过需要重新定义新的语法关键字并由特殊的编译器编译来实现   AspectJ
  • 类装载器:目标类被装载到Java虚拟机时,有一个特殊的类装载器对目标类的字节码进行增强
  • 运行期:目标对象和切面都是标准的Java类,通过Java虚拟机的动态代理功能或CGLib事项的运行期动态织入


public class AopProxyFactory {

	public static Object createProxy(final Object target, 
	        final MethodBeforeAdvice methodBeforeAdvice) {
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
				target.getClass().getInterfaces(),
				new InvocationHandler() {
					public Object invoke(Object proxy, Method method, Object[] args)
						throws Throwable {
						methodBeforeAdvice.before(method, args, target);
						return method.invoke(target, args);
					}
				});
	}
}


public class Main {
	public static void main(String[] args) {
		BookDao bookDao = new BookDao();
		BookServiceImpl target = new BookServiceImpl();
		target.setBookDao(bookDao);
		MethodBeforeAdvice log = new MethodBeforeAdvice() {
			public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
				System.out.println("call method" + arg0.getName());
			}
		};
		BookService bookService = (BookService) AopProxyFactory.createProxy(target, log);
		bookService.query();
	}
}


术语解释
  • Aspect:切面
  • 切面是一个横跨多个核心逻辑的功能,或者称之为系统关注点,例如日志记录,事务处理,安全检查。以前我们在每个方法中调用重复编写这些代码,现在我们将这些散落的代码集中起来,放在一个模块中,这个模块就是切面
  • Joinpoint:连接点
  • 连接点就是应用程序流程的何处插入切面,(一个方法调用时,访问一个字段时,特定的异常抛出时)
  • Pointcut:切入点
  • 切入点是一组连接点的集合,比如一个切面要在调用,所有以delete开头的方法时执行,就可以用通配符delete*来表示这一组连接点,我们将其称为切面
  • Advice:增强
  • 在特定连接点上执行的动作,执行这个动作就相当于对原始对象的功能做了增强
  • Introduction:引介
  • 为一个已有的Java对象,动态的添加新的接口
  • Weaving:织入
  • 织入是将切面整合到程序中的过程
  • Interceptor:拦截器
  • 拦截器是一种实现增强的方式
  • Target Object:目标对象
  • 真正执行核心逻辑的对象。
  • Advisor:一个Advice与Pointcut的结合
  • 定义如何将advice织入目标对象



常用Advice
1.MethodBeforeAdvice:在一个方法执行前增强
2.AfterReturningAdvice:在一个方法执行后增强
3.ThrowsAdvice:在一个方法执行前后增强
4.MethodInterceptor:在一个方法执行前后增强  可以控制整个方法执行与否,修改返回值,功能最强大。能使用上述三种简单的实现,就不要使用MethodInterceptor

public interface UserService {
	void login(String username, String password);
	boolean create(String username, String password);
}

@Service("userServiceTarget")
public class UserServiceImpl implements UserService {
	public void login(String username, String password) {
		if ("zhang".equals(username) && "zhang".equals(password)) {
			
		} else {
			throw new RuntimeException();
		}
	}
	public boolean create(String username, String password) {
		return "admin".equals(username) ? false : true;
	}
}

@Component
public class LoginMethodBeforeAdvice implements MethodBeforeAdvice {
	public void before(Method method, Object[] args, Object target) 
	        throws Throwable {
		System.out.println("[LoginMethodBeforeAdvice] User " + args[0] + " try to login....");
	}
}

@Component
public class LoginMethodAfterAdvice implements AfterReturningAdvice {
	public void afterReturning(Object returnValue, Method method, Object[] args, 
	        Object target) throws Throwable {
		System.out.println("[LoginMethodAfterAdvice] User " + args[0] + " is login...");
	}
}

@Component
public class LoginMethodThrowsAdvice implements ThrowsAdvice {
	public void afterThrowing(Throwable subClass) {
		System.out.println("[LoginMethodThrowsAdvice] An exception occur: " 
		    + subClass.getClass().getSimpleName());
	}
}

public class LoginMethodAroundAdvice implements MethodInterceptor {
	public Object invoke(MethodInvocation invocation) throws Throwable {
		// 这里实现MethodBeforeAdvice的功能
		Object ret = null;
		try {
			ret = invocation.proceed();
		} catch (Exception e) {
			// 这里实现ThrowsAdvice的功能
		}
		// 这里实现AfterReturningAdvice的功能
		return ret;
	}
}
	 
public class Drive {
	public static void main(String[] args) throws InterruptedException {

		ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
		UserService userService = (UserService) context.getBean("userService");

		try {
			userService.login("zhang", "zhang");
			Thread.sleep(500);
			userService.login("xxxx", "invaild-password");
		} catch (RuntimeException e) {
			//System.err.println("invalid user...");
		}
	}
}

输出
[LoginMethodBeforeAdvice] User zhang try to login....
[LoginMethodAfterAdvice] User zhang is login...
[LoginMethodBeforeAdvice] User xxxx try to login....
[LoginMethodThrowsAdvice] An exception occur: RuntimeException

<bean id="userService" class="org.springframework.aop.framework.ProxyFactoryBean">
	<property name="target" ref="userServiceTarget"/>
	<property name="interceptorNames">
		<list>
			<value>loginMethodBeforeAdvice</value>
			<value>loginMethodAfterAdvice</value>
			<value>loginMethodThrowsAdvice</value>
		</list>
	</property>
</bean>

三种Advice执行的位置不冲突,所以先后顺序无关,若加入MethodInterceptor,并且放置在最前面,则出现异常时,不执行invocation.proceed();其他三种Advice将不会被执行



Advisor 控制只在某些方法上执行
1.NameMatchMethodPointcutAdvisor
2.RegexpMethodPointcutAdvisor
@Component
public class CreateAfterReturningAdvice implements AfterReturningAdvice {
	public void afterReturning(Object returnValue, Method method, Object[] args, 
	    Object target) throws Throwable {
		System.out.println("[CreateAfterReturningAdvice] create user " + args[0]);
	}
}
	 
public class Drive {
	public static void main(String[] args) throws InterruptedException {
		ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
		UserService userService = (UserService) context.getBean("userService");

		try {
			userService.create("zhang", "zhang");
			userService.login("zhang", "zhang");
			Thread.sleep(500);
			userService.create("admin", "invaild-password");
			userService.login("admin", "invaild-password");
		} catch (RuntimeException e) {
			//System.err.println("invalid user...");
		}
	}
}

输出
[CreateAfterReturningAdvice] create user zhang
[LoginMethodAfterAdvice] User zhang is login...
[LoginMethodBeforeAdvice] User zhang try to login....
[LoginMethodAfterAdvice] User zhang is login...
[LoginMethodThrowsAdvice] An exception occur: RuntimeException


<bean id="createAfterReturningAdvisor" 
	    class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
	<property name="advice" ref="createAfterReturningAdvice"/>
	<property name="mappedName" value="create"/>
</bean>
 
<bean id="loginMethodBeforeAdvisor" 
		class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
	<property name="advice" ref="loginMethodBeforeAdvice"/>
	<property name="pattern" value=".*login.*"/>
</bean>
 
<bean id="userService" class="org.springframework.aop.framework.ProxyFactoryBean">
	<property name="target" ref="userServiceTarget"/>
	<property name="interceptorNames">
		<list>
			<value>loginMethodBeforeAdvisor</value>
			<value>createAfterReturningAdvisor</value>
			<!-- loginMethodAfterAdvice loginMethodThrowsAdvice 每个方法执行时都会被调用 -->
			<value>loginMethodAfterAdvice</value>
			<value>loginMethodThrowsAdvice</value>
		</list>
	</property>
 </bean>


spring aop代理实际上包含了一个有Advisor和Advice组成的拦截链,Advice总是增强所有方法,Advisor同时包含Advice和Pointcut,因此Advisor会通过Pointcut计算是否应该调用Advice对某个方法进行增强。

使用自动代理
1.自动为多个目标Bean实现Aop代理
2.避免客户端直接访问目标Bean
通过BeanPostProcessor实现,BeanNameAutoProxyCreator DefaultAdvisorAutoProxyCreator AspectJInvocationContextExposingAdvisorAutoProxyCreator AnnotationAwareAspectJAtuoProxyCreator

<!-- BeanNameAutoProxyCreator 所有以Service结尾的Bean -->
<bean id="beanNameAutoProxy" 
    class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
	<property name="beanNames" ref="*Service"/>
	<property name="interceptorNames">
		<list>
			<value>loginMethodBeforeAdvisor</value>
			<value>loginMethodAfterAdvice</value>
			<value>loginMethodThrowsAdvice</value>
			<value>createAfterReturningAdvisor</value>
		</list>
	</property>
</bean>
	 
<!-- DefaultAdvisorAutoProxyCreator -->
<bean id="defaultAutoProxy"
	class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />


引介 Introduction
一种类型特殊的拦截器,不能作用于任何切入点,只能作用于类,而非方法级别,换句话说就是给类动态的添加接口

想让User类具有Mutable接口,通过isReadonly来判断是否可以更改User类的信息

public class User {

	private String username;
	private String password;
	private String email;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
}

public interface Mutable {
	boolean isReadonly();
	void setReadonly(boolean isReadOnly);
}

public class MutableInterceptor extends DelegatingIntroductionInterceptor 
        implements Mutable {
	private boolean readonly;
	public boolean isReadonly() {
		return this.readonly;
	}
	public void setReadonly(boolean readonly) {
		this.readonly = readonly;
	}
}


public static void main(String[] args) {
	
	ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
	User user = (User) context.getBean("user");
	System.out.println(user.getEmail());
	((Mutable)user).setReadonly(true);
	System.out.println(((Mutable)user).isReadonly());
	user.setEmail("abc@xyz.com");
	System.out.println(user.getEmail());
}
输出 
default-email
false
abc@xyz.com	


<bean id="user" scope="prototype" 
    class="org.springframework.aop.framework.ProxyFactoryBean">
	<property name="target" ref="target"/>
	<!-- 对类代理,因此设置为true,同时需要CGlib -->
	<property name="proxyTargetClass" value="true"/>
	<property name="proxyInterfaces">
		<list>
			<value>demo.aop.introduction.Mutable</value>
		</list>
	</property>
	<property name="interceptorNames">
		<list>
			<value>introductionAdvisor</value>
		</list>
	</property>
</bean>

<bean id="introductionAdvisor" scope="prototype" 
	class="org.springframework.aop.support.DefaultIntroductionAdvisor">
	<constructor-arg>
		<bean class="demo.aop.introduction.MutableInterceptor"/>
	</constructor-arg>
</bean>

<bean id="target" class="demo.aop.introduction.User">
	<property name="username" value="default-username"/>
	<property name="password" value="default-password"/>
	<property name="email" value="default-email"/>
</bean>

可以看到User对象却是具有了Mutable接口,因为没有ClassCastException。但是我们
ProxyFactoryBean返回的是一个AOP代理对象,因此它可以截获所有方法的调用,并委托给MethodInterceptor处理,MethodInterceptor集成自DelegatingIntroductionInterceptor,DelegatingIntroductionInterceptor实现了MethodInterceptor接口,因此可以实现方法拦截。

DelegatingIntroductionInterceptorde的invoke方法
public Object invoke(MethodInvocation mi) throws Throwable {
        // 调用前是否是新的接口的方法?
		if (isMethodOnIntroducedInterface(mi)) {
		    // 调用delegate对象的方法
			Object retVal = AopUtils.invokeJoinpointUsingReflection(this.delegate,
    			mi.getMethod(), mi.getArguments());
			if (retVal == this.delegate && mi instanceof ProxyMethodInvocation) {
				Object proxy = ((ProxyMethodInvocation) mi).getProxy();
				if (mi.getMethod().getReturnType().isInstance(proxy)) {
					retVal = proxy;
				}
			}
			return retVal;
		}
		// 重写invoke方法,会拦截所有方法
		// 如果只希望拦截原始对象(User)的方法,就覆写doProceed方法
		return doProceed(mi);
	}
	
// 修改后的	MutableInterceptor
public class MutableInterceptor extends DelegatingIntroductionInterceptor implements Mutable {
	private boolean readonly;
	public boolean isReadonly() {
		return this.readonly;
	}
	public void setReadonly(boolean readonly) {
		this.readonly = readonly;
	}
	@Override
	protected Object doProceed(MethodInvocation mi) throws Throwable {
		if (readonly && mi.getMethod().getName().startsWith("set")) {
			throw new UnsupportedOperationException("Object is set to readonly");
		}
		return super.doProceed(mi);
	}
}


禁止在运行期改变AOP代理
<property name="frozen" value="true"/>

使用AspectJ实现AOP
// 1 声明Aspect
@Aspect
public class LoggerAspect {

}

// 2 声明Advice
@Before("execution(* demo.aop.impl.UserServiceImpl.login(..)) && args(username, ..)")
public void logBefore(String username){
	System.out.println("[logger] User "+ username +" try to login....");
}

@Around("execution(* demo.aop.impl.UserServiceImpl.login(..))")
public Object securityCheck(ProceedingJoinPoint pjp) throws Throwable {
	String username = (String) pjp.getArgs()[0];
	if ("admin".equals(username)) {
		System.out.println("[security check admin is forbidden]");
		throw new RuntimeException();
	}
	return pjp.proceed();
}

// 3 开启AspectJ支持
<aop:aspectj-autoproxy/>

executionde的完整表达式:execution(修饰符? 返回类型 声明类型? 方法名称(参数类型) 异常类型?)

声明Pointcut
上面的Advice中,我们直接把Pointcut的表达式卸载相应的注解中。可以通过@Pointcut注解提取出来单独定义
@Aspect
@Component
public class LoggerAspect {

	@Pointcut("execution(* demo.service.impl.UserServiceImpl.login(..))")
	public void loginMethod(){}
	
	@Before("loginMethod() && args(username, ..)")
	public void logBefore(String username) {
		System.out.println("[logger] User " + username + " try to login....");
	}

	@AfterReturning("loginMethod() && args(username, ..)")
	public void logSuccess(String username) {
		System.out.println("[logger] User " + username + " has login....");
	}

	@AfterThrowing(pointcut = "loginMethod()", throwing = "e")
	public void logFailure(RuntimeException e) {
		System.out.println("[logger] Exception: " + e.getMessage());
	}
	
	@Around("loginMethod()")
	public Object securityCheck(ProceedingJoinPoint pjp) throws Throwable {
		String username = (String) pjp.getArgs()[0];
		if ("admin".equals(username)) {
			System.out.println("[security check] admin is forbidden");
			throw new RuntimeException();
		}
		return pjp.proceed();
	}
}
分享到:
评论

相关推荐

    spring aop jar 包

    Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架的重要组成部分,它提供了一种在不修改源代码的情况下,对程序进行功能增强的技术。这个"spring aop jar 包"包含了实现这一功能所需的类和接口,...

    Spring AOP 16道面试题及答案.docx

    Spring AOP,全称为Aspect Oriented Programming,是面向切面编程的一种编程范式,它是对传统的面向对象编程(OOP)的一种补充。在OOP中,核心是对象,而在AOP中,核心则是切面。切面是关注点的模块化,即程序中的...

    简单spring aop 例子

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它提供了一种模块化和声明式的方式来处理系统中的交叉关注点问题,如日志、事务管理、安全性等。本示例将简要介绍如何在Spring应用中实现AOP,通过实际的...

    spring aop 自定义注解保存操作日志到mysql数据库 源码

    3、对spring aop认识模糊的,不清楚如何实现Java 自定义注解的 4、想看spring aop 注解实现记录系统日志并入库等 二、能学到什么 1、收获可用源码 2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑...

    死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理(csdn)————程序.pdf

    Spring AOP 是一种面向切面编程的技术,它允许我们在不修改源代码的情况下,对应用程序的特定部分(如方法调用)进行增强。在 Spring 中,AOP 的实现主要依赖于代理模式,有两种代理方式:JDK 动态代理和 CGLIB 动态...

    Spring AOP完整例子

    Spring AOP(面向切面编程)是Spring框架的核心特性之一,它允许开发者在不修改源代码的情况下,通过插入切面来增强或改变程序的行为。在本教程中,我们将深入探讨Spring AOP的不同使用方法,包括定义切点、通知类型...

    Spring Aop四个依赖的Jar包

    Spring AOP,全称Aspect-Oriented Programming(面向切面编程),是Spring框架的一个重要模块,它通过提供声明式的方式来实现面向切面编程,从而简化了应用程序的开发和维护。在Spring AOP中,我们无需深入到每个...

    spring aop依赖jar包

    现在,我们回到主题——"springaop依赖的jar包"。在Spring 2.5.6版本中,使用Spring AOP通常需要以下核心jar包: - `spring-aop.jar`:这是Spring AOP的核心库,包含了AOP相关的类和接口。 - `spring-beans.jar`:...

    spring AOP 引入jar包,spring IOC 引入Jar包

    Spring AOP 和 Spring IOC 是 Spring 框架的两个核心组件,它们对于任何基于 Java 的企业级应用开发都至关重要。Spring AOP(面向切面编程)允许开发者在不修改源代码的情况下,通过“切面”来插入新的行为或增强已...

    反射实现 AOP 动态代理模式(Spring AOP 的实现原理)

    面向切面编程(AOP)是一种编程范式,旨在将横切关注点(如日志、安全等)与业务逻辑分离,从而提高模块化。...利用Java反射机制和Spring AOP框架,开发者可以方便地实现AOP,从而提升代码的模块化和可维护性。

    Spring AOP实现机制

    **Spring AOP 实现机制详解** Spring AOP(面向切面编程)是Spring框架的核心特性之一,它允许程序员在不修改源代码的情况下,通过“切面”来插入额外的业务逻辑,如日志、事务管理等。AOP的引入极大地提高了代码的...

    springAOP配置动态代理实现

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它允许程序员在不修改源代码的情况下,通过在运行时插入额外的行为(如日志记录、性能监控等)来增强对象的功能。动态代理则是Spring AOP实现的核心技术之一...

    Spring AOP面向方面编程原理:AOP概念

    ### Spring AOP面向方面编程原理:AOP概念详解 #### 一、引言 随着软件系统的日益复杂,传统的面向对象编程(OOP)逐渐暴露出难以应对某些横切关注点(cross-cutting concerns)的问题。为了解决这一挑战,面向方面编程...

    小马哥讲 Spring AOP 编程思想 - API 线索图.pdf

    在讨论Spring AOP(面向切面编程)时,首先需要理解几个核心概念。Spring AOP 是Spring框架提供的一个功能模块,它允许开发者将横切关注点(cross-cutting concerns)从业务逻辑中解耦出来,通过在方法调用前后进行...

    spring aop切面拦截指定类和方法实现流程日志跟踪

    ### Spring AOP 实现流程日志跟踪 #### 一、背景与目的 在现代软件开发过程中,为了确保系统的稳定性和可维护性,通常会引入非功能性的需求来增强应用程序的功能,比如日志记录、安全控制等。这些需求往往不是业务...

    spring aop 五个依赖jar

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它提供了一种模块化和声明式的方式来处理系统中的交叉关注点,如日志、事务管理等。在Java应用中,AOP通过代理模式实现了切面编程,使得我们可以将业务逻辑...

    Spring源码最难问题:当Spring AOP遇上循环依赖.docx

    Spring源码最难问题:当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题,当Spring AOP遇上循环依赖时,该如何解决? Spring通过三级缓存机制解决循环依赖的问题。 在Spring中,bean的实例化...

    spring AOP依赖三个jar包

    Spring AOP,即Spring的面向切面编程模块,是Spring框架的重要组成部分,它允许开发者在不修改源代码的情况下,对程序进行横切关注点的处理,如日志、事务管理等。实现这一功能,主要依赖于三个核心的jar包:aop...

    spring aop的demo

    在`springAop1`这个压缩包中,可能包含了一个简单的应用示例,展示了如何定义一个切面类,以及如何在该类中定义通知方法。例如,我们可能会看到一个名为`LoggingAspect`的类,其中包含了`@Before`注解的方法,用于在...

Global site tag (gtag.js) - Google Analytics