Spoon是分析，生成和轉換Java代碼的工具。

在本文中，我們將看到通過使用以編程方式處理代碼的技術可以實現什么。 我認為這些技術不是很廣為人知或使用，這很遺憾，因為它們可能非常有用。 誰知道，即使您不想使用Spoon甚至不處理Java代碼，而是使用C＃，Python，Kotlin或其他語言，某些想法對于您當前的項目也可能有用。 讓我們學習如何以更智能的方式編程。

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

本文與隨附的存儲庫與所有代碼配對： ftomassetti / spoon-examples

使用代碼處理技術可以實現什么？

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

• 代碼分析
  • 計算源代碼指標，例如找出多少類具有比一定數量的方法更多的類
• 代碼生成
  • 以編程方式生成重復代碼。
• 代碼轉換
  • 自動重構，例如在構造函數中指定的字段中轉換幾種方法中使用的參數

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

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

設置湯匙

要設置湯匙，您需要提供：

• 要分析的代碼
• 所有依賴關系（當然還有依賴關系的依賴關系）

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

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

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

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

現在我們有了一個模型，讓我們看看如何使用它。

順便說一句，示例是用Kotlin編寫的，因為它是一種簡潔明了的語言，我認為它非常適合教程。 你同意嗎？

使用Spoon執行代碼分析

讓我們開始使用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) }

在本示例中，我們在主要函數中設置模型，然后在inspectClassesWithManyMethods中 ，按方法數量過濾類，然后使用幾個實用程序函數來打印這些類的列表（printTitle ， printList ）。

運行此代碼，我們獲得以下輸出：

===================================== | 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)

現在讓我們嘗試其他的東西。 讓我們嘗試查找所有測試類，并確保其名稱以“ Test”結尾。 測試類將是至少具有用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) }

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

在verifyTestClassesHaveProperName中，我們：

• 過濾所有屬于測試類的類 （它們至少具有一個用org.junit.Test注釋的方法）
• 查找所有名稱以Test結尾的測試類，以及所有不包含
• 我們打印要修復的類的列表以及有關它們的一些統計信息

讓我們運行這段代碼，我們得到以下結果：

================================ | 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

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

有關更高級的用法，您還可以查看有關使用Spoon進行體系結構實施的本文。

使用Spoon執行代碼生成

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

這是一個相當高級的示例，我花了一些時間熟悉Spoon才能編寫它。 我還必須向他們的團隊提出一些問題，以解決一些問題。 的確，這段代碼絕非易事，但是我認為我們應該認為這是一個非常復雜的功能，因此對我來說聽起來很公平。

好的，現在讓我們進入代碼。

這是一個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?"}}}} }

在頂層，我們可以看到整個架構所代表的實體。 我們知道它將被表示為一個對象并具有兩個屬性：

• 水果 ：字符串數組
• 蔬菜 ：一組蔬菜 ，其中蔬菜是下面描述的另一個對象，在“定義”部分中

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

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

我們應該得到什么

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

我們的代碼應生成兩個類：

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;} }

這是我們如何使用這兩個類的示例：

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());} }

在該示例中，我們構建了FruitThing和幾個Veggies的實例。 然后，我們對它們進行序列化并反序列化它們，以便我們可以證明序列化和反序列化都可以工作。

生成過程：一般組織

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

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

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

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)}} }

好的，所以魔術發生在generateJsonSchema中，對嗎？

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，并調用generateClasses ，這將返回一堆CompilationUnits。 基本上，每個CompilationUnit都是單個Java文件的抽象語法樹。

一旦獲得了這些編譯單元，就將它們打印為Java代碼。 我們還計算適當的文件名并實例化GeneratedJavaFile實例。

因此，看來我們現在來看一下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中，我們首先創建包（ CtPackageImpl類）。 我們將使用它來生成所有類。 我們將其保留在ClassProvider類中。 它將用于生成和跟蹤我們將生成的類。 然后，我們調用添加到架構的擴展方法，稱為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會發生什么？ 基本上，我們尋找定義對象的模式，并為每個對象生成一個類。 我們還對模式進行爬網以查找屬性，以查看它們是否間接定義或使用了我們可能要為其生成類的其他對象模式。

在ObjectSchema的擴展方法generateClass中生成一個類。 當它產生一個類時，我們將其傳遞給classProvider以便對其進行記錄。

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} }

到目前為止，我們已經設置了對架構進行爬網并確定生成內容的邏輯，但是我們還沒有看到很多Spoon特定的API。 這在generateClass中發生了變化。

在這里，我們首先實例化CtClassImpl，然后：

• 設置適當的包（從classProvider獲得）
• 將課程設為公開
• 指定類的名稱：如果類代表整個模式，我們可以將其作為參數接收，否則我們可以從模式本身派生它
• 查看單個屬性并在addProperty中處理它們
• 調用addSerializeMethod添加一個序列化方法，我們將使用該方法從此類的實例生成JSON

那么，我們如何添加屬性？

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) }

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

生成過程：序列化

在本節中，我們將看到如何生成類的serialize方法。 對于我們的兩個類，它們看起來像這樣：

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;}... }

這是生成這種方法的切入點：

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) }

我們實例化CtMethodImpl然后：

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

在這里，我們使用了一堆實用程序方法來簡化代碼，因為Spoon 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} }

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

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 。 該方法將包含在運行時庫中，以與我們生成的代碼一起使用。

它是這樣的：

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...} }

我們序列化某個屬性的方式取決于其類型。 簡單值（字符串和布爾值）很容易，而數組則比較棘手。 對于任何可通過JsonSerializable進行調用的對象，我們都調用相應的serialize方法。 我們為什么要這樣做？ 這樣我們就可以使用為類（ FruitThing和Veggie ）生成的序列化方法。

生成過程：反序列化

讓我們看看我們應該能夠生成的反序列化方法：

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;}... }

負責生成此類方法的代碼是哪一部分？ 毫不奇怪，它稱為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) }

結構與我們之前所見非常相似。 當然，這里涉及的是對addUnserializeStmts的調用。

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"))) }

現在，事情變得復雜了。 我們基本上必須為每個屬性調用設置方法。 給設置器，我們將使用適當的類型轉換將反序列化的結果傳遞給屬性類型。 要調用反序列化，我們需要一個TypeToken，用于引導反序列化過程。 我們想以不同的方式對同一值進行反序列化，具體取決于我們是否要獲取整數或字符串：類型標記告訴我們要獲取的內容。

生成過程：注釋

要構建此示例，我們必須編寫許多實用程序方法。 我們在本文中未顯示的整個示例的某些部分，但是您可以在協同存儲庫中找到所有這些代碼。

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

使用Spoon執行代碼轉換

在使用大型代碼庫或防止重復性任務出現人為錯誤時，代碼轉換可能非常有用。

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

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

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

讓我們看一下轉換的樣子：

// 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(); }}

在這個例子中，我們只轉換定義方法的類； 在實際情況下，我們可能還希望轉換這些方法的調用。

我們如何實現此代碼轉換

讓我們先看一下代碼轉換示例的主要方法，以便我們可以看到常規結構：

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()) }

如您所見，我們：

• 解析代碼
• 應用我們的類ParamToFieldRefactoring中定義的重構
• 我們打印結果代碼

有趣的地方當然是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})

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

// 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()}

就是這樣！ 現在，我們應該只打印代碼，我們就完成了。

我們如何打印代碼？ 通過一個名為toCode的擴展方法：

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

有關代碼轉換的更多信息

如果您想了解有關使用Spoon進行代碼轉換的更多信息，請看以下內容：

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

這篇文章是如何誕生的

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

當這篇文章是在Spoon的貢獻者的幫助下寫的時，我是這篇文章的作者，而且我還是JavaParser的貢獻者，所以這是我的“偏見警報”！

比較Spoon和JavaParser

Spoon是JavaParser的學術替代品。 雖然JavaParser本身實現符號解析（這是最難的部分），但Spoon卻充當Eclipse Java編譯器的包裝，然后在其之上構建一些高級API。 那么，這種選擇會有什么后果呢？

• Eclipse Java編譯器已經成熟，盡管并非沒有錯誤，但它相當可靠
• Eclipse Java編譯器是一個大型野獸，它具有依賴性和復雜的配置
• Eclipse Java編譯器是……編譯器，它不是用于符號解析的庫，因此它不如我們在JavaParser上擁有的本地解決方案靈活。

就個人而言，我對成為JavaParser的貢獻者有很大的偏見。 我已經習慣了JavaParser，Spoon的某些行為對我來說似乎是不自然的。 例如，對片段表達式的類型強制轉換似乎不起作用。 類訪問（例如，“ String.class”）不是由特定表達式表示，而是由字段訪問表示。 但是，某些功能確實很有用，我們也應該在JavaParser中獲得它們。

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

關于文檔，對于JavaParser來說似乎更好一些：我們有一本書，可以免費下載，并下載了數千次，還擁有一套教程。

不同的哲學

現在，Spoon是在學術環境和法國創立的。 以我的經驗，法國工程師非常有才華，但他們傾向于以“瘋狂的方式”重新發明事物。 以該項目采用的許可證為例：那是Apache許可證嗎？ GPL？ LGPL？ Eclipse許可證？ 不，這是CeCILL-C免費軟件許可協議 。 我從未聽說過的許可證，專門為遵守某些法國法規而創建。 現在，這可能是有史以來最偉大的許可證，但是對于想要采用該項目的公司，他們需要仔細研究一下，弄清楚這意味著什么，意味著什么，如果它與他們正在使用的其他許可證兼容，并且以此類推。 我認為，如果他們只是選擇一個現有許可證，事情可能會簡單得多。 因為存在現實 ，在這種現實中，公司不想僅使用Spoon就必須學習此許可。 這與我們非常務實的 JavaParser中的方法截然不同。 我們與公司討論并確定了他們需要哪些許可證，然后我們努力為用戶提供雙重許可證（Apache許可證或LGPL）。 為什么？ 因為他們是他們熟悉的選擇。

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

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

結論

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

在Java代碼上執行代碼處理時，Spoon是有效的解決方案。 因此，我邀請您熟悉并考慮使用它，我想您會幫自己一個忙。

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

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

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

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。