You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@netbeans.apache.org by vi...@apache.org on 2019/02/05 17:52:08 UTC
[incubator-netbeans-website] branch master updated: [NETBEANS-1867]
[NETBEANS-1912] Tutorials java/a (#316)
This is an automated email from the ASF dual-hosted git repository.
vieiro pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-netbeans-website.git
The following commit(s) were added to refs/heads/master by this push:
new 9a39e40 [NETBEANS-1867] [NETBEANS-1912] Tutorials java/a (#316)
9a39e40 is described below
commit 9a39e40ace2cc00541c5e51060f0bf94ad130aa4
Author: Antonio Vieiro <vi...@users.noreply.github.com>
AuthorDate: Tue Feb 5 18:52:03 2019 +0100
[NETBEANS-1867] [NETBEANS-1912] Tutorials java/a (#316)
Annotation tutorial
---
.../kb/docs/java/annotations-custom.asciidoc | 119 ++++++++++++---------
.../kb/docs/java/annotations-lombok.asciidoc | 43 +++++---
.../src/content/kb/docs/java/annotations.asciidoc | 20 ++--
3 files changed, 105 insertions(+), 77 deletions(-)
diff --git a/netbeans.apache.org/src/content/kb/docs/java/annotations-custom.asciidoc b/netbeans.apache.org/src/content/kb/docs/java/annotations-custom.asciidoc
index fcc41ac..1b4953c 100644
--- a/netbeans.apache.org/src/content/kb/docs/java/annotations-custom.asciidoc
+++ b/netbeans.apache.org/src/content/kb/docs/java/annotations-custom.asciidoc
@@ -17,7 +17,7 @@
// under the License.
//
-= Annotation Processors Support in the NetBeans IDE, Part II: Using Own Custom Annotation Processors in the IDE
+= Annotations Part II: Using Custom Annotation Processors
:jbake-type: tutorial
:jbake-tags: tutorials
:jbake-status: published
@@ -29,12 +29,7 @@
:description: Annotation Processors Support in the NetBeans IDE, Part II: Using Own Custom Annotation Processors in the IDE - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Annotation Processors Support in the NetBeans IDE, Part II: Using Own Custom Annotation Processors in the IDE
-_Contributed by Jesse Glick, written and maintained by Irina Filippova _
-
-
-* *Using Own Custom Annotation Processors in the IDE*
-
-image::../../../images_www/articles/71/netbeans-stamp-71-72-73.png[title="Content on this page applies to the NetBeans IDE 7.0, 7.1, 7.2 and 7.3"]
+The previous part of the annotations tutorial (link:annotations-lombok.html[Part I: Using Lombok for Custom Annotations]) showed how custom annotations work within NetBeans.
In this section of the tutorial, you will learn how to add a self-written custom annotation processor to a project in the IDE. This tutorial does not teach you how to write an annotation processor. It explains how to add it to a NetBeans IDE project.
@@ -42,14 +37,17 @@ The sample application used in this section was created by Jesse Glick and publi
The annotation processor used as the example generates a parent class for the annotated class. The generated parent class also contains a method that is called from the annotated class. Follow the instructions below on how to create and add a custom annotation processor to an IDE's project.
-*To complete this tutorial, you need the following software and resources.*
+== Requirements
+To complete this tutorial, you need the following software and resources.
+
+[cols="3,1"]
|===
|Software or Resource |Version Required
-|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |7.0, 7.1, 7.2, 7.3
+|link:https://netbeans.org/download/index.html[+NetBeans IDE+] | 9.0 or greater
-|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+Java Development Kit (JDK)+] |version 6 or 7
+|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+Java Development Kit (JDK)+] |version 6 or greater
|link:http://code.google.com/p/projectlombok/downloads/list[+lombok.jar+] |v1.12.4 or newer
|===
@@ -60,10 +58,11 @@ The annotation processor used as the example generates a parent class for the an
In this exercise you will create a class library project.
1. Choose File > New Project and select the Java Class Library project type in the Java category. Click Next.
-2. Type * ``AnnProcessor`` * as the Project Name and specify a location for the project. Click Finish.
+2. Type ``AnnProcessor`` as the Project Name and specify a location for the project. Click Finish.
When you click Finish, the IDE creates the class library project and lists the project in the Projects window.
+[start=3]
3. Right-click the AnnProcessor project node in the Projects window and choose Properties.
4. In the Sources category, confirm that either JDK 6 or JDK 7 are specified as the source/binary format.
5. Select the Libraries tab and confirm that the Java platform is set to either JDK 1.6 or JDK 1.7. Click OK to close the Project Properties window.
@@ -71,14 +70,16 @@ When you click Finish, the IDE creates the class library project and lists the p
In this exercise you will create two Java packages and one Java class in each of the packages.
1. Right-click the Source Packages node under the AnnProcessor project node and choose New > Java Package.
-2. Type * ``ann`` * for the Package Name and click Finish to create the new Java package.
-3. Repeat the two previous steps to create a Java package named * ``proc`` *.
+2. Type ``ann`` for the Package Name and click Finish to create the new Java package.
+3. Repeat the two previous steps to create a Java package named ``proc``.
After you create the two Java packages, the structure of the project should be similar to the following image.
image::images/packages.png[title="The structure of the project for the annotation processor."]
+
+[start=4]
4. Right-click the ``ann`` Java package and choose New > Java class.
-5. Type * ``Handleable`` * for the Class Name. Click Finish.
+5. Type ``Handleable`` for the Class Name. Click Finish.
6. Modify the new ``Handleable.java`` file to make the following changes. Save the file.
[source,java]
@@ -86,22 +87,23 @@ image::images/packages.png[title="The structure of the project for the annotatio
package ann;
-public *@interface* Handleable {
+public @interface Handleable {
}
----
This is how annotations are declared, and it is quite similar to an interface declaration. The difference is that the ``interface`` keyword must be preceded with an ``at`` sign (@). This annotation is called ``Handleable`` .
-*Additional Information.* In annotation declarations, you can also specify additional parameters, for example, what types of elements can be annotated, e.g. classes or methods. You do this by adding ``@Target(value = {ElementType.TYPE})`` for classes and ``@Target(value = {ElementType.METHOD}).`` So, the annotation declaration becomes annotated itself with _meta-annotations_.
+TIP: In annotation declarations, you can also specify additional parameters, for example, what types of elements can be annotated, e.g. classes or methods. You do this by adding ``@Target(value = {ElementType.TYPE})`` for classes and ``@Target(value = {ElementType.METHOD}).`` So, the annotation declaration becomes annotated itself with _meta-annotations_.
You now need to add code for the annotation processor to process the ``Handleable`` annotation.
-7. Right-click the * ``proc`` * Java package and choose New > Java class.
-8. Type * ``HandleableProcessor`` * for the Class Name. Click Finish.
+[start=7]
+7. Right-click the ``proc`` Java package and choose New > Java class.
+8. Type ``HandleableProcessor`` for the Class Name. Click Finish.
9. Modify the ``HandleableProcessor.java`` class to add the following code. Save your changes.
-*Note.* The value of ``@SupportedSourceVersion`` (in *bold*) will depend upon the version of the JDK that you are using and will be either ``(SourceVersion.RELEASE_7)`` or ``(SourceVersion.RELEASE_6)`` .
+NOTE: The value of ``@SupportedSourceVersion`` will depend upon the version of the JDK that you are using and will be either ``(SourceVersion.RELEASE_7)`` or ``(SourceVersion.RELEASE_6)`` .
[source,java]
@@ -127,7 +129,7 @@ import javax.tools.Diagnostic;
import javax.tools.JavaFileObject;
@SupportedAnnotationTypes("ann.Handleable")
-@SupportedSourceVersion(*SourceVersion.RELEASE_7*)
+@SupportedSourceVersion(SourceVersion.RELEASE_7)
public class HandleableProcessor extends AbstractProcessor {
/** public for ServiceLoader */
@@ -216,8 +218,8 @@ You now need to provide a public constructor for the class.
----
public class HandleableProcessor extends AbstractProcessor {
-* public HandleableProcessor() {
- }*
+ public HandleableProcessor() {
+ }
...
}
@@ -229,13 +231,12 @@ Then, you call the ``process`` () method of the parent ``AbstractProcessor``
[source,java]
----
-public class HandleableProcessor extends AbstractProcessor {*
- *...
-* public boolean process(Set<? extends TypeElement> annotations,
+public class HandleableProcessor extends AbstractProcessor {
+ ...
+ public boolean process(Set<? extends TypeElement> annotations,
RoundEnvironment roundEnv) {
...
}
-*
}
----
@@ -245,30 +246,30 @@ The annotation processor's logic is contained within the ``process()`` method
[source,java]
----
-public class HandleableProcessor extends AbstractProcessor {*
- *...
+public class HandleableProcessor extends AbstractProcessor {
+ ...
public boolean process(Set<? extends TypeElement> annotations,
RoundEnvironment roundEnv) {//For each element annotated with the Handleable annotation
- *for (Element e : roundEnv.getElementsAnnotatedWith(Handleable.class)) {
+ for (Element e : roundEnv.getElementsAnnotatedWith(Handleable.class)) {
-*//Check if the type of the annotated element is not a field. If yes, return a warning*.
+// Check if the type of the annotated element is not a field. If yes, return a warning.
if (e.getKind() != ElementKind.FIELD) {
processingEnv.getMessager().printMessage(
Diagnostic.Kind.WARNING,
"Not a field", e);
continue;
}
- *//Define the following variables: name and clazz*.**
+ //Define the following variables: name and clazz.
String name = capitalize(e.getSimpleName().toString());
TypeElement clazz = (TypeElement) e.getEnclosingElement();
-*//Generate a source file with a specified class name. *
+//Generate a source file with a specified class name.
try {
JavaFileObject f = processingEnv.getFiler().
createSourceFile(clazz.getQualifiedName() + "Extras");
processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE,
"Creating " + f.toUri());
Writer w = f.openWriter();
-*//Add the content to the newly generated file*.
+//Add the content to the newly generated file.
try {
PrintWriter pw = new PrintWriter(w);
pw.println("package "
@@ -292,8 +293,8 @@ w.close();
processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
x.toString());
}
-}*return true;
- * }*
+}return true;
+ }
...
}
----
@@ -304,16 +305,18 @@ The last block in this code declares the ``capitalize`` method that is used to
[source,java]
----
-public class HandleableProcessor extends AbstractProcessor {*
- *...*
+public class HandleableProcessor extends AbstractProcessor {
+ ...
private static String capitalize(String name) {
-char[] c = name.toCharArray();
-c[0] = Character.toUpperCase(c[0]);
-return new String(c);
+ char[] c = name.toCharArray();
+ c[0] = Character.toUpperCase(c[0]);
+ return new String(c);
+ }
}
-*}
----
+
+[start=10]
10. Build the project by right-clicking the ``AnnProcessor`` project and choosing Build.
@@ -322,9 +325,12 @@ return new String(c);
In this section you will create a Java Application project in which the annotation processor will be used.
1. Choose File > New Project and select the Java Application project type in the Java category. Click Next.
-2. In the Name and Location page, type * ``Demo`` * as the Project Name and specify the project location.
-3. Type * ``demo.Main`` * in the Create Main Class field. Click Finish.
+2. In the Name and Location page, type ``Demo`` as the Project Name and specify the project location.
+3. Type ``demo.Main`` in the Create Main Class field. Click Finish.
+
image::images/demo-project-wizard.png[title="Creating the Demo project in the New Project wizard."]
+
+[start=4]
4. Open the Project Properties window and confirm that either JDK 6 or JDK 7 are selected as the source/binary format in the Sources panel and that the Java platform is set to JDK 1.6 or JDK 1.7 in the Libraries panel.
5. Modify the ``Main.java`` class to add the following code. Save your changes.
@@ -333,16 +339,16 @@ image::images/demo-project-wizard.png[title="Creating the Demo project in the Ne
package demo;
-*import ann.Handleable;*
+import ann.Handleable;
-public class Main *extends MainExtras* {
+public class Main extends MainExtras {
- *@Handleable
- private String stuff;*
+ @Handleable
+ private String stuff;
- *public static void main(String[] args) {
+ public static void main(String[] args) {
new Main().handleStuff("hello");
- }*
+ }
}
----
@@ -357,23 +363,30 @@ In this simple example, the ``handleStuff`` method only prints out the current
After you save the ``Main.java`` code you will see that the IDE reports multiple compilation errors. This is because the annotation processor has not been added yet to the project.
+[start=6]
6. Right-click the ``Demo`` project node in the Projects window, choose Properties, then select the Libraries category in the Project Properties window.
7. In the Compile tab, click Add Project and locate the ``AnnProcessor`` project.
+
image::images/demo-properties-compile.png[title="Compile tab in Libraries category of the project's Properties window"]
The Compile tab corresponds to the ``-classpath`` option of the link:http://download.oracle.com/javase/6/docs/technotes/tools/windows/javac.html#options[+Java compiler+]. Because the annotation processor is a single JAR file that contains both the annotation definition and the annotation processor, you should add it to the project's classpath, which is the Compile tab.
+[start=8]
8. Select the Compiling category in the Project Properties window and select the Enable Annotation Processing and Enable Annotation Processing in Editor checkboxes.
9. Specify the annotation processor to run by click the Add button next to the Annotation Processors text area and typing * ``proc.HandleableProcessor`` * in the Annotation Processor FQN field.
+
image::images/demo-processor-fqn.png[title="Annotation Processor FQN dialog box"]
The Compiling category in the Project Properties window should look like the following image.
image::images/demo-properties-compiling.png[title="Compiling category in the project's Properties window"]
+
+[start=10]
10. Click OK in the Properties window.
-*Note.* In the ``Main.java`` file you might still see compilation errors. This is because the IDE cannot yet find the ``MainExtras.java`` file that declares the ``handleStuff`` method. The ``MainExtras.java`` file will be generated after you build the Demo project for the first time. If Compile On Save is enabled for you project, the IDE compiled the project when you saved ``Main.java`` .
+NOTE: In the ``Main.java`` file you might still see compilation errors. This is because the IDE cannot yet find the ``MainExtras.java`` file that declares the ``handleStuff`` method. The ``MainExtras.java`` file will be generated after you build the Demo project for the first time. If Compile On Save is enabled for you project, the IDE compiled the project when you saved ``Main.java`` .
+[start=11]
11. Right-click the Demo project and choose Build.
After you build the project, if you look at the project in the Projects window you can see a new ``Generated Sources`` node with the ``demo/MainExtras.java`` file.
@@ -395,19 +408,21 @@ public abstract class MainExtras {
}
}
----
+
+[start=12]
12. Right-click the Demo project and choose Run.
When you click Run you should see the following in the Output window. The Demo project compiles and prints the message.
image::images/demo-run.png[title="Projects window with Generated Sources"]
-link:/about/contact_form.html?to=3&subject=Feedback:%20Using%20the%20Annotation%20Processors%20Support%20in%20NetBeans%20IDE[+Send Feedback on This Tutorial+]
-
== See Also
See the following resources for more information about annotations in Java applications:
+* The previous part of the annotations tutorial: link:annotations-lombok.html[Part I: Using Lombok for Custom Annotations]).
* Java SE Documentation - link:http://download.oracle.com/javase/6/docs/technotes/guides/language/annotations.html[+Annotations+]
* Java SE Tutorial - link:http://download.oracle.com/javase/tutorial/java/javaOO/annotations.html[+Annotations+]
* link:http://download.oracle.com/javase/6/docs/technotes/tools/windows/javac.html#processing[+Java Compiler: Annotation Processing Options+]
* link:http://blogs.oracle.com/darcy/[+Joseph D. Darcy's Weblog+] - useful tips from the JSR-269 specification lead
+
diff --git a/netbeans.apache.org/src/content/kb/docs/java/annotations-lombok.asciidoc b/netbeans.apache.org/src/content/kb/docs/java/annotations-lombok.asciidoc
index bfda08c..edcddd0 100644
--- a/netbeans.apache.org/src/content/kb/docs/java/annotations-lombok.asciidoc
+++ b/netbeans.apache.org/src/content/kb/docs/java/annotations-lombok.asciidoc
@@ -17,7 +17,7 @@
// under the License.
//
-= Annotation Processors Support in the NetBeans IDE, Part I: Using Project Lombok
+= Annotations, Part I: Using Project Lombok for Custom Annotations
:jbake-type: tutorial
:jbake-tags: tutorials
:jbake-status: published
@@ -29,19 +29,18 @@
:description: Annotation Processors Support in the NetBeans IDE, Part I: Using Project Lombok - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Annotation Processors Support in the NetBeans IDE, Part I: Using Project Lombok
-image::images/netbeans-stamp-80-74-73.png[title="Content on this page applies to the NetBeans IDE 7.2, 7.3, 7.4 and 8.0"]
-
-
-* *Using Project Lombok for Custom Annotations*
To demonstrate how custom annotations work inside the NetBeans IDE, we will use Project Lombok, which provides a convenient way of automatically generating several Java code elements, such as getters, setters, constructors and others. For more information about its features, visit the link:http://projectlombok.org/[+Project Lombok's website+]. However, keep in mind that Project Lombok includes some features that might not work in all development environments.
-*To complete this tutorial, you need the following software and resources.*
+== Requirements
+To complete this tutorial, you need the following software and resources.
+
+[cols="3,1"]
|===
|Software or Resource |Version Required
-|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |7.2, 7.3, 7.4, 8.0
+|link:https://netbeans.org/download/index.html[+NetBeans IDE+] | 9.0 or later
|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+Java Development Kit (JDK)+] |version 7 or 8
@@ -53,19 +52,22 @@ To demonstrate how custom annotations work inside the NetBeans IDE, we will use
In this exercise you create a simple Java project and class that is named ``MyBooks.java`` which will demonstrate annotations in action.
-1. Choose *File > New Project* from the main menu to open the New Project wizard.
+1. Choose _File > New Project_ from the main menu to open the New Project wizard.
2. Select the Java Application project type in the Java category. Click Next.
-3. In the Name and Location page of the wizard, type * ``TestAnn`` * as the project name.
-4. Type * ``testann.TestBooks`` * in the Create Main Class field to replace the default class name. Click Finish.
+3. In the Name and Location page of the wizard, type ``TestAnn`` as the project name.
+4. Type ``testann.TestBooks`` in the Create Main Class field to replace the default class name. Click Finish.
+
image::images/newproj.png[title="Creating a new Java project in the NetBeans IDE"]
When you click Finish, the IDE creates the Java application project and opens the ``TestBooks.java`` class in the editor. You can see that the new project is now visible in the Projects window and that the ``TestBooks.java`` class is in the ``testann`` package under the Source Packages node.
+[start=5]
5. Right-click the ``testann`` package node in the Projects window and choose New > Java class.
-6. Type * ``MyBooks`` * for the Class Name and confirm that the class will be created in the ``testann`` package. Click Finish.
+6. Type ``MyBooks`` for the Class Name and confirm that the class will be created in the ``testann`` package. Click Finish.
When you click Finish the IDE opens the new class in the editor.
+[start=7]
7. In the source editor, add the following three fields to ``MyBooks.java`` .
[source,java]
@@ -80,9 +82,14 @@ public class MyBooks {
}
----
+
+[start=8]
8. Place your insert cursor in the class declaration and press Ctrl-Space to invoke the editor's code completion support.
9. Select ``MyBooks (int year, String title, String author) - generate`` in the code completion list to generate a constructor for ``MyBooks.java`` .
+
image::images/generate-constructor.png[title="Code completion to generate constructor"]
+
+[start=10]
10. Save your changes.
@@ -98,14 +105,17 @@ image::images/properties1.png[title="Libraries category in Properties window"]
The resources added on the Compile tab correspond to the ``-classpath`` option of the link:http://download.oracle.com/javase/6/docs/technotes/tools/windows/javac.html#options[+Java compiler+]. As ``lombok.jar`` is a single JAR file that contains both annotation definitions and annotation processors, you should add it to the project's classpath, which is the Compile tab.
+[start=5]
5. Choose the Compiling category in the Project Properties window.
6. Confirm that the Enable Annotation Processing checkbox is selected (it is enabled by default) and select the Enable Annotation Processing in Editor checkbox.
+
image::images/properties2.png[title="Compiling category in Properties window"]
The Enable Annotation Processing checkbox enables annotation processing while building and compiling your project. If the checkbox is not selected, the ``-proc:none`` option is passed to the Java compiler, and compilation takes places without any annotation processing. So, if you want to process annotations in your code, the Enable Annotation Processing checkbox must be selected.
By selecting the Enable Annotation Processing in Editor checkbox, you make annotation processing results visible in the editor. Any additional artifacts that are generated by annotation processors (classes, methods, fields, etc.) become visible in the IDE Editor and available in code completion, Navigator, GoTo Type, Find usages, and others.
+[start=7]
7. Click OK in the Project Properties window and return to the ``MyBooks.java`` file.
If you expand the Libraries node in the Projects window, you can see that ``lombok.jar`` is now listed as a project library.
@@ -119,7 +129,9 @@ image::images/projects-window.png[title="Libraries node in Projects window"]
To learn more about what annotations are supported by Project Lombok, refer to the Lombok link:http://projectlombok.org/features/index.html[+Features Overview+].
+[start=2]
2. Click the hint in the editor's left margin and add import for ``lombok.Data`` .
+
image::images/import-lombok.png[title="Hint in editor to import lombok"]
The resulting code in the Editor should look like the example below.
@@ -154,6 +166,7 @@ image::images/nav.png[title="Navigator window showing project members"]
You can also invoke the code completion window (Ctrl-Space) and see that the generated artifacts are available for picking them. Now, let's see that the project compiles and the generated artifacts can be called from other parts of the program.
+[start=3]
3. Open the ``TestBooks.java`` file with the _main_ method and add the following code (in bold) to create a new object of the ``MyBooks`` class.
[source,java]
@@ -168,6 +181,8 @@ public class TestBooks {
}
}
----
+
+[start=4]
4. Add the following code to print out the values of the ``books`` variable.
To return the values, we call the getter methods that were auto-generated by ``lombok.jar`` . While you are typing, note that the auto-generated artifacts are available from the code completion window.
@@ -186,6 +201,8 @@ public class TestBooks {
}
}
----
+
+[start=5]
5. Save your changes.
6. Right-click the project node in the Projects window and choose Run (F6).
@@ -195,9 +212,9 @@ image::images/output.png[title="Output window after running the application"]
You can see that the artifacts generated by the Lombok annotation processor are accessible from other parts of the program.
-
== Next Step
+* link:annotations-custom.html[+Part II: Using Own Custom Annotation Processor in the IDE+]
* Java SE Documentation - link:http://download.oracle.com/javase/6/docs/technotes/guides/language/annotations.html[+Annotations+]
* Java SE Tutorial - link:http://download.oracle.com/javase/tutorial/java/javaOO/annotations.html[+Annotations+]
-link:/about/contact_form.html?to=3&subject=Feedback:%20Using%20the%20Annotation%20Processors%20Support%20in%20NetBeans%20IDE[+Send Feedback on This Tutorial+]
+
diff --git a/netbeans.apache.org/src/content/kb/docs/java/annotations.asciidoc b/netbeans.apache.org/src/content/kb/docs/java/annotations.asciidoc
index 55c0619..b3d78c5 100644
--- a/netbeans.apache.org/src/content/kb/docs/java/annotations.asciidoc
+++ b/netbeans.apache.org/src/content/kb/docs/java/annotations.asciidoc
@@ -29,24 +29,22 @@
:description: Annotation Processors Support in the NetBeans IDE - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Annotation Processors Support in the NetBeans IDE
-_Sample contributed by Jesse Glick._
-
-
-
-image::images/netbeans-stamp-80-74-73.png[title="Content on this page applies to the NetBeans IDE 7.2, 7.3, 7.4 and 8.0"]
-
This two-part tutorial demonstrates how you can attach annotation processors to a project and use them while working on your code in the IDE. NetBeans IDE includes built-in support for custom annotation processors. Now you can conveniently specify annotation processors to run with your project and see the results of annotation processing directly in the Java Editor through code completion and navigation.
The link:annotations-lombok.html[+first part of the tutorial+] shows the use of the third-party annotation processor, link:http://projectlombok.org/[+Project Lombok+], in the NetBeans IDE.
The link:annotations-custom.html[+second part of the tutorial+] provides explanations of how to add a self-written annotation processor to a project. The sample code for this part of the tutorial is contributed by Jesse Glick.
-*To complete this tutorial, you need the following software and resources.*
+== Requirements
+
+To complete this tutorial, you need the following software and resources.
+
+[cols="3,1"]
|===
|Software or Resource |Version Required
-|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |7.2, 7.3, 7.4, 8.0
+|link:https://netbeans.apache.org/download/index.html[+NetBeans IDE+] | 9.0 or later
|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+Java Development Kit (JDK)+] |version 7 or 8
|===
@@ -70,8 +68,9 @@ In practice, annotations are most widely used in combination with Java Persisten
As mentioned above, in Java SE 6 javac, annotation processing was incorporated as an integral functionality of the Java compiler. The compiler automatically searches for annotation processors by default at user class path (unless annotation processing is explicitly disabled). In addition, the search path or a path to particular annotation processors can be specified by using javac options. In the table below, you can see a map of the javac options related to annotation processing and the [...]
-*Note.* In the IDE, the annotation processing options for all Java application with the exception of NetBeans platform applications are specified in the Project Properties window. To open the project's Properties window window, right-click your project and choose Properties.
+NOTE: In the IDE, the annotation processing options for all Java application with the exception of NetBeans platform applications are specified in the Project Properties window. To open the project's Properties window window, right-click your project and choose Properties.
+[cols="1,3,3"]
|===
|Java 6 javac Options |IDE Command |Description
@@ -117,8 +116,6 @@ Add options that should be passed to the annotation processor associated with yo
|===
-
-
== Next Steps
Read the following parts of the tutorial to learn how to use annotations in the IDE.
@@ -126,4 +123,3 @@ Read the following parts of the tutorial to learn how to use annotations in the
* link:annotations-lombok.html[+Part I: Using Project Lombok for Custom Annotations+]
* link:annotations-custom.html[+Part II: Using Own Custom Annotation Processor in the IDE+]
-link:/about/contact_form.html?to=3&subject=Feedback:%20Using%20the%20Annotation%20Processors%20Support%20in%20the%20NetBeans%20IDE[+Send Feedback on This Tutorial+]
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@netbeans.apache.org
For additional commands, e-mail: commits-help@netbeans.apache.org
For further information about the NetBeans mailing lists, visit:
https://cwiki.apache.org/confluence/display/NETBEANS/Mailing+lists