Groovy源代码分析（⼆）
2021SC@SDUSC
Groovy对Java类的扩展（上）
⾸先，我们来看⼀下groovy源码中有哪⼏个核⼼的包，如下图：
groovy的核⼼代码都在groovy-3.0.9这个jar包中，这个jar包中最重要的两个包分别是:groovy和org,⽽groovy中重点存的就是⼀些groovy对json,xml等处理的类，我们之后再详细讲解这个包中的核⼼类，今天我们分析的是org这个包中的核⼼类。⽽我们重点要讲解org/codehaus/groovy/runtime包中的核⼼类，其它包中的类则是⼀些辅助类，这个包中有如下⼏个类是我们要重点分析的，他们的类UML图如下所⽰：
下⾯我来为⼤家解释⼀下这个类图，可以看到核⼼的⼀个⽗类就是DefaultGroovyMethodsSupport,⽽其它的类都是他的⼦类，⼦类有⼀个共同的特点就是类名都是：XXXGroovyMethods，那我们为什么说这⼏个类是核⼼类呢，了解过groovy的同学都应该知道，groovy是java的扩展，那groovy扩展了那些东西呢，除了我们还没有讲的groovy包中的⼀些类，另⼀部分的扩展就是我们图中的这些XXXGroovyMethods类中的⽅法，举个例⼦，⼤家来看下⾯这段代码：
String content = new File('').text
println content
这两句代码的作⽤⾮常的明显，就是获取到⽂件中的内容，并打印出来，在java中，我们要创建⽂件类，然后通过创建⼀个流来读取出⽂件内容，⽽且还要关闭⽂件流，可谓是⾮常的繁杂。⽽在groovy中则⾮常的清爽，下⾯我们看⼀下groovy是如何实现这个text⽅法的，代码如下：
//最终的实现就在这⾥，这个⽅法是在IOGroovyMethods类中
public static String getText(BufferedReader reader) throws IOException {
StringBuilder answer = new StringBuilder();
char[] charBuffer = new char[8192];
try {
int nbCharRead;
while((nbCharRead = ad(charBuffer)) != -1) {
answer.append(charBuffer, 0, nbCharRead);
}
Reader temp = reader;
reader = null;
temp.clo();
} finally {
cloWithWarning(reader);
}
String();
}
过路人通过这段代码可以看到，Groovy底层的实现与Java原来的实现完全⼀样，只是groovy替我们完成了封装使得我们可以直接通过getText()⽅法来得到整个⽂本⽂件的内容。从这个⽅法，我们就可以看出groovy对java所作的扩展有多么的强⼤。
这也就是我们为什么要重点看这⼏个类，了解了这⼏个类的话就基本可以清楚地知道groovy对java做了那些扩展。
下⾯我们就分别来看⼀下这⼏个类是为java中的类做了那些扩展，我们⾸先来看⼀下DefaultGroovyMethods这个⽅法做了那些扩展，⾸先⼤家
要知道的是，这个类是对所有java中的类的⼀个扩展，也就是java中的任何⼀个类，在groovy中都是可以使⽤DefaultGroovyMethods中的⽅法的，下⾯我们来看⼀些⽐较常⽤的⽅法：
private static final Logger LOG = Logger(Name());
植树节来历private static final Integer ONE = Integer.valueOf(1);
private static final BigInteger BI_INT_MAX = BigInteger.valueOf(2147483647L);
private static final BigInteger BI_INT_MIN = BigInteger.valueOf(-2147483648L);
private static final BigInteger BI_LONG_MAX = BigInteger.valueOf(9223372036854775807L);
private static final BigInteger BI_LONG_MIN = BigInteger.valueOf(-9223372036854775808L);
public static final Class[] additionals = new Class[]{NumberNumberPlus.class, NumberNumberMultiply.class, NumberNumberMinus.class, NumberNumberDiv.cla public static final Class[] DGM_LIKE_CLASSES = new Class[]{DefaultGroovyMethods.class, DateGroovyMethods.class, EncodingGroovyMethods.class, IOGroov private static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
private static final NumberAwareComparator<Comparable> COMPARABLE_NUMBER_AWARE_COMPARATOR = new NumberAwareComparator();
public DefaultGroovyMethods() {
}
//⽤来直接判断other对象是否与调⽤对象相等
public static boolean is(Object lf, Object other) {
return lf == other;
}
//直接判断迭代器中的对象是否是唯⼀的
public static <T> Iterator<T> unique(Iterator<T> lf) {
return toList((Iterable)unique(toList(lf))).listIterator();
}
public static <T> Collection<T> unique(Collection<T> lf) {
return unique(lf, true);
}
/
/任意对象都都可以使⽤each⽅法来进⾏遍历，当然如果是不可迭代对象，会报错
public static <T> T each(T lf, Closure closure) {
each(InvokerHelper.asIterator(lf), closure);
return lf;
}
public static <T> T eachWithIndex(T lf, Closure closure) {山石榴花
Object[] args = new Object[2];
int counter = 0;
Iterator iter = InvokerHelper.asIterator(lf);
while(iter.hasNext()) {
args[0] = ();
args[1] = Integer.valueOf(counter++);
closure.call(args);
}
return lf;
}
这⾥就不⼀⼀列出了，这个类是对java对象做的⼀个扩展。
下⾯我们再来看StringGroovyMethods，从这个类的类名我们就可以看出，这个类是针对java中的String做的扩展，下⾯我们来看⼀下这
个类中对Java中的String类做了那些扩展：
static String lineSeparator = null;
public StringGroovyMethods() {
}
public static String uncapitalize(CharSequence lf) {
String s = lf.toString();
return s != null && s.length() != LowerCa(s.charAt(0)) + s.substring(1):s;
}
//将String⾸字母⼤写，这个⽅法⾮常的常⽤，尤其在⾃定义Task时候
public static String capitalize(CharSequence lf) {
return lf.length() == 0?"":"" + UpperCa(lf.charAt(0)) + lf.subSequence(1, lf.length());
}
//遍历字符串中的每个字符，并将对应的字符应⽤闭包
public static <T> T eachLine(CharSequence lf, @ClosureParams(value = FromString.class,options = {"String", "String,Integer"}) Closure<T> closure) throws IO return eachL
ine((String(), 0, closure);
}
public static <T> T eachLine(CharSequence lf, int firstLine, @ClosureParams(value = FromString.class,options = {"String", "String,Integer"}) Closure<T> closu int count = firstLine;
T result = null;
for(Iterator var5 = String()).iterator(); var5.hasNext(); ++count) {
String line = (();
result = DefaultGroovyMethods.callClosureForLine(closure, line, count);
}
return result;
}
其它的⽅法，我们也不再列出，可见通过StringGroovyMethods对⽅法的扩展，可以极⼤的⽅便我们的开发。
⽽ResourceGroovyMethods和IOGroovyMethods则是对⽂件IO流的扩展。⼀些常⽤的⽅法如下：
//获取⽂件中的字节码
public static byte[] getBytes(File file) throws IOException {
Bytes(new FileInputStream(file));
}
public static byte[] getBytes(InputStream is) throws IOException {
ByteArrayOutputStream answer = new ByteArrayOutputStream();
byte[] byteBuffer = new byte[8192];
int nbByteRead;
try {
while((nbByteRead = is.read(byteBuffer)) != -1) {
answer.write(byteBuffer, 0, nbByteRead);
}
诡辩学派} finally {
cloWithWarning(is);
}
ByteArray();
}
杜甫被誉为什么
//获取⽂件中的每⼀⾏内容，并对其应⽤闭包
public static <T> T eachLine(Reader lf, @ClosureParams(value = FromString.class,options = {"String", "String,Integer"}) Closure<T> closure) throws IOExceptio return eachLine((Reader)lf, 1, closure);
}
public static <T> T eachLine(Reader lf, int firstLine, @ClosureParams(value = FromString.class,options = {"String", "String,Integer"}) Closure<T> closure) thro int count = firstLine;
int count = firstLine;
T result = null;散字成语
BufferedReader br;
if(lf instanceof BufferedReader) {
br = (BufferedReader)lf;
} el {
br = new BufferedReader(lf);
}
try {
while(true) {
String line = br.readLine();
if(line == null) {
Reader temp = lf;
lf = null;
temp.clo();
Object var7 = result;
return var7;
}
result = DefaultGroovyMethods.callClosureForLine(closure, line, count);
++count;
}
} finally {
cloWithWarning(lf);
cloWithWarning(br);
}
}
//获取每⾏⽂件内容并返回调⽤者
public static String readLine(Reader lf) throws IOException {
if(lf instanceof BufferedReader) {
BufferedReader br = (BufferedReader)lf;
秋天的什么作文
adLine();
} el {
return lf.markSupported()?readLineFromReaderWithMark(lf):readLineFromReaderWithoutMark(lf);
}
}
//对每个字节使⽤闭包，与eachLine作⽤类似
public static void eachByte(InputStream is, @ClosureParams(value = SimpleType.class,options = {"byte"}) Closure closure) throws IOException {
try {
while(true) {
int b = is.read();
if(b == -1) {
什么是丙肝InputStream temp = is;
is = null;
temp.clo();
return;
}
closure.call(Byte.valueOf((byte)b));
}
} finally {
cloWithWarning(is);
}
}
这是我举出来的这两个类中的常⽤⽅法，可以看到，有了groovy对IO流的扩展，我们可以直接对⽂件，流进⾏更⽅便的操作。
最后⼀个⽐较重要的就是我们的EncodingGroovyMethods，这个类我们通过名字也可以看出， 是与编解码相关的扩展，代码如下：
public class EncodingGroovyMethods {
private static final char[] T_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".toCharArray();
private static final char[] T_TABLE_URLSAFE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=".toCharArray(); private static final String CHUNK_SEPARATOR = "\r\n";
