idea插件开发

https://www.cnblogs.com/mushan/p/12275581.html

https://www.cnblogs.com/kancy/p/10654569.html

https://www.cnblogs.com/yaoxiaohui/archive/2009/03/08/1406228.html

 

写Java代码的时候，经常会涉及到重复性的操作，这个时候就会想要是有这样一个插件就好了，如果是大家都会遇到的场景，IDE或许已经提供了，再不然也有可能有人编写了相关的插件。要是这个操作是你们的编码环境特有的，那就只能自己写工具了。所以这里来学学如何编写IDEA插件，让自己的编程环境更加强大，更好的进行装逼。

开发环境

开发IDEA插件有以下这些依赖：

• IntelliJ IDEA Community Edition
• IntelliJ IDEA Community Edition 源码
• Plugin DevKit 插件
• IntelliJ Platform SDK

安装IntelliJ IDEA Community Edition

你可能已经安装了Ultimate版本，但是你还是需要安装IDEA的社区版本。因为商业版是闭源的，所以在调试时无法调试核心代码。

下载IntelliJ IDEA Community Edition源码

社区版的安装包里是不包含源码的，所以我们需要手动从github上clone一份：

git clone --depth 1 git://git.jetbrains.org/idea/community.git idea

关于从源码运行IDEA的方法参考：Check Out And Build Community Edition

添加IDEA jdk

虽然不知道原因，但是根据Check Out And Build Community Edition，我们需要建立一个IDEA jdk来运行插件：

除非你在Mac上使用官方JDK，否则你需要手动添加/lib/tools.jar到classpath中。

配置IntelliJ Platform SDK

打开File | Project Structure新建一个IntelliJ Platform SDK：

Java SDK选择我们刚刚建立的IDEA jdk：

然后我们可以把下载的IDEA社区版源码添加到源码路径中，这样在调试时，就可以调试IDEA自身的代码了：

第一个插件

我们来编写一个最简单的插件来学习编写一个插件的完整步骤。

新建工程

选择IntellJ Platform Plugin，然后Project SDK指定刚刚新建的plugin sdk：

新建的插件项目：

插件根目录下有两个目录src和resources。src是插件代码目录，resource是插件资源目录，其中META-INF/plugin.xml是插件的描述文件，就像Java web项目的web.xml一样。

plugin.xml默认的内容如下：

<idea-plugin>
  <id>com.your.company.unique.plugin.id</id>
  <name>Plugin display name here</name>
  <version>1.0</version>
  <vendor email="support@yourcompany.com" url="http://www.yourcompany.com">YourCompany</vendor>

  <description><![CDATA[
      Enter short description for your plugin here.<br>
      <em>most HTML tags may be used</em>
    ]]></description>

  <change-notes><![CDATA[
      Add change notes here.<br>
      <em>most HTML tags may be used</em>
    ]]>
  </change-notes>

  <!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/build_number_ranges.html for description -->
  <idea-version since-build="145.0"/>

  <!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/plugin_compatibility.html
       on how to target different products -->
  <!-- uncomment to enable plugin in all products
  <depends>com.intellij.modules.lang</depends>
  -->

  <extensions defaultExtensionNs="com.intellij">
    <!-- Add your extensions here -->
  </extensions>

  <actions>
    <!-- Add your actions here -->
  </actions>

</idea-plugin>

新建一个Action

插件扩展IDEA最常见的方式就是在菜单栏或者工具栏中添加菜单项，用户通过点击菜单项来触发插件功能。IDEA提供了AnAction类，这个类有一个虚方法actionPerformed，这个方法会在每次菜单被点击时调用。

新建一个自定义的Action有两个步骤：

1. 继承AnAction类，在actionPerformed方法中实现插件逻辑
2. 注册action，有两种方式，通过代码注册和通过plugin.xml注册

我们先写一个简单的Action类：

public class TextBoxes extends AnAction {
    // 如果通过Java代码来注册，这个构造函数会被调用，传给父类的字符串会被作为菜单项的名称
    // 如果你通过plugin.xml来注册，可以忽略这个构造函数
    public TextBoxes() {
        // 设置菜单项名称
        super("Text _Boxes");
        // 还可以设置菜单项名称，描述，图标
        // super("Text _Boxes","Item description",IconLoader.getIcon("/Mypackage/icon.png"));
    }
 
    public void actionPerformed(AnActionEvent event) {
        Project project = event.getData(PlatformDataKeys.PROJECT);
        String txt= Messages.showInputDialog(project, "What is your name?", "Input your name", Messages.getQuestionIcon());
        Messages.showMessageDialog(project, "Hello, " + txt + "!\n I am glad to see you.", "Information", Messages.getInformationIcon());
    }
}

然后我们在plugin.xml中注册这个Action：

<actions>
  <group id="MyPlugin.SampleMenu" text="_Sample Menu" description="Sample menu">
    <add-to-group group-id="MainMenu" anchor="last"  />
       <action id="Myplugin.Textboxes" class="Mypackage.TextBoxes" text="Text _Boxes" description="A test menu item" />
  </group>
</actions>

这里我们新建了一个菜单组，其中text字符串的下划线表示这个字母作为快捷键。这个菜单显示的效果如下：

除了手动新建Action，IDEA还提供了快速新建的方法，在代码目录上点击新建，可以看到Action：

可以在这个面板中填写你要新建的Action信息，IDEA会帮你新建类，还有在plugin.xml中帮你注册：

运行插件

运行插件特别简单，和运行普通Java代码一样，点击运行或者调试的按钮，就会启动一个新的IDEA实例，这个实例中插件是生效的。

点击Text Boxes就可以看到插件的效果了。

参考资料

• Setting Up a Development Environment
• How to make an IntelliJ IDEA plugin in less than 30 minutes

 

5.带对话框的插件

一种常见的插件就是点击插件对应的菜单项后，弹出一个对话框（例如搜索工作空间里的类、提交SVN前的代码确认等等）。其实很简单，实现方法就是先创建一个Dialog，然后在Swing设计器中设计好Dialog中的控件布局，最后在Action中显示出对话框。具体代码就不列举了，有需求可以找我索取。

 

 

PicoContainer基础介绍

 

基础

这是一篇PicoContainer最重要特性的快速介绍。读完你能对PicoContainer是什么和不是什么有一个概念。

PicoContainer最重要的特性是实例化任意对象。这些通过它的API完成，这些API类似于HashTable。你向PicoContainer指定java.lang.Class对象，之后能够获得对象实例。

 

例子:

1.    MutablePicoContainer pico = new DefaultPicoContainer();  

2.    pico.addComponent(ArrayList.class);  

3.    List list = (List) pico.getComponent(ArrayList.class);  

这段代码做的事情类似如下代码：

1.    List list = new ArrayList();  

像这样的小例子并未展示PicoContainer的特性。只是展示了最基本的API。PicoContainer只有当大量类和接口之间存在负责依赖关系时，才能体现它的用处。

 

 

复杂依赖Juicer的例子

（绿色代表类，黄色代表接口）。PicoContainer通过注册类的构造方法指定依赖关系，PicoContainer可以被理解为一个通用工厂，并且可以被动态配置。PicoContainer能够实例化多个相互关联对象的复杂图关系。

 

写一些简单对象和接口的关联关系

上面Juicer的例子可以被转换成下述代码（我们增加了一个实现了Peelable接口的实例）:

 

 

1.    public interface Peelable {  

2.     void peel();  

3.    }  

 

1.    public class Apple implements Peelable {  

2.     public void peel() {  

3.     }  

4.    }  

 

1.    public class Peeler implements Startable {  

2.     private final Peelable peelable;  

3.      

4.     public Peeler(Peelable peelable) {  

5.     this.peelable = peelable;  

6.     }  

7.      

8.     public void start() {  

9.     peelable.peel();  

10. }  

11.  

12. public void stop() {  

13.  

14. }  

15.}  

 

1.    public class Juicer {  

2.     private final Peelable peelable;  

3.     private final Peeler peeler;  

4.      

5.     public Juicer(Peelable peelable, Peeler peeler) {  

6.     this.peelable = peelable;  

7.     this.peeler = peeler;  

8.     }  

9.    }  

装配组件

通过像这样注册类，PicoContainer对其进行了管理（注册顺序没有特别要求）：

1.    MutablePicoContainer pico = new DefaultPicoContainer();  

2.    pico.addComponent(Apple.class);  

3.    pico.addComponent(Juicer.class);  

4.    pico.addComponent(Peeler.class);  

 

实例化组件：

通过指定，可以从PicoContainer获得指定类的实例（获得的对象之前已经注册过）：

1.    Juicer juicer = (Juicer) pico.getComponent(Juicer.class);  

这将导致PicoContainer在这个情景下做如下事情：

1.    Peelable peelable = new Apple();  

2.    Peeler peeler = new Peeler(peelable);  

3.    Juicer juicer = new Juicer(peelable, peeler);  

4.    return juicer;  

注意PicoContainer识别出Apple是Peelable接口的实现，所以它可以被传递给Peeler和Juicer的构造函数。

 

容器层次结构

PicoContainer提供了对Singleton模式的一个有力替代物。通过容器层次结构，在对象实例的可见范围内，你能够创建类似Singleton的对象，并对其进行合适粒度的控制。（Singleton模式是静态和全局的。它不允许在全局范围内有多于一个的实例，并且它在全局任意地方均可见。当你试图通过它构建大型企业级应用时，这并不是非常理想。）

 

一个容器（和它的注册组件）能够访问其父类容器，但相反则不行。思考下面的例子，这个例子使用了上面的类：

这个例子只是为了说明问题，并不能工作！

1.    // Create x hierarchy of containers  

2.    MutablePicoContainer x = new DefaultPicoContainer();  

3.    MutablePicoContainer y = new DefaultPicoContainer( x );  

4.    MutablePicoContainer z = new DefaultPicoContainer( y );  

5.      

6.    // Assemble components  

7.    x.addComponent(Apple.class);  

8.    y.addComponent(Juicer.class);  

9.    z.addComponent(Peeler.class);  

10.  

11.// Instantiate components  

12.Peeler peeler = (Peeler) z.getComponent(Peeler.class);  

13.// WON'T WORK! peeler will be null  

14.peeler = (Peeler) x.getComponent(Peeler.class);  

15.// WON'T WORK! This will throw an exception  

16.Juicer juicer = (Juicer) y.getComponent(Juicer.class);  

这段代码可以被如下图示:

分析一下原因：

• 12行工作正常。Z能够从父容器中解析Peeler的依赖关系(Apple水果类的对象)
• 14行返回null，因为x找不到Peeler
• 16行抛出异常，因为Juicer的依赖关系Peeler不能够满足（y容器访问不到z容器）

当然上述代码显然不能工作，这只是一个说明容器层次结构如何工作的示例。

 

生命周期

PicoContainer支持生命周期。如果你定义的类实现了Startable接口，那么就能够通过在容器上的简单方法调用，控制这些对象的生命周期。容器的start()和stop()方法能够完成所有其所管理对象的start()和stop()方法的激活顺序。

 

调用容器的start()方法将调用所有容器管理对象的start()方法，用于实例化。

这意味着开始这些对象没有依赖关系，并且结束时他们拥有对其他对象的依赖。

 

生命周期还能作用于容器的层次结构。调用含有子容器的容器，将按广度优先顺序启动所有子容器，每个子容器启动其自己的调用。同样，调用stop()方法将导致容器层次结构中的容器按深度优先顺序依次调用其stop()过程。下图显示了当含有子容器的容器在调用其start()和stop()方法时，发生的情况。

MutablePicoContainer.start()

MutablePicoContainer.stop()

为了层次结构相关的生命周期能够工作，子容器必须被注册为其父容器的组件。仅仅创建容器时指定其父容器不能够导致父容器了解子容器。

 

例子：

1.    MutablePicoContainer parent = new DefaultPicoContainer(new Caching());  

2.    MutablePicoContainer child = new DefaultPicoContainer(parent);  

3.    // We must let the parent container know about the child container.  

4.    parent.addComponent(child);  

5.    // This will start the parent, which will start the child.  

6.    parent.start();  

 

比较使用风格

使用PicoContainer，你添加组件和获得实例可以有两种风格：

经典bean风格：

1.    pico = new DefaultPicoContainer();  

2.    pico.addComponent(ComponentOneImpl.class) // by type  

3.    pico.addComponent(ComponentTwoImpl.class) // by type  

4.    pico.addComponent(new ComponentThreeImpl()) // by instance  

5.    pico.addComponent(ComponentFourImpl.class) // by type  

6.      

7.    ComponentFourImpl four = pico.getComponent(ComponentFourImpl.class);  

根据习惯，你也可以使用流畅的风格：

  ComponentFour four = new DefaultPicoContainer()  

   .addComponent(ComponentOne.class)  

   .addComponent(ComponentTwo.class)  

   .addComponent(new ComponentThree())  

   .addComponent(ComponentFour.class)  

   .getComponent(ComponentFour.class);