NetBeans Copy Class Refactoring 模块教程_软件开发_Java

NetBeans Copy Class Refactoring 模块教程

作者: keven 日期: 08-04-04, 00:27

摘要: NetBeans Copy Class Refactoring 模块教程反馈请注意，并不是本教程中介绍的所有 API 都是当前最新的。在您自己的磁盘上使用它们。不保证本教程中使用的 NetBe... NetBeans Copy Class Refactoring 模块教程

MegaEntry 网络社区与信息交流平台!

反馈

请注意，并不是本教程中介绍的所有 API 都是当前最新的。在您自己的磁盘上使用它们。不保证本教程中使用的 NetBeans 与最终版本或下一个版本的 NetBeans 兼容。

重构是使用一些小变换重新设计代码，但不会改变任何程序行为。就像您构造一个表达式使它更容易理解和修改一样，您重构代码可以使其更容易读，更容易理解，更快更新。就像重构的表达式必须产生相同的效果一样，重构的程序必须与原始源具有相同的功能。

重构代码的一些常见目的包括：

使代码更容易更改或者更容易添加新的功能
降低复杂性以便更好地理解
删除不必要的重复
使代码能够满足其他需要或更一般的需要

本教程向您介绍如何通过添加附加的重构功能即 Copy Class 来扩展 IDE。Copy Class 功能允许您向相同或不同的包复制类。当您复制类时，您可以更改名称，也可以更改构造方法的名称。如果该类被复制到一个新包，则自动更新包声明。

本教程将介绍以下主题：

了解示例

安装软件
安装示例
介绍示例

设置模块项目

访问 NetBeans IDE 源
创建模块项目
指定模块的依存关系

创建重构逻辑

创建 Refactoring 类
创建 Refactoring Plugin 类
创建 Refactoring Plugin 工厂

创建用户界面

创建 CopyClass Action
创建 CopyClass RefactoringUI
创建 CopyClass 面板

在 NetBeans System Filesystem 中注册 Refactoring
构建和安装模块
向 NetBeans 捐献重构

安装完软件之后，本教程可以在 60 分钟之内完成。

有关创建 NetBeans 插件模块的更多信息，请参见 NetBeans 网站上的 NetBeans Development Project 主页。如果有问题，请访问 NetBeans Developer FAQ 或使用本页顶部的反馈链接。

了解示例

开始编写插件模块之前，必须确保您具备所有必要的软件。此外，您可能想在亲自构建之前使用示例。

安装软件

开始之前，需要在您的计算机上安装以下软件：

NetBeans IDE 5.0（下载）
NetBeans IDE 5.0 源文件（下载）
Java Standard Development Kit (JDK! ") version 1.4.2（下载）或 5.0（下载）

安装示例

采用以下步骤来安装示例：

解压缩附加的文件。
在 IDE 中，选择 File > Open Project，然后浏览到包含已解压缩文件的文件夹。打开模块项目。其形式如下：
右键单击项目节点并在 Target Platform 中选择 Install/Reload。将打开目标平台并安装该模块。

介绍示例

创建或打开应用程序并确保它具有一个 Java 源文件。
选择该 Java 源文件并在 Refactor 窗口中，选择新的 Copy Class 菜单项，如下所示：

将打开 Copy Class 对话框，如下所示：

也可以使用 To Package 下拉菜单选择将 Java 源文件复制到的包。如果没有选择包，则将该文件复制到包含原始文件的包。
单击 Next。将打开 Refactoring 窗口，如下所示：
单击 Do Refactoring。该类将被复制到您指定的文件夹中。

现在您了解了 Copy Class Refactoring 插件模块的用户界面，让我们从头开始创建该模块。

设置模块项目

开始编写模块前，必须确保正确地设置了项目。

访问 NetBeans IDE 源

当您使 IDE 的源可用于 NetBeans Platform Manager 时，您可以从 Source Editor 中访问 IDE 的源文件和 Javadoc。这样便简化了插件模块的开发，原因是它使您能够非常快速地查找有关执行的类和方法的信息。整个教程中都提到源和 Javadoc，因此应该在进行下一步前先使它们可用。

如果您尚未这样做，请从此处下载源。
选择 Tools > NetBeans Platform Manager。
在 Sources 选项卡中，单击 Add ZIP/Folder，并浏览到包含 NetBeans IDE 源的 ZIP 文件，如下所示：
单击 Close。

创建模块项目

选择 File > New Project。在 Categories 下，选择 NetBeans Plug-in Modules。在 Projects 下，选择 Module Project 并单击 Next。
在 Name and Location 面板中，在 Project Name 中键入 CopyClassRefactoring。将 Project Location 更改为您计算机上的任何目录，如 c:mymodules。选择 Standalone Module 单选按钮和 Set as Main Project 复选框。单击 Next。
在 Basic Module Configuration 面板中，将 Code Name Base 中的 yourorghere 替换为 netbeans.modules，于是全名为 org.netbeans.modules.copyclassrefactoring。在 Module Display Name 中填入 CopyClassRefactoring。留出本地化资源包和 XML 层的位置，以便将它们存储在具有名称 org.netbeans.modules.copyclassrefactoring 的包中。单击 Finish。

IDE 创建 CopyClassRefactoring 项目。该项目包含所有资源和项目元数据，如该项目的 Ant 构建脚本。该项目在 IDE 中打开。您可以在 Projects 窗口 (Ctrl-1) 中查看其逻辑结构，在 Files 窗口 (Ctrl-2) 中查看其文件结构。

指定模块的依存关系

您需要将几个属于 NetBeans API 的类设为子类。每个类都将被声明为 Module 依存关系。使用 Project Properties 对话框来执行此操作。

在 Projects 窗口中，右键单击 CopyClassRefactoring 项目节点并选择 Properties。在 Project Properties 对话框中单击 Libraries。
对于以下每个 API，单击“Add...”，从 Module 列表中选择名称，然后单击 OK 确认：
单击 OK，退出 Project Properties 对话框。
在 Projects 窗口中，展开 Important Files 节点，双击 Project Metadata 节点，并注意查看您选择的 API 是否按模块依存关系进行了声明：

<?xml version=                   "1.0                   " encoding=                   "UTF-8                   "?>

<project xmlns=                   "http://www.netbeans.org/ns/project/1                   ">

    <type>org.netbeans.modules.apisupport.project</type>

    <configuration>

        <data xmlns=                   "http://www.netbeans.org/ns/nb-module-project/2                   ">

            <code-name-base>org.netbeans.modules.refactoring.copyclass</code-name-base>

            <standalone/>

            <module-dependencies>

                <dependency>

                    <code-name-base>javax.jmi.reflect</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                        <specification-version>1.6</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.api.mdr</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.jmi.javamodel</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>2</release-version>

                        <specification-version>1.19.0</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.modules.java</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                        <specification-version>1.24.0.2.2.2</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.modules.java.project</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                        <specification-version>1.7</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.modules.javacore</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                        <specification-version>1.16.0.2.2</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.modules.jmiutils</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                        <specification-version>1.4.0.2</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.modules.projectapi</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.modules.projectuiapi</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.modules.refactoring</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                        <implementation-version/>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.openide.awt</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <specification-version>6.6</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.openide.filesystems</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <specification-version>6.2</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.openide.loaders</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <specification-version>5.4</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.openide.modules</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <specification-version>6.2</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.openide.nodes</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <specification-version>6.2</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.openide.text</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <specification-version>6.2</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.openide.util</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <specification-version>6.5</specification-version>

                    </run-dependency>

                </dependency>

            </module-dependencies>

            <public-packages/>

        </data>

    </configuration>

</project>

创建重构逻辑

重构的非可视部分执行重构逻辑。基本上它由两个类组成，即“refactoring”类和“refactoring plugin”类。

创建 Refactoring 类

refactoring 类作为用于调用重构的 API。此外，refactoring plugin 类使用它来确定重构参数。refactoring 类本身几乎不执行任何工作，所有工作都由 refactoring plugin 类来完成。refactoring 类通常只包含重构参数的获取方法和设置方法。参数为 newName、targetFolder 和 targetPackageName。它们在 Copy Class 对话框中使用：

执行以下操作：

创建文件。 右键单击 CopyClassRefactoring 项目节点，选择 New > Java Class，在 Class Name 中键入 CopyClassRefactoring，然后从 Package 下拉列表中选择 org.netbeans.modules.copyclassrefactoring。单击 Finish。新 Java 类将在 Source Editor 中打开。用以下内容替换默认代码：

package org.netbeans.modules.refactoring.copyclass;



import org.netbeans.jmi.javamodel.Resource;

import org.netbeans.modules.refactoring.api.AbstractRefactoring;

import org.netbeans.modules.refactoring.classpath.Util;

import org.openide.filesystems.FileObject;



public final class CopyClassRefactoring extends AbstractRefactoring {

   

    private Resource resource;

    private FileObject targetFolder;

    private String targetPackageName;

    private String newName;

   

    /** Creates a new instance of CopyClassRefactoring

     *

     */

    public CopyClassRefactoring(Resource resource) {

        this.resource = resource;

    }

   

    protected void setClassPath() {

        // leave the complete classpath

        Util.setDefaultClassPath();

    }



    public Resource getResource() {

        return resource;

    }



    // --- START PARAMETERS ----------------------------------------------------------



    public FileObject getTargetClassPathRoot() {

        return targetFolder;

    }



    public void setTargetClassPathRoot(FileObject targetFolder) {

        this.targetFolder = targetFolder;

    }

   

    public String getTargetPackageName() {

        return targetPackageName;

    }

   

    public void setTargetPackageName(String newName) {

        this.targetPackageName = newName;

    }

   

    public String getNewName() {

        return newName;

    }

   

    public void setNewName(String newName) {

        this.newName = newName;

    }



    // --- END PARAMETERS ----------------------------------------------------------



}

读取源。 按下 Ctrl 键，将鼠标移动到 AbstractRefactoring 标识符上，并注意到出现一个超链接：

单击该链接。AbstractRefactoring 类在 Source Editor 中打开。熟悉一下源文件并理解它如何与其 CopyClassRefactoring 实现相关。

创建 Refactoring Plugin 类

每个重构都应该至少有一个执行所有工作的插件类。重构模块本身应该提供进行 J2SE 重构的基本插件类。其他模块可以添加其他插件，这允许它们参与重构。例如，当重命名一个方法时，J2EE 插件类需要重命名 EJB（如有必要）的其他界面中的相关方法，并且更改部署描述符。下面介绍的插件类是执行所有基本 J2SE 工作的基本插件类。

插件类需要实现的四个方法为：

preCheck()。检查前提条件。
fastCheckParameters()。检查参数的有效性，只检查能快速执行且不需要复杂计算的检查。
checkParameters()。对所有 fastCheckParameters() 方法未涉及的其他参数进行有效性检查。
prepare()。负责创建重构所做更改的描述符（RefactoringElement 实现的实例）。实际上该方法负责告诉重构如何执行。通过创建 RefactoringElement 的特定实现的实例来实现，每个实例代表重构应该做的更改。因此，如果是 Rename Field 重构，则每次访问字段时进行的重命名将具有相应的 RefactoringElement，用来表示发生了一次重命名。因此，除了执行 prepare() 方法本身之外，您还需要创建将用于执行更改的 RefactoringElement 接口的实现。重构元素通常作为 SimpleRefactoringElementImpl 的子类被创建。以下是需要执行的方法：
- performChange()。执行重构元素所代表的更改。
- getText()。返回重构元素的文本。这通常包含重构元素将更改的代码片段或描述重构元素将执行功能的文本。
- getDisplayText()。通常与 getText() 相同，但是可能包含 HTML 标记。例如，如果更改包含代码的返回行，则可以使用 HTML 标记来用粗体显示将要更改的代码片段。
- getParentFile()。将受重构元素所代表的更改影响的文件。
- getJavaElement()。与此更改相关的 Java 元素。
- getPosition()。相关代码的文档位置。
由 prepare() 方法实例化重构元素并将其添加到作为输出参数的 RefactoringElementsBag 的实例。

所有上面的方法都返回名为 Problem 的类的实例。该类的实例代表对于执行重构来说可能是致命的或非致命的问题。这些方法执行各种检查（如给定重构的规范中所述）并返回它们发现的问题作为提到的 Problem 类的实例。可以将这些问题链接起来（使用 Problem.setNext() 方法），这有可能返回单次操作中的几个问题。注意致命问题必须位于链首。使用 JavaRefactoringPlugin.createProblem() 方法创建问题将自动确保此要求。所有方法（除 fastCheckParameters() 之外）都应该激发进度事件，因为它们正在执行潜在的耗费时间的操作。

执行以下操作：

创建文件。 右键单击 CopyClassRefactoring 项目节点，选择 New > Java Class，在 Class Name 中键入 CopyClassRefactoringPlugin，然后从 Package 下拉列表中选择 org.netbeans.modules.copyclassrefactoring。单击 Finish。新 Java 类将在 Source Editor 中打开。用以下内容替换默认代码：

package org.netbeans.modules.refactoring.copyclass;



import java.io.IOException;

import java.text.MessageFormat;

import java.util.Iterator;

import java.util.StringTokenizer;

import org.netbeans.jmi.javamodel.Element;

import org.netbeans.jmi.javamodel.Import;

import org.netbeans.jmi.javamodel.ImportClass;

import org.netbeans.jmi.javamodel.JavaClass;

import org.netbeans.jmi.javamodel.JavaModelPackage;

import org.netbeans.jmi.javamodel.Resource;

import org.netbeans.modules.javacore.JMManager;

import org.netbeans.modules.javacore.api.JavaModel;

import org.netbeans.modules.javacore.internalapi.JavaMetamodel;

import org.netbeans.modules.javacore.internalapi.JavaModelUtil;

import org.netbeans.modules.refactoring.CheckUtils;

import org.netbeans.modules.refactoring.api.AbstractRefactoring;

import org.netbeans.modules.refactoring.api.MoveClassRefactoring;

import org.netbeans.modules.refactoring.api.Problem;

import org.netbeans.modules.refactoring.api.RenameRefactoring;

import org.netbeans.modules.refactoring.plugins.JavaRefactoringPlugin;

import org.netbeans.modules.refactoring.plugins.MoveClassRefactoringPlugin;

import org.netbeans.modules.refactoring.spi.SimpleRefactoringElementImpl;

import org.netbeans.modules.refactoring.spi.RefactoringElementImplementation;

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag;

import org.openide.ErrorManager;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.openide.loaders.DataFolder;

import org.openide.loaders.DataObject;

import org.openide.text.PositionBounds;

import org.openide.util.NbBundle;

import org.openide.util.Utilities;



/** Plugin that implements the core functionality of Copy Class Refactoring.

 */

public class CopyClassRefactoringPlugin extends JavaRefactoringPlugin {

   

    /** Reference to the parent refactoring instance */

    private final CopyClassRefactoring refactoring;

   

    /** Creates a new instance of PullUpRefactoringPlugin

     * @param refactoring Parent refactoring instance.

     */

    CopyClassRefactoringPlugin(CopyClassRefactoring refactoring) {

        this.refactoring = refactoring;

    }

   

    /** Checks pre-conditions of the refactoring.

     * @return Problems found or null.

     */

    public Problem preCheck() {

        fireProgressListenerStart(AbstractRefactoring.PRE_CHECK, 4);

        try {

            Resource resource = refactoring.getResource();

           

            // check whether the element is valid

            Problem result = isElementAvail(resource);

            if (result != null) {

                // fatal error -> don                   't continue with further checks

                return result;

            }

           

            if (!CheckUtils.isElementInOpenProject(resource)) {

                return new Problem(true, NbBundle.getMessage(JavaRefactoringPlugin.class,                    "ERR_ProjectNotOpened                   "));

            }

           

            // increase progress (step 1)

            fireProgressListenerStep();

           

            // increase progress (step 2)

            fireProgressListenerStep();

           

            // increase progress (step 3)

            fireProgressListenerStep();

           

            // all checks passed -> return null

            return null;

        } finally {

            // fire operation end on the registered progress listeners

            fireProgressListenerStop();

        }

    }

   

    public Problem fastCheckParameters() {

        if (!Utilities.isJavaIdentifier(refactoring.getNewName())) {

            String msg = new MessageFormat(NbBundle.getMessage(RenameRefactoring.class,                    "ERR_InvalidIdentifier                   ")).format(

                new Object[] {refactoring.getNewName()}

            );

            return createProblem(null, true, msg);

        }

        if (!isValidPackageName(refactoring.getTargetPackageName())) {

            String msg = new MessageFormat(NbBundle.getMessage(RenameRefactoring.class,                    "ERR_InvalidPackage                   ")).format(

                new Object[] {refactoring.getTargetPackageName()}

            );

            return createProblem(null, true, msg);

        }

        String name = refactoring.getTargetPackageName().replace(                   '.                   ',                   '/                   ') +                    '/                   ' + refactoring.getNewName() +                    ".java                   ";

        if (refactoring.getTargetClassPathRoot().getFileObject(name) != null)

    return createProblem(null, true,

new MessageFormat(NbBundle.getMessage(MoveClassRefactoring.class,

                   "ERR_ClassToMoveClashes                   ")).format(new Object[]{refactoring.getNewName()}));

        return null;

    }

   

    private static boolean isValidPackageName(String name) {

        StringTokenizer tokenizer = new StringTokenizer(name,                    ".                   "); // NOI18N

        while (tokenizer.hasMoreTokens()) {

            if (!Utilities.isJavaIdentifier(tokenizer.nextToken())) {

                return false;

            }

        }

        return true;

    }



    public Problem checkParameters() {

        return null;

    }



    public Problem prepare(RefactoringElementsBag refactoringElements) {

        refactoringElements.add(refactoring,

                new CopyClass(

                    refactoring.getResource(),

                    refactoring.getTargetClassPathRoot(),

                    refactoring.getTargetPackageName(),

                    refactoring.getNewName()

                ));

        return null;

    }

}

读取源。 按下 Ctrl 键，将鼠标移动到 JavaRefactoringPlugin 标识符上，并注意到出现一个超链接：

单击该链接。JavaRefactoringPlugin 类在 Source Editor 中打开。熟悉一下源文件并理解它如何与其 CopyClassRefactoringPlugin 实现相关。

接下来，您创建将用来执行更改的 RefactoringElement 接口的实现。通过向上面文件末尾添加以下内部类来完成：

    private static class CopyClass extends SimpleRefactoringElementImpl implements RefactoringElementImplementation{

       

        private DataObject source;

        private FileObject targetRoot;

        private String targetPackageName;

        private String newName;

        private Resource resource;

       

        public CopyClass (Resource resource, FileObject targetRoot, String packageName, String newName) {

            this.source = ((JMManager) JMManager.getManager()).getDataObject(resource);

            this.resource = resource;

            this.targetRoot = targetRoot;

            this.targetPackageName = packageName;

            this.newName = newName;

        }

       

public String getText() {

            return getDisplayText ();

        }

   

public String getDisplayText() {

            return new MessageFormat (NbBundle.getMessage(CopyClassRefactoringPlugin.class,                    "TXT_CopyClassToPackage                   ")).format ( // NOI18N

                new Object[] {newName, targetPackageName, resource.getName()}

            );

        }



public Element getJavaElement() {

            return null;

        }



public PositionBounds getPosition() {

            return null;

        }



public void performChange() {

            String nameAfterCopy = null;

            try {

                FileObject fo = FileUtil.createFolder(targetRoot, targetPackageName.replace(                   '.                   ',                   '/                   '));

                DataFolder folder = DataFolder.findFolder(fo);

                objectToDelete = source.copy(folder);

                nameAfterCopy = objectToDelete.getName();

                objectToDelete.rename(newName);

            } catch (IOException ioe) {

                ErrorManager.getDefault().notify(ioe);

    }

            Resource r = JavaModel.getResource(objectToDelete.getPrimaryFile());

            String name = resource.getPackageName();

            ImportClass proxy = ((JavaModelPackage) r.refOutermostPackage()).getImport();

            Import addedImport = proxy.createImport(name, null, false, true);

            r.addImport(addedImport);

            for (Iterator i = r.getClassifiers().iterator(); i.hasNext(); ) {

                JavaClass c = (JavaClass) i.next();

                if (c.getSimpleName().equals(nameAfterCopy)) {

                    c.setSimpleName(newName);

                }

            }

           

        }



        private DataObject objectToDelete = null;



public FileObject getParentFile() {

            return source.getPrimaryFile();

        }

    }

读取源。 按下 Ctrl 键，将鼠标移动到 RefactoringElementImplementation 标识符上，并注意到出现一个超链接：

单击该链接。RefactoringElementImplementation 类在 Source Editor 中打开。熟悉一下源文件并理解它如何与其内部 CopyClass 实现相关。

创建 Refactoring Plugin 工厂

插件类的实例化由插件工厂执行。通过重构调用调用的 META-INF/services 文件夹中的一个条目，插件工厂在 NetBeans 查询中注册。为了确保调用给定重构时实例化插件类，您需要在工厂的 createInstance() 方法的开始部分为您的插件类添加以下实例化代码：

if (refactoring instanceof YourRefactoring) {

     return new YourRefactoringPlugin((YourRefactoring) refactoring);

}

从上面可以看出，createInstance() 方法将父重构视为参数。每个插件类应该参考父重构以便能够从中获得重构参数。这就是插件类通常将重构作为构造方法参数的原因。

执行以下操作：

创建文件。 右键单击 Unit Test Packages 节点，选择 New > Java Class，在 Class Name 中键入 PluginsFactory，然后从 Package 下拉列表中选择 org.netbeans.modules.copyclassrefactoring。单击 Finish。新 Java 类将在 Source Editor 中打开。用以下内容替换默认代码：

package org.netbeans.modules.refactoring.copyclass;



import org.netbeans.modules.refactoring.api.AbstractRefactoring;

import org.netbeans.modules.refactoring.spi.RefactoringPlugin;

import org.netbeans.modules.refactoring.spi.RefactoringPluginFactory;



public class PluginsFactory implements RefactoringPluginFactory {

    /** Factory method called by a refactoring. Creates and returns a new plugin

     * instance for a given refactoring. If no plugin for a given refactoring

     * is present, this method returns null.

     * @param refactoring Parent refactoring for which a plugin should be created.

     * @return New instance of a refactoring plugin for the provided refactoring

     * or null.

     */

    public RefactoringPlugin createInstance(AbstractRefactoring refactoring) {

        if (refactoring instanceof CopyClassRefactoring) {

            return new CopyClassRefactoringPlugin((CopyClassRefactoring) refactoring);

        }

        return null;

    }

}

读取源。 按下 Ctrl 键，将鼠标移动到 RefactoringPluginFactory 标识符上，并注意到出现一个超链接：

单击该链接。RefactoringPluginFactory 类在 Source Editor 中打开。熟悉一下源文件并理解它如何与其 PluginsFactory 实现相关。
在 NetBeans 查询中注册该工厂。 创建一个名为 META-INF/services 的文件夹。添加名为 org.netbeans.modules.refactoring.spi.RefactoringPluginFactory 的空文件，内容如下：
```
org.netbeans.modules.refactoring.copyclass.PluginsFactory
```

此时，Projects 窗口应该如下所示：

创建用户界面

用户界面由三个组件组成：

Refactoring action。 表示菜单中的重构功能，以调用重构：
RefactoringUI class。 RefactoringUI 接口的实现。插入到重构框架中。提供信息，如重构参数面板、重构的显示名称以及 Refactoring Class 的参考，如下所示：
Refactoring parameters panel。 特定于重构的 JPanel，它将显示在普通重构向导中以收集重构参数。

创建 CopyClassAction

要实现重构操作，您需要创建 org.netbeans.modules.refactoring.spi.ui.AbstractRefactoringAction 的子类。感兴趣的部分是 enabled() 和 createRefactoringUI() 方法：

enabled()。确定在 IDE 中基于当前活动的（选中的）节点应该启用操作的时间。通常情况下，该方法的实现不应该执行任何昂贵的操作，它最好不要接触 Java 元数据，完全由是否有 JavaDataObjects 位于选中的节点之后以及选中的节点数决定（当在 Pull Up 重构时某些操作可能同时适用于几个节点，您可以从中选择拉出几个成员，某些操作可能只能在一个节点上操作）。由于性能的原因，enable() 方法不能获得有关编辑器中 caret 位置的信息，这就是为什么应该减弱该方法中的检查。大部分其他检查应该在重构 preCheck() 方法中执行，该方法可以向用户提供一个描述性消息，说明为什么不在选定对象上执行重构的原因以及用户如何解决该问题。
createRefactoringUI()。用户调用操作时调用。方法接收活动的节点以及表示光标下文本的元素。基于这个原因，该方法应该构造重构应该执行的一组元素（或一个元素），并将其传递到应该从该方法中返回的重构 UI 对象的新实例中。

执行以下操作：

创建文件。 右键单击 CopyClassRefactoring 项目节点，选择 New > Java Class，在 Class Name 中键入 CopyClassAction，在 Package 中键入 org.netbeans.modules.copyclassrefactoring.options。单击 Finish。新 Java 类将在 Source Editor 中打开。用以下内容替换默认代码：

package org.netbeans.modules.refactoring.copyclass.ui;



import org.netbeans.jmi.javamodel.Element;

import org.netbeans.modules.java.JavaDataObject;

import org.netbeans.modules.javacore.JMManager;

import org.netbeans.modules.javacore.api.JavaModel;

import org.netbeans.modules.javacore.internalapi.JavaMetamodel;

import org.netbeans.modules.refactoring.spi.ui.AbstractRefactoringAction;

import org.netbeans.modules.refactoring.spi.ui.RefactoringUI;

import org.openide.loaders.DataObject;

import org.openide.nodes.Node;

import org.openide.util.NbBundle;



public class CopyClassAction extends AbstractRefactoringAction {

   

    /** Creates a new instance of PullUpAction

     */

    public CopyClassAction() {

        super(NbBundle.getMessage(CopyClassAction.class,                    "LBL_CopyClass_Action                   "), null); // NOI18N

        putValue(                   "noIconInMenu                   ", Boolean.TRUE); // NOI18N

    }

   

    /** Method responsible for creating RefactoringUI object.

     * @param nodes Active nodes to perform the refactoring on.

     * @param selectedElement Element to perform the refactoring on or null if the action

     *      was not invoked from the editor - in that case the active nodes take

     *      the precedence.

     * @return RefactoringUI object for Copy Class refactoring.

     */

    protected RefactoringUI createRefactoringUI(Node[] nodes, Element selectedElement) {



if (selectedElement == null) {

            // selected element is null -> action was invoked on nodes

            JavaDataObject ob = (JavaDataObject) nodes[0].getCookie(JavaDataObject.class);

           

            selectedElement =  JavaModel.getResource(ob.getPrimaryFile());

        }

        return new CopyClassRefactoringUI(selectedElement.getResource());

    }

   

    /** Method that determines whether this action is enabled for the active nodes.

     * @param activatedNodes Active nodes.

     * @return Boolean indicating whether the action is enabled.

     */

    protected boolean enabled(Node[] activatedNodes) {

      

// if no nodes are active, the action should be disabled

        if (activatedNodes.length != 1) return false;

       

        // the action should be enabled only if all selected nodes are associated

        // with the same JavaDataObject (i.e. they are all declared in the same Java file)

        // so, let                   's get dataobject from the first activated node

        DataObject dobj = (DataObject) activatedNodes[0].getCookie(DataObject.class);



        // check if the dataobject is instance of JavaDataObejct and that it represents a file

        // that is on the IDE classpath (belongs to one of open projects)

        if ((dobj instanceof JavaDataObject) && ((JMManager) JavaMetamodel.getManager()).mergedCPContains(dobj.getPrimaryFile())) {

            return true;

        } else {

            return false;

}



    }

   

    protected String iconResource () {

        return                    "org/netbeans/modules/refactoring/resources/refactoring.gif                   "; // NOI18N

    }

}

读取源。 按下 Ctrl 键，将鼠标移动到 AbstractRefactoringAction 标识符上，并注意到出现一个超链接：

单击该链接。AbstractRefactoringAction 类在 Source Editor 中打开。熟悉一下源文件并理解它如何与其 CopyClassAction 实现相关。

创建 CopyClassRefactoringUI

要将该模块插入到重构框架中，您需要创建 org.netbeans.modules.refactoring.spi.ui.RefactoringUI 的子类。感兴趣的部分是 getPanel() 和 checkParameters() 方法：

getPanel()。返回包含重构参数的输入字段的特定于重构的面板。该方法由负责显示重构参数对话框的 ParametersPanel 调用。从该方法中返回的面板的名称将用作对话框的名称。该面板可以使用传递 ParametersPanel 的 setPreviewEnabled 方法来启用和禁用重构参数对话框的 Preview 按钮。
checkParameters()。检查用户在重构参数面板中输入的参数并设置值。

执行以下操作：

创建文件。 创建 CopyClassRefactoringUI 文件并将其添加到 org.netbeans.modules.copyclassrefactoring.options 包中。用以下内容替换默认代码：

package org.netbeans.modules.refactoring.copyclass.ui;



import org.netbeans.jmi.javamodel.JavaClass;

import org.netbeans.jmi.javamodel.Resource;

import org.netbeans.modules.javacore.api.JavaModel;

import org.netbeans.modules.refactoring.api.AbstractRefactoring;

import org.netbeans.modules.refactoring.api.Problem;

import org.netbeans.modules.refactoring.copyclass.CopyClassRefactoring;

import org.netbeans.modules.refactoring.spi.ui.CustomRefactoringPanel;

import org.netbeans.modules.refactoring.spi.ui.ParametersPanel;

import org.netbeans.modules.refactoring.spi.ui.RefactoringUI;

import org.netbeans.modules.refactoring.ui.PullUpRefactoringUI;

import org.openide.util.HelpCtx;

import org.openide.util.NbBundle;



public class CopyClassRefactoringUI implements RefactoringUI {

    // reference to pull up refactoring this UI object corresponds to

    private final CopyClassRefactoring refactoring;

    // UI panel for collecting parameters

    private CopyClassPanel panel;

   

    public CopyClassRefactoringUI(Resource resource) {

        refactoring = new CopyClassRefactoring(resource);

    }

   

    // --- IMPLEMENTATION OF RefactoringUI INTERFACE ---------------------------

   

    public boolean isQuery() {

        return false;

    }



    public CustomRefactoringPanel getPanel(ParametersPanel parent) {

        if (panel == null) {

    panel = new CopyClassPanel(parent, getName()

+                    " -                    " + ((JavaClass) refactoring.getResource().getClassifiers().get(0)).getName(),

refactoring.getResource().getPackageName(), JavaModel.getFileObject(refactoring.getResource()));

        }

        return panel;

    }



    public Problem setParameters() {

        setupRefactoring();

        return refactoring.checkParameters();

    }

   

    public Problem checkParameters() {

        if (panel==null)

            return null;

        setupRefactoring();

        return refactoring.fastCheckParameters();

    }

   

    private void setupRefactoring() {

        refactoring.setTargetClassPathRoot(panel.getRootFolder());

        refactoring.setTargetPackageName(panel.getPackageName().replace(                   '/                   ',                     '.                   '));

        refactoring.setNewName(panel.getNewName());

    }



    public AbstractRefactoring getRefactoring() {

        return refactoring;

    }



    public String getDescription() {

        return NbBundle.getMessage(CopyClassAction.class,                    "DSC_CopyClass                   ", refactoring.getNewName()); // NOI18N

    }



    public String getName() {

        return NbBundle.getMessage(CopyClassAction.class,                    "LBL_CopyClass                   "); // NOI18N

    }



    public boolean hasParameters() {

        return true;

    }



    public HelpCtx getHelpCtx() {

        return new HelpCtx(PullUpRefactoringUI.class.getName());

    }

}

读取源。 按下 Ctrl 键，将鼠标移动到 RefactoringUI 标识符上，并注意到出现一个超链接：

单击该链接。RefactoringUI 类在 Source Editor 中打开。熟悉一下源文件并理解它如何与其内部 CopyClassRefactoringUI 实现相关。

创建 CopyClassPanel

执行以下操作：

创建文件。 创建 CopyClassPanel JPanel 并将其添加到 org.netbeans.modules.copyclassrefactoring.ui 包中。
设计面板。 向 JPanel 中添加一个 JTextfield、三个 JComboBoxes 和四个 JLabel，如下所示：

添加代码。在 Source 视图中，用以下内容替换默认的代码：

package org.netbeans.modules.refactoring.copyclass.ui;



import java.awt.Component;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import javax.swing.DefaultComboBoxModel;

import javax.swing.DefaultListCellRenderer;

import javax.swing.JList;

import javax.swing.JTextField;

import javax.swing.ListCellRenderer;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import org.netbeans.api.java.project.JavaProjectConstants;

import org.netbeans.api.project.FileOwnerQuery;

import org.netbeans.api.project.Project;

import org.netbeans.api.project.ProjectInformation;

import org.netbeans.api.project.ProjectUtils;

import org.netbeans.api.project.SourceGroup;

import org.netbeans.api.project.Sources;

import org.netbeans.api.project.ui.OpenProjects;

import org.netbeans.modules.refactoring.spi.ui.CustomRefactoringPanel;

import org.netbeans.modules.refactoring.spi.ui.ParametersPanel;

import org.netbeans.spi.java.project.support.ui.PackageView;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;



public class CopyClassPanel extends CustomRefactoringPanel implements ActionListener, DocumentListener {

 

    private static final ListCellRenderer GROUP_CELL_RENDERER = new GroupCellRenderer();

    private static final ListCellRenderer PROJECT_CELL_RENDERER = new ProjectCellRenderer();

   

    private Project project;

    private ParametersPanel parent;

    private FileObject fo;

    private SourceGroup[] groups;

   

    public CopyClassPanel(final ParametersPanel parent, String title, String startPackage, FileObject f) {

        setName(title);

        this.fo = f;

        this.parent = parent;

        initComponents();

        setCombosEnabled(true);

        setThisClassVisible(true);

       

        rootComboBox.setRenderer(GROUP_CELL_RENDERER);

        packageComboBox.setRenderer(PackageView.listRenderer());

        projectsComboBox.setRenderer( PROJECT_CELL_RENDERER );

               

        rootComboBox.addActionListener( this );

        packageComboBox.addActionListener( this );

        projectsComboBox.addActionListener( this );

       

        Object textField = packageComboBox.getEditor().getEditorComponent();

上一篇:NetBeans Editor Extension 模块教程

下一篇:NetBeans Project Template 模块教程

标题:

关于MegaEntry 申明联系我们

沪ICP备06021001号

强烈建议采用IE 6.0或以上的浏览器