You’ve definitely heard about
Xtext, the famous text modeling framework,
community award winner . We are all looking forward to the new project management wonder: the
release of Helios, upcoming on June the 23rd, which will include Xtext 1.0.0. In this article, I want do describe some aspects of integration of Xtext-based languages into IDE.
(more…)
Archive for the ‘java’ Category
Extending Xtext Build Participants
Parameterized classes, arrays and varargs
Yesterday, I discovered a funny nuance in Java programming language, which I didn’t know before and decided to share it with you. I was designing an API for transport of changes in relationships between two DTO types. Since I wanted to support batch changes, I created the class for carrying these:
class ManyToManyDelta<S extends BaseDto<?>, T extends BaseDto<?>> {
List<SimpleRelationship<S,T>> relationshipsToAdd;
List<SimpleRelationship<S,T>> relationshipsToRemove;
...
}
class SimpleRelationship<V extends BaseDto<?>, W extends BaseDto<?>> {
// BaseDto classes are identified by the parameterized Id
Id<V> left;
Id<W> right;
SimpleRelationship(BaseDto<V> one, BaseDto<W> another) {
left = one.getId();
right = another.getId();
}
}
Having this structure, you can model the relationship between two instances of types A and B by an instance of SimpleRelationship<A>. If you want to communicate the creation of a relationship you would put the latter into the relatioshipToAdd list, if you want to model the deletion, you would put it into the relatioshipToRemove list.
Now I it was time to develop methods for access of the relationship lists inside of the ManyToManyDelta:
class ManyToManyDelta<S extends BaseDto<?>, T extends BaseDto<?>> {
...
public void add(SimpleRelationship<S, T> toAdd) {
if (toAdd == null) { /* react */}
this.relatioshipToAdd.add(toAdd);
}
...
}
You could think that you have a batch update (e.g. an Array or List) of SimpleRelatioship objects you would like to add them by one invocation instead of a series of invocation. e.G:
class ManyToManyDelta<S extends BaseDto<?>, T extends BaseDto<?>> {
...
public void add(SimpleRelationship<S, T>[] toAdd) {
if (toAdd == null) { /* react */}
this.relatioshipToAdd.addAll(Arrays.asList(toAdd));
}
public void add(SimpleRelationship<S, T> toAdd) {
if (toAdd == null) { /* react */}
this.relatioshipToAdd.add(toAdd);
}
...
}
Using the varargs feature of Java you could also write equivalent:
class ManyToManyDelta<S extends BaseDto<?>, T extends BaseDto<?>> {
...
public void add(SimpleRelationship<S, T>... toAdd) {
if (toAdd == null) { /* react */}
this.relatioshipToAdd.addAll(Arrays.asList(toAdd));
}
...
}
That would be nice, right? By the way, it is a good idea, to write some client code, during the development of API. This discovers potential problems:
... A entityA = ...; B entityB = ...; ManyToManyDelta<A, B> delta = new ManyToManyDelta<A,B>(); delta.add(new SimpleRelationship<A,B>(entityA, entityB));
Coding this result in a type safety warning: A generic array of SimpleRelationship is created for a varargs parameter. Which reveals a problem in a Java language: you can not create an array of parameterized types. And resulting from this fact, you can not use that as varargs argument.
Finally, if you want to create convenience methods for one and many items, you have to do it in a old-fashined way, by providing overloaded methods.
JSF 2.0 Reality Check
Abstract
The JavaServer Faces (JSF) 2.0 is the newest Java presentation technology that is covered in JSR-314 and was publicly released on July 01, 2009. It became a part of the JEE6 standard and can be comfortably used in conjunction with other JEE frameworks, with Spring or just on its own. This article reveals the possible scenarios and shows the required configuration for the usage of JSF 2.0 with EJB 3.1 and with Spring 3.0. It also discusses several auxilary technologies which can be used along with JSF 2.0. (more…)
Real World Java EE Practices – Rethinking Best Practices by Adam Bien
I just returned from the furious event given by Adam Bien on
Real World Java EE Practices. The presentation has been held in Lehmanns Bookstore in Hamburg in co-operation with the JUGHH. It was a full success with no space left in the bookstore. I think, I got the last seat and there were some people standing.
Adam made it in an hour and presented many interesting topics. He started with new subjects introduces in JEE6, like optional local interfaces, cronjob-like Timer Service and other nice goodies. Then he covered new stuff from JEE like REST and CDI (Context and Dependency Injection). Finally, he moved to the best practices, patterns and anti-pattern. As usual, it was quick and precise – Adam answered many questions and gave a good overview of the technology.
After the presentation, JUGHH / Lehmanns offer a glass of sparkling wine for the smaller audience and Adam spoke about the possibility to speak about JavaFX next time. This time I left my camera at home and only had my phone with me, so sorry for the low-resolutioned picture…
Exposing Functionality using Web Services and JEE
Abstract
About two years ago, I published an article about Exposing the Functionality implemented in Stateless Session Beans (EJB 2.1) using Web Services. J2EE 1.4 times are over and the new version of the Java Enterprise framework, called Java Enterprise Edition 5 (JavaEE 5, or simply JEE) has emerged. In this article the same business scenario is repeated in the new framework.
Requirements
Before we dive into code examples, some software is required. The good news about the software is, that it also evolved over time. Here is what we use:
- Sun’s Java 6 SDK
- JBoss AS 5.1.0 GA for JDK6
- Eclipse Galileo 3.5.1 for JEE development
Configuring JBoss Datasource for Firebird DB
Accessing a relational database system from Java is a basic step required for many applications. The JEE architecture defines a standard for gaining this access, calls Java Connector Architecture (JCA). This article is a short HOWTO of configuring JCA-compliant datasource to a Firebird 2.x RDBMs using JBoss AS 5.1.0 as example. This tutorial is based on a Windows installation, but can be easily ported to Linux, or other OS.
For the configuration of the datasource two steps are required:
- Deployment of the Firebird RAR resource adapter (
jaybird-*.rar) - Creation of the
firebird-ds.xmlconfiguration
Eclipse CNF: Navigator Content Extensions
Abstract
After
providing the basic example of how the Eclipse Common Navigator Framework (CNF) can be used to display custom content, this article focuses on the main feature of the CNF – the contribution of content to the same navigator by several independent plug-ins. First of all, I will explain some minor changes introduced to the CNF in the Gallileo Edition, then I will focus on the content itself and finally provide an overview of how the action contributions can be provided. In the end of the post, some ideas on control of dynamic content are explained.
Gallileo Changes
There are two noticeable changes in the CNF that have been added with Eclipse Galileo. The return type of the method (more…)
Passing Data between Plug-ins
Abstract
The Eclipse Platform provides a very rich API for the development and configuration of plug-ins and RCPs. It does this in two ways: by providing the corresponding classes and interfaces or by using the extension point mechanism. During the development the question arises, how to develop own extension points and how those plug-in interfaces look like. This article summarizes some of my experiences with developing plug-ins extension points.
Introduction
The extensive use of extension points is the standard approach during the development of own plug-ins and Eclipse-based applications. Especially, in the 3.x branch, the Eclipse Developers introduced tons of new extension points, primarily for the user interface, moving towards the declarative definition of the UI. Even if the the topic of the definition of extension points is covered in several books and articles, it is a bit challenging to come up with a clean extension point design for a particular scenarios, especially for beginners. This has to do with the specific way, how the Eclipse platform handles extensions.
In order to have a concrete scenario, lets assume that a small RCP application consisting of two plug-ins is being developed. The application prints out the time every ten seconds. One plug-in is responsible for the functionality of the time generation (lets call it the Core plug-in) and another, for the presentation of the results of the first one (lets call it UI plug-in). The separation of code in UI and non-UI plug-ins is a common practice and the standard question is, how to to pass data between the two. In general we assume, that the UI plug-in depends on the Core plug-in.
(more…)
Packaging Eclipse-based RCP for the use in enterprise context
Abstract
Using Eclipse-based rich-clients as stand-alone applications is discussed in many books and articles. In the context of enterprise systems, the software development adopted several paradigms to improve the quality of the overall architecture. This short article describes some issues in packaging the application for using it in the context of enterprise systems.
Architectural Assumptions
Designing enterprise architectures is a standard discipline for IT-consulting companies or freelancers involved in software development. Maybe one of the main characteristics of enterprise architectures is the framework-driven approach of software creation. Thus, the software has to comply certain rules and standards adopted inside the enterprise. In order to simplify such constrained development process, it is common to use an in-house software framework, which enforces the compliance of the enterprise-internal standards and acts as glue between different technologies adopted as parts of the enterprise architecture.
Using such frameworks has major implications for the software development in general, and especially for the rich client development. The design issues are summarized in the next section.
Usaging an Enterprise Framework
The major goal of the enterprise in-house framework is to simplify the process of software systems development and to enforce standardization among the software systems. This usually includes the following aspects:
- Domain-specific component framework
- Methods for master data management
- Infrastructure services: authentication, authorization, communication, security, printing, reporting
- Application skeletons and launchers
The more unification and standardization is included inside the framework, the easier it is for a software developer to concentrate on the particular business task and the easier is the maintenance of the software system.
From the previous list, the most interesting part related to RCP packaging and deployment is the existence of the application skeletons and launchers. So, when launching an application, the framework libraries are loaded and executed first and pass the control to the application-specific modules. The advantage of this approach is that infrastructure services can be loaded first, which can be developed and shared among different applications.
(more…)
Eclipse DemoCamp Galileo Hamburg
As announced in a
previous post the Eclipse Demo Camp Hamburg – Galileo Edition took place in the East Hotel in Hamburg. Organized by
Peter and
Martin, the event was again an interesting meeting with Eclipse-interested people in a wonderful location. Five presenters introduced Eclipse and OSGi-related topics.
Moritz Eysholdt reported about the
(Meta)Model Evolutions, he was focusing on during his masters thesis. The interesting part of his solution are two Xtext DSLs for description of the Metamodel changes (EPatch) and model migration algorithms (MetaPatch).
Heiko Behrens gave a funny and really good introduction of Xtext and DSLs for not Xtext developers. I really like his examples: these are simple and understanding for everyone. Great job!
Marco Mosconi showed some
ObjectTeams (black) magic. A
very intersting technology using aspect-oriented programming for type-safe framework modifications. Seem to be pretty advanced technology with interesting tooling.
Markus Alexander Kuppe had a talk on ECF and
RFC 119 and gave some sneak preview of the upcomming features. Finally, I had a short talk on Common Navigator Framework, basically explaining the
article posted here and something I documented for Galileo. Here are some visual impressions:
my FlickR set and
Peter’s.
Loading ...