Comment se compliquer la vie en Java...

Mouaaaaa, je trouve ça marrant, les gens qui veulent montrer qu'ils connaissent les toutes dernières fonctionnalités de Java.

Voilà un exemple concret : suppression basique d'un répertoire temporaire (je dis bien : une simple "SUPPRESSION BASIQUE").

Ça c'est la version "je me la pète je maîtrise Java 7" :

Files.walkFileTree(tempDirectory, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult visitFile(Path file,
                        BasicFileAttributes attrs) throws IOException {

                    Files.delete(file);
                    return FileVisitResult.CONTINUE;
                }

                @Override
                public FileVisitResult postVisitDirectory(Path dir,
                        IOException exc) throws IOException {

                    if (exc == null) {
                        Files.delete(dir);
                        return FileVisitResult.CONTINUE;
                    } else {
                        throw exc;
                    }
                }
});

Euhhhh oui, c'est beau, il y a plein d'indentations et ça fait 15-20 lignes quand même...

Pourquoi ne pas implémenter une toute petite méthode récursive (le truc de base que l'on apprend en cours) ou tout simplement faire appel à Apache Commons (FileUtils.deleteDirectory(tempDirectory)) ?

Hormis le fait que je râle sur ce satané bout de code "tout moche" sur lequel je viens de tomber,
il y a derrière un vrai problème de fond : "faire la part des choses entre la maintenance/lisibilité et l'utilisation systématique/radicale/extrême des fonctionnalités évoluées de Java".

Désactiver le Java Update sous Windows

• Cliquer sur le menu Démarrer

• Taper msconfig puis Entrée

• Une popup apparait

• Aller sur l'onglet Démarrage

• Décocher la ligne Java(TM) Platform SE Auto Updater

• Cliquer sur Appliquer, puis OK

• Redémarrer Windows

N'hésitez pas à me laisser un petit commentaire pour me dire si cette astuce vous a été utile et à faire un +1 :o)

Java - ordering listFiles()

    /**
     * return files list ordered by type (directory/file) and by name:
     * step 1 : first the directories and after the files (type sorting). 
     * step 2 : after this type sorting, we order by name (alphabetical order).
     * @param file Directory to list
     * @return 
     */
    private File[] listFiles(File file) {
        File[] files = file.listFiles();
        Arrays.sort(files, new Comparator<File>() {

            //return positive value if f1 is previous to f2
            //return negative value if f2 is previous to f1
            public int compare(final File f1, final File f2) {
                boolean sameType = (f1.isDirectory() == f2.isDirectory());

                if (sameType) {
                    //same type, then only compare by name
                    //if nameCompare<0 then f1 is previous to f2 (alphabetical order)
                    return f1.getName().compareTo(f2.getName());
                } else {
                    if (f1.isDirectory()) {
                        //f1 is a directory, then f2 is a file, and then f1 is previous to f2 (we must return negative value)
                        return -1;
                    } else {
                        //f2 is a directory, then f1 is a file, and then f2 is previous to f1 (we must return positive value)
                        return 1;
                    }
                }
            }
        });
        return files;
    }

Configuration d'une application Java/Spring/Hibernate pour utiliser JavaMelody

Ceci est un petit résumé...

• Monitoring SQL, sans Datasource :

- modifier le driver :
hibernate.connection.driver_class : net.bull.javamelody.JdbcDriver

hibernate.connection.driver : oracle.jdbc.driver.OracleDriver

• Monitoring des Services (les @Service) :

- rajouter l'interface Monitored dans le package com.toto

- rajouter "implements Monitored" sur les classes des services que l'on souhaite monitorer

- rajouter dans applicationContext.xml :

<bean id="facadeMonitoringAdvisor" class="net.bull.javamelody.MonitoringSpringAdvisor">
    <property name="pointcut">
            <bean class="net.bull.javamelody.MonitoredWithInterfacePointcut">
                 <property name="interfaceName" value="com.toto.Monitored" />
            </bean>
        </property>
</bean>


PS : on peut aussi le faire avec @net.bull.javamelody.MonitoredWithSpring à la place de l'interface... 

pour plus d'infos : doc de JavaMelody

• Configuration diverse:

- rajouter dans web.xml :

<context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            classpath:net/bull/javamelody/monitoring-spring.xml
            classpath:applicationContext*.xml
        </param-value>
</context-param>

<filter>
         <filter-name>monitoring</filter-name>
         <filter-class>net.bull.javamelody.MonitoringFilter</filter-class>
</filter>

<filter-mapping>
         <filter-name>monitoring</filter-name>
         <url-pattern>/monitoring</url-pattern>
</filter-mapping>
 

<listener>
         <listener-class>net.bull.javamelody.SessionListener</listener-class>
</listener>

- rajouter dans pom.xml :

<dependency>
            <groupId>net.bull</groupId>
            <artifactId>javamelody</artifactId>
            <version>1.29.0</version>
</dependency>
<dependency>
            <groupId>org</groupId>
            <artifactId>jrobin</artifactId>
            <version>1.5.9.1</version>
</dependency>  

• Si jamais vous avez un message du genre "dépendance cyclique" (en gros un service A fait référence à un service B qui fait référence au A) :

- créer la classe AllowRawInjectionDespiteWrappingXMLWebApplicationContext :

package com.toto.utils.spring;

import java.io.IOException;

import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.web.context.support.XmlWebApplicationContext;

public class AllowRawInjectionDespiteWrappingXMLWebApplicationContext extends XmlWebApplicationContext {

  @Override
  protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException {
    beanFactory.setAllowRawInjectionDespiteWrapping(true);
    super.loadBeanDefinitions(beanFactory);
  }
}

- rajouter dans web.xml :
<context-param>
        <param-name>contextClass</param-name>
        <param-value>com.toto.utils.spring.AllowRawInjectionDespiteWrappingXMLWebApplicationContext</param-value>
    </context-param>

    

Installer automatiquement un jar dans un repository maven local

Si on veut installer un jar, par exemple le jar JavaMelody (super outil de monitoring Java) :

mvn install:install-file -DgroupId=net.bull -DartifactId=javamelody -Dversion=1.25.0 -Dpackaging=jar -Dfile=c:/temp/javamelody-1.25.0.jar

 

Monitoring with JavaMelody

Je vais vous parler d'un outil de monitoring de webapp : JavaMelody, hebergé sur Google Code.

Il permet de monitorer la conso mémoire, CPU, les connexions HTTP/S, les connexions JDBC, les requêtes SQL, les threads, les classes, le garbage collector etc.
Tout y passe :o)

Les prérequis sont minimes : JRE 1.5, Tomcat 5.5, GlassFish 2, JBoss 4, Jonas 4, Jetty 6, WebLogic 9. Les versions supérieures passent sans problème (hormis l'intégration avec Tomcat7 en cours de validation)

Accessoirement, il est même possible de monitorer du Hudson(Jenkins), JIRA, Confluence, Bamboo(connais pas), Grails.

Concernant le monitoring d'une webapp, il y a très peu de modification à faire du coté du WAR (ou EAR). Dans mon cas, j'ai juste rajouter deux 2 libs, modifier le web.xml, l'applicationContext (si on fait du Spring comme moi), l'hibernate.cfg.xml (si on fait du Hibernate). Ça gère même les EJB 3, Struts 2, Guice, Quartz.

En 15 minutes, vous monitorez toute votre application.

La documentation officielle est très claire (et l'installation est méga simple) :
http://code.google.com/p/javamelody/wiki/UserGuide?tm=6#Setup

Allez voir les captures d'écrans afin de vous rendre compte de la quantité d'informations que l'on peut obtenir simplement avec JavaMelody.

PS : JavaMelody est "production ready" :o)

PS : Il peut se plugger avec Nagios ;o)

Arrêter proprement un script Java

Ci-dessous un programme qui appelle en boucle la méthode processSomething(...) avec un sleep de 5 secondes.

Il faut donc traiter les user interrupts dans deux cas : 

• le cas où l'interruption se fait lors de l'exécution d'un processSomething(...) 

• et le cas où l'interruption se fait lors du sleep de 5 secondes.

public class StopSample{

    public static boolean running = true;

    public static void main(String [] args){

        new StopSample().processMain();

    }

    public void processMain() {

        // si on interrompt durant le processSomething(...) plus bas (cas 1) :

        Runtime.getRuntime().addShutdownHook(new Thread() {

            public void run() {

                StopSample.running = false;

                logger.info("Arret du programme suite à un user interrupt");

            }

        });

        try {

            for (; running;) {

                processSomething(...);

                Thread.sleep(5000);

            }

        } catch (InterruptedException e) {

            // si on interrompt durant le Thread.sleep (cas 2) :

            logger.info("Arret du programme suite à un user interrupt");

            System.exit(0);

        }

}

Lien : http://www.roseindia.net/javatutorials/hooking%20_into_the_shutdown_call.shtml