Mybatis 基础字段自动维护

1
@Intercepts({@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})})
2
public class AutoFillInterceptor implements Interceptor {
3

4
    private ConcurrentHashMap<Class, AuditingConfig> auditingConfigMap = new ConcurrentHashMap<>();
5

6
    private CurrentUserExtractor currentUserExtractor;
7

8
    public void setCurrentUserExtractor(CurrentUserExtractor currentUserExtractor) {
9
        this.currentUserExtractor = currentUserExtractor;
10
    }
11

12
    @Override
13
    public Object intercept(Invocation invocation) throws Throwable {
14
        Object[] args = invocation.getArgs();
15
        if (args.length > 1) {
16
            Object arg = args[1];
17
            Class<?> clazz = arg.getClass();
18
            AuditingConfig config = auditingConfigMap.computeIfAbsent(clazz, this::extractConfig);
19
            Field createField = config.getCreateField();
20
            Field modifiedField = config.getModifiedField();
21
            BeanWrapper beanWrapper = null;
22
            MappedStatement mappedStatement = (MappedStatement)args[0];
23
            SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
24
            if (createField != null || modifiedField != null) {
25
                beanWrapper = new BeanWrapperImpl(arg);
26
                Date now = new Date();
27
                if (sqlCommandType == SqlCommandType.INSERT) {
28
                    if (createField != null) {
29
                        setAuditingDateValue(beanWrapper, createField, now);
30
                    }
31
                    if (modifiedField != null) {
32
                        setAuditingDateValue(beanWrapper, modifiedField, now);
33
                    }
34
                    // if (config.getVersionFiled() != null) {
35
                    // setDefaultVersion(beanWrapper, config.getVersionFiled());
36
                    // }
37
                } else if (sqlCommandType == SqlCommandType.UPDATE) {
38
                    setAuditingDateValue(beanWrapper, modifiedField, now);
39
                }
40
            }
41
            if (currentUserExtractor != null) {
42
                Field createdByField = config.getCreatedByField();
43
                Field modifiedByField = config.getModifiedByField();
44
                if (createdByField != null && modifiedByField != null) {
45
                    Object user = currentUserExtractor.getCurrentUser();
46
                    if (beanWrapper == null) {
47
                        beanWrapper = new BeanWrapperImpl(arg);
48
                    }
49
                    if (sqlCommandType == SqlCommandType.INSERT) {
50
                        if (createField != null) {
51
                            setAuditingUserValue(beanWrapper, createdByField, user);
52
                        }
53
                        if (modifiedField != null) {
54
                            setAuditingUserValue(beanWrapper, modifiedByField, user);
55
                        }
56
                    } else if (sqlCommandType == SqlCommandType.UPDATE) {
57
                        setAuditingUserValue(beanWrapper, modifiedByField, user);
58
                    }
59
                }
60
            }
61
        }
62
        return invocation.proceed();
63
    }
64

65
    private void setAuditingDateValue(BeanWrapper beanWrapper, Field field, Date value) {
66
        String name = field.getName();
67
        if (field.getType() == Date.class) {
68
            beanWrapper.setPropertyValue(name, value);
69
        }
70
    }
71

72
    private void setAuditingUserValue(BeanWrapper beanWrapper, Field field, Object user) {
73
        String name = field.getName();
74
        if (beanWrapper.getPropertyValue(name) == null) {
75
            beanWrapper.setPropertyValue(name, user);
76
        }
77
    }
78

79
    private AuditingConfig extractConfig(Class<?> clazz) {
80
        AuditingConfig config = new AuditingConfig();
81
        ReflectionUtils.doWithFields(clazz, new ReflectionUtils.FieldCallback() {
82
            @Override
83
            public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
84
                Created created = field.getAnnotation(Created.class);
85
                if (created != null) {
86
                    config.setCreateField(field);
87
                } else {
88
                    Modified modified = field.getAnnotation(Modified.class);
89
                    if (modified != null) {
90
                        config.setModifiedField(field);
91
                    }
92
                }
93
                CreatedBy createdBy = field.getAnnotation(CreatedBy.class);
94
                if (createdBy != null) {
95
                    config.setCreatedByField(field);
96
                } else {
97
                    ModifiedBy modifiedBy = field.getAnnotation(ModifiedBy.class);
98
                    if (modifiedBy != null) {
99
                        config.setModifiedByField(field);
100
                    }
101
                }
102
                // Version version = field.getAnnotation(Version.class);
103
                // if (version != null) {
104
                // config.setVersionFiled(field);
105
                // }
106
            }
107
        });
108
        return config;
109
    }
110

111
    @Override
112
    public Object plugin(Object target) {
113
        return Plugin.wrap(target, this);
114
    }
115

116
    @Override
117
    public void setProperties(Properties properties) {
118

119
    }
120

121
    @Data
122
    private static class AuditingConfig {
123

124
        private Field createField;
125

126
        private Field modifiedField;
127

128
        private Field createdByField;
129

130
        private Field modifiedByField;
131

132
        private Field versionFiled;
133
    }
134
}