Spring Aop Demo

最新推荐文章于 2020-11-26 21:03:25 发布
最新推荐文章于 2020-11-26 21:03:25 发布
阅读量1.6k 收藏
点赞数
分类专栏： Java框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bruce128/article/details/51647471
版权

    最近做项目时，接入了四个极其重要的外部接口。为了核对接口的准确性，把这四个接口的所有入参和返回值都打了日志。完全是重复性的机械劳动。端午节的时候回想这件事，发现AOP不正是职业解决这种事情的吗！而且用AOP打日志，原有的业务代码省去了日志代码，更加精简。

    先写了个AOP的demo体验下功能。

导入aop相关的依赖

    虽然没有显式引入cglib.jar，但是spring-aop-3.2.jar已经集成了cglib的功能。所以我的服务类没有实现接口，但依然能实现AOP的功能。 

<properties>
    <v.spring>3.2.0.RELEASE</v.spring>
    <v.fastjson>1.1.36</v.fastjson>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${v.spring}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${v.spring}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${v.spring}</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${v.spring}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>${v.spring}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>${v.spring}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>${v.spring}</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>${v.fastjson}</version>
    </dependency>
</dependencies>

需要被切入的服务类

package com.jd.ls;

import org.springframework.stereotype.Service;

/**
 * Created by Administrator on 2016/6/8.
 */
@Service
public class Hello {
	public String hello(String name) {

		String s = "hello, " + name;
		System.out.println(s);
		return s;
	}

	public void throwEx() {
		throw new NullPointerException();
	}
}

AOP切面类

package com.jd.ls;

import com.alibaba.fastjson.JSON;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * Created by Administrator on 2016/6/8.
 */

@Component
@Aspect
public class AopTest {

	//如果要设置多个切点可以使用 || 拼接
	@Pointcut("execution(* com.jd.ls.Hello.*(..))")
	private void anyMethod() {
	}

	@Before(value = "anyMethod()")
	public void doBefore(JoinPoint joinPoint) {

		System.out.println("前置通知");
		System.out.println("方法签名：" + joinPoint.getSignature().toLongString());
	}

	@AfterReturning(value = "anyMethod()", returning = "result")
	public void doAfter(JoinPoint jp, String result) {

		System.out.println("后置通知, result:\t" + result);
	}

	@After("anyMethod()")
	public void after() {

		System.out.println("最终通知");
	}

	@AfterThrowing(value = "anyMethod()", throwing = "e")
	public void doAfterThrow(JoinPoint joinPoint, Throwable e) {
		e.printStackTrace();
	}

	@Around("anyMethod()")
	public Object doBasicProfiling(ProceedingJoinPoint joinPoint) throws Throwable {
		System.out.println("进入环绕通知");
		System.out.println("目标类名称：" + joinPoint.getTarget().getClass().getName());
		System.out.println("方法签名：" + joinPoint.getSignature().toLongString());
		System.out.println("方法参数：");
		for (Object o : joinPoint.getArgs()) {
			System.out.println(o.getClass().getName() + ":\t" + o.toString());
		}
		System.out.println("target" + joinPoint.getTarget());
		System.out.println("staticPart:" + joinPoint.getStaticPart().toShortString());
		System.out.println("kind:" + joinPoint.getKind());
		System.out.println("sourceLocation:" + joinPoint.getSourceLocation());
		Object object = joinPoint.proceed();// 执行该方法
		System.out.println("执行结果" + JSON.toJSONString(object));
		System.out.println("退出方法");
		System.out.println(joinPoint.toLongString());
		return object;
	}

}

    @Pointcut的路径参数指定了哪些类的哪些方法会作为切入点进行横向编程。而@Before，@After等注解则指定在什么时机织入代码。

spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
    
    <context:component-scan base-package="com.jd.ls"/>
    <!-- 打开aop 注解 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>

</beans>

单元测试

package com.jd.ls;


import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring-config.xml"})
public class AppTest {

	@Autowired
	Hello hello;

	@Test
	public void testAop() {
		System.out.println("====================启动服务");
		hello.hello("world");
		System.out.println("====================终止服务");
	}

	@Test
	public void testAopEx() {
		System.out.println("====================启动服务");
		hello.throwEx();
		System.out.println("====================终止服务");
	}

}

测试结果

    方法1的运行结果 
====================启动服务
进入环绕通知
目标类名称：com.jd.ls.Hello
方法签名：public java.lang.String com.jd.ls.Hello.hello(java.lang.String)
方法参数：
java.lang.String:	world
targetcom.jd.ls.Hello@4ac216
staticPart:execution(Hello.hello(..))
kind:method-execution
sourceLocation:org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint$SourceLocationImpl@1777b1
前置通知
方法签名：public java.lang.String com.jd.ls.Hello.hello(java.lang.String)
hello, world
执行结果"hello, world"
退出方法
execution(public java.lang.String com.jd.ls.Hello.hello(java.lang.String))
最终通知
后置通知, result:	hello, world
====================终止服务

    方法二的运行结果 
====================启动服务
进入环绕通知
目标类名称：com.jd.ls.Hello
方法签名：public void com.jd.ls.Hello.throwEx()
方法参数：
targetcom.jd.ls.Hello@4ac216
staticPart:execution(Hello.throwEx())
kind:method-execution
sourceLocation:org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint$SourceLocationImpl@1777b1
前置通知
方法签名：public void com.jd.ls.Hello.throwEx()
最终通知
java.lang.NullPointerException
	at com.jd.ls.Hello.throwEx(Hello.java:18)
	at com.jd.ls.Hello$$FastClassByCGLIB$$3f78c6d2.invoke(<generated>)
	at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:698)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:150)
	at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:50)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	at org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint.proceed(MethodInvocationProceedingJoinPoint.java:80)
	at com.jd.ls.AopTest.doBasicProfiling(AopTest.java:59)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
	at java.lang.reflect.Method.invoke(Method.java:597)
	at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethodWithGivenArgs(AbstractAspectJAdvice.java:621)
	at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethod(AbstractAspectJAdvice.java:610)
	at org.springframework.aop.aspectj.AspectJAroundAdvice.invoke(AspectJAroundAdvice.java:65)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	at org.springframework.aop.aspectj.AspectJAfterAdvice.invoke(AspectJAfterAdvice.java:42)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	at org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:50)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:55)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:90)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:631)
	at com.jd.ls.Hello$$EnhancerByCGLIB$$d4ecbb7c.throwEx(<generated>)
	at com.jd.ls.AppTest.testAopEx(AppTest.java:27)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
	at java.lang.reflect.Method.invoke(Method.java:597)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
	at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:74)
	at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:83)
	at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:72)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:231)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:88)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184)
	at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
	at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:71)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:236)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:174)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:157)
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:78)
	at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:212)
	at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:68)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
	at java.lang.reflect.Method.invoke(Method.java:597)
	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:140)

    方法二抛了异常，异常的堆栈在AOP的切面代码里被输出。
bruce128
关注
专栏目录
springAOP demo
sdzhangshulong的博客
06-29 713
首先是切面类 package com.atguigu.aop; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.AfterThrowing; import org.aspectj.lang...
SpringIOC Demo
Jack
05-01 361
1、设计目标：通过一个例子简单了解springIOC 2、实现步骤： （1）使用MyEclipse自动添加spring支持 （2）从网上下载lombok（可以使代码看起来更加简洁） （3）编写配置文件：applicationContext.xml （4）编写实体类或接口 （5）测试 3、代码：
Spring AOP demo
11-16
基于注解与 XML 配置文件两种形式的 AOP demo。 基于 xml 配置文件的 aop 管理 ```xml <!-- 配置切面的bean --> <bean id="loggingAspect" class="com.jas.aop.xml.LoggingAspect"/> <aop:config> <!-- 配置切点表达式 --> <aop:pointcut id="pointcut1" expression="execution(public void com.jas.aop.bean.PersonImpl.sayHello())"/> <aop:pointcut id="pointcut2" expression="execution(public void com.jas.aop.bean.PersonImpl.sayBye(String))"/> <!-- 配置切面 --> <aop:aspect ref="loggingAspect"> <!-- 配置通知 --> <aop:before method="beforeMethod" pointcut-ref="pointcut1"/> <aop:around method="aroundMethod" pointcut-ref="pointcut2"/> </aop:aspect> </aop:config> ``` Java 类 ```java public class LoggingAspect { public void beforeMethod(JoinPoint joinPoint) { System.out.println("在目标方法执行之前执行" + ", 要拦截的方法是：" + joinPoint.getSignature()); } public Object aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable { Object[] args = joinPoint.getArgs(); // 判断目标方法参数，满足条件修改参数值 if(" See You Again".equals(args[0])) { args[0] = " See You Again ..."; } // 在目标方法执行之前执行，相当于前置通知 System.out.println("这是一个前置通知"); // 执行目标方法 Object result = joinPoint.proceed(args); // 在目标方法执行之后之后，相当于后置通知 System.out.println("这是一个后置通知"); return result; } }
Spring Aop demo
xqhys的博客
01-09 329
前言 AOP（AspectOriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的...
spring aop demo
11-24
1、spring切入点 2、spring前置织入,传入参数处理 3、spring后置织入,传入参数处理 4、环绕织入，参数及返回值处理 5、返回后织入，返回值处理 6、异常织入，异常处理 maven环境下，测试用例可直接运行
spring aop demo 两种实现方式
12-08
Spring AOP（面向切面编程）是Spring框架的重要组成部分，它允许程序员在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行拦截和处理。这为日志、事务管理、性能监控等提供了方便。本示例提供了一种...
spring aop的demo
03-11
spring aop的demo spring aop的demo
Spring AOP简单demo
09-26
Spring AOP简单demo 入门级的 advice
@AspectJ配置Spring AOP，demo
03-14
@AspectJ配置Spring AOP,文档，Aspect jar包， 可运行的demo,
spring-aop实例demo
04-27
spring3.2.8使用aop的简单实例
Spring AOP 一个简单Demo
greywolf5的博客
08-23 173
public class Agent { public void speak() { System.out.print("Bond"); } } import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.intercept.MethodInvocation; public class AgentDecorator implements MethodInterceptor {
Spring之AOP简单demo
weixin_30911809的博客
05-22 102
1.加入JAR包。出了Spring自身的Jar包还要一些依赖的JAR包。不然会报ClassNotFound。 Student.java package com.lubby.bean; import org.springframework.stereotype...
Spring实现Aop(Demo)
weixin_48967642的博客
11-26 275
什么是AOP 定义: 面向切面编程 面向对象的语言虽然已经非常优秀，但是在灵活性上总是有些不如人意，因此，现在出来了函数式编程，也出来了我们今天要给大家讲的AOP。而AOP的出来并不是要取代OOP(面向对象编程)，它只是作为一个补充的角色过来，来解决一些咱们OOP解决不了(或者说很难解决)的一些代码。 AOP的使用只存在于一些特定的场合(具有横切逻辑的应用场合),横切逻辑这个解释可能比较抽象，咱们说得再具体一点，AOP可以用于事务管理，日志管理，性能监测等地方。 Spring实现AOP的方案 Spring实
Spring AOP应用实例demo
热门推荐
何静媛
03-16 1万+
AOP（Aspect-Oriented Programming，面向方面编程），可以说是OOP（Object-OrientedPrograming，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。 OOP的问题，AOP的补充： 当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你
Spring aop 小实例demo
幸运小侯子
04-27 1977
因为近期提供接口服务项目中要有个需求，所有的操作必须检查一下服务是否可用的动作，所以感觉Aop实现起来特别合适，整理学习一下小实例。   关于spring-Aop原理：http://m.oschina.net/blog/174838这篇文章写的很好。     个人觉着可能上线的时候配置文件更方便一下，所以例子主要是配置文件方式 Demo文件下载地址： http://download.
java spring aop切面demo
最新发布
06-21
下面是一个简单的Spring AOP切面（Aspect）的Demo示例： 首先，你需要在Spring配置文件中启用AOP支持，并定义一个切面（Aspect）： ```xml <beans xmlns="http://www.springframework.org/schema/beans" xmlns:...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值