SeamFramework.orgCommunity Documentation
Un des aspects de JBoss Seam est dans sa capacité RAD (Rapid Application Development, NdT Développement d'Application Rapide). Sans synonimie avec RAD, l'outil intéréssant dans ce cas est dans les langages dynamiques. Jusqu'à présent, choisir un langage dynamique était un choix qui été requis par une plateforme de développement complètement différente (une plateforme de développement avec un groupe d'APIs et un runtime si génial que vous ne devriez plus vouloir utiliser vos bonnes vieille APIs Java [sic] après, ce qui est une chance car vous ne devriez plus être forcé d'utiliser ces APIs propriétaire maintenant). Les langages dynamiques sont construis au dessus de la Machine Virtuelle Java et Groovy en particulier brise cette approche en silos.
JBoss Seam unifie maintenant le monde des langages dynamiques avec le monde Java EE en intégrant sans couture les deux langages statique et dynamique. JBoss Seam permet au développer d'application d'utiliser le meilleur outil pour la tâche, sans basculer de contexte. Ecrire les composants dynamiques de Seam est exactement comme écrire des composants classiques de Seam. Vous utilisez les même annotations, les même APIs, les mêmes tout.
Groovy est un langage dynamique agile basé sur le langage Java avec des fonctionnalité additionnelles inspirée par Python, Ruby et Smalltalk. La force de Groovy est dans deux points:
La syntaxe Java est supportée dans Groovy: le code Java est le code Groovy, ce qui rend la courbe d'apprentissage très douce
Les objets Groovy sont des objets Java, et les classes Groovy sont des classes Java: Groovy s'intègre facilement avec les bibliothèques Java et les serveurs d'applications.
A FAIRE: ecrire un rapide apperçu de l'ajout de syntaxe Groovy
Il n'y a pas grand chose à dire à propos de cela. Si un objet Groovy est un objet Java, vous pouvez virtuellement écrire tout composant Seam, ou toute classe pour ce qui est prévu, en Groovy et la déployer. Vous pouvez aussi mélanger les classes Groovy et Java dans la même application.
Comme vous devriez avoir noté maintenant, Seam utilise lourdement les annotations. Soyez sûr d'utiliser Groovy 1.1 ou supérieur pour le support des annotations. Voici un exemple de code en groovy utilisé dans une application Seam.
@Entity
@Name("hotel")
class Hotel implements Serializable
{
@Id @GeneratedValue
Long id
@Length(max=50) @NotNull
String name
@Length(max=100) @NotNull
String address
@Length(max=40) @NotNull
String city
@Length(min=2, max=10) @NotNull
String state
@Length(min=4, max=6) @NotNull
String zip
@Length(min=2, max=40) @NotNull
String country
@Column(precision=6, scale=2)
BigDecimal price
@Override
String toString()
{
return "Hotel(${name},${address},${city},${zip})"
}
}
Groovy supporte nativement la notion de propriété (asseseurs), donc il n'y a pas besoin d'écrire de verbeux assesseurs: dans l'exemple précédent, la classe hotel peut être accédé depuis Java comme hotel.getCity()
, les asseseurs peuvent être générés par le compilateur Groovy. Le type de la syntaxe pur sucre rends le code de l'entité très concise.
Ecrire les composants Seam en Groovy n'est pas vraiment différent qu'en Java: les annotations sont utilisées pour marquer la classe comme un composant de Seam.
@Scope(ScopeType.SESSION)
@Name("bookingList")
class BookingListAction implements Serializable
{
@In EntityManager em
@In User user
@DataModel List<Booking> bookings
@DataModelSelection Booking booking
@Logger Log log
@Factory public void getBookings()
{
bookings = em.createQuery('''
select b from Booking b
where b.user.username = :username
order by b.checkinDate''')
.setParameter("username", user.username)
.getResultList()
}
public void cancel()
{
log.info("Cancel booking: #{bookingList.booking.id} for #{user.username}")
Booking cancelled = em.find(Booking.class, booking.id)
if (cancelled != null) em.remove( cancelled )
getBookings()
FacesMessages.instance().add("Booking cancelled for confirmation number #{bookingList.booking.id}", new Object[0])
}
}
Seam-gen as une intégration transparente avec Groovy. Vous pouvez écrire le code Groovy dans un projet géré par seam-gen sans aucun prérequis d'infrastructure additionnel. Quand à écrire une entité Groovy, placez simplement vos fichiers .groovy
dans src/main
. Sans surprise, avec l'écriture d'une action, placez simplement vos fichiers .groovy
dans src/hot
.
Le déploiement des classes Groovy est assez proche du déploiement des classes Java (sans surprise, pas besoin d'écrire ni de se conformer avec la spécification composite en 3 lettres pour supportert un serveur d'application multi langage).
Au delà des déploiement standard, JBoss Seam a la capacité ,au moment du développement, de redéployer les classes de composants Seam JavaBeans sans avoir à redémarrer l'application, préservant beaucoup de temps de développement dans le cycle développement/test. Le même support est fourni par les composants de Seam de GroovyBeans quand les fichiers .groovy
sont déployés.
Une classe Groovy est une classe Java avec une représentation en bytecode tout comme une classe Java. Pour déployer une entité Groovy, un bean de session Groovy ou un composant Seam Groovy, une étape de compilation est nécéssaire. Une approche commune est d'utiliser la tache ant groovyc
. Une fois compilé, une classe Groovy n'est en acune manière différente d'une classe Java et le serveur d'application la traitera à équalité. Notez que cela autorise un mélange intégré de Groovy et de code Java.
JBoss Seam supporte nativement le déploiement de fichier .groovy
f (autrement dit sans compilation) dans le mode de redéploiement à chaud incrémental (seulement au développement). Cela rend possible un cycle edition/test très rapide. Pour configurer le déploiement de .groovy, suivez la configuration de la Section 2.8, « Seam et le déploiement incrémental à chaud » et deploiyez votre code Groovy (les fichiers .groovy
) dans le dossier WEB-INF/dev
. Les composants GroovyBean vont être pris incrémentallement sans avoir besoin de redémarrer l'application (ni heureusement le serveur d'application).
Soyez informé que le déploiement de fichier .groovy natif souffre des limitations identique du redéploiement à chaud classique de Seam:
Les composants doivent être des JavaBeans ou des GroovyBeans. Ils ne peuvent pas être des beans EJB3
Les entités ne peuvent pas redéployées à chaud
Le déploiement à chaud des composants ne sera pas visible pour toute classes deployé à l'extérieur de WEB-INF/dev
Le mode debug de Seam doit être activé
Seam-gen supporte de manière transparent le déploiement et la compilation de fichiers Groovy. Cela inclus le déploiement de fichier .groovy
natif dans le mode développement (sans compilation). Si vous créez un projet seam-gen de type WAR, les classes Java et Groovy dans src/hot
vont être automatiquement candidate pour le déploiement à chaud incrémental. Si vous êtes en mode de production, les fichiers Groovy vont être simplement compilés avant le déploiement.
Vous trouverez un exemple en ligne de la démonstration de la Réservation d'Hotel écrit totalement en Groovy et supportant le déploiement incrémental à chaud dans examples/groovybooking
.