Publicité

Rappel :

JUnit définit 3 classes principales:

TestCase qui est une classe de test. Chaque classe de test dérive de TestCase qui elle-même dérive de la classe Test qui est une classe de test. Chaque classe de test dérive de qui elle-même dérive de la classe .

TestSuite qui est un ensemble de tests qui dérive de la classe Test et qui contient des instances de la classe Test . Elle peut donc contenir des TestCase ou d'autres TestSuite ( Design Pattern "Composite") qui est un ensemble de tests qui dérive de la classe et qui contient des instances de la classe Test . Elle peut donc contenir des TestCase ou d'autres TestSuite ( "Composite")

TestRunner qui permet de lancer l'exécution d'une liste de Test. qui permet de lancer l'exécution d'une liste de Test.

Pour utiliser ce framework, il suffit donc d'écrire des classes de test dérivées de TestCase, placer une instance de chaque test dans une hiérarchie de TestSuite et enfin donner le tout à un TestRunner pour qu'il l'exécute.

Les méthodes de test

Dans toutes les précédentes versions, Junit utilisait la réflexion et les règles de nommage Sun pour localiser les méthodes de test.

import junit.framework.TestCase;

public class CalculerSalaireTest extends TestCase {

private int salaireMensuel = 1500 ;

private int prime = 5000;

public void testCalculerSalaireAnnuel() {

int salaireAnnuel = salaireMensuel *12 + prime;

assertEquals(23000, salaireAnnuel);

}

}

Dans JUnit 4, les tests sont identifies par l’annotation suivante: @Test

import org.junit.Test;

import junit.framework.TestCase;

public class CalculerSalaireTest extends TestCase {

private int salaireMensuel = 1500 ;

private int prime = 5000;

@Test void testCalculerSalaireAnnuel() {

int salaireAnnuel = salaireMensuel *12 + prime;

assertEquals(23000, salaireAnnuel);

}

}

L’avantage de l’annotation @Test est que vous n’avez plus besoin de nommer vos méthodes testNomDeMaMethode().

Du coup il est possible de renommer les fonctions de test de la manière que l’on veut.

import org.junit.Test;

import junit.framework.TestCase;

public class CalculerSalaireTest extends TestCase {

private int salaireMensuel = 1500 ;

private int prime = 5000;

@Test void SalaireAnnuel() {

int salaireAnnuel = salaireMensuel *12 + prime;

assertEquals(23000, salaireAnnuel);

}

}

Il n’est plus nécessaire d’étendre la classe TestCase pour avoir une classe de test. L’annotation @Test et l’import de la classe d’assertion (junit.Assert) suffit pour pouvoir utiliser les nombreuses methodes assertXXX().

import org.junit.Assert;

public class CalculerSalaireTest{

private int salaireMensuel = 1500 ;

private int prime = 5000;

@Test void salaireAnnuel() {

int salaireAnnuel = salaireMensuel *12 + prime;

assertEquals(23000, salaireAnnuel);

}

}

YoIl est aussi possible d’utiliser la notion d’import statique du JDK 1.5.

 

import static org.junit.Assert.assertEquals;

public class CalculerSalaireTest{

private int salaireMensuel = 1500 ;

private int prime = 5000;

 

@Test void salaireAnnuel() {

int salaireAnnuel = salaireMensuel *12 + prime;

assertEquals(23000, salaireAnnuel);

}

}

Cette approche permet de mieux tester les méthodes protected car la classe de test peut étendre la classe à tester.

 

 

 

 

 

 

Commons Configuration est une API qui permet de charger des données de configuration multi-sources :

  • PropertiesConfiguration : à partir d'un fichier properties
  • BaseConfiguration : configuration sous forme d'objet.
  • XMLConfiguration : recupérer des config XML
  • JNDIConfiguration : recuperer des config à partir de JNDI
  • SystemConfiguration recuperer des proprietes systeme
  • ConfigurationConverter prends un  java.util.Properties ou o.a.c.collections.ExtendedProperties et la convertit en  Configuration object.

 

 

Authentification Forte URL
CRYPTOCard - Token Authentication www.cryptocard.com
RSA SecurID  http://www.rsasecurity.com/node.asp?id=1156
Safeword - Secure Computing http://www.securecomputing.com/index.cfm?skey=643
Vasco Digipass http://www.vasco.com/

Les "Alteon Application Switches" de  Nortel permettent de gérer la haute disponibilité et à équibrer  la charge d'applications ou de périphériques perfectionnés, de gérer le trafic de manière intelligente, de rediriger  des applications , de mieux gérer la sécurité et la gestion de la bande passante.C'est la solution idéale pour les entreprises, les sites de e-commerce, les fournisseurs de contenu et les prestataires de services qui veulent disposer de fermes de serveurs  performantes et à haute disponibilité.

 

Répartition de charge entre serveurs HTTP

avec Websphere Network Dispatcher

-Part1-

 

Composant Network Dispatcher

Supposons que nous sommes en environnement demandant de disposer de plusieurs machines Web en frontal. Le composant Network Dispatcher va intercepter les requêtes clientes et les transmettre au serveur le plus adapté pour fournir une réponse. Il équilibre donc la charge des requêtes entrantes sur un ensemble de machines qui traitent le même type de requêtes.

Network Dispatcher peut répartir les requêtes entre plusieurs serveurs (notamment HTTP et Caching Proxy) en donnant des règles bien spécifiques à suivre.

 

Le Network dispatcher contient plusieurs modules que nous allons décrire brièvement dans les lignes suivantes.

• Dispatcher

Composant permettant de réaliser une redirection vers les serveurs en utilisant les méthodes :

à         MAC

à         NAT (Network Address Translation)

à         CBR : description ci dessous

 

• Content Based Routing (CBR)

CBR travaille avec Caching Proxy pour faire passer les requêtes des clientes aux serveurs http.

CBR permet de :

à         déterminer un ensemble de serveurs qui prendra en charge une requête en fonction de son contenu.

à         paramétrer plusieurs serveurs pour chaque type de requête.

à         détecter les incidents survenant sur un serveur et arrêter la direction de la requête vers le serveur défaillant.

 

 

• Site Selector

 

Un client envoie une requête à un serveur de noms appartenant au réseau.

Le serveur de noms achemine la requête vers le serveur contenant le service Site Selector qui résout le nom de domaine en adresse IP de l'un des serveurs cible et qui la lui renvoie. Le serveur de noms renvoie ensuite l'adresse IP au client.

Site Selector utilise le composant Metric server (installé sur chaque noeud) du dispatcher  pour

à         surveiller la charge d'un serveur

à         identifier les serveurs les moins chargés

à         identifier la défaillance d’un serveur

 

 

• Cisco CSS Controller & Nortel Alteon Controller

 

Ces contrôleurs font appel au Network Dispatcher et Metric Server pour déterminer la charge du serveur. Ils utilisent les informations fournies par ND et Metric Server pour calculer la pondération qu’ils envoient aux CSS Switch a Alteon .

Les serveurs Switch et Alteon utilisent les données fournies pour gérer la matrice des décisions d'équilibrage de charge.

 

Stratégies de cache
Strategie Explication
LRU(Least Recently Used)  Cette stratégie consiste à supprimer les fichiers les moins récents dans le cache. 
LRU-MIN  Stratégie LRU qui supprime les fichiers les plus volumineux et les moins récents
LRU-THOLD  Stratégie LRU qui ne copie pas les fichiers au delà d’une taille fixée.
LFU(Least Frequently Used) Cette strategie permet de supprimer les fichiers les moins utilisés.
GDS(Greedy Dual Size)  Stratégie permettant de calculer le rapport entre un critère  paramétrable (comme par exemple le temps de réponse) et la volumétrie de l’élément en cache..Ceux qui ont le plus petit rapport, sont éliminés.

SWARMCACHE- Part2

Traduction de la documentation officielle.

(Mehdi KASMI - Architecte technique - mehdi.kasmi@unilog.fr)

 

Algorithme de caching

 

Les algorithmes de caching suivants sont disponibles pour les mémoires cache locales :

 

Least Recently Used (LRU) traduction littérale en français: Le moins Récemment Utilisé

C'est l'algorithme le plus commun et direct de caching. Il y a une certaine quantité fixée d'objets qui peuvent être mis en cache et c'est configurable. Quand la mise en cache d'un nouvel objet est demandée et que la mémoire cache est pleine, l'objet qui a le moins récemment été interrogé de la mémoire cache (ou mis à jour dans la mémoire cache) est éjecté pour faire de l'espace.

 

Automatique

Cet algorithme tourne avec le Garbage collector pour permettre aux objets mis en cache d'être automatiquement détruits. La mémoire cache maintient des références aux objets mis en cache. Ceux-ci permettent aux objets mis en cache d'être détruits par le système si nécessaire. Cela permet de gérer une taille de mémoire cache qui est limitée à la quantité de mémoire disponible par la JVM. Cependant, à la différence de l'algorithme LRU, il ne garantit pas nécessairement que les objets fréquemment utilisés seront disponibles dans la mémoire cache.

 

Timeout

Algorithme permettant de libérer des objets qui n'ont pas été utilisés(en mode écriture) pendant un certain nombre de millisecondes. La propriété cache.timeout doit être renseignée pour modifier le temps de vie des objets.

 

L’algorithme hybride

Cet algorithme combine les avantages du LRU et de l'algorithme Automatique. On fournit deux niveaux de mise en cache. Au premier niveau, une mémoire cache de type LRU assure que les objets les plus récemment utilisés sont disponibles dans la mémoire cache. Au deuxième niveau, une mémoire cache Automatique récupère les objets mis en caches qui sont disponibles pour les traiter dans le Garbage collector.

 

Lequel devrais-je utiliser ?

L'algorithme Hybride offre la meilleure combinaison performance pour des objets fréquemment utilisés et maîtrise de la taille mémoire. C'est l'algorithme recommandé. Pour les développeurs qui veulent la mise en cache simple, déterminée, l'algorithme LRU peut être préférable.

 

Configuration de SwarmCache

 

Voici toutes les options de configuration disponibles via la classe "CacheConfiguration" :

 

CacheType

C’est ce qui correspond aux types des mémoires cache sous-jacentes qui seront utilisées.

Les options sont :

CacheConfiguration. TYPE_LRU, CacheConfiguration.TYPE_AUTO, CacheConfiguration.TYPE_TIMER et CacheConfiguration.TYPE_HYBRID.

Le paramètre par défaut est LRU.

 

LRUCacheSize

C’est la taille de mémoire cache de LRU. Cela se mesure en nombre d'objets et pas en octets.

Cette valeur est ignorée si CacheType est mis à CacheConfiguration. AUTO ou CacheConfiguration. MINUTEUR. La valeur par défaut est 10000.

 

MulticastIP

C’est l'adresse IP multipoint qui sera utilisée pour communiquer entre les Gestionnaires de mémoire cache.

La valeur par défaut est 231.12.21.132.

 

ChannelProperties

Si vous êtes familiers avec la technologie JavaGroups, vous devez savoir que c'est la valeur définissant le canal du JavaGroups.

Notez que si vous renseignez cette valeur, la Variable MulticastIP sera ignorée.

Vous trouverez plus de renseignements dans la Javadoc pour connaître les valeurs par défaut.

 

L'écriture d'Applications Cache-Aware

 

Maintenant que vous avez ce fabuleux moteur  de cache intégré à votre application  Web, comment l’utiliserez-vous ? Voici quelques astuces :

 

Dans la majorité des énormes applications Web, au moins 90 % de toutes les requêtes qui parviennent au moteur de persistance permettent de récupérer le même petit ensemble de données. Donc ce sont les données que vous voulez fournir que vous avez mis en Cache. Ne vous inquiétez pas tellement des autres 10%.

 

Ne mettez pas en cache d'objets imbriqués!

Supposons que nous avons une méthode getAllPeople, qui récupère toutes les Personnes présentes dans la base de données. Devrions-nous mettre en cache le résultat de cette interrogation ? C'est souvent une idée imprudente de faire ainsi. Le problème est qu'un des objets Personne pourrait être mis à jour et que getAllPeople n’est pas expiré à ce moment. Bien sûr, vous pourriez ajouter du code supplémentaire pour insérer, mettre à jour et supprimer  l'objet imbriqué dans la mémoire cache, mais cela deviendra rapidement malpropre.

 

 

Ayez le moyen de d'effacer toutes les données contenues dans le cache.

Si vous ne faites pas souvent de changements dans la de base de données, il est très pratique d'avoir un écran d'administrateur accessible via le Web qui permet d'effacer manuellement les caches

 

 

 SWARMCACHE - Part1

Traduction de la documentation officielle.

(Mehdi KASMI - Architecte Technique - mehdi.kasmi@unilog.fr)

 

Comment ça Marche ?

 

Le principe est simple. Chaque serveur instancie son propre gestionnaire. Pour chaque type d’objets que le serveur veut cacher, on instancie un cache et on le déclare dans le Gestionnaire.

Le gestionnaire fait partie d’un groupe multicast , et communique par ce biais avec les autres gestionnaires du groupe. Lorsqu’un Objet est libéré d’un cache, le manager le notifie à tous les autres gestionnaires du groupe qui s’assurent que l’objet est bien libéré de leurs caches respectifs. Le résultat est qu'un serveur n'aura pas dans sa mémoire cache de version erronée d'un objet qui aura été mis à jour ou supprimé sur un autre serveur.

 

Notez que les Gestionnaires doivent seulement communiquer entre eux quand un objet est supprimé d'une mémoire cache. ce qui arrive quand un objet est mis à jour ou supprimé. Les Gestionnaires ne coopèrent pas au-delà de cela. Cela signifie que la quantité de communications inter serveur est proportionnelle à la quantité de mise à jour ou suppression d'éléments dans l'application. Comme les communications sont multipoint, en antémémoire des hôtes ne sont pas proportionnels au nombre d'hôtes. Remarquez aussi qu'il n'y a aucun "serveur maître",  tous les hôtes sont des noeuds égaux. Ainsi l'opération de la mémoire cache distribuée est très robuste.

 

SwarmCache est conçu pour être intégré dans la couche de persistance d'une Application Java. Une fois intégré au moteur de persistance, SwarmCache devrait être transparent aux couches plus hautes du logiciel. SwarmCache ne supporte pas directement la gestion de transaction qui peut être accompli en enveloppant les objets (Wrapper) mis en antémémoire et en stockant quelques données de transaction supplémentaires. Ce sera décrit et probablement mis en œuvre plus tard dans le Framework.

 

Swarmcache requiert les jars suivants:

à        swarmcache.jar

à        jgroups-all.jar

à        commons-collections.jar

à        commons-logging.jar

 

Pour la plupart des applications, il est suffisant de se servir de la classe « CacheFactory » pour configurer et utiliser SwarmCache.

Voici un exemple :

 

import net.sf.swarmcache.*;
 ...
 CacheFactory cacheFactory;
 ...
 // Configure and Initialize the cache manager
CacheConfiguration conf = new CacheConfiguration();
conf.setCacheType(CacheConfiguration.TYPE_LRU);
cacheFactory = new CacheFactory(conf);
...
// Create a new cache, using a name that describes
//  what kind of object we will store
ObjectCache cache = cacheFactory.createCache("People");
...
// Store something in the cache
String key = "0001";
String person = "John Watkinson";
cache.put(key, person);
...
// Retrieve something from the cache
String person = (String)cache.get("0001");
System.out.println(person);
...
// Clear an object from the cache
// (This results in the sending of a 
//  multicast message to other caching hosts)
cache.clear("0001");
String person = (String)cache.get("0001");
// The following will print 'null'
System.out.println(person);

 

L'exemple est simple, l'exécution de ce code sur plusieurs machines d'un réseau (cluster) implique que leurs mémoires cache est cohérentes.

Notez que les clefs utilisées doivent être des objets sérialisable - Elles doivent implémenter l'interface java.io.Serializable.

Les objets qui sont stockés dans la mémoire cache n'ont pas besoin d'être "serializable". Et bien sûr, les clefs doivent être limitées en taille pour optimiser les transmissions entre nœuds.

 

Pour s'assurer d'avoir des clefs distinctes, il est est conseillé d'utilisé un cache par type d'objet manipulé.

 

L'utilisation de SwarmCache dans un Moteur de Persistance

 

Voici un code skeleton démontrant comment SwarmCache peut être intégré à un outil de gestion de la persistance.

La classe suivante permet de faire persister un objet de type Personne.

 

public class PersonEntity extends GenericEntity {
                    ObjectCache cache;
                    public PersonEntity(CacheFactory cacheFactory) {
                                         cache = cacheFactory.createCache("Person");
                                         // * Other initialization here
                  }
                    ...        
                    public Person get(long key) {
                                         Long cacheKey = new Long(key);
                                         Person person = (Person)cache.get(cachekey);
                                         if (person == null) {
                                                             // * Get the object from the database                                              
                                                             if (person != null) {
                                                                                 // Put it in the cache
                                                                                 cache.put(cacheKey, person);
                                                             }
                                         }
                                         return person;
                    }      
                    ... 
                    public void insert(Person person) {
                                         // * Do database insert
                                         // Add new object to cache
                                         Long cacheKey = new Long(person.getKey());
                                         cache.put(cacheKey, person);
                    }
                    ...
                    public void update(Person person) {
                                         // * Do database update
                                         // Remove object from cache
                                         // (This causes all caches in the group to be notified)
                                         Long cacheKey = new Long(person.getKey());
                                         cache.clear(cacheKey);
                                         // Re-add the object to the cache
                                         cache.put(cacheKey, person);
                    }
                    ...
                    public void delete(long key) {
                                         // * Do database delete
                                         // Remove object from cache
                                         // (This causes all caches in the group to be notified)
                                         Long cacheKey = new Long(key);
                                         cache.clear(cacheKey);                         
                    }
                    ...
}

 

OPEN SOURCE

EHCache: http://ehcache.sourceforge.net

Framework de cache java Simple, rapide, thread Safe basé sur JCache (JSR 107)
EHCache est non distribué.


OSCache: http://www.opensymphony.com/oscache

OSCache est une solution tres utilisées et à haute performance
Les fonctionnalites de OSCache incluent: caching rapide in-memory , caching persistent sur disque, support duclustering ...
Pour la fonctionnalite de clustering des caches, les protocols de broadcast peuvent être JavaGroups ou JMS.


Swarmcache: http://swarmcache.sourceforge.net

SwarmCache est un cache distribué simple.
IL utilise le multicast IP pour communiquer avec autant de machines qu'il y sur un LAN.
IL est utilisé et concu pour être utilisé dans un environnement CLuster.
Pour la fonctionnalite de clustering des caches, le protocol de broadcast est JavaGroups

COMMERCIAL

Tangosol Coherence: http://www.tangosol.com

Tangosol Coherence™ est un cahce in-memory (JCache compliant) et gestionnaire de données pour des applications J2EE distribuées (Cluster).
il propose plusieurs strategies de cache:  local, replicated, optimistic, distributed & NearCache.
Pour la fonctionnalite de clustering des caches, les protocols de broadcast peuvent être TCMP ou JMS.


Gigaspaces: http://www.gigaspaces.com

GigaSpaces est le premier grid server for de gestion des transactions distribuées en temps réeel.
Utilisé pour d'enormes volumes, dans des environnements applicatifs hétérogènes, sur des plateformes distribuées.

/**
* Methode permettant d'envoyer une requete HTTP à une URL en passant par un proxy
* avec des parametres et
* permettant de récupérer le flux de reponse.
*
*@Param String adresse URL distante
*@Param String parametre1
*@Param String parametre2
*/

public void EnvoyerRequetePost(String adresse, String param1, String param2){
   OutputStreamWriter writer = null;
   BufferedReader reader = null;
   try {
 // on precise le nom du proxy utilisé pour se connecter
 // à l'url distante, ainsi que le port.
 Properties prop = System.getProperties();
  prop.put("http.proxyHost","192.168.0.100");
  prop.put("http.proxyPort","80");

      // Constitution de la requete
       //encodage des paramètres de la requête - l'utilisatation de StringBuffres serait plus appropriées
       String donnees = URLEncoder.encode("param1", "UTF-8")+ "="+URLEncoder.encode("valeur1", "UTF-8");
       donnees += "&"+URLEncoder.encode("param2", "UTF-8")+"=" + URLEncoder.encode("valeur2", "UTF-8");

       //création de la connection à l'adresse distante
       URL url = new URL(adresse);
       URLConnection conn = url.openConnection();
       conn.setDoOutput(true);
     
      //envoi de la requête à l'adresse distante
       writer = new OutputStreamWriter(conn.getOutputStream());
       writer.write(donnees);
       writer.flush();

      //lecture de la réponse et ecriture dans la log
        reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        String ligne;
        while ((ligne = reader.readLine()) != null) {
         System.out.println(ligne);
        }
   }catch (Exception e) {
      // affichage de la trace en cas d'exception
      e.printStackTrace();
   }finally{
      try{
  writer.close();
  }
      catch(Exception e){}
      try{
  reader.close();
         }
      catch(Exception e){}
   }
}

 
 
Créer un blog sur over-blog.com - Contact - C.G.U. - Rémunération en droits d'auteur - Signaler un abus