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

不念不忘少年蓝@ 2023-06-01 03:25 6阅读 0赞

转载;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.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 '操作日志表';

转载于:https://www.cnblogs.com/Jeely/p/11310490.html