Object obj = boundSql.getAdditionalParameter(propertyName);
sql = sql.replaceFirst("\\?", getParameterValue(obj));

// 有问题的语句
String sql = "er WHERE realname like ? AND deleted = ?";
sql = sql.replaceFirst("\\?", "\\%$%");
System.out.println(sql);
// 修改
sql = sql.replaceFirst("\\?", Matcher.quoteReplacement("\\%$%"));

/**
 * Processes replacement string to replace group references with
 * groups.
 */
private StringBuilder appendExpandedReplacement(String replacement, StringBuilder result) {
    int cursor = 0;
    while (cursor < replacement.length()) {
        char nextChar = replacement.charAt(cursor);
        // 可以看出，转义符号使用起来也需要小心。如果在最后面，又会报错。
        if (nextChar == '\\') {
            cursor++;
            if (cursor == replacement.length())
                throw new IllegalArgumentException(
                    "character to be escaped is missing");
            // 对转义符的操作比较简单，只是先跳过转义符，然后将下一个字符拷贝
            nextChar = replacement.charAt(cursor);
            result.append(nextChar);
            cursor++;
        // 如果是$，那么后面要么是数字，要么是{
        } else if (nextChar == '$') {
            // Skip past $
            cursor++;
            // Throw IAE if this "$" is the last character in replacement
            if (cursor == replacement.length())
               throw new IllegalArgumentException(
                    "Illegal group reference: group index is missing");
            nextChar = replacement.charAt(cursor);
            int refNum = -1;
            if (nextChar == '{') {
                cursor++;
                StringBuilder gsb = new StringBuilder();
                // 先读出{}中的内容
                while (cursor < replacement.length()) {
                    nextChar = replacement.charAt(cursor);
                    if (ASCII.isLower(nextChar) ||
                        ASCII.isUpper(nextChar) ||
                        ASCII.isDigit(nextChar)) {
                        gsb.append(nextChar);
                        cursor++;
                    } else {
                        break;
                    }
                }
                if (gsb.length() == 0)
                    throw new IllegalArgumentException(
                        "named capturing group has 0 length name");
                if (nextChar != '}')
                    throw new IllegalArgumentException(
                        "named capturing group is missing trailing '}'");
                String gname = gsb.toString();
                if (ASCII.isDigit(gname.charAt(0)))
                    throw new IllegalArgumentException(
                        "capturing group name {" + gname +
                        "} starts with digit character");
                //{}中包含的内容，是分组的名字，分组存在，直接拿来分组的值，不存在则报错
                if (!parentPattern.namedGroups().containsKey(gname))
                    throw new IllegalArgumentException(
                        "No group with name {" + gname + "}");
                refNum = parentPattern.namedGroups().get(gname);
                cursor++;
            } else {
                // The first number is always a group
                refNum = nextChar - '0';
                // 只接受0-9的数字，也就是分组的序号
                if ((refNum < 0) || (refNum > 9))
                    throw new IllegalArgumentException(
                        "Illegal group reference");
                cursor++;
                // Capture the largest legal group string
                boolean done = false;
                while (!done) {
                    if (cursor >= replacement.length()) {
                        break;
                    }
                    int nextDigit = replacement.charAt(cursor) - '0';
                    if ((nextDigit < 0) || (nextDigit > 9)) { // not a number
                        break;
                    }
                    int newRefNum = (refNum * 10) + nextDigit;
                    if (groupCount() < newRefNum) {
                        done = true;
                    } else {
                        refNum = newRefNum;
                        cursor++;
                    }
                }
            }
            // Append group
            if (start(refNum) != -1 && end(refNum) != -1)
                result.append(text, start(refNum), end(refNum));
        } else {
            result.append(nextChar);
            cursor++;
        }
    }
    return result;
}

String Str = new String("Welcome to Tutoririalspoint.combb");
System.out.print("Return Value :" );
System.out.println(Str.replaceFirst("Tuto(.*)als(?<hi>.*)(bb)", "$1AMROOD}$2--$3--${hi}--xx"));
// 输出：
// Return Value :Welcome to ririAMROOD}point.com--bb--point.com--xx

private String showSql(Configuration configuration, BoundSql boundSql) {
  Object parameterObject = boundSql.getParameterObject();
  List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
  String sql = boundSql.getSql().replaceAll("[\\s]+", " ");
  if (parameterMappings.size() > 0 && parameterObject != null) {
    TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
    if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
      sql = sql.replaceFirst("\\?", Matcher.quoteReplacement(getParameterValue(parameterObject)));

    } else {
      MetaObject metaObject = configuration.newMetaObject(parameterObject);
      for (ParameterMapping parameterMapping : parameterMappings) {
        String propertyName = parameterMapping.getProperty();
        if (metaObject.hasGetter(propertyName)) {
          Object obj = metaObject.getValue(propertyName);
          sql = sql.replaceFirst("\\?", Matcher.quoteReplacement(getParameterValue(obj)));
        } else if (boundSql.hasAdditionalParameter(propertyName)) {
          Object obj = boundSql.getAdditionalParameter(propertyName);
          sql = sql.replaceFirst("\\?", Matcher.quoteReplacement(getParameterValue(obj)));
        }
      }
    }
  }
  return sql;
}

@PageAble
public Object method(int page, int size) {
	。。。
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PageAble {
	 String pageSizeName() default "size";
	 String pageNumName() default "page";
	 int pageSize() default 20;
	 int pageNum() default 1;
}

public class ResultPageView<T> {
	 private Long total = 0l;
	 private Integer current = 1;
	 private Integer pageCount = 0;
	 private List<T> list;
	 // 省略一些构造方法、getter/setter方法
}

private static final String PAGE_ABLE = "@annotation(com.xxxxxo0o0.baseservice.annotation.PageAble)";
@Around(PAGE_ABLE)
public Object doAroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
	logger.info("execute method : " + proceedingJoinPoint.getSignature().getName());
	try {
		// 准备开始分页
		prepare(proceedingJoinPoint);
		// 执行被注解的方法
		Object obj = proceedingJoinPoint.proceed();
		// 装饰被注解方法返回的值
		Object result = after(obj);
		return result;
	} catch (Throwable throwable) {
		logger.error("aspect execute error : ", throwable);
		throw throwable;
	} finally {
		// 先忽略这个finally里面的内容
		//PageHelper.clearPage();
	}
}

private void prepare(ProceedingJoinPoint point) throws Exception {
	Signature signature = point.getSignature();
	MethodSignature methodSignature = (MethodSignature) signature;
	Method targetMethod = methodSignature.getMethod();
	PageAble pageAble = targetMethod.getAnnotation(PageAble.class);
	// 获取参数名称
	String numName = pageAble.pageNumName();
	String sizeName = pageAble.pageSizeName();
	// 先获取page和size的默认值
	int pageNo = pageAble.pageNum();
	int pageSize = pageAble.pageSize();
	// 获取参数值列表
	Object[] paramValues = point.getArgs();
	// 获取参数名列表
	String[] paramNames = methodSignature.getParameterNames();
	int length = paramNames.length;
	// 对参数列表进行遍历
	for (int i = 0; i < length; i++) {
		// 如果参数名 == 注解中写入的页数参数名
		if (paramNames[i].equals(numName)) {
			// 从参数值列表中取出值，赋值给页数
			pageNo = (Integer) paramValues[i];
		// 如果参数名 == 注解中写入的每页数量的参数名
		} else if (paramNames[i].equals(sizeName)) {
			// // 从参数值列表中取出值，赋值为每页尺寸
			pageSize = (Integer) paramValues[i];
		}
	}
	// 调用PageHelper的分页
	PageHelper.startPage(pageNo, pageSize);
}

private Object after(Object obj) {
    assert obj instanceof List;
    PageInfo<?> pageInfo = new PageInfo((List<?>) obj);
    // 从某个地方获取的分页的信息。（其实是ThreadLocal，先忽略）
    Page<Object> localPage = PageHelper.getLocalPage();
    // 获取分页参数
    long total = localPage.getTotal();
    int pageNum = localPage.getPageNum();
    int pages = localPage.getPages();
    List<?> list = (List<?>) obj;
    try {
	    List<Map> mapList = new ArrayList<>();
	    for (Object o : list) {
	    	// 将一个对象按照原来的字段名转成map
			HashMap<String, Object> map = MapUtil.convertObj2Map(o);
			if (o instanceof BaseModel) {
				BaseModel baseModel = (BaseModel) o;
				map.put("id", baseModel.getId());
			}
			ReflectionUtils
			    .doWithFields(o.getClass(), new InnerFieldCallback(map, o), new InnerFieldFilter());
			mapList.add(map);
	    }
	    list = mapList;
    } catch (Exception e) {
		logger.error("convert obj to map occurred error ", e);
    }
    pageInfo = new PageInfo((list));
    ResultPageView<?> resultPageView;
    resultPageView = new ResultPageView<>(total, pageNum, pages, pageInfo.getList());
    // 清除分页信息
    PageHelper.clearPage();
    return resultPageView;
  }

/**
 * 开始分页
 *
 * @param pageNum      页码
 * @param pageSize     每页显示数量
 * @param count        是否进行count查询
 * @param reasonable   分页合理化,null时用默认配置
 * @param pageSizeZero true且pageSize=0时返回全部结果，false时分页,null时用默认配置
 */
public static <E> Page<E> startPage(int pageNum, int pageSize, boolean count, Boolean reasonable, Boolean pageSizeZero) {
    Page<E> page = new Page<E>(pageNum, pageSize, count);
    page.setReasonable(reasonable);
    page.setPageSizeZero(pageSizeZero);
    //当已经执行过orderBy的时候
    Page<E> oldPage = getLocalPage();
    if (oldPage != null && oldPage.isOrderByOnly()) {
        page.setOrderBy(oldPage.getOrderBy());
    }
    setLocalPage(page);
    return page;
}

PageHelper.startPage(1, 10);
List<Country> list;
if(param1 != null){
    list = countryMapper.selectIf(param1);
} else {
    list = new ArrayList<Country>();
}

public class MyPageHelper extends PageHelper {

	@Override
	public void afterAll() {
		// 获取分页信息
		Page<Object> localPage = getLocalPage();
		// 调用父类方法，即清除分页信息
		super.afterAll();
		// 又将分页信息塞回线程中。
		// 为什么要这样做？为了让在切面中，加入分页的详细信息。
		setLocalPage(localPage);
	}
}

@Override
public boolean skip(MappedStatement ms, Object parameterObject, RowBounds rowBounds) {
    if(ms.getId().endsWith(MSUtils.COUNT)){
        throw new RuntimeException("在系统中发现了多个分页插件，请检查系统配置!");
    }
    Page page = pageParams.getPage(parameterObject, rowBounds);
    if (page == null) {
        return true;
    } else {
        //设置默认的 count 列
        if(StringUtil.isEmpty(page.getCountColumn())){
            page.setCountColumn(pageParams.getCountColumn());
        }
        autoDialect.initDelegateDialect(ms);
        return false;
    }
}

// --------------------------Controller------------
  /**
   * 测试web端登录锁表
   */
  @GetMapping("/hotline/test")
  public void testSomeThing() throws InterruptedException {
    testService.doSomething();
  }
// ----------------------------Service----------------
@Service
public class TestService {

  @Autowired
  private BizConfMapper confMapper;

  @Transactional(rollbackFor = Exception.class)
  public void doSomething() throws InterruptedException {
    // 共享锁
    BizConf conf = confMapper.selectByPrimaryKey(0);
    // 排它锁
    confMapper.updateByPrimaryKey(conf);
    // 等待让下个线程超时，最起码要大于50
    Thread.sleep(60000);
  }
}

/**
 * 分布式锁
 */
@Component
public class DistributedLock {

    public static final Logger logger = LoggerFactory.getLogger(DistributedLock.class);
    /**
     * 加锁默认超时时间
     */
    private static final long DEFAULT_TIMEOUT_SECOND = 5;
    /**
     * 获取所等待的时间
     */
    private static final long DEFAULT_WAITE_TIMEOUT_SECOND = 5;
    /**
     * 加锁循环等待时间
     */
    private static final long LOOP_WAIT_TIME_MILLISECOND = 30;
    @Autowired
    @Qualifier("redisCacheService")
    private BaseCacheService cacheService;

    /**
     * 有超时等待的加锁
     *
     * @param timeoutSecond      如果为null,使用默认超时时间
     * @param waiteTimeoutSecond 若果为null,使用默认超时时间
     * @return 加锁的值（超时时间：-1表示获取失败，超时）
     */
    public long lock(String key, Long timeoutSecond, Long waiteTimeoutSecond) {

        logger.info("Thread：" + Thread.currentThread().getName() + " start lock");
        long beganTime = System.currentTimeMillis() / 1000;
        //如果参数错误
        if (timeoutSecond != null && timeoutSecond <= 0) {
            timeoutSecond = DEFAULT_TIMEOUT_SECOND;
        }
        timeoutSecond = timeoutSecond == null ? DEFAULT_TIMEOUT_SECOND : timeoutSecond;
        if (waiteTimeoutSecond != null && waiteTimeoutSecond <= 0) {
            waiteTimeoutSecond = DEFAULT_WAITE_TIMEOUT_SECOND;
        }
        waiteTimeoutSecond =
                waiteTimeoutSecond == null ? DEFAULT_WAITE_TIMEOUT_SECOND : waiteTimeoutSecond;
        while (true) {
            //等待超时判断
            long endTime = System.currentTimeMillis() / 1000;
            if ((endTime - beganTime) >= waiteTimeoutSecond) {
                return -1l;
            }
            //超时时间点
            long timeoutTimeMilli = cacheService.getCurrentTimeMilliForCache() + timeoutSecond * 1000;

            //如果设置成功
            if (cacheService.setIfAbsent(key, timeoutTimeMilli)) {
                logger.info("Thread：" + Thread.currentThread().getName() + " lock success");
                return timeoutTimeMilli;
            }

            //如果已经超时
            Long value = cacheService.getVal(key, Long.class);
            if (value != null && value.longValue() < cacheService.getCurrentTimeMilliForCache()) {

                //设置新的超时时间
                Long oldValue = cacheService.getAndSet(key, timeoutTimeMilli);

                //多个线程同时getset，只有第一个才可以获取到锁
                if (value.equals(oldValue)) {
                    logger.info("Thread：" + Thread.currentThread().getName() + " lock success");
                    return timeoutTimeMilli;
                }
            }

            //延迟一定毫秒，防止请求太频繁
            try {
                Thread.sleep(LOOP_WAIT_TIME_MILLISECOND);
            } catch (InterruptedException e) {
                logger.error("DistributedLock lock sleep error", e);
            }
        }
    }

    /**
     * 无超时等待的加锁
     *
     * @param timeoutSecond 如果为null,使用默认超时时间
     * @return 加锁的值（超时时间）
     */
    public long lock(String key, Long timeoutSecond) {

        logger.info("Thread：" + Thread.currentThread().getName() + " start lock");

        //如果参数错误
        if (timeoutSecond != null && timeoutSecond <= 0) {
            timeoutSecond = DEFAULT_TIMEOUT_SECOND;
        }
        timeoutSecond = timeoutSecond == null ? DEFAULT_TIMEOUT_SECOND : timeoutSecond;
        while (true) {
            //超时时间点
            long timeoutTimeMilli = cacheService.getCurrentTimeMilliForCache() + timeoutSecond * 1000;

            //如果设置成功
            // 若在redis中、没有相应的key值，那么可以认为，当前线程即或得该锁。
            if (cacheService.setIfAbsent(key, timeoutTimeMilli)) {
                logger.info("Thread：" + Thread.currentThread().getName() + " lock success");
                return timeoutTimeMilli;
            }

            //如果已经超时
            // 此时该key在redis已存在，获取该key的值
            Long value = cacheService.getVal(key, Long.class);
            if (value != null && value.longValue() < cacheService.getCurrentTimeMilliForCache()) {

                //设置新的超时时间
                // 如果此时获取到的oldValue，与前面获取的value相同，则说明该线程可以获得锁
                // 获得锁后，set进新值。
                Long oldValue = cacheService.getAndSet(key, timeoutTimeMilli);

                //多个线程同时getset，只有第一个才可以获取到锁
                if (value.equals(oldValue)) {
                    logger.info("Thread：" + Thread.currentThread().getName() + " lock success");
                    return timeoutTimeMilli;
                }
            }

            //延迟一定毫秒，防止请求太频繁
            try {
                Thread.sleep(LOOP_WAIT_TIME_MILLISECOND);
            } catch (InterruptedException e) {
                logger.error("DistributedLock lock sleep error", e);
            }
        }
    }

    /**
     * 释放锁
     */
    public void unLock(String key, long lockValue) {

        logger.info("Thread：" + Thread.currentThread().getName() + " start unlock");
        Long value = cacheService.getVal(key, Long.class);
        if (value != null && value.equals(lockValue)) {//如果是本线程加锁
            cacheService.deleteVal(key);
            logger.info("Thread：" + Thread.currentThread().getName() + " unlock success");
        }
    }
}