精华内容
下载资源
问答
  • springboot中使用aop将操作日志记录到数据库
    千次阅读
    2019-08-06 16:45:51

    1.pom中引入aop依赖

    <!--spring切面aop依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    

    2.创建实体类

    import java.io.Serializable;
    
    /**
     * 日志表
     * */
    public class AdminLog implements Serializable {
    
        private static final long serialVersionUID = 7925874058046995566L;
    
        private String id;
        private String userId;//用户id 操作人ID
        private String userName;//用户名称 关联admin_user
        private String loginip;//登录ip
        private int type;//操作类型(0登录、1查询、2修改)
        private String url ; // 操作的url
        private String operation;//操作内容
        private String createtime;//操作时间
        private String remark;//备注
    	/**生成getter和setter方法 */
    

    3.自定义log注解

    import java.lang.annotation.*;
    
    /**
     * created by chen on 2019/8/6.
     * 配置自定义log注解类
     */
    @Target(ElementType.METHOD) //注解放置的目标位置,METHOD是可注解在方法级别上
    @Retention(RetentionPolicy.RUNTIME) //注解在哪个阶段执行
    @Documented //生成文档
    public @interface MyLog {
        /** 操作事件     */
        String operation () default "";
    
        /** 日志类型 */
        int type ();
    }
    

    4.创建aop切面实现类

    import com.***.admin.entity.AdminLog;
    import com.***.admin.entity.AdminUser;
    import com.***.util.UUIDUtil;
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    import org.aspectj.lang.JoinPoint;
    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.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 javax.servlet.http.HttpServletRequest;
    import java.lang.reflect.Method;
    import java.util.Date;
    
    /** 系统日志:切面处理类 */
    @Aspect
    @Component
    public class SysLogAspect {
    	/**我这里是使用log4j2把一些信息打印在控制台上面,可以不写 */
        private static final Logger log = LogManager.getLogger(SysLogAspect.class);
    
    	/**操作数据库 */
        @Autowired
        private MyLogMapper myLogMapper;
    
        //定义切点 @Pointcut
        //在注解的位置切入代码
        @Pointcut("@annotation(com.***.log.MyLog)")
        public void logPoinCut() {
        }
    
        //切面 配置通知
        @Before("logPoinCut()")         //AfterReturning
        public void saveOperation(JoinPoint joinPoint) {
            log.info("---------------接口日志记录---------------");
            //用于保存日志
            AdminLog adminLog = new AdminLog();
    
            //从切面织入点处通过反射机制获取织入点处的方法
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            //获取切入点所在的方法
            Method method = signature.getMethod();
    
            //获取操作--方法上的Log的值
            MyLog myLog = method.getAnnotation(MyLog.class);
            if (myLog != null) {
                //保存操作事件
                String operation = myLog.operation();
                adminLog.setOperation(operation);
    
                //保存日志类型
                int type = myLog.type();
                adminLog.setType(type);
    
                log.info("operation="+operation+",type="+type);
            }
    
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            String requestURL = request.getRequestURL().toString();
            adminLog.setUrl(requestURL);
            // 客户端ip
            String ip = request.getRemoteAddr();
            adminLog.setLoginip(ip);
            // 操作人账号、姓名(需要提前将用户信息存到session)
            AdminUser user = (AdminUser) request.getSession().getAttribute("user");
            if(user != null) {
                String userId = user.getId();
                String userName = user.getName();
                adminLog.setUserId(userId);
                adminLog.setUserName(userName);
            }
            log.info("url="+requestURL,"ip="+ip);
           
            //调用service保存Operation实体类到数据库
            //我id使用的是UUID,不需要的可以注释掉
            String id = UUIDUtil.getUUID();
            adminLog.setId(id);
            myLogMapper.insert(adminLog);
        }
    }
    

    5.mapper层将操作添加到数据库

    import com.***.admin.entity.AdminLog;
    import org.apache.ibatis.annotations.Insert;
    import org.apache.ibatis.annotations.Mapper;
    
    /**
     * created by Administrator on 2019/8/6.
     */
    @Mapper
    public interface MyLogMapper {
        @Insert("insert into admin_log" +
                " (id,user_id,user_name,loginip,type,url,operation,createtime,remark)" +
                " values" +
                " (#{id},#{userId},#{userName},#{loginip},#{type},#{url},#{operation},now(),#{remark})")
        void insert(AdminLog adminLog);
    }
    

    6.测试

    @RestController
    @RequestMapping("user")
    public class UserController {
    
        private static final Logger log = LogManager.getLogger(UserController.class);
    
        @Autowired
        private UserService userService;
      
        /*测试操作日志保存到数据库*/
        /*假装登录,将用户信息存到session(方法是我之前写的懒得改,所以直接取的第一条数据)*/
        @RequestMapping("/login")
        public List<AdminUser> login(HttpServletRequest request){
            List<AdminUser> user = userService.getUser();
            AdminUser user1 = user.get(0);
            request.getSession().setAttribute("user",user1);
            return user;
        }
        /*记录日志*/
        @MyLog(operation = "查询用户信息",type = 1)
        @RequestMapping("/log")
        public List<AdminUser> insertLog(HttpServletRequest request){
            List<AdminUser> user = userService.getUser();
            return user;
        }
    }
    

    然后是控制台打印信息
    在这里插入图片描述
    数据库信息
    在这里插入图片描述

    更多相关内容
  • 主要介绍了SpringBoot Logback日志记录到数据库的实现方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • C# 利用log4net 把日志写入到数据库
  • springboot 日志输出到数据库

    千次阅读 2019-12-21 20:04:04
    springboot日志输出到数据库 **************************** logback.xml配置 <appender name="mysql" class="ch.qos.logback.classic.db.DBAppender"> <connectionSource class="ch.qos.logba...

    springboot 日志输出到数据库

     

    *********************

    logback.xml配置

     

        <appender name="mysql" class="ch.qos.logback.classic.db.DBAppender">
            <connectionSource class="ch.qos.logback.core.db.DataSourceConnectionSource">
                <dataSource class="com.alibaba.druid.pool.DruidDataSource">
                    <url>jdbc:mysql://localhost:3306/log?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone=GMT%2B8</url>
                    <driverClassName>com.mysql.cj.jdbc.Driver</driverClassName>
                    <username>root</username>
                    <password>123456</password>
                </dataSource>
            </connectionSource>
        </appender>
    

     

    *********************

    数据库设置

     

    BEGIN;
    DROP TABLE IF EXISTS logging_event_property;
    DROP TABLE IF EXISTS logging_event_exception;
    DROP TABLE IF EXISTS logging_event;
    COMMIT;
    
    BEGIN;
    CREATE TABLE logging_event 
      (
        timestmp         BIGINT NOT NULL,
        formatted_message  TEXT NOT NULL,
        logger_name       VARCHAR(254) NOT NULL,
        level_string      VARCHAR(254) NOT NULL,
        thread_name       VARCHAR(254),
        reference_flag    SMALLINT,
        arg0              VARCHAR(254),
        arg1              VARCHAR(254),
        arg2              VARCHAR(254),
        arg3              VARCHAR(254),
        caller_filename   VARCHAR(254) NOT NULL,
        caller_class      VARCHAR(254) NOT NULL,
        caller_method     VARCHAR(254) NOT NULL,
        caller_line       CHAR(4) NOT NULL,
        event_id          BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY
      );
    COMMIT;
    
    
    BEGIN;
    CREATE TABLE logging_event_property
      (
        event_id       BIGINT NOT NULL,
        mapped_key        VARCHAR(254) NOT NULL,
        mapped_value      TEXT,
        PRIMARY KEY(event_id, mapped_key),
        FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
      );
    COMMIT;
    
    
    BEGIN;
    CREATE TABLE logging_event_exception
      (
        event_id         BIGINT NOT NULL,
        i                SMALLINT NOT NULL,
        trace_line       VARCHAR(254) NOT NULL,
        PRIMARY KEY(event_id, i),
        FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
      );
    COMMIT;

     

    *********************

    数据库插入示例

     

    logging_event

               

     

    logging_event_exception

                      

     

    logging_event_property

                      

     

     

    展开全文
  • 演示了java记录通过log4j2记录日志到mysql数据库
  • 详细介绍了log4j的使用方法,介绍了java中日志记录如何写入数据库,对于初学者来说很不错的一个文档
  • SpringBoot Aop 记录操作日志存入数据库 本文不探讨具体原理,只讲业务实现。我主要是将这个操作分为以下几步: 1.首先我们需要自定义一个操作注解来获取我们拦截的接口的相关信息 2.那么接下来就是这个操作注解放在...

    SpringBoot Aop 记录操作日志存入数据库

    本文不探讨具体原理,只讲业务实现。我主要是将这个操作分为以下几步:
    1.首先我们需要自定义一个操作注解来获取我们拦截的接口的相关信息
    在这里插入图片描述
    2.那么接下来就是这个操作注解放在哪里了
    在这里插入图片描述
    我们需要将该注解放在我们需要拦截的接口上,那这个接口具体属于哪个模块,我们就可以命名moduleName即模块名,option就是这个接口具体是干什么的。注意,所有加上该注解的接口如果被调用那么都会被拦截。
    3.接下来我们利用SpringAOP来拦截接口进行日志操作

        */**
         * @author : hao.wu
         * @Description :日志拦截器,切面处理类
         * @Date : Create in 14:32 2019/5/23
         * @Modified By:
         */
        @Aspect
        @Component
        public class LogInterceptor {
            @Autowired
            private CrmOperationLogService crmOperationLogService;
            @Around("@annotation(log)")
            public Object interceptorApplogic(ProceedingJoinPoint pj, OperationLog log) throws Throwable {
            	//这个Pojo是我日志记录的实体类
                OperationLogPojo operationLogPojo = new OperationLogPojo();
               //因为项目的权限控制用的是shiro,所以我这里的可以获取到操作人id,名字这段无关具体操作流程
                Subject subject = SecurityUtils.getSubject();
                UserInfoCommand user = (UserInfoCommand) subject.getSession().getAttribute(ConstantMsg.USER_LOGIN);
                Long userId = user.getId();
                String userName = user.getUserName();
                //获取到被拦截接口上注解的option
                String option = log.option();
                //***继续执行被拦截的接口,记住最后一定要返回这个结果***
                Object proceed = pj.proceed();
                //获取到拦截的接口的方法名
                String methodName = pj.getSignature().getName();
                MethodSignature signature = (MethodSignature) pj.getSignature();
                //被拦截的方法的参数名称数组
                String[] parameterNames = signature.getParameterNames();
                //被拦截的方法的参数值对象数组,这里我们将传入的参数转为json字符串格式便于存入数据库
                Object[] objects = pj.getArgs();
                StringBuilder args = new StringBuilder();
                for (int i = 0; i < objects.length; i++) {
                    String s = JSON.toJSONString(objects[i]);
                    if (i == objects.length - 1){
                        args.append(s);
                    }else {
                        args.append(s).append(",");
                    }
                }
                //给日志操作记录类赋值然后存入数据库
                operationLogPojo.setUserId(userId);
                operationLogPojo.setUserName(userName);
                //方法名
                operationLogPojo.setMethodName(methodName);
                //操作名
                operationLogPojo.setOperation(option);
                operationLogPojo.setOperationTime(new Date());
                //被拦截方法的传入的参数值
                operationLogPojo.setArgs(args.toString());
                crmOperationLogService.addOperationLog(operationLogPojo);
                return proceed;
            }
        }**
    

    4.那么最后我们来看一下数据库里的结果吧
    在这里插入图片描述
    第一次写博客,写的不好还请见谅。

    展开全文
  • Spring-Aop切面+自定义注解将日志记录存储到数据库

    万次阅读 多人点赞 2018-07-30 22:30:57
    SpringAop切面+自定义注解实现日志记录   在之前的SpringAop当中,实现了对service层的方法定义了切入点,从而在执行service层的方法的时候会自动加入事务,而这些操作,都是在配置文件当中去实现的;   在这...

    SpringAop切面+自定义注解实现日志记录

     

    在之前的SpringAop当中,实现了对service层的方法定义了切入点,从而在执行service层的方法的时候会自动加入事务,而这些操作,都是在配置文件当中去实现的;

     

    在这篇博文当中,会一不同的方式来实现日志事务的添加,用的式注解的方式,而且切入点和事务都是一起定义在切面类当中的;

     

    首先来说明一些概念:

     

    SpringAop 底层的原理就是动态代理,

     

    但是运行时织入的,也就是在用到目标类或者方法的时候,生成一个代理类,然后将配好的通知织入

     

    但就Aop而言的话它本身还有的方式就是,编译时织入,比如说是前置通知,当你编译了以后他就会织入到方法当中,所以你通过反射的方法去看的话会看到相应的生成代码

    ,还有就是在类加载期间织入的,

    但是就性能而言的,SpringAop的这种动态代理的方式,是有着较高的效率的;

    Spring提供了四种aop切面的支持

     

       基于代理的经典的pringAop

       纯POJO切面

       @AspectJ注解驱动切面//底层也是Spring的动态代理 只是参考了AspectJ的一些形式

       注入式Aspectj切面

    而本此使用的就是@AspectJ注解驱动切面的方式。

     

     

    1.要实现自定义注解的切面实现;

    首先我们要有一个自定义的注解,下面就是自定义注解的代码,关于自定义注解大家可以自己去了解,下面式创建过程:

     

    在创建类的时候选择Annotation这个注解方式,即可;

    下面是代码:

    我们在OperationLogger这样一个注解类中写如下代码:

    @Retention(RetentionPolicy.RUNTIME)//注解会在class中存在,运行时可通过反射获取
    @Target(ElementType.METHOD)//目标是方法
    public @interface OperationLogger
    {

        String modelName()
    default "";
    //
    首先是被调用的方法的名称,其默认值是“”
        String user();
    //
    接下了一个就是当前使用这个方法的用户是谁
        String option();
    //
    之后就是这个用户所做的是什么操作
    }

    其实这个类就是一个特殊的接口,只不过这个注解是声明在方法之上的;

     

    2.在我们定义好了注解之后我们还需要的就是一个切面类:

    我们将切面的名称命名为:SysLogAspect,在这个类当中我们将声明各种通知,以及处理通知的方法,并调用Logservice来实现将记录的日志写入到数据库当中,用到的就是反射的方法:

    下面是代码:

    首先声明这是一个事务切面
    @Aspect
    @Component

    让其被Spring容器去管理
    public class SysLogAspect
    {

    我们在这和切面当中声明服务层的接口,来实现将我们获取到的日志存入到数据库当中

        @Autowired
       
    private LoggerService loggerService;

    之后声明一个日志的对象
        private static final Logger logger =

    Logger.getLogger(SysLogAspect.class);


    然后配置切点,切点实在空方法上去配置的,当然这是简便写法,因为这样的话,后面方法上面的切面就直接可以用户这个空的方法名去代替这样就避免了重复去写契入点
        @Pointcut("@annotation(com.qf.annocation.OperationLogger)")
       
    public void controllerAspect()
        {
            System.
    out.println("我是一个切入点");
        }

    1)配置通知

        /**
         *
    前置通知(Before advice :在某连接点(JoinPoint)之前执行的通知,但这个通知不能阻止连接点前的执行。
         * @param joinPoint
        
    */

    前置通知的切入点就直接写的是之前声明切入点的方法
        @Before("controllerAspect()")
       
    public void doBefore(JoinPoint joinPoint)
        {
            System.
    out.println("=====SysLogAspect前置通知开始=====");

    //调用日志处理类去处理我们的日志
            handleLog(joinPoint, null);
        }

       
    /**
         *
    后通知(After advice :当某连接点退出的时候执行的通知(不论是正常返回还是异常退出)。
         * @param joinPoint
        
    */

    同样后置通知的切入点就直接写的是之前声明切入点的方法
        @AfterReturning(pointcut = "controllerAspect()")
       
    public void doAfter(JoinPoint joinPoint)
        {
            System.
    out.println("=====SysLogAspect后置通知开始=====");

    //调用日志处理类去处理我们的日志
            handleLog(joinPoint, null);
        }

       
    /**
         *
    抛出异常后通知(After throwing advice 在方法抛出异常退出时执行的通知。
         * @param joinPoint
        
    * @param e
        
    */

    异常通知,我们用value去接收切入点,

    这里解释一下当你的参数是一个的时候默认是用value去接收的参数是多个的时候必须做声明,因为是异常通知所需要一个异常注解在上面以便于记录
        @AfterThrowing(value = "controllerAspect()", throwing = "e")
       
    public void doAfter(JoinPoint joinPoint, Exception e)
        {


            System.out.println("=====SysLogAspect异常通知开始=====")

    //调用日志处理类去处理我们的日志,传入异常;
            handleLog(joinPoint, e);
          

        }

       
    /**
         *
    环绕通知(Around advice :包围一个连接点的通知,类似WebServlet规范中的FilterdoFilter方法。可以在方法的调用前后完成自定义的行为,也可以选择不执行。
         * @param joinPoint
        
    */

    然后是环绕通知对于环绕通知来说,它于其它的不同之处有两点:

    1. 参数是ProceedingJoinPoint
    2. 使用环绕通知的时候必须去手动执行方法,如果你不去执行方法,当你直接使用的是环绕通知的时候,它会将你日志注解声明之下的方法的返回值屏蔽这样前端是得不到数据的这样会造成一堆的问题,所以要手动去执行proceed方法

    3.     @Around("controllerAspect()")
         
      public Object doAround(ProceedingJoinPoint joinPoint)
          {
              Object proceed=
      null;
              System.
      out.println("=====SysLogAspect 环绕通知开始=====");

    //调用日志处理类去处理我们的日志
            handleLog(joinPoint, null);

           
    try {
                proceed = joinPoint.proceed();
               
    return proceed;
            }
    catch (Throwable throwable) {
                throwable.printStackTrace();
            }
           
    return null;
        }


       /**
     
       2* 日志处理方法
         *
         * @param
    joinPoint
        
    * @param e
        
    */
       
    private void handleLog(JoinPoint joinPoint, Exception e)
        {
           
    try
           
    {

    在这里我们首先根据得到的JoinPoint获得注解,具体调用的方法在下面:
                //获得注解,这是在
                OperationLogger logger = giveController(joinPoint);

    判断一下返回的是不是空值,防止出现空指针错误
                if (logger == null)
                {
                   
    return;
                }


    // 获取目标方法的签名

    String signature = joinPoint.getSignature().toString();

    //根据的带的签名去截取方法名

    String methodName =

    在目标方法的签名当中以最后一个点加1开始,以包裹参数的第一个尖括号结尾截取方法名

    signature.substring(signature.lastIndexOf(".")+1  

     

    signature.indexOf("("));

    当然这个变量并不会在这里用到
                String longTemp = joinPoint.getStaticPart().toLongString();

     

    再通过得到调用方法的目标对象,从而获取它的类名
                String classType =

    joinPoint.getTarget().getClass().getName();
    再通过反射来得到这个类对象
                Class<?> clazz = Class.forName(classType);
    得到它内部所有的方法
                Method[] methods = clazz.getDeclaredMethods();
                System.
    out.println("methodName: " + methodName);
    对得到的方法集合进行变脸
                for (Method method : methods)
                {

    如果以这个方法上面的注解值日志注解并且方法的名称是之前截取到的方法名
                    if (method.isAnnotationPresent(OperationLogger.class)


                            && method.getName().equals(methodName))
                    {

    这个时候就可以通过这个方法去获取其上面的注解
          我们将获取主借注解的功能封装成一个方法,将之前反射得到的类对象当作参数传递过去
                        String clazzName = clazz.getName();
                        System.
    out.println("clazzName: " + clazzName + ", methodName: "
                               
    + methodName);

    调用方法,在这里实现的就是对方法的遍历
                        String process = SysLogAspect.process(clazz);

    这里就调用我们的服务层去将得到的数据写入数据库
                        loggerService.addLogger(process,methodName);
                    }
                }

            }
    catch (Exception exp)
            {
               
    logger.error("异常信息:{}", exp);
                exp.printStackTrace();
            }
        }

       
    /**
         *
    获得注解
         * @param joinPoint
        
    * @return
        
    * @throws Exception
         */
       
    private static OperationLogger giveController(JoinPoint joinPoint) throws Exception
        {
          

    访问目标方法参数,有三种方法(实际有四种)

    1.joinpoint.getargs():获取带参方法的参数

    2.joinpoint.getTarget():.获取他们的目标对象信息

    3..joinpoint.getSignature():(signature是信号,标识的意思):获取被增强的方法相关信息

    Signature signature = joinPoint.getSignature();

    //将其强转为MethodSignature 在根据这个去得到具体使用的方法       

     

     

    MethodSignature methodSignature = (MethodSignature) signature;
            Method method = methodSignature.getMethod();

           
    if (method != null)
            {

    根据方法提供的方法去的到它上面的注解,参数就是我们的自定义注解的类对象

    在这里,参数是什么样的注解,你得到的就是相应注解的对象,接收的时候返回值类型也就是相应的类型
                return method.getAnnotation(OperationLogger.class);
            }
           
    return null;
        }

     

    被调用的方法,在这里获得方法上面的注解返回即可,这里由于我们的注解比较的少,所以我们直接返回的就是字符串,如果有多个,可以分装一个对象这里直接返回对像即可
        public static String process(Class clazz) {
           
    //找方法

            String modelName=null;
            Method[] methods = clazz.getMethods();
           
    for (Method method : methods) {
               
    OperationLogger annotation = method.getAnnotation(OperationLogger.class);//获取指定类型的注解
                //动态代理对象,

                if (annotation != null) {
                   
    //说明有注解
                    modelName = annotation.modelName();
                    String user = annotation.user();

                }
            }
           
    return modelName;
        }
    }

    以上就是我们的日志事务切面,以及对日志的处理都已经准备完毕

     

    准备好了注解以及事务切面之后,我们来写一个控制类

    再其上面声明我我们自定义的注解

    我们以得到数据库列表这个控制器为例

     

    之后我们就来编写服务层

    再得到参数之后将其直接插入数据库即可

     

    之后我们除了之前与SSM一样的配置意外,我们还应该对我们的注解开启扫描:

     

    在Springmvc的配置文件当中加尔u这两个即可;

     

    最后我们来测试的结果:

    以上就完成了通过springAop的日志事务来将我们用户的一步步操作注入到数据库当中,实现了,数据库存储操所日志的功能

     版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_42112846;

     

    展开全文
  • 实现laravel 插入操作日志到数据库

    千次阅读 2018-08-18 14:31:03
    将中间件注册 Kernel.php 文件 /** * The application's global HTTP middleware stack. * * 这些中间件是在对应用程序的每次请求中运行的 * * @var array */ protected $middleware = [ ........
  • 缺点:要针对每个不同的注解标志进行分别取注解标志,获取参数进行日志记录输出 1. 需要引用的依赖 <!--spring切面aop依赖--> <dependency> <groupId>org.springframework.boot</g...
  • 这是一个利用Nlog工具来对日志进行记录到数据库的一个简单的例子。有什么问题请联系微信号:CengYingjun
  • 第一步: 创建日志表 第二步: 添加aop依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> ...
  • log4j输出日志到数据库表中

    热门讨论 2012-11-08 13:57:28
    通过Log4j输出日志到数据库表中,有表的创建sql,是完整的一套代码,可以直接运行。
  • log4j将日志存储到数据库

    千次阅读 2017-07-18 11:40:40
    log4j是javaEE日志输出文件,通常情况下我们都是把log日志输出指定的日志文件中,在这儿我们使用log4j将日志存储mysql,oracle数据库表中,使用log4j前必须引入log4j.jar 和commons-logging.jar这两个jar包。...
  • log4j将记录日志保存到数据库

    千次阅读 2015-06-12 10:55:04
    log4j将记录日志保存到数据库  1、创建日志表 要把日志持久化,必须在数据库中创建一张用来存储日志信息的表,表内字段为日志 的一个主要属性包括:操作类,执行方法,打印时间,日志级别,日志内容。   CREATE...
  • 之前要做一个记录用户操作的日志记录,找了很多方法,最后选择使用spring AOP来实现。由于是要记录用户操作的日志,所以我使用的是返回通知(@AfterReturning),只有在前端调用了我后端的接口并成功返回,才调用我...
  • 二进制日志文件开启后,所有对数据库操作的记录均会被记录到此文件, 所以,当长时间开启之后,日志文件会变得很大,占用磁盘空间。 使用二进制日志文件恢复数据库 开启日志文件 mysql默认是不开启日志文件的功能的...
  • 如何查看mysql数据库操作记录日志

    千次阅读 2021-01-19 08:38:55
    1、首先确认你日志是否启用了mysql>show variables like 'log_bin'。2、如果启用了,即ON,那日志文件就在mysql的安装目录的data目录下。3、怎样知道当前的日志mysql> show master status。4、看二进制日志...
  • log4net mysql 加密 log4net调试日志
  • 使用logger日志将操作记录写入数据库

    千次阅读 热门讨论 2018-11-29 09:43:44
    之前做的一个项目有这么个要求,在日志管理系统里,需要将某些日志信息存储到数据库里,供用户、管理员查看分析。因此我就花了点时间搞了一下这一功能。 说白了就是在用户在调用某接口的时候,相应的会在数据库进行...
  • Javaweb记录日志到数据库和文件中

    千次阅读 2017-07-13 20:02:29
    =============jsp页面=================== ...*target: 记录到哪里(1=数据库(default),2=文件,3=数据库+文件) *type:日志种类(1=服务器运行日志(default),2=SQL日志,3=用户动作日志), *level:日志等级(1=普通(de
  • //如果是更新删除操作则存储到数据库里 if ( $action == 'update' || $action == 'delete' || $action == 'insert' && ! $patt ) { $actionModel = new ...
  • mysql数据库查看操作日志记录

    千次阅读 2021-02-18 11:27:29
    查看数据库表的创建时间 SELECT CREATE_TIME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='web_crawl_2021' AND TABLE_NAME='sys_user'; 三.查看biglog的日志文件 show master status; 四.查看...
  • 1.右键进入转换设置页面,选择日志表要放在哪个数据库几日志表名称 2.设置好后,点击下方的SQL按钮,会弹出创建表语句,执行即可
  • Log4j记录日志到数据库的一个实例

    千次阅读 2019-07-27 19:52:02
    无意中发现了一个巨牛的人工智能教程,忍不住分享一下给大家。...点这里可以跳转教程。 log4j的配置 #log4j.rootLogger=error,stdout,info,debug,error log4j.rootCategory=info,stdout,database log4j....
  • 某系统日志记录器要求支持多种日志记录方式,如文件记录、数据库记录等,且用户可以根据要求动态选择日志记录方式,现使用工厂方法模式设计该系统。 //日志记录接口:抽象产品 interface Logger{ public void ...
  • log4j2记录日志到数据库(完美支持mysql)1、首先创建存储日志的数据表ibs_log2、创建Log4j2.xml配置文件3、创建数据库连接类ConnectionFactory3.1 普通写法:3.2 调用配置好的连接池获取数据库连接(关键) ...
  • 日志框架Nlog之将日志输出到数据库

    千次阅读 热门讨论 2015-09-24 17:15:49
    那你也一定知道,我们本篇博客输出到数据库的关键点还是在配置文件的配置而已。为了本篇博客的完整性,大家再跟我一起熟悉一下整个过程。 第一步:添加对NLog的引用  具体步骤已经在上文中详细的写了。 请...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 545,784
精华内容 218,313
关键字:

日志记录到数据库

友情链接: GONGCHENG.rar