<p:selectOneMenu id="choixCategories" value="#{controleur.numCategorieSelectionnee}" style="width:125px" onchange="submit()" valueChangeListener="#{controleur.maMethode()}">
                <f:selectItem itemLabel="-- Choisissez une catégorie --" itemValue="" />
                <f:selectItems itemValue="#{controleur.renvoyerNumCategorie(i)}" itemLabel="#{controleur.renvoyerSuperbe(i)}" var="i" value="#{controleur.daoCategorie.renvoyerToutes()}" />
                
            </p:selectOneMenu>

import javax.faces.convert.Converter;
...
@RequestScoped
@Named
public class ConverterEtudiant implements Converter {

    @Inject
    private DaoEtudiant daoe;
    
    @Override
    public Object getAsObject(FacesContext context, UIComponent component, String value) {
       //retourne un objet en fonction du champ html value (du num d'étudiant)
        return daoe.rechercher(Integer.parseInt(value));
    }

    @Override
    public String getAsString(FacesContext context, UIComponent component, Object value) {
        //remplit le champ "value=" du select html avec le numéro d'étudiant
        if(value==null){
            return "";
        }
        return String.valueOf(((Etudiant)value).getId());
    }
    
}

<p:selectOneMenu value="#{cdiControl.e}" converter="#{converterEtudiant}">
<f:selectItems var="etudiant" itemLabel="#{etudiant.getNom()}" value="#{cdiControl.daoEtudiant.getAll()}" />

<h:selectOneMenu id="categorieRecherche" value="#{controlRecherche.categorieRecherche}" required="true">
     <f:selectItem itemLabel="Toutes catégories" itemValue="" />
     <f:selectItems itemValue="#{nomCategorie}" var="nomCategorie" value="#{controlRecherche.listeNomCategorie}" />
</h:selectOneMenu>

package modele.access;

import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.ParameterExpression;
import javax.persistence.criteria.Root;
import modele.Eleve;

@Stateless
public class DaoEleve extends Dao<Eleve> {
//une méthode pour renvoyer toutes les banques dans une liste
	public List<Eleve> liretous()
	{
            return em.createNativeQuery("select * from eleve",Eleve.class).getResultList();
	}
        
	public Eleve rechercherparId(int id) //cherche avec la clef
	{
		return em.find(Eleve.class, id);
	}
        
        public List<Eleve> rechercherparNom(String nom) //cherche avec la clef
	{
            //Danger d'injection SQL !!
            return em.createNativeQuery("select * from eleve where nom='"+nom+"'",Eleve.class).getResultList();
	}

        //                             SQL natif
        //Avantage : connu et éprouvé
        //Inconvévient : Syntaxe peut varier légèrement selon le SGBD
        public List<Eleve> rechercherparNomParams(String nom) //cherche avec la clef
	{
            Query requete=em.createNativeQuery("select * from eleve where nom=?1",Eleve.class);
            requete.setParameter(1, nom);
            return requete.getResultList();
	}

        //                             JPQL    
        //Avantage : on reste purement en orienté objet
        //Inconvénient : difficile de passer des requêtes complexes
        public List<Eleve> rechercherparNomJPQL(String nom) //cherche avec la clef
	{
            Query requete=em.createQuery("select e from Eleve e where e.nom=:nom");
            requete.setParameter("nom", nom);
            return requete.getResultList();
	}
        
        
        //                             NamedQuery/NamedNativeQuery
        // -la syntaxe est légèrement vérifiée lors du démarrage de l'appli
        //  -regroupées dans les classes les concernants
        public List<Eleve> rechercherparNomNamed(String nom) //cherche avec la clef
	{
            Query requete=em.createNamedQuery("Eleve.findByNom");
            requete.setParameter("nom", nom);
            return requete.getResultList();
	}
                
        
        //                             APICriteria
        //Avantage : les erreurs de requêtes sont vues au moment de la compilation
        //Inconvénient : légèrement moins lisible
        public List<Eleve> rechercherparNomAPICriteria(String nom) //cherche avec la clef
	{
            CriteriaBuilder constructeurRequete = em.getCriteriaBuilder();
            CriteriaQuery<Eleve> requeteCriteria = constructeurRequete.createQuery(Eleve.class);
            Root<Eleve> c = requeteCriteria.from(Eleve.class);
            ParameterExpression<String> p = constructeurRequete.parameter(String.class);
            requeteCriteria.select(c).where(constructeurRequete.equal(c.get("nom"), nom));
            Query requete = em.createQuery(requeteCriteria);
            return requete.getResultList();
	}
	
}

<f:metadata>
    <f:viewAction action="#{controleur.afficherMsgConsole()}"/>
</f:metadata>

 <h:form id="mainForm">
            <p:growl id="growl" />

            <p:dataTable  id="bookDataTable" 
                          value="#{controlIndex.listTest}" 
                          var="produit" 
                          editable="true">
                <p:column headerText="ID" style="width : 200px ; font-size : 9px">#{produit.id}</p:column>
                <p:column headerText="Titre">
                    <p:cellEditor>
                        <f:facet name="output">#{produit.modele}</f:facet>
                        <f:facet name="input"><p:inputText value="#{produit.modele}" /></f:facet> 
                    </p:cellEditor>
                </p:column>
  
                <p:column headerText="Actions"><p:rowEditor /></p:column>

                <p:ajax event="rowEdit" 
                        update="bookDataTable :mainForm:growl" 
                        listener="#{controlEdition.onRowEdit}" />
            </p:dataTable>


        </h:form>

    @Size(max = 32)
    @Column(name = "nom")
    @Pattern(regexp="^[a-zA-Z]+$",message="Champs Alphabétique")
    private String nom;

Nom : <p:inputText id="nom" value="#{controlInscription.utilisateur.nom}" />
<p:message for="nom"/>

<?xml version='1.0' encoding='UTF-8'?>
<faces-config version="2.2"
              xmlns="http://xmlns.jcp.org/xml/ns/javaee"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-facesconfig_2_2.xsd">
    <protected-views>
    <url-pattern>/protected/welcomePrimefaces.xhtml</url-pattern>
    </protected-views>
</faces-config>

    <error-page>
    <exception-type>javax.faces.application.ProtectedViewException</exception-type>
        <location>/connexion.xhtml</location>
    </error-page>

    <login-config>
        <auth-method>BASIC</auth-method>
        <realm-name>realmTopCommerce2</realm-name>
            <form-login-config>
    </form-login-config>
    </login-config>
    <security-constraint>
        <web-resource-collection>
            <web-resource-name>Default secure pages</web-resource-name>
            <url-pattern>/protegeesParRealm/*</url-pattern>
        </web-resource-collection>
        <auth-constraint>
            <role-name>default_user_role</role-name>
        </auth-constraint>
    </security-constraint>
    <security-role>
        <role-name>default_user_role</role-name>
    </security-role>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE glassfish-web-app PUBLIC "-//GlassFish.org//DTD GlassFish Application Server 3.1 Servlet 3.0//EN" "http://glassfish.org/dtds/glassfish-web-app_3_0-1.dtd">
<glassfish-web-app error-url="">
  <security-role-mapping>
        <role-name>default_user_role</role-name>
        <group-name>utilisateur</group-name>
  </security-role-mapping>
</glassfish-web-app>

        <auth-method>FORM</auth-method>
        <realm-name>realmTopCommerce2</realm-name>
            <form-login-config>
        <form-login-page>/connexion.xhtml</form-login-page>
        <form-error-page>/logonError.jsp</form-error-page>
    </form-login-config>

    public String connexionRealm(){
        System.out.println("On va chercher "+pseudo);
        FacesContext context = FacesContext.getCurrentInstance();
        HttpServletRequest request = (HttpServletRequest)
                context.getExternalContext().getRequest();
        try {
            request.login(pseudo, motDePasse);
            utilisateur=daoUtilisateur.rechercherParPseudo(pseudo);
        } catch (ServletException e) {
            System.out.println("Echec du login");
        }
        return "index.xhtml";
    }

<security-constraint>   
    <display-name>ConstraintSSL</display-name>
    <web-resource-collection>
        <web-resource-name>protected</web-resource-name>
        <description/>
        <url-pattern>/*</url-pattern>
        <http-method>GET</http-method>
        <http-method>POST</http-method>
        <http-method>HEAD</http-method>
        <http-method>PUT</http-method>
        <http-method>OPTIONS</http-method>
        <http-method>TRACE</http-method>
        <http-method>DELETE</http-method>
    </web-resource-collection>

    <user-data-constraint>        
      <transport-guarantee>CONFIDENTIAL</transport-guarantee>
    </user-data-constraint>        

</security-constraint>

package controller;

import org.springframework.stereotype.Component;

import javax.servlet.*;
import java.io.IOException;

@Component
public class MonBeauFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("coucou du filter");
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {

    }
}

package dataAccess;

import java.io.Serializable;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

//Serializable car le Controleur est en SessionScoped
//si on peut sauvegarder le controleur durant toute une session, il faut pouvoir sauver les Dao
public class Dao<T> implements Serializable{
    //on ne créé pas d'entitymanagerfactory
    @PersistenceContext(unitName="testConnexionMysqlServeurAppliPU")
    protected EntityManager em; //pour que les autres classes dao puissent y accéder
    
    public void ecrire(T objetEntite)
    {
        //pas besoin de         em.getTransaction().begin();
        em.persist(objetEntite);
    }
    
    public void maj(T objetEntite)
    {
        em.merge(objetEntite);
    }
    
    public void supprimer(T objetEntite)
    {
        T objettrouve=em.merge(objetEntite); //il met à jour l'objet et le retourne
        em.remove(objettrouve); //supprime l'objet de la base
    }
}

package dataAccess;

import javax.ejb.Stateless;
import modele.Etudiant;

@Stateless //on doit déclarer qu'il s'agit d'un EJB, stateless en l'occurence NE PAS OUBLIER OU ERREUR " javax.persistence.TransactionRequiredException"
public class DaoEtudiant extends Dao  { 
    
    	public Etudiant rechercherparId(int id) //cherche avec la clef
	{
		return em.find(Etudiant.class, id);
	}	
}

package controleur;

import dataAccess.DaoEtudiant;
import java.io.Serializable;
import javax.enterprise.context.SessionScoped;
import javax.inject.Inject;
import javax.inject.Named;
import modele.Etudiant;

@SessionScoped
@Named
public class Controleur implements Serializable{
    private Etudiant e;
    
    @Inject //permet de récupérer le Dao créé automatiquement (on nous l'injecte)
    private DaoEtudiant daoEtudiant;
    
    public Controleur(){
        //Attention on peut pas demander directement au dao
        //e=daoEtudiant.rechercherparId(1);
    }

    public Etudiant getE() {
        return e;
    }

    public void setE(Etudiant e) {
        this.e = e;
    }

    public DaoEtudiant getDaoEtudiant() {
        return daoEtudiant;
    }

    public void setDaoEtudiant(DaoEtudiant daoEtudiant) {
        this.daoEtudiant = daoEtudiant;
    }
    
    public Etudiant getEtudiantParId(int id){
        return daoEtudiant.rechercherparId(id);
    }
    
    
}

import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

//Adresse JNDI créée dans glassfish qui pointe vers notre serveur SMTP
@Resource(name="jmail/mailcommande")
private Session session;	

        MimeMessage message = new MimeMessage(session);

        try {
            message.setFrom(new InternetAddress(session.getProperty("mail.from")));
            InternetAddress[] address = {new InternetAddress("bob@bob.com")};
            message.setRecipients(Message.RecipientType.TO, address);
            message.setSubject("SUJET DU MAIL");
            message.setSentDate(new Date());
            message.setText("TEXTE DU MAIL");
            Transport.send(message);
        } catch (MessagingException ex) {
            ex.printStackTrace();
        }

@Named
@Singleton
@Startup
public class Controleur3 {

    @Resource
    TimerService timerService;

    @PostConstruct
    public void init(){
        ScheduleExpression heureMessage = new ScheduleExpression().hour("16").minute("46");

        timerService.createCalendarTimer(heureMessage, new TimerConfig());
    }

    @Timeout 
    public void afficherMessage(Timer timer) {
        System.out.println("il est 16h40");
    }
}

public class EtudiantListener {
    @Resource
    private SessionContext ctx; // sessionContext permet d'acceder à la transaction ejb, on pourra faire un ctx.setRollbackOnly(); dessus par exemple pour la forcer à ne faire qu'un rollback

   @PostPersist //indique que la méthode suivante se déclenchera après l'insertion en base
   public void checknomprenom(Etudiant e) //l'objet en cours de traitement est injecté ici automatiquement
   {
        FacesContext context=FacesContext.getCurrentInstance();
        context.addMessage(null, new FacesMessage("Etudiant écrit")); //affichage d'un message
   }

}

@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE) //definition du type de stratégie d'héritage
@DiscriminatorColumn(name="typeuser",discriminatorType=DiscriminatorType.STRING) //definition de la colonne discriminante et du type de discriminant içi une chaine.
@DiscriminatorValue("non-admin") // valeur du discriminant ("non-admin")

@Table(name = "utilisateur")
@NamedQueries({
.......//les NamedQueries
public class Utilisateur implements Serializable {

@Entity
@DiscriminatorValue("admin") 
public class Admin extends Utilisateur{

+----+---------+-----------+
| id | nom     | typeuser  |
+----+---------+-----------+
| 13 | Morane  | non-admin |
| 14 | Adhmine | admin     |
| 17 | padmin  | non-admin |
+----+---------+-----------+

Class classeObjet = Class.forName ("MaJolieClasse"); //ici je met un string directement mais on pourrait le choper dans un fichier texte à part
MonInterface monBelObjetBienType= (MonInterface)objet.newInstance();

Injection XML

<?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-3.0.xsd">

   <bean id = "dao" class = "mon.paquet.ClasseImplementantDao"></bean>
   <bean id = "metier" class = "mon.paquet.ClasseMetier">
      <property name = "attributDao" ref = "dao"/>
   </bean>
</beans>

//dans src/main/resources/applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
     
    <context:component-scan base-package="com.monpackage" />
    
    <bean id="beanClasseQuiDitCoucou"    class="com.monpackage.ClasseQuiDitCoucou">
    <property name="coucou" value="Coucou tout le monde !"></property> <!-- l'attribut String coucou prendra la valeur "Coucou tout le monde !". Outre les strings on peut injecter des integer, des lists, etc.-->
    </bean>
     
</beans> 

//cette classe sera injectée et sa propriété "coucou" sera modifiée
package com.monpackage;

public class ClasseQuiDitCoucou {
	private String coucou;

	public String getCoucou() {
		return coucou;
	}

	public void setCoucou(String coucou) {
		this.coucou = coucou;
	}
}

package com.monpackage;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Hello world!
 *
 */
public class App 
{
	static String monAttribut;
    public static void main( String[] args )
    {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //on a besoin du xml pour savoir quel classe injecter. On génère en même temps un "contexte", une sorte d'environnement là seront exécutés nos beans.
        ClasseQuiDitCoucou instanceDeLaClasseQuiDitCoucou = (ClasseQuiDitCoucou) context.getBean("beanClasseQuiDitCoucou"); //instanciation de ce qui est référence par beanClasseQuiDitCoucou
        System.out.println(instanceDeLaClasseQuiDitCoucou.getCoucou());
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.monpackage" />

    <bean id="ClasseQuiDitCoucou"    class="com.monpackage.ClasseQuiDitCoucou">
        <property name="coucou" value="Coucou tout le monde !"></property>
    </bean>

    <bean id="bdao"    class="com.monpackage.DaoImpl">
    </bean>

    <bean id="metier" class="com.monpackage.MetierImpl">
        <property name="dao" ref="bdao"></property> <!-- ici on fait une reférence au bean déclaré plus haut mais on pourrait aussi directement déclarer le bean ici -->
    </bean>

</beans>

package com.monpackage;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main 
{
	static String monAttribut;
    public static void main( String[] args )
    {
    	ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");    	
  
        Metier instanceMetier = (Metier) context.getBean("metier");
        System.out.println(instanceMetier.calcul());
    }

}

package com.monpackage;

public interface Metier {
	double calcul();
}

package com.monpackage;

public class MetierImpl implements Metier {

	private IDao dao;
	public double calcul() {
			double nb=dao.getValue();
			return 2*nb;
	}
	public IDao getDao() {
		return dao;
	}
	public void setDao(IDao dao) {
		this.dao = dao;
	}

	
}

package com.monpackage;

public interface IDao {
	 double getValue();
}

package com.monpackage;

public class DaoImpl implements IDao {
		
	public double getValue() {
		return 5;
	}

}

<bean id="dao" abstract="true"> <!-- ne peut pas être instancié -->
    <property name="attribut" ref="valeur"/>
</bean>

<bean id="fooDao" class="daoEnfant" parent="dao">
<!-- il aura "attribut" -->
</bean>

@Value("${ma.propriete}")
private String maPropriete;

    @Value("classpath:mesxml/monxml.xml")
    private Resource xml;

Injection par annotation

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.monpackage, com.monautrepackage" />

</beans>

package com.monpackage;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.File;

public class Main
{
    static String monAttribut;
    public static void main( String[] args )
    {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        Metier instanceMetier = (Metier) context.getBean("Metier");
        System.out.println(instanceMetier.calcul());
    }
}

package com.monpackage;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component("Metier")
public class MetierImpl implements Metier {

    @Autowired
    private IDao dao;
    public double calcul() {
        double nb=dao.getValue();
        return 2*nb;
    }
    public IDao getDao() {
        return dao;
    }
    public void setDao(IDao dao) {
        this.dao = dao;
    }

}

AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(); //nouveau contexte
context.scan("com.monpackage"); //ici on indique les classe à scanner pour trouver les annotations
context.refresh();
context.close();

package com.monpackage.configuration;


import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.hibernate4.HibernateTransactionManager;
import org.springframework.orm.hibernate4.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
@EnableTransactionManagement
@ComponentScan({"com.monpackage"})
@PropertySource(value ={"classpath:application.properties"})
public class HibernateConfiguration {

    @Autowired
    private Environment environnement;

    @Bean
    public LocalSessionFactoryBean sessionFactoryBean(){
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setPackagesToScan(new String[] {"com.monpackage"});
        sessionFactory.setHibernateProperties(hibernateProperties());
        return sessionFactory;
    }
    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(environnement.getRequiredProperty("jdbc.driverClassName"));
        dataSource.setUrl(environnement.getRequiredProperty("jdbc.url"));
        dataSource.setUsername(environnement.getRequiredProperty("jdbc.username"));
        dataSource.setPassword(environnement.getRequiredProperty("jdbc.password"));
        return dataSource;
    }

    private Properties hibernateProperties(){
        Properties properties=new Properties();
        properties.put("hibernate.dialect", environnement.getRequiredProperty("hibernate.dialect"));
        properties.put("hibernate.show_sql", environnement.getRequiredProperty("hibernate.show_sql"));
        properties.put("hibernate.format_sql", environnement.getRequiredProperty("hibernate.format_sql"));
        properties.put("hibernate.hbm2ddl.auto", environnement.getRequiredProperty("hibernate.hbm2ddl.auto"));
        return properties;
    }

    @Bean
    public HibernateTransactionManager transactionManager(SessionFactory s){
        HibernateTransactionManager txManager=new HibernateTransactionManager();
        txManager.setSessionFactory(s);
        return txManager;
    }

}

Injection par code java

Fichiers properties

<bean id="mailProperties"
    class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="classpath:monBeauFichier.properties" />
</bean>

<bean id="mailSender" class="mon.paquet.MonBean">
    <property name="attributAChanger" value="${smtp.host}" />
</bean>

Forcer des paramètres via ligne de commande

-Dspring.datasource.url="jdbc:blablamadatasource" -Dspring.datasource.username="monuser" -Dspring.datasource.password="monpass" -Dspring.config.location="/chemin/vers/mon/fichier.properties"

Scope des beans

package com.monpackage;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.context.annotation.ScopedProxyMode;
import org.springframework.stereotype.Component;

@Scope("singleton")
@Component("Metier")
public class MetierImpl implements Metier {

    static int nbrVisiteur=0;

    @Autowired
    private IDao dao;

    public MetierImpl() {
        System.out.println("Lancement de mon bean");
    }

}

//Dans le main
Metier instanceMetier = (Metier) context.getBean("Metier"); //on appelle le bean une fois, "Lancement de mon bean" doit s'afficher
instanceMetier = (Metier) context.getBean("Metier"); //on l'appelle une deuxième fois, , "Lancement de mon bean" ne doit PAS s'afficher si on est en singleton. Il DEVRAIT s'afficher une seconde fois si on avais mis en @Scope("prototype")

Instanciation et injection

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext*.xml</param-value>
</context-param>

<listener>
   <listener-class>
        org.springframework.web.context.ContextLoaderListener
   </listener-class>
</listener> 

Spring Retry

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> <!-- equivalent de ClassPathXmlApplicationContext.... -->
    </listener>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>


    <!-- on lui dit de consulter dispatcher-servlet.xml si l'url commence par slash -->
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
      http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- On indique quel package scanner pour trouver les annotations-->
    <context:component-scan base-package="com.monpackage" />

    <!-- Ajoute le support des annotations -->
    <mvc:annotation-driven/>

    <!-- Indique où seront situées les vues -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/view/" /> 
        <property name="suffix" value=".jsp" />
    </bean>
    <!--  <mvc:resources..../>  pour les pages statiques-->

    <mvc:resources mapping="/resources/**" location="/WEB-INF/resources/"/>
</beans>

<?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 id="dao" class="com.monpackage.dao.CatalogueDaoImpl"></bean> <!-- définition d'un bean -->
    <bean id="metier" class="com.monpackage.metier.CatalogueMetierImpl">
        <property name="dao" ref="dao"></property>  <!-- injection d'un bean -->
    </bean>

</beans>

Installation sous Eclipse

Installation sous Netbeans

Exemple d'un CRUD simple (pas de BDD)

package com.monpackage.dao;

import org.jboss.logging.Logger;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.*;

@Component //indique que ça peut être injecté
public class CatalogueDaoImpl implements ICatalogueDao {
    private Map<String,Produit> produits=new HashMap<String,Produit>(); //pour l'exercice, on utilise pas hibernate mais une hashmap où chaque produit est lié à sa ref
    Logger logger= Logger.getLogger(CatalogueDaoImpl.class);

    @Override
    public void addProduit(Produit p){
        produits.put(p.getReference(),p);
    }

    @Override
    public Produit getProduit(String ref){
        return produits.get(ref);
    }

    @Override
    public List<Produit> getAllProduits(){
        Collection<Produit> prods = produits.values();
        return new ArrayList<Produit>(prods);
    }

    @Override
    public List<Produit> getProduits(String motCherche){  //On récupère chaque produit et hashmap et on renvoie une liste
        List<Produit> prods = new ArrayList<>();
        for(Produit p: produits.values()){
            if(p.getDesignation().indexOf(motCherche)>=0){ //...a condition que la string entrée existe dans la désignation.
                prods.add(p);
            }
        }
        return prods;
    }


    @Override

    public void updateProduit(Produit p){

        produits.put(p.getReference(), p);

    }

    @Override
    public void deleteProduit(String reference){ //on supprime de la hashmap en se basant sur la référence
        produits.remove(reference);
    }

    @Override
    @PostConstruct //se déclenchera dès que ce bean sera appelé
    public void init(){
        this.addProduit(new Produit("HP675","Ordinateur",100,10));
        this.addProduit(new Produit("AEP65","Ordinateur",100,10));
        this.addProduit(new Produit("AT980","Ordinateur",100,10));
    }
}

package com.monpackage.dao;

import java.util.List;

public interface ICatalogueDao { //on utilise une interface pour découpler le code

    void addProduit(Produit p);
    List<Produit> getProduits(String mc);
    void deleteProduit(String reference);
    void init();
    List<Produit> getAllProduits();
    void updateProduit(Produit p);
    Produit getProduit(String ref);
}

package com.monpackage.dao;

import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Positive;
import java.io.Serializable;


public class Produit implements Serializable { //le modèle

    @NotEmpty //on force reference à contenir quelque chose
    private String reference;
    private String designation;
    @Positive //le prix doit être positif
    private double prix;
    private int quantite;

    public Produit() { //il faut un constructeur vide pour pouvoir instancier un nouveau produit vide (qu'on va modifier puis insérer dans la liste)

    }

    public Produit(@NotEmpty String reference, String designation, double prix, int quantite) {
        this.reference = reference;
        this.designation = designation;
        this.prix = prix;
        this.quantite = quantite;
    }

    public String getReference() {
        return reference;
    }

    public void setReference(String reference) {
        this.reference = reference;
    }

    public String getDesignation() {
        return designation;
    }

    public void setDesignation(String designation) {
        this.designation = designation;
    }

    public double getPrix() {
        return prix;
    }

    public void setPrix(double prix) {
        this.prix = prix;
    }

    public int getQuantite() {
        return quantite;
    }

    public void setQuantite(int quantite) {
        this.quantite = quantite;
    }
}

package com.monpackage.metier;

import com.monpackage.dao.ICatalogueDao;
import com.monpackage.dao.Produit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class CatalogueMetierImpl implements ICatalogueMetier {

    @Autowired //Spring va chercher un objet de type ICatalogueDao, l'instancier et l'injecter
    private ICatalogueDao dao;

    public ICatalogueDao getDao() {
        return dao;
    }

    public void setDao(ICatalogueDao dao) {
        this.dao = dao;
    }

    @Override
    public void addProduit(Produit p){
        dao.addProduit(p);
    }

    @Override
    public Produit getProduit(String mc){
       return dao.getProduit(mc);
    }

    @Override
    public List<Produit> getAllProduits(){
        return dao.getAllProduits();
    }

    @Override
    public List<Produit> getProduits(String mc){
        return dao.getProduits(mc);
    }

    @Override
    public void deleteProduits(String mc){
         dao.deleteProduit(mc);
    }

    @Override
    public void updateProduit(Produit p){
         dao.updateProduit(p);
    }


}

package com.monpackage.metier;

import com.monpackage.dao.Produit;
import org.springframework.stereotype.Component;

import java.util.List;


public interface ICatalogueMetier {
    void addProduit(Produit p);
    Produit getProduit(String mc);
    List<Produit> getAllProduits();
    List<Produit> getProduits(String mc);
    public void deleteProduits(String mc);
    public void updateProduit(Produit p);
}

package com.monpackage.web;

import com.monpackage.Produit;
import com.monpackage.ICatalogueMetier;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import javax.validation.Valid;

@Controller
public class CatalogueController {
    @Autowired
    private ICatalogueMetier metier;

    @RequestMapping("/index") //si l'url correspond à /index
    public String index(Model model) {
        model.addAttribute("produit", new Produit()); //on va créer un nouveau produit et l'envoyer au modèle
        model.addAttribute("produits", metier.getAllProduits()); //on récupère la liste des produits et on l'envoie au modèle
        System.out.println("il faut get les produits !"+metier.getAllProduits());
        return "produits";
    }


    @RequestMapping("/saveProduit")
    public String save(@Valid Produit p, BindingResult bindingResult, Model model) { //bindingResult return faux si ya des erreurs sur les contraintes
        if(bindingResult.hasErrors()){
            model.addAttribute("produits", metier.getAllProduits());
            return "produits";
        }
        metier.addProduit(p);
        model.addAttribute("produit", new Produit());
        model.addAttribute("produits", metier.getAllProduits());
        return "produits";
    }

    @RequestMapping("/deleteProduit")
    public String delete(@RequestParam String ref, Model model){
        metier.deleteProduits(ref);
        model.addAttribute("produit", new Produit());
        model.addAttribute("produits", metier.getAllProduits());
        return "produits";
    }


    @RequestMapping("/editProduit")
    public String edit(@RequestParam String ref, Model model){
        model.addAttribute("produit", metier.getProduit(ref));
        model.addAttribute("produits", metier.getAllProduits());
        return "produits";
    }


}

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://www.springframework.org/tags/form" prefix="f" %>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Catalogue de Produits</title>
</head>
<body>
<div>
    <f:form modelAttribute="produit" method="post" action="saveProduit">
        <table>
            <tr>
                <td>Reference:</td>
                <td><f:input path="reference"/></td>
                <td><f:errors path="reference" cssClass="error"/></td>
            </tr>
            <tr>
                <td>Désignation:</td>
                <td><f:input path="designation"/></td>
                <td><f:errors path="designation" cssClass="error"/></td>
            </tr>
            <tr>
                <td>Prix :</td>
                <td><f:input path="prix"/></td>
                <td><f:errors path="prix" cssClass="error"/></td>
            </tr>
            <tr>
                <td>Quantité :</td>
                <td><f:input path="quantite"/></td>
                <td><f:errors path="quantite" cssClass="error"/></td>
            </tr>
        </table>
        <input type="submit" value="Save"/>
    </f:form>
</div>
<div>
    <p>${ produits }</p>
    <table>
        <tr>
            <th>REF</th>
            <th>DESIGNATION</th>
            <th>PRIX</th>
            <th>QUANTITE</th>
        </tr>

        <c:forEach items="${ produits }" var="p" varStatus="loop">

            <tr>
                <td>${p.reference}</td>
                <td>${p.designation}</td>
                <td>${p.prix}</td>
                <td>${p.quantite}</td>
                <td><a href="deleteProduit?ref=${ p.reference }">Delete</a></td>
                <td><a href="editProduit?ref=${ p.reference }">Edit</a></td>
            </tr>

        </c:forEach>
    </table>

</div>
</body>
</html>

Création de la base

DROP DATABASE IF EXISTS SPRINGMVCTEST;

CREATE DATABASE SPRINGMVCTEST CHARACTER SET utf8 COLLATE utf8_general_ci;
USE SPRINGMVCTEST;

CREATE TABLE utilisateur (
    id INT(6) auto_increment UNIQUE NOT NULL,
	nom VARCHAR(64)  NOT NULL,
    constraint PK_utilisateur PRIMARY KEY (id)
);

Préparation du projet

//Tout ce qui concerne Hibernate 5 :
antlr-2.7.7.jar
byte-buddy-1.8.17.jar
classmate-1.3.4.jar
dom4j-1.6.1.jar
hibernate-commons-annotations-5.0.4.Final.jar
hibernate-core-5.3.6.Final.jar
jandex-2.0.5.Final.jar
javassist-3.23.1-GA.jar
javax.activation-api-1.2.0.jar
javax.persistence-api-2.2.jar
jboss-logging-3.3.2.Final.jar
jboss-transaction-api_1.2_spec-1.1.1.Final.jar

//diver mysql
mysql-connector-java-5.1.47.jar

//spring mvc
spring-web-4.3.18.RELEASE.jar
spring-webmvc-4.3.18.RELEASE.jar
spring-webmvc-portlet-4.3.18.RELEASE.jar
spring-websocket-4.3.18.RELEASE.jar

//spring
aopalliance-1.0.jar
commons-logging-1.2.jar
spring-aop-4.3.18.RELEASE.jar
spring-aspects-4.3.18.RELEASE.jar
spring-beans-4.3.18.RELEASE.jar
spring-context-4.3.18.RELEASE.jar
spring-context-support-4.3.18.RELEASE.jar
spring-core-4.3.18.RELEASE.jar
spring-expression-4.3.18.RELEASE.jar
spring-instrument-4.3.18.RELEASE.jar
spring-instrument-tomcat-4.3.18.RELEASE.jar
spring-jdbc-4.3.18.RELEASE.jar
spring-jms-4.3.18.RELEASE.jar
spring-messaging-4.3.18.RELEASE.jar
spring-orm-4.3.18.RELEASE.jar
spring-oxm-4.3.18.RELEASE.jar
spring-test-4.3.18.RELEASE.jar
spring-tx-4.3.18.RELEASE.jar

Création de la classe modèle

package mon.beau.packag;

import javax.persistence.*;
import java.io.Serializable;
import static javax.persistence.GenerationType.IDENTITY;


@Entity
@Table(name="utilisateur")
public class Utilisateur implements Serializable { //le modèle

    @GeneratedValue(strategy = IDENTITY)
    @Id @Column(name="utilisateur")
    private int id;
    @Column(name="nom")
    private String nom;

    public Utilisateur() {
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }
}

Utilisation de la classe HibernateTemplate

package mon.beau.packag;
import org.springframework.orm.hibernate5.HibernateTemplate;
import java.util.*;

public class AccesBase {

    //C'est cet objet qui va nous permettre de manipuler notre base !
    HibernateTemplate template;

    public HibernateTemplate getTemplate() {
        return template;
    }

    public void setTemplate(HibernateTemplate template) {
        this.template = template;
    }
}

Création du controleur

package mon.beau.packag;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;


@Controller
public class IndexController {
    @Autowired
    private AccesBase accesBase;

    @RequestMapping("/insert")
    public String index(Model model) {

        System.out.println(accesBase.getTemplate().get(Utilisateur.class,1).getNom()); //on récupère un utilisateur en base... Vous devez en avoir un bien sûr

        //pour créer un utilisateur

        Utilisateur u=new Utilisateur();
        u.setNom("john");
        accesBase.getTemplate().save(u); //on met l'utilisateur en bases
        return "index";
    }

}

Injection des beans et configuration d'hibernate

<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:p="http://www.springframework.org/schema/p"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">


    <bean id="hibernateDataSource"
          class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/SPRINGMVCTEST" />
        <property name="username" value="mleveque" />
        <property name="password" value="password" />
    </bean>

    <bean id="mysessionFactory"  class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="hibernateDataSource"></property>
        <property name="annotatedClasses">
            <list>
                <value>mon.beau.packag.Utilisateur</value>
            </list>
        </property>

        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <!-- <prop key="hibernate.hbm2ddl.auto">create</prop> --> <!-- si on veut créer la base lors du lancement du programme, à enlever en prod... -->
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
            </props>
        </property>
    </bean>

    <bean id="template" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <property name="sessionFactory" ref="mysessionFactory"></property>
        <property name="checkWriteOperations" value="false"/> <!-- pour autoriser l'insertion de données -->
    </bean>

    <bean id="dao" class="mon.beau.packag.AccesBase">
        <property name="template" ref="template"></property>
    </bean>

</beans>

Autres fichiers

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
      http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="mon.beau.packag" />

    <mvc:annotation-driven/>

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/view/" />
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

package com.monpackage.coursspringboot.dao;

import com.monpackage.coursspringboot.entities.Etudiant;
import org.springframework.data.jpa.repository.JpaRepository;

public interface EtudiantRepository extends JpaRepository<Etudiant,Long> {}

package com.monpackage.coursspringboot.controllers;

import com.monpackage.coursspringboot.dao.EtudiantRepository;
import com.monpackage.coursspringboot.entities.Etudiant;
import com.monpackage.coursspringboot.entities.Section;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.web.bind.annotation.*;

//c'est pas très conseilleé d'avoir le service directement en restController, il vaudrait mieux découpler : un restController qui appelle un service derrière. Cela permettrait d'avoir la vérification du code métier dans le service+comme chaque service lance une transaction, les transactions seraient isolées.

@RestController
public class EtudiantRestService {
    @Autowired
    private EtudiantRepository etudiantRepository;
    @RequestMapping(value="/saveEtudiant", method= RequestMethod.POST)
    public Etudiant saveEtudiant(@RequestBody Etudiant etudiant){
        return etudiantRepository.save(etudiant);
    }

    @RequestMapping(value="/listEtudiant", method= RequestMethod.GET)
    public Page<Etudiant> listerEtudiant(int page, int size){
        return etudiantRepository.findAll(new PageRequest(page,size));
    }

    @RequestMapping(value="/getEtudiant/{id}")
    public Etudiant getSection(@PathVariable("id") Long id){
        return etudiantRepository.findById(id).get();
    }
}

{
        "nom":"Crasby",
        "prenom":"Bob",
        "dateNaissance":1540559249
}

package com.monpackage.coursspringboot;

import com.monpackage.coursspringboot.dao.EtudiantRepository;
import com.monpackage.coursspringboot.entities.Etudiant;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.List;

@SpringBootApplication
public class CoursspringbootApplication {

    public static void main(String[] args) {
        try {
            ApplicationContext ctx = SpringApplication.run(CoursspringbootApplication.class, args);
            EtudiantRepository etudiantRepository = ctx.getBean(EtudiantRepository.class);
            DateFormat df = new SimpleDateFormat("yyyy-mm-dd");
            etudiantRepository.save(new Etudiant("Bob", "Johnson", df.parse("1999-11-11")));
            etudiantRepository.save(new Etudiant("Bill", "Johnson", df.parse("1999-11-11")));

            List<Etudiant> etds = etudiantRepository.findAll();
            for (Etudiant e : etds) {

            }
        }catch(Exception e){}

    }
}

package com.monpackage.coursspringboot.entities;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import java.io.Serializable;
import java.util.Date;

@Entity
public class Etudiant implements Serializable {
    @Id
    @GeneratedValue
    private Long idEtudiant;
    private String nom;
    private String prenom;
    private Date dateNaissance;

    public Etudiant() {
    }

    public Etudiant(String nom, String prenom, Date dateNaissance) {
        this.nom = nom;
        this.prenom = prenom;
        this.dateNaissance = dateNaissance;
    }
//getters et setters
}

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springsec
spring.datasource.username=mleveque
spring.datasource.password=password
spring.jooq.sql-dialect=org.hibernate.dialect.MySQL5InnoDBDialect
sping.jpa.show-sql=false
spring.jpa.hibernate.ddl-auto=none
spring.jackson.serialization.FAIL_ON_EMPTY_BEANS=false

    @ApiOperation(httpMethod = "GET", value = "Mon beau webservice.", response = MonBeauDTO.class, responseContainer = "List")
    @ApiResponses(value = {
            @ApiResponse(code = HttpServletResponse.SC_OK, message = "OK") })
    @RequestMapping(value = "/std", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    @ResponseBody
    public List<MonBeauDTO> maBelleMethode(@ModelAttribute MesBeauxParametres mesBeauxParametres) throws MaBelleException {
        if (mesBeauxParametres.getMonPremierParam() != null) {
            //faire quelque chose selon ce param
        }else if (mesBeauxParametres.getMonDeuxiemeParam() != null){
            //faire quelque chose selon ce param
        }

@Stateless //indique qu'il s'agit d'un EJB
@Path("modele.produit") //le chemin pour y accéder (http://monsite/webresources/modele.produit)
public class ProduitFacadeREST extends AbstractFacade<Produit> {

    @PersistenceContext(unitName = "exoCDI_topCommercePartie2PU") //pour la création de l'entity manager
    private EntityManager em;

    public ProduitFacadeREST() {
        super(Produit.class);
    }

    @GET //que se passera-t-il si on fait un HTTP GET (càd si le navigateur appelle une page)
    @Path("{id}")
    @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON}) //les formats de fichier qui seront générés
    public Produit find(@PathParam("id") Integer id) {
        return super.find(id);
    }

    @DELETE
    @Path("{id}")
    public void remove(@PathParam("id") Integer id,@HeaderParam("key") String clef) {
        if(clef=="clefDeSuppression"){
            super.remove(super.find(id));
        }else{
            System.out.println("la clef n'est pas bonne.");
        }
    }

    @GET
    @Path("{id}/listeProduits")
    @Produces({MediaType.APPLICATION_JSON})
    public List<Produit>  listerProduitsCategories(@PathParam("id") Integer id) {
        return em.createNativeQuery("select * from produit where idCategorie="+id,Produit.class).getResultList();
        
    }

CloseableHttpClient client = HttpClientBuilder.create().build();
        HttpGet get = new HttpGet("http://localhost:8080/exoCDI_topCommercePartie2/webresources/modele.categorie"); // creation d'une requete
        
        
        HttpResponse response = null;
        try {
            response = client.execute(get); //execution de la requete
        } catch (IOException ex) {
            Logger.getLogger(ExoCDI_connexionATopCommerce.class.getName()).log(Level.SEVERE, null, ex);
        }
        StatusLine statusLine = response.getStatusLine();
        System.out.println("Code réponse du serveur :"+statusLine.getStatusCode());
        if(statusLine.getStatusCode() == 200) { // si réponse positive du serveur
            HttpEntity entity = response.getEntity(); //recuperation sous forme httpentity
            InputStream content = null;
            try {
                content = entity.getContent(); //passage du contenu dans inputStream
            } catch (IOException ex) {
                Logger.getLogger(ExoCDI_connexionATopCommerce.class.getName()).log(Level.SEVERE, null, ex);
            } catch (UnsupportedOperationException ex) {
                Logger.getLogger(ExoCDI_connexionATopCommerce.class.getName()).log(Level.SEVERE, null, ex);
            }
            
            
            Reader reader = new InputStreamReader(content); //objet de type reader pour reconstruire l'objet
            
            GsonBuilder gsonBuilder = new GsonBuilder(); //objet  factory à objet json
            
            Gson gson = gsonBuilder.create(); //creation du objet gson
            listeCategories = new ArrayList<Categorie>();
            listeCategories = Arrays.asList(gson.fromJson(reader, Categorie[].class)); //gson fromJson resconstruit des objets à partir d'un inputstream et des métadonées de type Class
            try {
                content.close(); //finalisation on ferme le flux
            } catch (IOException ex) {
                Logger.getLogger(Controleur.class.getName()).log(Level.SEVERE, null, ex);
            }

            System.out.println(listeCategories.get(0).getLibelle()); //on affiche la 1ere categorie
        }

SOAP

 <Button
     android:layout_height="wrap_content"
     android:layout_width="wrap_content"
     android:text="Cliquez-moi"
     android:onClick="MaSuperbeMethode" />

        //Un listener pour table
        View.OnClickListener clickButtonTable = new View.OnClickListener()
        {
            @Override
            public void onClick(View actuelView)
            {
                // traitement déclenché par le clic sur le bouton
                Intent intent = new Intent(MainActivity.this, TableConversions.class);
                startActivity(intent);
            }
        };

        //on l'attribue au bouton table
        buttonTable.setOnClickListener(clickButtonTable);

button = (Button) findViewById(R.id.button_id);
         button.setOnClickListener(new View.OnClickListener() {
             public void onClick(View v) {
                 // Perform action on click
             }
         });

package com.example.aka.exocdi_chronometre;

import android.app.Fragment;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class FragmentChrono extends Fragment {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        // Inflate le layout (càd récupère le XML et l'utilise comme vue)
        return inflater.inflate(R.layout.fragment_chrono, container, false);
    }


}

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <fragment android:name="com.example.aka.exocdi_chronometre.FragmentChrono"
        android:id="@+id/headlines_fragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
</FrameLayout>

package com.example.aka.exocdi_chronometre;

import android.content.Intent;
import android.os.Bundle;
import android.support.v4.app.FragmentActivity;
import android.support.v7.app.AppCompatActivity;
import android.view.View;


public class MainActivity extends FragmentActivity { //attention, si on extends FragmentActivity, il faudra "import android.support.v4.app.Fragment;" dans la classe du fragment

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Check that the activity is using the layout version with
        // the fragment_container FrameLayout
        if (findViewById(R.id.layoutQuiContientLeFragment) != null) {

            // However, if we're being restored from a previous state,
            // then we don't need to do anything and should return or else
            // we could end up with overlapping fragments.
            if (savedInstanceState != null) {
                return;
            }

            // Create a new Fragment to be placed in the activity layout
            FragmentChrono fragmentChrono = new FragmentChrono();

            // In case this activity was started with special instructions from an
            // Intent, pass the Intent's extras to the fragment as arguments
            fragmentChrono.setArguments(getIntent().getExtras());

            // Add the fragment to the 'fragment_container' FrameLayout
            getSupportFragmentManager().beginTransaction()
                    .add(R.id.layoutQuiContientLeFragment, fragmentChrono).commit();
        }
}

package com.example.aka.exocdi_chronometre;

import android.support.v4.app.Fragment; //ATTENTION, l'import a changé comparé au fragment statique
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class FragmentChrono extends Fragment {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment_chrono, container, false);
    }


}

FragmentHistorique fragmentHistorique = new FragmentHistorique();

FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();

// On ajoute le fragment appelé "fragmentHistorique" devant l'ancien fragment
transaction.add(R.id.layoutQuiContientLeFragment, fragmentHistorique);

//ajoute la transaction au "backstack" -ce qui nous permet de retrouver le précédent fragment avec back
transaction.addToBackStack(null); //on peut donner un nom à cet ajout au backstack pour le récupérer plus tard d'une autre façon qu'en appuyant sur back

//Effectue la transaction
transaction.commit();

Netbeans

@DatabaseField(id = true
private String name;
@DatabaseField(columnName = "passwd", canBeNull = false)
private String password;

package com.monpackage;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.*;

public class Main {


    public static void main(String[] args) {


       try {
           ServerSocket ss = new ServerSocket(8821);
           Socket s = ss.accept();
           DataInputStream dis=new DataInputStream(s.getInputStream());
           String str=(String)dis.readUTF();
           System.out.println("Message="+str);
           ss.close();
           System.out.println("Bye.");

       }catch(Exception e) {
           System.out.println(e.getMessage());
       }
    }
    

}

package com.monpackage;

import java.io.*;
import java.net.Socket;


public class Main {
    public static void main(String[] args) {
        try{
            Socket s=new Socket("localhost",8821);
            DataOutputStream dout=new DataOutputStream(s.getOutputStream());
            dout.writeUTF("Hello Server");
            dout.flush();
            dout.close();
            s.close();
        }catch(Exception e){System.out.println(e);}
    }
}

        try {
            PrintWriter sortie = new PrintWriter(new FileOutputStream("Etudiant.txt"));
            sortie.print(prenomEtudiant);
            sortie.print(nomEtudiant);
            sortie.print(note);
            sortie.close ();
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }

package afpa.cdi.euroFrancs;

import android.app.Activity;
import android.os.Bundle;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

public class MainActivity extends Activity
{
    private EditText francsEditText;
    private EditText eurosEditText;
    
    /** Méthode appelée lors de la création de l'activité. */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        
        //on indique qu'on utilise ressources/values/strings.xml
        setContentView(R.layout.main);
        
        // On récupère les EditText pour les modifier plus tard
        francsEditText = (EditText) findViewById(R.id.francsEditText);
        eurosEditText = (EditText) findViewById(R.id.eurosEditText);
        
        // On créé un listener qui va surveiller les changements sur le champ du texte
        TextWatcher surveilleModifTexteEuros = new TextWatcher()
        //une classe anonyme avec ses méthodes obligatoires
        {
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            }
            
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                //on converti l'autre champ
                if(eurosEditText.hasFocus()){
                    if(!eurosEditText.getText().toString().equals("") && !eurosEditText.getText().toString().equals(".")){
                        Long nombreConverti=Math.round(Double.valueOf(eurosEditText.getText().toString())*655);
                        francsEditText.setText(String.valueOf(nombreConverti.doubleValue()/100));
                    }else{
                        //si le champ euros est complètement effacé, il faut aussi effacer le champ francs 
                        francsEditText.setText("");
                    }
                }
            }
            
            public void afterTextChanged(Editable s) {
            }
        };
        
        TextWatcher surveilleModifTexteFrancs = new TextWatcher()
        {
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            }
            
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                if(francsEditText.hasFocus()){
                    if(!francsEditText.getText().toString().equals("") && !francsEditText.getText().toString().equals(".")){
                        Long nombreConverti=Math.round(Double.valueOf(francsEditText.getText().toString())*655);
                        eurosEditText.setText(String.valueOf(nombreConverti.doubleValue()/100));
                    }else{
                        //si le champ francs est complètement effacé, il faut aussi effacer le champ euros 
                        eurosEditText.setText("");                           
                    }
                }
            }
            
            public void afterTextChanged(Editable s) {
            }
        };

        // On lui attribue une méthode si il reçoit le focus
        eurosEditText.addTextChangedListener(surveilleModifTexteEuros);
        francsEditText.addTextChangedListener(surveilleModifTexteFrancs);
        
        
        //BOUTON RESET
        // On implémente l’interface OnClickListener
        OnClickListener clickButton = new OnClickListener()
        {
            @Override
            public void onClick(View actuelView)
            {
                // traitement déclenché par le clic sur le bouton
                // par exemple affichage d’une boite popup
                Toast.makeText(getBaseContext(), "Reset", Toast.LENGTH_LONG).show();
                francsEditText.setText("");
                eurosEditText.setText("");
            }
        };
        // On récupère le bouton cliqué
        Button bouton = (Button) findViewById(R.id.boutonReset);
        // On appelle sa méthode setOnClickListener()
        bouton.setOnClickListener(clickButton);
    }
    
    
}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/euros"
    />
<EditText android:id="@+id/eurosEditText"
android:layout_width="fill_parent"
android:layout_height="40dip"
android:ems="20"
android:layout_marginLeft="36dip"
android:inputType="numberDecimal"
/>
<TextView
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/francs"
    />
<EditText android:id="@+id/francsEditText"
android:layout_width="fill_parent"
android:layout_height="40dip"
android:ems="20"
android:layout_marginLeft="36dip"
android:inputType="numberDecimal"
/>
<Button
    android:id="@+id/boutonReset"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/reset"
/>
</LinearLayout>

//cecodepeut être dans un OnClickListener par exemple
Intent intent = new Intent(MainActivity.this, Resultat.class);
intent.putExtra("nomPourRecupererObjetEnvoye",objetEnvoye);  //on peut envoyer des paramètres de la façon suivante
startActivity(intent);

        super.onCreate(savedInstanceState);
        setContentView(R.layout.activite_principale);
        //la liste de choses qui seront affichées dans la liste view
        listTextes=new ArrayList();
        //on récupère la liste view
        maListView = (ListView) findViewById(R.id.maListeView);
        //on ajoute les éléments voulus
        listTextes.add("texte1");
        listTextes.add("texte2");
        listTextes.add("texte3");
        //il faut utiliser un adapter
        final ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, listTextes);
        //on met l'adapter sur la listeview
        maListView.setAdapter(adapter);

    <array name="Unite1">
        <item name="nom">Euros</item>
        <item name="valeurEnEuro">1</item>
    </array>
     <array name="Unite2">
        <item name="nom">Francs</item>
        <item name="valeurEnEuro">0.1524</item>
    </array>


    <array name="unitesUtilisees">
        <item>@array/Unite1</item>
        <item>@array/Unite2</item>
    </array>

        //on récupère le contenu du tableau listant les taux et les unites
        TypedArray unitesUtilisees = getResources().obtainTypedArray(R.array.unitesUtilisees);
        tabNomUnites = new String[unitesUtilisees.length()];
        tabTaux = new String[unitesUtilisees.length()];
        for (int i = 0; i < unitesUtilisees.length(); ++i) {
            //on récupère l'id de la ressource stockée à la position i du tableau unitesUtilisees
            //c'est à dire un tableau de string
            System.out.println("contenu de unitesUtilisees ?"+String.valueOf(getResources().obtainTypedArray(unitesUtilisees.getResourceId(i, 0))));
            System.out.println("Quelle unite ?"+String.valueOf(getResources().getResourceEntryName(unitesUtilisees.getResourceId(i, 0))));
            TypedArray soustabUnitesUtilisees=getResources().obtainTypedArray(unitesUtilisees.getResourceId(i, 0));
            System.out.println("Le contenu de soustabUnitesUtilisees :"+soustabUnitesUtilisees.toString());
            //on parcourt le tableau qui vient d'être renvoyé
            for (int j = 0; j < soustabUnitesUtilisees.length(); ++j) {
               System.out.println("Nom du champ :"+soustabUnitesUtilisees.getResourceId(j,99));
                System.out.println("Contenu du champ :"+String.valueOf((soustabUnitesUtilisees.getString(j))));
            }
        }

I/System.out: contenu de unitesUtilisees ?[3, 5, 2, 0, 0, 0, 16, 1, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0]
I/System.out: Quelle unite ?Unite1
I/System.out: Le contenu de soustabUnitesUtilisees :[3, 5, 2, 0, 0, 0, 16, 1, 2, 0, 0, 0]
I/System.out: Nom du champ :99
I/System.out: Contenu du champ :Euros
I/System.out: Nom du champ :99
I/System.out: Contenu du champ :1

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="Unite1">
        <item>Euros</item>
        <item>1</item>
    </string-array>
     <string-array name="Unite2">
        <item>Francs</item>
        <item>0.1524</item>
    </string-array>

    <array name="unitesUtilisees">
        <item>@array/Unite1</item>
        <item>@array/Unite2</item>

    </array>
</resources>

        TypedArray unitesUtilisees = getResources().obtainTypedArray(R.array.unitesUtilisees);
        tabNomUnites = new String[unitesUtilisees.length()];
        tabTaux = new String[unitesUtilisees.length()];
        for (int i = 0; i < unitesUtilisees.length(); ++i) {
            tabNomUnites[i]=getResources().getStringArray(unitesUtilisees.getResourceId(i, 0))[0];
            tabTaux[i]=getResources().getStringArray(unitesUtilisees.getResourceId(i, 0))[1];
        }

package com.example.aka.exocdi_chronometre;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;

public class HandlerThreadChrono extends Handler {

    private MainActivity mainActivity;

    public HandlerThreadChrono(MainActivity ma) {
        mainActivity=ma;
    }

    @Override
    public void handleMessage(Message msg) {

        mainActivity.mettreAJourChrono();
    }
}

package com.example.aka.exocdi_chronometre;

import android.os.Bundle;
import android.os.Message;

public class ThreadChrono implements Runnable {
    private HandlerThreadChrono handlerThreadChrono;
    private int i;

    public ThreadChrono(HandlerThreadChrono h) {
        handlerThreadChrono=h;
    }

    public void run(){
        //on contacte le chrono pour lui dire d'updater la vue
            handlerThreadChrono.sendEmptyMessage(0);
           // System.out.println("ThreadChrono, tour "+(i++));
        //on relance dans xxx millisecondes
        handlerThreadChrono.postDelayed(this,100);
    }

}

<?xml version="1.0" encoding="utf-8"?>
<!-- activity_screen_slide.xml -->
<android.support.v4.view.ViewPager
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/idDeMonPager"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentStatePagerAdapter;

public class MaClassePager extends FragmentStatePagerAdapter {
    private FragmentChrono fragmentChrono;
    private FragmentHistorique fragmentHistorique;

    public MaClassePager(FragmentManager fm) {
        super(fm);
        System.out.println("Constructeur du fragment");
        fragmentChrono=new FragmentChrono();
        fragmentHistorique=new FragmentHistorique();
    }

    @Override
    public Fragment getItem(int position) { //à la position X, on retourne un fragment ou un autre
        System.out.println("getItem dans le pager");
        if(position==0) {
            System.out.println("On retourne"+fragmentChrono);
            return fragmentChrono;
        }

        return fragmentHistorique;
    }

    @Override
    public int getCount() {
        return 2; //le nombre de pages dans le fragment
    }


    @Override
    public void notifyDataSetChanged() { //cette méthode est appelée quand on veut rafraichir les fragments
        super.notifyDataSetChanged();
        System.out.println("NotifyDatasetchanged dans le pager");
        fragmentHistorique.actualiserHistorique();
    }
}

private ViewPager viewPager;
private MaClassePager monInstanceDepager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.layout_du_pager);//on utilise le layout du pager
        viewPager=(ViewPager) findViewById(R.id.idDeMonPager);
        monInstanceDepager=new MaClassePager(getSupportFragmentManager());
        viewPager.setAdapter(monInstanceDepager);

package com.example.aka.testpager;


import android.support.v4.app.Fragment; //ATTENTION, l'import a changé comparé au fragment statique
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class Fragment1 extends Fragment {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment1, container, false);
    }


}

package com.example.aka.testpager;

import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentStatePagerAdapter;

public class MaClassePager extends FragmentStatePagerAdapter {


    public MaClassePager(FragmentManager fm) {
        super(fm);
    }

    @Override
    public Fragment getItem(int position) { //à la position X, on retourne un fragment ou un autre
        System.out.println("Position : "+position);
        switch (position) {
            case 0:
                return new Fragment1();
            case 1:
                return new Fragment2();
            default:
                return new Fragment1(); //il ne faut pas retourner null sinon crash
        }
    }

    @Override
    public int getCount() {
        return 2; //le nombre de pages dans le fragment
    }


    @Override
    public void notifyDataSetChanged() { //cette méthode est appelée quand on veut rafraichir les fragments
        super.notifyDataSetChanged();
    }
}

package com.example.aka.testpager;

import android.support.v4.view.ViewPager;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    private ViewPager viewPager;
    private MaClassePager monInstanceDepager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.layout_du_pager);
        viewPager=(ViewPager) findViewById(R.id.idDeMonPager);
        monInstanceDepager=new MaClassePager(getSupportFragmentManager());
        viewPager.setAdapter(monInstanceDepager);
    }
}

Application utilisant Apache httpclient

android {
...
    buildTypes {
       ...
    }
...
   useLibrary 'org.apache.http.legacy'
}

package com.example.aka.testrest;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Thread t=new Thread(new ThreadConnexion());
        t.start();
    }
}

package com.example.aka.testrest;

import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;

public class ThreadConnexion implements Runnable {

    @Override
    public void run() {
        System.out.println("Le threadConnexion run...");
        DefaultHttpClient httpclient = new DefaultHttpClient();
        try {
            HttpHost target = new HttpHost("192.168.122.1", 8080, "http");
            HttpGet getRequest = new HttpGet("/testWebServiceAndroid");
            System.out.println("On se connecte à " + target);
            HttpResponse httpResponse = httpclient.execute(target, getRequest);
            HttpEntity entity = httpResponse.getEntity();

            System.out.println("----------------------------------------");
            System.out.println(httpResponse.getStatusLine());
            System.out.println("----------------------------------------");

            if (entity != null) {
                System.out.println(EntityUtils.toString(entity));
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            httpclient.getConnectionManager().shutdown();
        }
    }
}

Rest

android {
...
    }
    buildTypes {
...
    }
    useLibrary 'org.apache.http.legacy'
}

dependencies {
...
    compile 'com.google.code.gson:gson:2.4'
...
}

package com.example.aka.testrest;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Thread t=new Thread(new ThreadConnexion());
        t.start();
    }
}

package com.example.aka.testrest;

public class Etudiant {
    private int id;
    private String nom;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }
}

package com.example.aka.testrest;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ThreadConnexion implements Runnable {

    @Override
    public void run() {
        System.out.println("Le threadConnexion run...");
        DefaultHttpClient httpclient = new DefaultHttpClient();
        try {
            HttpHost target = new HttpHost("192.168.122.1", 8080, "http");
            HttpGet getRequest = new HttpGet("/testWebServiceAndroid/webresources/modele.etudiant");
            System.out.println("On se connecte à " + target);
            HttpResponse httpResponse = httpclient.execute(target, getRequest);
            HttpEntity entity = httpResponse.getEntity();



            InputStream content = null;
            try {
                content = entity.getContent(); //passage du contenu dans inputStream
            } catch (IOException ex) {
            } catch (UnsupportedOperationException ex) {
            }


            Reader reader = new InputStreamReader(content); //objet de type reader pour reconstruire l'objet

            GsonBuilder gsonBuilder = new GsonBuilder(); //objet factory à objet json

            Gson gson = gsonBuilder.create(); //creation du objet gson
            List listeEtudiants = new ArrayList<Etudiant>();
            listeEtudiants = Arrays.asList(gson.fromJson(reader, Etudiant[].class)); //gson fromJson resconstruit des objets à partir d'un inputstream et des métadonées de type Class
            try {
                content.close(); //finalisation on ferme le flux
            } catch (IOException ex) {
            }
            System.out.println("Mon étudiant joli :"+((Etudiant)listeEtudiants.get(0)).getNom());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            httpclient.getConnectionManager().shutdown();
        }
    }
}

I/System.out: Le threadConnexion run...
I/System.out: On se connecte à http://192.168.122.1:8080
D/NetworkSecurityConfig: No Network Security Config specified, using platform default
I/OpenGLRenderer: Initialized EGL, version 1.4
D/OpenGLRenderer: Swap behavior 1
E/EGL_emulation: tid 19823: eglSurfaceAttrib(1174): error 0x3009 (EGL_BAD_MATCH)
W/OpenGLRenderer: Failed to set EGL_SWAP_BEHAVIOR on surface 0xa24d0840, error=EGL_BAD_MATCH
I/System.out: !!!!!!!!!!!!!! Content :org.apache.http.conn.EofSensorInputStream@860a409
I/System.out: Mon étudiant joli :Bob

package com.example.aka.webservicemeteo.access;

import android.os.Message;
import android.util.Log;

import com.example.aka.webservicemeteo.modele.WeatherObservation;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;

import org.json.JSONObject;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Arrays;
import java.util.List;

public class ThreadGetMeteo implements Runnable {

    private MonHandler monHandler;

    public ThreadGetMeteo(MonHandler monHandler) {
        this.monHandler = monHandler;
    }

    @Override
    public void run() {
        try {
            Log.i("suivi","Dans le ThreadGetMeteo, ouverture de l'url pour récupérer l'observation météo...");

            URL url = new URL("http://api.geonames.org/findNearByWeatherJSON?lat=47.316667&lng=5.016667&username=levmc");
            HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

            BufferedReader contenuWebRecu = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));
            //Log.i("suivi","STREAM RECU" + contenuWebRecu.readLine());


            String json = contenuWebRecu.readLine();
            Gson gson = new Gson();
            //on ne peut pas directement reconstruire un objet WeatherObservation car le webservice
            //renvoie un json avec WeatherObservation à la racine, c'est ballot
            //on va donc reconstruire dans une classe intermédiaire
            JsonObject jsonObject = gson.fromJson(json, JsonObject.class);
            //puis, depuis cette classe intermédiaire, on va récupérer tous les enfants de "weatherObservation"
            WeatherObservation weatherObservation  = gson.fromJson(((JsonObject)jsonObject.get("weatherObservation")), WeatherObservation.class);


            Log.i("suivi","Reconstruction de l'observation météo à partir du JSON reçu..."+weatherObservation);


             contenuWebRecu.close(); //finalisation on ferme le flux

            Log.i("suivi","Exemple de weatherobservation :"+weatherObservation);
            Log.i("suivi","Ville :"+weatherObservation.getStationName());
            Log.i("suivi","Température :"+weatherObservation.getTemperature());

            Message message=new Message();
            //on met l'objet weatherObservation dans le message à destination du handler
            message.obj=weatherObservation;
            //on envoie le message au handler
            monHandler.sendMessage(message);


        } catch (Exception e) {
            //il faudrait plutôt catcher différentes exceptions ici
            //"pas de réseau ?" "pas de réponse ?" "mauvaise réponse ?"
            Message message=new Message();
            message.obj=e.getLocalizedMessage().toString();
            //on envoie le message au handler
            monHandler.sendMessage(message);
            Log.i("suivi","Exception :"+e.getMessage());
        }finally {
            Log.i("suivi","Terminé !");
        }
    }
}

package com.example.aka.testpersothreads;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;

public class MonHandler extends Handler {

    private ActivitePrincipale activitePrincipale;

    public MonHandler(ActivitePrincipale ma) {
        activitePrincipale=ma;
        System.out.println("Creation du handler");
    }

    @Override
    public void handleMessage(Message msg) {
        System.out.println("Un message a été reçu : "+msg.toString());
        activitePrincipale.modifInterface();
    }


}

package com.example.aka.webservicemeteo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;

import com.example.aka.webservicemeteo.access.MonHandler;
import com.example.aka.webservicemeteo.access.ThreadGetMeteo;

public class ActivitePrincipale extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_activite_principale);

        MonHandler monHandler=new MonHandler(this);
        Thread t=new Thread(new ThreadGetMeteo(monHandler));
        t.start();
    }


    public void changerTexteCentralPar(String nouveauTexte) {
        TextView texteCentral= (TextView) findViewById(R.id.texteCentral);
        texteCentral.setText(nouveauTexte);
    }
}

Fonctionnement observable / observé

package petitTestRxJava;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.operators.observable.ObservableCreate;

public class maBelleClassePrincipale {

	public static void main(String[] args) {
		System.out.println("1) Début du programme, création de l'observable");
		Observable<String> observable = new ObservableCreate<String>(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("3) Envoi d'un message");
                emitter.onComplete();
            }
        });
		
        System.out.println("2) Milieu du programme, création d'un observer");
        Observer<String> observer = new Observer<String>() { //
            //il lui faut forcément les méthodes onNext, onError, onComplete car c'est ce que l'observable va appeler
            @Override
            public void onNext(String s) { 
                System.out.println("onNext " + s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                System.out.println("onComplete");
            }


           @Override
            public void onSubscribe(Disposable d) {
                System.out.println("onSubscribe");		
            }
        };
        
        observable.subscribe(observer); //on donne cet obsrvateur à l'observable, ce qui va déclencher l'envoi du message
     }
}

1) Début du programme
2) Milieu du programme
onNext 3) Envoi d'un message
onComplete

	public static void main(String[] args) {
		System.out.println("1) Début du programme");
        Observable<String> observable = Observable.create( //Création d'un observable.
                new ObservableOnSubscribe<String>(){
                    public void subscribe(ObservableEmitter<String> observableEmitteur){
                    	observableEmitteur.onNext("3) La belle data !"); //sous le capot, appelle en fait le onNext du "observer"
                    }
                }
            );
        System.out.println("2) Milieu du programme");
        observable.subscribe(laChaine-> System.out.println(laChaine)); //sous le capot, créé un "observer" en lui donnant la callback "laChaine-> System.out.println(laChaine)"
	}

public void subscribe(ObservableEmitter<String> monBeauSouscripteur){
...
    monBeauSouscripteur.onError(new Exception()); //appelle du onError du subscriber
...
    monBeauSouscripteur.onComplete(); //envoi

System.out.println("2) Milieu du programme");
observable
.doOnError(t -> {System.out.println("Exception reçue : " + t);})
.doOnComplete(() -> {System.out.println("Fin du programme");})
.subscribe( a-> System.out.println(a));

        observable.subscribe( //utilisation d'une méthode alternative pour lui filer les codes du...
        		a-> System.out.println(a), //...onNext()
        		t -> {System.out.println("Exception reçue : " + t);}, //...onError()
        		() -> {System.out.println("Fin du programme");} //...onSuccess()
        		);

Créer un observable, façon simple

package petitTestRxJava;

import io.reactivex.rxjava3.core.Observable;

public class maBelleClassePrincipale {

	public static void main(String[] args) {
        Observable.just("La belle data !").subscribe( obj -> System.out.println(obj)); //Affiche "La belle data !"
        Observable.just("a", "b", "c").subscribe( obj-> System.out.println(obj)); //Affiche a, b puis c
        Observable.fromIterable(new ArrayList<>(Arrays.asList(1,2,3))).subscribe( a-> System.out.println(a)); //Affiche 1, 2 puis 3
        Observable.range(1, 1_000_000).subscribe( obj-> System.out.println(obj)); //Affiche de un à un million
	}
}

Back pressure

Map

	List<String> mesBellesLettres = Arrays.asList("a", "b", "c");
        Observable.fromIterable(mesBellesLettres)
                                       //pour chaque élément on renvoi un observable avec une fonction appliquée sur l'émission
        .map(obj -> obj.toUpperCase()) //on pourrait aussi utiliser la méthode statique comme ceci : .map(String::toUpperCase)
        .subscribe( a-> System.out.println(a)); //(renvoie A, B puis C)

	List<String> mesBellesLettres = Arrays.asList("a", "b", "c");
        Observable.fromIterable(mesBellesLettres)
        .map(string -> { 
        	System.out.println("Transformation en majuscule !"); 
        	string.toUpperCase(); 
        	return string; //on renvoie un String et la fonction map() s'occupe de l'encapsuler dans un observable
        	}) 
        .subscribe( a-> System.out.println(a)); //cet observable on peut y souscrire ici
	}

flatMap

	public static void main(String[] args) {		
	    String[] loginInfo = {"utilisateur", "mot_de_passe"};
	    Observable.just(loginInfo)
	    .flatMap(obj -> seConnecter(obj))
	    .subscribe(obj-> System.out.println("code de retour : " + obj));
	}

	static Observable<Integer> seConnecter(String[] obj) {
	    System.out.println("LOG : Connexion avec " + obj[0] + " " + obj[1]);
	    //....imaginons qu'on appelle une fonction de connexion qui renvoie un numero (1 si réussie par exemple)
	    int retourResultatConnexion = 1;
	    return Observable.just(retourResultatConnexion);
	}

//Affiche :
//LOG : Connexion avec utilisateur mot_de_passe
//code de retour : 1

LOG : Connexion avec utilisateur mot_de_passe
Code de retour io.reactivex.rxjava3.internal.operators.observable.ObservableJust@60c6f5b

        .subscribe(obj-> {
        	obj.subscribe(obj2 -> System.out.println("Code de retour"  + obj2));        	
        });

static Observable<String> listerAchats(int numCommande) {
	String[] objetsDeLaCommande ={"fraises", "fromage blanc", "boudoirs", "papier toilette"}; 
    return Observable.fromArray(objetsDeLaCommande);
}

public static void main(String[] args) {		
    int numCommande = 123;
    
    System.out.println("Liste de la commande 123 :");
    
    Observable.just(numCommande)
    .flatMap(obj -> listerAchats(obj))
    .subscribe(obj-> System.out.println("-" + obj));
}

//Affiche :
//Liste de la commande 123 :
//-fraises
//-fromage blanc
//-boudoirs
//-papier toilette

zip

Observable<String> titreFilmObservable = Observable.just("Star Trek", "Ip Man");
Observable<String> genreFilmObservable = Observable.just("Science Fiction", "Action");

Observable<String> resultObservable = Observable.zip(titreFilmObservable, genreFilmObservable, (titre, genre) -> titre + "=" + genre);

resultObservable.subscribe( str -> System.out.println(str));

//Affiche :
//Star Trek=Science Fiction
//Ip Man=Action

Delay

subscribeOn

toBlocking

System.out.println("Debut");

Observable.just("La belle donnée !")
.subscribeOn(Schedulers.io()) //creation d'un nouveau thread
.delay(1000, TimeUnit.MILLISECONDS) //attente d'une seconde
//.toBlocking() //bloque le thread principal 
.subscribe( obj -> System.out.println("La donnée : " + obj)); //sans toBlocking() on ne verra jamais ça, car le thread principal s'arrête avant

//Thread.sleep(2000); //si on ne veut pas de toBlocking() on peut attendre manuellement que le thread Schedulers.io() se termine
System.out.println("Fin");

import javax.jms.*

//dans un init() par exemple, récupération du contexte :
    Hashtable<String, String> ht = new Hashtable<String, String>();
        ht.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.enterprise.naming.SerialInitContextFactory"); //ca dépend de votre serveur, weblogic, apache...
        ht.put(Context.PROVIDER_URL, "monbeauserver:5000");
        ht.put(Context.SECURITY_PRINCIPAL, "monlogin");
        ht.put(Context.SECURITY_CREDENTIALS, "monpass");
        try {
            ctx = new InitialContext(ht);
        } catch (NamingException e) {
            e.printStackTrace();
        }

//puis envoi de message au topic
      TopicConnectionFactory factory = (TopicConnectionFactory) ctx.lookup("MaConnectionFactory"); //le nom JNDI
      connection = factory.createTopicConnection("monlogin", "monpass");
      session = connection.createTopicSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);
      Message message = session.createTextMessage("coucou");
      TopicPublisher topicPublisher = session.createPublisher(((Topic)ctx.lookup("jndi/jms/remote/montopic")));
      topicPublisher.send(message);
      connection.close();

            NamingEnumeration<NameClassPair> list = ctx.list("");
            while (list.hasMore()) {
                System.out.println("-------->" + list.next().getName());
            }

			<plugin>
				<groupId>org.openjfx</groupId>
				<artifactId>javafx-maven-plugin</artifactId>
				<version>0.0.8</version>
				<id>linux-build</id>
				<phase>install</phase>
				<goals>
					<goal>jlink</goal>
				</goals>
				<configuration>
					<stripDebug>true</stripDebug>

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>mavenproject2</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    <!-- https://mvnrepository.com/artifact/net.java.dev.designgridlayout/designgridlayout -->
<dependencies>
    <dependency>
    <groupId>net.java.dev.designgridlayout</groupId> <!-- Identifie le groupe qui a créé designgridlayout. Pas obligé d'avoir un nom de groupe avec des points (junit ne le fait pas) mais en général on le fait -->
    <artifactId>designgridlayout</artifactId> <!-- le nom de la librairie -->
    <version>1.5</version> <!-- le groupid+le nom de la libraie permettent d'identifier une libraire mais il y a plusieurs versions, ici on précise celle qu'on veut -->
</dependency>
</dependencies>
</project>

        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-rs-client</artifactId>
            <version>3.0.0</version>
            <scope>provided</scope>
        </dependency>

(...) this determines what version of a dependency will be used when multiple versions of an artifact are encountered. (...) You can always guarantee a version by declaring it explicitly in your project's POM. (...) since Maven 2.0.9 it's the order in the declaration that counts: the first declaration wins.

<dependency>
    <groupId>idDuGroupe</groupId>
    <artifactId>maBelleLib</artifactId>
    <version>1.6</version>
    <scope>system</scope>
    <systemPath>${project.basedir}/libs/maBelleLib.1.6.jar</systemPath>
</dependency>

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>MonProjetJavaEE</groupId>
    <artifactId>MonProjetJavaEE</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>MonProjetJavaEE</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

[ERROR] No goals have been specified for this build. You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. 

    private List<List<String>> decouper(List<String> listeADecouper, int taille) {
        List<List<String>> listeDeListeDecoupees = new ArrayList<>();
        for (int i = 0; i <= listeADecouper.size(); i += taille) {//tant que i est plus petit que le nombre d'objets, on incrémente de i+la taille max
            //on fait une nouvelle liste en prenant les objets depuis le ième jusqu'à : soit i+taillemax, soit jusqu'au dernier
            //donc avec 15à éléments et taille à 100 : ième jusqu'à i+taillemax = de 0 à 100
            //ième jusqu'au dernier = de 100 à 150
            listeDeListeDecoupees.add(listeADecouper.subList(i, Math.min(i + taille, listeADecouper.size())));
        }
        return listeDeListeDecoupees;
    }

    public static long factoriserRecursivement(long n){
        if(n>1){
            return factoriserRecursivement(n-1)*n;
        }
        return 1;
    }

    public static void trierTableau(int[] tableauATrier) {
        int tampon=0;
        int tailleTour=tableauATrier.length-1;
        int nombreDeBoucle=0;

        //pour chaque élément du tableau
        for (int j = 0; j < tableauATrier.length-1; j++) {
            nombreDeBoucle++;
            System.out.println("-----");
            for (int i = 0; i < tailleTour; i++) { //on pourrait faire "for (int i = 0; i < ((tableauATrier.length-1)-j); i++) {" pour se passer de tailleTour
                nombreDeBoucle++;
                System.out.println(tableauATrier.length-1 + " vient-il après " + tableauATrier[i + 1] + " ?");
                System.out.println("Faut tester " + tableauATrier[i] + " par rapport à " + tableauATrier[i + 1]);
                if (tableauATrier[i] > tableauATrier[i + 1]) {
                    System.out.println("Oui ! On échange les 2 cases");
                    tampon = tableauATrier[i];
                    tableauATrier[i] = tableauATrier[i + 1];
                    tableauATrier[i + 1] = tampon;
                }else {
                    System.out.println("Non, on touche à rien.");
                }
                afficherTableau(tableauATrier);
            }
            tailleTour=tailleTour-1; //le plus grand élément vient d'être mis au bout du tableau, on a plus besoin de le parcourir entièrement (on pourrait mais on perdrait du temps)
        }
        System.out.println("Nombre de boucle : "+nombreDeBoucle);
        afficherTableau(tableauATrier);
    }

String nom = Optional.ofNullable(monObjet)
           .map(MonObjet::getMonAutreObjet)
           .map(MonAutreObjet::getNom)
           .orElse("");

Optional<String> op = Optional.of("kikoo");
op.filter(s->s.contains("a")).ifPresentOrElse(System.out::println, () -> System.out.println("La chaine ne contiens pas la lettre a"));

Lettre	Unicode	HTML
à	\u00e0	à
â	\u00e2	â
ä	\u00e4	ä
è	\u00e8	è
é	\u00e9	é
ê	\u00ea	ê
ë	\u00eb	ë
î	\u00ee	î
ï	\u00ef	ï
ô	\u00f4	ô
ö	\u00f6	ö
ù	\u00f9	ù
û	\u00fb	û
ü	\u00fc	ü
ç	\u00e7	ç
'       \u2019   

        File file = new File(getClass().getResource("/json/syntaxe_incorrecte.json").getFile());
        String content = new String(Files.readAllBytes(file.toPath()));
        System.out.println(content);

	String contenuDuFichierTexte = "";
	FileInputStream file = new FileInputStream("chemin/relatif"); //ou /chemin/absolu
    	try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(file, "UTF-8"));) {
        	String line = null;
        	while ((line = bufferedReader.readLine()) != null) {
        		contenuDuFichierTexte += line;
        	}
        } catch (IOException e) {
        	LOGGER.error(String.format("Cannot read file \"%s\"", file), e);
		}

{
    "attribut": "blah",
    "deuxiemeAttribut": "blabla",
    "tableau":[
               {
                  "valeurDuTableau": "valeur"
               },
               {
                  "valeurDuTableau": "encoreUneValeur"
               }
              ]
}

package mon.beau.package;

import ......

public class MonBeauDeserializer extends StdDeserializer<MonObjet> {

    public MonBeauDeserializer() {
        this(null);
    }

    public MonBeauDeserializer(Class<?> vc) {
        super(vc);
    }

    @Override
    public MonObjet deserialize(JsonParser jp, DeserializationContext ctxt)
            throws IOException, JsonProcessingException {
        JsonNode root = jp.getCodec().readTree(jp);
        MonObjet monObjet = new MonObjet();

        monObjet.setMonAttribut(root.get("attribut").asText());
        monObjet.setMonDeuxiemeAttribut(root.get("deuxiemeAttribut").asText());
        for (JsonNode leTableau : root.get("tableau")) {
            System.out.println(leTableau.get("valeurDuTableau").asText());
        }

        return monObjet;
    }
}

        ObjectMapper mapper = new ObjectMapper(); //mapper ordinaire de jackson
        SimpleModule module = new SimpleModule(); //un module qu'on va ajouter à ce mapper
        module.addDeserializer(MonObjet.class, new MonBeauDeserializer()); //ajout de deserializer comme module
        mapper.registerModule(module); //enregistrement du module auprès du mapper

        //et, enfin pour récupérer l'objet :
        MonObjet monObjet = mapper.readValue(contenuPage, MonObjet.class);

final static Logger logger = Logger.getLogger("monBeauLoggerDefiniDansLeXML"); //on peut aussi passer la classe
//plus tard dans le code :
logger.error("Une erreur s'est produite.", e);

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

<!-- Là où seront envoyés les logs : -->
      <!-- Dans la console -->
	<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern"
			    value="%d %p [%t] %C (%F:%L) - %m%n"/>
		</layout>
	</appender>
      <!-- Dans un fichier -->
    <appender name="RF" class="org.apache.log4j.RollingFileAppender">
        <param name="File" value="/chemin/du/log.log"/>
        <param name="MaxFileSize" value="3000KB"/>
        <param name="MaxBackupIndex" value="5"/>
		<layout class="org.apache.log4j.PatternLayout">
  		     <param name="ConversionPattern"
                            value="%d %p [%t] %C (%F:%L) - %m%n"/>
		</layout>
	</appender>
      
        <!-- Dans un autre fichier -->
	<appender name="mon2eAppender" class="org.apache.log4j.RollingFileAppender">
		<param name="maxFileSize" value="10MB" />
		<param name="maxBackupIndex" value="5" />
		<param name="File" value="/autre/chemin/pour/le/log.log"/>
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern"
				   value="%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n" />
		</layout>
	</appender>

        
        <!-- par défaut les logs iront là -->
	<root>
		<priority value="debug"/>
		<appender-ref ref="STDOUT"/>
	</root>

        <!-- on créé un logger -->
	<category name="nom.du.logger"> <!-- on met souvent le nom d'un package car ya une notion d'héritage mais pas obligé. -->
		<priority value="debug"/> <!-- Il écrira seulement debug et valeurs supérieures (info, warn, error, fatal, all) -->
		<appender-ref ref="RF"/>
	</category>

	<category name="nom.du.logger.enfant"> <!-- Il y a un héritage, tout ce qui sera écrit ici sera AUSSI écrit dans RF -->
		<priority value="debug"/>
		<appender-ref ref="mon2eAppender"/>  <!-- on écrit dans le 2e appender -->
	</category>

	<category name="nom.du.logger.enfantegoiste" additivity="false"> <!-- additivity élimine l'héritage -->
		<priority value="debug"/>
		<appender-ref ref="mon2eAppender"/>  <!-- on écrit dans le 2e appender -->
	</category>

public class MaBelleClasse {
    public static void main(String[] args) {
      //on peut accéder à cette classe depuis l'extérieur !
    }
}

Entrer dans la méthode main

Méthodes utilitaires sympa

Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Built-By: leCreateurDuManifest
Class-Path: conf/ lib/MaTresJolieLibrairieJava.1.2.3.4.jar lib/monAutr
 eTresJolieLibJava02.jar
Created-By: Apache Maven 3.3.9
Build-Jdk: 1.8.0_171
Main-Class: mon.beau.package.MaBelleClasse

connectorPort=23020
shutdownPort=23025
ajpPort=23029

    private static long getSuperDigit(String digit, int k) {
       //pour chaque caractere du string on convertit sa representation ("4") en int puis multiplie tout ensemble
       long superDigitTentative = digit.chars().mapToLong(Character::getNumericValue).sum();
       //additionner le resultat ((1+2+3)*3) revient au meme que dupliquer (1+2+3+1+2+3+1+2+3) 
       superDigitTentative*=k; //mais moins consommateur en resources
       if(superDigitTentative>9) {
        superDigitTentative = getSuperDigit(""+superDigitTentative, 1);
       }
       return superDigitTentative;
    }

    public static void fizzBuzz(int n) {
    // Write your code here
        for(int i=1;i<=n;i++) {
         if (i%3==0 && i%5==0) {
             System.out.println("FizzBuzz");
         }else if (i%3==0) {
             System.out.println("Fizz");
         }else if (i%5==0) {
             System.out.println("Buzz");
         }else {
             System.out.println(i);
         }
        }
    }

    public static void plusMinus(List<Integer> arr) {
        int positiveNumbers = (int) arr.stream().filter(n -> n>0).count();
        int negativeNumbers = (int) arr.stream().filter(n -> n<0).count();
        int zeroNumbers = (int) arr.stream().filter(n -> n==0).count();
        System.out.println(String.format("%.6f", (float)positiveNumbers/arr.size()));
        System.out.println(String.format("%.6f", (float)negativeNumbers/arr.size()));
        System.out.println(String.format("%.6f", (float)zeroNumbers/arr.size()));
    }

ArrayList<Integer> bigToSmall = new ArrayList<>(arr);
bigToSmall.sort((a,b) -> b-a);
        
System.out.print(bigToSmall.stream().skip(1L).collect(Collectors.summingLong(a -> a))); //saute le + grandm additionne les 4 petits
        
System.out.print(" ");
ArrayList<Integer> smallToBig = new ArrayList<>(arr);
smallToBig.sort((a,b) -> a-b);
System.out.print(smallToBig.stream().skip(1L).collect(Collectors.summingLong(a -> a))); //additionne les 4 grands

public static String timeConversion(String s) {
  LocalTime ldt = LocalTime.parse(s, DateTimeFormatter.ofPattern("hh:mm:ssa"));
  return ldt.format(DateTimeFormatter.ofPattern("HH:mm:ss"));
}

int a=1, b=9;
System.out.println("a vaut " + a + ", b vaut " + b);
int tmp; //la var temporaire

tmp=a;
a=b;
b=tmp;
System.out.println("a vaut " + a + ", b vaut " + b);

int a=1, b=9;
System.out.println("a vaut " + a + ", b vaut " + b);

a=b-a; //9-1=8
b=b-a; //9-8=1
a=a+b; //8+1=9
System.out.println("a vaut " + a + ", b vaut " + b);
//a vaut 1, b vaut 9
//a vaut 9, b vaut 1

int a=11, b=9;
System.out.println("a vaut " + a + ", b vaut " + b);

a=b-a; //9-11=-2
b=b-a; //9--2=11
a=a+b; //-2+11=9
System.out.println("a vaut " + a + ", b vaut " + b);
//a vaut 11, b vaut 9
//a vaut 9, b vaut 11

int[] monTableau = {2,6,3,3,2,9,6};
List<Integer> maListe = 
Arrays.stream(monTableau).mapToObj(a->a).collect(Collectors.toList()); //.boxed() au lieu de mapToObj(a->a) marche aussi
for(int i=0;i<monTableau.length;i++) {
	if(maListe.indexOf(maListe.get(i)) == maListe.lastIndexOf(maListe.get(i))) {
		System.out.println("Celui qui est seul" + maListe.get(i));
		break;
	}
}

     public static int lonelyinteger(List<Integer> a) {
         if(a.size()==1) {
             return a.get(0);
         }
        Integer toReturn = null;
      a.sort((j,k) -> j-k);
      
    for(int i=0;i<a.size()-1;i++) {
        System.out.println("test de "+ a.get(i));
        if(i>0 && a.get(i) != a.get(i-1) && a.get(i) != a.get(i+1)) {
            toReturn = a.get(i);
            System.out.println("vu !!!" + toReturn);
                        break;
        }
    }
    if(toReturn==null) {
        toReturn=a.get(a.size()-1);
    }
        return toReturn;
    }
    
}

package littleTests;

import java.util.Arrays;

class Solution {
    public static void main(String[] args) {
    	int[] monTableau = {1,2,3,4,5,6,7};
    	System.out.println("Mon tableau est " + Arrays.toString(monTableau));
    	for(int i=0;i<monTableau.length/2;i++) { //depuis l'index 0, jusqu'à la moitiée du tableau (car sinon on réinverserait après la moitié !!) 
    		int temp=monTableau[i];//on sauve pos0, puis pos1, puis pos2....
    		//(monTableau.length-1)-i sera egal à (8-1-0)=7, puis 6, puis 5....
    		monTableau[i] = monTableau[(monTableau.length-1)-i]; //pos0 prend la valeur de pos7, puis pos1=pos6...
    		monTableau[(monTableau.length-1)-i] = temp; //pos7 prend la valeur de pos0, puis pos6 la valeur de pos1...
    		System.out.println("Mon tableau devient " + Arrays.toString(monTableau));
    	}
    }
}

/*
Mon tableau est     [1, 2, 3, 4, 5, 6, 7]
Mon tableau devient [7, 2, 3, 4, 5, 6, 1]
Mon tableau devient [7, 6, 3, 4, 5, 2, 1]
Mon tableau devient [7, 6, 5, 4, 3, 2, 1]
*/

a b c d
e f g h
i j k l
m n o p

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

class Result {

    /*
     * Complete the 'minimumBribes' function below.
     *
     * The function accepts INTEGER_ARRAY q as parameter.
     */

    public static void minimumBribes(List<Integer> q) {
        int totalBribes=0;
        int posPrevue=1; // le chiffre qu'on s'attend a trouver `a ce stade de parcours du tableau
                                   // ce n'est pas forcement i ! Si i=0 mais qu'on vient juste 
                                   // de voir 2, on s'attendra a trouver 3 derriere
        int prevSiDecalageDeUn=2; // le chiffre qu'on s'attend a trouver s'il y a eu un decalage de un
        int prevSiDecalageDe2=3; //....un decalage de 2.
        for(int i=0;i<q.size();i++) {
            System.out.println("On teste la pos " + i + ", qui devrait etre " + posPrevue);
            if (posPrevue==q.get(i)) {
                System.out.println("Sa position semble coherente, on avance" + i);
                System.out.println("posPrevue passe de " + posPrevue + "a " + prevSiDecalageDeUn);
                posPrevue = prevSiDecalageDeUn;
                System.out.println("prevSiDecalageDeUn passe de " + prevSiDecalageDeUn + "a " + prevSiDecalageDe2);
                prevSiDecalageDeUn = prevSiDecalageDe2;
                System.out.println("prevSiDecalageDe2 ++");
                prevSiDecalageDe2++;
            } else if (prevSiDecalageDeUn==q.get(i)) {
                System.out.println("Ce n'est pas le cas, pot de vin detecte");
                totalBribes++;
                System.out.println("prevSiDecalageDeUn passe de " + prevSiDecalageDeUn + "a " + prevSiDecalageDe2);
                prevSiDecalageDeUn = prevSiDecalageDe2;
                System.out.println("prevSiDecalageDe2 ++");
                prevSiDecalageDe2++;
            } else if (prevSiDecalageDe2==q.get(i)) {
                System.out.println("Ce n'est pas le cas, double pot de vin detecte");
                totalBribes+=2;
                System.out.println("prevSiDecalageDe2 ++");
                prevSiDecalageDe2++;
            } else{
                System.out.println( "Too chaotic");
                return;
            }
        }
        System.out.println(totalBribes);

    }

}

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

        int t = Integer.parseInt(bufferedReader.readLine().trim());

        IntStream.range(0, t).forEach(tItr -> {
            try {
                int n = Integer.parseInt(bufferedReader.readLine().trim());

                List<Integer> q = Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
                    .map(Integer::parseInt)
                    .collect(toList());

                Result.minimumBribes(q);
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }
        });

        bufferedReader.close();
    }
}

1
5
2 1 5 3 4

class Solution {
    public int removeElement(int[] nums, int val) {
        int maxLengthToCheck = nums.length-1;
        for(int i=0;i<maxLengthToCheck;i++) {
            System.out.println("Checking pos " + i + ", there is " + nums[i] + " here.");
            if (nums[i] == val) { //le nombre courant est non-voulu
                System.out.println("Moving " + nums[i] + "...");
                int tmp;
                // on inverse le nombre courant (non-voulu) avec le dernier du tableau 
                tmp=nums[i];
                nums[i]=nums[maxLengthToCheck]; // attention ce dernier est peut etre non-voulu aussi, faudra verif
                nums[maxLengthToCheck]=tmp;
                // on sait que le dernier est non desire donc on s'arretera desormais a celui d'avant
                maxLengthToCheck--;
                //on reverif le nombre a la pos qu'on vient de verif, car le nombre de fin de tableau peut etre non-voulu lui aussi
                i--;
            }
        }
        
        System.out.println(Arrays.toString(nums));

        //bon la c'est juste une petite boucle pour compter les nombres voulus
        int numberOfWanted=0;
        for(int i=0;i<nums.length;i++) {
            if (nums[i] != val) {
                numberOfWanted++;
            }
        }
        System.out.println("numberOfWanted="+numberOfWanted);

        return numberOfWanted;
    }
}

class Solution {
    public int removeElement(int[] nums, int val) {
        int indexPourRemplacerTableau=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]!=val){
                System.out.println("il y a un nombre voulu a l'index " + i);
                System.out.println("le tableau etait   " + Arrays.toString(nums)); //3, 2, 2, 3
                nums[indexPourRemplacerTableau]=nums[i];
                System.out.println("le tableau devient " + Arrays.toString(nums)); //2, 2, 2, 3
                indexPourRemplacerTableau++;
            }
        }
        return indexPourRemplacerTableau;
    }
}

class Solution {
    public int removeDuplicates(int[] nums) {
     int compteurIndexNombresVoulus=1;
     int dernierNombre=nums[0];
     for(int i=1;i<nums.length;i++) {
        System.out.println(Arrays.toString(nums));
        System.out.println("on travaille sur " + nums[i]);

        System.out.println("le dernier nombre était " + dernierNombre + ", actuellement on a " + nums[i] );
        if (nums[i] != dernierNombre) {
             System.out.println("on prend !");
             nums[compteurIndexNombresVoulus] = nums[i];
            compteurIndexNombresVoulus++;
        } else {
            System.out.println("on n'en veut pas.");
        }
        dernierNombre = nums[i];
     }  
             //System.out.println(Arrays.toString(nums));

     return compteurIndexNombresVoulus; 
    }
}

class Solution {
    public int removeDuplicates(int[] nums) { //1,1,2
     int compteurIndexNombresVoulus=1; //on laisse le premier nombre
     for(int i=0;i<nums.length-1;i++) { //jusqu'a l'avant dernier
        System.out.println(Arrays.toString(nums));
        System.out.println("on travaille sur " + nums[i]);

        System.out.println(nums[i] + " est il plus petit que " + nums[i+1]);
        if(nums[i] < nums[i + 1]){
        System.out.println("on prend !"); //1 est plus petit que 2
             nums[compteurIndexNombresVoulus] = nums[i+1]; //on ajoute 2
            compteurIndexNombresVoulus++;
        }
     }  
     System.out.println(Arrays.toString(nums));

     return compteurIndexNombresVoulus; 
    }
}

class Solution {
    public int majorityElement(int[] nums) {
        HashMap<Integer, Integer> freqHshMap = new HashMap<>(); //une map nombre, frequence
        for (int i=0;i<nums.length;i++) { //pour chaque element
            int count = 0;
            for (int j=0;j<nums.length;j++) { // on compte l'integralite des elements identiques (O(n^2) dommage)
                if (nums[j] == nums[i]) {
                    System.out.println(nums[i] + " vu");
                    count++; // incremente un compteur quand on en trouve
                }
//                System.out.println(nums[i] + " apparait " + count + " fois ");
                freqHshMap.put(nums[i], count); //renseigne la hashmap
            } 
        }

//        System.out.print(freqHshMap);

        return Collections.max(freqHshMap.entrySet(), Map.Entry.comparingByValue()).getKey();

    }
}

class Solution {
    public int majorityElement(int[] nums) {
        HashMap<Integer, Integer> freqHshMap = new HashMap<>(); //une map nombre, frequence
        for (int i=0;i<nums.length;i++) { //pour chaque element
            int value = freqHshMap.getOrDefault(nums[i], 0); //on va utiliser la valeur dans la hashmap si elle existe, zero sinon
            freqHshMap.put(nums[i], value + 1); //a cette valeur on rajoute 1
        }

        System.out.println(freqHshMap);

        return Collections.max(freqHshMap.entrySet(), Map.Entry.comparingByValue()).getKey();

    }
}

class Solution {
    public int majorityElement(int[] nums) {
      Arrays.sort(nums);
      return nums[(nums.length/2)];  
    }
}

class Solution {
    public int maxProfit(int[] prices) {
        int bestDiff=0;
        for(int i=0;i<prices.length;i++) { // pour chaque jour
            for(int j=i+1;j<prices.length;j++) { // on compare avec les jours suivants
                int diffOfThisIteration=prices[j]-prices[i];
                //System.out.println("Diff achat a " + prices[i] + " et vente a " + prices[j] + "=" + diffOfThisIteration);
                if(diffOfThisIteration>0 && diffOfThisIteration>bestDiff) {
                    bestDiff = diffOfThisIteration;
                }
            }
        }
        return bestDiff;
    }
}

class Solution {
    public int maxProfit(int[] prices) {
        int lowestPricePos=0; //La pos ou se trouve le meilleur prix
        int highestPricePos=1; //La pos ou se trouve le pire prix
        int bestProfit = 0;  //Le meilleur profit
        for(int i=0;i<prices.length-1;i++) {
            System.out.println("Day " + i);

            if (prices[i] < prices[lowestPricePos]) { //si le prix du jour est inferieur a celui qu'on a sauve
                lowestPricePos = i; //ca devient le nouveau plus bas
                System.out.println("New lowest price: " + prices[lowestPricePos]);
                highestPricePos = lowestPricePos; // le plus haut prix on peut l'oublier vu qu'on s'interesse juste au futur
                                                  // on a deja le profit possible en memoire de toute facon donc on peut oublier
                                                  // le jour du plus haut prix
            }

            //System.out.println("Comparing " + prices[i+1] +" and "+ prices[highestPricePos]);
            if (prices[i+1] >= prices[highestPricePos]) {
                highestPricePos = i+1;
                //System.out.println("New highest price: " + prices[highestPricePos]);
            }
            if (lowestPricePos<highestPricePos && (prices[highestPricePos] - prices[lowestPricePos])>bestProfit ) {
                profit = prices[highestPricePos] - prices[lowestPricePos];
                //System.out.println("Best profit, buy day" + lowestPricePos + ", sell day " + highestPricePos + ", earn "+ bestProfit );

            }
        }
        return profit;
    }
}