Mycila Blog

Redis Introduction

2011-12-02T00:59:00.000-05:00

Redis est un serveur NoSQL (sorte de MemCache évolué) permettant de partager des données entre différens serveurs. Nous allons voir comment l'utiliser en Java et ses principaux atout, notament l'atomicité, les transactions, l'asynchrone et les différents types de données supportés. Nous allons également montrer un usage concret d'utilisation d'un tel type de BD pour le clustering de sessions sur Jetty.

Redis Introduction

View more presentations from Mathieu Carbou

Source code: https://github.com/Ovea/conf-redis

Advanced Junit & Mockito

2011-12-02T00:57:00.000-05:00

Junit est une librarie de test que tout le monde connaît, mais peu de personne savent qu'il existe de nombreuses fonctionnailités plus ou moins documentées et assez puissantes. Cette présentation vise à montrer ces outils cachés via des démonstrations (@Rule, Suite, Theories, Comment tester la concurrence, Exécution en parallèle des tests, ...). Nous entrerons également dans le détail à savoir comment créer votre propre Runner Junit pour étendre ce framework et nous verrons les features expérimentales de Junit. Enfin nous verrons comment utiliser Mockito, un framework avancé de mocking.

Advanced junit and mockito

View more presentations from Mathieu Carbou

Source code: http://github.com/Ovea/conf-junit

Java, Groovy and Javascript compatible coding library

2011-11-15T23:26:00.001-05:00

Last week I worked on a Java/Groovy and JavaScript compatible coding library including:

binary to hex representation (aka Hex class of commons codec)
base64 implementation
Tiny Encryption Algorithm (XXTEA)
ASCII to binary conversion

The challenge is to get the same output in JavaScript and Java for the same input. JavaScript has no byte type so the only common binary type representation I found for both of them is to arrays of 32-bits integers,

Most of existing coding JavaScript library works based on String, but String encoding may vary between Java and JavaScript. Integers cannot. On Java-side, the library can work with bytes, integers and most of all NIO buffers.

Here is an excerpt of what you can do with this library. The result is the same in Java, Groovy and JavaScript providing the same input.

Java / Groovy

// ascii <-> binary conversion 

String str = 'abcdefghijklmnopqrstuvwxyz' 

IntBuffer buffer = ASCII.toIntBuffer(str)

assert str == ASCII.fromIntBuffer(buffer)

 // hex representation

String str = '0123456789ABCDEF'

IntBuffer buffer = HEX.decodeHexAsInts(str)

assert str == HEX.encodeHexString(buffer)

// Base64 

String str = Base64.encodeBase64String(buffer)

ByteBuffer buffer =  Base64.decodeBase64(str)

// TEA key generation

  

Random r = new SecureRandom()

IntBuffer key = IntBuffer.wrap([

    r.nextInt(), 

    r.nextInt(), 

    r.nextInt(), 

    r.nextInt()] as int[]) //128-bits keys

// TEA encryption

String data = "...." // > 128-bits data

IntBuffer buffer = ASCII.toIntBuffer(data)

XXTEA.encryptInPlace(buffer, key)

String b64 = Base64.encodeBase64String(buffer)

// TEA decryption

buffer = Base64.decodeBase64(b64).asIntBuffer()

XXTEA.decryptInPlace(buffer, key)

String clear_text = ASCII.fromIntBuffer(buffer) 

JavaScript

// ascii <-> binary conversion 

var str = 'abcdefghijklmnopqrstuvwxyz'; 

var int_array = ovea.crypto.ascii.toInts(str);

str ==  ovea.crypto.ascii.fromInts(int_array);

 // hex representation

var str = '0123456789ABCDEF'v

var int_array = ovea.crypto.hex.decode(str);

str == ovea.crypto.hex.encode(int_array);

// Base64 

var str = ovea.crypto.base64.encode(buffer);

var int_array =  ovea.crypto.base64.decode(str);

// TEA key generation

var key = [0, 1, 2, 3]  // 128-bits key

// TEA encryption

  

var data = "...." // > 128-bits data

var buffer = ovea.crypto.ascii.toInts(data);

ovea.crypto.xxtea.encryptInPlace(buffer, key);

var b64 = ovea.crypto.base64.encode(buffer); 

// TEA decryption

var buffer = ovea.crypto.base64.decode(b64);
ovea.crypto.xxtea.decryptInPlace(buffer, key);
var clear_text = ovea.crypto.ascii.fromInts(buffer);

The project java-js-crypto is available on Ovea's GitHub. The license is Apache 2 and libraries are deployed in Maven2 Central Repository at:

http://repo1.maven.org/maven2/com/ovea/ovea-crypto/

Jetty session clustering with Redis

2011-10-06T10:26:00.002-04:00

Ovea's implementation of Jetty Session Clustering based on Redis has been updated to Jetty 8 releases in september. It is available in Maven repository at:
http://repo1.maven.org/maven2/com/ovea/jetty-session-redis/2.0.rc1/
The main advantage of using Redis is that Redis is a volatile in-memory storage enabling expiration on entries plus atomic operations. It is also very fast.

Reverse-Ajax part 5

2011-10-06T10:18:00.003-04:00

The last article on Reverse-Ajax has already been published on IBM Developer Works.

Reverse-Ajax part 5

It talks about Event-Driven Web development.

Direct Star TV

2011-09-27T00:21:00.001-04:00

Particularly these days, when everyone seems obsessed with procuring the very best programming technologies available, the benefits of satellite television packages have been publicized to a great extent. However, many people also worry that they will be forfeiting certain services if they switch to satellite. For example, some think that satellite service is less reliable than cable, or that they will have less access to local channels without a basic cable package. Fortunately, neither of these concerns is very valid, as you will be able to tell with just a little bit of research on different satellite programming packages.

To begin with, you will find that Satellite companies actually offer packages that are uniquely catered to different regions. For example, depending on where you live or where you need television service, just run a simple search such as “Yuma Cable” or “Satellite in Philadelphia,” etc. You will find that not only are there packages available that extend your range of channels while also allowing you to keep your local channels; you will also be provided with free installation from an employee of the company that you choose to get your service from. Essentially, this means that when you start with your new television package, you will have exactly what you already have, plus the addition of potentially hundreds of new channels.

You will also find that a satellite television package offers you access to special deals, and special channels. For instance, if you are a football fan looking to catch absolutely all of the action this season, you may want to look into features such as “Sunday NFL Ticket,” which literally brings you every game throughout the season. Or, if you are more interested in movies and television, you should probably consider upgrading to gain access to channels such as Cinemax and HBO, both of which have reputations for providing extremely high quality entertainment. Whatever your interest may be, a satellite television company will be able to offer you multiple ways of tapping into your favorite aspects of television watching.

Furthermore, you will probably find that the clarity and consistency of your satellite signal is flawless. While many people like to argue about the differences in these factors with regard to cable and satellite, the fact is that both are fairly advanced at this point, and should bring you a high quality picture all of the time. So, if you simply want to enjoy your connection with increased programming options, it might be the right decision for you to switch to a satellite provider some time soon.

Stream and Process Pipes and Socket Tunnels

2011-09-12T14:47:00.000-04:00

When communicating over sockets and processes we often have to create pipes to connect streams. The code is quite difficult to write since it's a combination of threads, synchronization, exception handling, locks, ..
We developed at Ovea a library to facilitate piping streams, processes and also creating socket tunnels.
The usage is really simple:

Stream Pipes

// create a pipe
Pipe pipe = Pipes.create("optional  pipe name", myInputStream, myOutputStream).listenedBy(myOptionalPipeListener);

// get the connection handle
PipeConnection connection = pipe.connect();

// then you can do
connection.await();
connection.await(1, SECONDS);
connection.interrupt();

Process Pipes

ProcessPipe pipe = Pipes.pipe(
        new ProcessBuilder("ls", "-al", "/workspace/ovea/project/pipe/src").start(),
        new ProcessBuilder("cut", "-c", "50-").start(),
        new ProcessBuilder("grep", "-v", "-E", ""^\.\.?$"").start());
Pipes.connect("out", pipe.getInputStream(), System.out);
Pipes.connect("err", pipe.getErrorStream(), System.err);
int retCode = pipe.waitFor();

Socket Tunnels

Socket socket1 = new Socket("localhost", 2000);
Socket socket2 = new Socket("localhost", 2222);
Tunnel tunnel = Tunnel.connect(socket1, socket2, new TunnelListener() {
    @Override
    public void onConnect(Tunnel tunnel) {
        System.out.println("onConnect - " + tunnel);
    }

    @Override
    public void onClose(Tunnel tunnel) {
        System.out.println("onClose - " + tunnel);
    }

    @Override
    public void onBroken(Tunnel tunnel, BrokenTunnelException e) {
        System.out.println("onBroken - " + tunnel);
    }

    @Override
    public void onInterrupt(Tunnel tunnel) {
        System.out.println("onInterrupt - " + tunnel);
    }
});

The Maven Dependency has been deployed:

<dependency>
    <groupId>com.ovea</groupId>
    <artifactId>ovea-pipe</artifactId>
    <version>1.0.ga</version>
    <optional>true</optional>
</dependency>

=> Ovea Pipe on GitHub

Mycila Junit

2011-09-10T13:01:00.000-04:00

I've updated mycila-junit to lastest Junit version (4.9). This projects include all the ConcurrentJunitRunner and ConcurrentRule desribed in my previous blog posts at

http://blog.mycila.com/search/label/junit.

The library is released and will be available on Maven Repository in 2-3 days at

http://repo1.maven.org/maven2/com/mycila/mycila-junit/

You can take version 1.1.ga for Junit 4.9 and above.

Reverse-Ajax part 3 & 4

2011-09-06T16:02:00.000-04:00

My next articles on Reverse-Ajax are available on IBM Developer Works.

Subversion recursive update with Java 7 Fork/Join

2011-08-15T20:08:00.001-04:00

Some time ago I've developed a little bash script called svn-recursive-update to update recursively projects given a root directory.

I've rewritten it yesterday in Groovy (thus the script now works in any plateform) using the new Java 7 Concurrent feature: the Fork/Join framework. The Fork/Join concurrency API is really suited when you have a task that you can divide in 2 or more tasks recursively and when you don't necessary know when the processing will finish.

Since our tool scan all folders, sub-folders and so on to find Subversion projects, we have an updater task calling itself for each sub-folder.

class Updater extends RecursiveAction {
    File dir
    Updater(File dir) {this.dir = dir}
    protected void compute() {
        if (dir.isDirectory()) {
            if (new File(dir, '.svn').exists()) {
                // do svn update
            } else {
                def tasks = dir.listFiles({dir.isDirectory()} as FileFilter).collect({new Updater(it)})
                if (tasks) invokeAll(tasks)
            }
        }
    }
}

The recursive task can then be started within a thread pool like this:

ForkJoinPool pool = new ForkJoinPool(cpus);
pool.invoke(new Updater(root));

You can find the complete groovy code of svnup.groovy in Gist. Just put this file in your bin directory and run it from any folder.

Reverse-Ajax Part 2

2011-07-30T12:12:00.001-04:00

Part 2 of the Reverse-Ajax series I write is online at

http://www.ibm.com/developerworks/web/library/wa-reverseajax2/index.html

JQuery CORS plugin

2011-07-29T20:15:00.010-04:00

When working with web applications spread onto several subdomains or different domains, accessing resources in Ajax or even doing Reverse-Ajax can really be difficult.

Hopefully, the Cross-Origin Resource Sharing (CORS) specification is there to allow Ajax request to be sent from a domain to another domain, and even working with cookies.

With jQuery, IE8+ is not supported because it used another separate object called XDomainRequest. Thus, several plugins can be found to add a complete CORS support with jQuery. Amongst them we have:

This one or this one, which provide their own API around jQuery code
This one which overrides some jQuery methods.

At Ovea, we were in the case with an existing application and we could not use solutions 1 because we cannot change our code, and we do not have any control olver third party libraries doing Ajax calls, and we cannot use solution 2 because we are using a lot of more methods other than $.get and $.post.

Thus, we developed a working jQuery CORS plugin which transparently add CORS support, even in IE8+. for this, we used $.ajaxSettings.xhr to redefine the way Ajax request implementations are created.

Microsoft's XDomainRequest does not allow cookies to be passed in the headers. So we needed to rewrite the requests to add support for a potential session cookie in the url directly. This allows the web server to correctly found the session on server-side.

http://server/path;jsessionid=XYZ?name-value;

The usage is really simple. After adding the jQuery Javascript in your page, add the jquery.xdomain.js file. If your session cookie is not called JSESSION_ID, you can change the value like this:

<script src="path/to/jquery.js" type="text/javascript"></script>
<script type="text/javascript">
    window.SESSION_COOKIE_NAME = 'ID';
</script>
<script src="path/to/jquery.xdomain.js" type="text/javascript"></script>

That's all !

Code source of the jQuery CORS Plugin on GIST.

If have any comments or bugs, please use the comment thread on the GIST page.

Reverse-Ajax, Part1

2011-07-19T16:12:00.004-04:00

My first article of a 5-articles series is alive on IBM Developer Works at:

http://www.ibm.com/developerworks/web/library/wa-reverseajax1/index.html

Ovea's CometD contributions

2011-07-13T15:53:00.005-04:00

We released yesterday version 1.1.ga of cometd-contrib. CometD Contrib is an extension to CometD which provide additional features:

Goole Guice integration
WebSocket support for Jetty 8.0.0.M3
Custom and J2ee security policies

Version 1.0.ga supports Jetty 8.0.0.M2.

GitHub:
https://github.com/Ovea/cometd-contrib

Maven dependency:

<dependency>
    <groupId>com.ovea</groupId>
    <artifactId>ovea-cometd-contrib</artifactId>
    <version>1.1.ga</version>
</dependency>

Sample:
You can find an example of a web application using Guice and CometD plus Ovea's extensions in the JS-EventBus project in Ovea'GitHub.

CLEAR 4G Internet Customer Reviews

2011-06-16T17:59:00.000-04:00

As you have no doubt noticed, wireless internet is becoming so widespread that seemingly everybody is connecting online from all kinds of places. People freely use their laptops in cafes, their smart tablets in offices and bookstores, and even their smart phones outside in parks or at ballgames. All of these are examples of the luxurious convenience offered by wireless internet technology. However, did you know that wireless internet is not just available through these devices and the companies that manufacture them? Many people tend to think that companies like Verizon or AT&T are the only ones that provide wireless internet service, simply because these are the companies through which many people purchase their smart phones or cellular service. This is not the case; actually, there are also companies, such as Clear Wireless, that serve the sole purpose of providing you with wireless internet at reliable speeds and competitive prices. For more information and customer reviews on such a company, try looking up Clear internet reviews to see what people have to say about their service. You can also look up specific comparison charts and comments that discuss the pros and cons of different wireless service providers.

If you are looking to switch wireless providers, or even if you are getting connected for the first time, you can find service from some providers as low as about $35 per month. Once you purchase the service, you will be sent a wireless router for your home, as well as a USB modem that you can plug into your laptop or smart tablet. This means that, first of all, your home can receive wireless service from the included router, meaning that even in your home you will no longer have to mess with chords and phone connections to get online, and you will not have to purchase an additional home wireless system. Second, with the USB modem, you will be able to get online from just about anywhere outside of your home, just the way that you see so many people do it these days. Just plug in the modem, and you will have instant access to your 4G network, allowing you to surf the Internet, send and receive emails, watch videos, and do anything else you would normally do online at the quick
est speeds and with the clearest signal. Some companies even offer 4G/3G combination packages, which allow you even more certainty that you will remain connected no matter where you go, as your device will automatically pick up the nearest 4G or 3G signal. Because of these and many other benefits, it is worth researching wireless providers to find out which one might be best for you.

Not dead

2011-06-15T20:22:00.001-04:00

It's been a while since I did't post anything ! I'm not dead - just very busy :-)

I'm working on two interesting projects enveloped with no Web Framework: just plain REST services, HTML 5 pages and Javascript. I am focusing on the event-driven part (either on client-side and server-side). We are using JMS, CometD, Redis (mainly for session clustering in Jetty), and developing for desktop and mobile platforms.

We also contribute a lot in Open-Source: all the bricks we are using are available into Ovea's GitHub.

We've developed a CometD extension to use CometD bayeux in a Webapp powered by Google Guice and its Guice Servlet extension. We hope to release the module soon. It is currently in our CometD fork in Ovea's GitHub.

Here are some projects we've been very active in:

CometD fork: https://github.com/Ovea/cometd-fork
Client-side EventBus and Remote bridge with CometD, and also Guice with CometD sample: https://github.com/Ovea/js-eventbus
Web resource management: https://github.com/Ovea/virtual-resources
Synchronize async events: https://github.com/Ovea/js-sync
Session clustering with Redis and Jetty: https://github.com/Ovea/jetty-session-redis

In my little spare time, I am also currently writing a series of 5 articles on Reverse-Ajax techniques for IBM Developer Network. Keep in touch ! There will also be an insight of Event-Driven web development and some how-to and samples so that Reverse-Ajax techniques has no more secret for you !

Synchronize asynchronous unordered events in JavaScript

2011-04-19T22:36:00.001-04:00

At Ovea, we are developing web applications in an Event-Driven way by using an asynchronous communication library plus an local/remote EventBus system we open-sourced.

The EventBus system enables components to publish and subscribe to events like this:

bus.topic('/event/dom/loaded').subscribe(function() {
    // dom loaded
});
bus.topic('/event/member/loaded').subscribe(function(member) {
    // member loaded
});
bus.topic('/event/page/changed').subscribe(function() {
    // page changed
});

Also, we have the usual DOM events, like:

$('#save-info').click(function(e) {
    // button clicked
    return false;
});

when you are working in a component way client-side, components are totally independent and communicate through the Event Bus system. You often need to trigger or do some actions when two or more events have all occurred.

In example, you might need to redraw the UI when the DOM is loaded and when the save-info button has been clicked and when the event '/event/member/loaded' is sent.

With SyncAsync you can do that, and more ! This is a library that can be used to synchronize asynchronous events and trigger some other.

We can write:

var sync = new SyncAsync({
    name: 'test-to-redraw-ui',
    trigger: 'each'
});

jQuery.ready(sync.newCallback());
$('#save-info').click(sync.newCallback(false));
bus.topic('/event/member/loaded').subscribe(sync.newCallback());

sync.sync(function(domReady, save-info, memberLoaded) {
    // Function called when all events are resolved. The function receives all contexts and arguments of all callbacks
    // $ == domReady.arg[0]
    // e == save-info.arg[0] (jQuery event object received by the second callback)
    // Button 'save-info' == save-info.ctx
    // member == memberLoaded.arg[0] 
});

The project is on GitHub at https://github.com/Ovea/js-sync

Reverse-Ajax techniques and libraries

2011-03-18T09:51:00.000-04:00

Conference I gave at Montreal JUG Thursday March 17th 2011 on Reverse-Ajax techniques and libraries. Samples are available at Ovea's GitHub (links are on the slides).

Reverse Ajax

View more presentations from Mathieu Carbou

Jetty Session Clustering with Redis - Released !

2011-03-10T22:12:00.000-05:00

We've released the first version of the "Jetty Session Clustering with Redis" plugin. It works very well :-)

Downloads: https://github.com/Ovea/jetty-session-redis/downloads

Do we still need a web framework ?

2011-03-10T15:28:00.001-05:00

here are the slides of the conference I gave yesterday at Confoo.ca

Do we still need a web framework ?

View more presentations from Mathieu Carbou.

Confoo.ca next week !

2011-03-03T15:06:00.001-05:00

Jetty Session Clustering with Redis

2011-02-28T14:54:00.000-05:00

We've open-sourced this week at Ovea a Jetty plugin to add Session Clustering to Jetty by using Redis.
Redis is a high-performance No-Sql database which is commonly used for key-value storage, caching, ... Redis has a lot of interesting features such as transactions and publish/subscribe.

The Jetty module jetty-session-redis uses Jedis, the Java client of Redis.

The configuration is completely transparent for a Webapp since you only need to modify the jetty.xml server configuration plus de webapp context files.

We have also implemented several serializers for your session attributes:

XStream
JSON
JBoss Serializer
JDK Serializer

You can also implement you own by implementing a the Serializer interface. Gzip compression is also supported to reduce the length of serialized objects.

The project can be found at https://github.com/Ovea/jetty-session-redis, with an extensive README file to help you for the setup. It is currently in snapshot state (we plan to release a beta soon). All comments and bugs are welcomed !

We also plan to implement for higher performance an asynchronous save system and support Redis key/value based on bytes to improve performance.

Mathieu.

Future conference I'll give at Confoo.ca

2011-02-20T23:40:00.001-05:00

Do we still need a web framework ???

http://confoo.ca/en/2011/session/as-t-on-encore-besoin-d-un-framework-web

JDK Logging per Webapp

2011-01-11T23:17:00.001-05:00

Logging in Java is probably the easier thing that has been made a lot complicated. In Java, you have plenty of logging libraries and wrappers amongst:

commons logging
log4j, log4j extras, jmx, mail
slf4j (api, implementation, commons logging wrapper, jdk logging wrapper, ...)
jdk logging (java.util.logging)
and a lot and lot of others

You aim to have in your web application at then end all of these stupid wrappers because libraries depends on them.
If you are concerned about performance, you already know that the best way to use those loggers are by testing then logging:

private static final Logger LOGGER = Logger.getLogger(MyClass.class.getName());
[...]
if (LOGGER.isLoggable(Level.FINE))
    LOGGER.fine("Creating new connection...");

My frustration when I see libraries and applications developed is always the same: You are provided by the JDK with a common logging system available to anyone without the need of any external JAR. You also write the same code when you want to log something.

So why the hell are people keep using libraries like SLF4J or commons-logging or even more !!!!

The JDK logging API, even if not as good as log4j, does everything you need. A shortcoming was that the JDK logging system is not well designed to work in an application server and have each web application controlling its own logging configuration. This is mainly due to the fact that java.* classes are directly loaded from the system classloader.

But this is not the case anymore !!!

I've written a very small JAR which you can put in your application server common libraries. This JAR enables your web applications to use the JDK logging system and have each different configurations.

You will find all information here: http://code.google.com/p/mycila/wiki/JdkLoggingPerWebapp

So now your don't need to use any logging wrapper anymore !! Just use the standard JDK Logging API.

But wait !!!

You can now develop libraries and code completely independent of any logging libraries. But what if someone wants to use the JDK API but still want to output logs with log4j (log rotation, compression, ...) ?

Writing a wrapper for the JDK Logging system is trivial ! Here is one that can redirect all JDK logging calls to log4j:

import org.apache.log4j.Level;
import org.apache.log4j.Logger;

import java.util.HashMap;
import java.util.Map;
import java.util.logging.Handler;
import java.util.logging.LogManager;
import java.util.logging.LogRecord;

/**
 * @author Mathieu Carbou
 */
public final class JdkOverLog4j extends Handler {

    private static final Map<java.util.logging.Level, Level> LEVELS_JDK_TO_LOG4J = new HashMap<java.util.logging.Level, Level>() {
        {
            put(java.util.logging.Level.OFF, Level.OFF);
            put(java.util.logging.Level.SEVERE, Level.ERROR);
            put(java.util.logging.Level.WARNING, Level.WARN);
            put(java.util.logging.Level.INFO, Level.INFO);
            put(java.util.logging.Level.CONFIG, Level.INFO);
            put(java.util.logging.Level.FINE, Level.DEBUG);
            put(java.util.logging.Level.FINER, Level.DEBUG);
            put(java.util.logging.Level.FINEST, Level.DEBUG);
            put(java.util.logging.Level.ALL, Level.ALL);
        }
    };

    private static final Map<Level, java.util.logging.Level> LEVELS_LOG4J_TO_JDK = new HashMap<Level, java.util.logging.Level>() {
        {
            put(Level.OFF, java.util.logging.Level.OFF);
            put(Level.FATAL, java.util.logging.Level.SEVERE);
            put(Level.ERROR, java.util.logging.Level.SEVERE);
            put(Level.WARN, java.util.logging.Level.WARNING);
            put(Level.INFO, java.util.logging.Level.INFO);
            put(Level.DEBUG, java.util.logging.Level.FINE);
            put(Level.TRACE, java.util.logging.Level.FINE);
            put(Level.ALL, java.util.logging.Level.ALL);
        }
    };

    @Override
    public void publish(LogRecord record) {
        // normalize levels
        Logger log4jLogger = Logger.getLogger(record.getLoggerName());
        Level log4jLevel = log4jLogger.getEffectiveLevel();
        java.util.logging.Logger jdkLogger = java.util.logging.Logger.getLogger(record.getLoggerName());
        java.util.logging.Level expectedJdkLevel = LEVELS_LOG4J_TO_JDK.get(log4jLevel);
        if (expectedJdkLevel == null)
            throw new AssertionError("Level not supported yet - have a bug !" + log4jLevel);
        if (!expectedJdkLevel.equals(jdkLogger.getLevel())) {
            jdkLogger.setLevel(expectedJdkLevel);
        }
        log4jLogger.log(record.getLoggerName(), LEVELS_JDK_TO_LOG4J.get(record.getLevel()), record.getMessage(), record.getThrown());
    }

    @Override
    public void flush() {
    }

    @Override
    public void close() throws SecurityException {
    }

    public static void install() {
        LogManager.getLogManager().reset();
        LogManager.getLogManager().getLogger("").addHandler(new JdkOverLog4j());
        LogManager.getLogManager().getLogger("").setLevel(java.util.logging.Level.ALL);
    }
}

Simply put this class in your webapp and at the startup of your webapp, run the code:

JdkOverLog4j.install();

Now all calls to the JDK Logging system are redirected to Log4j !!!

So now you have the best of both world:

You are using the standard java.util.logging API
You are not binding your code to any logging library or wrapper
The client can decide which system he will use
You can still use log4j at the very end, but your application and libraries will be even more loosely coupled to it

Compagnies de Design

2010-12-23T07:54:00.000-05:00

Rech. compagnies de design (industriel, produit ou intérieur) sur Montréal: en connaissez-vous ?