Das Leben mit einem Multi-Modul-Projekt ist nicht so einfach. Um die Routine zum Erstellen eines neuen Moduls zu vermeiden, haben wir unser eigenes Plug-In für Android Studio erstellt. Bei der Implementierung sind wir auf einen Mangel an praktischer Dokumentation gestoßen, haben verschiedene Ansätze ausprobiert und viele Fallstricke ausgegraben. Es stellte sich heraus, zwei Artikel: "Theorie" und "Praxis" . Triff mich!

Worüber werde ich sprechen?

• Warum ein Plugin? Warum ein Plugin?
  
  • Checkliste erstellen
  • Checkliste Automatisierungsoptionen
• Grundlagen der Plugin-Entwicklung
  
  • Aktionen
  • UI-Entwicklung in Plugins
  • Schlussfolgerungen
• IDEA-Interna: Komponenten, PSI
  
  • IDEA Interne Einheit
  • PSI
  • Schlussfolgerungen

Warum ein Plugin? Warum ein Plugin?

Wenn Sie ein Android-Projekt mit mehreren Modulen entwickeln, wissen Sie, welche Routine es ist, jedes Mal ein neues Modul zu erstellen. Sie müssen ein Modul erstellen, Gradle darin konfigurieren, Abhängigkeiten hinzufügen, auf die Synchronisierung warten und nicht vergessen, etwas im Anwendungsmodul zu reparieren - alles nimmt viel Zeit in Anspruch. Wir wollten die Routine automatisieren und haben zunächst eine Checkliste erstellt, die zeigt, was wir jedes Mal tun, wenn wir ein neues Modul erstellen.

1. Zunächst erstellen wir das Modul selbst über das Menü Datei -> Neu -> Neues Modul -> Android-Bibliothek.

2. Wir schreiben die Pfade zum Modul in die Datei settings.gradle, da wir verschiedene Modultypen haben - Core-Module und Feature-Module, die sich in verschiedenen Ordnern befinden.

// settings.gradle include ':analytics project(':analytics').projectDir = new File(settingsDir, 'core/framework-metrics/analytics) ... include ':feature-worknear' project(':feature-worknear').projectDir = new File(settingsDir, 'feature/feature-worknear') 

3. Ändern Sie die Konstanten compileSdk , minSdk , targetSdk im generierten build.gradle : Ersetzen Sie sie durch die Konstanten, die im root build.gradle definiert sind.

 // Feature module build.gradle … android { compileSdkVersion rootProject.ext.targetSdkVersion defaultConfig { minSdkVersion rootProject.ext.minSdkVersion targetSdkVersion rootProject.ext.targetSdkVersion ... } } 

Hinweis: Wir haben diesen Teil unserer Arbeit kürzlich in unser Gradle-Plugin entfernt, mit dessen Hilfe alle erforderlichen Parameter der Datei build.gradle in mehreren Zeilen konfiguriert werden können.

4. Da wir den gesamten neuen Code in Kotlin schreiben, verbinden wir standardmäßig zwei Plugins: kotlin-android und kotlin-kapt . Wenn das Modul irgendwie mit der Benutzeroberfläche verbunden ist, verbinden wir zusätzlich das Modul kotlin-android-extensions .

 // Feature module build.gradle apply plugin: 'com.android.library' apply plugin: 'kotlin-android' apply plugin: 'kotlin-android-extensions' apply plugin: 'kotlin-kapt' 

5. Wir verbinden die allgemeinen Bibliotheken und Kernmodule. Kernmodule sind beispielsweise Logger, Analytics, einige allgemeine Dienstprogramme und Bibliotheken - RxJava, Moxy und viele andere.

 // Feature module build.gradle dependencies { def libraries = rootProject.ext.deps compileOnly project(':logger') compileOnly project(':analytics') … // Kotlin compileOnly libraries.kotlin // DI compileOnly libraries.toothpick kapt libraries.toothpickCompiler } 

6. Richten Sie kapt für Toothpick ein. Zahnstocher ist unser zentrales DI-Framework. Höchstwahrscheinlich wissen Sie: Um die Codegenerierung anstelle der Reflektion im Release-Build zu verwenden, müssen Sie den Anmerkungsprozessor so konfigurieren, dass er versteht, woher die Fabriken für die erstellten Objekte stammen:

 // Feature module build.gradle defaultConfig { ... javaCompileOptions { annotationProcessorOptions { arguments = [ toothpick_registry_package_name: "ru.hh.feature_worknear" ] } } ... 

Hinweis: In hh.ru verwenden wir die erste Version von Toothpick, in der zweiten haben wir die Möglichkeit zur Codegenerierung entfernt .

7. Wir konfigurieren kapt für Moxy im erstellten Modul. Moxy ist unser Hauptframework für die Erstellung von MVP in einer Anwendung, und Sie müssen es ein wenig drehen, damit es in einem Projekt mit mehreren Modulen funktioniert. Registrieren Sie insbesondere das Paket des erstellten Moduls in den kapt-Argumenten:

 // Feature module build.gradle android { ... kapt { arguments { arg("moxyReflectorPackage", "ru.hh.feature_worknear") } } ... 

Hinweis: Wir haben bereits auf die neue Version von Moxy umgestellt, und dieser Teil der Codegenerierung hat seine Relevanz verloren.

8. Wir generieren eine Reihe neuer Dateien. Ich meine nicht die Dateien, die automatisch erstellt werden (AndroidManifest.xml, build.gradle, .gitignore), sondern den allgemeinen Rahmen des neuen Moduls: Interaktoren, Repositorys, DI-Module, Präsentatoren, Fragmente. Es gibt viele dieser Dateien, sie haben am Anfang die gleiche Struktur, und das Erstellen ist eine Routine.

9. Wir verbinden unser erstelltes Modul mit dem Anwendungsmodul. In diesem Schritt müssen Sie daran denken, Toothpick in der Datei build.gradle des Anwendungsmoduls zu konfigurieren. Zu diesem Zweck fügen wir das Paket des erstellten Moduls dem speziellen Argumentanmerkungsprozessor hinzu - dentpick_registry_children_package_names .

 // App module build.gradle defaultConfig { … javaCompileOptions { annotationProcessorOptions { arguments = [ toothpick_registry_package_name: "ru.hh.android", toothpick_registry_children_package_names: [ "ru.hh.analytics", "ru.hh.feature_worknear", ... ].join(",") ] } } … 

Danach konfigurieren wir Moxy im Anwendungsmodul. Wir haben eine Klasse, die mit der Annotation @RegisterMoxyReflectorPackages gekennzeichnet ist - dort fügen wir den Paketnamen des erstellten Moduls hinzu:

 // App module file @RegisterMoxyReflectorPackages( "ru.hh.feature_force_update", "ru.hh.feature_profile", "ru.hh.feature_worknear" ... ) class MoxyReflectorStub 

Vergessen Sie am Ende nicht, das erstellte Modul mit dem Abhängigkeitsblock des Anwendungsmoduls zu verbinden:

 // Application module build.gradle dependencies { def libraries = rootProject.ext.deps implementation project(':logger') implementation project(':dependency-handler') implementation project(':common') implementation project(':analytics') implementation project(':feature_worknear') ... 

Wir haben eine Checkliste mit neun Punkten.

Da es viele Punkte gibt, wird es wahrscheinlich etwas vergessen. Und dann fragen Sie sich stundenlang, was passiert ist und warum das Projekt nicht stattfinden wird.

Wir haben beschlossen, dass Sie nicht so leben können und etwas ändern müssen.

Checkliste Automatisierungsoptionen

Nachdem wir die Checkliste zusammengestellt hatten, suchten wir nach Optionen zur Automatisierung ihrer Elemente.

Die erste Option war ein Versuch, "Strg + C, Strg + V" auszuführen . Wir haben versucht, eine Implementierung für die Erstellung des Android Library-Moduls zu finden, die uns "out of the box" zur Verfügung steht. Im Ordner mit Android Studio (für MacOs: / Applications / Android \ Studio.app/Contents/plugins/android/lib/templates/gradle-projects/ ) finden Sie einen speziellen Ordner mit Vorlagen der Projekte, die bei Auswahl von Datei - angezeigt werden. > Neu -> Neues Modul. Wir haben versucht, die NewAndroidModule-Vorlage zu kopieren, indem wir die ID in der Datei template.xml.ftl geändert haben. Dann haben sie die IDE gestartet, ein neues Modul erstellt und ... Android Studio ist abgestürzt, weil die Liste der Module, die Sie im Menü zum Erstellen eines neuen Moduls sehen, fest codiert ist. Sie können sie nicht durch primitives Kopieren und Einfügen ändern. Wenn Sie versuchen, ein Element aufzunehmen und hinzuzufügen, zu löschen oder zu ändern, stürzt Android Studio einfach ab.

Die zweite Option zur Automatisierung der Checkliste war die FreeMarker-Vorlagen-Engine . Nach einem erfolglosen Versuch des Kopierens und Einfügens haben wir uns die Modulvorlagen genauer angesehen und FreeMarker-Vorlagen unter der Haube gefunden.

Ich werde Ihnen nicht im Detail sagen, was FreeMarker ist - es gibt einen guten Artikel von RedMadRobot und ein Video von MosDroid von Lesha Bykov . Kurz gesagt - dies ist eine Engine zum Generieren von Dateien mithilfe von Vorlagen und speziellen Map-ki-Java-Objekten. Sie füttern Vorlagen, Objekte und FreeMarker generiert Code an der Ausgabe.

Aber schauen Sie sich noch einmal die Checkliste an:

Wenn Sie genau hinschauen, können Sie sehen, dass es in zwei große Gruppen von Aufgaben unterteilt ist:

• Die Aufgaben zum Generieren eines neuen Codes (1, 3, 4, 5, 6, 7, 8) und
• Aufgaben zum Ändern eines vorhandenen Codes (2, 7, 8, 9)

Und wenn FreeMarker Aufgaben der ersten Gruppe mit einem Knall bewältigt, dann bewältigt es die zweite überhaupt nicht. Als kleines Beispiel: Wenn Sie in der aktuellen Implementierung der FreeMarker-Integration in Android Studio versuchen, eine Zeile in die Datei settings.gradle einzufügen, die nicht mit dem Wort 'include' beginnt, stürzt das Studio ab . Hier haben wir die Traurigen gefangen und beschlossen, die Verwendung von FreeMarker aufzugeben.

Nach einem Fehler mit FreeMarker kam die Idee auf, mein eigenes Konsolendienstprogramm für die Durchführung einer Checkliste zu schreiben. In Intellij IDEA ist es möglich, ein Terminal zu verwenden. Warum also nicht? Lassen Sie uns ein Skript über die Bash schreiben, total business:

Da wir das erstellte Modul jedoch flexibel konfigurieren möchten, müssen wir viele verschiedene Flags eingeben, was für das Drucken in der Konsole nicht sehr bequem ist.

Danach traten wir einen Schritt zurück und erinnerten uns daran, dass wir in Intellij IDEA arbeiteten. Und wie ist es angeordnet? Es gibt einen bestimmten Kern von Klassen, eine Engine, an die viele Plug-Ins angeschlossen sind, die die von uns benötigte Funktionalität hinzufügen.

Wie viele von Ihnen sehen im Screenshot mehr als zwei verbundene Plugins?

Hier sind sie mindestens drei miteinander verbunden. Wenn Sie mit Kotlin arbeiten, ist das Kotlin-Plugin aktiviert. Wenn Sie in einem Projekt mit Gradle arbeiten, ist auch das Gradle-Plugin enthalten. Wenn Sie in einem Projekt mit einem Versionskontrollsystem arbeiten - Git, SVN oder etwas anderem -, ist das entsprechende Plug-In für die Integration dieses VCS enthalten.

Wir haben uns das offizielle JetBrains- Plugin-Repository angesehen und festgestellt, dass es bereits über 4000 offiziell registrierte Plugins gibt! Fast die ganze Welt schreibt Plugins, und diese Plugins können alles: von der Integration einer Programmiersprache in IDEA bis hin zu spezifischen Tools, die in IDEA ausgeführt werden können.

Kurz gesagt, wir haben beschlossen, unser eigenes Plugin zu schreiben.

Grundlagen der Plugin-Entwicklung

Wir gehen weiter zu den Grundlagen der Plugin-Entwicklung. Um loszulegen, benötigen Sie nur drei Dinge:

1. IntelliJ IDEA , minimale Community Edition (Sie können in der Ultimate-Version arbeiten, bietet jedoch keine besonderen Vorteile bei der Entwicklung von Plugins);
2. Plugin DevKit ist ein spezielles Plugin, das die Möglichkeit bietet, andere Plugins zu schreiben.
3. Und jede JVM-Sprache, in der Sie ein Plugin schreiben möchten. Es könnte Kotlin, Java, Groovy sein - alles.

Wir beginnen mit der Erstellung eines Plugin-Projekts. Wir wählen Neues Projekt , Punkt Gradle , wir kreuzen das IntelliJ Platform Plugin an und wir erstellen das Projekt.

Hinweis: Wenn das Kontrollkästchen IntelliJ Platform Plugin nicht angezeigt wird, ist das Plugin DevKit nicht installiert.

Nach dem Ausfüllen der erforderlichen Felder sehen wir eine leere Plugin-Struktur.

Schauen wir es uns genauer an. Es besteht aus:

• Ordner, in die Sie den Code für das zukünftige Projekt schreiben werden; ( main / java , main / kotlin usw.);
• build.gradle- Datei, in der Sie die Abhängigkeiten Ihres Plugins von einigen Bibliotheken deklarieren und so etwas wie das gradle-Intellij-Plugin konfigurieren.

Gradle-Intellij-Plugin - Gradle-Plugin, mit dem Sie Gradle als Plugin-Build-System verwenden können. Dies ist praktisch, da fast jeder Android-Entwickler mit Gradle vertraut ist und weiß, wie man damit arbeitet. Darüber hinaus fügt das Gradle-Intellij-Plugin Ihrem Projekt nützliche Gradle-Aufgaben hinzu, insbesondere:

• runIde - Diese Aufgabe startet eine separate IDEA-Instanz mit einem Plugin, das Sie entwickeln, damit Sie es debuggen können.
• buildPlugin - sammelt das Zip-Archiv Ihres Plugins, damit Sie es entweder lokal oder über das offizielle IDEA-Repository verteilen können;
• verifyPlugin - Diese Aufgabe überprüft Ihr Plugin auf schwerwiegende Fehler, die es möglicherweise nicht in Android Studio oder eine andere IDEA integrieren lassen.

Was gibt Gradle-Intellij-Plugin noch ? Mit seiner Hilfe wird es einfacher, Abhängigkeiten von anderen Plugins hinzuzufügen, aber wir werden etwas später darüber sprechen, aber im Moment kann ich sagen, dass das Gradle-Intellij-Plugin Ihr Bruder ist. Verwenden Sie es.

Zurück zur Plugin-Struktur. Die wichtigste Datei eines Plugins ist plugin.xml .

 <idea-plugin> <id>com.experiment.simple.plugin</id> <name>Hello, world</name> <vendor email="myemail@yourcompany.com" url="http://www.mycompany.com"> My company </vendor> <description><![CDATA[ My first ever plugin - try to open Hello world dialog<br> ]]></description> <depends>com.intellij.modules.lang</depends> <depends>org.jetbrains.kotlin</depends> <depends>org.intellij.groovy</depends> <idea-version since-build="163"/> <actions> <group description="My actions" id="MyActionGroup" text="My actions"> <separator/> <action id="com.experiment.actions.OpenHelloWorldAction" class="com.experiment.actions.OpenHelloWorldAction" text="Show Hello world" description="Open dialog"> <add-to-group group-id="NewGroup" anchor="last"/> </action> </group> </actions> <idea-plugin> 

Dies ist eine Datei, die enthält:

• Ihre Plugin-Metadaten: Kennung, Name, Beschreibung, Herstellerinformationen, Änderungsprotokoll
• Beschreibung der Abhängigkeiten von anderen Plugins;
• Hier können Sie auch die IDEA-Version angeben, mit der Ihr Plugin ordnungsgemäß funktioniert
• Hier werden auch Aktionen beschrieben.

Aktionen

Was sind Aktionen ? Angenommen, Sie öffnen ein Menü, um eine neue Datei zu erstellen. Tatsächlich wurde jedes Element dieses Menüs durch eine Art Plugin hinzugefügt:

Aktionen sind die Einstiegspunkte für Benutzer in Ihr Plugin. Jedes Mal, wenn der Benutzer auf einen Menüpunkt klickt, erhalten Sie die Kontrolle innerhalb des Plugins. Sie können auf diesen Klick reagieren und das Notwendige tun.
Wie werden Aktionen erstellt? Schreiben wir eine einfache Aktion, die einen Dialog mit der Meldung "Hallo Welt" anzeigt.

 class OpenHelloWorldAction : AnAction() { override fun actionPerformed(actionEvent: AnActionEvent) { val project = actionEvent.project Messages.showMessageDialog( project, "Hello world!", "Greeting", Messages.getInformationIcon() ) } override fun update(e: AnActionEvent) { super.update(e) // TODO - Here we can update our action (for example, disable it) } override fun beforeActionPerformedUpdate(e: AnActionEvent) { super.beforeActionPerformedUpdate(e) // TODO - This method calls right before 'actionPerformed' } } 

Um eine Aktion zu erstellen, erstellen wir zunächst eine Klasse, die von der AnAction- Klasse erbt. Zweitens müssen wir die actionPerformed-Methode neu definieren, wobei der spezielle Parameter der AnActionEvent- Klasse kommt . Dieser Parameter enthält Informationen zum Ausführungskontext Ihrer Aktion. Der Kontext bezieht sich auf das Projekt, in dem Sie arbeiten, die Datei, die jetzt im Code-Editor des Benutzers geöffnet ist, die im Projektbaum ausgewählten Elemente und andere Daten, die bei der Verarbeitung Ihrer Aufgaben hilfreich sein können.

Um das Dialogfeld "Hallo Welt" anzuzeigen , rufen wir zuerst das Projekt ab (nur über den Parameter AnActionEvent ) und verwenden dann die Dienstprogrammklasse Nachrichten , um das Dialogfeld anzuzeigen.

Welche zusätzlichen Funktionen haben wir in der Aktion? Wir können zwei Methoden überschreiben: update und beforeActionPerformedUpdate .

Die Aktualisierungsmethode wird jedes Mal aufgerufen, wenn sich der Ausführungskontext Ihrer Aktion ändert. Warum es für Sie nützlich sein kann: Zum Beispiel, um den Menüpunkt zu aktualisieren, der von Ihrem Plugin hinzugefügt wurde. Angenommen, Sie haben eine Aktion geschrieben, die nur mit Kotlin-Dateien funktioniert, und der Benutzer hat jetzt die Groovy-Datei geöffnet. Dann können Sie in der Aktualisierungsmethode Ihre Aktion unzugänglich machen.

Die beforeActionPerformedUpdate- Methode ähnelt der update-Methode, wird jedoch direkt vor actionPerformed aufgerufen . Dies ist die letzte Gelegenheit, Ihre Aktion zu beeinflussen. In der Dokumentation wird empfohlen, bei dieser Methode nichts „Schweres“ auszuführen, damit sie so schnell wie möglich ausgeführt wird.

Sie können Aktionen auch an bestimmte Elemente der IDEA-Schnittstelle binden und diese als Standardtastenkombinationen für den Aufruf festlegen. Ich empfehle, hier mehr darüber zu lesen.

UI-Entwicklung in Plugins

Wenn Sie ein eigenes Dialogdesign benötigen, müssen Sie hart arbeiten. Wir haben unsere Benutzeroberfläche entwickelt, weil wir eine praktische grafische Oberfläche haben wollten, in der es möglich sein würde, einige Ticks zu markieren, einen Selektor für Enum-Werte zu haben und so weiter.

Das Plugin DevKit für die Entwicklung der Benutzeroberfläche fügt einige Aktionen hinzu, z. B. das GUI-Formular und den Dialog . Das erste erstellt ein leeres Formular für uns, das zweite ein Formular mit zwei Schaltflächen: Ok und Abbrechen .

Okay, es gibt einen Formulardesigner , aber er ist ... so lala. Im Vergleich dazu sieht sogar der Layout-Designer in Android Studio komfortabel und gut aus. Die gesamte Benutzeroberfläche wird in einer Bibliothek wie Java Swing entwickelt. Dieser Formular-Designer generiert eine für Menschen lesbare XML-Datei. Wenn Sie im Formular-Designer nichts tun können (Beispiel: Fügen Sie mehrere Steuerelemente in dieselbe Rasterzelle ein und verbergen Sie alle Steuerelemente bis auf eines), müssen Sie zu dieser Datei gehen und sie ändern. IDEA übernimmt diese Änderungen.

Fast jedes Formular besteht aus zwei Dateien: Die erste hat die Erweiterung .form , dies ist nur die XML-Datei, die zweite ist die sogenannte Bound-Klasse , die in Java, Kotlin, geschrieben werden kann, aber was auch immer Sie wollen. Es fungiert als Formular-Controller. Unerwartet, aber das Schreiben in Java ist viel einfacher als in anderen Sprachen. Denn zum Beispiel ist das Tuning für Kotlin noch nicht so perfekt. Wenn Sie bei der Arbeit mit der Java-Klasse neue Komponenten hinzufügen, werden diese Komponenten automatisch zur Klasse hinzugefügt. Wenn Sie den Namen der Komponente im Designer ändern, wird sie automatisch abgerufen. Bei Kotlin werden jedoch keine Komponenten hinzugefügt - es findet keine Integration statt, Sie können etwas vergessen und nicht verstehen, warum nichts funktioniert.

Wir fassen die Grundlagen zusammen

• Um ein Plugin zu erstellen, benötigen Sie: IDEA Community Edition, Plugin DevKit und Java, die damit verbunden sind.
• Gradle-Intellij-Plugin ist dein Bruder, es wird dein Leben stark vereinfachen, ich empfehle es zu benutzen.
• Schreiben Sie keine eigene Benutzeroberfläche, es sei denn, dies ist erforderlich. In IDEA gibt es viele Dienstprogrammklassen, mit denen Sie sofort eine eigene Benutzeroberfläche erstellen können. Wenn Sie etwas Kompliziertes brauchen, machen Sie sich bereit, hart zu arbeiten.
• Das Plugin kann beliebig viele Aktionen ausführen. Das gleiche Plugin kann Ihrer IDEA viele Funktionen hinzufügen.

IDEA-Interna: Komponenten, PSI

Lassen Sie uns über den Darm von IDEA sprechen, darüber, wie er im Inneren angeordnet ist. Ich sage Ihnen, dass nichts in Ihrem Kopf zusammenbricht, wenn ich den praktischen Teil erkläre, und dass Sie verstehen, woher er kommt.

Wie ist IDEA aufgebaut? Auf der ersten Ebene der Hierarchie befindet sich eine Klasse wie Application . Dies ist eine separate IDEA-Instanz. Für jede IDEA-Instanz wird ein Anwendungsklassenobjekt erstellt. Wenn Sie beispielsweise AppCode, Intellij IDEA und Android Studio gleichzeitig ausführen, erhalten Sie drei separate Instanzen der Anwendungsklasse. Diese Klasse ist für den Eingabe- / Ausgabestream ausgelegt.

Die nächste Stufe ist die Projektklasse . Dies ist das Konzept, das dem beim Öffnen eines neuen Projekts in IDEA am nächsten kommt. Das Projekt wird normalerweise benötigt, um andere Komponenten in IDEA zu integrieren: Dienstprogrammklassen, Manager und vieles mehr.

Die nächste Detailebene ist die Modulklasse . Im Allgemeinen ist ein Modul eine Hierarchie von Klassen, die in einem Ordner zusammengefasst sind. Aber hier meinen wir mit Modulen Maven-Module, Gradle-Module. Diese Klasse wird zum einen benötigt, um die Abhängigkeiten zwischen Modulen zu bestimmen, und zum anderen, um nach Klassen innerhalb dieser Module zu suchen.

Die nächste Detailebene ist die VirtualFile- Klasse. Dies ist eine Abstraktion über die reale Datei , die sich auf Ihrer Festplatte befindet. Mehrere VirtualFile- Instanzen können jeder realen Datei entsprechen, sind jedoch alle gleich. Wenn gleichzeitig die reale Datei gelöscht wird, wird VirtualFile nicht selbst gelöscht, sondern wird einfach ungültig.

Jeder VirtualFile ist eine Entität wie Document zugeordnet. Es ist eine Abstraktion über den Text Ihrer Datei. Das Dokument wird benötigt, damit Sie Ereignisse verfolgen können, die sich auf Änderungen im Text der Datei beziehen: Der Benutzer hat eine Zeile eingefügt, eine Zeile gelöscht usw. usw.

Ein wenig neben dieser Hierarchie steht die Editor- Klasse - es ist ein Code-Editor. Jedes Projekt kann einen Editor haben . Es wird benötigt, damit Sie Ereignisse im Zusammenhang mit dem Code-Editor verfolgen können: Der Benutzer hat die Zeile markiert, in der sich das Caret befindet, und so weiter.

Das Letzte, worüber ich sprechen wollte, ist PsiFile . Dies ist auch eine Abstraktion über reale Dateien, jedoch unter dem Gesichtspunkt der Darstellung von Codeelementen . PSI steht für Program Structure Interface.

Und woraus besteht jedes Programm? Betrachten Sie eine reguläre Java-Klasse.

 package com.experiment; import javax.inject.Inject; class SomeClass { @Inject String injectedString; public void someMethod() { System.out.println(injectedString); } } 

Es besteht aus der Angabe eines Pakets, von Importen, Klassen, Feldern, Methoden, Anmerkungen, Schlüsselwörtern, Datentypen, Modifikatoren, Bezeichnern, Methodenreferenzen, Ausdrücken und Token. Und für jedes Element gibt es eine Abstraktion von PsiElement . Das heißt, jedes Ihrer Programme besteht aus PsiElements .

PsiFile ist wiederum eine Baumstruktur, in der jedes Element ein übergeordnetes Element und viele Nachkommen haben kann.

Ich möchte erwähnen, dass PSI nicht gleich einem abstrakten Syntaxbaum ist . Ein abstrakter Syntaxbaum ist ein Repräsentationsbaum Ihres Programms, nachdem der Parser Ihr Programm übergeben hat, und er ist von jeder Programmiersprache getrennt. PSI ist im Gegenteil an eine bestimmte Programmiersprache gebunden . Wenn Sie mit einer Java-Klasse arbeiten, haben Sie es mit Java PsiElements zu tun. Bei der Arbeit mit einer Groovy-Klasse - mit Groovy PsiElements und so weiter. , PSI- - , , , – .

PSI – PSI- IDEA. , , , . .

IDEA

• PSI IDEA;
• PSI- IDEA, ;
• PsiElement-.

, . .