Jeecg中通过Spring_AOP+注解方式实现日志的管理

转载;https://blog.csdn.net/ma451152002/article/details/77234236
Jeecg中通过Spring_AOP+注解方式实现日志的管理

一、设计思路

通过spring的aop切面功能，拦截到请求的所有的符合切面表达式的方法，判断是否含有注解标志，生成日志对象，然后通过aop的后置通知进行日志的持久化。

二、代码实现

    1、工程结构：
    

2、pom.xml增加aop依赖：

 <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-aop</artifactId>
          <version>4.1.7.RELEASE</version>
        </dependency>
        <dependency>
          <groupId>aspectj</groupId>
          <artifactId>aspectjrt</artifactId>
          <version>1.5.3</version>
        </dependency>
        <dependency>
          <groupId>org.aspectj</groupId>
          <artifactId>aspectjweaver</artifactId>
          <version>1.8.4</version>
        </dependency>
        <dependency>
          <groupId>aopalliance</groupId>
          <artifactId>aopalliance</artifactId>
          <version>1.0</version>
        </dependency>
        <dependency>
          <groupId>cglib</groupId>
          <artifactId>cglib</artifactId>
          <version>3.2.4</version>
        </dependency> 



3、定义我们的Log实体对象
package aop;
 
import java.util.Date;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
 
import org.hibernate.annotations.DynamicInsert;
import org.hibernate.annotations.DynamicUpdate;
import org.hibernate.annotations.GenericGenerator;
import org.jeecgframework.core.common.entity.IdEntity;
 
@Entity
@Table(name="assess_log_test")
@DynamicInsert(true)
@DynamicUpdate(true)
@SuppressWarnings("serial")
public class Log  implements java.io.Serializable{
    /**
     * 日志id
     */
    private String id;
 
    /**
     * 当前操作人id
     */
    private String loginAccount;
 
    /**
     * 当前操作人ip
     */
    private String loginIp;
 
    /**
     * 操作请求的链接
     */
    private String actionUrl;
 
    /**
     * 执行的模块
     */
    private String module;
 
    /**
     * 执行的方法
     */
    private String method;
 
    /**
     * 执行操作时间
     */
    private Long actionTime;
 
    /**
     * 描述
     */
    private String description;
 
    /**
     * 执行的时间
     */
    private Date gmtCreate;
 
    /**
     * 该操作状态，1表示成功，-1表示失败！
     */
    private Short state;
 
    @Id
    @GeneratedValue(generator = "paymentableGenerator")
    @GenericGenerator(name="paymentableGenerator",strategy="uuid")
    @Column(name="id",nullable=false,length=32)
    public String getId() {
        return id;
    }
    @Column(name="login_account",length=32)
    public String getLoginAccount() {
        return loginAccount;
    }
    @Column(name="login_ip",length=32)
    public String getLoginIp() {
        return loginIp;
    }
    @Column(name="action_url",length=100)
    public String getActionUrl() {
        return actionUrl;
    }
    @Column(name="module",length=32)
    public String getModule() {
        return module;
    }
    @Column(name="method",length=32)
    public String getMethod() {
        return method;
    }
    @Column(name="action_time")
    public Long getActionTime() {
        return actionTime;
    }
    @Column(name="description",length=200)
    public String getDescription() {
        return description;
    }
    @Column(name="gmt_create")
    public Date getGmtCreate() {
        return gmtCreate;
    }
    @Column(name="state")
    public Short getState() {
        return state;
    }
 
    public void setId(String id) {
        this.id = id;
    }
 
    public void setLoginAccount(String loginAccount) {
        this.loginAccount = loginAccount;
    }
 
    public void setLoginIp(String loginIp) {
        this.loginIp = loginIp;
    }
 
    public void setActionUrl(String actionUrl) {
        this.actionUrl = actionUrl;
    }
 
    public void setModule(String module) {
        this.module = module;
    }
 
    public void setMethod(String method) {
        this.method = method;
    }
 
    public void setActionTime(Long actionTime) {
        this.actionTime = actionTime;
    }
 
    public void setDescription(String description) {
        this.description = description;
    }
 
    public void setGmtCreate(Date gmtCreate) {
        this.gmtCreate = gmtCreate;
    }
 
    public void setState(Short state) {
        this.state = state;
    }
 
    @Override
    public String toString() {
        return "Log [id=" + id + ", loginAccount=" + loginAccount
                + ", loginIp=" + loginIp + ", actionUrl=" + actionUrl
                + ", module=" + module + ", method=" + method + ", actionTime="
                + actionTime + ", description=" + description + ", gmtCreate="
                + gmtCreate + ", state=" + state + "]";
    }
    
    
 
}

4.定义注解对象
package aop;
 
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;
 
/**
 * 日志记录
 *  
 *  @author mgj 
 *    @date 2017-8-11 上午10:53:19
 */
@Target({ElementType.PARAMETER,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface SystemLog {
    String module() default "";
    String methods() default "";
}
5.定义aop界面拦截方法
 package aop;
 
import java.lang.reflect.Method;
import java.util.Date;
import javax.servlet.http.HttpServletRequest;
 
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.jeecgframework.core.util.ResourceUtil;
import org.jeecgframework.core.util.StringUtil;
import org.jeecgframework.web.system.pojo.base.TSUser;
import org.jeecgframework.web.system.service.SystemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
 
 
import antlr.StringUtils;
 
@Component
@Aspect
public class LogAopAction {
    private long BEGIN_TIME;
    private long END_TIME;
    private Log log = new Log();
    @Autowired
    private SystemService  systemService;
    
 
    //@Pointcut("execution(* vote.backmanage.teachermanage.controller.AssessTeacherInfoController.*(..))")
    //@Pointcut("execution(* vote.backmanage.teachermanage.controller.*.*(..))")
    //@Pointcut("execution(* vote.backmanage.teachermanage.controller..*.*(..))")
    @Pointcut("execution(* vote.backmanage.teachermanage.controller..*.*(..))")
    public  void controllerAspect(){}
    
    @Before("controllerAspect()")
    public  void doBefore(){
        BEGIN_TIME = new Date().getTime();
    }
    
    @AfterReturning("controllerAspect()")
    public  void doAfter(){
        if (log.getState() == 1 || log.getState() == -1) {
            log.setActionTime(END_TIME - BEGIN_TIME);
            log.setGmtCreate(new Date(BEGIN_TIME));
            
            System.out.println(log);
            System.out.println("存入到数据库");
            systemService.save(log);
            
        }else {
            System.out.println(log);
            System.out.println("不存到数据库里");
        }
    }
    @After("controllerAspect()")
    public  void after(){
        END_TIME = new Date().getTime();
    }
 
    @Around("controllerAspect()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes())
                                        .getRequest();
        //获得当前用户
        TSUser user = ResourceUtil.getSessionUserName();
        String name = user.getRealName();
        log.setLoginAccount(name);
        
        //拦截的实体类
        Object target = pjp.getTarget();
        //拦截的方法名
        String methodName = pjp.getSignature().getName();
        //拦截的方法参数
        Object[] args = pjp.getArgs();
        //拦截的放参数类型
        Signature sig = pjp.getSignature();
        
        MethodSignature msig = null;
        if (!(sig instanceof MethodSignature)) {
            throw new IllegalArgumentException("该注解只能用于方法");
        }
        
        msig = (MethodSignature)sig;
        Class[] parameterTypes = msig.getMethod().getParameterTypes();
        
        Object object = null;
        Method method = null;
        
        try{
            method = target.getClass().getMethod(methodName, parameterTypes);
        }catch (Exception e) {
            e.printStackTrace();
        }
        
        if (null != method) {
            if (method.isAnnotationPresent(SystemLog.class)) {//判断是否包含我们自定义的注解
                SystemLog systemlog = method.getAnnotation(SystemLog.class);
                log.setModule(systemlog.module());
                log.setMethod(systemlog.methods());
                log.setLoginIp(getIp(request));
                log.setActionUrl(request.getRequestURI());
                
                try {
                    object = pjp.proceed();
                    log.setDescription("执行成功");
                    log.setState((short)1);
                } catch (Exception e) {
                    log.setDescription("执行失败");
                    log.setState((short)-1);
                    e.printStackTrace();
                }
                
            }else {//不包自定义注解
                object = pjp.proceed();
                log.setDescription("此操作不包含注解");
                log.setState((short)0);
            }
            
        }else {//不需要拦截
            object = pjp.proceed();
            log.setDescription("不需要拦截直接运行");
            log.setState((short)0);
        }
        
        return object;
    }
    
    /**
     *    获得ip地址
     *  @param request
     *  @return
     *  @author mgj 
     *    @date 2017-8-11 下午2:19:51
     */
    private String getIp(HttpServletRequest request){
        if (request.getHeader("x-forwarded-for") == null) {
            return request.getRemoteAddr();
        }
        return request.getHeader("x-forwarded-for");
    }
    
}


6.增加aop自动扫描配置

（1）打开spring-mvc.xml文件，增加aop上下文

   如下：
 <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:mvc="http://www.springframework.org/schema/mvc" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p" 
    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/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 
        http://www.springframework.org/schema/aop  
       http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  ">

（2）增加aop自动扫描并实例化bean
 <aop:aspectj-autoproxy proxy-target-class="true" />
<bean id="logAopAction" class="aop.LogAopAction"></bean>

7.持久化Log实体的xml配置，使用自动扫描class的形式进行配置。打开spring-mvc-hibernate.xml文件，增加<value>aop.</value>
<bean id="sessionFactory"
        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="entityInterceptor" ref="hiberAspect" />
        <property name="hibernateProperties">
            <props>
                <!--<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop> -->
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">false</prop>
                <prop key="hibernate.temp.use_jdbc_metadata_defaults">false</prop>
            </props>
        </property>
        <!-- 注解方式配置 -->
        <property name="packagesToScan">
            <list>
                <value>org.jeecgframework.web.system.pojo.*</value>
                <value>org.jeecgframework.web.demo.entity.*</value>
                <value>org.jeecgframework.web.test.entity.*</value>
                <value>org.jeecgframework.web.cgform.entity.*</value>
                <value>org.jeecgframework.web.cgreport.entity.*</value>
                <value>aop.</value>
            </list>
        </property>
</bean>

8.使用注解方式，配置日志，在访问的controller方法上，增加@SystemLog(module="区教师库登录",methods="区教师库的assessTeacherInfo()方法")配置
    /**
     * 教师库管理列表 页面跳转
     * 
     * @return
     */
    @RequestMapping(params = "assessTeacherInfo")
    @SystemLog(module="区教师库登录",methods="区教师库的assessTeacherInfo()方法")
    public ModelAndView assessTeacherInfo(HttpServletRequest request) {        
        return new ModelAndView("vote/backmanage/teachermanage/assessTeacherInfoList");
    }

9.效果



三、注意事项
         1.增加aop自动扫描包时，必须写到spring-mvc.xml内，不可写到spring-mvc-aop.xml文件中。因为spring-mvc.xml会比spring-mvc-aop.xml文先执行。
         2.持久化Log实体，使用自动扫描class的形式进行配置时，规则如下
（1）<value>aop.</value>，会解析为aop/*.class 或者 aop/xxx/*.class。即aop的包以及子包下的所有class。
            （2）<value>aop</value>，会解析为aop/*.class 。即aop的包下的所有class。
            （3）<value>aop.*</value>，会解析为 aop/xxx/*.class。即aop的子包下的所有class。

四、思考
1.需要深刻理解spring_mvc.xml文件的执行顺序。
2.需要深刻理解使用自动扫描class的形式的配置规则。


---------------------------------------------------------------------------

附录：

Log实体创建的mysql脚本：

drop table if exists assess_log_test;
 
create table  assess_log_test (
    id varchar(32) not null COMMENT '主键id',
    login_account varchar(32) default null comment '当前操作人',
    login_ip varchar(32) default null comment '登录ip',
    action_url varchar(100) default null comment '请求url',
    module varchar(32) default null comment '执行模块',
    method varchar(32) default null comment '执行方法',
    action_time bigint default 0 comment '执行操作时间',
    description varchar(200)    default null comment '描述',
    gmt_create  datetime default null comment '执行时间',
    state smallint(6) default null comment '操作状态',
  primary key (id)
)engine=innodb default charset=utf8  comment '操作日志表';