Wetts's blog

It is nice for a Python module to have a docstring, explaining what the module does, what it provides, examples of how to use the classes. This is different from the comments that you often see at the beginning of a file giving the copyright and license information, which IMO should not go in the docstring (some even argue that they should disappear altogether, see eg.

As your code is not contained in a class or function it is expecting those variables to be constants and as such they should be uppercase.

You can read PEP8 for further information.

{
    "name": "Django",
    "type": "python",
    "request": "launch",
    "stopOnEntry": false,
    "pythonPath": "${config:python.pythonPath}",
    "program": "${workspaceRoot}/manage.py",
    "args": [
        "runserver",
        "--no-color",
        "--noreload"
    ],
    "debugOptions": [
        "WaitOnAbnormalExit",
        "WaitOnNormalExit",
        "RedirectOutput",
        "DjangoDebugging"
    ]
}

"PY_HEADER": {
    "prefix": "header",
    "body": [
        "# -*- encoding: utf-8 -*-",
        "'''",
        "@File    :   $TM_FILENAME",
        "@Time    :   $CURRENT_YEAR/$CURRENT_MONTH/$CURRENT_DATE $CURRENT_HOUR:$CURRENT_MINUTE:$CURRENT_SECOND",
        "@Author  :   Zhang Wensong",
        "@Version :   1.0",
        "@Contact :   zhang.wetts@163.com",
        "@Desc    :   $1",
        "'''",
        "",
        "# here put the import lib",
        "$0"
    ],
}

"MD_HEADER": {
    "prefix": "header",
    "body": [
        "title: $TM_FILENAME",
        "date: $CURRENT_YEAR/$CURRENT_MONTH/$CURRENT_DATE $CURRENT_HOUR:$CURRENT_MINUTE:$CURRENT_SECOND",
        "tags:",
        "- $1",
        "categories:",
        "- $2",
        "",
        "---",
        "",
        "$0"
    ],
}

"[markdown]": {
    "editor.quickSuggestions": true
}

public interface IUserService {
    public void request();
}

public class UserServiceImpl implements IUserService {
    @Override
    public void request() {
        System.out.println("this is userService");
    }
}

public class UserServiceProxy implements IUserService {

    private IUserService userService;

    public UserServiceProxy(IUserService userService) {
        this.userService = userService;
    }

    @Override
    public void request() {
        long startTime = System.currentTimeMillis();
        userService.request();
        System.out.println("reques cost :" + (System.currentTimeMillis() - startTime));
    }

    public static void main(String[] args) {
        IUserService userService = new UserServiceImpl();
        UserServiceProxy userServiceProxy = new UserServiceProxy(userService);
        // this is userService
        // reques cost :0
        userServiceProxy.request();
    }
}

public class RequestCostInvocationHandler implements InvocationHandler {

    private Object target;

    public RequestCostInvocationHandler(Object target) {
        this.target = target;
    }

	/** 被代理对象的任何方法被执行时，都会先进入这个方法 */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getName().equals("request")) {
            long startTime = System.currentTimeMillis();
            // 执行目标对象的方法
            method.invoke(target, args);
            System.out.println("reques cost :" + (System.currentTimeMillis() - startTime));
        }
        return null;
    }

    public static void main(String[] args) {

        // 3个参数解释如下
        // classloader,生成代理类
        // 代理类应该实现的接口
        // 实现InvocationHandler的切面类
        IUserService userService = (IUserService) Proxy.newProxyInstance(IUserService.class.getClassLoader(),
                new Class[]{IUserService.class}, new RequestCostInvocationHandler(new UserServiceImpl()));

        IProductService productService = (IProductService) Proxy.newProxyInstance(IProductService.class.getClassLoader(),
                new Class[]{IProductService.class}, new RequestCostInvocationHandler(new ProductServiceImpl()));

        // this is userService
        // reques cost :0
        userService.request();

        // this is productService
        // reques cost :0
        productService.request();
    }

}

Role role = roleMapper.getRole(3L);

plugin2( plugin1( start() ) )

public interface IGetStr {
    public String getStrZero();
    public String getStrOne();
}

public class GetStrImpl implements IGetStr {

    @Override
    public String getStrZero() {
        return "0";
    }

    @Override
    public String getStrOne() {
        return "1";
    }
}

public interface Interceptor {

    /** 执行拦截逻辑的方法 */
    Object intercept(Invocation invocation);

    /**
     * target是被拦截的对象，它的作用是给被拦截对象生成一个代理对象，并返回它。
     * 为了方便，可以直接使用Mybatis中org.apache.ibatis.plugin类的wrap方法（是静态方法）生成代理对象
     * 我这里也写了一个Plugin方法
     */
    Object plugin(Object target);
}

public class Invocation {

    private final Object target;
    private final Method method;
    private final Object[] args;

    public Invocation(Object target, Method method, Object[] args) {
        this.target = target;
        this.method = method;
        this.args = args;
    }

    public Object proceed() throws InvocationTargetException, IllegalAccessException {
        return method.invoke(target, args);
    }
}

public class Plugin implements InvocationHandler {

    /** 目标对象 */
    private final Object target;
    /** Interceptor对象 */
    private final Interceptor interceptor;

    public Plugin(Object target, Interceptor interceptor) {
        this.target = target;
        this.interceptor = interceptor;
    }

	/** 生成代理对象 */
    public static Object wrap(Object target, Interceptor interceptor) {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                new Class[]{IGetStr.class},
                new Plugin(target, interceptor));
    }

	/** 被代理对象的方法执行时，这个方法会被执行 */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    	// 只为方法getStrZero生成代理对象
        if (method.getName().equals("getStrZero")) {
            return interceptor.intercept(new Invocation(target, method, args));
        }
        return method.invoke(target, args);
    }
}

public class FirstInterceptor implements Interceptor {


    /** 执行拦截逻辑的方法 */
    @Override
    public Object intercept(Invocation invocation) {
        try {
            return "plugin1 " + invocation.proceed() + " plugin1";
        } catch (Exception e) {
            return null;
        }
    }

    /** 为原先的类生成代理对象 */
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }
}

public class SecondInterceptor implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) {
        try {
            return "plugin2 " + invocation.proceed() + " plugin2";
        } catch (Exception e) {
            return null;
        }
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }
}

public class InterceptorChain {

    /** 放拦截器 */
    private final List<Interceptor> interceptors = new ArrayList<Interceptor>();

    public Object pluginAll(Object target) {
        for (Interceptor interceptor : interceptors) {
            target = interceptor.plugin(target);
        }
        return target;
    }

    public void addInterceptor(Interceptor interceptor) {
        interceptors.add(interceptor);
    }
}

public class Main {

    public static void main(String[] args) {

        // 配置插件
        InterceptorChain interceptorChain = new InterceptorChain();
        interceptorChain.addInterceptor(new FirstInterceptor());
        interceptorChain.addInterceptor(new SecondInterceptor());

        // 获得代理对象
        IGetStr getStr = new GetStrImpl();
        getStr = (IGetStr) interceptorChain.pluginAll(getStr);

        String result = getStr.getStrZero();
        // plugin2 plugin1 0 plugin1 plugin2
        System.out.println(result);

        result = getStr.getStrOne();
        // 1
        System.out.println(result);
    }
}

CREATE TABLE `globallocktable` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `lockKey` varchar(60) NOT NULL COMMENT '锁名称',
  `createTime` datetime NOT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `lockKey` (`lockKey`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='全局锁';

@Component
public class GlobalLockComponent {
  
  @Resource
  private GlobalLockTableDAO globalLockDAO;
  
  /**
   * 尝试获得锁，成功为true，失败为false
   */
  public boolean tryLock(String key) {
    return GlobalLockUtil.tryLock(this.globalLockDAO, key);
  }
  
  /**
   * 如果已经有其他程序占用该锁，并且超过timeoutMs（毫秒）时间，就强制清除这个锁占用
   * 即根据key先删除记录，再添加记录
   */
  public boolean tryLockWithClear(String key, Long timeoutMs) {
    return GlobalLockUtil.tryLockWithClear(this.globalLockDAO, key, timeoutMs);
  }

  /**
   * 释放锁，根据key删除记录
   */
  public void releasLock(String key) {
    GlobalLockUtil.releasLock(this.globalLockDAO, key);
  }

}

public class GlobalLockTable {

  private Integer id;
  private String lockKey;
  private Date createTime;
  // 省略get和set方法
}

public interface GlobalLockTableDAO {

  int deleteByPrimaryKey(Integer id);
  
  int deleteByLockKey(String lockKey);

  GlobalLockTable selectByLockKey(String key);

  int insertSelectiveWithTest(GlobalLockTable record);
}

public class GlobalLockUtil {

  private static Logger logger = LoggerFactory.getLogger(GlobalLockUtil.class);

  private static GlobalLockTable tryLockInternal(GlobalLockTableDAO lockDAO, String key) {
    GlobalLockTable insert = new GlobalLockTable();
    insert.setCreateTime(new Date());
    insert.setLockKey(key);
    // 注意的地方1
    int count = lockDAO.insertSelectiveWithTest(insert);
    if (count == 0) {
      GlobalLockTable ready = lockDAO.selectByLockKey(key);
      logger.warn("can not lock the key: {}, {}, {}", insert.getLockKey(), ready.getCreateTime(),
          ready.getId());
      return ready;
    }
    logger.info("yes got the lock by key: {}", insert.getId(), insert.getLockKey());
    return null;
  }

  /** 超时清除锁占用，并重新加锁 **/
  public static boolean tryLockWithClear(GlobalLockTableDAO lockDAO, String key, Long timeoutMs) {
    GlobalLockTable lock = tryLockInternal(lockDAO, key);
    if (lock == null) return true;
    if (System.currentTimeMillis() - lock.getCreateTime().getTime() <= timeoutMs) {
      logger.warn("sorry, can not get the key. : {}, {}, {}", key, lock.getId(), lock.getCreateTime());
      return false;
    }
    logger.warn("the key already timeout wthin : {}, {}, will clear", key, timeoutMs);
    // 注意的地方2
    int count = lockDAO.deleteByPrimaryKey(lock.getId());
    if (count == 0) {
      logger.warn("sorry, the key already preemptived by others: {}, {}", lock.getId(), lock.getLockKey());
      return false;
    }
    lock = tryLockInternal(lockDAO, key);
    return lock != null ? false : true;
  }
  
  /** 加锁 **/
  public static boolean tryLock(GlobalLockTableDAO lockDAO, String key) {
    return tryLockInternal(lockDAO, key) == null ? true : false;
  }
  
  /** 解锁 **/
  public static void releasLock(GlobalLockTableDAO lockDAO, String key) {
    lockDAO.deleteByLockKey(key);
  }
}

<insert id="insertSelectiveWithTest" useGeneratedKeys="true" keyProperty="id" parameterType="com.javashitang.middleware.lock.mysql.pojo.GlobalLockTable">
  insert into `globallocktable` (`id`,
  `lockKey`, `createTime` )
   select #{id,jdbcType=INTEGER}, #{lockKey,jdbcType=VARCHAR}, #{createTime,jdbcType=TIMESTAMP}
   from dual where not exists
    (select 1 from globallocktable where lockKey = #{lockKey,jdbcType=VARCHAR})
</insert>

if (!globalLockComponent.tryLock(name)) {
  // 没有获取到锁返回
  return;
}
try {
  // 这里写业务逻辑
} catch (Exception e) {
} finally {
  globalLockComponent.releasLock(name)
}

作者：qang pan
链接：https://www.zhihu.com/question/19967778/answer/28403912
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。