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 <vie...@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-unsubscr...@netbeans.apache.org
For additional commands, e-mail: commits-h...@netbeans.apache.org
For further information about the NetBeans mailing lists, visit:
https://cwiki.apache.org/confluence/display/NETBEANS/Mailing+lists
