Spoon是分析，生成和轉(zhuǎn)換Java代碼的工具。

在本文中，我們將看到通過使用以編程方式處理代碼的技術(shù)可以實(shí)現(xiàn)什么。 我認(rèn)為這些技術(shù)不是很廣為人知或使用，這很遺憾，因?yàn)樗鼈兛赡芊浅Ｓ杏谩?誰知道，即使您不想使用Spoon甚至不處理Java代碼，而是使用C＃，Python，Kotlin或其他語言，某些想法對(duì)于您當(dāng)前的項(xiàng)目也可能有用。 讓我們學(xué)習(xí)如何以更智能的方式編程。

Spoon具有一些與JavaParser重疊的功能， JavaParser是我貢獻(xiàn)的框架。 對(duì)于某些任務(wù)，Spoon可能是更好的選擇，而對(duì)于另一些任務(wù)，JavaParser具有明顯的優(yōu)勢。 稍后，我們將深入探討這些工具之間的差異。

本文與隨附的存儲(chǔ)庫與所有代碼配對(duì)： ftomassetti / spoon-examples

使用代碼處理技術(shù)可以實(shí)現(xiàn)什么？

勺子和一般的代碼處理工具可用于：

• 代碼分析
  • 計(jì)算源代碼指標(biāo)，例如找出多少類具有比一定數(shù)量的方法更多的類
• 代碼生成
  • 以編程方式生成重復(fù)代碼。
• 代碼轉(zhuǎn)換
  • 自動(dòng)重構(gòu)，例如在構(gòu)造函數(shù)中指定的字段中轉(zhuǎn)換幾種方法中使用的參數(shù)

這三大家族與我們與代碼交互的方式大致不同：

• 在代碼分析中，代碼是我們用來產(chǎn)生非代碼輸出的輸入
• 在代碼生成中，我們使用一些通常不是代碼的輸入，或者使用與我們輸出的語言相同的代碼。 輸出是代碼
• 在代碼轉(zhuǎn)換中，相同的代碼庫是輸入和輸出

設(shè)置湯匙

要設(shè)置湯匙，您需要提供：

• 要分析的代碼
• 所有依賴關(guān)系（當(dāng)然還有依賴關(guān)系的依賴關(guān)系）

利用此信息，Spoon可以構(gòu)建代碼模型。 在該模型上，您可以執(zhí)行相當(dāng)高級(jí)的分析。 這與JavaParser的工作方式不同。 如果需要，在JavaParser中，您可以構(gòu)建代碼的輕量級(jí)模型，而無需考慮依賴關(guān)系。 當(dāng)您沒有可用的依賴項(xiàng)或需要執(zhí)行簡單快速的操作時(shí)，這將很有用。 您也可以通過啟用符號(hào)解析來進(jìn)行更高級(jí)的分析，但這是可選的，并且在僅某些依賴項(xiàng)可用時(shí)也可以使用。

我喜歡Spoon的一件事是支持從Maven進(jìn)行配置。 我認(rèn)為這是一個(gè)非常有用的功能。 但是，我只想得到Gradle的支持。

在我們的示例中，我們不使用Maven配置，我們僅指定一個(gè)包含代碼的目錄。 在我們的例子中，我們正在檢查JavaParser的核心模塊，該模塊的依賴項(xiàng)為零，因此我們無需指定任何JAR即可構(gòu)建代碼模型。

fun main(args: Array<String>) {val launcher = Launcher()launcher.addInputResource("codebases/jp/javaparser-core/src/main/java")launcher.environment.noClasspath = trueval model = launcher.buildModel()... }

現(xiàn)在我們有了一個(gè)模型，讓我們看看如何使用它。

順便說一句，示例是用Kotlin編寫的，因?yàn)樗且环N簡潔明了的語言，我認(rèn)為它非常適合教程。 你同意嗎？

使用Spoon執(zhí)行代碼分析

讓我們開始使用20多種方法打印類列表：

fun examineClassesWithManyMethods(ctModel: CtModel, threshold: Int = 20) {val classes = ctModel.filterChildren<CtClass<*>> {it is CtClass<*> && it.methods.size > threshold}.list<CtClass<*>>()printTitle("Classes with more than $threshold methods")printList(classes.asSequence().sortedByDescending { it.methods.size }.map { "${it.qualifiedName} (${it.methods.size})"})println() }fun main(args: Array<String>) {val launcher = Launcher()launcher.addInputResource("codebases/jp/javaparser-core/src/main/java")launcher.environment.noClasspath = trueval model = launcher.buildModel()examineClassesWithManyMethods(model) }

在本示例中，我們?cè)谥饕瘮?shù)中設(shè)置模型，然后在inspectClassesWithManyMethods中 ，按方法數(shù)量過濾類，然后使用幾個(gè)實(shí)用程序函數(shù)來打印這些類的列表（printTitle ， printList ）。

運(yùn)行此代碼，我們獲得以下輸出：

===================================== | Classes with more than 20 methods | =====================================* com.github.javaparser.ast.expr.Expression (141)* com.github.javaparser.printer.PrettyPrintVisitor (105)* com.github.javaparser.ast.visitor.EqualsVisitor (100)* com.github.javaparser.ast.visitor.NoCommentEqualsVisitor (98)* com.github.javaparser.ast.visitor.CloneVisitor (95)* com.github.javaparser.ast.visitor.GenericVisitorWithDefaults (94)* com.github.javaparser.ast.visitor.ModifierVisitor (94)* com.github.javaparser.ast.visitor.VoidVisitorWithDefaults (94)* com.github.javaparser.ast.visitor.HashCodeVisitor (93)* com.github.javaparser.ast.visitor.NoCommentHashCodeVisitor (93)* com.github.javaparser.ast.visitor.ObjectIdentityEqualsVisitor (93)* com.github.javaparser.ast.visitor.ObjectIdentityHashCodeVisitor (93)* com.github.javaparser.ast.stmt.Statement (92)* com.github.javaparser.ast.visitor.GenericListVisitorAdapter (92)* com.github.javaparser.ast.visitor.GenericVisitorAdapter (92)* com.github.javaparser.ast.visitor.VoidVisitorAdapter (92)* com.github.javaparser.ast.Node (62)* com.github.javaparser.ast.NodeList (62)* com.github.javaparser.ast.type.Type (55)* com.github.javaparser.ast.body.BodyDeclaration (50)* com.github.javaparser.ast.modules.ModuleDirective (44)* com.github.javaparser.ast.CompilationUnit (44)* com.github.javaparser.JavaParser (39)* com.github.javaparser.resolution.types.ResolvedReferenceType (37)* com.github.javaparser.utils.SourceRoot (34)* com.github.javaparser.ast.body.CallableDeclaration (29)* com.github.javaparser.ast.body.MethodDeclaration (28)* com.github.javaparser.printer.PrettyPrinterConfiguration (27)* com.github.javaparser.metamodel.PropertyMetaModel (26)* com.github.javaparser.ast.type.WildcardType (25)* com.github.javaparser.ast.expr.ObjectCreationExpr (24)* com.github.javaparser.ast.type.PrimitiveType (24)* com.github.javaparser.printer.lexicalpreservation.NodeText (24)* com.github.javaparser.utils.VisitorList (24)* com.github.javaparser.printer.lexicalpreservation.Difference (23)* com.github.javaparser.ast.comments.Comment (22)* com.github.javaparser.ast.expr.FieldAccessExpr (22)* com.github.javaparser.ast.type.ClassOrInterfaceType (22)* com.github.javaparser.utils.Utils (22)* com.github.javaparser.JavaToken (22)* com.github.javaparser.ast.body.ClassOrInterfaceDeclaration (21)* com.github.javaparser.ast.body.FieldDeclaration (21)* com.github.javaparser.ast.expr.MethodCallExpr (21)* com.github.javaparser.ast.stmt.ExplicitConstructorInvocationStmt (21)* com.github.javaparser.ast.stmt.IfStmt (21)* com.github.javaparser.ParserConfiguration (21)

現(xiàn)在讓我們嘗試其他的東西。 讓我們嘗試查找所有測試類，并確保其名稱以“ Test”結(jié)尾。 測試類將是至少具有用org.unit.Test注釋的方法的類。

fun CtClass<*>.isTestClass() = this.methods.any { it.annotations.any { it.annotationType.qualifiedName == "org.junit.Test" } }fun verifyTestClassesHaveProperName(ctModel: CtModel) {val testClasses = ctModel.filterChildren<CtClass<*>> { it is CtClass<*> && it.isTestClass() }.list<CtClass<*>>()val testClassesNamedCorrectly = testClasses.filter { it.simpleName.endsWith("Test") }val testClassesNotNamedCorrectly = testClasses.filter { it !in testClassesNamedCorrectly }printTitle("Test classes named correctly")println("N Classes named correctly: ${testClassesNamedCorrectly.size}")println("N Classes not named correctly: ${testClassesNotNamedCorrectly.size}")printList(testClassesNotNamedCorrectly.asSequence().sortedBy { it.qualifiedName }.map { it.qualifiedName }) }fun main(args: Array<String>) {val launcher = Launcher()launcher.addInputResource("codebases/jp/javaparser-core/src/main/java")launcher.addInputResource("codebases/jp/javaparser-core-testing/src/test/java")launcher.addInputResource("libs/junit-vintage-engine-4.12.3.jar")launcher.environment.noClasspath = trueval model = launcher.buildModel()verifyTestClassesHaveProperName(model) }

構(gòu)建模型與以前幾乎相同，我們只是添加了更多的源目錄和JAR，作為測試模塊對(duì)JUnit的依賴。

在verifyTestClassesHaveProperName中，我們：

• 過濾所有屬于測試類的類 （它們至少具有一個(gè)用org.junit.Test注釋的方法）
• 查找所有名稱以Test結(jié)尾的測試類，以及所有不包含
• 我們打印要修復(fù)的類的列表以及有關(guān)它們的一些統(tǒng)計(jì)信息

讓我們運(yùn)行這段代碼，我們得到以下結(jié)果：

================================ | Test classes named correctly | ================================ N Classes named correctly: 124 N Classes not named correctly: 2* com.github.javaparser.wiki_samples.CreatingACompilationUnitFromScratch* com.github.javaparser.wiki_samples.removenode.RemoveDeleteNodeFromAst

當(dāng)然，這些只是相當(dāng)簡單的示例，但希望它們足以顯示Spoon和代碼分析的潛力。 處理代表您的代碼的模型，提取有趣的信息以及驗(yàn)證是否遵守某些語義規(guī)則是相當(dāng)容易的。

有關(guān)更高級(jí)的用法，您還可以查看有關(guān)使用Spoon進(jìn)行體系結(jié)構(gòu)實(shí)施的本文。

使用Spoon執(zhí)行代碼生成

讓我們來看一個(gè)考慮一個(gè)常見任務(wù)的代碼生成示例：JSON的代碼序列化和反序列化。 我們將從采用JSON模式開始，然后我們將生成表示JSON模式描述的實(shí)體的類。

這是一個(gè)相當(dāng)高級(jí)的示例，我花了一些時(shí)間熟悉Spoon才能編寫它。 我還必須向他們的團(tuán)隊(duì)提出一些問題，以解決一些問題。 的確，這段代碼絕非易事，但是我認(rèn)為我們應(yīng)該認(rèn)為這是一個(gè)非常復(fù)雜的功能，因此對(duì)我來說聽起來很公平。

好的，現(xiàn)在讓我們進(jìn)入代碼。

這是一個(gè)JSON模式：

{"$id": "https://example.com/arrays.schema.json","$schema": "http://json-schema.org/draft-07/schema#","description": "A representation of a person, company, organization, or place","type": "object","properties": {"fruits": {"type": "array","items": {"type": "string"}},"vegetables": {"type": "array","items": { "$ref": "#/definitions/veggie" }}},"definitions": {"veggie": {"type": "object","required": [ "veggieName", "veggieLike" ],"properties": {"veggieName": {"type": "string","description": "The name of the vegetable."},"veggieLike": {"type": "boolean","description": "Do I like this vegetable?"}}}} }

在頂層，我們可以看到整個(gè)架構(gòu)所代表的實(shí)體。 我們知道它將被表示為一個(gè)對(duì)象并具有兩個(gè)屬性：

• 水果 ：字符串?dāng)?shù)組
• 蔬菜 ：一組蔬菜 ，其中蔬菜是下面描述的另一個(gè)對(duì)象，在“定義”部分中

在定義部分，我們可以看到素食是具有兩個(gè)屬性的對(duì)象：

• veggieName ：字符串
• veggieLike ：布爾值

我們應(yīng)該得到什么

我們想要得到的是兩個(gè)java類：一個(gè)代表整個(gè)模式，一個(gè)代表單個(gè)蔬菜。 這兩個(gè)類應(yīng)允許讀取和寫入單個(gè)字段，將實(shí)例序列化為JSON以及從JSON反序列化實(shí)例。

我們的代碼應(yīng)生成兩個(gè)類：

package com.thefruit.company;public class FruitThing implements com.strumenta.json.JsonSerializable {private java.util.List<java.lang.String> fruits;public java.util.List<java.lang.String> getFruits() {return fruits;}public void setFruits(java.util.List<java.lang.String> fruits) {this.fruits = fruits;}private java.util.List<com.thefruit.company.Veggie> vegetables;public java.util.List<com.thefruit.company.Veggie> getVegetables() {return vegetables;}public void setVegetables(java.util.List<com.thefruit.company.Veggie> vegetables) {this.vegetables = vegetables;}public com.google.gson.JsonObject serialize() {com.google.gson.JsonObject res = new com.google.gson.JsonObject();res.add("fruits", com.strumenta.json.SerializationUtils.serialize(fruits));res.add("vegetables", com.strumenta.json.SerializationUtils.serialize(vegetables));return res;}public static com.thefruit.company.FruitThing unserialize(com.google.gson.JsonObject json) {com.thefruit.company.FruitThing res = new com.thefruit.company.FruitThing();res.setFruits((java.util.List) com.strumenta.json.SerializationUtils.unserialize(json.get("fruits"), com.google.gson.reflect.TypeToken.getParameterized(java.util.List.class, java.lang.String.class)));res.setVegetables((java.util.List) com.strumenta.json.SerializationUtils.unserialize(json.get("vegetables"), com.google.gson.reflect.TypeToken.getParameterized(java.util.List.class, com.thefruit.company.Veggie.class)));return res;} }

和：

package com.thefruit.company;public class Veggie implements com.strumenta.json.JsonSerializable {private java.lang.String veggieName;public java.lang.String getVeggieName() {return veggieName;}public void setVeggieName(java.lang.String veggieName) {this.veggieName = veggieName;}private boolean veggieLike;public boolean getVeggieLike() {return veggieLike;}public void setVeggieLike(boolean veggieLike) {this.veggieLike = veggieLike;}public com.google.gson.JsonObject serialize() {com.google.gson.JsonObject res = new com.google.gson.JsonObject();res.add("veggieName", com.strumenta.json.SerializationUtils.serialize(veggieName));res.add("veggieLike", com.strumenta.json.SerializationUtils.serialize(veggieLike));return res;}public static com.thefruit.company.Veggie unserialize(com.google.gson.JsonObject json) {com.thefruit.company.Veggie res = new com.thefruit.company.Veggie();res.setVeggieName((java.lang.String) com.strumenta.json.SerializationUtils.unserialize(json.get("veggieName"), com.google.gson.reflect.TypeToken.get(java.lang.String.class)));res.setVeggieLike((boolean) com.strumenta.json.SerializationUtils.unserialize(json.get("veggieLike"), com.google.gson.reflect.TypeToken.get(boolean.class)));return res;} }

這是我們?nèi)绾问褂眠@兩個(gè)類的示例：

package com.thefruit.company;import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.JsonElement;import java.util.Arrays;public class Example {public static void main(String[] args) {FruitThing ft = new FruitThing();ft.setFruits(Arrays.asList("Banana", "Pear", "Apple"));Veggie cucumber = new Veggie();cucumber.setVeggieLike(false);cucumber.setVeggieName("Cucumber");Veggie carrot = new Veggie();carrot.setVeggieLike(true);carrot.setVeggieName("Carrot");ft.setVegetables(Arrays.asList(cucumber, carrot));Gson gson = new GsonBuilder().setPrettyPrinting().create();System.out.println(gson.toJson(ft.serialize()));JsonElement serialized = ft.serialize();FruitThing unserializedFt = FruitThing.unserialize(serialized.getAsJsonObject());System.out.println("Fruits: " + unserializedFt.getFruits());} }

在該示例中，我們構(gòu)建了FruitThing和幾個(gè)Veggies的實(shí)例。 然后，我們對(duì)它們進(jìn)行序列化并反序列化它們，以便我們可以證明序列化和反序列化都可以工作。

生成過程：一般組織

生成過程將生成一組GeneratedJavaFile實(shí)例，每個(gè)實(shí)例都有自己的文件名和代碼。 以后我們可以將它們寫入文件或在內(nèi)存中進(jìn)行編譯。

在程序的主要功能中，我們將讀取JSON模式并將其傳遞給函數(shù)generateJsonSchema 。 我們將其與兩個(gè)參數(shù)一起傳遞：首先在其中生成我們的類的包的名稱，然后是代表整個(gè)架構(gòu)的類的名稱。

一旦我們獲得了生成的類，我們就將它們打印在屏幕上以快速瀏覽。

data class GeneratedJavaFile(val filename: String, val code: String)fun main(args: Array<String>) {Dummy::class.java.getResourceAsStream("/a_json_schema.json").use {val generatedClasses = generateJsonSchema(it, "com.thefruit.company", "FruitThing")generatedClasses.forEach {println("*".repeat(it.filename.length))println(it.filename)println("*".repeat(it.filename.length))println(it.code)}} }

好的，所以魔術(shù)發(fā)生在generateJsonSchema中，對(duì)嗎？

fun generateJsonSchema(jsonSchema: InputStream, packageName: String, rootClassName: String) : List<GeneratedJavaFile> {val rawSchema = JSONObject(JSONTokener(jsonSchema))val schema = SchemaLoader.load(rawSchema) as ObjectSchemaval cus = generateClasses(schema, packageName, rootClassName)val pp = DefaultJavaPrettyPrinter(StandardEnvironment())return cus.map { cu ->pp.calculate(cu, cu.declaredTypes)val filename = cu.declaredTypes[0].qualifiedName.replace('.', File.separatorChar) + ".java"GeneratedJavaFile(filename, pp.result)} }

在generateJsonSchema中，我們解析提供模式的InputStream，并調(diào)用generateClasses ，這將返回一堆CompilationUnits。 基本上，每個(gè)CompilationUnit都是單個(gè)Java文件的抽象語法樹。

一旦獲得了這些編譯單元，就將它們打印為Java代碼。 我們還計(jì)算適當(dāng)?shù)奈募?shí)例化GeneratedJavaFile實(shí)例。

因此，看來我們現(xiàn)在來看一下generateClasses 。

fun generateClasses(schema: ObjectSchema, packageName: String, rootClassName: String) : List<CompilationUnit> {// First we create the classesval pack = CtPackageImpl()pack.setSimpleName<CtPackage>(packageName)val classProvider = ClassProvider(pack)schema.generateClassRecursively(classProvider, rootClassName)// Then we put them in compilation units and we generate themreturn classProvider.classesForObjectSchemas.map {val cu = CompilationUnitImpl()cu.isAutoImport = truecu.declaredPackage = packcu.declaredTypes = listOf(it.value)cu}.toList() }

在generateClasses中，我們首先創(chuàng)建包（ CtPackageImpl類）。 我們將使用它來生成所有類。 我們將其保留在ClassProvider類中。 它將用于生成和跟蹤我們將生成的類。 然后，我們調(diào)用添加到架構(gòu)的擴(kuò)展方法，稱為generateClassRecursively 。

最后，我們將從classProvider中獲取類，并將其放入CompilationUnits中。

private fun Schema.generateClassRecursively(classProvider: ClassProvider, name: String? = null) {when (this) {is ObjectSchema -> {classProvider.register(this, this.generateClass(classProvider, name))this.propertySchemas.forEach { it.value.generateClassRecursively(classProvider) }}is ArraySchema -> this.allItemSchema.generateClassRecursively(classProvider)is StringSchema, is BooleanSchema -> nullis ReferenceSchema -> this.referredSchema.generateClassRecursively(classProvider)else -> TODO("not implemented: ${this.javaClass}")} }

generateClassRecursively會(huì)發(fā)生什么？ 基本上，我們尋找定義對(duì)象的模式，并為每個(gè)對(duì)象生成一個(gè)類。 我們還對(duì)模式進(jìn)行爬網(wǎng)以查找屬性，以查看它們是否間接定義或使用了我們可能要為其生成類的其他對(duì)象模式。

在ObjectSchema的擴(kuò)展方法generateClass中生成一個(gè)類。 當(dāng)它產(chǎn)生一個(gè)類時(shí)，我們將其傳遞給classProvider以便對(duì)其進(jìn)行記錄。

private fun ObjectSchema.generateClass(classProvider: ClassProvider, name: String? = null): CtClass<Any> {return CtClassImpl<Any>().let { ctClass ->val packag = classProvider.packpackag.types.add(ctClass)ctClass.setParent(packag)ctClass.setVisibility<CtModifiable>(ModifierKind.PUBLIC)ctClass.setSimpleName<CtClass<Any>>(name ?: this.schemaLocation.split("/").last().capitalize())ctClass.setSuperInterfaces<CtType<Any>>(setOf(createTypeReference(JsonSerializable::class.java)))this.propertySchemas.forEach {ctClass.addProperty(it.key, it.value, classProvider)}addSerializeMethod(ctClass, this, classProvider)addUnserializeMethod(ctClass, this, classProvider)ctClass} }

到目前為止，我們已經(jīng)設(shè)置了對(duì)架構(gòu)進(jìn)行爬網(wǎng)并確定生成內(nèi)容的邏輯，但是我們還沒有看到很多Spoon特定的API。 這在generateClass中發(fā)生了變化。

在這里，我們首先實(shí)例化CtClassImpl，然后：

• 設(shè)置適當(dāng)?shù)陌?#xff08;從classProvider獲得）
• 將課程設(shè)為公開
• 指定類的名稱：如果類代表整個(gè)模式，我們可以將其作為參數(shù)接收，否則我們可以從模式本身派生它
• 查看單個(gè)屬性并在addProperty中處理它們
• 調(diào)用addSerializeMethod添加一個(gè)序列化方法，我們將使用該方法從此類的實(shí)例生成JSON

那么，我們?nèi)绾翁砑訉傩?#xff1f;

fun CtClass<*>.addProperty(name: String, schema: Schema, classProvider: ClassProvider) {val field = CtFieldImpl<Any>().let {it.setSimpleName<CtField<Any>>(name)it.setType<CtField<Any>>(schema.toType(classProvider))it.setVisibility<CtField<Any>>(ModifierKind.PRIVATE)}this.addField<Any, Nothing>(field)addGetter(this, field)addSetter(this, field) }

我們只需添加一個(gè)字段（ CtField ）。 我們?cè)O(shè)置正確的名稱，類型和可見性，并將其添加到類中。 目前我們還沒有生成getter或setter。

生成過程：序列化

在本節(jié)中，我們將看到如何生成類的serialize方法。 對(duì)于我們的兩個(gè)類，它們看起來像這樣：

public class FruitThing implements com.strumenta.json.JsonSerializable {...public com.google.gson.JsonObject serialize() {com.google.gson.JsonObject res = new com.google.gson.JsonObject();res.add("fruits", com.strumenta.json.SerializationUtils.serialize(fruits));res.add("vegetables", com.strumenta.json.SerializationUtils.serialize(vegetables));return res;}... }public class Veggie implements com.strumenta.json.JsonSerializable {...public com.google.gson.JsonObject serialize() {com.google.gson.JsonObject res = new com.google.gson.JsonObject();res.add("veggieName", com.strumenta.json.SerializationUtils.serialize(veggieName));res.add("veggieLike", com.strumenta.json.SerializationUtils.serialize(veggieLike));return res;}... }

這是生成這種方法的切入點(diǎn)：

fun addSerializeMethod(ctClass: CtClassImpl<Any>, objectSchema: ObjectSchema, classProvider: ClassProvider) {val method = CtMethodImpl<Any>().let {it.setVisibility<CtModifiable>(ModifierKind.PUBLIC)it.setType<CtTypedElement<Any>>(jsonObjectType)it.setSimpleName<CtMethod<Any>>("serialize")val statements = LinkedList<CtStatement>()statements.add(createLocalVar("res", jsonObjectType, objectInstance(jsonObjectType)))objectSchema.propertySchemas.forEach { statements.addAll(addSerializeStmts(it, classProvider)) }statements.add(returnStmt(localVarRef("res")))it.setBodyBlock(statements)it}ctClass.addMethod<Any, CtType<Any>>(method) }

我們實(shí)例化CtMethodImpl然后：

• 我們?cè)O(shè)置方法的可見性
• 我們將返回類型設(shè)置為JSONObject
• 我們將名稱設(shè)置為序列化
• 我們創(chuàng)建JSONObject類型的res變量
• 對(duì)于每個(gè)屬性，我們將生成序列化語句，以將該屬性的值添加到res中
• 最后，我們添加一個(gè)return語句并將此塊設(shè)置為方法的主體

在這里，我們使用了一堆實(shí)用程序方法來簡化代碼，因?yàn)镾poon API非常冗長。

例如，我們使用createLocalVar和objectInstance ，如下所示：

fun createLocalVar(name: String, type: CtTypeReference<Any>, value: CtExpression<Any>? = null) : CtLocalVariable<Any> {return CtLocalVariableImpl<Any>().let {it.setSimpleName<CtNamedElement>(name)it.setType<CtTypedElement<Any>>(type)if (value != null) {it.setAssignment<CtRHSReceiver<Any>>(value)}it} }fun objectInstance(type: CtTypeReference<Any>) : CtConstructorCall<Any> {return CtConstructorCallImpl<Any>().let {it.setType<CtTypedElement<Any>>(type)it} }

現(xiàn)在，我們來看看如何為特定屬性生成序列化方法的語句。

un addSerializeStmts(entry: Map.Entry<String, Schema>,classProvider: ClassProvider): Collection<CtStatement> {return listOf(instanceMethodCall("add", listOf(stringLiteral(entry.key),staticMethodCall("serialize",listOf(fieldRef(entry.key)),createTypeReference(SerializationUtils::class.java))), target= localVarRef("res"))) }

基本上，我們委托給SerializationUtils.serialize 。 該方法將包含在運(yùn)行時(shí)庫中，以與我們生成的代碼一起使用。

它是這樣的：

public class SerializationUtils {public static JsonElement serialize(Object value) {if (value instanceof JsonSerializable) {return ((JsonSerializable) value).serialize();}if (value instanceof Iterable<?>) {com.google.gson.JsonArray jsonArray = new com.google.gson.JsonArray();for (Object element : (Iterable<?>)value) {jsonArray.add(com.strumenta.json.SerializationUtils.serialize(element));}return jsonArray;}if (value instanceof Boolean) {return new JsonPrimitive((Boolean)value);}if (value instanceof String) {return new JsonPrimitive((String)value);}throw new UnsupportedOperationException("Value: " + value + " (" + value.getClass().getCanonicalName() + ")");}public static Object unserialize(JsonElement json, TypeToken<?> expectedType) {...to be discussed later...} }

我們序列化某個(gè)屬性的方式取決于其類型。 簡單值（字符串和布爾值）很容易，而數(shù)組則比較棘手。 對(duì)于任何可通過JsonSerializable進(jìn)行調(diào)用的對(duì)象，我們都調(diào)用相應(yīng)的serialize方法。 我們?yōu)槭裁匆@樣做？ 這樣我們就可以使用為類（ FruitThing和Veggie ）生成的序列化方法。

生成過程：反序列化

讓我們看看我們應(yīng)該能夠生成的反序列化方法：

public class FruitThing implements com.strumenta.json.JsonSerializable {...public static com.thefruit.company.FruitThing unserialize(com.google.gson.JsonObject json) {com.thefruit.company.FruitThing res = new com.thefruit.company.FruitThing();res.setFruits((java.util.List) com.strumenta.json.SerializationUtils.unserialize(json.get("fruits"), com.google.gson.reflect.TypeToken.getParameterized(java.util.List.class, java.lang.String.class)));res.setVegetables((java.util.List) com.strumenta.json.SerializationUtils.unserialize(json.get("vegetables"), com.google.gson.reflect.TypeToken.getParameterized(java.util.List.class, com.thefruit.company.Veggie.class)));return res;}... }public class Veggie implements com.strumenta.json.JsonSerializable {...public static com.thefruit.company.Veggie unserialize(com.google.gson.JsonObject json) {com.thefruit.company.Veggie res = new com.thefruit.company.Veggie();res.setVeggieName((java.lang.String) com.strumenta.json.SerializationUtils.unserialize(json.get("veggieName"), com.google.gson.reflect.TypeToken.get(java.lang.String.class)));res.setVeggieLike((boolean) com.strumenta.json.SerializationUtils.unserialize(json.get("veggieLike"), com.google.gson.reflect.TypeToken.get(boolean.class)));return res;}... }

負(fù)責(zé)生成此類方法的代碼是哪一部分？ 毫不奇怪，它稱為addUnserializeMethod ：

fun addUnserializeMethod(ctClass: CtClassImpl<Any>, objectSchema: ObjectSchema, classProvider: ClassProvider) {val method = CtMethodImpl<Any>().let {it.setType<CtTypedElement<Any>>(createTypeReference(ctClass))it.setModifiers<CtModifiable>(setOf(ModifierKind.STATIC, ModifierKind.PUBLIC))it.setSimpleName<CtMethod<Any>>("unserialize")it.setParameters<CtExecutable<Any>>(listOf(CtParameterImpl<Any>().let {it.setSimpleName<CtNamedElement>("json")it.setType<CtTypedElement<Any>>(jsonObjectType)it}))val thisClass = createTypeReference(ctClass.qualifiedName)val statements = LinkedList<CtStatement>()statements.add(createLocalVar("res", thisClass, objectInstance(thisClass)))objectSchema.propertySchemas.forEach { statements.addAll(addUnserializeStmts(it, classProvider)) }statements.add(returnStmt(localVarRef("res")))it.setBodyBlock(statements)it}ctClass.addMethod<Any, CtType<Any>>(method) }

結(jié)構(gòu)與我們之前所見非常相似。 當(dāng)然，這里涉及的是對(duì)addUnserializeStmts的調(diào)用。

fun addUnserializeStmts(entry: Map.Entry<String, Schema>,classProvider: ClassProvider): Collection<CtStatement> {// call to get the field, e.g. `json.get("veggieName")`val getField = instanceMethodCall("get",listOf(stringLiteral(entry.key)),target = localVarRef("json"))// call to create the TypeToken, e.g., `TypeToken.get(String.class)`// or `TypeToken.getParameterized(List.class, String.class)`val ctFieldType = entry.value.toType(classProvider)val createTypeToken = if (ctFieldType is CtTypeReference<Any> && ctFieldType.actualTypeArguments.isNotEmpty()) {staticMethodCall("getParameterized",(listOf(classField(ctFieldType)) + ctFieldType.actualTypeArguments.map { classField(it) }).toList() as List<CtExpression<Any>>,createTypeReference(TypeToken::class.java))} else {staticMethodCall("get",listOf(classField(ctFieldType)),createTypeReference(TypeToken::class.java))}val callToUnserialize = staticMethodCall("unserialize",listOf(getField, createTypeToken),createTypeReference("com.strumenta.json.SerializationUtils"))val castedCallToUnserialize = cast(callToUnserialize, entry.value.toType(classProvider))return listOf(instanceMethodCall("set" + entry.key.capitalize(), listOf(castedCallToUnserialize), target= localVarRef("res"))) }

現(xiàn)在，事情變得復(fù)雜了。 我們基本上必須為每個(gè)屬性調(diào)用設(shè)置方法。 給設(shè)置器，我們將使用適當(dāng)?shù)念愋娃D(zhuǎn)換將反序列化的結(jié)果傳遞給屬性類型。 要調(diào)用反序列化，我們需要一個(gè)TypeToken，用于引導(dǎo)反序列化過程。 我們想以不同的方式對(duì)同一值進(jìn)行反序列化，具體取決于我們是否要獲取整數(shù)或字符串：類型標(biāo)記告訴我們要獲取的內(nèi)容。

生成過程：注釋

要構(gòu)建此示例，我們必須編寫許多實(shí)用程序方法。 我們?cè)诒疚闹形达@示的整個(gè)示例的某些部分，但是您可以在協(xié)同存儲(chǔ)庫中找到所有這些代碼。

還要注意，我們可以將代碼保存到文件中，并使用編譯器API進(jìn)行編程編譯。 如果需要，我們甚至可以在內(nèi)存中編譯它。 在實(shí)際情況下，我建議這樣做，而不是像我在本教程中所做的那樣，將代碼手動(dòng)復(fù)制粘貼到文件中。

使用Spoon執(zhí)行代碼轉(zhuǎn)換

在使用大型代碼庫或防止重復(fù)性任務(wù)出現(xiàn)人為錯(cuò)誤時(shí)，代碼轉(zhuǎn)換可能非常有用。

例如，假設(shè)您決定更改必須實(shí)施特定模式的方式。 假設(shè)您在代碼庫中使用了數(shù)十次單例模式，并且您想確保每次懶惰地創(chuàng)建實(shí)例（即，僅在第一次需要時(shí)）。 您可以自動(dòng)執(zhí)行此轉(zhuǎn)換。

或者假設(shè)您正在更新正在使用的庫，并且您所依賴的特定方法已重命名，或者其參數(shù)順序已更改。 同樣，您可以通過使用代碼轉(zhuǎn)換來解決此問題。

對(duì)于我們的示例，我們將采取一些簡單的措施。 我們將重構(gòu)一個(gè)類。 在此類中，我們有幾種方法可以接收特定的參數(shù)。 鑒于基本上每個(gè)操作都需要此參數(shù)，因此我們決定將其移至構(gòu)造函數(shù)并將其另存為字段實(shí)例。 然后，我們要轉(zhuǎn)換獲取該參數(shù)的所有方法，以使它們不再需要它，而是訪問相應(yīng)的字段。

讓我們看一下轉(zhuǎn)換的樣子：

// original code class MyClass {MyClass() {} void foo(MyParam param, String otherParam) {param.doSomething();}int bar(MyParam param) {return param.count();}}// transformed code class MyClass {MyParam param;MyClass(MyParam param) {this.param = param;} void foo(String otherParam) {this.param.doSomething();} int bar() { return this.param.count(); }}

在這個(gè)例子中，我們只轉(zhuǎn)換定義方法的類； 在實(shí)際情況下，我們可能還希望轉(zhuǎn)換這些方法的調(diào)用。

我們?nèi)绾螌?shí)現(xiàn)此代碼轉(zhuǎn)換

讓我們先看一下代碼轉(zhuǎn)換示例的主要方法，以便我們可以看到常規(guī)結(jié)構(gòu)：

fun main(args: Array<String>) {val originalCode = """class MyClass {MyClass() {}void foo(MyParam param, String otherParam) {param.doSomething();}int bar(MyParam param) {return param.count();}}"""val parsedClass = Launcher.parseClass(originalCode)ParamToFieldRefactoring("param", createTypeReference("com.strumenta.MyParam")).refactor(parsedClass)println(parsedClass.toCode()) }

如您所見，我們：

• 解析代碼
• 應(yīng)用我們的類ParamToFieldRefactoring中定義的重構(gòu)
• 我們打印結(jié)果代碼

有趣的地方當(dāng)然是ParamToFieldRefactoring

class ParamToFieldRefactoring(val paramName: String, val paramType: CtTypeReference<Any>) {fun refactor(clazz: CtClass<*>) {// Add field to the classclazz.addField<Any, Nothing>(CtFieldImpl<Any>().let {it.setSimpleName<CtNamedElement>(paramName)it.setType<CtTypedElement<Any>>(paramType)it})// Receive the value for the field in each constructorclazz.constructors.forEach {it.addParameter<Nothing>(CtParameterImpl<Any>().let {it.setSimpleName<CtNamedElement>(paramName)it.setType<CtTypedElement<Any>>(paramType)it})it.body.statements.add(CtAssignmentImpl<Any, Any>().let {it.setAssigned<CtAssignment<Any, Any>>(qualifiedFieldAccess(paramName, clazz.qualifiedName))it.setAssignment<CtRHSReceiver<Any>>(localVarRef(paramName))it})}clazz.methods.filter { findParamToChange(it) != null }.forEach {val param = findParamToChange(it)!!CtIterator(it).forEach {if (it is CtParameterReference<*> && it.simpleName == paramName) {val cfr = CtFieldReferenceImpl<Any>()cfr.setSimpleName<CtReference>(paramName)cfr.setDeclaringType<CtFieldReference<Any>>(createTypeReference(clazz.qualifiedName))it.replace(cfr)}}param.delete()}}fun findParamToChange(method: CtMethod<*>) : CtParameter<*>? {return method.parameters.find { it.simpleName == paramName }} }

首先，我們將新字段添加到類中：

clazz.addField<Any, Nothing>(CtFieldImpl<Any>().let {it.setSimpleName<CtNamedElement>(paramName)it.setType<CtTypedElement<Any>>(paramType)it})

然后，向所有構(gòu)造函數(shù)添加一個(gè)參數(shù)，以便我們可以接收該值并將其分配給該字段：

// Receive the value for the field in each constructorclazz.constructors.forEach {it.addParameter<Nothing>(CtParameterImpl<Any>().let {it.setSimpleName<CtNamedElement>(paramName)it.setType<CtTypedElement<Any>>(paramType)it})it.body.statements.add(CtAssignmentImpl<Any, Any>().let {it.setAssigned<CtAssignment<Any, Any>>(qualifiedFieldAccess(paramName, clazz.qualifiedName))it.setAssignment<CtRHSReceiver<Any>>(localVarRef(paramName))it})}

請(qǐng)注意，在實(shí)際的應(yīng)用程序中，我們可能還需要考慮該類過去僅具有默認(rèn)構(gòu)造函數(shù)的情況，并添加一個(gè)采用將單個(gè)值分配給字段的全新構(gòu)造函數(shù)。 為了簡單起見，我們?cè)谑纠泻雎粤诉@一點(diǎn)。

最后，我們要修改所有方法。 如果他們使用的參數(shù)名稱被考慮，我們將刪除該參數(shù)。 我們還將查找對(duì)該參數(shù)的所有引用，并將其替換為對(duì)新字段的引用：

clazz.methods.filter { findParamToChange(it) != null }.forEach {val param = findParamToChange(it)!!CtIterator(it).forEach {if (it is CtParameterReference<*> && it.simpleName == paramName) {val cfr = CtFieldReferenceImpl<Any>()cfr.setSimpleName<CtReference>(paramName)cfr.setDeclaringType<CtFieldReference<Any>>(createTypeReference(clazz.qualifiedName))it.replace(cfr)}}param.delete()}

就是這樣！ 現(xiàn)在，我們應(yīng)該只打印代碼，我們就完成了。

我們?nèi)绾未蛴〈a？ 通過一個(gè)名為toCode的擴(kuò)展方法：

fun CtClass<*>.toCode() : String {val pp = DefaultJavaPrettyPrinter(StandardEnvironment())val cu = CompilationUnitImpl()pp.calculate(cu, listOf(this))return pp.result }

有關(guān)代碼轉(zhuǎn)換的更多信息

如果您想了解有關(guān)使用Spoon進(jìn)行代碼轉(zhuǎn)換的更多信息，請(qǐng)看以下內(nèi)容：

• CocoSpoon ，用于檢測Java代碼以計(jì)算代碼覆蓋率的工具
• Trebuchet ，一個(gè)概念證明，展示如何使用Spoon將Java代碼轉(zhuǎn)換為C ++。

這篇文章是如何誕生的

Spoon是處理Java代碼的工具。 在某種程度上，它可以看作是JavaParser的競爭對(duì)手。 我一直想研究了很長一段時(shí)間，但我有許多事情一大堆 ，我想看看和勺子從未到列表的頂部。 然后，JavaParser的一些用戶指出了關(guān)于Spoon項(xiàng)目的討論，討論了JavaParser和Spoon之間的區(qū)別。 在我看來，存在一些誤解，Spoon的貢獻(xiàn)者賣出的JavaParser有點(diǎn)短……在成千上萬的開發(fā)人員和知名公司都使用JavaParser并對(duì)此感到非常滿意之后。 另外，JavaParser可能是最著名的Java解析器。 因此，我開始與Spoon的貢獻(xiàn)者進(jìn)行討論，這引發(fā)了撰寫本文的想法。

當(dāng)這篇文章是在Spoon的貢獻(xiàn)者的幫助下寫的時(shí)，我是這篇文章的作者，而且我還是JavaParser的貢獻(xiàn)者，所以這是我的“偏見警報(bào)”！

比較Spoon和JavaParser

Spoon是JavaParser的學(xué)術(shù)替代品。 雖然JavaParser本身實(shí)現(xiàn)符號(hào)解析（這是最難的部分），但Spoon卻充當(dāng)Eclipse Java編譯器的包裝，然后在其之上構(gòu)建一些高級(jí)API。 那么，這種選擇會(huì)有什么后果呢？

• Eclipse Java編譯器已經(jīng)成熟，盡管并非沒有錯(cuò)誤，但它相當(dāng)可靠
• Eclipse Java編譯器是一個(gè)大型野獸，它具有依賴性和復(fù)雜的配置
• Eclipse Java編譯器是……編譯器，它不是用于符號(hào)解析的庫，因此它不如我們?cè)贘avaParser上擁有的本地解決方案靈活。

就個(gè)人而言，我對(duì)成為JavaParser的貢獻(xiàn)者有很大的偏見。 我已經(jīng)習(xí)慣了JavaParser，Spoon的某些行為對(duì)我來說似乎是不自然的。 例如，對(duì)片段表達(dá)式的類型強(qiáng)制轉(zhuǎn)換似乎不起作用。 類訪問（例如，“ String.class”）不是由特定表達(dá)式表示，而是由字段訪問表示。 但是，某些功能確實(shí)很有用，我們也應(yīng)該在JavaParser中獲得它們。

總而言之，它們是不同的工具，具有不同的功能集，而且我認(rèn)為也有不同的理念，如下所述。

關(guān)于文檔，對(duì)于JavaParser來說似乎更好一些：我們有一本書，可以免費(fèi)下載，并下載了數(shù)千次，還擁有一套教程。

不同的哲學(xué)

現(xiàn)在，Spoon是在學(xué)術(shù)環(huán)境和法國創(chuàng)立的。 以我的經(jīng)驗(yàn)，法國工程師非常有才華，但他們傾向于以“瘋狂的方式”重新發(fā)明事物。 以該項(xiàng)目采用的許可證為例：那是Apache許可證嗎？ GPL？ LGPL？ Eclipse許可證？ 不，這是CeCILL-C免費(fèi)軟件許可協(xié)議 。 我從未聽說過的許可證，專門為遵守某些法國法規(guī)而創(chuàng)建。 現(xiàn)在，這可能是有史以來最偉大的許可證，但是對(duì)于想要采用該項(xiàng)目的公司，他們需要仔細(xì)研究一下，弄清楚這意味著什么，意味著什么，如果它與他們正在使用的其他許可證兼容，并且以此類推。 我認(rèn)為，如果他們只是選擇一個(gè)現(xiàn)有許可證，事情可能會(huì)簡單得多。 因?yàn)榇嬖诂F(xiàn)實(shí) ，在這種現(xiàn)實(shí)中，公司不想僅使用Spoon就必須學(xué)習(xí)此許可。 這與我們非常務(wù)實(shí)的 JavaParser中的方法截然不同。 我們與公司討論并確定了他們需要哪些許可證，然后我們努力為用戶提供雙重許可證（Apache許可證或LGPL）。 為什么？ 因?yàn)樗麄兪撬麄兪煜さ倪x擇。

總的來說，當(dāng)我與Spoon的家伙交談時(shí)，我有不同的哲學(xué)感受。 他們清楚地意識(shí)到他們的產(chǎn)品要好得多，并且坦率地說，JavaParser如此受歡迎，讓他們有些失望。 我們討論了一些合作的可能性，但在我看來，這是從我們正確的角度出發(fā)。 在JavaParser中，我們不認(rèn)為我們是對(duì)的。 我們只是聽取用戶意見，在彼此之間進(jìn)行討論，然后再努力向前邁進(jìn)，使用戶的生活更加輕松。 一個(gè)很大的優(yōu)勢就是我們會(huì)收到很多反饋，因此當(dāng)我們出錯(cuò)時(shí)，用戶可以幫助我們糾正方向。

關(guān)于依賴關(guān)系，到目前為止，在JavaParser上，我們一直在努力保持核心模塊沒有任何依賴關(guān)系。 我們將來可能會(huì)放寬此約束，但總的來說，我們將依賴管理視為重要方面。 相反，在Spoon中，您需要添加一個(gè)Maven存儲(chǔ)庫以使用甚至不在Maven Central或任何知名Maven存儲(chǔ)庫上的庫。 為什么？ 為什么要讓用戶的生活變得更加艱難？

結(jié)論

我認(rèn)為代碼處理功能非常強(qiáng)大：它允許使用我們開發(fā)人員的技能來自動(dòng)化部分工作，從而減少工作量和錯(cuò)誤。 如果您使用大型代碼庫，那么它是在工具箱中的好工具。 至少我認(rèn)為，更多的開發(fā)人員應(yīng)該意識(shí)到它提供的可能性。

在Java代碼上執(zhí)行代碼處理時(shí)，Spoon是有效的解決方案。 因此，我邀請(qǐng)您熟悉并考慮使用它，我想您會(huì)幫自己一個(gè)忙。

翻譯自: https://www.javacodegeeks.com/2019/03/analyze-generate-transform-java-spoon.html

創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎(jiǎng)勵(lì)來咯，堅(jiān)持創(chuàng)作打卡瓜分現(xiàn)金大獎(jiǎng)

總結(jié)

以上是生活随笔為你收集整理的如何以及为什么使用Spoon分析，生成和转换Java代码的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。