<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-logging</artifactId>
</dependency>

<?xml version="1.0" encoding="UTF-8"?>
<configuration  scan="true" scanPeriod="60 seconds" debug="false">
 <contextName>logback</contextName>
 <!--輸出到控制臺-->
 <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  <encoder>
   <!--<pattern>%d{HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>-->
   <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
<!--            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} -%5p ${PID:-} [%15.15t] %-30.30C{1.} : %m%n</pattern>-->
  </encoder>
 </appender>

 <!--按天生成日志-->
 <appender name="logFile"  class="ch.qos.logback.core.rolling.RollingFileAppender">
    <Prudent>true</Prudent> 
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
      <FileNamePattern>
     poslog/%d{yyyy-MM-dd}/%d{yyyy-MM-dd}.log
      </FileNamePattern>
      <maxHistory>7</maxHistory> 
    </rollingPolicy>
    <layout class="ch.qos.logback.classic.PatternLayout">
      <Pattern>
       %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n
      </Pattern>
    </layout>
 </appender>

 <root level="INFO">
  <appender-ref ref="console" />
  <appender-ref ref="logFile" />
 </root>

</configuration>

@SpringBootTest
public class LoggerTest {

    private static final Logger logger = LoggerFactory.getLogger(LoggerTest.class);

    @Test
    public void test() {
        logger.trace("trace 級別的日志");
        logger.debug("debug 級別的日志");
        logger.info("info 級別的日志");
        logger.warn("warn 級別的日志");
        logger.error("error 級別的日志");
    }
}

logging.file.name=info.log

logging.file.path=/workspace/log

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
 <!-- 日志存放路徑 -->
 <property name="log.path" value="d:/logback" />
 <!-- 日志輸出格式 -->
 <property name="log.pattern" value="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{20} - [%method,%line] - %msg%n" />

 <!-- 控制臺輸出 -->
 <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  <encoder>
   <pattern>${log.pattern}</pattern>
  </encoder>
 </appender>
 
 <!-- 系統(tǒng)日志輸出 -->
 <appender name="file_info" class="ch.qos.logback.core.rolling.RollingFileAppender">
  <file>${log.path}/sys-info.log</file>
  <!-- 循環(huán)政策：基于時間創(chuàng)建日志文件 -->
  <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
   <!-- 日志文件名格式 -->
   <fileNamePattern>${log.path}/sys-info.%d{yyyy-MM-dd}.log</fileNamePattern>
   <!-- 日志最大的歷史 60天 -->
   <maxHistory>60</maxHistory>
  </rollingPolicy>
  <encoder>
   <pattern>${log.pattern}</pattern>
  </encoder>
  <filter class="ch.qos.logback.classic.filter.LevelFilter">
   <!-- 過濾的級別 只會打印debug不會有info日志-->
<!--            <level>DEBUG</level>-->
   <!-- 匹配時的操作：接收（記錄） -->
   <onMatch>ACCEPT</onMatch>
   <!-- 不匹配時的操作：拒絕（不記錄） -->
   <onMismatch>DENY</onMismatch>
  </filter>
 </appender>
 
 <appender name="file_error" class="ch.qos.logback.core.rolling.RollingFileAppender">
  <file>${log.path}/sys-error.log</file>
  <!-- 循環(huán)政策：基于時間創(chuàng)建日志文件 -->
  <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
   <!-- 日志文件名格式 -->
   <fileNamePattern>${log.path}/sys-error.%d{yyyy-MM-dd}.log</fileNamePattern>
   <!-- 日志最大的歷史 60天 -->
   <maxHistory>60</maxHistory>
  </rollingPolicy>
  <encoder>
   <pattern>${log.pattern}</pattern>
  </encoder>
  <filter class="ch.qos.logback.classic.filter.LevelFilter">
   <!-- 過濾的級別 -->
   <level>ERROR</level>
   <!-- 匹配時的操作：接收（記錄） -->
   <onMatch>ACCEPT</onMatch>
   <!-- 不匹配時的操作：拒絕（不記錄） -->
   <onMismatch>DENY</onMismatch>
  </filter>
 </appender>
 
 <!-- 用戶訪問日志輸出  -->
 <appender name="sys-user" class="ch.qos.logback.core.rolling.RollingFileAppender">
  <file>${log.path}/sys-user.log</file>
  <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
   <!-- 按天回滾 daily -->
   <fileNamePattern>${log.path}/sys-user.%d{yyyy-MM-dd}.log</fileNamePattern>
   <!-- 日志最大的歷史 60天 -->
   <maxHistory>60</maxHistory>
  </rollingPolicy>
  <encoder>
   <pattern>${log.pattern}</pattern>
  </encoder>
 </appender>
 
 <!-- 系統(tǒng)模塊日志級別控制  -->
 <logger name="com.example" level="debug" />
 <!-- Spring日志級別控制  -->
 <logger name="org.springframework" level="warn" />

 <root level="info">
  <appender-ref ref="console" />
 </root>
 
 <!--系統(tǒng)操作日志-->
 <root level="info">
  <appender-ref ref="file_info" />
  <appender-ref ref=&##34;file_error" />
 </root>
 
 <!--系統(tǒng)用戶操作日志-->
 <logger name="sys-user" level="info">
  <appender-ref ref="sys-user"/>
 </logger>
</configuration> 

logging:
	level:
		com.example: info
		org.springframework: warn

#com.yoodb.study.demo04包下所有class以DEBUG級別輸出
logging.level.com.yoodb.study=DEBUG
#用來指定自己創(chuàng)建的日志文件
logging.config=classpath:logback-spring.xml
#指定輸出文件位置
logging.file.path=D://workspace/log

@RestController  
public class HelloWorldController {  
   
    protected static Logger logger=LoggerFactory.getLogger(HelloWorldController.class);  
       
    @RequestMapping("/")  
    public String helloworld(){  
        logger.debug("關(guān)注微信公眾號“Java精選”，Spring Boot系列文章持續(xù)更新中，帶你從入門到精通，玩轉(zhuǎn)Spring Boot框架。");  
        return "Hello world!";  
    }  
       
    @RequestMapping("/hello/{name}")  
    public String helloName(@PathVariable String name){  
        logger.debug("訪問 helloName,Name={}",name);  
        return "Hello "+name;  
    }  
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Loggable{
	
	String value() default "";
	//可以添加更多的配置屬性，如操作類型、級別
}

@Aspect
@Component
public class LoggingAspect{

	@Autowired
	private Logger logger;//SLF4j獲取
	
	@Around("@annotation(loggable)")
	public Object logBusinessOperation(Proceeding joinPoint,Loggable loggable)throws Throwable{
		
		//方法執(zhí)行前的邏輯，例如記錄開始事件、方法參數(shù)等
		long start = System.currentTimeMillis();
		try{
			Object result = jointPoint.proceed();//執(zhí)行目標(biāo)方法
			//方法執(zhí)行后的邏輯，例如記錄結(jié)束時間、返回值等
			return result;
		}catch(Exception e){
			// 異常處理邏輯，如記錄異常信息
        	throw e;
		}finally{
			long executionTime = System.currentTimeMillis() - start;
        	// 構(gòu)建日志信息并記錄
        	logger.info("{} executed in {} ms", joinPoint.getSignature(), executionTime);
		}
	}
}

@Configuration
@EnableAspectJAutoProxy
public class AopConfig{
	
	//可能還需要其他的配置或bean
}

public class SomeService{
	
	@Loggable
	public void someBusinessMethod(Object someParam){
		//業(yè)務(wù)邏輯
	}
}

@Repeatable(LogRecords.class)
@Target({ElementType.METHOD,ElmenetType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface LogRecord{
	
	String success();

	String fail() default "";

	String operator() default ""; //業(yè)務(wù)操作場景人

    String type(); // 業(yè)務(wù)場景 模塊范圍

    String subType() default ""; //業(yè)務(wù)子場景，主要是模塊下的功能范圍

    String bizNo(); //業(yè)務(wù)場景的業(yè)務(wù)編號，

    String extra() default "";//一些操作的擴展操作

    String actionType(); //業(yè)務(wù)操作類型，比如編輯、新增、刪除
}

public class LogRecordParser{
	
	public static Map<String,Object> parseLogRecord(Annotation logRecordAnnotation){

		Map<String,Object> result = new HashMap<>();
		
		ExpressionParser parser = new ExpressionParser(new SpelFunction("parseLogRecord", LogRecordParser.class, "parseLogRecord"));
		for(String attribute : logRecordAnnotation.getAttributeNames()){
			
			Object value = logRecordAnnotation.getAttribute(attribute);
			Expression expression = parser.parseExpression(attribute);
            TypeResolutionContext typeResolutionContext = new TypeResolutionContext();
            typeResolutionContext.setMethod(new Method(null, null, null));
            Object parsedValue = expression.getValue(typeResolutionContext);

            result.put(attribute, parsedValue);
		}
		
		return result;
	}
}

//部分的 binlog 數(shù)據(jù)變動結(jié)構(gòu)的 RowChange 定義如下：

@Data
public static class RowChange {
    private int tableId;
    private List<RowDatas> rowDatas;
    private String eventType;
    private boolean isDdl;
}

@Data
public static class RowDatas {
    private List<DataColumn> afterColumns;
    private List<DataColumn> beforeColumns;
}

@Data
public static class DataColumn {
    private int sqlType;
    private boolean isNull;
    private String mysqlType;
    private String name;
    private boolean isKey;
    private int index;
    private boolean updated;
    private String value;
}

mybatis-plus:
  type-aliases-package: quick.pager.shop.model
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      id-type: auto

logging:
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [${spring.application.name}] [traceId:%X{X-B3-TraceId}][spanId:%X{X-B3-SpanId}][parentSpanId:%X{X-B3-ParentSpanId}] --- [%t] - [%class:%method: %line] - %msg%n"
    file: "%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [${spring.application.name}] [traceId:%X{X-B3-TraceId}][spanId:%X{X-B3-SpanId}][parentSpanId:%X{X-B3-ParentSpanId}] --- [%t] - [%class:%method: %line] - %msg%n"
  level:
    org.springframework: error
    com.alibaba: error
    org.apache.ibatis: error
    io.seata: error
  file:
    path: ./logs/${spring.application.name}
    max-size: 50MB
    name: ${spring.application.name}

@Service
@Slf4j //lombok:1.18.12
public class GoodsSpuServiceImpl extends ServiceImpl<GoodsSpuMapper, GoodsSpu> implements GoodsSpuService {
	
	@Autowired
    private GoodsClassMapper goodsClassMapper;
    @Autowired
    private BannerClient bannerClient;

	@Override
	public Response<Long> create(GoodsSpuSaveRequest request){
	
		if(StringUtils.isBlank(request.getSpuName())){
			return Response.toError(ResponseStatus.Code.FAIL_CODE, "spu名稱不能為空！");
		}
		
		if(checkName(request.getSpuName(), null)){
			return Response.toError(ResponseStatus.Code.FAIL_CODE, "spu名稱已存在！");
		}

		GoodsSpu spu = this.conv(request);
        spu.setCreateTime(DateUtils.dateTime());
        spu.setDeleteStatus(Boolean.FALSE);
        if (this.baseMapper.insert(spu) > 0) {
            return Response.toResponse(spu.getId());
        }
		
		//添加日志
		log.error("新增SPU失敗 result = {}",JSON.toJSONString(request));

		return Response.toError(ResponseStatus.Code.FAIL_CODE, "新增SPU失敗");
	}

	@Override
	public Response<Long> delete(final Long id){
		int delete = this.baseMapper.deleteById(id);
		if(delete>0){
			return Response.toResponse(id);
		}

		//添加日志
		log.error("刪除SPU失敗 id={}",id);
		
		return Response.toError(ResponseStatus.Code.FAIL_CODE, "刪除SPU失敗");
	}
}

private Boolean checkName(final String name,final Long id){

	List<GoodsSpu> spus = this.baseMapper.selectList(new LambdaQueryWrapper<GoodsSpu>()
                .eq(GoodsSpu::getSpuName, name));

	if(CollectionUtils.isEmpty(spus)){
		return Boolean.FALSE;
	}

	return spus.stream()
		.filter(item->Objects.isNull(id)?Boolean.TRUE:IConsts.ZERO!=item.getId().compareTo(id))
		.anyMatch(item->item.getSpuName().equals(name));
}

/**
	自定義操作日志記錄注解
*/
@Target({ElementType.PARAMETER,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface OperLog{
	
	//模塊
	public String title() default "";

	//功能
	public BusinessType businessType() default BusinessType.OTHER;

	//操作人類別
	public OperatorType operatorType() default OperatorType.MANAGE;

	//是否保存請求的參數(shù)
	public boolean isSaveRequestData() default true;
}

/**
 * 業(yè)務(wù)操作類型
 *
 * @author ruoyi
 */
public enum BusinessType {
    /**
     * 其它
     */
    OTHER,

    /**
     * 新增
     */
    INSERT,

    /**
     * 修改
     */
    UPDATE,

    /**
     * 刪除
     */
    DELETE,

    /**
     * 授權(quán)
     */
    GRANT,

    /**
     * 導(dǎo)出
     */
    EXPORT,

    /**
     * 導(dǎo)入
     */
    IMPORT,

    /**
     * 強退
     */
    FORCE,

    /**
     * 生成代碼
     */
    GENCODE,

    /**
     * 清空
     */
    CLEAN,
}

/**
 * 操作人類別
 *
 * @author ruoyi
 */
public enum OperatorType {
    /**
     * 其它
     */
    OTHER,

    /**
     * 后臺用戶
     */
    MANAGE,

    /**
     * 手機端用戶
     */
    MOBILE
}

@Aspect
@Slf4j
@Document
public class OperLogAspect{
	
	//配置織入點（注解）
	@Pointcut("@annotation(com.ruoyi.system.log.annotation.OperLog)")
	public void logPointCut(){}
	
	//處理完請求后執(zhí)行
	@AfterReturning(pointcut = "logPointCut")
	public void doAfterReturning(JoinPoint joinPoint){
		handleLog(joinPoint,null);
	}

	//攔截異常操作
	@AfterThrowing(value = "logPointCut()",throwing = "e")
	public void doAfterThrowing(JoinPoint joinPoint,Exception e){
		handleLog(joinPoint,e);
	}

	protected void handleLog(final JoinPoint joinPoint,final Exception e){
	
		try{
			
			// 獲得注解
            com.ruoyi.system.log.annotation.OperLog controllerLog = getAnnotationLog(joinPoint);
            if (controllerLog == null) {
                return;
            }

			// *========數(shù)據(jù)庫日志=========*//
            OperLog operLog = new OperLog();
            operLog.setStatus(BusinessStatus.SUCCESS.ordinal());
            // 請求的地址
            HttpServletRequest request = ServletUtils.getRequest();
            String ip = IpUtils.getIpAddr(request);
            operLog.setOperIp(ip);
            operLog.setOperUrl(request.getRequestURI());
            operLog.setOperLocation(AddressUtils.getRealAddressByIP(ip));
            String username = request.getHeader(Constants.CURRENT_USERNAME);
            operLog.setOperName(username);
            if (e != null) {
                operLog.setStatus(BusinessStatus.FAIL.ordinal());
                operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000));
            }

			//設(shè)置方法名稱
			String className = joinPoint.getTarget().getClass().getName();
			Strng methodName = joinPoint.getSignature().getName();
			operLog.setMethod(className + "." + methodName + "()");
			
			//設(shè)置請求方式
			operLog.setRequestMethod(request.getMethod());
			//處理設(shè)置注解上的參數(shù)
			Object[] args = joinPoint.getArgs();
			getControllerMethodDescription(controllerLog, operLog, args);

			//發(fā)布事件
			SpringContextHolder.publishEvent(new OperLogEvent(operLog));
			
		}catch(Exception exp){
			//記錄本地異常日志
			log.error("==前置通知異常==");
			log.error("異常信息:{}", exp.getMessage());
            exp.printStackTrace();
		}
	}

	//是否存在注解，如果存在就獲取
	private com.ruoyi.system.log.annotation.OperLog getAnnotationLog(JoinPoint joinPoint) throws Exception {
		
		Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        if (method != null) {
            return method.getAnnotation(com.ruoyi.system.log.annotation.OperLog.class);
        }
        return null;
	}

	//獲取注解中對方法的描述信息，用于Controller層注解
	public void getControllerMethodDescription(com.ruoyi.system.log.annotation.OperLog log, OperLog operLog, Object[] args) 
												throws Exception {
		// 設(shè)置action動作
        operLog.setBusinessType(log.businessType().ordinal());
        // 設(shè)置標(biāo)題
        operLog.setTitle(log.title());
        // 設(shè)置操作人類別
        operLog.setOperatorType(log.operatorType().ordinal());
        // 是否需要保存request，參數(shù)和值
        if (log.isSaveRequestData()) {
            // 獲取參數(shù)的信息，傳入到數(shù)據(jù)庫中。
            setRequestValue(operLog, args);
        }
	}

	//獲取請求的參數(shù)，放到log中
	private void setRequestValue(OperLog operLog, Object[] args) throws Exception {
        List<?> param = new ArrayList<>(Arrays.asList(args)).stream().filter(p -> !(p instanceof ServletResponse))
                .collect(Collectors.toList());
        log.debug("args:{}", param);
        String params = JSON.toJSONString(param, true);
        operLog.setOperParam(StringUtils.substring(params, 0, 2000));
    }
}

/**
 * 客戶端工具類
 *
 * @author ruoyi
 */
public class ServletUtils {
    /**
     * 獲取String參數(shù)
     */
    public static String getParameter(String name) {
        return getRequest().getParameter(name);
    }

    /**
     * 獲取String參數(shù)
     */
    public static String getParameter(String name, String defaultValue) {
        return Convert.toStr(getRequest().getParameter(name), defaultValue);
    }

    /**
     * 獲取Integer參數(shù)
     */
    public static Integer getParameterToInt(String name) {
        return Convert.toInt(getRequest().getParameter(name));
    }

    /**
     * 獲取Integer參數(shù)
     */
    public static Integer getParameterToInt(String name, Integer defaultValue) {
        return Convert.toInt(getRequest().getParameter(name), defaultValue);
    }

    /**
     * 獲取request
     */
    public static HttpServletRequest getRequest() {
        return getRequestAttributes().getRequest();
    }

    /**
     * 獲取response
     */
    public static HttpServletResponse getResponse() {
        return getRequestAttributes().getResponse();
    }

    /**
     * 獲取session
     */
    public static HttpSession getSession() {
        return getRequest().getSession();
    }

    public static ServletRequestAttributes getRequestAttributes() {
        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
        return (ServletRequestAttributes) attributes;
    }

    /**
     * 將字符串渲染到客戶端
     *
     * @param response 渲染對象
     * @param string   待渲染的字符串
     * @return null
     */
    public static String renderString(HttpServletResponse response, String string) {
        try {
            response.setContentType("application/json");
            response.setCharacterEncoding("utf-8");
            response.getWriter().print(string);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 是否是Ajax異步請求
     *
     * @param request
     */
    public static boolean isAjaxRequest(HttpServletRequest request) {
        String accept = request.getHeader("accept");
        if (accept != null && accept.indexOf("application/json") != -1) {
            return true;
        }

        String xRequestedWith = request.getHeader("X-Requested-With");
        if (xRequestedWith != null && xRequestedWith.indexOf("XMLHttpRequest") != -1) {
            return true;
        }

        String uri = request.getRequestURI();
        if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml")) {
            return true;
        }

        String ajax = request.getParameter("__ajax");
        if (StringUtils.inStringIgnoreCase(ajax, "json", "xml")) {
            return true;
        }
        return false;
    }
}

/**
 * 獲取IP方法
 *
 * @author ruoyi
 */
public class IpUtils {

    public static String getIpAddr(HttpServletRequest request) {
        if (request == null) {
            return "unknown";
        }
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Forwarded-For");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Real-IP");
        }

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }

        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip.split(",")[0];
    }

    public static boolean internalIp(String ip) {
        byte[] addr = textToNumericFormatV4(ip);
        if (null != addr) {
            return internalIp(addr) || "127.0.0.1".equals(ip);
        }
        return false;
    }

    private static boolean internalIp(byte[] addr) {
        final byte b0 = addr[0];
        final byte b1 = addr[1];
        // 10.x.x.x/8
        final byte SECTION_1 = 0x0A;
        // 172.16.x.x/12
        final byte SECTION_2 = (byte) 0xAC;
        final byte SECTION_3 = (byte) 0x10;
        final byte SECTION_4 = (byte) 0x1F;
        // 192.168.x.x/16
        final byte SECTION_5 = (byte) 0xC0;
        final byte SECTION_6 = (byte) 0xA8;
        switch (b0) {
            case SECTION_1:
                return true;
            case SECTION_2:
                if (b1 >= SECTION_3 && b1 <= SECTION_4) {
                    return true;
                }
            case SECTION_5:
                switch (b1) {
                    case SECTION_6:
                        return true;
                }
            default:
                return false;
        }
    }

    /**
     * 將IPv4地址轉(zhuǎn)換成字節(jié)
     *
     * @param text IPv4地址
     * @return byte 字節(jié)
     */
    public static byte[] textToNumericFormatV4(String text) {
        if (text.length() == 0) {
            return null;
        }

        byte[] bytes = new byte[4];
        String[] elements = text.split("\\.", -1);
        try {
            long l;
            int i;
            switch (elements.length) {
                case 1:
                    l = Long.parseLong(elements[0]);
                    if ((l < 0L) || (l > 4294967295L)) {
                        return null;
                    }
                    bytes[0] = (byte) (int) (l >> 24 & 0xFF);
                    bytes[1] = (byte) (int) ((l & 0xFFFFFF) >> 16 & 0xFF);
                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 2:
                    l = Integer.parseInt(elements[0]);
                    if ((l < 0L) || (l > 255L)) {
                        return null;
                    }
                    bytes[0] = (byte) (int) (l & 0xFF);
                    l = Integer.parseInt(elements[1]);
                    if ((l < 0L) || (l > 16777215L)) {
                        return null;
                    }
                    bytes[1] = (byte) (int) (l >> 16 & 0xFF);
                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 3:
                    for (i = 0; i < 2; ++i) {
                        l = Integer.parseInt(elements[i]);
                        if ((l < 0L) || (l > 255L)) {
                            return null;
                        }
                        bytes[i] = (byte) (int) (l & 0xFF);
                    }
                    l = Integer.parseInt(elements[2]);
                    if ((l < 0L) || (l > 65535L)) {
                        return null;
                    }
                    bytes[2] = (byte) (int) (l >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 4:
                    for (i = 0; i < 4; ++i) {
                        l = Integer.parseInt(elements[i]);
                        if ((l < 0L) || (l > 255L)) {
                            return null;
                        }
                        bytes[i] = (byte) (int) (l & 0xFF);
                    }
                    break;
                default:
                    return null;
            }
        } catch (NumberFormatException e) {
            return null;
        }
        return bytes;
    }

    public static String getHostIp() {
        try {
            return InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
        }
        return "127.0.0.1";
    }

    public static String getHostName() {
        try {
            return InetAddress.getLocalHost().getHostName();
        } catch (UnknownHostException e) {
        }
        return "未知";
    }
}

/**
 * 獲取地址類
 *
 * @author ruoyi
 */
public class AddressUtils {
    private static final Logger log = LoggerFactory.getLogger(AddressUtils.class);

    public static final String IP_URL = "http://ip-api.com/json/%s?lang=zh-CN";

    public static String getRealAddressByIP(String ip) {
        String address = "XX XX";
        // 內(nèi)網(wǎng)不查詢
        if (IpUtils.internalIp(ip)) {
            return "內(nèi)網(wǎng)IP";
        }

        String rspStr = HttpUtil.get(String.format(IP_URL, ip));
        if (StringUtils.isEmpty(rspStr)) {
            log.error("獲取地理位置異常 {}", ip);
            return address;
        }

        JSONObject obj;
        try {
            obj = JSON.unmarshal(rspStr, JSONObject.class);
            address = obj.getStr("country") + "," + obj.getStr("regionName") + "," + obj.getStr("city");
        } catch (Exception e) {
            log.error("獲取地理位置異常 {}", ip);
        }
        return address;
    }

}

public class OperLogEvent extends ApplicationEvent {
    private static final long serialVersionUID = 8905017895058642111L;

    public OperLogEvent(OperLog source) {
        super(source);
    }
}

@Slf4j
@Service
@Lazy(false)
public class SpringContextHolder implements ApplicationContextAware,DisposableBean{
	
	private static ApplicationContext applicationContext = null;
	
	//取得存在在靜態(tài)變量中的ApplicationContext
	public static ApplicationCotnext getApplicationCotnext(){
		return applicationContext;
	}

	//實現(xiàn)ApplicationContextAware接口, 注入Context到靜態(tài)變量中
	@Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        SpringContextHolder.applicationContext = applicationContext;
    }

	//清除SpringContextHolder中的ApplicationContext為Null
	public static void clearHolder() {
        if (log.isDebugEnabled()) {
            log.debug("清除SpringContextHolder中的ApplicationContext:" + applicationContext);
        }
        applicationContext = null;
    }

	//發(fā)布事件   SpringContextHolder.publishEvent(new OperLogEvent(operLog));
	public static void publishEvent(ApplicationEvent event) {
        if (applicationContext == null) {
            return;
        }
        applicationContext.publishEvent(event);
    }

	//實現(xiàn)DisposableBean接口, 在Context關(guān)閉時清理靜態(tài)變量.
	@Override
    @SneakyThrows
    public void destroy() {
        SpringContextHolder.clearHolder();
    }

	//獲取運行環(huán)境
	public static String getActiveProfile() {
        return applicationContext.getEnvironment().getActiveProfiles()[0];
    }
}

//新增保存通知公告
@HasPermissions("system:notice:add")
@OperLog(title = "通知公告", businessType = BusinessType.INSERT)
@PostMapping("save")
public R addSave(@ReqeustBody Notice notice){

	notice.setParkId(getParkId());
	notice.setCreateBy(getLoginName());
	return toAjax(noticeService.insertNotice(notice));
}