version 0.4.0.0 update

完成乐观锁开发。目前有互斥锁、读写锁、乐观锁，均已测试可用

Author: ZongXR

README.md

@@ -58,4 +58,7 @@
 <tr>
 <td>0.3.3.0</td><td>完成乐观锁处理器开发，目前可以将乐观锁动态编译进入类成员</td><td>2022年1月30日</td>
 </tr>
+<tr>
+<td>0.4.0.0</td><td>完成乐观锁开发。目前有互斥锁、读写锁、乐观锁，均已测试可用</td><td>2022年1月30日</td>
+</tr>
 </table>

src/main/java/org/springframework/lock/annotation/EnableSpringLocks.java

@@ -2,6 +2,7 @@
 
 import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.context.annotation.Import;
+import org.springframework.lock.aspect.OptimisticLockAspect;
 import org.springframework.lock.aspect.ReadLockAspect;
 import org.springframework.lock.aspect.SynchronizedAspect;
 import org.springframework.lock.aspect.WriteLockAspect;
@@ -14,7 +15,8 @@
 @Import({
         SynchronizedAspect.class,
         ReadLockAspect.class,
-        WriteLockAspect.class
+        WriteLockAspect.class,
+        OptimisticLockAspect.class
 })
 @EnableAspectJAutoProxy(exposeProxy = true, proxyTargetClass = true)
 @Retention(RetentionPolicy.RUNTIME)

src/main/java/org/springframework/lock/annotation/OptimisticLock.java

@@ -12,7 +12,7 @@
 public @interface OptimisticLock {
 
     /**
-     * 乐观锁忙等待时间
+     * 乐观锁忙等待毫秒数
      * @return 乐观锁忙等待时间
      */
     long value() default 500L;

src/main/java/org/springframework/lock/annotation/Synchronized.java

@@ -1,7 +1,5 @@
 package org.springframework.lock.annotation;
 
-import org.springframework.core.annotation.AliasFor;
-
 import java.lang.annotation.*;
 
 /**
@@ -13,7 +11,7 @@
 public @interface Synchronized {
 
     /**
-     * 用来当作锁的成员变量名，默认使用当前类的字节码当作锁，同lock
+     * 用来当作锁的成员变量名，默认使用当前类的字节码当作锁
      * @return 锁对象
      */
     String value() default "";

src/main/java/org/springframework/lock/annotation/package-info.java

@@ -0,0 +1,8 @@
+/**
+ * 这个包包含了该框架的全部注解.
+ * 每个注解上都有对应的注释，写得很清楚，自己看就可以了，不加以赘述.
+ * 需要注意的是，如果需要使锁注解生效，需要在springboot启动类上添加{@code @EnableSpringLocks}注解
+ * @author 宗祥瑞
+ * @version 0.5.0.0
+ */
+package org.springframework.lock.annotation;

src/main/java/org/springframework/lock/aspect/OptimisticLockAspect.java

@@ -5,6 +5,14 @@
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.lock.annotation.OptimisticLock;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static java.lang.Thread.sleep;
 
 /**
  * 乐观锁的切面
@@ -25,8 +33,48 @@ public class OptimisticLockAspect {
      */
     @Around("@annotation(org.springframework.lock.annotation.OptimisticLock)")
     public Object aroundOptimisticLock(ProceedingJoinPoint jp) throws Throwable {
-        Object result = jp.proceed();
+        Object obj = jp.getTarget();
+        Class<?> clz = obj.getClass();
+        // 获取等待时长，默认500毫秒
+        long waitTime = 500L;
+        MethodSignature signature = (MethodSignature) jp.getSignature();
+        Method method = signature.getMethod();
+        if (method != null) {
+            OptimisticLock annotation = method.getAnnotation(OptimisticLock.class);
+            if (annotation != null) {
+                waitTime = annotation.value();
+            }
+        }
+        // 获取锁对象
+        AtomicBoolean lock = null;
+        for (Field field : clz.getDeclaredFields()) {
+            if ("$opLock".equals(field.getName())){
+                field.setAccessible(true);
+                Object unknownLock = field.get(obj);
+                lock = (AtomicBoolean) unknownLock;
+            }
+        }
+        Object result = null;
+        if (lock != null){
+            while (true){
+                if (lock.compareAndSet(true, false))
+                    // 拿到了锁
+                    break;
+                else
+                    // 如果没拿到锁就忙等待
+                    sleep(waitTime);
+            }
+            try {
+                LOGGER.info(clz.getSimpleName() + "获得乐观锁");
+                result = jp.proceed();
+                LOGGER.info(clz.getSimpleName() + "释放乐观锁");
+            }finally {
+                lock.set(true);
+            }
+        }else{
+            LOGGER.warn(clz.getSimpleName() + "生成乐观锁失败,未能加锁");
+            result = jp.proceed();
+        }
         return result;
     }
-
 }

src/main/java/org/springframework/lock/aspect/SynchronizedAspect.java

@@ -3,11 +3,9 @@
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.aspectj.lang.ProceedingJoinPoint;
-import org.aspectj.lang.Signature;
 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.reflect.MethodSignature;
-import org.springframework.boot.SpringApplication;
 import org.springframework.lock.annotation.Synchronized;
 
 import java.lang.reflect.Field;

src/main/java/org/springframework/lock/aspect/package-info.java

@@ -0,0 +1,8 @@
+/**
+ * 这个包存放了注解对应的切面，用来做动态代理.
+ * 每个切面都有注释，没什么好说的，不加以赘述.
+ * 切面这部分需要托管到spring容器中去执行.
+ * @author 宗祥瑞
+ * @version 0.5.0.0
+ */
+package org.springframework.lock.aspect;

src/main/java/org/springframework/lock/processor/OptimisticLockProcessor.java

@@ -4,7 +4,6 @@
 import com.sun.source.tree.Tree;
 import com.sun.tools.javac.api.JavacTrees;
 import com.sun.tools.javac.code.Flags;
-import com.sun.tools.javac.code.TypeTag;
 import com.sun.tools.javac.processing.JavacProcessingEnvironment;
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.tree.TreeMaker;
@@ -17,7 +16,6 @@
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeKind;
 import javax.tools.Diagnostic;
 import java.util.HashSet;
 import java.util.Set;
@@ -120,14 +118,15 @@ public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
 
     /**
      * 制作乐观锁
+     * @param clz 要添加锁的类
      * @return 变量声明
      */
     private JCVariableDecl makeOptimisticLock(TypeElement clz){
         // 导入包
         JCCompilationUnit imports = (JCCompilationUnit) this.javacTrees.getPath(clz).getCompilationUnit();
         imports.defs = imports.defs.append(this.treeMaker.Import(this.treeMaker.Select(this.treeMaker.Ident(names.fromString("java.util.concurrent.atomic")), this.names.fromString("AtomicBoolean")), false));
         // 声明变量
-        JCModifiers modifiers = this.treeMaker.Modifiers(Flags.PRIVATE + Flags.FINAL);
+        JCModifiers modifiers = this.treeMaker.Modifiers(Flags.PRIVATE + Flags.VOLATILE);
         JCVariableDecl var = this.treeMaker.VarDef(
                 modifiers,
                 this.names.fromString("$opLock"),

src/main/java/org/springframework/lock/processor/ReadLockProcessor.java

@@ -5,7 +5,6 @@
 import com.sun.source.tree.Tree;
 import com.sun.tools.javac.api.JavacTrees;
 import com.sun.tools.javac.code.Flags;
-import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.processing.JavacProcessingEnvironment;
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.tree.TreeMaker;
@@ -16,12 +15,10 @@
 import javax.lang.model.SourceVersion;
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.Name;
 import javax.lang.model.element.TypeElement;
 import javax.tools.Diagnostic;
 import java.util.HashSet;
 import java.util.Set;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
 
 import static com.sun.tools.javac.tree.JCTree.*;
 import static com.sun.tools.javac.util.List.nil;
@@ -133,6 +130,7 @@ public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
 
     /**
      * 制作读写锁
+     * @param clz 要添加锁的类
      * @return 变量声明
      */
     private JCVariableDecl makeReadWriteLock(TypeElement clz){
@@ -152,6 +150,7 @@ private JCVariableDecl makeReadWriteLock(TypeElement clz){
 
     /**
      * 制作读锁
+     * @param clz 要添加锁的类
      * @return 变量声明
      */
     private JCVariableDecl makeReadLock(TypeElement clz){