Archives de catégorie : how to (technique)

java 8: Méthode par défaut

Java 8 introduit la notion de méthode par defaut pour les interfaces.  Une méthode par défaut étant appelée en  l’absence d’implémentation spécifique.

ceci permet de faire de l’héritage multiple, en implémentant 2 interfaces ayant les memes méthodes

exemple

 

 

interface Person1 { 
    void sayGoodBye(); 
    default void sayHello() { 
        System.out.println("Hello Person1!"); 
    } 
}

interface Person2 { 
    void sayGoodBye(); 
    default void sayHello() { 
        System.out.println("Hello Person2!"); 
    } 
}
class Toto implements Person1,Person2{
public void static main(String[] args){
Toto toto=new Toto();
toto.sayGoobye(); 
}

 @Override
 public void sayHello() {
 Person1.super.sayHello(); 
 }

 

Java 8: les expressions lambda

Une première incursion dans le monde de Java 8 avec les expressions Lambda:
public class Test2 {

public static void main(String args[]) {

Chatable c = (String s) -> {    // implémentation dynamique de la methode ditMiaou
System.out.println(« le chat est  » + s);
};
Chatable b = (String s) -> {  // implémentation dynamique différente  de la methode ditMiaou
System.out.println(« le chat est  » + s.toUpperCase());
};
c.ditMiaou(« bijou »);
b.ditMiaou(« shany »);
}

@FunctionalInterface       //  une interface fonctionnelle n’a qu’une seule méthode
public interface Chatable {

public void ditMiaou(String s);
}
}

et la sortie:

run:
le chat est shany
le chat est SHANY

——————————————————

exemple 2: avec une liste

import java.util.Arrays;
import java.util.List;
public class Test3 {

public static void main(String args[]) {

Chatable c = (List<String> l) -> {  // ici le parametre est une liste, le stream est décrit ci après
l.stream().forEach((s) -> {
System.out.println(« le chat  » + s.toUpperCase()+ » dit miaou »);
});
};

c.ditMiaou(Arrays.asList(« shany », « mistgri », »bijou », »sissi », »chépa »));
}

@FunctionalInterface
public interface Chatable {

public void ditMiaou(List<String> lesChats);
}
}

 

et la sortie

run:
le chat SHANY dit miaou
le chat MISTGRI dit miaou
le chat BIJOU dit miaou
le chat SISSI dit miaou
le chat CHÉPA dit miaou

——————————————————

le stream:

un stream représente une séquence d’objets sans les stocker. LA source de cette séquence est une collection. Ca supporte des opérations d’agrégation tels que les filtre, les map, les find… et ces opérations peut être mis en pipe.

 

Quelques outils noSQL

ganglia, sysstat

 

no sql

architecture horizontale (ajout de serveur), souplesse du schema, documents peu structurés
richesse schema, peu d’application
mapreduce interessant si plusieurs tera octets
on favorise ecriture et restitution

=> blog, ged (à voir), logistique,

sql

richesse requete sql
transactionnel
reporting
plusieurs clients
=>erp, reporting,

mixte: e commerce

hbase, cassandra: gros volumes, pas interessant pour moyen volume
couchDB : orientée web, erland, json, rest, perf moyennes
mongoDB: documents, bson, montée en charge horizontale
riak:  clef/valeur, independance des noeuds, performances ++
redis: base en mémoire

 

 

Producteur et Consommateur: activeMQ et MongoDB

L’idée est d’émettre une grande quantité de messages sur une queue et de les faire consommer. Le tout en insérant les messages dans une base mongoDB.

je me suis inspiré des articles suivants:

  • http://www.tutorialspoint.com/mongodb/mongodb_java.htm
  • http://activemq.apache.org/hello-world.html

La classe principale se charge de lancer un consommateur et n producteurs (ici 500000)

public class App {
 
 public static void main(String[] args) throws Exception {
 thread(new Consommator(), false);
 thread(new Productor(500000), false);
 
 }
 
 public static void thread(Runnable runnable, boolean daemon) {
 Thread brokerThread = new Thread(runnable);
 brokerThread.setDaemon(daemon);
 brokerThread.start();
 }
 }

Le producteur

public class Productor implements Runnable, ExceptionListener {
private Random random;
 private static int MAX = 100;
public Productor(int max) {
 MAX = max;
 random = new Random();
 }
public synchronized void onException(JMSException ex) {
 System.out.println("JMS Exception occured. Shutting down client.");
 }
public void run() {
 try {
 // Create a ConnectionFactory
 ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("vm://localhost");
// Create a Connection
 Connection connection = connectionFactory.createConnection();
 connection.start();
// Create a Session
 Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// Create the destination (Topic or Queue)
 Destination destination = session.createQueue("we.ARE.TOTO");
// Create a MessageProducer from the Session to the Topic or Queue
 MessageProducer producer = session.createProducer(destination);
 producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
for (int i = 0; i < MAX; i++) {
 // Create a messages
 String text = "Hello world! From: " + Thread.currentThread().getName() + " : " + random.nextInt();
 TextMessage message = session.createTextMessage(text);
 // Tell the producer to send the message
 // System.out.println("Sent message: " + message.hashCode() + " : " + Thread.currentThread().getName());
 producer.send(message);
 }
 // Clean up
 session.close();
 connection.close();
 } catch (Exception e) {
 System.out.println("Caught: " + e);
 e.printStackTrace();
 }
 }
}

Le consommateur

public class Consommator implements Runnable, ExceptionListener {
public synchronized void onException(JMSException ex) {
 System.out.println("JMS Exception occured. Shutting down client.");
 }
@Override
 public void run() {
 boolean isRunning = true;
 long debut = System.currentTimeMillis();
 long nbMsg = 0;
 try {
 ///DB
 MongoClient mongoClient = new MongoClient("localhost", 27017);
 // Now connect to your databases
 DB db = mongoClient.getDB("test");
 System.out.println("Connect to database successfully");
 boolean auth = db.authenticate("admin", "admin".toCharArray()
 );
 System.out.println("Authentication: " + auth);
 DBCollection coll = db.getCollection("mycol");
 System.out.println("Collection mycol selected successfully");
 //AQ
 //JNDI properties
 Properties props = new Properties();
 props.setProperty(Context.INITIAL_CONTEXT_FACTORY, "org.apache.activemq.jndi.ActiveMQInitialContextFactory");
 props.setProperty(Context.PROVIDER_URL, "vm://localhost");
//specify queue propertyname as queue.jndiname
 props.setProperty("queue.slQueue", "we.ARE.TOTO");
javax.naming.Context ctx = new InitialContext(props);
 ConnectionFactory connectionFactory = (ConnectionFactory) ctx.lookup("ConnectionFactory");
 Connection connection = connectionFactory.createConnection();
 connection.start();
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
Destination destination = (Destination) ctx.lookup("slQueue");
 //Using Message selector ObjectClass = ‘AlarmImpl’
 MessageConsumer consumer = session.createConsumer(destination);
while (isRunning) {
 // System.out.println("Waiting for message...");
 Message message = consumer.receive(1000);
 if (message != null && message instanceof TextMessage) {
 nbMsg++;
 TextMessage txtMsg = (TextMessage) message;
long fin = System.currentTimeMillis();
 long temps = fin - debut;
 try {
 // To connect to mongodb server
 
 BasicDBObject doc = new BasicDBObject("title", "MongoDB").
 append("msg", txtMsg.toString());
coll.insert(doc);
 System.out.println("Document inserted successfully");
 } catch (Exception e) {
 System.err.println(e.getClass().getName() + ": " + e.getMessage());
 }
System.out.println("je trziyr " + nbMsg + " par " + temps / 1000);
 }
 }
 System.out.println("Closing connection");
 consumer.close();
 session.close();
 connection.close();
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
}

 

Test unitaire

exemple de code pour effectuer des tests unitaires

import com.xoff.wcv.service.GameService; 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
// on charge la configuration spring initialisant tous les beans
 @ContextConfiguration(locations={"file:src/main/webapp/WEB-INF/mvc-dispatcher-servlet.xml"})
 public class PlayerServiceTest {
@Autowired
 private GameService gameService;
@Test
 public void testPlayerService() {
// appel d'un service (qui en l'occurrence effectue un appel à la base de données)
 System.out.println("coucou:"+gameService.count());
}
 }

------
pour utiliser les annotations, il faut ajouter dans le pom.xml

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>2.5</version>
</dependency>

Installation d’un server Git

j’ai choisi pour ma part une machine Linux, avec pour objectif d’heberger mes sources dans un repositoy GIT (http://fr.wikipedia.org/wiki/Git) sur Linux et d’y acceder essentiellement via Netbeans

j’ai installé ubuntu sur une machine virtuelle

  1. – la commande ifconfig permet d’avoir l’ip
  2. – dans oracle virtualBox, il faut utiliser un bridge au niveau reseau pour que la machine virtuelle soit visible de l’exterieur

voici quelques articles m’ayant permis de reussir cela:

  1. http://www.hackido.com/2010/01/installing-git-on-server-ubuntu-or.html
  2. http://kosiara87.blogspot.fr/2012/06/giteagainnetgitosisgit-not-found.html
  3. http://www.debuntu.org/secure-your-ssh-server-with-publicprivate-key-authentification/

 

il convient à la fin de l’installation d’effectuer un git fetch puis pull puis push.

 

maven jenkins sonar

j’ai choisi jenkins comme outil d’intégration continue car c’est le plus facile à installer et configurer.

all

il s’integre parfaitement à maven et sonar formant ainsi un trio gagnant.

paraméter jenkins:

– il faut installer le plugin sonar

install1

il faut ensuite parametrer jenkins, il est important de spécifier un jdk et le répertoire de sonar dans la partie

 

install2

paraméter un projet:

j’ai choisi un projet mavenisé pour plus de simplicité

etape1

 

 

 

 

etape2

Sonar

Sonar est une première étape vers l’intégration continue. L’outil permet de vérifier la qualité du code. (cf. http://fr.wikipedia.org/wiki/Sonar_(logiciel)).

a/ installation:

b/ importation dans sonar

importer le projet cible avec mvn sonar:sonar  (cf. article sur la configuration maven http://technologie.xoff.info/?p=64 )

necessite tous les .jar