diff --git a/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/AbstractDistributedLockHandler.java b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/AbstractDistributedLockHandler.java
new file mode 100644
index 0000000..8cbca67
--- /dev/null
+++ b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/AbstractDistributedLockHandler.java
@@ -0,0 +1,30 @@
+package com.supwisdom.institute.backend.common.core.distributedlock;
+
+public abstract class AbstractDistributedLockHandler implements DistributedLockHandler {
+
+  @Override
+  public boolean lock(String key) {
+    return lock(key, TIMEOUT_MILLIS, RETRY_TIMES, SLEEP_MILLIS);
+  }
+
+  @Override
+  public boolean lock(String key, int retryTimes) {
+    return lock(key, TIMEOUT_MILLIS, retryTimes, SLEEP_MILLIS);
+  }
+
+  @Override
+  public boolean lock(String key, int retryTimes, long sleepMillis) {
+    return lock(key, TIMEOUT_MILLIS, retryTimes, sleepMillis);
+  }
+
+  @Override
+  public boolean lock(String key, long expire) {
+    return lock(key, expire, RETRY_TIMES, SLEEP_MILLIS);
+  }
+
+  @Override
+  public boolean lock(String key, long expire, int retryTimes) {
+    return lock(key, expire, retryTimes, SLEEP_MILLIS);
+  }
+
+}
diff --git a/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/DefaultDistributedLockHandler.java b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/DefaultDistributedLockHandler.java
new file mode 100644
index 0000000..950a510
--- /dev/null
+++ b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/DefaultDistributedLockHandler.java
@@ -0,0 +1,17 @@
+package com.supwisdom.institute.backend.common.core.distributedlock;
+
+public class DefaultDistributedLockHandler extends AbstractDistributedLockHandler {
+  
+  private ThreadLocal<String> lockFlag = new ThreadLocal<String>();
+
+  @Override
+  public boolean lock(String key, long expire, int retryTimes, long sleepMillis) {
+    return true;
+  }
+
+  @Override
+  public boolean releaseLock(String key) {
+    return true;
+  }
+
+}
diff --git a/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/DistributedLockAutoConfiguration.java b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/DistributedLockAutoConfiguration.java
new file mode 100644
index 0000000..68df599
--- /dev/null
+++ b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/DistributedLockAutoConfiguration.java
@@ -0,0 +1,21 @@
+package com.supwisdom.institute.backend.common.core.distributedlock;
+
+import lombok.extern.slf4j.Slf4j;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Slf4j
+@Configuration
+public class DistributedLockAutoConfiguration {
+  
+  @Bean
+  @ConditionalOnMissingBean(DistributedLockHandler.class)
+  public DistributedLockHandler defaultDistributedLockHandler() {
+    DistributedLockHandler defaultDistributedLockHandler = new DefaultDistributedLockHandler();
+    log.debug("DistributedLockAutoConfiguration.defaultDistributedLockHandler is {}", defaultDistributedLockHandler);
+
+    return defaultDistributedLockHandler;
+  }
+}
diff --git a/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/DistributedLockHandler.java b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/DistributedLockHandler.java
new file mode 100644
index 0000000..e989da9
--- /dev/null
+++ b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/DistributedLockHandler.java
@@ -0,0 +1,83 @@
+package com.supwisdom.institute.backend.common.core.distributedlock;
+
+public interface DistributedLockHandler {
+  public static final long TIMEOUT_MILLIS = 30000;
+
+  public static final int RETRY_TIMES = Integer.MIN_VALUE;
+
+  public static final long SLEEP_MILLIS = 500;
+
+  /**
+   * 获取锁<br>
+   * 超时：30000 ms (30 s) {@link DistributedLockHandler.TIMEOUT_MILLIS}<br>
+   * 重试次数：不重试 {@link DistributedLockHandler.RETRY_TIMES}<br>
+   * 重试等待：500 ms {@link DistributedLockHandler.SLEEP_MILLIS}<br>
+   * <br>
+   * @param key
+   * @return
+   */
+  public boolean lock(String key);
+
+  /**
+   * 获取锁<br>
+   * 超时：30000 ms (30 s) {@link DistributedLockHandler.TIMEOUT_MILLIS}<br>
+   * 重试等待：500 ms {@link DistributedLockHandler.SLEEP_MILLIS}<br>
+   * <br>
+   * @param key
+   * @param retryTimes 重试次数
+   * @return
+   */
+  public boolean lock(String key, int retryTimes);
+
+  /**
+   * 获取锁<br>
+   * 超时：30000 ms (30 s) {@link DistributedLockHandler.TIMEOUT_MILLIS}<br>
+   * <br>
+   * @param key
+   * @param retryTimes 重试次数
+   * @param sleepMillis 重试等待 单位 ms
+   * @return
+   */
+  public boolean lock(String key, int retryTimes, long sleepMillis);
+
+  /**
+   * 获取锁<br>
+   * 重试次数：不重试 {@link DistributedLockHandler.RETRY_TIMES}<br>
+   * 重试等待：500 ms {@link DistributedLockHandler.SLEEP_MILLIS}<br>
+   * <br>
+   * @param key
+   * @param expire 超时 单位 ms
+   * @return
+   */
+  public boolean lock(String key, long expire);
+
+  /**
+   * 获取锁<br>
+   * 重试等待：500 ms {@link DistributedLockHandler.SLEEP_MILLIS}<br>
+   * <br>
+   * @param key
+   * @param retryTimes 重试次数
+   * @param expire 超时 单位 ms
+   * @return
+   */
+  public boolean lock(String key, long expire, int retryTimes);
+
+  /**
+   * 获取锁<br>
+   * <br>
+   * @param key
+   * @param expire 超时 单位 ms
+   * @param retryTimes 重试次数
+   * @param sleepMillis 重试等待 单位 ms
+   * @return
+   */
+  public boolean lock(String key, long expire, int retryTimes, long sleepMillis);
+
+  /**
+   * 释放锁<br>
+   * <br>
+   * @param key
+   * @return
+   */
+  public boolean releaseLock(String key);
+}
diff --git a/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/EnableDistributedLock.java b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/EnableDistributedLock.java
new file mode 100644
index 0000000..89053c9
--- /dev/null
+++ b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/EnableDistributedLock.java
@@ -0,0 +1,17 @@
+package com.supwisdom.institute.backend.common.core.distributedlock;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.context.annotation.Import;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Import({DistributedLockAutoConfiguration.class})
+public @interface EnableDistributedLock {
+
+}
diff --git a/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/aop/DistributedLock.java b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/aop/DistributedLock.java
new file mode 100644
index 0000000..52c2485
--- /dev/null
+++ b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/aop/DistributedLock.java
@@ -0,0 +1,36 @@
+package com.supwisdom.institute.backend.common.core.distributedlock.aop;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface DistributedLock {
+
+  /** 锁的资源，redis的key */
+  String value() default "default";
+
+  /** 持锁时间,单位毫秒 */
+  long keepMills() default 30000;
+
+  /** 当获取失败时候动作 */
+  LockFailAction action() default LockFailAction.CONTINUE;
+
+  public enum LockFailAction {
+    /** 放弃 */
+    GIVEUP,
+    /** 继续 */
+    CONTINUE;
+  }
+
+  /** 重试的间隔时间,设置GIVEUP忽略此项 */
+  long sleepMills() default 200;
+
+  /** 重试次数 */
+  int retryTimes() default 5;
+
+}
diff --git a/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/aop/DistributedLockAspectConfiguration.java b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/aop/DistributedLockAspectConfiguration.java
new file mode 100644
index 0000000..fb67688
--- /dev/null
+++ b/common/core/src/main/java/com/supwisdom/institute/backend/common/core/distributedlock/aop/DistributedLockAspectConfiguration.java
@@ -0,0 +1,67 @@
+package com.supwisdom.institute.backend.common.core.distributedlock.aop;
+
+import java.lang.reflect.Method;
+import java.util.Arrays;
+
+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.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.util.StringUtils;
+
+import com.supwisdom.institute.backend.common.core.distributedlock.DistributedLockAutoConfiguration;
+import com.supwisdom.institute.backend.common.core.distributedlock.DistributedLockHandler;
+import com.supwisdom.institute.backend.common.core.distributedlock.aop.DistributedLock.LockFailAction;
+
+@Aspect
+@Configuration
+@ConditionalOnClass({ProceedingJoinPoint.class, DistributedLockHandler.class})
+@AutoConfigureAfter(DistributedLockAutoConfiguration.class)
+public class DistributedLockAspectConfiguration {
+  
+  private final Logger logger = LoggerFactory.getLogger(DistributedLockAspectConfiguration.class);
+  
+  @Autowired
+  private DistributedLockHandler distributedLockHandler;
+
+  @Pointcut("@annotation(com.supwisdom.institute.backend.common.core.distributedlock.aop.DistributedLock)")
+  private void lockPoint(){
+    
+  }
+  
+  @Around("lockPoint()")
+  public Object around(ProceedingJoinPoint pjp) throws Throwable{
+    Method method = ((MethodSignature) pjp.getSignature()).getMethod();
+    DistributedLock distributedLockAnnotation = method.getAnnotation(DistributedLock.class);
+    String key = distributedLockAnnotation.value();
+    if(StringUtils.isEmpty(key)){
+      Object[] args = pjp.getArgs();
+      key = Arrays.toString(args);
+    }
+    int retryTimes = distributedLockAnnotation.action().equals(LockFailAction.CONTINUE) ? distributedLockAnnotation.retryTimes() : 0;
+    boolean lock = distributedLockHandler.lock(key, distributedLockAnnotation.keepMills(), retryTimes, distributedLockAnnotation.sleepMills());
+    if(!lock) {
+      logger.debug("get lock failed : " + key);
+      return null;
+    }
+    
+    //得到锁,执行方法，释放锁
+    logger.debug("get lock success : " + key);
+    try {
+      return pjp.proceed();
+    } catch (Exception e) {
+      logger.error("execute locked method occured an exception", e);
+    } finally {
+      boolean releaseResult = distributedLockHandler.releaseLock(key);
+      logger.debug("release lock : " + key + (releaseResult ? " success" : " failed"));
+    }
+    return null;
+  }
+}
\ No newline at end of file
diff --git a/common/core/src/main/resources/META-INF/spring.factories b/common/core/src/main/resources/META-INF/spring.factories
new file mode 100644
index 0000000..b94673d
--- /dev/null
+++ b/common/core/src/main/resources/META-INF/spring.factories
@@ -0,0 +1,4 @@
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+  com.supwisdom.institute.backend.common.core.distributedlock.DistributedLockAutoConfiguration,\
+  com.supwisdom.institute.backend.common.core.distributedlock.aop.DistributedLockAspectConfiguration
+
diff --git a/common/framework/pom.xml b/common/framework/pom.xml
index 18d0ac5..1cf7bc7 100644
--- a/common/framework/pom.xml
+++ b/common/framework/pom.xml
@@ -47,11 +47,35 @@
       <artifactId>spring-boot-starter-web</artifactId>
       <optional>true</optional>
     </dependency>
+    
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-aop</artifactId>
+      <optional>true</optional>
+    </dependency>
+    
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-jpa</artifactId>
       <optional>true</optional>
     </dependency>
+    
+    
+    <!-- <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-data-redis</artifactId>
+      <optional>true</optional>
+    </dependency> -->
+    <dependency>
+      <groupId>org.springframework.data</groupId>
+      <artifactId>spring-data-redis</artifactId>
+      <optional>true</optional>
+    </dependency>
+    <dependency>
+      <groupId>redis.clients</groupId>
+      <artifactId>jedis</artifactId>
+      <optional>true</optional>
+    </dependency>
 
 
     <dependency>
diff --git a/common/framework/src/main/java/com/supwisdom/institute/backend/common/framework/distributedlock/RedisDistributedLockAutoConfiguration.java b/common/framework/src/main/java/com/supwisdom/institute/backend/common/framework/distributedlock/RedisDistributedLockAutoConfiguration.java
new file mode 100644
index 0000000..edf8505
--- /dev/null
+++ b/common/framework/src/main/java/com/supwisdom/institute/backend/common/framework/distributedlock/RedisDistributedLockAutoConfiguration.java
@@ -0,0 +1,33 @@
+package com.supwisdom.institute.backend.common.framework.distributedlock;
+
+import lombok.extern.slf4j.Slf4j;
+
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.AutoConfigureBefore;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.core.RedisTemplate;
+
+import redis.clients.jedis.Jedis;
+
+import com.supwisdom.institute.backend.common.core.distributedlock.DistributedLockAutoConfiguration;
+import com.supwisdom.institute.backend.common.core.distributedlock.DistributedLockHandler;
+
+@Slf4j
+@Configuration
+@ConditionalOnClass({ Jedis.class })
+@AutoConfigureAfter(RedisAutoConfiguration.class)
+@AutoConfigureBefore(DistributedLockAutoConfiguration.class)
+public class RedisDistributedLockAutoConfiguration {
+
+  @Bean
+  public DistributedLockHandler redisDistributedLockHandler(RedisTemplate<Object, Object> redisTemplate) {
+    DistributedLockHandler redisDistributedLockHandler = new RedisDistributedLockHandler(redisTemplate);
+    log.debug("RedisDistributedLockAutoConfiguration.redisDistributedLockHandler is {}", redisDistributedLockHandler);
+    
+    return redisDistributedLockHandler;
+  }
+
+}
diff --git a/common/framework/src/main/java/com/supwisdom/institute/backend/common/framework/distributedlock/RedisDistributedLockHandler.java b/common/framework/src/main/java/com/supwisdom/institute/backend/common/framework/distributedlock/RedisDistributedLockHandler.java
new file mode 100644
index 0000000..59afa38
--- /dev/null
+++ b/common/framework/src/main/java/com/supwisdom/institute/backend/common/framework/distributedlock/RedisDistributedLockHandler.java
@@ -0,0 +1,117 @@
+package com.supwisdom.institute.backend.common.framework.distributedlock;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.dao.DataAccessException;
+import org.springframework.data.redis.connection.RedisConnection;
+import org.springframework.data.redis.core.RedisCallback;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.util.StringUtils;
+
+import com.supwisdom.institute.backend.common.core.distributedlock.AbstractDistributedLockHandler;
+
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisCluster;
+import redis.clients.jedis.JedisCommands;
+
+public class RedisDistributedLockHandler extends AbstractDistributedLockHandler {
+
+  private final Logger logger = LoggerFactory.getLogger(RedisDistributedLockHandler.class);
+
+  private RedisTemplate<Object, Object> redisTemplate;
+
+  private ThreadLocal<String> lockFlag = new ThreadLocal<String>();
+
+  public static final String UNLOCK_LUA;
+
+  static {
+    StringBuilder sb = new StringBuilder();
+    sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
+    sb.append("then ");
+    sb.append("    return redis.call(\"del\",KEYS[1]) ");
+    sb.append("else ");
+    sb.append("    return 0 ");
+    sb.append("end ");
+    UNLOCK_LUA = sb.toString();
+  }
+
+  public RedisDistributedLockHandler(RedisTemplate<Object, Object> redisTemplate) {
+    super();
+    this.redisTemplate = redisTemplate;
+  }
+
+  @Override
+  public boolean lock(String key, long expire, int retryTimes, long sleepMillis) {
+    boolean result = setRedis(key, expire);
+    // 如果获取锁失败，按照传入的重试次数进行重试
+    while ((!result) && retryTimes-- > 0) {
+      try {
+        logger.debug("lock failed, retrying..." + retryTimes);
+        Thread.sleep(sleepMillis);
+      } catch (InterruptedException e) {
+        return false;
+      }
+      result = setRedis(key, expire);
+    }
+    return result;
+  }
+
+  private boolean setRedis(String key, long expire) {
+    try {
+      String result = redisTemplate.execute(new RedisCallback<String>() {
+        @Override
+        public String doInRedis(RedisConnection connection) throws DataAccessException {
+          JedisCommands commands = (JedisCommands) connection.getNativeConnection();
+          String uuid = UUID.randomUUID().toString();
+          lockFlag.set(uuid);
+          return commands.set(key, uuid, "NX", "PX", expire);
+        }
+      });
+      return !StringUtils.isEmpty(result);
+    } catch (Exception e) {
+      logger.error("set redis occured an exception", e);
+    }
+    return false;
+  }
+
+  @Override
+  public boolean releaseLock(String key) {
+    // 释放锁的时候，有可能因为持锁之后方法执行时间大于锁的有效期，此时有可能已经被另外一个线程持有锁，所以不能直接删除
+    try {
+      List<String> keys = new ArrayList<String>();
+      keys.add(key);
+      List<String> args = new ArrayList<String>();
+      args.add(lockFlag.get());
+
+      // 使用lua脚本删除redis中匹配value的key，可以避免由于方法执行时间过长而redis锁自动过期失效的时候误删其他线程的锁
+      // spring自带的执行脚本方法中，集群模式直接抛出不支持执行脚本的异常，所以只能拿到原redis的connection来执行脚本
+
+      Long result = redisTemplate.execute(new RedisCallback<Long>() {
+        public Long doInRedis(RedisConnection connection) throws DataAccessException {
+          Object nativeConnection = connection.getNativeConnection();
+          // 集群模式和单机模式虽然执行脚本的方法一样，但是没有共同的接口，所以只能分开执行
+          // 集群模式
+          if (nativeConnection instanceof JedisCluster) {
+            return (Long) ((JedisCluster) nativeConnection).eval(UNLOCK_LUA, keys, args);
+          }
+
+          // 单机模式
+          else if (nativeConnection instanceof Jedis) {
+            return (Long) ((Jedis) nativeConnection).eval(UNLOCK_LUA, keys, args);
+          }
+          return 0L;
+        }
+      });
+
+      return result != null && result > 0;
+    } catch (Exception e) {
+      logger.error("release lock occured an exception", e);
+    }
+    return false;
+  }
+
+}
diff --git a/common/framework/src/main/resources/META-INF/spring.factories b/common/framework/src/main/resources/META-INF/spring.factories
new file mode 100644
index 0000000..53d2c7c
--- /dev/null
+++ b/common/framework/src/main/resources/META-INF/spring.factories
@@ -0,0 +1,2 @@
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+  com.supwisdom.institute.backend.common.framework.distributedlock.RedisDistributedLockAutoConfiguration