Spring AOP实例——异常处理和记录程序执行时间

实例简介:

  这个实例主要用于在一个系统的所有方法执行过程中出线异常时,把异常信息都记录下来,另外记录每个方法的执行时间。

用两个业务逻辑来说明上述功能,这两个业务逻辑首先使用Spring AOP的自动代理功能,然后一个用Java的动态代理,一个用CGLIB代理。

实现思路:

  首先定义负责异常处理的Advice:ExceptionHandler.java,定义记录程序执行时间的Advice:TimeHandler.java

然后定义业务逻辑接口LogicInterface.java,编写实现业务逻辑接口的类Logic1.java,该业务逻辑在Spring AOP中使用java的动态代理

编写另一个业务逻辑Logic2.java,不实现业务逻辑接口,该业务逻辑在Spring AOP中使用CGLIB代理,然后使用自动代理定义配置文件config.xml

最后编写测试程序,执行并查看输出结果。

1.定义异常处理的Adice:ExceptionHandle.java

 1 //***ExceptionHandler.java********
 2 package com.gc.action;
 3
 4 import java.lang.reflect.Method;
 5
 6 import org.apache.log4j.Level;
 7 import org.apache.log4j.Logger;
 8 import org.springframework.aop.ThrowsAdvice;
 9
10 //使用Throw通知类型来实现Advice
11 public class ExceptionHandler implements ThrowAdvice{
12     private Logger logger = Logger.getLogger(this.getClass().getName());
13
14     public void afterThrowing(Method method,Object[] args,Object target,Throwable subclass)throws Throwable{
15         logger.log(Level.INFO,args[0]+" 执行 "+method.getName()+"时有异常抛出..."+subclass);
16
17 }
18
19 }

2.定义记录程序执行时间的Advice为TimeHandler.java

 1 //***TimeHandler.java*****
 2 package com.gc.action;
 3
 4 import org.aopalliance.interceptor.MethodInterceptor;
 5 import org.aopalliance.interceptor.MethodInvocation;
 6 import org.apache.log4j.Level;
 7 import org.apache.log4j.Logger;
 8
 9 public class TimeHandler implements MethodInterceptor{
10      private Logger logger = Logger.getLogger(this.getClass().getName());
11
12      public Object invoke(MethodInvocation methodInvocation)throws Throwable{
13         long procTime = System.currentTimeMillis();
14         logger.log(Level.INFO,methodInvocation.getArguments()[0]+"开始执行"+methodInvocation.getMethod()+"方法");
15 }
16         try{
17            Object result = methodInvocation.proceed();
18            return result;
19
20            }
21        finally{
22            procTime = System.currentTimeMillis()-procTime;
23            logger.log(Level.INFO,methodInvocation.getArguments()[0]+"执行"+methodInvocation.getMethod()+"方法结束");
24            logger.log(Level.INFO,"执行"+methodInvocation.getMethod.getName()+"方法共用了"+procTime+"毫秒");
25             }
26 }

3.定义业务逻辑接口

1 //*****LogicInterface.java*****
2 package com.gc.impl;
3
4 public interface LogicInterface{
5      public void doInsert(String name);
6      public void doUpdate(String name);
7      public void doDelete(String name);
8
9 }

4.编写实现业务逻辑接口的类Logic1.java

 1 //*****Logic2.java******
 2 package com.gc.action;
 3
 4 import com.gc.impl.LogicInterface;
 5
 6 public class Logic1 implements LogicInterface{
 7      public void doInsert(String name)
 8      {
 9             System.out.println("新增...");
10             for(int i=0;i<1000000;i++)
11             {
12             //模拟执行时间
13             }
14      }
15      public void doUpdate(String name)
16      {
17             System.out.println("修改...");
18             for(int i=0;i<3000000;i++)
19             {
20              //模拟执行时间
21             }
22      }
23          public void doDelete(String name)
24      {
25             System.out.println("删除...");
26             for(int i=0;i<2000000;i++)
27             {
28             //模拟执行时间
29             }
30      }
31
32 }

5.编写不实现业务逻辑接口的类Logic2.java

 1  1 //*****Logic2.java******
 2  2 package com.gc.action;
 3  3
 4  4 import com.gc.impl.LogicInterface;
 5  5
 6  6 public class Logic2{
 7  7      public void doInsert(String name)
 8  8      {
 9  9             System.out.println("新增...");
10 10             for(int i=0;i<4000000;i++)
11 11             {
12 12             //模拟执行时间
13 13             }
14 14      }
15 15      public void doUpdate(String name)
16 16      {
17 17             System.out.println("修改...");
18 18             for(int i=0;i<5000000;i++)
19 19             {
20 20              //模拟执行时间
21 21             }
22 22      }
23 23          public void doDelete(String name)
24 24      {
25 25             System.out.println("删除...");
26 26             for(int i=0;i<6000000;i++)
27 27             {
28 28             //模拟执行时间
29 29             }
30 30      }
31 31
32 32 }

6.使用自动代理定义配置文件config.xml

待续。。。

时间: 2024-10-14 00:03:58

Spring AOP实例——异常处理和记录程序执行时间的相关文章

Spring Aop实例之AspectJ注解配置

http://blog.csdn.net/xiaoxian8023/article/details/17285809 上篇博文<Spring Aop实例之xml配置>中,讲解了xml配置方式,今天来说说AspectJ注解方式去配置spring aop. 依旧采用的jdk代理,接口和实现类代码请参考上篇博文.主要是将Aspect类分享一下: [java] view plaincopy package com.tgb.aop; import org.aspectj.lang.JoinPoint;

Spring AOP 切面编程记录日志和接口执行时间

最近客户现在提出系统访问非常慢,需要优化提升访问速度,在排查了nginx.tomcat内存和服务器负载之后,判断是数据库查询速度慢,进一步排查发现是因为部分视图和表查询特别慢导致了整个系统的响应时间特别长.知道了问题之后,就需要对查询比较慢的接口进行优化,但哪些接口需要优化.哪些不需要呢?只能通过日志里的执行时间来判断,那么如何才能知道每一个接口的执行时间呢? 如果想学习Java工程化.高性能及分布式.深入浅出.微服务.Spring,MyBatis,Netty源码分析的朋友可以加我的Java高级

Spring aop 实例(转)

面向切面编程,有效的降低了代码之间的耦合性,易于维护:例如:我们习惯在代码中加上一些日志信息,在程序出错时方便快速查找找到问题,通常做法是在请求进入方法的时候打印日志,退出前打印日志,还有在出错时打印日志,那么问题就来了,每个方法中都需要打印日志,这些相同的部分就可以当做一个切面,通过配置切点来触发所需要的功能,比如,我需要在请求进入方法的时候打印,即可使用aop当中的前置通知来做到,这样就不需要每个方法中都去写一遍,配置好之后引用即可. 简单的记录一下spring aop的一个示例 基于两种配

Spring Aop实例之xml配置

上篇博文<3幅图让你了解Spring AOP>中介绍了aop通知类型,AOP的配置方式有2种方式:xml配置和AspectJ注解方式.今天我们就来实践一下xml配置方式. http://blog.csdn.net/xiaoxian8023/article/details/17258933 我采用的jdk代理,所以首先将接口和实现类代码附上 [java] view plaincopy package com.tgb.aop; public interface UserManager { publ

spring aop实例介绍

在Spring 2.0中,Pointcut的定义包括两个部分:Pointcut表示式(expression)和Pointcut签名(signature).让我们先看看execution表示式的格式:括号中各个pattern分别表示修饰符匹配(modifier-pattern?).返回值匹配(ret-type-pattern).类路径匹配(declaring-type-pattern?).方法名匹配(name-pattern).参数匹配((param-pattern)).异常类型匹配(throws

Spring Aop实例

在上篇博文中,我向大家介绍了Aop重要概念和教程,这回给出代码示例. 一.XML方式 1. TestAspect:切面类 [java] view plaincopy package com.spring.aop; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; public class TestAspect { public void doAfter(JoinPoint jp) { S

Spring AOP 实现业务日志记录

1. 用户管理业务逻辑接口(UserManagerApplogic.java ) Java代码   package com.iteye.applogic; public interface UserManagerApplogic { public void addUser(String name); } 2. 用户管理业务逻辑实现类(UserManagerApplogicImpl.java) Java代码   package com.iteye.applogic.impl; import org

spring aop 方法增加日志记录

使用场景: 1:调用外部接口时需要记录出参和入参. 2:分布式系统之间,调用各个系统之间需要记录日志,一旦出现了问题也可以找得到元数据 一言不合,上代码: # 枚举类 1 package xxxxxxxxxx; 2 3 import java.lang.annotation.ElementType; 4 import java.lang.annotation.Retention; 5 import java.lang.annotation.RetentionPolicy; 6 import ja

spring Aop 实例

SpringMvc.xml中添加扫描日志类和使用aop注解. <!--扫描全局日志 --> <context:component-scan base-package="com.company.wx.log" /> <aop:aspectj-autoproxy expose-proxy="true"/> 配置类: @Aspect @Component public class GlobalLogConfig { @Autowired