springboot配置slf4j+logback

清疚 2023-06-16 10:54 43阅读 0赞

pom.xml配置

<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.10</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.1.2</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-core</artifactId>
        <version>1.1.2</version>
    </dependency>

在resources下面创建logback.xml,springboot启动会自动加载logback.xml

<?xml version="1.0" encoding="UTF-8"?>
    <configuration>
        
    
        <property name="log.path" value="./logs/" /> 
        <property name="log.infofile.name" value="rest.info" />
        <property name="log.errorfile.name" value="rest.error" />
    
        
        <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
            <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
                
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            </encoder>
        </appender>
    
        <appender name="info" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>${log.path}/${log.infofile.name}.log</file>
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>INFO</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <encoder>
                <pattern>
                    %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread]  %-5level %logger{50} - %msg%n
                </pattern>
            </encoder>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${log.path}/${log.infofile.name}.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>10MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
            </rollingPolicy>
        </appender>
    
        <appender name="error" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>${log.path}/${log.errorfile.name}.log</file>
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>ERROR</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <encoder>
                <pattern>
                    %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread]  %-5level %logger{50} - %msg%n
                </pattern>
            </encoder>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${log.path}/${log.errorfile.name}.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>10MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
            </rollingPolicy>
        </appender>
    
    
        <root level="INFO">
            <appender-ref ref="CONSOLE"/>
            <appender-ref ref="info"/>
            <appender-ref ref="error"/>
        </root>
    
    </configuration>

创建BaseController

package com.ws.ww.controller;
    
    
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    
    public class BaseController {
        protected final Log logger= LogFactory.getLog(getClass());
    }

测试

package com.ws.ww.controller;
    
    import com.ws.ww.pojo.Video;
    import com.ws.ww.service.videoService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.time.LocalDateTime;
    @RestController
    @RequestMapping("/video/")
    public class videoController extends BaseController {
    @Autowired
    videoService videoServices;
    
        @RequestMapping("/videoid/{conId}")
        public  Video getVideoById(@PathVariable Integer conId) {
            Video video= videoShared.videoMap.get(1);
            try {
                logger.info("info日志信息");
              
            } catch (Exception e) {
                logger.error(e.getMessage());
            }
            return video;
        }
    
    }

配置拦截请求方法

创建http拦截器

import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    import com.example.demo.util.DateUtil;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.ModelAndView;
    import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.util.Enumeration;
    import java.util.LinkedHashMap;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * @author dongdingzhuo
     * @description: 请求拦截器
     * @datetime 2020/4/7 16:19
     */
    public class RequestInterceptor extends HandlerInterceptorAdapter {
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
    //    private final NamedThreadLocal<Long> startTimeThreadLocal = new NamedThreadLocal<>("StopWatch-StartTime");
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
    //        //客户端IP
    //        String ip = IpUtil.getIpAddress(request);
            //请求路径
            String uri = request.getRequestURI();
            //请求参数
            String params = getParamsStr(request);
            //请求方法
            String method = request.getMethod();
            //请求头
            Map<String, String> heads = new LinkedHashMap<>();
            Enumeration<String> headerNames = request.getHeaderNames();
            while (headerNames.hasMoreElements()) {
                String headerName = headerNames.nextElement();
                heads.put(headerName, request.getHeader(headerName));
            }
            //请求时间
            String requestTime = DateUtil.currentDateTimeStr2();
            Map<String, Object> map = new LinkedHashMap<>();
            map.put("uri", uri);
            map.put("params", params);
            map.put("method", method);
            map.put("requestTime", requestTime);
    //        map.put("ip", ip);
            map.put("heads", heads);
            logger.info(JSON.toJSONString(map, SerializerFeature.DisableCircularReferenceDetect, SerializerFeature.WriteMapNullValue));
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
    
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
    
        }
    
        private String getParamsStr(HttpServletRequest request) {
            StringBuilder result = new StringBuilder();
            Map<String, String[]> paramsMap = request.getParameterMap();
            Set<Map.Entry<String, String[]>> entrySet = paramsMap.entrySet();
            for (Map.Entry<String, String[]> entry : entrySet) {
                String key = entry.getKey();
                String[] values = entry.getValue();
                if (values != null) {
                    for (String value : values) {
                        result.append(String.format("&%s=%s", key, value));
                    }
                } else {
                    result.append(String.format("&%s=%s", key, ""));
                }
            }
            return result.toString().replaceFirst("&", "");
        }
    }

DateUtil

import java.text.DateFormat;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.time.Instant;
    import java.time.LocalDateTime;
    import java.time.ZoneOffset;
    import java.time.format.DateTimeFormatter;
    import java.util.ArrayList;
    import java.util.Calendar;
    import java.util.Date;
    import java.util.List;
    
    /**
     * @author dongdingzhuo
     * @description: 日期时间工具类
     * @datetime 2020/4/2 10:44
     */
    public class DateUtil {
        /**
         * 日期时间转换为字符串格式
         *
         * @param source  待处理的日期
         * @param pattern 转换的格式
         * @return
         */
        public static String dateToStr(LocalDateTime source, String pattern) {
            return source.format(DateTimeFormatter.ofPattern(pattern));
        }
    
        public static String longToDate(long time, String pattern) {
            SimpleDateFormat sdf = new SimpleDateFormat(pattern);
            Date date = new Date(time);
            return sdf.format(date);
        }
    
        /**
         * 字符串转换为日期格式
         *
         * @param source  待处理的字符串
         * @param pattern 转换的格式
         * @return
         */
        public static LocalDateTime strToDate(String source, String pattern) {
            return LocalDateTime.parse(source, DateTimeFormatter.ofPattern(pattern));
        }
    
        /**
         * 字符串转换为时间戳
         *
         * @param source
         * @param pattern
         * @return
         */
        public static long strToLong(String source, String pattern) {
            LocalDateTime localDateTime = strToDate(source, pattern);
            return localDateTime.toEpochSecond(ZoneOffset.of("+8"));
        }
    
        /**
         * 当前日期时间(yyyyMMddHHmmss)
         *
         * @return
         */
        public static String currentDateTimeStr() {
            return dateToStr(LocalDateTime.now(), "yyyyMMddHHmmss");
        }
    
        /**
         * 当前日期时间(yyyy-MM-dd HH:mm:ss)
         *
         * @return
         */
        public static String currentDateTimeStr2() {
            return dateToStr(LocalDateTime.now(), "yyyy-MM-dd HH:mm:ss");
        }
    
        /**
         * 当前年(yyyy)
         *
         * @return
         */
        public static String currentYearStr() {
            return dateToStr(LocalDateTime.now(), "yyyy");
        }
    
        /**
         * 当前年月(yyyyMM)
         *
         * @return
         */
        public static String currentYearMonthStr() {
            return dateToStr(LocalDateTime.now(), "yyyyMM");
        }
    
        /**
         * 当前日期(yyyyMMdd)
         *
         * @return
         */
        public static String currentDateStr() {
            return dateToStr(LocalDateTime.now(), "yyyyMMdd");
        }
    
        /**
         * 当前日期(yyyy-MM-dd)
         *
         * @return
         */
        public static String currentDateStr2() {
            return dateToStr(LocalDateTime.now(), "yyyy-MM-dd");
        }
    
        /**
         * 当前日期(yyMMdd)
         *
         * @return
         */
        public static String currentSimpleDateStr() {
            return dateToStr(LocalDateTime.now(), "yyMMdd");
        }
    
        /**
         * 当前时间戳(毫秒)
         *
         * @return
         */
        public static long currentMillis() {
            return Instant.now().toEpochMilli();
        }
    
        /**
         * 当前时间戳(秒)
         *
         * @return
         */
        public static long currentSeconds() {
            return Instant.now().getEpochSecond();
        }
    
        /**
         * 当前星期(0代表星期日)
         *
         * @return
         */
        public static int currentWeek() {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(new Date());
            return calendar.get(Calendar.DAY_OF_WEEK) - 1;
        }
    
        /**
         * 增加天数
         *
         * @param days
         * @return
         */
        public static String addDay(int days) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(new Date());
            calendar.add(Calendar.DAY_OF_YEAR, days);
            long time = calendar.getTime().getTime();
            return longToDate(time, "yyyy-MM-dd");
        }
    
        /**
         * 增加天数
         *
         * @param days
         * @return
         */
        public static String addDay(String date, String format, int days) {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            try {
                Date parse = sdf.parse(date);
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(parse);
                calendar.add(Calendar.DAY_OF_YEAR, days);
                return sdf.format(calendar.getTime());
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 增加半小时
         *
         * @param sourceTime
         * @return
         */
        public static String addHalfHour(String sourceTime) {
            String[] split = sourceTime.split(":");
            int hour = Integer.parseInt(split[0]);
            int minute = Integer.parseInt(split[1]);
            if (minute == 30) {
                return (hour < 9 ? "0" + (hour + 1) : (hour + 1)) + ":" + "00";
            }
            return (hour < 10 ? ("0" + hour) : hour) + ":" + "30";
        }
    
    
        /**
         * 时间转换为cron表达式
         *
         * @param s      需要转换的日期时间(yyyy-MM-dd HH:mm:ss)
         * @param field  需要增加的天数/小时数/分钟数/秒数...
         * @param amount 需要增加的具体数目
         * @return
         */
        public static String convertOnceCron(String s, int field, int amount) {
            Calendar calendar = Calendar.getInstance();
            if (s == null) {
                calendar.setTime(new Date());
            } else {
                SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                try {
                    calendar.setTime(dateFormat.parse(s));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }
            calendar.add(field, amount);
            SimpleDateFormat sdf = new SimpleDateFormat("s m H d M ? yyyy");
            return sdf.format(calendar.getTime());
        }
    
        /**
         * 获取开始结束日期之间的所有日期
         *
         * @param startDate 开始日期(yyyyMMdd)
         * @param endDate   结束日期(yyyyMMdd)
         * @return
         */
        public static List<String> getDays(String startDate, String endDate) {
            // 返回的日期集合
            List<String> days = new ArrayList<>();
            DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
            try {
                Date start = dateFormat.parse(startDate);
                Date end = dateFormat.parse(endDate);
                Calendar tempStart = Calendar.getInstance();
                tempStart.setTime(start);
                Calendar tempEnd = Calendar.getInstance();
                tempEnd.setTime(end);
                tempEnd.add(Calendar.DATE, +1);
                while (tempStart.before(tempEnd)) {
                    days.add(dateFormat.format(tempStart.getTime()));
                    tempStart.add(Calendar.DAY_OF_YEAR, 1);
                }
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return days;
        }
    
    
    }

mvc拦截器

import com.example.demo.interceptor.RequestInterceptor;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    /**
     * @author WS
     * @description: 项目相关配置
     * @datetime 2020/4/7 16:28
     */
    @Configuration
    public class WebConfig implements WebMvcConfigurer {
    
    //    @Bean
    //    public TokenInterceptor tokenInterceptor() {
    //        return new TokenInterceptor();
    //    }
    //
    //    @Bean
    //    public VisitorInterceptor visitorInterceptor() {
    //        return new VisitorInterceptor();
    //    }
    //
    //    @Bean
    //    public IpBlackListInterceptor ipBlackListInterceptor() {
    //        return new IpBlackListInterceptor();
    //    }
    
        private final String[] SKIP_PATH = {
                "/error",
                "/login",
                "/smsLogin",
                "/passwordLogin",
                "/register",
                "/sms/getCode",
                "/fileUpload",
                "/refreshToken",
                "/favicon.ico"
        };
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            registry.addInterceptor(new RequestInterceptor());
    //        registry.addInterceptor(tokenInterceptor()).excludePathPatterns(SKIP_PATH);
    //        registry.addInterceptor(visitorInterceptor()).excludePathPatterns(SKIP_PATH);
    //        registry.addInterceptor(ipBlackListInterceptor()).excludePathPatterns(
    //                "/error",
    //                "/favicon.ico"
    //        );
        }
    }

打印出的日志在项目跟目录Logs文件夹里