[Frühling] AOP implementiert das Ausfüllen öffentlicher Felder

Inhaltsverzeichnis

1. Öffentliche Felder werden automatisch ausgefüllt

1.1 Problemanalyse

1.2 Umsetzungsideen

1.3 Code-Entwicklung

1.3.1 Schritt 1

1.3.2 Schritt 2

1.3.3 Schritt 3

1.4 Funktionstest

1.5 Code-Einreichung

1. Öffentliche Felder werden automatisch ausgefüllt

1.1 Problemanalyse

Im vorherigen Kapitel haben wir die Entwicklung der Mitarbeiterverwaltungsfunktion und der Gerichtsklassifizierungsfunktion des Backend-Systems abgeschlossen . Beim Hinzufügen von Mitarbeitern oder beim Hinzufügen neuer Gerichtskategorien müssen wir die Erstellungszeit, den Ersteller, die Änderungszeit, die Änderungsperson usw. festlegen Felder. Beim Bearbeiten von Mitarbeitern oder beim Bearbeiten von Gerichtkategorien müssen Felder wie Änderungszeit und Modifikator festgelegt werden. Diese Felder sind öffentliche Felder, d. h. diese Felder sind in vielen Tabellen in unserem System zu finden, wie folgt:

Seriennummer	Feldname	Bedeutung	Art der Daten
1	Zeit schaffen	Erstellungszeitpunkt	Terminzeit
2	create_user	Ersteller-ID	bigint
3	Updatezeit	Ändern Sie die Zeit	Terminzeit
4	update_user	Personen-ID ändern	bigint

Für diese Felder lautet unsere Zuweisungsmethode:

1) Wenn Sie neue Daten hinzufügen, legen Sie „createTime“ und „updateTime“ auf die aktuelle Zeit und „createUser“ und „updateUser“ auf die aktuelle Anmeldebenutzer-ID fest.

2) Wenn Sie Daten aktualisieren, setzen Sie updateTime auf die aktuelle Zeit und updateUser auf die aktuelle Login-Benutzer-ID.

Derzeit werden bei der Verarbeitung dieser Felder in unserem Projekt Zuweisungsvorgänge in jeder Geschäftsmethode wie folgt durchgeführt:

So fügen Sie neue Mitarbeiter hinzu:

/**
     * 新增员工
     *
     * @param employeeDTO
     */
    public void save(EmployeeDTO employeeDTO) {
        //.......................
		//
        //设置当前记录的创建时间和修改时间
        employee.setCreateTime(LocalDateTime.now());
        employee.setUpdateTime(LocalDateTime.now());

        //设置当前记录创建人id和修改人id
        employee.setCreateUser(BaseContext.getCurrentId());//目前写个假数据，后期修改
        employee.setUpdateUser(BaseContext.getCurrentId());
		///
        employeeMapper.insert(employee);
    }

Mitarbeitermethode bearbeiten:

/**
     * 编辑员工信息
     *
     * @param employeeDTO
     */
    public void update(EmployeeDTO employeeDTO) {
       //........................................
	   ///
        employee.setUpdateTime(LocalDateTime.now());
        employee.setUpdateUser(BaseContext.getCurrentId());
       ///

        employeeMapper.update(employee);
    }

Neue Methode zur Klassifizierung von Gerichten hinzugefügt:

/**
     * 新增分类
     * @param categoryDTO
     */
    public void save(CategoryDTO categoryDTO) {
       //....................................
       //
        //设置创建时间、修改时间、创建人、修改人
        category.setCreateTime(LocalDateTime.now());
        category.setUpdateTime(LocalDateTime.now());
        category.setCreateUser(BaseContext.getCurrentId());
        category.setUpdateUser(BaseContext.getCurrentId());
        ///

        categoryMapper.insert(category);
    }

Ändern Sie die Klassifizierungsmethode für Gerichte:

/**
     * 修改分类
     * @param categoryDTO
     */
    public void update(CategoryDTO categoryDTO) {
        //....................................
        
		//
        //设置修改时间、修改人
        category.setUpdateTime(LocalDateTime.now());
        category.setUpdateUser(BaseContext.getCurrentId());
        //

        categoryMapper.update(category);
    }

Wenn diese öffentlichen Felder gemäß der oben genannten Operationsmethode verarbeitet werden, muss die Operation in jeder Geschäftsmethode ausgeführt werden, und die Codierung ist relativ redundant und umständlich. Können diese öffentlichen Felder irgendwo einheitlich verarbeitet werden, um die Entwicklung zu vereinfachen?

Die Antwort lautet: Ja, wir verwenden die AOP-Aspektprogrammierung, um eine Funktionserweiterung zu erreichen und die automatische Füllfunktion öffentlicher Felder zu vervollständigen.

1.2 Umsetzungsideen

Bei der Implementierung des automatischen Ausfüllens öffentlicher Felder, dh beim Zuweisen bestimmter Werte zu bestimmten Feldern beim Einfügen oder Aktualisieren, besteht der Vorteil darin, dass diese Felder einheitlich verarbeitet werden können, wodurch eine Duplizierung des Codes vermieden wird. In der obigen Problemanalyse haben wir erwähnt, dass es vier öffentliche Felder gibt, denen beim neuen Hinzufügen/Aktualisieren Werte zugewiesen werden müssen. Die spezifische Situation ist wie folgt:

Seriennummer	Feldname	Bedeutung	Art der Daten	Operationstyp
1	Zeit schaffen	Erstellungszeitpunkt	Terminzeit	einfügen
2	create_user	Ersteller-ID	bigint	einfügen
3	Updatezeit	Ändern Sie die Zeit	Terminzeit	einfügen, aktualisieren
4	update_user	Personen-ID ändern	bigint	einfügen, aktualisieren

Umsetzungsschritte:

1) Benutzerdefinierte Annotation AutoFill, die zur Identifizierung von Methoden verwendet wird, die das automatische Ausfüllen öffentlicher Felder erfordern.

2) Passen Sie die Aspektklasse AutoFillAspect an, um Methoden mit AutoFill-Annotationen einheitlich abzufangen und öffentlichen Feldern durch Reflektion Werte zuzuweisen.

3) Fügen Sie der Mapper-Methode eine AutoFill-Annotation hinzu

Um die oben genannten Schritte umzusetzen, müssen Sie die folgenden Kenntnisse beherrschen (alles in früheren Kursen gelernt):

Technische Punkte: Aufzählung, Anmerkungen, AOP, Reflexion

1.3 Code-Entwicklung

Implementieren Sie es nacheinander gemäß den im vorherigen Abschnitt analysierten Implementierungsschritten, insgesamt drei Schritte.

1.3.1 Schritt 1

Benutzerdefinierte Anmerkung AutoFill

Geben Sie das Sky-Server-Modul ein und erstellen Sie das Paket com.sky.annotation.

package com.sky.annotation;

import com.sky.enumeration.OperationType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义注解，用于标识某个方法需要进行功能字段自动填充处理
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoFill {
    //数据库操作类型：UPDATE INSERT
    OperationType value();
}

Wo OperationType im Sky-Common-Modul definiert wurde

package com.sky.enumeration;

/**
 * 数据库操作类型
 */
public enum OperationType {

    /**
     * 更新操作
     */
    UPDATE,

    /**
     * 插入操作
     */
    INSERT
}

1.3.2 Schritt 2

Benutzerdefinierter Aspekt AutoFillAspect

Erstellen Sie im Sky-Server-Modul das Paket com.sky.aspect.

package com.sky.aspect;

/**
 * 自定义切面，实现公共字段自动填充处理逻辑
 */
@Aspect
@Component
@Slf4j
public class AutoFillAspect {

    /**
     * 切入点
     */
    @Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")
    public void autoFillPointCut(){}

    /**
     * 前置通知，在通知中进行公共字段的赋值
     */
    @Before("autoFillPointCut()")
    public void autoFill(JoinPoint joinPoint){
        /重要
        //可先进行调试，是否能进入该方法 提前在mapper方法添加AutoFill注解
        log.info("开始进行公共字段自动填充...");

    }
}

Verbessern Sie die AutoFill-Methode des benutzerdefinierten Aspekts AutoFillAspect

package com.sky.aspect;

import com.sky.annotation.AutoFill;
import com.sky.constant.AutoFillConstant;
import com.sky.context.BaseContext;
import com.sky.enumeration.OperationType;
import lombok.extern.slf4j.Slf4j;
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.stereotype.Component;
import java.lang.reflect.Method;
import java.time.LocalDateTime;

/**
 * 自定义切面，实现公共字段自动填充处理逻辑
 */
@Aspect
@Component
@Slf4j
public class AutoFillAspect {

    /**
     * 切入点
     */
    @Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")
    public void autoFillPointCut(){}

    /**
     * 前置通知，在通知中进行公共字段的赋值
     */
    @Before("autoFillPointCut()")
    public void autoFill(JoinPoint joinPoint){
        log.info("开始进行公共字段自动填充...");

        //获取到当前被拦截的方法上的数据库操作类型
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();//方法签名对象
        AutoFill autoFill = signature.getMethod().getAnnotation(AutoFill.class);//获得方法上的注解对象
        OperationType operationType = autoFill.value();//获得数据库操作类型

        //获取到当前被拦截的方法的参数--实体对象
        Object[] args = joinPoint.getArgs();
        if(args == null || args.length == 0){
            return;
        }

        Object entity = args[0];

        //准备赋值的数据
        LocalDateTime now = LocalDateTime.now();
        Long currentId = BaseContext.getCurrentId();

        //根据当前不同的操作类型，为对应的属性通过反射来赋值
        if(operationType == OperationType.INSERT){
            //为4个公共字段赋值
            try {
                Method setCreateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_TIME, LocalDateTime.class);
                Method setCreateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_USER, Long.class);
                Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
                Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);

                //通过反射为对象属性赋值
                setCreateTime.invoke(entity,now);
                setCreateUser.invoke(entity,currentId);
                setUpdateTime.invoke(entity,now);
                setUpdateUser.invoke(entity,currentId);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }else if(operationType == OperationType.UPDATE){
            //为2个公共字段赋值
            try {
                Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
                Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);

                //通过反射为对象属性赋值
                setUpdateTime.invoke(entity,now);
                setUpdateUser.invoke(entity,currentId);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

1.3.3 Schritt 3

Fügen Sie der Methode der Mapper-Schnittstelle eine AutoFill-Annotation hinzu

Am Beispiel von CategoryMapper fügen Sie der neuen bzw. geänderten Methode die Annotation @AutoFill() hinzu. Auch EmployeeMapper muss den gleichen Vorgang ausführen.

package com.sky.mapper;

@Mapper
public interface CategoryMapper {
    /**
     * 插入数据
     * @param category
     */
    @Insert("insert into category(type, name, sort, status, create_time, update_time, create_user, update_user)" +
            " VALUES" +
            " (#{type}, #{name}, #{sort}, #{status}, #{createTime}, #{updateTime}, #{createUser}, #{updateUser})")
    @AutoFill(value = OperationType.INSERT)
    void insert(Category category);
    /**
     * 根据id修改分类
     * @param category
     */
    @AutoFill(value = OperationType.UPDATE)
    void update(Category category);

}

Kommentieren Sie gleichzeitig den Code aus, der öffentlichen Feldern in der Geschäftsschicht Werte zuweist.

1) Codekommentare für die Zuweisung von Werten zu öffentlichen Feldern in den Neu- und Bearbeitungsmethoden der Mitarbeiterverwaltung.

2) Codekommentare zum Zuweisen von Werten zu öffentlichen Feldern in den neuen und modifizierten Methoden zur Verwaltung der Gerichtsklassifizierung.

1.4 Funktionstest

Nehmen Sie zum Testen die neu hinzugefügte Gerichtskategorie als Beispiel

Starten Sie das Projekt und Nginx

Sehen Sie sich die Konsole an

Bestimmen Sie, ob das Ausfüllen des öffentlichen Felds abgeschlossen ist, indem Sie die SQL-Ausgabe auf der Konsole beobachten

Tabelle ansehen

Daten in der Kategorietabelle

Darunter wurden die Felder „create_time“, „update_time“, „create_user“ und „update_user“ alle automatisch ausgefüllt.

Da der Benutzer „Administrator“ (ID=1) zum Anmelden zum Hinzufügen von Gerichten verwendet wird, sind „create_user“ und „update_user“ beide 1.

1.5 Code-Einreichung

Klicken Sie auf „Senden“:

Während des Einreichungsvorgangs erscheint eine Eingabeaufforderung:

Weiter pushen:

Push erfolgreich: