import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections.CollectionUtils;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import fr.mylinkedin.entity.Formation;
import fr.mylinkedin.entity.Personne;
import fr.mylinkedin.entity.PosteOccupe;
import util.HibernateUtil;
public class Test {
public static void main(String[] args) {
HibernateUtil.initialize("projet_hibernate", "projet_hibernate");
SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Transaction tx;
Session session;
String testCase = args[0];
long t0 = new Date().getTime();
if (testCase.equals("EXEC1")) {
// Premi�re ex�cution, insertion de personnes et cr�ation de relations
// sur plusieurs niveaux
System.out
.println("################## EXEC 1 ###################");
session = sessionFactory.getCurrentSession();
tx = session.getTransaction();
tx.begin();
for (int i = 1; i <= 100; i++) {
if (i % 500 == 0) {
System.out.println(i);
}
Personne personnetest = new Personne();
personnetest.setNom("NomTest" + i);
personnetest.setPrenom("PrenomTest" + i);
personnetest.setCourriel("CourrielTest" + i);
session.persist(personnetest);
if (i % 49 != 0) {
for (int j = 1; j <= 49; j += 2) {
Personne personnetest2 = (Personne) session.get(
Personne.class, personnetest.getId() - j);
if (personnetest2 != null) {
personnetest.addRelationDirecte(personnetest2);
session.update(personnetest);
}
}
} else if (i % 49 == 0) {
Personne personnetest3 = (Personne) session.get(
Personne.class, personnetest.getId() - 50);
if (personnetest3 != null)
personnetest.addRelationDirecte(personnetest3);
}
session.update(personnetest);
}
tx.commit();
} else if (testCase.equals("EXEC2")) {
// Ex�cution des diff�rents chargements et strat�gies
System.out
.println("################## EXEC 2 ###################");
session = sessionFactory.getCurrentSession();
tx = session.getTransaction();
tx.begin();
//<set name="relationsDirectes" table="PERSONNE_RELATION_DIRECTE" cascade="save-update" lazy="true" fetch="join" >
//lazy="true" fetch="join"
//lazy="true" fetch="select"
//lazy="true" fetch="subselect"
//lazy="false" fetch="join"
//lazy="false" fetch="select"
//lazy="false" fetch="subselect"
Personne personne = (Personne) session.get(Personne.class, new Long(1));
tx.commit();
} else if (testCase.equals("TEST1")) {
// Retrouver toutes les relations de premier niveau d'une personne
System.out
.println("################## TEST 1 ###################");
session = sessionFactory.getCurrentSession();
tx = session.getTransaction();
tx.begin();
String courriel = "john.doe@nobody.com";
Personne personne = findPersonneByCourriel(session, courriel);
Set<Personne> relationsDirectes = personne.getRelationsDirectesR();
System.out.println("=> relations directes de "
+ personne.getCourriel() + " : ");
displayPersonneCollection(relationsDirectes);
tx.commit();
} else if (testCase.equals("TEST2")) {
// Retrouver toutes les relations de niveau sup�rieur � 1 d'une
// personne : Java Pur
System.out.println("################## TEST 2 ###################");
session = sessionFactory.getCurrentSession();
tx = session.getTransaction();
tx.begin();
// Personne dont on cherche les relations de niveau > 1 (soit les
// relations indirectes)
Personne personne = (Personne) session.get(Personne.class, new Long(1));
int niveau = 5;
Set<Personne> relationsFound = getRelationsIndirectes(personne,niveau);
System.out.println("=> toutes les relations de niveau "+niveau+" de "+ personne.getCourriel() + " : ");
displayPersonneCollection(relationsFound);
tx.commit();
}
else if (testCase.equals("TEST3")) {
// Retrouver toutes les relations de niveau sup�rieur � 1 d'une
// personne : SQL
System.out.println("################## TEST 3 ###################");
session = sessionFactory.getCurrentSession();
tx = session.getTransaction();
tx.begin();
// Personne dont on cherche les relations de niveau > 1
Personne personne = (Personne) session.get(Personne.class, new Long(1));
int niveau = 5;
@SuppressWarnings("unchecked")
List<Personne> relations = getRelationsIndirectesSqlNiveau(session, personne, niveau);
System.out.println("=> toutes les relations de niveau "+niveau+" de "+ personne.getCourriel() + " : ");
displayPersonneCollection(relations);
tx.commit();
} else if (testCase.equals("TEST4")) {
// Retrouver toutes les personnes liant directement ou indirectement
// deux personnes
// = intersection des relations directes et indirectes des deux
// personnes
System.out
.println("################## TEST 4 ###################");
session = sessionFactory.getCurrentSession();
tx = session.getTransaction();
tx.begin();
// Personnes dont on cherche les relations directes et indirectes
String courriel1 = "john.doe@nobody.com";
Personne personne1 = findPersonneByCourriel(session, courriel1);
String courriel2 = "jane.doe@nobody.com";
Personne personne2 = findPersonneByCourriel(session, courriel2);
int minDepth = 1;
@SuppressWarnings("unchecked")
List<Personne> relations1 = getRelationsIndirectesSQL(session,
personne1, minDepth);
@SuppressWarnings("unchecked")
List<Personne> relations2 = getRelationsIndirectesSQL(session,
personne2, minDepth);
@SuppressWarnings("unchecked")
List<Personne> liens = (List<Personne>) CollectionUtils
.intersection(relations1, relations2);
System.out
.println("=> toutes les personnes liant directement ou indirectement "
+ personne1.getCourriel()
+ " � "
+ personne2.getCourriel() + " : ");
displayPersonneCollection(liens);
tx.commit();
} else if (testCase.equals("TEST5")) {
// Retrouver toutes les relations potentielles d'une personne : Java Pur
System.out.println("################## TEST 5 ###################");
session = sessionFactory.getCurrentSession();
tx = session.getTransaction();
tx.begin();
int i = 0;
System.out.println(i++);
// Personne dont on cherche les relations directes et indirectes
Personne personne = (Personne) session.get(Personne.class, new Long(9));
System.out.println(i++);
// toutes les relations de niveau 2 et plus
Set<Personne> relations = getRelationsIndirectes(personne);
System.out.println(i++);
// toutes les personnes ayant suivi les m�mes formations
for (Formation form : personne.getFormationsSuiviesR()) {
for (Personne personneFormee : form.getPersonnesFormeesR()) {
if (!relations.contains(personneFormee)
&& personneFormee != personne) {
relations.add(personneFormee);
}
}
}
System.out.println(i++);
// toutes les personnes ayant travaill� dans les m�mes entreprises
for (PosteOccupe posteOccupe : personne.getPostesOccupesR()) {
for (PosteOccupe posteOccupeEntreprise : posteOccupe.getEntreprise().getPostesOccupesR()) {
if (!relations.contains(posteOccupeEntreprise.getPersonne())
&& posteOccupeEntreprise.getPersonne() != personne) {
relations.add(posteOccupeEntreprise.getPersonne());
}
}
}
System.out.println("=> tous les contacts potentiels de "
+ personne.getCourriel() + "(nb : "+relations.size() +") : ");
displayPersonneCollection(relations);
tx.commit();
} else if (testCase.equals("TEST6")) {
//Retrouver toutes les relations potentielles d'une personne : HQL et SQL
System.out.println("################## TEST 6 ###################");
session = sessionFactory.getCurrentSession();
tx = session.getTransaction();
tx.begin();
String courriel = "molly.doe@nobody.com";
Personne personne = findPersonneByCourriel(session, courriel);
//les contacts de niveau 2 et plus sont des contacts directs potentiels
List<Personne> personnes = (List<Personne>) getRelationsIndirectesSQL(session, personne, 2);
//les personnes travaillant ou ayant travaill� pour la m�me entreprise sont des contacts directs potentiels
@SuppressWarnings("unchecked")
List<Personne> personnesEntreprise = (List<Personne>) session.getNamedQuery("personne-lien-entreprise")
.setParameter("personne_id", personne.getId())
.list();
//les personnes ayant suivi les memes formations sont des contacts directs potentiels
@SuppressWarnings("unchecked")
List<Personne> personnesFormation = (List<Personne>) session.getNamedQuery("personne-lien-formation")
.setParameter("personne_id", personne.getId())
.list();
@SuppressWarnings("unchecked")
List<Personne> allRelations = (List<Personne>) CollectionUtils.union( CollectionUtils.union(personnes, personnesEntreprise),personnesFormation);
System.out.println ("=> tous les contacts potentiels de "+personne.getCourriel()+" : ");
displayPersonneCollection(allRelations);
tx.commit();
} else if (testCase.equals("TEST7")) {
//Retrouver toutes les personnes ayant consult� un profil de personne donn�e
System.out.println("################## TEST 7 ###################");
session = sessionFactory.getCurrentSession();
tx = session.getTransaction();
tx.begin();
String courriel = "bob.doe@nobody.com";
Personne personne = findPersonneByCourriel(session, courriel);
@SuppressWarnings("unchecked")
List<Personne> consultants = (List<Personne>) session.getNamedQuery("personne-consultant")
.setParameter("personne_id", personne.getId())
.list();
System.out.println("=> toutes les personnes ayant consult� le profil de "+personne.getCourriel()+" : ");
displayPersonneCollection(consultants);
tx.commit();
}
long t1 = new Date().getTime();
System.out.println("temps en millisecondes : "+(t1-t0));
System.out.println("memory used : "
+ Long.toString(Runtime.getRuntime().totalMemory()
- Runtime.getRuntime().freeMemory()));
}
@SuppressWarnings("unchecked")
private static List<Personne> getRelationsIndirectesSQL(Session session,
Personne personne, int minDepth) {
return (List<Personne>) session
.getNamedQuery("person-relation-graph-min")
.setParameter("personne_id", personne.getId())
.setParameter("min_depth", minDepth).list();
}
@SuppressWarnings("unchecked")
private static List<Personne> getRelationsIndirectesSqlNiveau(Session session,
Personne personne, int niveau) {
return (List<Personne>) session
.getNamedQuery("person-relation-graph")
.setParameter("personne_id", personne.getId())
.setParameter("min_depth", niveau)
.setParameter("max_depth", niveau).list();
}
private static void displayPersonneCollection(
Collection<Personne> personneCollection) {
for (Personne p : personneCollection) {
System.out.println("=> " + p.getCourriel());
}
}
private static Personne findPersonneByCourriel(Session session,
String courriel) {
return (Personne) session
.createQuery(
"select p from Personne p "
+ "where p.courriel = :courriel")
.setParameter("courriel", courriel).uniqueResult();
}
private static Set<Personne> getRelationsIndirectes(Personne personne) {
// Structure de donn�es de type file pour stocker les relations de
// niveau 1
// dont on veut retrouver les relations de niveau 1 et ainsi de suite
LinkedList<Personne> relationsToFind = new LinkedList<Personne>();
// on y ajoute les relations de niveau 1 de la personne
relationsToFind.addAll(personne.getRelationsDirectesR());
// Structure de donn�es pour stocker les relations de niveau 1
// dont on a d�j� retrouv� les relations de niveau 1
HashSet<Personne> relationsFound = new HashSet<Personne>();
while (!relationsToFind.isEmpty()) {
Personne relation = relationsToFind.pop();
// parmi les relations trouv�es, on ne garde pas la personne elle-meme
if (relation != personne
) {
relationsFound.add(relation);
}
// on parcourt ensuite les relations directes de la relation pour
// les ajouter � la file de recherche
Set<Personne> relations = relation.getRelationsDirectesR();
for (Personne per : relations) {
// on ajoute la personne � la file si elle ne fait pas partie
// des relations d�j� trouv�es
// si elle n'est pas d�j� dans la file de recherche
// si elle n'est pas parmi les relations directes de la personne
// Si elle n'est pas la personne elle-meme
if (!relationsFound.contains(per)
&& !relationsToFind.contains(per)
&& !personne.getRelationsDirectesR().contains(per)
&& per != personne) {
relationsToFind.addLast(per);
}
}
}
relationsFound.removeAll(personne.getRelationsDirectesR());
return relationsFound;
}
private static Set<Personne> getRelationsIndirectes(Personne personne, int niveau) {
int i = 0;
// Structure de donn�es de type file pour stocker les relations de
// niveau 1
// dont on veut retrouver les relations de niveau 1 et ainsi de suite
LinkedList<Personne> relationsToFind = new LinkedList<Personne>();
// on y ajoute les relations de niveau 1 de la personne
System.out.println(i++);
relationsToFind.addAll(personne.getRelationsDirectesR());
// Structure de donn�es pour stocker les relations de niveau 1
// dont on a d�j� retrouv� les relations de niveau 1
HashSet<Personne> relationsFound = new HashSet<Personne>();
// Structure de donn�es pour stocker les niveaux des relations
Map<Personne,Integer> relationsNiveau = new HashMap<Personne,Integer>();
for(Personne per : personne.getRelationsDirectesR()){
relationsNiveau.put(per,1);
}
System.out.println(i++);
while (!relationsToFind.isEmpty()) {
Personne relation = relationsToFind.pop();
//si l'on a atteint le niveau demand�, on sort de la boucle
if (relationsNiveau.get(relation) > niveau)
break;
// parmi les relations trouv�es, on ne garde pas les relations
// directe ni la personne elle-meme
if (relation != personne) {
relationsFound.add(relation);
}
System.out.println(i++);
// si le niveau de la relation est inf�rieur au niveau demand�,
//on doit parcourir ses relations directes
if (relationsNiveau.get(relation) < niveau){
// on parcourt relations directes de la relation pour
// les ajouter � la file de recherche
Set<Personne> relations = relation.getRelationsDirectesR();
for (Personne per : relations) {
// on ajoute la personne � la file si elle ne fait pas partie
// des relations d�j� trouv�es
// si elle n'est pas d�j� dans la file de recherche
// si elle n'est pas parmi les relations directes de la personne
// Si elle n'est pas la personne elle-meme
if (!relationsFound.contains(per)
&& !relationsToFind.contains(per)
&& !personne.getRelationsDirectesR().contains(per)
&& per != personne) {
relationsToFind.addLast(per);
relationsNiveau.put(per, relationsNiveau.get(relation)+1);
}
}
}
}
//on ne garde les relations que du niveau demand�.
Set<Personne> resultat = new HashSet<Personne>();
for(Personne per : relationsFound){
if(relationsNiveau.get(per).equals(niveau)){
resultat.add(per);
}
}
return resultat;
}
}