java-ee

#java-ee
Table des matières
À propos 1

Chapitre 1: Démarrer avec java-ee 2

Remarques 2

Examples 2

Installation 2

Qu'est-ce que Java EE? 2

Installation de Payara Server Full 5

Construire ma première application JavaEE (Hello World) 6

Créer un nouveau projet 6

Nettoyez et construisez le projet 7

Déployer le fichier WAR 7

Déployer le fichier WAR directement à partir de Netbeans 7

Voir les résultats 7

Chapitre 2: Java Connector Architecture (JCA) 8

Remarques 8

Examples 10

Exemple d'adaptateur de ressources 10

Chapitre 3: Java Messaging Service (JMS) 11

Introduction 11

Remarques 11

Examples 11

Création de ConnectionFactory 11

Utilisation de la bibliothèque ActiveMQ pour la messagerie (implémentations spécifiques au 12

Utilisation de la recherche basée sur jndi pour la messagerie (exemple non spécifique à l' 14

Chapitre 4: Java RESTful Web Services (JAX-RS) 17

Remarques 17

Examples 17

Ressource simple 17

Types de méthode GET 18

Méthode DELETE 19
 Méthode POST 19

Mappeur d'exception 20

UriInfo 20

Les sous-ressources 21

Convertisseurs de paramètres personnalisés 22

Liaison de nom 22

Définition d'une annotation de liaison de nom 23

Relier un filtre ou un intercepteur à un noeud final 23

Documentation 24

Chapitre 5: L'API Javamail 25

Remarques 25

Examples 25

Envoi d'un email à un serveur de messagerie POP3 25

Envoyer un email simple 26

Envoyer un courrier HTML formaté 27

Chapitre 6: L'API WebSockets 28

Remarques 28

Examples 28

Créer une communication WebSocket 28

Codeurs et décodeur: WebSockets orientés objet 29

Crédits 37
À propos
You can share this PDF with anyone you feel could benefit from it, downloaded the latest version
from: java-ee

It is an unofficial and free java-ee ebook created for educational purposes. All the content is
extracted from Stack Overflow Documentation, which is written by many hardworking individuals at
Stack Overflow. It is neither affiliated with Stack Overflow nor official java-ee.

The content is released under Creative Commons BY-SA, and the list of contributors to each
chapter are provided in the credits section at the end of this book. Images may be copyright of
their respective owners unless otherwise specified. All trademarks and registered trademarks are
the property of their respective company owners.

Use the content presented in this book at your own risk; it is not guaranteed to be correct nor
accurate, please send your feedback and corrections to info@[Link]

[Link] 1
Chapitre 1: Démarrer avec java-ee
Remarques
Cette section fournit une vue d'ensemble de ce qu'est java-ee et pourquoi un développeur peut
vouloir l'utiliser.

Il devrait également mentionner tous les grands sujets dans java-ee, et établir un lien avec les
sujets connexes. La documentation de java-ee étant nouvelle, vous devrez peut-être créer des
versions initiales de ces rubriques connexes.

Examples
Installation

Tout d'abord, vous ne pouvez pas "installer" Java EE. Java EE comprend un certain nombre de
spécifications. Vous pouvez toutefois installer des implémentations de ces spécifications.

Selon vos besoins, il y a beaucoup de possibilités. Pour installer la plupart (ou la totalité) des
spécifications, vous pouvez choisir un serveur d'applications compatible Java EE 7. Selon vos
besoins, vous pouvez choisir entre les serveurs d'applications qui implémentent le profil Web ou
les serveurs d'applications qui implémentent le profil complet. Pour obtenir la liste des serveurs
d'applications compatibles Java EE7, voir Compatibilité Java EE .

Qu'est-ce que Java EE?

Java EE signifie Java Enterprise Edition. Java EE étend le Java SE (qui signifie Java Standard
Edition). Java EE est un ensemble de technologies et de spécifications connexes axées sur le
développement d'applications d'entreprise à grande échelle. Java EE est développé dans un
processus piloté par la communauté. Jusqu'à présent, les versions suivantes de Java EE ont été
publiées:

• J2EE 1.2 (12 décembre 1999)

• J2EE 1.3 (24 septembre 2001)
• J2EE 1.4 (11 novembre 2003)
• Java EE 5 (11 mai 2006)
• Java EE 6 (10 décembre 2009)
• Java EE 7 (5 avril 2013)

Et Java EE 8 devrait être publié au premier semestre 2017.

Un concept clé de Java EE est que chaque version de Java EE comprend un ensemble de
technologies spécifiques. Ces technologies concernent des JSR spécifiques (Java Specification
Requests). Pour qu'un programmeur utilise ces technologies, il doit télécharger une
implémentation des spécifications de la technologie Java EE. La communauté Java fournit une

[Link] 2
implémentation de référence pour chaque technologie, mais d'autres technologies conformes à
Java EE sont développées et peuvent également être utilisées. La communauté fournit un
ensemble de tests, à savoir le kit de compatibilité Java (JCK) qui peut être utilisé par les
développeurs d’une implémentation JSR pour vérifier s’il est conforme ou non au JSR. Le tableau
suivant donne un aperçu des technologies composant Java EE 7 et du JSR associé définissant
les spécifications.

Technologie Java EE 7 JSR

JSR
Plate-forme Java, Enterprise Edition 7 (Java EE 7)
342

JSR
API Java pour WebSocket
356

JSR
API Java pour le traitement JSON
353

JSR
Java Servlet 3.1
340

JSR
Faces JavaServer 2.2
344

JSR
Langage d'expression 3.0
341

JSR
JavaServer Pages 2.3
245

Bibliothèque de balises standard pour JavaServer Pages (JSTL) 1.2 JSR 52

JSR
Applications par lots pour la plate-forme Java
352

JSR
Utilitaires de concomitance pour Java EE 1.0
236

JSR
Contextes et injection de dépendances pour Java 1.1
346

JSR
Injection de dépendance pour Java 1.0
330

JSR
Bean Validation 1.1
349

JSR
Enterprise JavaBeans 3.2
345

[Link] 3
 Technologie Java EE 7 JSR

JSR
Intercepteurs 1.2 (version de maintenance)
318

JSR
Architecture du connecteur Java EE 1.7
322

JSR
Java Persistence 2.1
338

JSR
Annotations communes à la plate-forme Java 1.2
250

JSR
API Java Message Service 2.0
343

JSR
Java Transaction API (JTA) 1.2
907

JSR
JavaMail 1.5
919

JSR
API Java pour RESTful Web Services (JAX-RS) 2.0
339

JSR
Implémentation des services Web d'entreprise 1.3
109

JSR
API Java pour les services Web basés sur XML (JAX-WS) 2.2
224

JSR
Métadonnées des services Web pour la plate-forme Java
181

JSR
API Java pour RPC basé sur XML (JAX-RPC) 1.1 (facultatif)
101

API Java pour la messagerie XML 1.3 JSR 67

API Java pour les registres XML (JAXR) 1.0 JSR 93

Interface du fournisseur de services d'authentification Java pour les conteneurs JSR

1.1 196

JSR
Contrat d'autorisation Java pour les conteneurs 1.5
115

Java EE Application Deployment 1.2 (facultatif) JSR 88

J2EE Management 1.1 JSR 77

[Link] 4
 Technologie Java EE 7 JSR

Prise en charge du débogage pour d'autres langues 1.0 JSR 45

JSR
Architecture Java pour la liaison XML (JAXB) 2.2
222

JSR
API Java pour le traitement XML (JAXP) 1.3
206

JSR
Java Database Connectivity 4.0
221

JSR
Java Management Extensions (JMX) 2.0
003

JSR
JavaBeans Activation Framework (JAF) 1.1
925

JSR
API de streaming pour XML (StAX) 1.0
173

Installation de Payara Server Full

Conditions préalables

• JDK 1.7 ou version ultérieure installé. Vous pouvez trouver les JDK Oracle ici.

Pas

• Téléchargez Payara Server Full .

• Décompressez le serveur Payara à un endroit de votre ordinateur. Nous utiliserons
C:\payara41 comme INSTALL_DIR pour les utilisateurs Windows et /payara41 pour les
utilisateurs Linux / Mac.

Démarrer / arrêter Payara à partir de l'invite de commande

• Windows: Ouvrez une invite de commande et exécutez la commande suivante pour

démarrer / arrêter Payara:

"C:\payara41\bin\asadmin" start-domain

"C:\payara41\bin\asadmin" stop-domain

• Linux / Max: Ouvrez un terminal et exécutez la commande suivante pour démarrer / arrêter
Payara:

/payara41/bin/asadmin start-domain

/payara41/bin/asadmin stop-domain

Démarrer Payara depuis Netbeans

[Link] 5
 • Ajouter le serveur Payara à Netbeans (voir chapitre précédent)
• Accédez à l'onglet "Services" (Windows -> Services).
• Développez l'élément 'Servers'.
• Cliquez avec le bouton droit sur le serveur Payara et sélectionnez «Démarrer».
• (Facultatif) Cliquez avec le bouton droit sur le serveur Payara et sélectionnez «View Domain
Admin Console» pour accéder à la console.

Pour vérifier que vous exécutez le serveur d'applications, ouvrez un navigateur et accédez à http:
// localhost: 4848 pour afficher la console du serveur Payara.

Voila! Il est maintenant temps de créer votre première application en utilisant JavaEE et de la
déployer sur votre serveur!

Construire ma première application JavaEE (Hello World)

Comprenons quelque chose. JavaEE comprend un certain nombre de spécifications. Lorsque

vous installez un serveur d'applications (Payara par exemple), vous installez toutes les
spécifications en même temps. Par exemple, il existe une spécification pour un ORM appelé JPA
(Java Persistence API), une spécification pour construire des applications Web basées sur des
composants appelée JSF (Java Server Faces), une spécification pour construire des services
Web REST et des clients appelés JAX-RS .

Comme vous pouvez le deviner, il n'y a pas qu'une seule façon de créer une application Hello
World simple dans JavaEE.

Deuxièmement, la spécification JavaEE a une structure spécifique de dossiers qui ressemble à

ceci (simplifié):

/projectname/src/main/java
/projectname/src/main/resources
/projectname/src/main/resources/META-INF
/projectname/src/main/webapp
/projectname/src/main/webapp/WEB-INF

Dans /projectname/src/main/java nous mettons toutes les classes Java dont nous avons besoin.

Dans /projectname/src/main/webapp nous mettons des fichiers HTML, des fichiers CSS, des fichiers
javascript, etc.

Dans le /projectname/src/main/webapp/WEB-INF certains fichiers de configuration facultatifs, tels que

[Link] et [Link] , sont disponibles .

Pour plus de simplicité, nous utiliserons l'EDI NetBeans (c'est gratuit) pour créer notre première
application JavaEE. Vous pouvez le trouver ici. Choisissez la version JavaEE et installez-la.

Créer un nouveau projet

• Ouvrez l'IDE NetBeans
• Allez dans Fichier> Nouveau projet> Maven> Application Web et cliquez sur Suivant.

[Link] 6
 • Modifiez le nom du projet en HelloJavaEE , puis cliquez sur Suivant et terminer.

Nettoyez et construisez le projet

• Allez dans Run> Clean and Build Project (HelloJavaEE).

Déployer le fichier WAR

• Dans un navigateur, accédez à http: // localhost: 4848 (suivez les instructions pour installer
le serveur payara ).
• Allez dans Applications> Cliquez sur Déployer, cliquez sur Sélectionner un fichier et
choisissez votre fichier de guerre ([Link]) sous
../NetBeansProjects/HelloJavaEE/target .

Déployer le fichier WAR directement à partir de Netbeans

• Installez Payara (voir chapitre suivant).
• Dans Netbeans, allez dans l'onglet "Services" (Window-> Services si vous ne le voyez pas).
• Cliquez avec le bouton droit sur Servers et sélectionnez "Add Server ..."
• Sélectionnez «Serveur GlassFish», donnez-lui un nom et cliquez sur Suivant.
• Pointez sur votre installation locale Payara, sélectionnez «Domaine local» et cliquez sur
Suivant.
• Laissez les paramètres d'emplacement du domaine tels qu'ils sont (Domaine: domaine1,
hôte: localhost, port DAS: 4848, port HTTP: 8080).
• Allez dans l'onglet "Projets" (Windows -> Projets).
• Cliquez avec le bouton droit sur votre projet et sélectionnez «Propriétés».
• Dans le volet de gauche, accédez à «Exécuter» et sélectionnez le serveur que vous venez
d'ajouter.
• (Facultatif) Modifiez le chemin de contexte. Si vous définissez le chemin de contexte sur "/
MyFirstApplication", l'URL par défaut sera " http: // localhost: 8080 / MyFirstApplication ".

Voir les résultats

• Dans un navigateur, accédez à http: // localhost: 8080 / HelloJavaEE-1.0-SNAPSHOT

Voila! C'est votre première application utilisant la technologie JavaEE. Vous devriez maintenant
commencer à créer d'autres applications "Hello World" utilisant des spécifications différentes
comme JPA, EJB, JAX-RS, JavaBatch, etc ...

Lire Démarrer avec java-ee en ligne: [Link]

java-ee

[Link] 7
Chapitre 2: Java Connector Architecture
(JCA)
Remarques
Clarifions d'abord certaines terminologies:

• La messagerie sortante est l'endroit où le message démarre depuis le serveur (pour être
plus précis, il est lancé depuis votre application que vous avez sur le serveur, WebSphere
Liberty dans ce cas) et se termine sur le système EIS.
• La messagerie entrante est l'endroit où le message commence à partir du système EIS et
se termine sur le serveur.
• Message Point final en général, l'endroit où le message se retrouve assis / reçu à un stade
spécifique de son cycle de vie.

Ainsi, avec la connectivité sortante, nous faisons référence à la situation dans laquelle une
application obtient une connexion à un système EIS externe et y lit ou écrit des données. Avec la
connectivité entrante, nous faisons référence à la situation dans laquelle l'adaptateur de
ressources (RA) écoute les événements du système EIS externe et appelle votre application
lorsqu'un tel événement se produit.

Illustration d'un RA sortant

[Link] 8
Illustration d'un RA entrant

Qu'est-ce qu'un message de MessageEndPoint dans JCA?

Le serveur d'applications (ex: WebSphere Liberty ) fournit des MBeans de point de terminaison de
message pour vous aider à gérer la remise d'un message à vos beans gérés par message
agissant comme écouteurs sur des ordinateurs d'extrémité spécifiques, qui sont des destinations
et gérant les ressources EIS. utilisé par ces haricots à message. Les beans pilotés par message
qui sont déployés en tant que noeuds finaux de message ne sont pas les mêmes que les beans
pilotés par message configurés sur un port d'écoute. Les beans pilotés par message qui sont
utilisés en tant que noeuds finaux de message doivent être déployés à l'aide d'un
ActivationSpecification défini dans une configuration RA pour JCA (disponible dans le fichier
[Link] ).

[Link] 9
Qu'est-ce que cela signifie activer un MessageEndPoint?

Avec les MBeans de noeud final de message, vous pouvez activer et désactiver des noeuds
finaux spécifiques dans vos applications pour vous assurer que les messages ne sont distribués
que sur des beans gérés par des messages qui interagissent avec des ressources EIS saines.
Cette fonctionnalité vous permet d'optimiser les performances de vos applications JMS dans les
situations où une ressource EIS ne se comporte pas comme prévu. La remise des messages à un
noeud final échoue généralement lorsque le bean géré par les messages à l'écoute appelle une
opération sur une ressource non saine. Par exemple, un fournisseur de messagerie, qui est un
adaptateur de ressources entrantes compatible JCA, peut ne pas transmettre les messages à un
noeud final lorsque son bean géré par message tente de valider des transactions sur un serveur
de base de données qui ne répond pas.

MessageEndPoint doit-il être un bean?

Cela devrait. Sinon, vous vous retrouverez dans une situation désastreuse en créant votre propre
façon de faire non conventionnelle, qui dépassait l'objectif de suivre les spécifications Java EE.
Concevez vos beans gérés par message pour déléguer le traitement métier à d'autres beans
d'entreprise. N'accédez pas aux ressources EIS directement dans le bean géré par message,
mais indirectement via un bean délégué.

Pouvez-vous montrer un exemple simple de travail / déploiement d'un MessageEndPoint?

Vérifiez la deuxième ressource que je mentionne ci-dessous pour un exemple utile.

Ressources d'apprentissage utiles:

• Gestion des messages avec les points de terminaison de message

• Développer des connecteurs entrants

Examples
Exemple d'adaptateur de ressources

class MyResourceAdapter
implements [Link] {

public void start(BootstrapContext ctx){..}

public void stop(){..}

public void endpointActivation (MessageEndpoingFactory mf, ActivationSpec a){..}

public void endpointDeactivation (MessageEndpoingFactory mf, ActivationSpec a){..}
public void getXAResources(ActivationSpec[] activationSpecs){..}
}

Lire Java Connector Architecture (JCA) en ligne: [Link]

connector-architecture--jca-

[Link] 10
Chapitre 3: Java Messaging Service (JMS)
Introduction
Java Message Service est une API Java qui permet aux applications de créer, envoyer, recevoir
et lire des messages. L'API JMS définit un ensemble commun d'interfaces et de sémantiques
associées qui permettent aux programmes écrits dans le langage de programmation Java de
communiquer avec d'autres implémentations de messagerie. JMS permet une communication qui
n'est pas seulement couplée de manière souple, mais également asynchrone et fiable.

Remarques
Java Message Service (JMS) est une API Java standard qui permet aux applications de créer,
envoyer, recevoir et lire des messages de manière asynchrone.

JMS définit un ensemble général d'interfaces et de classes permettant aux applications d'interagir
avec d'autres fournisseurs de messages.

JMS est similaire à JDBC: JDBC se connecte à différentes bases de données (Derby, MySQL,
Oracle, DB2, etc.) et JMS se connecte à différents fournisseurs (OpenMQ, MQSeries, SonicMQ,
etc.).

L'implémentation de référence JMS est Open Message Queue (OpenMQ). C'est un projet open
source et peut être utilisé dans des applications autonomes ou peut être intégré dans un serveur
d'applications. C'est le fournisseur JMS par défaut intégré à GlassFish.

Examples
Création de ConnectionFactory

Les fabriques de connexions sont les objets gérés qui permettent à l'application de se connecter
au fournisseur en créant un objet Connection . [Link] est une interface qui
encapsule les paramètres de configuration définis par un administrateur.

Pour utiliser ConnectionFactory client doit exécuter la recherche JNDI (ou utiliser l'injection). Le
code suivant obtient l'objet InitialContext JNDI et l'utilise pour rechercher l'objet ConnectionFactory
sous le nom JNDI:

Context ctx = new InitialContext();

ConnectionFactory connectionFactory =
(ConnectionFactory) [Link]("jms/javaee7/ConnectionFactory");

Les méthodes disponibles dans cette interface sont les méthodes createConnection() qui renvoient
un objet Connection et les nouvelles méthodes JMS 2.0 createContext() qui renvoient un JMSContext
.

[Link] 11
Il est possible de créer une Connection ou un JMSContext avec l'identité d'utilisateur par défaut ou en
spécifiant un nom d'utilisateur et un mot de passe:

public interface ConnectionFactory {

Connection createConnection() throws JMSException;
Connection createConnection(String userName, String password) throws JMSException;

JMSContext createContext();
JMSContext createContext(String userName, String password);
JMSContext createContext(String userName, String password, int sessionMode);
JMSContext createContext(int sessionMode);
}

Utilisation de la bibliothèque ActiveMQ pour la messagerie (implémentations

spécifiques au fournisseur jms de activemq)

Configurer ActiveMQ

• Téléchargez une distribution ActiveMQ à partir de [Link] et décompressez-la

quelque part
• Vous pouvez démarrer le serveur immédiatement, en exécutant non sécurisé sur localhost,
en utilisant le script bin / activemq
• Lorsqu'il est en cours d'exécution, vous pouvez accéder à la console de votre serveur local
sur http: // localhost: 8161 / admin /
• Configurez-le en modifiant conf / [Link]
• Comme le titre l'indique, les exemples suivants implémentent des implémentations
spécifiques à l'utilisateur activemq jms et donc [Link] doivent être ajoutés au
classpath.

Envoi d'un message via un client autonome

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class JmsClientMessageSender {

public static void main(String[] args) {

ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616"); //
ActiveMQ-specific
Connection con = null;
try {
con = [Link]();
Session session = [Link](false, Session.AUTO_ACKNOWLEDGE); // non-
transacted session

Queue queue = [Link]("[Link]"); // only specifies queue name

MessageProducer producer = [Link](queue);

[Link] 12
 Message msg = [Link]("hello queue"); // text message
[Link](msg);

} catch (JMSException e) {
[Link]();
} finally {
if (con != null) {
try {
[Link](); // free all resources
} catch (JMSException e) { /* Ignore */ }
}
}
}
}

Polling for messages

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class JmsClientMessagePoller {

public static void main(String[] args) {

ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616"); //
ActiveMQ-specific
Connection con = null;

try {
con = [Link]();
Session session = [Link](false, Session.AUTO_ACKNOWLEDGE); // non-
transacted session

Queue queue = [Link]("[Link]"); // only specifies queue name

MessageConsumer consumer = [Link](queue);

[Link](); // start the connection

while (true) { // run forever
Message msg = [Link](); // blocking!
if (!(msg instanceof TextMessage))
throw new RuntimeException("Expected a TextMessage");
TextMessage tm = (TextMessage) msg;
[Link]([Link]()); // print message content
}
} catch (JMSException e) {
[Link]();
} finally {
try {
[Link]();
} catch (JMSException e) {/* Ignore */ }
}
}
}

[Link] 13
Utiliser MessageListener

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class JmsClientMessageListener {

public static void main(String[] args) {

ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616"); //
ActiveMQ-specific
Connection con = null;

try {
con = [Link]();
Session session = [Link](false, Session.AUTO_ACKNOWLEDGE); // non-
transacted session
Queue queue = [Link]("[Link]"); // only specifies queue name

MessageConsumer consumer = [Link](queue);

[Link](new MessageListener() {
public void onMessage(Message msg) {
try {
if (!(msg instanceof TextMessage))
throw new RuntimeException("no text message");
TextMessage tm = (TextMessage) msg;
[Link]([Link]()); // print message
} catch (JMSException e) {
[Link]("Error reading message");
}
}
});
[Link](); // start the connection
[Link](60 * 1000); // receive messages for 60s
} catch (JMSException e1) {
[Link]();
} catch (InterruptedException e) {
[Link]();
} finally {
try {
[Link](); // free all resources
} catch (JMSException e) {
[Link]();
}
}
}
}

Utilisation de la recherche basée sur jndi pour la messagerie (exemple non

spécifique à l'implémentation)

[Link] 14
Cette méthode permet d'écrire et de déployer du code non spécifique à l'implémentation sur
plusieurs plates-formes jms. L'exemple de base ci-dessous se connecte au serveur activemq jms
et envoie un message.

import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class JmsClientJndi {

public static void main(String[] args) {

Properties jndiProps = new Properties();

// Following two could be set via a system property for flexibility in the code.
[Link](Context.INITIAL_CONTEXT_FACTORY,
"[Link]");
[Link](Context.PROVIDER_URL, "tcp://localhost:61616");

QueueConnection conn = null;

QueueSession session = null;
QueueSender sender = null;
InitialContext jndi = null;
try {
jndi = new InitialContext(jndiProps);
QueueConnectionFactory factory = (QueueConnectionFactory)
[Link]("ConnectionFactory");
conn = [Link]();
[Link]();

session = [Link](false, Session.AUTO_ACKNOWLEDGE);

Queue queue = (Queue) [Link]("dynamicQueues/[Link]");
sender = [Link](queue);

TextMessage msg = [Link]();

[Link]("Hello worlds !!!!! ");
[Link](msg);

} catch (NamingException e) {
[Link]();
} catch (JMSException e) {
[Link]();
} finally {
try {
if (sender != null)
[Link]();
if (session != null)
[Link]();
if (conn != null)
[Link]();

[Link] 15
 } catch (JMSException e) {
[Link]();
}
}
}
}

Lire Java Messaging Service (JMS) en ligne: [Link]

messaging-service--jms-

[Link] 16
Chapitre 4: Java RESTful Web Services (JAX-
RS)
Remarques
Contrairement à SOAP et à WS-stack, qui sont spécifiés comme normes W3C, REST est en
réalité un ensemble de principes pour la conception et l’utilisation d’une interface Web. Les
applications REST / RESTful reposent largement sur d’autres normes:

HTTP
URI, URL
XML, JSON, HTML, GIF, JPEG, and so forth (resource representations)

Le rôle de JAX-RS (API Java pour RESTful Web Services) est de fournir des API prenant en
charge la création de services RESTful. Cependant, JAX-RS n'est qu'un moyen d'y parvenir . Les
services RESTful peuvent être implémentés d'autres manières en Java et (en effet) dans de
nombreux autres langages de programmation.

Examples
Ressource simple

Tout d'abord, pour une application JAX-RS, vous devez définir un URI de base à partir duquel
toutes les ressources seront disponibles. Pour cela, la classe [Link] doit
être étendue et annotée à l' [Link] annotation [Link] .
L'annotation accepte un argument de chaîne qui définit l'URI de base.

@ApplicationPath(JaxRsActivator.ROOT_PATH)
public class JaxRsActivator extends Application {

/**
* JAX-RS root path.
*/
public static final String ROOT_PATH = "/api";

Les ressources sont de simples classes POJO qui sont annotées avec l'annotation @Path .

import [Link];
import [Link];
import [Link];

@Path("/hello")
public class HelloWorldResource {
public static final String MESSAGE = "Hello StackOverflow!";

[Link] 17
 @GET
@Produces("text/plain")
public String getHello() {
return MESSAGE;
}
}

Lorsqu'une HTTP GET est envoyée à /hello , la ressource répond avec un Hello StackOverflow!
message.

Types de méthode GET

import [Link];
import [Link];
import [Link];

@Path("/hello")
public class HelloWorldResource {
public static final String MESSAGE = "Hello World!";

@GET
@Produces("text/plain")
public String getHello() {
return MESSAGE;
}

@GET
@Path("/{letter}")
@Produces("text/plain")
public String getHelloLetter(@PathParam("letter") int letter){
if (letter >= 0 && letter < [Link]()) {
return [Link](letter, letter + 1);
} else {
return "";
}
}
}

GET sans paramètre donne tout le contenu ("Hello World!") Et le paramètre GET with path donne la
lettre spécifique de cette chaîne.

Quelques exemples:

$ curl [Link]
Hello World!

$ curl [Link]
H

$ curl [Link]
o

Remarque: si vous @GET l'annotation de type de méthode (par exemple, @GET ci-dessus), une
méthode de requête est par défaut un gestionnaire de requête GET.

[Link] 18
Méthode DELETE

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

@Path("hello")
public class HelloWorldResource {

private String message = "Hello StackOverflow!";

@GET
@Produces("text/plain")
public String getHello() {
return message;
}

@DELETE
public Response deleteMessage() {
message = null;
return [Link]().build();
}
}

Consommez-le avec une boucle:

$ curl [Link]
Hello StackOverflow!

$ curl -X "DELETE" [Link]

$ curl [Link]
null

Méthode POST

import [Link];
import [Link];
import [Link];
import [Link];

@Path("hello")
public class HelloWorldResource {
@POST
@Path("/receiveParams")
public Response receiveHello(@FormParam("name") String name, @FormParam("message") String
message) {
//process parameters
return [Link](200).build();
}

@POST
@Path("/saveObject")
@Consumes("application/json")

[Link] 19
 public Response saveMessage(Message message) {
//process message json
return [Link](200).entity("OK").build();
}
}

La première méthode peut être invoquée via l'envoi de formulaires HTML en envoyant des
paramètres d'entrée capturés. L'action de soumission de formulaire doit indiquer -

/hello/receiveParams

La seconde méthode nécessite un message POJO avec des getters / setters. Tout client REST
peut appeler cette méthode avec une entrée JSON comme -

{"sender":"someone","message":"Hello SO!"}

POJO doit avoir la même propriété que JSON pour que la sérialisation fonctionne.

public class Message {

String sender;
String message;

public String getSender() {

return sender;
}
public void setSender(String sender) {
[Link] = sender;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
[Link] = message;
}
}

Mappeur d'exception

@Provider
public class IllegalArgumentExceptionMapper implements
ExceptionMapper<IllegalArgumentException> {

@Override
public Response toResponse(IllegalArgumentException exception) {
return [Link]().entity("Invalid input: " + [Link]()).build();
}
}

Ce mappeur d'exception intercepte toutes les exceptions IllegalArgumentException lancées dans

l'application et affiche à l'utilisateur un message clair au lieu d'une trace de pile.

UriInfo

[Link] 20
Afin d'obtenir des informations sur l'URI utilisé par l'agent utilisateur pour accéder à votre
ressource, vous pouvez utiliser l'annotation du paramètre @Context avec un paramètre UriInfo .
L'objet UriInfo a quelques méthodes qui peuvent être utilisées pour obtenir différentes parties de
l'URI.

//server is running on [Link]

// webapp is at /webapp, servlet at /webapp/servlet
@Path("class")
class Foo {

@GET
@Path("resource")
@Produces(MediaType.TEXT_PLAIN)
public Response getResource(@Context UriInfo uriInfo) {
StringBuilder sb = new StringBuilder();
[Link]("Path: " + [Link]() + "\n");
[Link]("Absolute Path: " + [Link]() + "\n");
[Link]("Base URI: " + [Link]() + "\n");
[Link]("Request URI: " + [Link]() + "\n");
return [Link]([Link]()).build();
}
}

sortie d'un GET sur [Link] :

Path: class/resource
Absolute Path: [Link]
Base URI: [Link]
Request URI: [Link]

Les sous-ressources

Parfois, pour des raisons organisationnelles ou autres, il est logique que votre ressource de
niveau supérieur renvoie une sous-ressource ressemblant à ceci. (Votre sous-ressource n'a pas
besoin d'être une classe interne)

import [Link];
import [Link];
import [Link];

@Path("items")
public class ItemsResource {

@Path("{id}")
public String item(@PathParam("id") String id) {
return new ItemSubResource(id);
}

public static class ItemSubResource {

private final String id;

public ItemSubResource(String id) {

[Link] = id;
}

[Link] 21
 @GET
@Produces("text/plain")
public Item item() {
return "The item " + id;
}
}
}

Convertisseurs de paramètres personnalisés

Voici un exemple d'implémentation de convertisseurs de paramètres personnalisés pour les

noeuds finaux JAX-RS. L'exemple montre deux classes de la bibliothèque [Link] de Java 8.

@Provider
public class ParamConverters implements ParamConverterProvider {
@Override
public <T> ParamConverter<T> getConverter(Class<T> rawType,
Type genericType,
Annotation[] annotations)
{
if (rawType == [Link])
return (ParamConverter<T>) new ParamConverter<LocalDate>() {
@Override
public LocalDate fromString(String value) {
return [Link](value);
}

@Override
public String toString(LocalDate value) {
return null;
}
};
else if (rawType == [Link])
return (ParamConverter<T>) new ParamConverter<MonthDay>() {
@Override
public MonthDay fromString(String value) {
int[] ddmm = [Link]([Link]("/"))
.mapToInt(Integer::parseInt)
.toArray();
return [Link](ddmm[1], ddmm[0]);
}

@Override
public String toString(MonthDay value) {
return null;
}
};
return null;
}
}

Liaison de nom

La liaison de noms est un concept qui permet de dire à un runtime JAX-RS qu'un filtre ou un
intercepteur spécifique ne sera exécuté que pour une méthode de ressource spécifique. Lorsqu'un
filtre ou un intercepteur est limité à une méthode de ressource spécifique, nous disons qu'il est lié

[Link] 22
à un nom . Les filtres et intercepteurs sans limitation sont appelés globaux .

Définition d'une annotation de liaison de nom

Les filtres ou les intercepteurs peuvent être affectés à une méthode de ressource à l'aide de
l'annotation @NameBinding . Cette annotation est utilisée comme annotation de méta pour les autres
annotations implémentées par l'utilisateur qui sont appliquées à un fournisseur et à des méthodes
de ressource. Voir l'exemple suivant:

@NameBinding
@Retention([Link])
public @interface Compress {}

L'exemple ci-dessus définit une nouvelle annotation @Compress qui est une annotation de liaison de
nom telle qu'elle est annotée avec @NameBinding . L'annotation @Compress peut être utilisée pour lier
des filtres et des intercepteurs aux points d'extrémité.

Relier un filtre ou un intercepteur à un noeud

final
Considérez que vous avez un intercepteur qui effectue la compression GZIP et que vous
souhaitez lier un tel intercepteur à une méthode de ressource. Pour ce faire, annotez la méthode
de ressource et l'intercepteur comme suit:

@Compress
public class GZIPWriterInterceptor implements WriterInterceptor {

@Override
public void aroundWriteTo(WriterInterceptorContext context)
throws IOException, WebApplicationException {
final OutputStream outputStream = [Link]();
[Link](new GZIPOutputStream(outputStream));
[Link]();
}
}

@Path("helloworld")
public class HelloWorldResource {

@GET
@Produces("text/plain")
public String getHello() {
return "Hello World!";
}

@GET
@Path("too-much-data")
@Compress
public String getVeryLongString() {

[Link] 23
 String str = ... // very long string
return str;
}
}

Le @Compress est appliqué à la méthode de ressource getVeryLongString() et à l'intercepteur

GZIPWriterInterceptor . L'intercepteur sera exécuté uniquement si une méthode de ressource avec
une telle annotation sera exécutée.

Dans l'exemple ci-dessus, l'intercepteur sera exécuté uniquement pour la méthode

getVeryLongString() . L'intercepteur ne sera pas exécuté pour la méthode getHello() . Dans cet
exemple, la raison est probablement claire. Nous aimerions compresser uniquement les données
longues et nous n'avons pas besoin de compresser la réponse courte de "Hello World!" .

La liaison de noms peut être appliquée à une classe de ressources. Dans l'exemple,
HelloWorldResource serait annoté avec @Compress . Cela signifie que toutes les méthodes de
ressources utiliseront la compression dans ce cas.

Notez que les filtres globaux sont exécutés toujours, même pour les méthodes de ressources qui
ont des annotations de liaison de noms.

Documentation
• @NameBinding annotation @NameBinding
• Documentation Jersey sur les filtres et intercepteurs

Lire Java RESTful Web Services (JAX-RS) en ligne: [Link]

ee/topic/7008/java-restful-web-services--jax-rs-

[Link] 24
Chapitre 5: L'API Javamail
Remarques
La page JavaMail du site Web Oracle le décrit comme suit

L'API JavaMail fournit une infrastructure indépendante de la plate-forme et

indépendante du protocole pour créer des applications de messagerie et de
messagerie. L'API JavaMail est disponible en tant que package facultatif pour une
utilisation avec la plate-forme Java SE et est également incluse dans la plate-forme
Java EE.

Le site principal du projet JavaMail est maintenant sur [Link] . De là, vous pouvez trouver les
javadocs pour de nombreuses versions des API, des liens vers les référentiels de code source,
des liens pour les téléchargements, des exemples et des astuces pour utiliser JavaMail avec
certains fournisseurs de services de messagerie populaires.

Examples
Envoi d'un email à un serveur de messagerie POP3

Cet exemple montre comment établir une connexion à un serveur de messagerie POP3
compatible SSL et envoyer un simple e-mail (texte uniquement).

// Configure mail provider

Properties props = new Properties();
[Link]("[Link]", "[Link]");
[Link]("[Link]", "[Link]");
// Enable SSL
[Link]("[Link]", "true");
[Link]("[Link]", "true");

// Enable SMTP Authentication

[Link]("[Link]","true");

Authenticator auth = new PasswordAuthentication("user", "password");

Session session = [Link](props, auth);

// Get the store for authentication

final Store store;
try {
store = [Link]("pop3");
} catch (NoSuchProviderException e) {
throw new IllegalStateException(e);
}

try {
[Link]();
} catch (AuthenticationFailedException | MessagingException e) {
throw new IllegalStateException(e);
}

[Link] 25
 try {
// Setting up the mail
InternetAddress from = new InternetAddress("sender@[Link]");
InternetAddress to = new InternetAddress("receiver@[Link]");

MimeMessage message = new MimeMessage(session);

[Link](from);
[Link]([Link], to);

[Link]("Test Subject");
[Link]("Hi, I'm a Mail sent with Java Mail API.");

// Send the mail

[Link](message);
} catch (AddressException | MessagingException e)
throw new IllegalStateException(e);
}

Mises en garde:

• Divers détails ont été câblés dans le code ci-dessus à des fins d'illustration.
• La gestion des exceptions n'est PAS un exemple. IllegalStateException est un mauvais
choix, pour commencer.
• Aucune tentative n'a été faite pour gérer les ressources correctement.

Envoyer un email simple

public class GoogleMailTest {

GoogleMailTest() {

public static void Send(final String username, final String password, String
recipientEmail, String title, String message) throws AddressException, MessagingException {
[Link](username, password, recipientEmail, "", title, message);
}

public static void Send(final String username, final String password, String
recipientEmail, String ccEmail, String title, String message) throws AddressException,
MessagingException {
[Link](new [Link]());
final String SSL_FACTORY = "[Link]";
// Get a Properties object
Properties props = [Link]();
[Link]("[Link]", "[Link]");
[Link]("[Link]", SSL_FACTORY);
[Link]("[Link]", "false");
[Link]("[Link]", "465");
[Link]("[Link]", "true");
[Link]("[Link]", "465");
[Link]("[Link]", "true");
[Link]("[Link]", "false");
Session session = [Link](props, null);
// -- Create a new message --
final MimeMessage msg = new MimeMessage(session);
// -- Set the FROM and TO fields --

[Link] 26
 [Link](new InternetAddress(username));
[Link]([Link], [Link](recipientEmail,
false));
[Link](null, [Link]());
if ([Link]() > 0) {
[Link]([Link], [Link](ccEmail,
false));
}
[Link](title);
[Link](message);
[Link](new Date());
SMTPTransport t = (SMTPTransport) [Link]("smtps");
[Link]("[Link]", username, password);
[Link](msg, [Link]());
[Link]();
}
// And use this code in any class, I'm using it in the same class in main method
public static void main(String[] args) {
String senderMail = "inzi769@[Link]"; //sender mail id
String password = "769inzimam-9771"; // sender mail password here
String toMail = "[Link]@[Link]"; // recepient mail id here
String cc = ""; // cc mail id here
String title = "Java mail test"; // Subject of the mail
String msg = "Message here"; // message to be sent

GoogleMailTest gmt = new GoogleMailTest();

try {
if ([Link]()) {
[Link](senderMail, password, toMail, title, msg);
} else {
[Link](senderMail, password, toMail, cc, title, msg);
}
} catch (MessagingException ex) {
[Link]([Link]()).log([Link], null, ex);
}
}

Envoyer un courrier HTML formaté

Vous pouvez utiliser le même exemple ci-dessus Envoyer un message simple avec un peu de
modification. Utilisez [Link]() au lieu de [Link]() et utilisez le type de contenu html
comme text/html .

vérifie ça

[Link](message, "text/html; charset=utf-8");

au lieu de

[Link](message);

Lire L'API Javamail en ligne: [Link]

[Link] 27
Chapitre 6: L'API WebSockets
Remarques
WebSocket est un protocole qui permet la communication entre le client et le serveur / noeud final
à l'aide d'une seule connexion TCP.

WebSocket est conçu pour être implémenté dans les navigateurs Web et les serveurs Web, mais
il peut être utilisé par n'importe quelle application client ou serveur.

Cette rubrique sur les API Java pour les Websockets développées par JSR 356 et intégrées aux
spécifications Java EE 7.

Examples
Créer une communication WebSocket

WebSocket fournit un protocole de communication duplex / bidirectionnel sur une seule connexion
TCP.

• le client ouvre une connexion à un serveur qui écoute une requête WebSocket
• un client se connecte à un serveur en utilisant un URI.
• Un serveur peut écouter les demandes de plusieurs clients.

Point de terminaison du serveur

Vous pouvez créer un entpoint de serveur WebSocket en annotant simplement un POJO avec
@ServerEndpoint . @OnMessage décore une méthode qui reçoit les messages entrants. @OnOpen peut
être utilisé pour décorer une méthode à appeler lorsqu'une nouvelle connexion d'un homologue
est reçue. De même, une méthode annotée avec @OnClose est appelée lorsqu'une connexion est
fermée.

@ServerEndpoint("/websocket")
public class WebSocketServerEndpoint
{

@OnOpen
public void open(Session session) {
[Link]("a client connected");
}

@OnClose
public void close(Session session) {
[Link]("a client disconnected");
}

@OnMessage
public void handleMessage(String message) {
[Link]("received a message from a websocket client! " + message);

[Link] 28
 }

Point de contact client

De manière similaire au point de terminaison du serveur, vous pouvez créer un point de

terminaison client WebSocket en annotant un POJO avec @ClientEndpoint .

@ClientEndpoint
public class WebsocketClientEndpoint {

Session userSession = null;

// in our case i.e. "[Link]

public WebsocketClientEndpoint(URI endpointURI) {
WebSocketContainer container = [Link]();
[Link](this, endpointURI);
}

@OnOpen
public void onOpen(Session userSession) {
[Link]("opening websocket");
[Link] = userSession;
}

@OnClose
public void onClose(Session userSession, CloseReason reason) {
[Link]("closing websocket");
[Link] = null;
}

@OnMessage
public void onMessage(String message) {
[Link]("received message: "+ message);
}

public void sendMessage(String message) {

[Link]("sending message: "+ message);
[Link]().sendText(message);
}
}

Codeurs et décodeur: WebSockets orientés objet

Grâce aux encodeurs et aux décodeurs, le JSR 356 propose des modèles de communication
orientés objet.

Définition des messages

Supposons que tous les messages reçus doivent être transformés par le serveur avant d'être
renvoyés à toutes les sessions connectées:

public abstract class AbstractMsg {

public abstract void transform();
}

[Link] 29
Supposons maintenant que le serveur gère deux types de messages: un message textuel et un
message basé sur un entier.

Les messages entiers multiplient le contenu par lui-même.

public class IntegerMsg extends AbstractMsg {

private Integer content;

public IntegerMsg(int content) {

[Link] = content;
}

public Integer getContent() {

return content;
}

public void setContent(Integer content) {

[Link] = content;
}

@Override
public void transform() {
[Link] = [Link] * [Link];
}
}

Message de chaîne précédant un texte:

public class StringMsg extends AbstractMsg {

private String content;

public StringMsg(String content) {

[Link] = content;
}

public String getContent() {

return content;
}

public void setContent(String content) {

[Link] = content;
}

@Override
public void transform() {
[Link] = "Someone said: " + [Link];
}
}

Codeurs et décodeur

Il existe un encodeur par type de message et un seul décodeur pour tous les messages. Les
encodeurs doivent implémenter l' [Link]<Type> lorsque Decoder doit implémenter
[Link]<Type> .

[Link] 30
Le codage est assez simple: à partir d'un message, la méthode d' encode doit générer une chaîne
au format JSON. Voici l'exemple pour IntegerMsg .

public class IntegerMsgEncoder implements [Link]<IntegerMsg> {

@Override
public String encode(IntegerMsg object) throws EncodeException {
JsonObjectBuilder builder = [Link]();

[Link]("content", [Link]());

JsonObject jsonObject = [Link]();

return [Link]();
}

@Override
public void init(EndpointConfig config) {
[Link]("IntegerMsgEncoder initializing");
}

@Override
public void destroy() {
[Link]("IntegerMsgEncoder closing");
}
}

StringMsg similaire pour la classe StringMsg . De toute évidence, les encodeurs peuvent être
factorisés via des classes abstraites.

public class StringMsgEncoder implements [Link]<StringMsg> {

@Override
public String encode(StringMsg object) throws EncodeException {
JsonObjectBuilder builder = [Link]();

[Link]("content", [Link]());

JsonObject jsonObject = [Link]();

return [Link]();
}

@Override
public void init(EndpointConfig config) {
[Link]("StringMsgEncoder initializing");
}

@Override
public void destroy() {
[Link]("StringMsgEncoder closing");
}

Le décodeur se déroule en deux étapes: vérifier si le message reçu correspond au format excepté
avec willDecode , puis transformer le message brut reçu en un objet avec decode :

la classe publique MsgDecoder implémente [Link] {

[Link] 31
 @Override
public AbstractMsg decode(String s) throws DecodeException {
// Thanks to willDecode(s), one knows that
// s is a valid JSON and has the attribute
// "content"
JsonObject json = [Link](new StringReader(s)).readObject();
JsonValue contentValue = [Link]("content");

// to know if it is a IntegerMsg or a StringMsg,

// contentValue type has to be checked:
switch ([Link]()) {
case STRING:
String stringContent = [Link]("content");
return new StringMsg(stringContent);
case NUMBER:
Integer intContent = [Link]("content");
return new IntegerMsg(intContent);
default:
return null;
}

@Override
public boolean willDecode(String s) {

// 1) Incoming message is a valid JSON object

JsonObject json;
try {
json = [Link](new StringReader(s)).readObject();
}
catch (JsonParsingException e) {
// ...manage exception...
return false;
}
catch (JsonException e) {
// ...manage exception...
return false;
}

// 2) Incoming message has required attributes

boolean hasContent = [Link]("content");

// ... proceed to additional test ...

return hasContent;
}

@Override
public void init(EndpointConfig config) {
[Link]("Decoding incoming message...");
}

@Override
public void destroy() {
[Link]("Incoming message decoding finished");
}

ServerEndPoint

[Link] 32
Le serveur EndPoint ressemble à la communication WebSocket avec trois différences principales:

1. Annotation ServerEndPoint a les encoders et decoders attributs

2. Les messages ne sont pas envoyés avec sendText mais avec sendObject

3. L'annotation OnError est utilisée. S'il y avait une erreur lors de willDecode , elle sera traitée
ici et les informations d'erreur seront renvoyées au client.

@ServerEndpoint (value = "/ webSocketObjectEndPoint", decoders = {[Link]},

encoders = {[Link], [Link]}) classe publique
ServerEndPoint {

@OnOpen
public void onOpen(Session session) {
[Link]("A session has joined");
}

@OnClose
public void onClose(Session session) {
[Link]("A session has left");
}

@OnMessage
public void onMessage(Session session, AbstractMsg message) {
if (message instanceof IntegerMsg) {
[Link]("IntegerMsg received!");
} else if (message instanceof StringMsg) {
[Link]("StringMsg received!");
}

[Link]();
sendMessageToAllParties(session, message);
}

@OnError
public void onError(Session session, Throwable throwable) {
[Link]().sendText([Link]());
}

private void sendMessageToAllParties(Session session, AbstractMsg message) {

[Link]().forEach(s -> {
[Link]().sendObject(message);
});
}

Comme j'étais très verbeux, voici un client JavaScript de base pour ceux qui veulent avoir un
exemple visuel. S'il vous plaît noter que ceci est un exemple de chat: toutes les parties
connectées recevront la réponse.

<!DOCTYPE html>
<html>
<head>
<title>Websocket-object</title>

[Link] 33
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<!-- start of BAD PRACTICE! all style and script must go into a
dedicated CSS / JavaScript file-->
<style>
body{
background: dimgray;
}

.container{
width: 100%;
display: flex;
}

.left-side{
width: 30%;
padding: 2%;
box-sizing: border-box;
margin: auto;
margin-top: 0;
background: antiquewhite;
}
.left-side table{
width: 100%;
border: 1px solid black;
margin: 5px;
}
.left-side table td{
padding: 2px;
width: 50%;
}
.left-side table input{
width: 100%;
box-sizing: border-box;
}

.right-side{
width: 70%;
background: floralwhite;
}
</style>

<script>
var ws = null;
[Link] = function () {
// replace the 'websocket-object' with the
// context root of your web application.
ws = new WebSocket("[Link]
object/webSocketObjectEndPoint");
[Link] = onOpen;
[Link] = onClose;
[Link] = onMessage;
};

function onOpen() {
printText("", "connected to server");
}

function onClose() {
printText("", "disconnected from server");
}

[Link] 34
 function onMessage(event) {
var msg = [Link]([Link]);
printText("server", [Link]([Link]));
}

function sendNumberMessage() {
var content = new Number([Link]("inputNumber").value);
var json = {content: content};
[Link]([Link](json));
printText("client", [Link](json));
}

function sendTextMessage() {
var content = [Link]("inputText").value;
var json = {content: content};
[Link]([Link](json));
printText("client", [Link](json));
}

function printText(sender, text) {

var table = [Link]("outputTable");
var row = [Link](1);
var cell1 = [Link](0);
var cell2 = [Link](1);
var cell3 = [Link](2);

switch (sender) {
case "client":
[Link] = "orange";
break;
case "server":
[Link] = "green";
break;
default:
[Link] = "powderblue";
}
[Link] = new Date().toISOString();
[Link] = sender;
[Link] = text;
}
</script>

<!-- end of bad practice -->

</head>
<body>

<div class="container">
<div class="left-side">
<table>
<tr>
<td>Enter a text</td>
<td><input id="inputText" type="text" /></td>
</tr>
<tr>
<td>Send as text</td>
<td><input type="submit" value="Send"
onclick="sendTextMessage();"/></td>
</tr>
</table>

<table>

[Link] 35
 <tr>
<td>Enter a number</td>
<td><input id="inputNumber" type="number" /></td>
</tr>
<tr>
<td>Send as number</td>
<td><input type="submit" value="Send"
onclick="sendNumberMessage();"/></td>
</tr>
</table>
</div>
<div class="right-side">
<table id="outputTable">
<tr>
<th>Date</th>
<th>Sender</th>
<th>Message</th>
</tr>
</table>
</div>
</div>
</body>
</html>

Le code est complet et a été testé sous Payara 4.1. L'exemple est purement standard (pas de
bibliothèque / framework externe)

Lire L'API WebSockets en ligne: [Link]

[Link] 36
Crédits
S.
Chapitres Contributeurs
No

Démarrer avec java- Barathon, Community, mylenereiners, Pablo Andrés Martínez

1
ee Vargas, Spyros K

Java Connector
2 M. A. Kishawy
Architecture (JCA)

Java Messaging
3 DimaSan, Setu, Stephen C
Service (JMS)

Cassio Mazzochi Molin, Daniel Käfer, efreitora, Eric Finn, Jeff

Java RESTful Web
4 Hutchins, Jesse van Bekkum, justderb, kann, mico, RobAu,
Services (JAX-RS)
sargue, Stephen C

5 L'API Javamail Inzimam Tariq IT, Johannes B, Stephen C, Stephen Leppik

6 L'API WebSockets Adrian Krebs, Al1, Stephen C

[Link] 37