spring aop记录日志

		<dependency>
		    <groupId>javassist</groupId>
		    <artifactId>javassist</artifactId>
		    <version>3.12.1.GA</version>
		</dependency>

		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.8.8</version>
		</dependency>
package com.try2better.daily.component;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;

@Retention(RetentionPolicy.RUNTIME)  
@Target({ElementType.METHOD,ElementType.TYPE})  
@Documented
//最高优先级  
@Order(Ordered.HIGHEST_PRECEDENCE)  
public @interface Try2betterAspectLog {
	String name() default "";  
}
package com.try2better.daily.component;

import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;

import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.bytecode.CodeAttribute;
import javassist.bytecode.LocalVariableAttribute;

import javax.servlet.http.HttpServletRequest;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.try2better.daily.entity.LogRecordEntity;
import com.try2better.daily.util.LoggerUtil;

@Aspect
@Component
public class LogAspect {

    @AfterReturning(returning="result", pointcut="@annotation(com.try2better.daily.component.Try2betterAspectLog)")
    public void after(JoinPoint joinPoint,Object result) throws ClassNotFoundException{
    	Object target = joinPoint.getTarget();
    	if(target == null || !(target instanceof BaseController)){
    		throw new RuntimeException("此controller没有继承BaseController!");
    	}
    	BaseController controller = (BaseController)joinPoint.getTarget();
    	HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
    	String uri = request.getRequestURI();
    	String url = request.getRequestURL().toString();
    	String queryString = request.getQueryString();
    	String classType = joinPoint.getTarget().getClass().getName();    
        Class<?> clazz = Class.forName(classType);    
        String className = clazz.getName();    
        String methodName = joinPoint.getSignature().getName(); //获取方法名称   
    	 //获取参数名称和值  
        Map<String,Object> parameterMap = getFieldsNameValueMap(joinPoint); 
        
        LogRecordEntity logRecordEntity = new LogRecordEntity();
        logRecordEntity.setUrl(url);;
        logRecordEntity.setUri(uri);;
        logRecordEntity.setQueryString(queryString);;
    
        logRecordEntity.setUserId("admin");;
        logRecordEntity.setRequestDate(new java.util.Date());;
    
        logRecordEntity.setClassName(className);;
        logRecordEntity.setMethodName(methodName);;
        logRecordEntity.setParameterMap(parameterMap);;
        logRecordEntity.setResult(result);;
    
	LoggerUtil.info(controller.getLogger(), logRecordEntity);
    }
  
    
    
    private Map<String,Object> getFieldsNameValueMap(JoinPoint joinPoint){  
    	Map<String,Object > map=new HashMap<String,Object>();  
    	try {
    		Object[] args = joinPoint.getArgs();
        	String classType = joinPoint.getTarget().getClass().getName();    
            Class<?> clazz = Class.forName(classType);    
            String clazzName = clazz.getName();    
            String methodName = joinPoint.getSignature().getName(); //获取方法名称   
           
            ClassPool pool = ClassPool.getDefault();    
            ClassClassPath classPath = new ClassClassPath(this.getClass());    
            pool.insertClassPath(classPath);    
            CtClass cc = pool.get(clazzName);    
            CtMethod cm = cc.getDeclaredMethod(methodName);    
            javassist.bytecode.MethodInfo methodInfo = cm.getMethodInfo();  
            CodeAttribute codeAttribute = methodInfo.getCodeAttribute();    
            LocalVariableAttribute attr = (LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);    
            if (attr == null) {    
                throw new RuntimeException();
            }    
            int pos = Modifier.isStatic(cm.getModifiers()) ? 0 : 1;    
            for (int i = 0; i < cm.getParameterTypes().length; i++){    
                map.put( attr.variableName(i + pos),args[i]);//paramNames即参数名    
            }    
		} catch (Exception e) {
			e.printStackTrace();
		}
        return map;    
    }    
}
package com.try2better.daily.entity;

import java.util.Date;
import java.util.Map;

public class LogRecordEntity {

	private String url;
	private String uri;
	private String queryString;

	private String userId;
	private Date requestDate;

	private String className;
	private String methodName;
	private Map<String,Object> parameterMap;
	private Object result;

	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getUri() {
		return uri;
	}
	public void setUri(String uri) {
		this.uri = uri;
	}
	public String getQueryString() {
		return queryString;
	}
	public void setQueryString(String queryString) {
		this.queryString = queryString;
	}
	public String getUserId() {
		return userId;
	}
	public void setUserId(String userId) {
		this.userId = userId;
	}
	public Date getRequestDate() {
		return requestDate;
	}
	public void setRequestDate(Date requestDate) {
		this.requestDate = requestDate;
	}
	public String getClassName() {
		return className;
	}
	public void setClassName(String className) {
		this.className = className;
	}
	public String getMethodName() {
		return methodName;
	}
	public void setMethodName(String methodName) {
		this.methodName = methodName;
	}
	public Map<String, Object> getParameterMap() {
		return parameterMap;
	}
	public void setParameterMap(Map<String, Object> parameterMap) {
		this.parameterMap = parameterMap;
	}
	public Object getResult() {
		return result;
	}
	public void setResult(Object result) {
		this.result = result;
	}

}
package com.try2better.daily.util;

import org.slf4j.Logger;

import com.alibaba.fastjson.JSONObject;
import com.try2better.daily.entity.LogRecordEntity;

public class LoggerUtil {

	public static void info(Logger logger,LogRecordEntity logRecordEntity){
		logger.info(JSONObject.toJSONString(logRecordEntity));
	}
}
package com.try2better.daily.controller;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.try2better.daily.component.BaseController;
import com.try2better.daily.component.Try2betterAspectLog;
import com.try2better.daily.entity.Task;
import com.try2better.daily.util.qrcode.EncodeRequestEntity;
import com.try2better.daily.util.qrcode.EncodeResultEntity;
import com.try2better.daily.util.qrcode.QRCodeHelper;

@Controller
@RequestMapping("/")
public class QRCodeController extends BaseController{

	@Try2betterAspectLog
	@ResponseBody
	@RequestMapping("/method")
	public Map<String,Object> method1(String a,Integer b){
		Map<String,Object> map = new HashMap<String, Object>();
		map.put("1", "1");
		return map;
	}

}
package com.try2better.daily.component;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class BaseController {

	protected final Logger logger = LoggerFactory.getLogger(getClass());

	public Logger getLogger() {
		return logger;
	}

}
时间: 2024-10-29 06:15:40

spring aop记录日志的相关文章

SSH框架系列:Spring AOP应用记录日志Demo

分类: [java]2013-12-10 18:53 724人阅读 评论(0) 收藏 举报 1.简介 Spring 中的AOP为Aspect Oriented Programming的缩写,面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.以下是Spring AOP的小例子 源代码:https://github.com/nuptboyzhb/SpringAOPDemo 2.例子简介 2.1切面aspect:Logging.java [java] view plainc

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

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

Spring AOP进行日志记录

在java开发中日志的管理有很多种.我一般会使用过滤器,或者是Spring的拦截器进行日志的处理.如果是用过滤器比较简单,只要对所有的.do提交进行拦截,然后获取action的提交路径就可以获取对每个方法的调用.然后进行日志记录.使用过滤器的好处是可以自己选择性的对某一些方法进行过滤,记录日志.但是实现起来有点麻烦. 另外一种就是使用Spring的AOP了.这种方式实现起来非常简单,只要配置一下配置文件就可以了.可是这种方式会拦截下所有的对action的每个操作.使得效率比较低.不过想做详细日志

JavaEE学习之Spring aop

一.基本概念 AOP——Aspect-Oriented Programming,面向切面编程,它是spring框架的一个重要组成部分.一般的业务逻辑都有先后关系,我们可以理解为纵向关系,而AOP关注的是横向关系,每一个关注点可以理解为一个横切面.例如我们的大部分代码都会涉及到日志记录,很多的数据库操作都会涉及到事务的创建和提交.那么从横向关注这些逻辑,他们都一个个的切面. AOP技术的具体实现,可以通过动态代理技术或者是在程序编译期间进行静态的"织入"方式.AOP经常使用的场景包括:日

spring aop环绕通知记录应用的日志

使用的框架是spring mvc+spring 最近想利用spring aop的环绕通知来处理web的日志问题,总的来讲,如果在controller层做切入,则难监控实际运行情况,在service层做切入,则只能监控到service层的情况,通过捕捉service抛出的异常来记录日志,对于目前本人应用而言,已经足够了,先将记录如下: 代码: @Component @Aspect public class ExceptionLog { /** * 61 * 环绕通知需要携带ProceedingJo

Spring AOP 实现原理(二) 使用 Spring AOP

与 AspectJ 相同的是,Spring AOP 同样需要对目标类进行增强,也就是生成新的 AOP 代理类:与 AspectJ 不同的是,Spring AOP 无需使用任何特殊 命令对 Java 源代码进行编译,它采用运行时动态地.在内存中临时生成"代理类"的方式来生成 AOP 代理. Spring 允许使用 AspectJ Annotation 用于定义方面(Aspect).切入点(Pointcut)和增强处理(Advice),Spring 框架则可识别并根据这些 Annotati

spring aop简单日志实例

转载自:http://www.blogjava.net/laoding/articles/242611.html 一直就用spring的IOC,遗憾spring的另一重要组成部分AOP却没用过,所以近几天抽空研究了下AOP,学了些东西,在这里记录下spring2.0的aop配置,以一个简单的记录日志的实例来说明,先介绍下用XMLSchema来配置,下一篇介绍annotation配置,废话不多说,开始吧先新建个web工程,将spring的包加进去,为方便就把全部的jar包加进去. 先来看个接口,很

关于 Spring AOP (AspectJ) 你该知晓的一切

[版权申明]未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) http://blog.csdn.net/javazejian/article/details/54629058 出自[zejian的博客] 关联文章: 关于Spring IOC (DI-依赖注入)你需要知道的一切 关于 Spring AOP (AspectJ) 你该知晓的一切 本篇是年后第一篇博文,由于博主用了不少时间在构思这篇博文,加上最近比较忙,所以这篇文件写得比较久,也分了不同的时间段在写,已尽最大能力去连贯博文中的内容

spring AOP自定义注解方式实现日志管理

转:spring AOP自定义注解方式实现日志管理 今天继续实现AOP,到这里我个人认为是最灵活,可扩展的方式了,就拿日志管理来说,用Spring AOP 自定义注解形式实现日志管理.废话不多说,直接开始!!! 关于配置我还是的再说一遍. 在applicationContext-mvc.xml中要添加的 <mvc:annotation-driven />     <!-- 激活组件扫描功能,在包com.gcx及其子包下面自动扫描通过注解配置的组件 -->     <conte