题目：
输入：类名(全类名)，方法名。
返回：用于cache的key值
要求：key值为DBO$+类名+方法名。不能超过50字符如果大于50，去掉包名。还大于，去掉类名。然后超长，截断方法名。
单元测试代码：
@Test
public void should_GenerateKey() throws Exception {
assertThat(cacheKey.generateKey("com.email.dao.Repository26", "saveProduct13"), is("DBO$com.email.dao.Repository26.saveProduct13"));
assertThat(cacheKey.generateKey("com.email.dao.Repository26", "saveLooooongProduct21"), is("DBO$Repository26.saveLooooongProduct21"));
assertThat(cacheKey.generateKey("com.email.dao.LoooooooooooogRepository40", "saveLooooongProduct21"), is("DBO$saveLooooongProduct21"));
assertThat(cacheKey.generateKey("com.email.dao.LoooooooooooogRepository40", "saveLooooooooooooooooooooooooooooooongProduct47"), is("DBO$saveLooooooooooooooooooooooooooooooongProduc.~"));
}
原始代码 V0：
// CacheKey.java
public String generateKey(String service, String method) {
String head = "DBO$";
String key = "";
int len = head.length() + service.length() + method.length();
if (len <= 50) {
key = head + service + "." + method;
} else {
service = service.substring(service.lastIndexOf(".") + 1);
len = head.length() + service.length() + method.length();
key = head + service + "." + method;
if (len > 50) {
key = head + method;
if (key.length() > 50) {
key = key.substring(0, 48) + ".~";
}
}
}
return key;
}
重构思路：
其实原始代码的思路还是比较清晰，利用变量key存储结果，组合出不同情况下可能的CacheKey，利用临时变量len判断是否达到题目要求。 在这个过程中，发生变化的量实在有点多，if...else...的嵌套层数也很深，所以导致代码阅读起来比较费事儿。
所以第一步，就是试图去干掉这些坏味道，找寻能够复用的逻辑。
这一步最重要是用到了Replace Nested Conditional with Guard Clauses方法。当发现一堆嵌套的if...else...并且不断地在这中间给某一变量赋值时候，就可以考虑是否可以用这个重构方法了，思路是把赋值的地方return，然后减少if...else...嵌套层数。
其余的改动如提取常量就不说了，这样我们得到了改进的第一版。
V1:
// CacheKey.java
public static final String HEAD = "DBO$";
public static final int LIMIT = 50;
private String generateKey(String service, String method) {
if (length(service, method) <= LIMIT) {
return HEAD + service + "." + method;
}
service = service.substring(service.lastIndexOf(".") + 1);
if (length(service, method) <= LIMIT) {
return HEAD + service + "." + method;
}
service = "";
if (length(service, method) <= LIMIT) {
return HEAD + service + method;
}
return (HEAD + service + method).substring(0, 48) + ".~";
}
private int length(String service, String method) {
return HEAD.length() + service.length() + method.length();
}
重写思路：
重构到V1版本，代码可读性已经有了质的提升了。
通过代码我们可以很清晰地了解到它的意图（“哦，原来就是求字符串长度，然后每次去和LIMIT这个限制去比较，如果小于LIMIT就返回，不然就往下走”）。这样的代码已经算是很成功的重构了，不信你去看着原始代码，然后试图去用比括弧里面内心OS更少的字数去描述它。
接下去的想法是既然模式已经出现了（三个长得一样的if判断），那还有没有更好的办法去复用上这段逻辑，况且不断变化的service这个变量感觉也怪别扭。
V2:
// CacheKey.java
public static final String HEAD = "DBO$";
public static final int LIMIT = 50;
public String generateKey(String service, String method) {
return new StrLimit(LIMIT)
.tryString(StringUtils.left((HEAD + method), LIMIT - 2)+ ".~")
.tryString(HEAD + method)
.tryString(HEAD + getClassName(service) + method)
.tryString(HEAD + getPackageName(service) + getClassName(service) + method)
.get();
}
private String getPackageName(String service) {
return service.substring(0, service.lastIndexOf(".")) + ".";
}
private String getClassName(String service) {
return service.substring(service.lastIndexOf(".") + 1) + ".";
}
// StrLimit.class
public class StrLimit {
private int limit;
private String tempString;
public StrLimit(int limit) {
this.limit = limit;
}
public StrLimit tryString(String s) {
if (s.length() <= limit) {
this.tempString = s;
}
return this;
}
public String get() {
return this.tempString;
}
}
在V2版本，专门搞了个类StrLimit来执行判断的逻辑，这样虽然从代码行数来说比V1版本更多了，但不断和LIMIT比较的逻辑被很好地封装在了trySting这个函数内，而且StrLimit这个类与我们题目本身的业务数据和需求并没有很强的耦合关系，所以单独提出来也算ok。
另外加入了getPackageName和getClassName两个函数，能够增加代码的可读性，毕竟在需求里面，包名、类名是有区分的，而入参里面service却同时包含了包名和类名，区分出来更好理解一些。
(需要注意的是那个LIMIT-2中的2代表的是“.~”的字符串长度。)
还有一种思路是从算法角度上去重做：将特殊字符镶嵌在包名、类名、方法名中间，拼接成一条长长的字符串，然后不管3721把它截取指定长度，通过判断剩余字符串中特殊字符的数量来决定最终CacheKey。感觉思路可行，所以也实现了一把：
V3:
// CacheKey.java
public String generateKey2(String service, String method) {
String afterConcat = concatWithSeparator(service, method);
String afterCut = cutToLimit(afterConcat);
int nubOfSEP = StringUtils.countMatches(afterCut, SEPARATOR);
if (nubOfSEP == 2) {
return afterCut.startsWith(getPackageName(service)) ?
HEAD + getPackageName(service) + getClassName(service) + method :
HEAD + getClassName(service) + method;
}
if (nubOfSEP == 1) {
return HEAD + method;
}
if (nubOfSEP == 0) {
return (HEAD + method).substring(0, 48) + ".~";
}
throw new RuntimeException("Should not be here.");
}
private String cutToLimit(String afterConcat) {
if (afterConcat.length() + HEAD.length() + 2 > LIMIT) {
return StringUtils.right(afterConcat, LIMIT - 2 - HEAD.length());
} else {
return afterConcat;
}
}
private String concatWithSeparator(String service, String method) {
return getPackageName(service) + SEPARATOR + getClassName(service) + SEPARATOR + method;
}
好吧，写完之后都被自己恶心到了，这个。
不如V1、V2不说，甚至跟原始代码比都没有什么优势。
最后贴上@VK同学的代码：
private static final String POSTFIX = ".~";
private static final int LIMIT = 50;
public String generateKey(String service, String method) {
String head = "DBO$";
String className = service.substring(service.lastIndexOf(".") + 1);
String packageName = service.substring(0, service.lastIndexOf(".") + 1);
int remainderLength = LIMIT - head.length();
if (method.length() > remainderLength) {
method = method.substring(0, remainderLength - POSTFIX.length()) + POSTFIX;
remainderLength = 0;
} else {
remainderLength -= method.length();
}
if (className.length() > remainderLength) {
className = "";
remainderLength = 0;
} else {
className = className + ".";
remainderLength -= className.length();
}
if (packageName.length() > remainderLength) {
packageName = "";
}
return head + packageName + className + method;
}
还有@lambeta同学的：
private static final int LIMIT = 50;
public String generateKey(String service, String method) {
String head = "DBO$";
String simpleName = service.substring(service.lastIndexOf(".") + 1);
String packageName = service.substring(0, service.lastIndexOf(".") + 1);
int limitOfMethod = LIMIT - head.length();
int limitOfClassName = limitOfMethod - method.length();
int limitOfPackageName = limitOfClassName - simpleName.length();
return head +
cond(packageName.length() > limitOfPackageName, () -> "", () -> packageName) +
cond(simpleName.length() > limitOfClassName, () -> "", () -> simpleName + ".") +
cond(method.length() > limitOfMethod, () -> method.substring(0, limitOfMethod - 2) + ".~", () -> method);
}
private static String cond(boolean expr, Supplier<String> lhs, Supplier<String> rhs) {
return expr ? lhs.get() : rhs.get();
}
原题来自于中国软件匠艺小组
网友评论