系統需求分析

業務描述

用戶在sso-resource工程訪問我們的資源資料時,獲取用戶的行為日志資訊,然后傳遞給sso-system工程,將日志資訊存盤到資料庫.

業務架構分析

系統服務中的日志存盤設計

業務描述

本次設計中，系統服務負責將其它服務獲取的用戶行為日志寫入到資料庫，

Pojo邏輯實作

定義一個Log物件,用于在記憶體中存盤用戶行為日志資訊,例如:

package com.jt.system.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * 基于此物件封裝用戶行為日志?
 * 誰在什么時間執行了什么操作,訪問了什么方法,傳遞了什么引數,訪問時長是多少.
 */
@Data
@TableName("tb_logs")
public class Log implements Serializable {
    private static final long serialVersionUID = 3054471551801044482L;
    @TableId(type = IdType.AUTO)
    private Long id;
    private String username;
    private String operation;
    private String method;
    private String params;
    private Long time;
    private String ip;
    @TableField("createdTime")
    private Date createdTime;
    private Integer status;
    private String error;
}

Dao 邏輯實作

第一步:創建用戶行為日志資料層物件,用于處理資料持久化邏輯,例如

package com.jt.system.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.system.pojo.Log;
import org.apache.ibatis.annotations.Mapper;

/**
 * 用戶行為日志資料層物件
 */
@Mapper
public interface LogMapper extends BaseMapper<Log> {
}

第二步:定義單元測驗,對資料層方法進行單元測驗

package com.jt;

import com.jt.system.dao.LogMapper;
import com.jt.system.pojo.Log;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Date;

@SpringBootTest
public class LogMapperTests {
    @Autowired
    private LogMapper logMapper;
    @Test
    void testInsert(){
        //構建用戶行為日志物件(基于此物件存盤一些用戶行為日志,先用假資料)
        Log log=new Log();
        log.setUsername("cgb2107");
        log.setIp("192.168.100.200");
        log.setOperation("查詢資源");
        log.setMethod("pkg.ResourceController.doSelect");
        log.setParams("");
        log.setStatus(1);
        log.setTime(100L);
        log.setCreatedTime(new Date());
        //將日志持久化到資料庫
        logMapper.insert(log);
    }
}

Service邏輯實作

第一步:定義日志業務介面,例如:

package com.jt.system.service;
import com.jt.system.pojo.Log;
/**
 * 用戶行為日志業務邏輯介面定義
 */
public interface LogService {
    /**
     * 保存用戶行為日志.
     * @param log
     */
    void insertLog(Log log);
    //.....
}

第二步:定義日志業務介面實作類,例如:

package com.jt.system.service.impl;

import com.jt.system.dao.LogMapper;
import com.jt.system.pojo.Log;
import com.jt.system.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogMapper logMapper;
    /**
     * @Async描述的方法底層會異步執行(不由web服務執行緒執行,
     * 而是交給spring自帶的執行緒池中的執行緒去執行)但是@Async注解的
     * 應用有個前提,需要啟動類上啟動異步執行(添加@EnableAsync注解描述).
     * 優點:不會長時間阻塞web服務(例如tomcat)執行緒
     */
    @Async
    @Override
    public void insertLog(Log log) {
        logMapper.insert(log);
    }
}

Controller 邏輯實作

第一步:定義LogController物件,用于實作日志控制邏輯,例如:

package com.jt.system.controller;

import com.jt.system.pojo.Log;
import com.jt.system.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/log")
public class LogController {
    @Autowired
    private LogService logService;
    @PostMapping
    public void doInsertLog(@RequestBody Log log){
        logService.insertLog(log);
    }
}

第二步:啟動服務,基于postman進行訪問測驗,例如:

資源服務中行為日志操作設計

業務描述

在不修改目標業務方法代碼實作的基礎之上,訪問目標方法時,獲取用戶行為日志.

Pojo邏輯物件定義

定義日志物件，用戶封裝獲取到的用戶行為日志，例如：

package com.jt.resource.pojo;
import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * 基于此物件封裝用戶行為日志?
 * 誰在什么時間執行了什么操作,訪問了什么方法,傳遞了什么引數,訪問時長是多少.
 */
@Data
public class Log implements Serializable {
    private static final long serialVersionUID = 3054471551801044482L;
    private Long id;
    private String username;
    private String operation;
    private String method;
    private String params;
    private Long time;
    private String ip;
    private Date createdTime;
    private Integer status;
    private String error;
}

切入點注解定義

構建一個自定義注解,名字為RequiredLog,后續會基于此注解描述作為切入點,定義切入點方法.例如：

package com.jt.resource.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 定義RequiredLog注解,通過此注解對需要
 * 進行日志記錄的方法進行描述
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RequiredLog {
    String value() default "";
}

AOP方式獲取并記錄日志

定義一個日志切面,基于此切面中的通知方法實作用戶行為日志的獲取和記錄

package com.jt.resource.aspect;

import com.jt.resource.annotation.RequiredLog;
import com.jt.resource.pojo.Log;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import java.lang.reflect.Method;
import java.util.Date;

/**
 * @Aspect 注解描述的型別為一個切面型別,在此類中可以定義:
 * 1)切入點(切入擴展邏輯的位置~例如權限控制,日志記錄,事務處理的位置),在
 * @Aspect描述的類中,通常使用@Pointcut注解進行定義.使用切入點描述的方法為切入點方法.
 *
 * 2)通知方法(在切入點對應的目標方法執行前后要執行邏輯需要寫到這樣的方法中),在
 * @Aspect描述的類中,通過@Before,@After,@Aroud,@AfterReturning,@AfterThrowing
 * 這樣的注解進行描述.
 * a: @Before切入點方法執行之前執行
 * b: @After 切入點方法執行之后執行(不管切入點方法是否執行成功了,它都會執行)
 * c: @Aroud 切入點方法執行之前和之后都可以執行(最重要)
 * d: @AfterReturning 切入點方法成功執行之后執行
 * e: @AfterThrowing 切入點方法執行時出了例外會執行
 */
@Aspect
@Component
public class LogAspect {
    /**
     * @Pointcut 注解用于定義切入點,此注解中的內容為切入點運算式
     * @annotation 為注解方式的切入點運算式,此方式的運算式為一種細粒度的切入點運算式,
     * 因為它可以精確到方法,例如我們現在使用RequiredLog注解描述方法時,由它描述的方法
     * 就是一個切入點方法.
     */
    @Pointcut("@annotation(com.jt.resource.annotation.RequiredLog)")
    public void doLog(){
        //此方法中不需要寫任何內容,只負責承載@Pointcut注解
    }

    /**
     * @Around 注解描述的方法為Aspect中的一個環繞通知方法,在此方法
     * 內部可以控制對目標方法的呼叫.
     * @param joinPoint 連接點物件,此物件封裝了你要執行的切入點方法資訊,可以基于
     *           此物件對切入點方法進行反射呼叫
     * @return 目標執行鏈中切入點方法的回傳值.
     * @throws Throwable
     */
    @Around("doLog()")
    public Object doAround(ProceedingJoinPoint joinPoint)throws Throwable{
        int status=1;//狀態
        String error=null;//錯誤資訊
        long time=0l;//執行時長
        long t1=System.currentTimeMillis();
        try {
            //手動呼叫目標執行鏈(這個執行鏈中包含切入點方法~目標方法)
           Object result = joinPoint.proceed();
           long t2=System.currentTimeMillis();
           time=t2-t1;
           return result;
        }catch (Throwable e){
           long t3=System.currentTimeMillis();
           time=t3-t1;
           status=0;
           error=e.getMessage();
           throw e;
        }finally {
           saveLog(joinPoint,time,status,error);
        }
    }
    //存盤用戶行為日志
    private void saveLog(ProceedingJoinPoint joinPoint,long time,
                         int status,String error)throws Throwable{
        //1.獲取用戶行為日志
        //1.1獲取目標物件型別(切入點方法所在類的型別)
        Class<?> targetClass = joinPoint.getTarget().getClass();
        //1.2.獲取目標方法
        //1.2.1獲取方法簽名(包含方法資訊,....)
        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        //1.2.2獲取方法物件
        Method targetMethod=
                targetClass.getDeclaredMethod(signature.getName(),signature.getParameterTypes());
        //1.3獲取方法上的RequiredLog注解內容
        //1.3.1獲取目標方法上注解
        RequiredLog requiredLog=targetMethod.getAnnotation(RequiredLog.class);
        //1.3.2獲取注解中的內容(這個內容為我們定義的操作名)
        String operation=requiredLog.value();
        //1.4獲取目標方法名(類名+方法名)
        String targetMethodName=targetClass.getName()+"."+targetMethod.getName();
        //1.5獲取目標方法執行時傳入的引數
        String params=new ObjectMapper().writeValueAsString(joinPoint.getArgs());
        //1.6獲取登錄用戶名(參考了Security官方的代碼)
        String username=(String)
                SecurityContextHolder.getContext()
                        .getAuthentication()
                        .getPrincipal();
        //1.7獲取ip地址(從當前執行緒獲取request物件,然后基于request獲取ip地址)
        //String ip="192.168.1.100";
        ServletRequestAttributes requestAttributes =
        (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        String ip=requestAttributes.getRequest().getRemoteAddr();
        //2.將用戶行為日志,封裝到Log物件
        Log logInfo=new Log();
        logInfo.setIp(ip);//后續獲取
        logInfo.setUsername(username);
        logInfo.setOperation(operation);
        logInfo.setMethod(targetMethodName);
        logInfo.setParams(params);
        logInfo.setTime(time);
        logInfo.setStatus(status);
        logInfo.setError(error);
        logInfo.setCreatedTime(new Date());
        System.out.println("logInfo="+logInfo);
    }

}

啟動服務進行訪問測驗

依次啟動nacos,sso-system,sso-auth,sso-resource,sso-gateway,sso-ui工程服務，然后執行登陸，登陸成功后查詢我的資源，檢測日志輸出，

服務中AOP技術應用原理分析

AOP是一種設計思想，它要實作的功能就是"錦上添花",就是在盡量不修改原有目標方法的基礎上，添加一些擴展功能，例如日志的記錄，權限的控制，事務的控制，異步任務的執行等等，其應用原理如圖所示：

說明：當我們在專案中定義了AOP切面以后，系統啟動時，會對有@Aspect注解描述的類進行加載分析，基于切入點的描述為目標型別物件，創建代理物件，并在代理物件內部創建一個執行鏈，這個執行鏈中包含攔截器（封裝了切入點資訊），通知（Around，…），目標物件等，我們請求目標物件資源時，會直接按執行鏈的順序對資源進行呼叫，

Feign方式將日志傳遞給系統服務

第一步：確保sso-resource工程中添加了openfeign依賴，例如：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

第二步：確保sso-resource工程的啟動上添加了@EnableFeignClients注解，例如：

package com.jt;

@EnableFeignClients
@SpringBootApplication
public class ResourceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ResourceApplication.class, args);
    }
}

第三步:定義日志遠程服務呼叫介面，例如：

package com.jt.resource.service;
import com.jt.resource.pojo.Log;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

@FeignClient(value = "sso-system",contextId = "remoteLogService")
public interface RemoteLogService {
     @PostMapping("/log")
     public void insertLog(@RequestBody Log log);
}

第四步：在LogAspect類中注入RemoteLogService物件，并通過此物件將日志物件傳遞到sso-system服務

@Autowired
private RemoteLogService remoteLogService;
....

第五步：依次啟動服務進行訪問測驗，