Framework Spring/Hello world!
= Hello world! avec Java =
Pour afficher dans la console "Hello world!", il suffit de modifier la méthode main de la manière suivante :
public static void main(String[] args) 
 System.out.println("Hello world!");
Cela donne le résultat suivant dans la console :
Ceci constitue un des programmes java les plus simples et ne fait pas appel à Maven ou Spring.
= Hello world! avec Spring =
L'une des fonctionnalités de Spring est de permettre l'injection de données dans des instances de classes et cela en dehors de cette classe. On peut ainsi créer une classe qui sera paramétrée par un fichier de configuration externe. Cette paramétrisation s'effectue via un bean, c'est-à-dire un conteneur que l'on met autour de la classe pour insérer des données. Il ne s'agit pas ici d'accéder à la classe qui s'effectue toujours de manière classique.
On peut créer un fichier Beans.xml qui va définir l'ensemble des beans, on le place à la racine du dossier source. On peut créer la classe en question ici MessageDisplayer dans le package principal :
Classe paramétrée.
La classe MessageDisplayer peut être définie comme un simple afficheur :
 package mainPackage;
 public class MessageDisplayer 
 private String message;
 public void setMessage(String message)
 this.message = message;
 public void displayMessage()
 System.out.println("message : " + message);
C'est la chaine message que Spring va permettre d'initialiser depuis l'extérieur.
Fichier de beans.
Dans ce fichier on définit un bean lié à la classe MessageDisplayer.
 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 <bean class = "mainPackage.MessageDisplayer">
 <property name = "message" value = "Hello world!"/>
 </bean>
 </beans>
On indique au départ qu'il s'agit d'un fichier xml avec le numéro de la norme ainsi que le type d'encodage, ici UTF-8 qui est le plus universel dans les années 2010. On définit ensuite une balise beans contenant l'ensemble des beans. L'espace de nom est défini par xmlns et permet d'avoir une référence pour les éléments du xml, il va de paire avec l’instance de schéma définie par xmlns:xsi. On donne ensuite les localisations en elles-mêmes du namespace et du xsd, XML Schema Definition, à utiliser, c'est ce dernier qui est le plus explicite.
Ensuite on arrive à la partie propre au projet c'est-à-dire l'ensemble des beans. On crée un bean avec comme classe celle qui nous intéresse ici. On peut spécifier de multiples autres paramètres notamment le nom via name. La chaîne message définie dans la classe MessageDisplayer reçoit un contenu "Hello world!" qui sera initialisé à la création de l'objet.
Lien entre configuration et bean.
Il faut modifier la classe principale pour faire une utilisation de MessageDisplayer :
 package mainPackage;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 public class MainClass 
 public static void main(String[] args) 
 ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("Beans.xml");
 MessageDisplayer messageDisplayer = (MessageDisplayer) classPathXmlApplicationContext .getBean("mainPackage.MessageDisplayer");
 messageDisplayer.displayMessage();
 classPathXmlApplicationContext.close();
On récupère tout d'abord le contexte d'application paramétrée avec le fichier de bean. On crée ensuite un MessageDisplayer initialisé avec les paramètres du bean, puis on appelle la fonction d'affichage. À la fin on ferme le contexte.
Résultat.
La sortie sur la console est la suivante :
On peut voir ici qu'on a des logs de Spring qui sont apparues.