Nachdem im ersten Teil der JPA Einführung die Infrastruktur für die Arbeit mit JPA fertig gestellt wurde, kommen wir nun zu den Entitätsklassen. Bei den Entities handelt es sich um ganz normale Java Klassen (POJOs), die kein spezielles Interface implementieren oder von einer vorgegebenen Oberklasse erben müssen. Lediglich ein default Konstruktor muss vorhanden sein.
Dank JPA Annotationen kann man erkennen, dass die Objekte persistiert werden.
Möchte man EJB3 konform arbeiten, so sollten die Annotationen dort angebracht werden, wo auf die Properties zugegriffen wird: An den Attributen für field-access, an den Getter-Methoden bei property-access. Dies sollte konsistent gemacht werden, und die beiden Formen sollten nicht gemischt werden. (Zwischen den beiden Formen wird über die Position der @Id Annotation unterschieden.)
Die Annotation der Attribute hat dabei den Vorteil, dass schnell erkennbar ist, was wie persistiert wird – kann jedoch bei einigen JPA Providern zu Performance Problemen führen. Auf der anderen Seite führen Getter-Methoden, die nicht zu persistierende Werte liefern und nicht explizit von der Persistierung ausgenommen werden zu möglicherweise schwer zu findenden Programmfehlern.

Ein Beispiel für eine einfache Entitätsklasse

@Entity
public class Person {
@Id
@GeneratedValue
private Long id;
private String vorname;
private String nachname;
// default constructor
public Person () {
}
// getter + setter
}

Die @Entity Annotation macht kenntlich, dass diese Klasse von JPA persistiert werden soll, @Id kennzeichnet den Primärschluessel und @GeneratedValue bedeutet, dass dieser automatisch generiert werden soll (also ein synthetischer Primärschlüssel).
Mit diesen wenigen Angaben ist bereits erreicht, dass Objekte der Person Klasse persistiert werden können – lediglich die Konfiguration der Datenbank für JPA fehlt noch. Die genaue Steuerung in welche Tabellen/Spalten die Speicherung in der Datenbank erfolgt ist optional, und wird ohne zusätzliche Konfiguration mit Default-Werten realisiert.

JPA persistence.xml Konfiguration

In der Datei “persistence.xml” (normalerweise im META-INF Verzeichnis) befindet sich die Datenbankkonfiguration fuer den JPA Provider.
Ein verkürztes Beispiel passende zu der Beispiel-Entität von oben:
<persistence xmln="http://java.sun.com/xml/ns/persistence" ... >
<persistence-unit name="addressbook">
<class>com.example.domain.Person</class>
<properties>
<property name="hibernate.connection.driver_class" value="org.hsqldb.jdbcDriver" />
...
</properties>
</persistence-unit>
</persistence>
Zuerst erfolgt die Angabe des symbolischen Namens unter welchem diese Konfiguration verfügbar gemacht wird, dann folgt welche Klasse(n) zu persistieren sind (falls diese nicht per @Entity bereits deklariert sind, je nach JPA Provider reicht die @Entity Annotation nicht aus) und schließlich die Konfiguration der Datenbankverbindung ueber den JPA Provider Hibernate.
Theoretisch sind verschiedene Persistence-Units möglich, ebenso kann über <provider> explizit der JPA Provider konfiguriert werden. In der Praxis findet sich jedoch für eine Anwendung in der Regel eine Persistence Unit und lediglich eine JPA Implementierung, die dann auch standardmäßig verwendet wird.
Die Properties des JPA Providers sind dabei spezifisch für den jeweiligen Provider – in diesem Fall Hibernate.

Objekt mittels JPA speichern

Nun fehlt nur noch, dass ein Entity Object mittels JPA auch gespeichert wird. Nachdem die Vorarbeiten erledigt sind, zeigt sich schnell wie einfach die Arbeit Objekte zu speichern und zu laden dank JPA wird:
EntityManagerFactory emf =
Persistence.createEntityManagerFactory("addressbook" ); //der symbolische Name
EntityManager em = emf .createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin ()
Person p = new Person ();
...
em.persist(p);
tx.commit();
em.close();
Im nächsten Teil folgt dann wie Objekte aus der Datenbank geladen, geändert und auch gelöscht werden können.

Weitere Artikel:

1. JPA Tutorial: JPA Einrichtung

JPA, die Java Persistence API bietet im Vergleich zu JDBC ein erhöhtes Abstraktionsniveau und ermöglicht damit in kurzer Zeit Anwendungen zu entwickeln, in denen Daten dauerhaft gespeichert werden müssen.
Zum Hintergrund von JPA: Bei dem Umgang mit Datenbanken gibt es schon sehr lange JDBC (Java Database connectivity) als einheitliche API um die Verbindung zu Datenbanken herzustellen. Auch hier handelt es sich bereits um eine einheitliche Schnittstelle, jedoch wird darüber lediglich festgelegt, wie Verbindungen aufgebaut werden, wie eine Abfrage eingeleitet wird und wie Transaktionen manuell gesteuert werden können.
Damit bleiben zwei Probleme: Der SQL Code muss von Hand erstellt werden, was gerade bei CRUD (Create, Update, Delete) Anwendungen viel Produktivität kostet, und zudem ist der SQL Code in der Regel herstellerabhängig. Ein Wechsel von Oracle zu Postgres bedeutet damit das Programm an vielen Stellen ändern zu müssen. Auch sind händisch erstellte Abfragen nicht immer optimal: Lazy loading von Entitäten, Caching Strategien und Transaktionssteuerung können sehr aufwendig werden. Dazu gesellen sich der relativ hohe Wartungsaufwand und die Gefahr von Fehlern die erst zur Laufzeit entdeckt werden.Das Beispielprojekt wird ein einfaches Adressbuch, dabei werden Personen und ihre zugehörigen Adressen gespeichert. Im ersten Teil beschäftigen wir uns damit die Projektstruktur einzurichten, und die nötigen Bibliotheken zu installieren.

Dependencies

JPA selber ist lediglich eine API – diese wird durch einen sogenannten JPA Provider implementiert. Hibernate, OpenJPA und EclipseLink (bzw. Oracle Toplink) sind Beispiele fuer JPA Provider, die als OpenSource zur Verfuegung stehen und auch kommerziell verwendet werden koennen.
Am einfachsten lassen sich diese Abhaengigkeiten durch Maven erfuellen, Maven kuemmert sich dabei um Download der direkten und indirekten (transistiven) Dependencies. Fuer diejenigen, die bereits Maven Erfahrung haben und Maven mit JPA nutzen moechten, hier ein Beispiel (weiter unten findet sich ein fertiges Eclipse Projekt ohne Maven zum Download) fuer Hibernate als JPA Provider (und SLF4J zum Loggen):
<dependencies>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>3.3.2.GA</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-annotations</artifactId>
<version>3.4.0.GA</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>3.4.0.GA</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-c3p0</artifactId>
<version>3.3.2.GA</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-ehcache</artifactId>
<version>3.3.2.GA</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.5.8</version>
</dependency>
<dependency>
<groupId>org.hsqldb</groupId>
<artifactId>hsqldb</artifactId>
<version>1.8.0.10</version>
</dependency>
</dependencies>

Manuelle Einrichtung

Hier eine Liste der nötigen Bibliotheken, für diejenigen, die von Hand (beinhaltet alle transitiven Abhängigkeiten) das Projekt konfigurieren möchten:

• antlr-2.7.6.jar
• c3p0-0.9.1.jar
• commons-collections-3.1.jar
• commons-logging-1.0.4.jar
• dom4j-1.6.1.jar
• ehcache-1.2.3.jar
• ejb3-persistence-1.0.2.GA.jar
• hibernate-annotations-3.4.0.GA.jar
• hibernate-c3p0-3.3.2.GA.jar
• hibernate-commons-annotations-3.1.0.GA.jar
• hibernate-core-3.3.2.GA.jar
• hibernate-ehcache-3.3.2.GA.jar
• hibernate-entitymanager-3.4.0.GA.jar
• hsqldb-1.8.0.10.jar
• javassist-3.4.GA.jar
• jta-1.1.jar
• slf4j-api-1.5.8.jar
• slf4j-simple-1.5.8.jar
• xml-apis-1.0.b2.jar

Diese JAR Dateien werden in den Classpath gelegt, normalerweise in einen “lib” Ordner, und anschließend wird der Classpath entsprechend konfiguriert. (In Eclipse über Rechtsklick auf das Projekt “Properties” im Menü auswählen, dann “Java Build Path” und dort mittels “Add JARs” die entsprechenden Dateien hinzufügen.)

JPA Projekt Download

Der Download als fertiges Eclipse Projekt (hier: Eclipse JPA Project) beinhaltet die nötigen JAR Dateien im “lib” Ordner, ist bereits entsprechend konfiguriert und benötigt kein Maven oder andere externe Tools.  (Die Ordnerstruktur verwendet jedoch die Maven Verzeichnisstruktur, was jedoch keine große Umstellung bedeuten sollte.)

Für dies Beispiel wird hsql als Datenbank verwendet, und dabei separat gestartet. Je nach Anwendung (Desktop oder Server) würde man in der Regel eine eingebettete Datenbank (Swing/Desktop Anwendung) oder eine externe Datenbank (Java Enterprise Application) verwenden. Hsql bietet den Betrieb als Embedded- und Standalone-Datenkbank an, dabei ist die JAR Datei mit rund 700kb relativ schlank und kann somit sehr gut für dieses Tutorial eingesetzt werden.

Um HSQL zu konfigurieren gibt es die Datei “server.properties”, die eine Datenbank konfiguriert, die in dem Ordner “db” abgelegt wird, “addressbook” heisst und auch als “addressbook” angesprochen wird.
Server properties:
server.database.0=db/addressbook
server.dbname.0=addressbook

Von der Kommandozeile startet man den HSQL Server dann aus dem Projekt Verzeichnis in dem sich der “db” Ordner, der “lib” Ordner mit der hsqldb JAR Datei  und die “server.properties” Datei befindet:
java -cp lib/hsqldb-1.8.0.10.jar org.hsqldb.Server

Damit ist die Vorbereitung der serverseitigen JPA Infrastruktur abgeschlossen, die nächsten Schritte beinhalten die Einrichtung von JPA Provider, Verbindung zur Datenbank und welche Java Klassen wie auf die Datenbank abgebildet werden sollen.
(Zum besseren Vergleich zwischen Hibernate und JPA beinhaltet das Beispielprojekt auch die entsprechende native Hibernate Konfiguration und die Hibernate API Aufrufe in separaten Klassen. Mehr dazu in den folgenden Artikeln.)

Weitere Artikel:

1. JPA Einführung: Entity Klassen
2. Java Testing best practice: Projekt Organisation

Drawing in code:

Part 2 (Transfer the prototype into swing):

So you will find out that this is not magic but only drawing the same elements that we used in the vector drawing programm but now in their Java2D representations. We just create a buffered image with the same size as the prototype. So we could use the same pixelcoordinates for the shapes and gradients in swing.

In Adobe Fireworks you have the ability to move the mousecursor over a pixel and you could see the pixelcoordinate and it’s color values in a window, this is nothing special but it’s a needed functionality to grab the positions of all the shapes and the colors of the gradients from the prototype. Keep in mind that i won’t show how i pick all these coordinates and colors, but you have to do this

Step 1. – 5.

First coding the vertical pill which is in principle just a rounded rectangle with a corner radius of it’s width.

After that we code the rounded rectangle that will represent the bottom if the tube.

Now follows the small ellipse on the top.
After all we combine all of these shapes into one which is really easy in swing.

Just take a look at the code:

/**
* Tutorial Step 1. - 5.
* Create the glass tube form
*/
final java.awt.geom.Area TUBE = new java.awt.geom.Area(new java.awt.geom.RoundRectangle2D.Float(1, 8, 86, 136, 86, 86));
final java.awt.geom.Area TUBE_BOTTOM = new java.awt.geom.Area(new java.awt.geom.RoundRectangle2D.Float(1, 75, 86, 70, 30, 30));
final java.awt.geom.Area TUBE_TOP = new java.awt.geom.Area(new java.awt.geom.Ellipse2D.Float(38, 0, 12, 18));
TUBE.add(TUBE_TOP);
TUBE.add(TUBE_BOTTOM);

Step 6.

Create and apply a horizontal gradient to the tube.

/**
* Tutorial Step 6.
* Create and apply the left to right gradient
*/
final java.awt.geom.Point2D START_LEFT = new java.awt.geom.Point2D.Float(0,0);
final java.awt.geom.Point2D STOP_RIGHT = new java.awt.geom.Point2D.Float(86,0);

final float[] FRACTIONS_LEFT_TO_RIGHT =
{
    0.0f,
    0.15f,
    0.4f,
    0.6f,
    0.75f,
    1.0f
};

final java.awt.Color[] COLORS_LEFT_TO_RIGHT =
{
    new java.awt.Color(0.0f, 0.0f, 0.0f, 0.5f),
    new java.awt.Color(0.0f, 0.0f, 0.0f, 0.3f),
    new java.awt.Color(0.0f, 0.0f, 0.0f, 0.1f),
    new java.awt.Color(0.0f, 0.0f, 0.0f, 0.1f),
    new java.awt.Color(0.0f, 0.0f, 0.0f, 0.3f),
    new java.awt.Color(0.0f, 0.0f, 0.0f, 0.5f)
};

final java.awt.LinearGradientPaint LEFT_TO_RIGHT_GRADIENT = new java.awt.LinearGradientPaint(START_LEFT, STOP_RIGHT, FRACTIONS_LEFT_TO_RIGHT, COLORS_LEFT_TO_RIGHT);

g2.setPaint(LEFT_TO_RIGHT_GRADIENT);
g2.fill(TUBE);

Step 7.

Now create and apply a vertical gradient from top to bottom to the same tube shape.

/**
* Tutorial Step 7.
* Create and apply the top to bottom gradient
*/
final java.awt.geom.Point2D START_TOP = new java.awt.geom.Point2D.Float(0,0);
final java.awt.geom.Point2D STOP_BOTTOM = new java.awt.geom.Point2D.Float(0,146);

final float[] FRACTIONS_TOP_TO_BOTTOM =
{
    0.0f,
    0.9f,
    1.0f
};

final java.awt.Color[] COLORS_TOP_TO_BOTTOM =
{
    new java.awt.Color(0.0f, 0.0f, 0.0f, 0.0f),
    new java.awt.Color(0.0f, 0.0f, 0.0f, 0.0f),
    new java.awt.Color(0.0f, 0.0f, 0.0f, 0.6f)
};

final java.awt.LinearGradientPaint TOP_TO_BOTTOM_GRADIENT = new java.awt.LinearGradientPaint(START_TOP, STOP_BOTTOM, FRACTIONS_TOP_TO_BOTTOM, COLORS_TOP_TO_BOTTOM);

g2.setPaint(TOP_TO_BOTTOM_GRADIENT);
g2.fill(TUBE);

Step 8. – 9.

So let’s add the side light effect. So we code two roundedrectangles and subtract one from another. Let’s take a look at the code:

/**
* Tutorial Step 8. - 9.
* Create the side light reflection shape
*/
final java.awt.geom.Area SIDE_LIGHT_EFFECT = new java.awt.geom.Area(new java.awt.geom.RoundRectangle2D.Float(3, 43, 36, 99, 18, 18));
final java.awt.geom.Area EFFECT_SUB = new java.awt.geom.Area(new java.awt.geom.RoundRectangle2D.Float(7, 37, 36, 105, 18, 18));
SIDE_LIGHT_EFFECT.subtract(EFFECT_SUB);

et voila…that was easy

Step 10.

Now we have to create and apply a horizontal gradient for this side light effect.

/**
* Tutorial Step 10.
* Create and apply the side light gradient
*/
final java.awt.geom.Point2D SIDE_LIGHT_EFFECT_START = new java.awt.geom.Point2D.Float(3, 0);
final java.awt.geom.Point2D SIDE_LIGHT_EFFECT_STOP = new java.awt.geom.Point2D.Float(13, 0);

final float[] SIDE_LIGHT_EFFECT_FRACTIONS =
{
    0.0f,
    1.0f
};

final java.awt.Color[] SIDE_LIGHT_EFFECT_COLORS =
{
    new java.awt.Color(1.0f, 1.0f, 1.0f, 0.5f),
    new java.awt.Color(1.0f, 1.0f, 1.0f, 0.0f)
};

final java.awt.LinearGradientPaint SIDE_LIGHT_EFFECT_GRADIENT = new java.awt.LinearGradientPaint(SIDE_LIGHT_EFFECT_START, SIDE_LIGHT_EFFECT_STOP, SIDE_LIGHT_EFFECT_FRACTIONS, SIDE_LIGHT_EFFECT_COLORS);

g2.setPaint(SIDE_LIGHT_EFFECT_GRADIENT);
g2.fill(SIDE_LIGHT_EFFECT);

Step 11.

Next thing to code is the ellipse on top of the tube which will be the top light reflection.

/**
* Tutorial Step 11.
* Create the top light effect ellipse
*/
final java.awt.geom.Ellipse2D TOP_LIGHT_EFFECT = new java.awt.geom.Ellipse2D.Float(17, 11, 52, 21);

Step 12.

Now we have to create and apply the gradient for this top light reflection.

/**
* Tutorial Step 12.
* Create and apply the top light gradient
*/
final java.awt.geom.Point2D TOP_LIGHT_EFFECT_START = new java.awt.geom.Point2D.Float(0, 11);
final java.awt.geom.Point2D TOP_LIGHT_EFFECT_STOP = new java.awt.geom.Point2D.Float(0, 32);

final float[] TOP_LIGHT_EFFECT_FRACTIONS =
{
    0.0f,
    1.0f
};

final java.awt.Color[] TOP_LIGHT_EFFECT_COLORS =
{
    new java.awt.Color(1.0f, 1.0f, 1.0f, 0.5f),
    new java.awt.Color(1.0f, 1.0f, 1.0f, 0.0f)
};

final java.awt.LinearGradientPaint TOP_LIGHT_EFFECT_GRADIENT = new java.awt.LinearGradientPaint(TOP_LIGHT_EFFECT_START, TOP_LIGHT_EFFECT_STOP, TOP_LIGHT_EFFECT_FRACTIONS, TOP_LIGHT_EFFECT_COLORS);

g2.setPaint(TOP_LIGHT_EFFECT_GRADIENT);
g2.fill(TOP_LIGHT_EFFECT);

Step 13.

This one is ease, just a small ellipse on top.

/**
* Tutorial Step 13.
* Create the small light effect ellipse
*/
final java.awt.geom.Ellipse2D SMALL_TOP_LIGHT_EFFECT = new java.awt.geom.Ellipse2D.Float(39, 3, 4, 6);

Step 14.

And again create and apply the right gradient for the reflection effect.

/**
* Tutorial Step 14.
* Create and apply the small light effect gradient
*/
final java.awt.geom.Point2D SMALL_TOP_LIGHT_EFFECT_START = new java.awt.geom.Point2D.Float(0, 3);
final java.awt.geom.Point2D SMALL_TOP_LIGHT_EFFECT_STOP = new java.awt.geom.Point2D.Float(0, 9);

final float[] SMALL_TOP_LIGHT_EFFECT_FRACTIONS =
{
    0.0f,
    1.0f
};

final java.awt.Color[] SMALL_TOP_LIGHT_EFFECT_COLORS =
{
    new java.awt.Color(1.0f, 1.0f, 1.0f, 0.3f),
    new java.awt.Color(1.0f, 1.0f, 1.0f, 0.0f)
};

final java.awt.LinearGradientPaint SMALL_TOP_LIGHT_EFFECT_GRADIENT = new java.awt.LinearGradientPaint(SMALL_TOP_LIGHT_EFFECT_START, SMALL_TOP_LIGHT_EFFECT_STOP, SMALL_TOP_LIGHT_EFFECT_FRACTIONS, SMALL_TOP_LIGHT_EFFECT_COLORS);

g2.setPaint(SMALL_TOP_LIGHT_EFFECT_GRADIENT);
g2.fill(SMALL_TOP_LIGHT_EFFECT);

Step 15.

We are coming slowly to the end, now creating the small rectangle for the stripe reflection.

/**
* Tutorial Step 15.
* Creating the rectangle for the stripe light effect
*/
final java.awt.geom.Rectangle2D STRIPE_LIGHT_EFFECT = new java.awt.geom.Rectangle2D.Float(13, 46, 62, 1);

Step 16.

Finally create and apply the gradient for the stripe reflection.

/**
* Tutorial Step 16.
* Create and apply the stripe light effect gradient
*/
final java.awt.geom.Point2D STRIPE_LIGHT_EFFECT_START = new java.awt.geom.Point2D.Float(13, 0);
final java.awt.geom.Point2D STRIPE_LIGHT_EFFECT_STOP = new java.awt.geom.Point2D.Float(75, 0);

final float[] STRIPE_LIGHT_EFFECT_FRACTIONS =
{
    0.0f,
    0.5f,
    1.0f
};

final java.awt.Color[] STRIPE_LIGHT_EFFECT_COLORS =
{
    new java.awt.Color(1.0f, 1.0f, 1.0f, 0.0f),
    new java.awt.Color(1.0f, 1.0f, 1.0f, 0.5f),
    new java.awt.Color(1.0f, 1.0f, 1.0f, 0.0f)
};

final java.awt.LinearGradientPaint STRIPE_LIGHT_EFFECT_GRADIENT = new java.awt.LinearGradientPaint(STRIPE_LIGHT_EFFECT_START, STRIPE_LIGHT_EFFECT_STOP, STRIPE_LIGHT_EFFECT_FRACTIONS, STRIPE_LIGHT_EFFECT_COLORS);

g2.setPaint(STRIPE_LIGHT_EFFECT_GRADIENT);
g2.fill(STRIPE_LIGHT_EFFECT);

Prototype	Swing

Conclusion:

As you can see transfering an image to swing is not rocket-science. To achieve this you have to get a feeling for drawing effects like light reflections, shadows etc. (and i’m really not a designer).

So my recommendation is follow design blogs, play with your drawing program or just walk around with open eyes and take pictures of intersting things…there are so many of them…

Please find the related Netbeans project here DrawInCode.zip

Now enjoy swinging…

Weitere Artikel:

1. Drawing in code (Part 1)
2. Java2D Conical Gradient Paint
3. Swing Worldclock

Drawing in code:

Part 1 (Drawing the prototype):

After i published my little fun swing nixieclock i got a lot of requests on how i transferred the image into swing.
Because i remember when i was starting swing development i asked myself the same questions when i saw the amazing work of swing/design guru’s like Kirill Grouchnikov, Romain Guy, Joshua Marinacci, Chet Haase, and others.
Well in the meantime i figured out how to do this and find a workflow that i would like to share here. By the way this is really nothing compared to the things these swing/design guru’s are able to do.

So here we go, first of all i have one good advice for you “Know your tools”,
which means not only java and swing but also your graphics program.

So i’m using Adobe Fireworks for that but you could also use any other kind of graphics program like Adobe Photoshop, Gimp, Inkscape etc.

I will start the tutorial with the drawing of the tube in Adobe Fireworks because it makes coding in swing so much easier if you know how to draw it in a graphics program. So the first part will be focussed on the drawing and the second part will explain how to draw all the different points in java2d/swing:

So we would like to create a nixie glass tube in swing that should look similar to this but to keep it simple i will focus only on the glass tube itself without any numbers or logic etc. Once you understand the way of doing this you could easily adopt these technique to everything you would like to do (if there is a equivalent in swing).

Step 1. Draw a vertical pill which will be the main body of the tube.
Step 2. Draw a rounded rectangle that will represent the bottom if the tube.
Step 3. Merge this two shapes into one shape.
Step 4. Now draw a little ellipse on top of the tube.
Step 5. Again merge the two shapes into one.
Step 6. Fill the tube with a horizontal gradient from left to right where you use black with different values for transparency. Position Transparency 0% 60% 15% 20% 75% 20% 100% 60%
Step 7. Now fill the same tube shape again with a vertical gradient from top to bottom again using black with different values for transparency. Position Transparency 0% 0% 90% 0% 100% 60%
Step 8. Now we will add some reflection effects. First of all a side light reflection. Therefor create a vertical rounded rectangle. Than create a second rounded rectangle which is slightly higher than the first one and place it a little bit shifted to the right of the first one.
Step 9. Subtract the second rectangle from the first one.
Step 10. Now fill this shape with a horizontal gradient from left to right with white of with different values for transparency. Position Transparency 0% 60% 100% 0%
Step 11. Create a ellipse on top of the tube which will be the top light reflection.
Step 12. Fill this ellipse with a vertical gradient from top to bottom with white with different values for transparency. Position Transparency 0% 60% 100% 0%
Step 13. Next add a small ellipse on the very top of the tube.
Step 14. Fill this ellipse also with a vertical gradient from top to bottom with white with different values for transparency. Position Transparency 0% 60% 100% 0%
Step 15. Finally create a small horizontal rectangle on the top of the tube.
Step 16. Fill this rectangle with a horizontal gradient from left to right with different values for transparency Position Transparency 0% 0% 50% 60% 100% 0%
That’s it… so we created a nice looking glass tube just with combination of some shapes and gradients. In the second part of the tutorial i’ll explain the representation of all these shapes and gradients in code…so hang on…

Part two: http://www.jug-muenster.de/drawing-in-code-part-2-2-384/

Weitere Artikel:

1. Drawing in code (Part 2)
2. Swing Workshop “Swing Basics” – Source Code Update
3. Swing NixieClock