JDT核心
文档整理：eclipse插件开发群，群号：153432793，群主整理，转载请注明！
JDT 核心
JDT 核心（org.eclipse.jdt.core）是用于定义 Java 核心元素和 API 的插件。在开发特定于 Java 的功能部件时，总是应该将此插件列示为先决条件。
JDT 核心包使您能够访问 Java 模型对象和无外设 Java IDE 基础结构。JDT 核心包包括：
?org.eclipse.jdt.core－定义用于描述Java 模型的类。
?https://www.doczj.com/doc/d011828506.html,piler－定义编译器基础结构的API。
?org.eclipse.jdt.core.dom－支持可用于检查编译单元的结构直到语句级别的“抽象语法树”（AST）。
?org.eclipse.jdt.core.eval－支持对代码片段编辑测试窗或调试器中的代码段进行评估。
?org.eclipse.jdt.core.jdom－支持Java“文档对象模型”（DOM），它可用于表示Java 编译单元的结构。
?org.eclipse.jdt.core.search－支持在工作空间的Java 模型中搜索与特定描述相匹配的Java 元素。
?org.eclipse.jdt.core.util－提供用于处理.class 文件和Java 模型元素的实用程序类。
从版本 3.0 起，建议不要使用 org.eclipse.jdt.core.jdom。应使用
org.eclipse.jdt.core.dom 来完成对编译单元的结构的处理。
Java 模型
Java 模型是用来对与创建、编辑和构建 Java 程序相关联的对象进行建模的一些类。Java 模型类是在org.eclipse.jdt.core中定义的。这些类实现资源的特定于 Java 的行为，并进一步将 Java 资源分解成模型元素。
Java 元素
包org.eclipse.jdt.core定义了用来对组成 Java 程序的元素建模的一些类。JDT 使用内存中的对象模型来表示 Java 程序的结构。此结构是从项目的类路径派生的。模型是分层的。可以将程序的元素分解成子元素。
处理 Java 元素与处理资源对象相似。当使用 Java 元素时，实际上是在使用某些底层的模型对象的句柄。必须使用exists()协议来确定元素是否真正存在于工作空间中。
下表总结了不同种类的 Java 元素。
所有 Java 元素都支持IJavaElement接口。
某些元素显示在“包”视图中。这些元素实现IOpenable接口，原因是必须在打开它们之后才能浏览它们。下图说明这些元素在“包”视图中是如何表示的。
实现IOpenable的 Java 元素基本上是根据在底层资源文件中找到的信息创建的。相同的元素是在资源导航器视图中按类别表示的。
其他元素对应于组成 Java 编译单元的项。下图显示 Java 编译单元和内容大纲窗口（它显示编译单元中的源元素）。
因为这些元素可以提供相应的源代码，所以它们实现了ISourceReference接口。（当在内容大纲窗口中选择了这些元素时，就会在 Java 编辑器中显示它们相应的源代码）。
Java 元素及其资源
许多 Java 元素对应于工作空间中的通用资源。当您想根据通用资源来创建
Java 元素时，最好是从类JavaCore开始。以下代码段说明如何从 Java 元素的相应资源中获取 Java 元素。
private void createJavaElementsFrom(IProject myProject, IFolder myFolder, IFile myFile) {
IJavaProject myJavaProject = JavaCore.create(myProject);
if (myJavaProject == null)
// the project is not configured for Java (has no Java nature) return;
// get a package fragment or package fragment root
IJavaElement myPackageFragment = JavaCore.create(myFolder);
// get a .java (compilation unit), .class (class file), or
// .jar (package fragment root)
IJavaElement myJavaFile = JavaCore.create(myFile);
}
一旦有了 Java 元素，就可以使用 JDT API 来遍历和查询模型。还可以查询包含在 Java 元素内的非 Java 资源。
private void createJavaElementsFrom(IProject myProject, IFolder myFolder, IFile myFile) {
...
// get the non Java resources contained in my project.
Object[] nonJavaChildren =
myJavaProject.getNonJavaResources();
...
Java 项目
当根据简单项目来创建 Java 项目时，JavaCore将检查项目是否是用 Java 性质来配置的。JDT 插件使用项目性质来将项目指定为具有 Java 行为。当“新建Java 项目”向导创建项目时，将为项目指定此性质
（org.eclipse.jdt.core.JavaCore#NATURE_ID）。如果未对项目配置 Java 性质，则在要求创建项目时，JavaCore将返回 null。
JavaCore还用来维护 Java 类路径，包括用于查找源代码和库的位置以及用于生成输出二进制（.class）文件的位置。
什么是 Java 项目的唯一特征？Java 项目将它们的类路径记录在“.classpath”文件中，并将 Java 增量项目构建器添加到项目的构建规范中。否则，它们只是常规项目，并且可以由插件利用其他性质（和其他增量构建器）来配置。对于那些想要利用除了它们自己的行为之外的 Java 行为来配置项目的插件，它们通常使用NewJavaProjectWizardPage来为项目指定除了它们自己的定制性质或行
为之外的 Java 性质。
IJavaModel可以认为是工作空间中具有 Java 项目性质的所有项目的父代（因此，可以当作IJavaProject）。
处理Java 代码
插件可以使用 JDT API 来创建类或接口、将方法添加到现有类型中或者改变方法的类型。
改变 Java 对象最简单的方法就是使用 Java 元素 API。可以使用更常见的技术来处理 Java 元素的初始源代码。
使用Java 元素来修改代码
生成编译单元
通过程序来生成编译单元最简单的方法是使用
IPackageFragment.createCompilationUnit。指定编译单元的名称和内容。于
是在包中创建了编译单元，并返回新的ICompilationUnit。
通常，可以通过在对应包目录的相应文件夹中创建扩展名为“.java”的文件资源来按类别创建编译单元。使用类属资源 API 对于 Java 工具是一种旁门左道，因此，在通知类属资源更改侦听器以及 JDT 侦听器将 Java 模型更新为新编译单元之前，Java 模型不会更新。
修改编译单元
大部分对 Java 源代码的简单修改可以使用 Java 元素 API 来完成。
例如，可以通过编译单元查询类型。一旦您具有IType，就可以使用诸如createField、createInitializer、createMethod或createType的协议来将源代码成员添加至类型。在这些方法中提供了源代码以及关于成员的位置的信息。
ISourceManipulation接口定义 Java 元素的常见源代码处理。这包括用于重命名、移动、复制或删除类型的成员的方法。
工作副本
可以通过处理编译单元来修改代码（于是修改了底层IFile）或人们可以修改编译单元的内存副本（称为工作副本）。
工作副本是使用getWorkingCopy方法从编译单元中获取的。（注意，要创建工作副本，编译单元不需要存在于 Java 模型中。）当不再需要这种工作副本时，创建这种工作副本的人员应负责使用discardWorkingCopy方法来废弃它。
工作副本修改内存缓冲区。getWorkingCopy()方法创建缺省缓冲区，但是客户机可以使用getWorkingCopy(WorkingCopyOwner, IProblemRequestor, IProgressMonitor)方法提供它们自己的缓冲区实现。客户机可以直接处理此缓冲区的文本。如果客户机直接处理文本，则它们必须经常使用reconcile(int,
boolean, WorkingCopyOwner, IProgressMonitor)方法来使工作副本与缓冲区同步。
最后，可以使用commitWorkingCopy方法将工作副本保存至磁盘（用来替换原始的编译单元）。
例如，下列代码段使用定制工作副本拥有者在编译单元上创建工作副本。该代码段将修改缓冲区、协调更改、将更改落实到磁盘，最后废弃工作副本。
// Get original compilation unit
ICompilationUnit originalUnit = ...;
// Get working copy owner
WorkingCopyOwner owner = ...;
// Create working copy
ICompilationUnit workingCopy = originalUnit.getWorkingCopy(owner, null, null);
// Modify buffer and reconcile
IBuffer buffer = ((IOpenable)workingCopy).getBuffer();
buffer.append("class X {}");
workingCopy.reconcile(NO_AST, false, null, null);
// Commit changes
https://www.doczj.com/doc/d011828506.html,mitWorkingCopy(false, null);
// Destroy working copy
workingCopy.discardWorkingCopy();
工作副本还可以供若干使用工作副本拥有者的客户机共享。稍后可以使用findWorkingCopy方法来检索工作副本。因此，对于原始编译单元和工作副本拥有者，共享工作副本很重要。
下列内容说明了客户机 1 如何创建共享的工作副本、客户机 2 如何检索此工作副本、客户机 1 如何废弃此工作副本以及尝试检索共享的工作副本的客户机 2 如何注意到该工作副本不再存在：
// Client 1 & 2: Get original compilation unit
ICompilationUnit originalUnit = ...;
// Client 1 & 2: Get working copy owner
WorkingCopyOwner owner = ...;
// Client 1: Create shared working copy
ICompilationUnit workingCopyForClient1 =
originalUnit.getWorkingCopy(owner, null, null);
// Client 2: Retrieve shared working copy
ICompilationUnit workingCopyForClient2 =
originalUnit.findWorkingCopy(owner);
// This is the same working copy
assert workingCopyForClient1 == workingCopyForClient2;
// Client 1: Discard shared working copy
workingCopyForClient1.discardWorkingCopy();
// Client 2: Attempt to retrieve shared working copy and find out it's null
workingCopyForClient2 = originalUnit.findWorkingCopy(owner);
assert workingCopyForClient2 == null;
使用DOM/AST API 来修改代码
有三种方法来创建CompilationUnit。第一种方法是使用ASTParser。第二种方法是使用ICompilationUnit#reconcile(...)。第三种方法是从头开始对AST（抽象语法树）使用工厂方法。
从现有的源代码创建AST
必须使用ASTParser.newParser(int)来创建ASTParser的实例。
将使用下列其中一个方法将源代码提供给ASTParser：
?setSource(char[])：从源代码创建AST
?setSource(IClassFile)：从类文件创建AST
?setSource(ICompilationUnit)：从编译单元创建AST
然后通过调用createAST(IProgressMonitor)来创建AST。
结果是每个节点都有一个具有正确源位置的AST。在使用setResolveBindings(boolean)创建树之前，必须请求绑定的解决方案。解决绑定是一个成本很高的操作，仅当需要时才执行。一旦修改了树，就会丢失所有位置和绑定。
通过协调工作副本来创建AST
如果工作副本不一致（已修改），则可以通过调用方法reconcile(int, boolean,
org.eclipse.jdt.core.WorkingCopyOwner, org.eclipse.core.runtime.IProgressMonitor)来创建AST。要请求AST 创建，使用AST.JLS2作为第一个参数来调用reconcile(...)方法。
仅当问题请求程序是活动或者当强制执行问题检测时，才会计算其绑定。解决绑定是一个成本很高的操作，仅当需要时才执行。一旦修改了树，就会丢失所有位置和绑定。
从头开始
可以通过对AST使用工厂方法来从头创建CompilationUnit。这些方法名以new...开头。以下是创建HelloWorld类的一个示例。
第一个代码段是生成的输出：
package example;
import java.util.*;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello" + " world");
}
}
下列代码段是生成输出的相应代码。
AST ast = new AST();
CompilationUnit unit = ast.newCompilationUnit();
PackageDeclaration packageDeclaration =
ast.newPackageDeclaration();
packageDeclaration.setName(ast.newSimpleName("example"));
unit.setPackage(packageDeclaration);
ImportDeclaration importDeclaration =
ast.newImportDeclaration();
QualifiedName name =
ast.newQualifiedName(
ast.newSimpleName("java"),
ast.newSimpleName("util"));
importDeclaration.setName(name);
importDeclaration.setOnDemand(true);
unit.imports().add(importDeclaration);
TypeDeclaration type = ast.newTypeDeclaration();
type.setInterface(false);
type.setModifiers(Modifier.PUBLIC);
type.setName(ast.newSimpleName("HelloWorld"));
MethodDeclaration methodDeclaration =
ast.newMethodDeclaration();
methodDeclaration.setConstructor(false);
methodDeclaration.setModifiers(Modifier.PUBLIC | Modifier.STATIC);
methodDeclaration.setName(ast.newSimpleName("main"));
methodDeclaration.setReturnType(ast.newPrimitiveType(Primitiv eType.VOID));
SingleVariableDeclaration variableDeclaration =
ast.newSingleVariableDeclaration();
variableDeclaration.setModifiers(Modifier.NONE);
variableDeclaration.setType(ast.newArrayType(ast.newSimpleTyp e(ast.newSimpleName("String"))));
variableDeclaration.setName(ast.newSimpleName("args"));
methodDeclaration.parameters().add(variableDeclaration);
org.eclipse.jdt.core.dom.Block block = ast.newBlock();
MethodInvocation methodInvocation =
ast.newMethodInvocation();
name =
ast.newQualifiedName(
ast.newSimpleName("System"),
ast.newSimpleName("out"));
methodInvocation.setExpression(name);
methodInvocation.setName(ast.newSimpleName("println"));
InfixExpression infixExpression =
ast.newInfixExpression();
infixExpression.setOperator(InfixExpression.Operator.PLUS);
StringLiteral literal = ast.newStringLiteral();
literal.setLiteralValue("Hello");
infixExpression.setLeftOperand(literal);
literal = ast.newStringLiteral();
literal.setLiteralValue(" world");
infixExpression.setRightOperand(literal);
methodInvocation.arguments().add(infixExpression);
ExpressionStatement expressionStatement =
ast.newExpressionStatement(methodInvocation);
block.statements().add(expressionStatement);
methodDeclaration.setBody(block);
type.bodyDeclarations().add(methodDeclaration);
unit.types().add(type);
检索额外的位置
DOM/AST 节点只包含一对位置（起始位置和节点的长度）。这并不总是够用。要检索中间位置，应使用IScanner API。例如，我们具有想要对其了解instanceof运算符的位置的InstanceofExpression。可以编写以下方法来实现此目的：
private int[] getOperatorPosition(Expression expression, char[] source) {
if (expression instanceof InstanceofExpression) {
IScanner scanner =
ToolFactory.createScanner(false, false, false, false);
scanner.setSource(source);
int start = expression.getStartPosition();
int end = start + expression.getLength();
scanner.resetTo(start, end);
int token;
try {
while ((token =
scanner.getNextToken()) != ITerminalSymbols.TokenNameEOF) {
switch(token) {
case ITerminalSymbols.TokenNameinstanceof:
return new int[] {scanner.getCurrentTokenStartPosition(),
scanner.getCurrentTokenEndPosition()};
}
}
} catch (InvalidInputException e) {
}
}
return null;
}
IScanner用来将输入源代码分成多个标记。每个标记都具有特定值，这些特定值是在ITerminalSymbols接口中定义的。迭代和检索正确的标记是非常简单的。如果想要在SuperMethodInvocation中查找super关键字的位置，则还建议您使用扫描程序。
源代码修改
某些源代码修改不是通过 Java 元素 API 来提供的。编辑源代码（例如，更改现有元素的源代码）的较常见方法是使用编译单元的初始源代码和 DOM/AST 的重写 API 来完成的。
要执行 DOM/AST 重写，存在两组 API：描述性重写和修改重写。
描述性 API 不修改 AST，而是使用ASTRewrite API 来生成修改描述。AST 重写程序收集对节点修改的描述并将这些描述转换为可以适用于初始源代码的文
本编辑。
// creation of a Document
ICompilationUnit cu = ... ; // content is "public class X {\n}"
String source = cu.getBuffer().getContents();
Document document= new Document(source);
// creation of DOM/AST from a ICompilationUnit
ASTParser parser = ASTParser.newParser(AST.JLS2);
parser.setSource(cu);
CompilationUnit astRoot = (CompilationUnit) parser.createAST(null);
// creation of ASTRewrite
ASTRewrite rewrite = new ASTRewrite(astRoot.getAST());
// description of the change
SimpleName oldName =
((TypeDeclaration)astRoot.types().get(0)).getName();
SimpleName newName = astRoot.getAST().newSimpleName("Y");
rewrite.replace(oldName, newName, null);
// computation of the text edits
TextEdit edits = rewrite.rewriteAST(document,
cu.getJavaProject().getOptions(true));
// computation of the new source code
edits.apply(document);
String newSource = document.get();
// update of the compilation unit
cu.getBuffer().setContents(newSource);
修改 API 允许直接修改 AST：
?请求记录修改（CompilationUnit.recordModifications()）。
?对AST 节点执行修改。
?当完成修改时，生成可以适用于初始源代码的文本编辑（CompilationUnit.rewrite(...)）。
// creation of a Document
ICompilationUnit cu = ... ; // content is "public class X {\n}"
String source = cu.getBuffer().getContents();
Document document= new Document(source);
// creation of DOM/AST from a ICompilationUnit
ASTParser parser = ASTParser.newParser(AST.JLS2);
parser.setSource(cu);
CompilationUnit astRoot = (CompilationUnit) parser.createAST(null);
// start record of the modifications
astRoot.recordModifications();
// modify the AST
TypeDeclaration typeDeclaration =
(TypeDeclaration)astRoot.types().get(0)
SimpleName newName = astRoot.getAST().newSimpleName("Y");
typeDeclaration.setName(newName);
// computation of the text edits
TextEdit edits = astRoot.rewrite(document,
cu.getJavaProject().getOptions(true));
// computation of the new source code
edits.apply(document);
String newSource = document.get();
// update of the compilation unit
cu.getBuffer().setContents(newSource);
对Java 元素的更改作出响应
如果事后插件需要知道对 Java 元素所作的更改，则可以向JavaCore注册Java IElementChangedListener。
JavaCore.addElementChangedListener(new MyJavaElementChangeReporter());
还可以更具体，并使用
addElementChangedListener(IElementChangedListener, int)来指定您感兴趣的事件的类型。
例如，如果您只想在协调操作期间侦听事件：
JavaCore.addElementChangedListener(new MyJavaElementChangeReporter(), ElementChangedEvent.POST_RECONCILE);
JavaCore支持二种类型的事件：
?POST_CHANGE：在相应的POST_CHANGE资源更改通知期间，将通知此事件类型的侦听器。
?POST_RECONCILE：在结束对工作副本的协调操作时，将通知此事件类型的侦听器（请参阅ICompilationUnit.reconcile(int, boolean, WorkingCopyOwner,
IProgressMonitor)）。
Java 元素更改侦听器在概念上类似于资源更改侦听器（在跟踪资源更改中进行了描述）。下列代码段实现 Java 元素更改指示器，它将元素变化打印到系统控制台中。
public class MyJavaElementChangeReporter implements IElementChangedListener { public void
elementChanged(ElementChangedEvent event) {
IJavaElementDelta delta= event.getDelta();
if (delta != null) {
System.out.println("delta received: ");
System.out.print(delta);
}
}
}
IJavaElementDelta包括已更改的元素和描述所发生的更改类型的标志。在大多数时候，delta 树的根位于“Java 模型”级别。然后，客户机必须使用getAffectedChildren来浏览此 delta 以了解已经更改了哪些项目。
以下示例方法遍历 delta，并打印已添加、已除去和已更改的元素：
void traverseAndPrint(IJavaElementDelta delta) {
switch (delta.getKind()) {
case IJavaElementDelta.ADDED:
System.out.println(delta.getElement() + " was added"); break;
case IJavaElementDelta.REMOVED:
System.out.println(delta.getElement() + " was removed");
break;
case IJavaElementDelta.CHANGED:
System.out.println(delta.getElement() + " was changed");
if ((delta.getFlags() &
IJavaElementDelta.F_CHILDREN) != 0) {
System.out.println("The change was in its children");
}
if ((delta.getFlags() & IJavaElementDelta.F_CONTENT) != 0) {
System.out.println("The change was in its content");
}
/* Others flags can also be checked */
break;
}
IJavaElementDelta[] children = delta.getAffectedChildren(); for (int i = 0; i < children.length; i++) {
traverseAndPrint(children[i]);
}
}
有多种操作可以触发 Java 元素更改通知。以下是一些示例：
?创建资源，例如IPackageFragment.createCompilationUnit（delta 指示编译单元的添加）
?修改资源，例如ICompilationUnit.createType（delta 指示编译单元已更改，并且已添加类型来作为此编译单元的子代）
?修改项目的类路径，例如IJavaProject.setRawClasspath（delta 指示包段根目录已添加至类路径、已从类路径中除去或在类路径上已重新排序）
?修改类路径变量值，例如JavaCore.setClasspathVariable（delta 还指示包段根目录已经受到影响）
?更改.jar 文件的源代码连接，例如IPackageFragmentRoot.attachSource（delta 指示源已拆离，然后连接）
?使工作副本与它的缓冲区协调，例如IWorkingCopy.reconcile
?修改以“.java”结尾并且在项目的类路径上的IFile，例如，使用IFile.setContents（delta 指示编译单元已更改，但是未提供更详细的信息，原因是这不是通过“Java 模型”操
作来完成的）
与IResourceDelta相似，可以使用IWorkspaceRunnable来对 Java 元素delta 进行批处理。立即就会合并和报告在IWorkspaceRunnable中运行的若干“Java 模型”操作产生的 delta。
JavaCore提供了run方法来对 Java 元素更改进行批处理。
例如，以下代码段将触发两个 Java 元素更改事件：
// Get package
IPackageFragment pkg = ...;
// Create 2 compilation units
ICompilationUnit unitA =
pkg.createCompilationUnit("A.java", "public class A {}", false, null);
ICompilationUnit unitB =
pkg.createCompilationUnit("B.java", "public class B {}", false, null);
而以下代码段将触发 1 个 Java 元素更改事件：
// Get package
IPackageFragment pkg = ...;
// Create 2 compilation units
JavaCore.run(
new IWorkspaceRunnable() {
public void run(IProgressMonitor monitor) throws CoreException {
ICompilationUnit unitA =
pkg.createCompilationUnit("A.java", "public class A {}", false, null);
ICompilationUnit unitB =
pkg.createCompilationUnit("B.java", "public class B {}", false, null);
}
},
null);
设置Java 构建路径
本节描述如何设置 Java 构建路径。构建路径是用于构建 Java 项目（IJavaProject）的类路径。
类路径只是一组用于描述可用类型的类路径条目（IClassPathEntry）。类型能够以源或二进制格式出现，并且条目在路径中的顺序定义了用于在构建期间解析类型的查找顺序。
Java 构建路径反映在 Java 项目元素的结构中。可以查询项目的包段根目录（IPackageFragmentRoot）。每个类路径条目都映射至一个或多个包段根目录，每个包段根目录进一步包含一组包段。
此处对构建路径的讨论不涉及 Java 运行时路径，Java 运行时路径可以独立于构建路径进行定义。（有关运行时类路径的讨论，请参阅运行 Java 代码。）
更改构建路径
可以通过对相应项目的 Java 元素使用setRawClasspath来使用程序更改项目的构建路径。以下代码设置项目资源的类路径：
IProject project = ... // get some project resource
IJavaProject javaProject = JavaCore.create(project);
IClasspathEntry[] newClasspath = ...;
javaProject.setRawClasspath(newClasspath, someProgressMonitor);
（注意：术语“原始”类路径用来强调尚未解析任何用来描述条目位置的变量的事实。）
Java 构建路径保存在项目的文件结构中的名为“.classpath”的文件中。此文件可用来提供一种方法来通过某些源代码资源库与其他项目共享 Java 构建路径设置。需要特别指出的是，由于可能会毁坏此文件，所以不应该手工编辑它。
类路径条目
可以使用对JavaCore定义的工厂方法来定义类路径条目。类路径条目可以引用下列任何一项：
?源代码文件夹－一个包含源代码编译单元的文件夹，这些源代码编译单元组织在它们的相应包目录结构下面。源代码文件夹用来更好地在大型项目中组织源文件，
并且只能在包含项目内引用源代码文件夹。相应的工厂方法为newSourceEntry。在给定的源代码文件夹中，期望根据每个编译单元的包语句来将每个编译单元嵌套在
适当的文件夹结构中。例如，包“p1”中的编译单元“X.java”必须位于源代码文件夹的子文件夹“p1”中。只要多个源代码文件夹不重叠，就可以使用它们。可以对源代码
文件夹指定它自己的输出位置，该输出位置确定应在何处放置生成的类文件。如果
未指定任何输出位置，则将把类文件放置在包含项目的输出位置中（请参阅
IJavaProject.setOutputLocation）。
以下是指示项目“MyProject”的源代码文件夹“src”的类路径条目的
示例：
IClassPathEntry srcEntry = JavaCore.newSourceEntry(new
Path("/MyProject/src"));
?二进制库－类文件文件夹（包含在工作空间内部）或类文件归档文件（包含在工作空间内部或外部）。归档库可以具有相连接的源代码归档，当请求类文件元素的源（getSource）时，就会抽取这些源代码归档。这些库的工厂方法是newLibraryEntry。
以下是指示“MyProject”的类文件文件夹“lib”的类路径条目的示例：
IClassPathEntry libEntry = JavaCore.newLibraryEntry(
new Path("/MyProject/lib"),
null, // no source
null, // no source
false); // not exported
以下类路径条目具有源代码连接：
IClassPathEntry libEntry = JavaCore.newLibraryEntry(
new Path("d:/lib/foo.jar"), // library location
new Path("d:/lib/foo_src.zip"), // source archive location new Path("src"), // source archive root path
true); // exported
源代码归档根路径描述根在源代码归档中的位置。如果设置为空，则将动态地推断归档的根。
?先决条件项目－另一个Java 项目。先决条件项目总是将它的源代码文件夹提供给从属项目使用。（可选）它还可以提供它的任何标记为已导出的类路径条目（请参阅支持附加布尔参数“isExported”的工厂方法）。这意味着除了将它的源添加至其从属项之外，项目还将导出这样标记的所有类路径条目。这将允许先决条件项目更好地隐藏它们自己的结构更改。例如，给定的项目可以选择从使用源代码文件夹切换到导出库。完成此操作并不要求其从属项目更改它们的类路径。项目先决条件的工厂方法是newProjectEntry。
以下类路径条目指示先决条件项目“MyFramework”。
IClassPathEntry prjEntry = JavaCore.newProjectEntry(new
Path("/MyFramework"), true); // exported
?通过使用一些类路径变量实现对项目或库的间接引用－可以相对于类路径变量来动态解析项目或库的位置，类路径变量是作为条目路径的第一个段指定的。条目路径的其余部分被追加至已解析的变量路径。类路径变量的工厂方法是
newVariableEntry。类路径变量对于整个工作空间来说是全局的，并且可以通过JavaCore 方法getClasspathVariable和setClasspathVariable来处理。
可能会注册自动的类路径变量初始化方法，当启动工作空间时，通过扩展点org.eclipse.jdt.core.classpathVariableInitializer来调用该类路径变量初始化方法。
以下类路径条目指示一个库，该库的位置存放在变量“HOME”中。使用变量“SRC_HOME”和“SRC_ROOT”来定义源代码连接：
IClassPathEntry varEntry = JavaCore.newVariableEntry(
new Path("HOME/foo.jar"), // library location
new Path("SRC_HOME/foo_src.zip"), // source archive location new Path("SRC_ROOT"), // source archive root path
true); // exported
JavaCore.setClasspathVariable("HOME", new Path("d:/myInstall"), null); // no progress monitor
指示类路径容器的条目－对一组结构化项目或库的间接引用。类路径容器用来引用一组描述复杂库结构的类路径条目。与类路径变量相似，类路径容器
（IClasspathContainer）是动态解析的。类路径容器可以由不同的项目使用，从而导致它们的路径条目对每个项目解析为不同的值。它们还提供关于它们表示的库的元信息（库的名称、种类和描述）。类路径变量的工厂方法是newContainerEntry。可以通过JavaCore 方法getClasspathContainer和setClasspathContainer来处理类路径容器。
可能会注册一个自动的类路径容器初始化方法，当需要绑定容器时，通过扩展点org.eclipse.jdt.core.classpathContainerInitializer来被动地调用类路径容器初始化方法。
以下类路径条目指示系统类库容器：
IClassPathEntry varEntry = JavaCore.newContainerEntry(
new Path("JDKLIB/default"), // container 'JDKLIB' + hint
'default'
false); // not exported
JavaCore.setClasspathContainer(
new Path("JDKLIB/default"),
new IJavaProject[]{ myProject }, // value for 'myProject' new IClasspathContainer[] {
new IClasspathContainer() {
public IClasspathEntry[] getClasspathEntries() {
return new IClasspathEntry[]{
JavaCore.newLibraryEntry(new Path("d:/rt.jar"), null, null, false);
};
}
public String getDescription() { return "Basic JDK library container"; }
public int getKind() { return
IClasspathContainer.K_SYSTEM; }
public IPath getPath() { return new
Path("JDKLIB/basic"); }
}
},
null);
排除模式
可以对类路径源条目指定排除模式，排除模式防止源代码文件夹中的特定资源在类路径中可见。对模式的使用允许过滤掉资源树的指定部分。每个排除模式路径都是相对于类路径条目的，并且使用与 Ant 相似的模式机制。只要外部模式排除内部模式，排除模式就可以用来指定嵌套的源代码文件夹。
有关排除模式的更多详细信息，请参阅getExclusionPatterns。
Java 项目 API isOnClasspath在确定特定资源是否在类路径中之前将同时检查包括模式和排除模式。
注释：
?排除模式比包括模式具有更高的优先顺序；换句话说，排除模式可以除去包括模式要包括的文件，反之则不行。
?从构建路径排除的嵌套源代码文件夹可以设置为输出位置。以下是指示项目“MyProject”的源代码文件夹“src”的类路径条目的示例，排除的嵌套源代码文件夹用作输出位置：
? IPath sourceFolder = new Path("/MyProject/src");
? IPath outputLocation = sourceFolder.append("bin");
? IClassPathEntry srcEntry = JavaCore.newSourceEntry(
? sourceFolder, // source folder location
? new Path[] { outputLocation }, // excluded nested folder ? outputLocation); // output location
包括模式
也可以对类路径源条目指定包含模式，这显式地将资源定义为在类路径中是可视的。当未指定包含模式时，则源条目包括以此源条目的路径为根的资源树中的所有相关文件。指定一个或多个包括模式意味着只能包含资源树的指定部分。每个指定的路径都必须是相对路径，并且将解释为相对于此源条目的路径。文件模式是区分大小写的。通过这些模式中的一个或多个模式匹配的文件将包括在相应的包段中根目录中，除非它被此条目的一个或多个排除模式排除。
有关路径模式的语法和语义的讨论，请参阅getExclusionPatterns。缺少任何包括模式在语义上等同于显式包括模式 **。
Eclipse插件开发文档记录 一、参考网站 二、插件开发之基础篇(1) 名词翻译 有一些名词在翻译的过程中可能会出现歧义，在这里统一一下。 アーキテクチャ=architecture=架构 プラットフォーム=platform=平台 コンポーネント=component=组件 其余的随时补充。 的架构 Eclipse被作为java的IDE（集成开发环境）被广泛的应用，但是从本质上看Eclipse是一个整合了各种开发工具的平台。因此，它采用了可以自由的增加各种功能的插件架构技术。Eclipse平台的基本架构如图1-1所示。 图1-1 Eclipse的架构 在这里，在最底层位置的是作为Eclipse插件架构基干的OSGi运行时。虽然在早期的Eclipse版本中已经开始使用插件架构了，但是在的时候才首次引入了OSGi。OSGi是open services gateway initiative的简称、原本是一种为嵌入式硬件开发的,使网络上的服务提供者和使用者交互(結びつける)的注册服务。Eclipse使用OSGi来进行插件的管理。 OSGi运行时之上所有被配置的组件群都是以插件的方式提供的。SWT和JFa ce提供了用户接口(User Interface)的API。由于SWT和JFace并不依赖于Ecl ipse，也有可能被作为类库单独使用。Eclipse不仅把基本的用户接口作为工作台API(WorkBench API)提供出来，在后面要讲到的工作区(Workspace)内的资源通过资源API(Resource API)的形式也被作为基本API提供出来了。在这之上构建起了帮助系统以及基于更新管理器的自动更新等功能。
本篇文章主要介绍了"Eclipse插件开发之Wizard的学习与创建"，主要涉及到Eclipse插件开发之Wizard的学习与创建方面的内容，对于Eclipse插件开发之Wizard的学习与创建感兴趣的同学可以参考一下。 Wizards的学习与创建 第一章wizard了解 一个Wizard主要由Wizard Dialog、Wizard、Wizard Page三部分组成，如图。 其中Wizard Dialog定义了Wizard中的按钮并管理所提供的向导项页面；Wizard用于控制向导中的外观和行为；Wizard Page定义了向导项页面显示内容的控制机制。 Eclipse提供的三个扩展点： 新建向导org.eclipse.ui.newWizard 导入向导org.eclipse.ui.importWizard 导出向导org.eclipse.ui.exportWizard 第二章wizard的创建实例 下面将以org.eclipse.ui.newWizardsd的使用为例，创建wizard。 通过FileàNewàProjectàPlug-in DevelopmentàPlug-in Projectà输入项目名—>模板选择Coustom plug-in wizard—>可选模板都不用àfinish。 创建plugin.xml和如图所示的类。 主要包括向导类（MyNewWizard）和向导页面（可多个，实例中FirstWizardPage和SecondWizardPage）。 向导类继承Wizard类并实现INewWizard接口。 想到页面类主要是继承WizardPage类。 这两个类的常用方法见附录 plugin.xml 内容如下所示 id要求唯一，category的显示参考下图。
第一种方法很简单，在Eclipse的主目录（%ECLIPSE_HOME%）下有一个plugins目录和features目录。将插件解压缩后，在解压缩后的文件夹里一般可以看到plugins文件夹，有的插件解压缩后还可以看到一个features文件夹。一般将plugins文件夹下的内容直接拷贝到%ECLIPSE_HOME%\plugins目录下，如果解压缩后的插件目录下还有features文件夹，则把该文件夹下的内容也拷贝到%ECLIPSE_HOME%\features下。重新启动Eclipse之后就可以使用刚刚安装的插件了。如果不能使用插件，可能是因为插件还未启用。可以到Help/Software Updates/Manage Configuration下将“Disable”的插件“Enable”即可。这种插件安装方式简单、快捷，但是有缺陷，若插件太多，会使内容非常混乱，而且分不清哪个是系统自带的，哪个是以后安装的。当安装了许多插件之后，Eclipse变的很大，不便于更新和管理众多插件。每次重新安装Eclipse，就要花时间来安装那几个常用的插件。 第二种方法也很简单，它主要借助于Eclipse的向导来安装插件。通过Help/Software Updates/Find and Install，在弹出的菜单中选择“Search for new features to install”，点“Next”，在下一菜单中选择“New Local Site”或“New Archived Site”，找到你下载的插件所在目录，选中安装即可。这种方法安装插件比较安全，不易出错，缺点就是对于插件的要求也比较挑剔，所以能够支持这种方式安装的插件也比较少。一般要求插件目录下不光有plugins和features文件夹，还要有site.xml文件（site.xml是进行自动安装的配置文件，eclipse会根据文件的信息自动安装插件）。支持J2ME开发的EclipseME插件就是通过这种方式安装的。 第三种方式就是在Eclipse主目录下创建一个links目录，然后将你自己的插件放在你想放的任何地方，这个时候你放插件的目录就是插件目录（%PLUGIN_HOME%），然后在你的%ECLIPSE_HOME%\links\目录下创建一个link文件，比如要安装一个vss插件，可以在links目录下创建一个vss.eclipse.link文件，link文件的名称随便取。这个vss.eclipse.link 文件指向的存放vss插件的目录（%PLUGIN_HOME%）。假如你的vss插件的zip/rar文件解压缩后放在C:\eclipse_plugins\vss.eclipse下（如果是插件是jar文件则可以不用解压缩），则vss.eclipse.link文件的内容就应该是：path=C:\\eclipse_plugins\\vss.eclipse。注意：path所指的文件路径一定要增加一个“\”转义符来分开。以这种方式安装插件要有一定的讲究。即：插件目录下面一定要有eclipse目录，然后在eclipse目录下分别建立features 和plugins。例如：如vss.eclipse.zip解压成vss.eclipse目录，这个目录包含一个plugins 子目录。先在vss.eclipse目录中新建一个子目录eclipse，然后把plugins目录移动到刚建立的eclipse 目录中，然后再在刚刚建立的eclipse目录下建立一个features目录。即目录结构要是这样的：C:\eclipse_plugins\vss.eclipse\eclipse\plugins、 C:\eclipse_plugins\vss.eclipse\eclipse\features。其它压缩文件解压后若已经包含 eclipse\plugins、eclipse\features目录，则不需要建立eclipse目录结构。启动Eclipse后，Eclipse会到link文件指定的目录下去查找eclipse\features 目录和eclipse\plugins 目录，看是否有合法的功能部件和插件。也就是说，目标目录必须包含一个\eclipse 目录。如果找到，附加的功能部件和插件在运行期配置是将是可用的，如果链接文件是在工作区创建之后添加的，附加的功能部件和插件会作为新的配置变更来处理。对于第三种方式的说明： 1. 插件可以分别安装在多个自定义的目录中； 2. 一个自定义目录可以安装多个插件； 3. link文件的文件名及扩展名可以取任意名称，比如ddd.txt，myplugin都可以； 4. link文件中path=插件目录的path路径分隔要用“\\”或是“/”； 5. 在links目录也可以有多个link文件，每个link文件中的path参数都将生效； 6. 插件目录可以使用相对路径；
RCP中文入门教程 赵阳 2005.12.26 简单地讲, 一个RCP应用就是一个可独立于Eclispe IDE开发环境运行的Eclipse 插件. 下面我们以一个简单的例子开始我们的RCP旅程. 一、新建插件工程 因为RCP应用本身就是一个Eclispe插件, 所以从新建一个Eclispe插件工程开始. 1)启动Eclispe, 从Eclispe的 File菜单创建一个插件工程: File à New à Project à Plug-in Development à Plug-in Project 点击Next, 进入New Plug-in Project插件向导: 在Project Name中输入工程名称:simplebrowser (最好小写) 勾选”Create an OSGi bundle mainfest”使用OSGi打包清单. OSGi是Eclipse 3.0 以上版本用于动态装载插件的标准, 在Eclipse 2.1中是不需要的. 最好选中它. 点击Next按钮.
修改Plug-in ID 及其他插件属性值. 这里采用默认值, 在”Rich Client Application”一栏中, “Would you like to create a rich client application ?”一项选择”Yes”设置创建的插件为RCP应用. 点击Next. 在模板中选择最基本的Hello Rcp模板, 点击“Finish”按钮, Eclispe将会创建一个简单的RCP应用并且自动打开插件清单编辑器的主页面. 在这里你可以方便的配置你的RCP应用, 免去手工编写和修改配置文件的麻烦.
引言 Eclipse 具有丰富的菜单功能，给开发人员提供了很好的用户体验。总体而言，Eclipse 菜单种类包括视图/ 编辑器菜单，主菜单（Main Menu），视图/ 编辑器菜单（ViewPart/EditorPart Menu）和上下文菜单（Context Menu）。插件开发人员通过灵活应用这些菜单，可以给用户提供很好的体验。由于视图和编辑器菜单功能类似，因此本文重点讲述视图菜单（视图下拉菜单及其工具栏菜单），除此之外，还将讲述主菜单和上下文菜单。 如图1 所示为Project Explorer 视图的菜单，包括视图下拉菜单和工具栏菜单（折叠树节点）。通常而言，出现在视图工具栏的菜单都会出现在视图的下拉菜单，也就是说，比较常用的视图菜单放在视图的工具栏。 图 1. Project Explorer 视图的菜单 如图2 所示为Project Explorer 视图中的上下文菜单，只有当我们右键点击时才会出现。通常而言，出现频率较高的菜单项才会出现在菜单中。上下文菜单具有很强的灵活项，它可以随着我们点击的对象不同，弹出的菜单也会有相应的变化。 图 2. Project Explorer 视图中的上下文菜单
如图3 所示为Eclipse 的主菜单，包括最上面的主菜单项（不可移动）及其下面的工具栏菜单（可以移动，并且Eclipse 提供了显示/ 不显示这些菜单的功能），Eclipse 并不建议我们为每一个插件都添加新的主菜单，这样容易造成冗余，而且不方便用户操作。通常，我们可以把菜单项添加到Eclipse 已有的菜单，如插件的查找功能可以添加一个查找菜单项到Eclipse 的Search 主菜单上。 图 3. Eclipse 的主菜单 前面讲到Eclipse 的各种菜单，那么，如何在开发插件或RCP 应用程序的时 候添加这些菜单？本文下面的篇幅将详细介绍如何扩展Eclipse 的菜单功能， 使读者深入了解Eclipse 的菜单功能，并能够开发具有这些菜单的应用程序。 因此，必须掌握三方面的内容：菜单种类，菜单的扩展点，菜单控制（显示/ 隐藏或启用/ 禁用菜单项）。下面从概念上介绍这三方面内容，下一小节将会进 行详细介绍。 菜单种类 正如前面所讲到的，Eclipse 的菜单包括视图菜单，主菜单及上下文菜单三个种类。 菜单项的扩展点 Eclipse 提供了两种扩展点供用户添加菜单项到相应的位置。这两种扩展点为https://www.doczj.com/doc/d011828506.html,mands（本文简称为Commands 方式）和 org.eclipse.ui.actionSets（本文简称为Actions 方式）。Actions 方式为界面上不同区域的表现方式提供了相应的扩展点，并且没有分离其界面表现和内在实现。恰恰相反，Commands 方式通过三步有效的达到界面表现和内部实现的分离：
有关Eclipse开发中的一些知识 1. Eclipse的整个窗口称为workbench window 2. 右上角切换perspective的工具栏成为shortcut bar 3. workbench window可同时打开多个。通过配置也可让每一个新打开的perspective显示在新window中 4. 在一个window中，每个perspective可以用不同组的view，但所有的view 共享同一组editor 5. view重用于在信息的列表或层次结构中导航，如resources；或显示当前active 的editor的属性 6. 对view的修改马上会马上保存 7. editor常用于编辑和浏览资源。可用文本表示，也可用图像表示 8. editor的修改遵循open-save-close生命周期模型 9. part用于统称view和editor 10. 同一时间内，只能有一个active的part 11. active的part是常用操作，如copy、past、cut的目标 12. active的part也决定状态栏的内容 13. 某一个editor不再active时，view仍可能显示该不再active的eidtor的相关信息。比如Hierarchy View。 14. editor中，显示文件名的区域称为tab，asterisk表示未save，setDirty()。 15. active part由editor变为view时，menu bar和tool bar的一些operation 可能会被disable掉。
16. editor可stack放置，也可side-by-side放置 17. 当某一resource没有相关联的editor时，将试图启用外部工具 18. 可用ctrl+F6来打开已启动的editor的列表 19. view含有两个菜单，一个用于控制其位置，一个称为”view pull-down menu”，常含有排序、过滤等功能 20. 文件导出的方式有：DND、Export、COPY/PAST 21. 文件导入的方式有：DND、Import、COPY/PAST。(DND和COPY是否支持依赖于操作系统) 22. 删除project时，可以仅从workspace中删除而仍保留在操作系统中，也可OS中也删除。File和Folder不支持此功能 23. search中的show previous search可显示以前的搜索结果。其中的pin，可在再次搜索时另启动一个新的search view 24. marker包括bookmark、task marker、debugging breakpoint、problem 25. task可以关联到文件、关联到文件中的某一行、也可以没有任何关联。在task view中可以对已完成的task打勾 26. dock cursor的种类 27. 可自定义perspective的action set 28. 开启一新的perspective后，window的标题栏会改变 29. 可自定义perspective的command，以改变menu bar和tool bar中可显示的内容 30. 可自己定义File->new菜单中显示那些内容、也可自定义window->open perspective中显示那些试图供选择
Java 开发的10 大必备Eclipse 插件 毫无疑问，Eclipse 是Java 开发最流行的IDE 之一，而这一切主要归功于Eclipse 的插件。 据悉，Eclipse 有数百个插件，可用于不同类型的任务，并与其他工具集成，比如从GitHub、SVN、CVS 等下载代码的插件。通过使用正确的插件，开发者可以提高开发效率。 例如，一旦安装了EGit 插件，开发者就能从Eclipse 直接管理Git 存储库，无需任何其他Git 客户端。同样，添加Spring Tools 插件可以帮你轻松创建基于Spring 和Spring-Boot 的应用程序。 许多Java 开发人员并没有真正充分地使用Eclipse。一位Java 开发人员告诉我，由于插件数量过多，找到合适的插件成为一项挑战性的工作，但是Eclipse 市场已经解决这个问题。如果你想要学好web前端最好加入一个好的学习环境，可以来这个Q群，首先是132，中间是667，最后是127，这样大家学习的话就比较方便，还能够共同交流和分享资料.通过查看下载计数来核实流行度，你就能轻松地搜索Eclipse 插件，最重要的是，你能在Eclipse IDE 中完成这项工作。 不浪费时间，这里有10 款必不可少的Java 开发插件。
1.EGit 对现在的Java 开发人员来说，这可能是最重要的Eclipse 插件。它可以让你从GitHub 下载代码，并为Eclipse 提供Git 集成。
EGit 还能让你快速而灵活地搜索和查询历史记录。如果你不熟悉Git，我建议你首先看下Git MasterClass ，它提供了一个完整的分步指南，帮你掌握所有重要的Git 概念和命令。 简而言之，它是Java 开发的必备插件。 2.Spring Tools 无疑，Spring 是最流行的Java 框架，这个插件使得在Eclipse 中创建Spring 和Spring Boot 项目变得非常容易。通过STS 插件，你可以使用简单易用的start.spring.io 集成快速创建Spring Boot 项目。
Eclipse插件开发指南 EclipseEclipse 插件开发指南插件开发指南 EclipseEclipse 插件开发指南插件开发指南 目目录录 目目录录 第第 1 章章 Eclipse 概述概述 第第章章概述概述 1.1 Eclipse 简介简介 简介简介
Eclipse 的历史的历史 的历史的历史 Eclipse 的优势与技术特征的优势与技术特征 的优势与技术特征的优势与技术特征1.2 安装安装 Eclipse 安装安装 安装的软硬件环境要求安装的软硬件环境要求 安装的软硬件环境要求安装的软硬件环境要求安装安装 Eclipse 3.0 安装安装 1.3 Eclipse 插件的安装方法插件的安装方法
插件的安装方法插件的安装方法 第三方插件第三方插件 SWT Deginer 的下载与安装的下载与安装 第三方插件第三方插件的下载与安装的下载与安装 Eclipse 中文包的安装中文包的安装以以 Ecli 为例为例 中文包的安装中文包的安装以以为例为例 第第 2 章章 Eclipse 的使用的使用 第第章章的使用的使用 2.1 Eclipse 常用技巧和设置常用技巧和设置 常用技巧和设置常用技巧和设置 创建一个新的项目创建一个新的项目
创建一个新的项目创建一个新的项目 运行项目运行项目 运行项目运行项目 代码格式化及注释的设置代码格式化及注释的设置 代码格式化及注释的设置代码格式化及注释的设置 使用使用 Eclipse 强大的重构功能强大的重构功能 使用使用强大的重构功能强大的重构功能 任务任务 TODO 的设定的设定 任务任务的设定的设定 程序代码的追踪程序代码的追踪
而且还支持汉字, 不过一般的插件好象没几个真的去用汉字. Category 里的ID 很有用.因为如果需要有两个 wizard 在一个分组里的话,你只要第二个extension 使用同一个Category 的ID就行了. Wizard 这里才是真正的向导本身类. Name 不用说,还是显示在菜单中的. ICON 可以设置一个小图标.顺便找一个图片就行了. Project 这个属性真的是关键.是否在new project 的那个菜单里. Category 就是这个wizard挂在哪个分组里. class=id 向导本身的属性了.不用多说了.
JDT核心 JDT 核心 JDT 核心（org.eclipse.jdt.core）是用于定义 Java 核心元素和 API 的插件。在开发特定于 Java 的功能部件时，总是应该将此插件列示为先决条件。 JDT 核心包使您能够访问 Java 模型对象和无外设 Java IDE 基础结构。JDT 核心包包括： ?－定义用于描述Java 模型的类。 ?－定义编译器基础结构的API。 ?－支持可用于检查编译单元的结构直到语句级别的“抽象语法树”（AST）。 ?－支持对代码片段编辑测试窗或调试器中的代码段进行评估。 ?－支持Java“文档对象模型”（DOM），它可用于表示Java 编译单元的结构。 ?－支持在工作空间的Java 模型中搜索与特定描述相匹配的Java 元素。 ?－提供用于处理.class 文件和Java 模型元素的实用程序类。 从版本 3.0 起，建议不要使用 org.eclipse.jdt.core.jdom。应使用 org.eclipse.jdt.core.dom 来完成对编译单元的结构的处理。 Java 模型 Java 模型是用来对与创建、编辑和构建 Java 程序相关联的对象进行建模的一些类。Java 模型类是在中定义的。这些类实现资源的特定于 Java 的行为，并进一步将 Java 资源分解成模型元素。 Java 元素 包定义了用来对组成 Java 程序的元素建模的一些类。JDT 使用内存中的对象模型来表示 Java 程序的结构。此结构是从项目的类路径派生的。模型是分层的。可以将程序的元素分解成子元素。 处理 Java 元素与处理资源对象相似。当使用 Java 元素时，实际上是在使用某些底层的模型对象的句柄。必须使用exists()协议来确定元素是否真正存在于工作空间中。 下表总结了不同种类的 Java 元素。
China 搜索 : 在 只用 + - " " ( ) IBM 主页 | 产品与服务 | 支持与下载 | 个性化服务 developerWorks 中国网站 : Java : 所有的文章 Eclipse 入门-- Eclipse 的使用简介及插件开发 内容： 一．Eclipse 简介 1.文件存放 2.Eclipse 开发环境 3.编译与运行 4.版本管理 5.使用插件 二．开发Eclipse 插件参考资料关于作者 倪大鹏 (ndp@https://www.doczj.com/doc/d011828506.html, ) 2001 年11 月 IBM 宣布捐出了价值 4 千万美金的开发软件给开放源码的 Eclipse 项目。如此受青睐的 Eclipse 是什么样子呢，如何使用呢？本文的第一部分会使你对Eclipse 有一个初步的认识。并且，Eclipse 这个号称未来能进行任何语言开发的IDE 集大成者，又将如何实现它的这一宏伟目标？第二部分介绍的Eclipse 的插件开发将是其中的关键所在。 Eclipse 是替代IBM Visual Age for Java （以下简称IVJ ）的下一代IDE 开发环境，但它未来 的目标不仅仅是成为专门开发Java 程序的IDE 环境，根据Eclipse 的体系结构，通过开发插件，它能扩展到任何语言的开发，甚至能成为图片绘制的工具。目前，Eclipse 已经开始提供C 语言开发的功能插件。更难能可贵的是，Eclipse 是一个开放源代码的项目，任何人都可以下载Eclipse 的源代码，并且在此基础上开发自己的功能插件。也就是说未来只要有人需要，就会有建立在Eclipse 之上的COBOL ，Perl ，Python 等语言的开发插件出现。同时可以通过开发新的插件扩展现有插件的功能，比如在现有的Java 开发环境中加入Tomcat 服务器插件。可以无限扩展，而且有着统一的外观，操作和系统资源管理，这也正是Eclipse 的潜力所在。 虽然目前Eclipse 项目还没有最后完成，但从已有的版本中已经能领略到Eclipse 设计主导思想和主要功能特点。现在就了解Eclipse 不但能使广大程序员对这款业界期望很高的IDE 能一睹为快，更为重要的是如果能参加到Eclipse 项目的开发中或是阅读它的开放源代码，这对广大程序员来说无疑是一个千载难逢的提高编程水平的好机会。Eclipse 计划提供多个平台的版本，象Windows ，Linux ，Solaris ，HP-UX 和AIX ，以下只介绍Windows 版本。本文第一部分先介绍Eclipse 的基本使用方法。第二部分介绍如何进行Eclipse 的插件开发。 一．Eclipse 简介 Eclipse 是开放源代码的项目，你可以到https://www.doczj.com/doc/d011828506.html, 去免费下载Eclipse 的最新版本，一般Eclipse 提供几个下载版本：Release ，Stable Build ，Integration Build 和Nightly Build ，建议下载Release 或Stable 版本，笔者用的是Build20020125（Stable 版本）。Eclipse 本身是用Java 语言编写，但下载的压缩包中并不包含Java 运行环境，需要用户自己另行安装JRE ，并且要在操作系统的环境变量中指明JRE 中bin 的路径。安装Eclipse 的步骤非常简单：只需将下载的压缩包按原路径直接解压既可。需注意如果有了更新的版本，要先删除老的版本重新安装，不能直接解压到原来的路径覆盖老版本。在解压缩之后可以到相应的安装路径去找Eclipse.exe 运行。如果下载的是Release 或Stable 版本，并且JRE 环境安装正确无误，一般来说不会有什么问题，在闪现一个很酷的月蚀图片后，Eclipse 会显示它的缺省界面： dW 全部内容
Eclipse插件开发入门. Eclipse最有魅力的地方就是它的插件体系结构。在这个体系中重要的概念是扩展点（extension points）。扩展点就是在软件开发过程中暴露出来的接口。每一个插件都是在现有的扩展点上开发的，并可能还留有自己的扩展点，以便在这个插件上继续开发。 简介 Eclipse 平台是IBM向开发源码社区捐赠的开发框架，它之所以出名并不是因为IBM宣称投入开发的资金总数为4 000万美元，而是因为如此巨大的投入所带来的成果：一个成熟的、精心设计的、可扩展的体系结构。Eclipse 的价值是它为创建可扩展的集成开发环境提供了一个开放源码平台。这个平台允许任何人构建与环境和其他工具无缝集成的工具。工具与Eclipse无缝集成的关键是插件。除了小型的运行时内核之外，Eclipse中的所有东西都是插件。从这个角度来讲，所有功能部件都是以同等的方式创建的。 由于有了插件，Eclipse系统的核心部分在启动时要完成的工作十分简单：启动平台的基础部分和查找系统的插件。整个Eclipse体系结构就像一个大拼图，可以不断地向上加插件，同时，在现有插件上还可以再加插件。 开发“Hello，world”插件 创建插件最简单的方法是使用Eclipse中专门为开发插件而设计的插件PDE（Plug-in Development Environment）。PDE 和 Java Development Tooling（JDT）IDE是 Eclipse 的标准扩展。PDE 提供了一些向导可以帮助创建插件。下面的“Hello，world”插件将通过PDE进行开发。 下面是创建一个简单插件的操作步骤。 （1）运行Eclipse。 单击Eclipse的“File”→“New”→“Other”菜单项，在弹出的对话框中选择Select对话框左边的Plug-in Development向导。如图1所示，选择Plug-in Project。 图1 新建插件对话框 （2）单击“Next”按钮，弹出新建对话框，输入项目名称。此处使用了 “com.test.helloworld”。单击“Next”按钮后弹出新建对话框页，如图2所示，插件标识就与项目名称相同。使用项目名称作为插件标识可以将该插件与另一个插件的名称发生冲突的机会减到最小。
Eclipse插件开发中的Java项目模型 Eclipse插件开发中的Java项目模型是比较重要的内容，也是我们最长接触到的。本文将详细的为大家讲解Java 项目模型。 AD： Java项目模型 Eclipse的项目有很多种，包括Java项目、C++项目、C#项目等，每种项目都有自己的特点。我们最常接触到的项目就是Java项目，因此我们重点来讲解一下Java项目模型。 Java模型是用来对与创建、编辑和构建Java程序相关联的对象进行建模的一些类。Java模型类是在中定义的。这些类实现资源的特定于Java的行为，并进一步将Java资源分解成模型元素。 $ Java模型的继承结构图如图所示。 图Java模型的继承结构图 IJavaElement的子类接口还有IMethod、IType等，在这里没有全部列出。Java模型中的类结构比较简单，级次也非常少。 下面介绍一下各个接口的主要方法。 (1) IJavaElement exists：判断元素是否存在。处理Java元素与处理资源对象相似。当使用Java元素时，实际上是在使用某些底层的模型对象的句柄。必须使用exists()来确定元素是否真正存在于工作空间中。
, getElementName：返回元素的名称。 getJavaModel：返回其对应的JavaModel，返回值类型是IJavaModel。 getJavaProject：返回元素对应的Java工程，返回值类型是IJavaProject。 getParent：返回父元素，返回值类型是IJavaElement。 getResource：返回元素对应的资源，返回值类型是IResource。 (2) IClassFile 此接口代表编译后的class二进制文件。 ^ isClass：判断是否是Java类。 isInterface：判断是否是接口。 (3) ICompilationUnit 此接口代表Java源文件。 getAllTypes：返回此文件中定义的所有类型，返回值类型是IType[]。一个Java文件中可以定义多个类型。getPrimary：返回主类型，返回值类型是ICompilationUnit。 (4) IJavaModel > 此接口表示根Java 元素，对应于工作空间。是所有具有Java 性质的项目的父类。它对于Java项目的作用和IWorkspaceRoot对于IProject的作用相似。
Eclipse插件开发系列--nature: 很久没有写插件开发的体会了. 网上很多的插件开发的文档,但是大多数都是插件XML介绍,还有就是hello world.这种书不看当然不对,但是看多了.也没什么大用了.写的都是差不多的.. 哎,看了好几本这样的书,真的是浪费时间了. 项目的nature 如果有插件要创建项目,或者是在已有项目上增加JA V A特性,这个其实就是在.project 里填加nature 先来分析一下.project文件.