Splitting the sql-file
I just read every line in with PHP and when I encounter a comment (– ), I create a new file.

//Set time limit to one hour
set_time_limit(3600);

$dir = '/path/to/store/splits';
$file = '/path/to/large/sql/file.sql';

$i = 1000000;
//open large sql-file
$handle = fopen($file,"r");
if($handle) {
	while(($buffer = fgets($handle)) !== false) {
		//read line and append it to the file with name $i.sql
		$newfile = fopen($dir . '/' .$i . '.sql', 'a+');
		fwrite($newfile,$buffer);
		//if a comment is found, create a new file
		if(substr($buffer,0,3) === '-- '){
			$i++;
		}
	}
fclose($handle);
}

Splitting this 20Gb file took about 10 minutes on my server and created approximately 500 files. The largest file was 5Gb and I know I could import a 5Gb-file without a problem.

Importing the sql-file
Importing the file was pretty simple. I wrote a script that loops over all the files and imports them into the database.

set_time_limit(3600000);

//The directory containing the splitted files
$dir = '/path/to/store/splits';

$files = scandir($dir);

ob_start();
//loop over the files and import them into the database
foreach($files as $file){
	echo $dir . $file . "\n";
	system("mysql -u mysql_username -pmysql_password mysql_databasename < $dir/$file");
	ob_flush();
}

In my case, it took more than 8 hours to completely import those database but with the help of these 2 scripts, it worked like a charm.

In this post I’ll try to teach you how to create a message driven bean which can communicate with an application client.
In order to follow this tutorial, I’ll assume you have Netbeans (6.9) and Glassfish available on your system.

Creating the Message driven bean

Create a new project in Netbeans and choose for a Java EE – EJB Module.

Create a new project

Next, give your project a name and make sure you select Glassfish 3 as your server and Java EE 6 as your Java EE version.

Server and settings

Than you can add a new Message Driven Bean to your project

Add a Message Driven Bean

Give the Bean a name and a package.
Click next to destinations on the Add button to add a destination.
Choose a name for your destination.
Choose between Queue or Topic. In this example it isn’t important which one you choose. The difference between Topic and Queue is if you want Point-to-point or Publish/subscribe communication for your beans.

Name your bean

Netbeans creates code for you and, except for the actual businesscode, your bean is ready.

In this simple example, I just want to pass a name from my applicationclient to my bean and my bean has to echo “Helllo name”

The full code looks like this:

package hello;

import java.util.logging.Level;
import java.util.logging.Logger;
import javax.ejb.ActivationConfigProperty;
import javax.ejb.MessageDriven;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;

@MessageDriven(mappedName = "jms/hello", activationConfig =  {
        @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
        @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue")
    })
public class HelloBean implements MessageListener {

    public HelloBean() {
    }

    public void onMessage(Message message) {
        try {
            System.out.println("Hello " + message.getStringProperty("name"));
        } catch (JMSException ex) {
            Logger.getLogger(HelloBean.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

Almost all the configuration is mapped into 1 annotation.
- The annotation @MessageDriven transforms your normal class into an actual Message Driven Bean.
- The @ActivationConfigProperty annotation is to be used for defining properties to your bean such as the acknowledge mode, message selector, subscription durability and destination type.
In previous versions of JEE, you had to create an XML-file to define all these properties.

Our bean is finished and can be deployed.
Start your Glassfish server and simply click on the deploy button to deploy your bean into Glassfish.

If you open your Glassfish admin console (by default located at http://localhost:4848/ ), you should see that your application is successfully deployed and activated into Glassfish.

Also verify that the JMS resources for your MDB are succesfully created

Creating the Application client

The MDB is created and is waiting for messages. Now it’s time to create the Application client.
Just create a new project and choose for an Enterprise Applicaton Client from the list

The code for the applicaton client looks like this:

package mdbclient;

import javax.annotation.Resource;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;

public class Main {

    @Resource(mappedName = "jms/helloFactory")
    private static ConnectionFactory connectionFactory;

    @Resource(mappedName = "jms/hello")
    private static Queue queue;

    public static void main(String[] args) throws JMSException {
        Connection connection = connectionFactory.createConnection();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        MessageProducer producer = session.createProducer(queue);
        Message message = session.createTextMessage();
        message.setStringProperty("name", "World!!");
        producer.send(message);
        System.exit(0);
    }
}

If you deploy and run this application you should see in the server output the string “Hello World!!

What’s going on?
First we have to create 2 resources to inject the parameters into the Queue and ConnectionFactory . This can be done easily with the @resource annotation.
Next, we just have to create the actual jms-message. I think the code is pretty clear so it shouldn’t be to difficult to understand what’s going on.

Remote invocation

It would be cool if we can run the client from a remote computer.
This is also very easy with webstart.

Go to your Glassfish admin and simply enable Java Web Start.

If you launch this jnpl file from a remote compter, you should again see the message “Hello World!!” in your Glassfish Server output.

When you get an error, it’s possible that you have to change the IP address of the orb-listener-1 to the IP address of the computer where your Glassfish is running on.

Happy Messaging!!

Luckily, using Google Optimizer for dynamic content isn’t that hard with a little planning.
Google has put an article about this topic in their online help but I don’t like this solution very much. I have found 2 other ways to use Optimizer with dynamic content: the CSS and the Ajax way.
I’ll try to describe both of them in this blogpost.

In my examples I’ll use PHP as dynamic language. The code is far from difficult so you propably can translate it easy in the language you prefer.

The CSS way

In this technique, you basically load every scenario but display only one of them. The displaying of the right scenario is done through a little bit of CSS-magic.
In this example, I will test the contents of a div with 3 scenario’s:
Just create a multivariate experiment in Google and add the optimizer tags to your code.
A good rule of thumb is: add as little as possible between the utmx_section script tags. In this case, just try to add only a tag with a css selector.
This is my example source code and my test in Optimizer:

<html>
    <head> 

        <!-- Google Website Optimizer Control Script -->
	… Optimizer head script…
        <!-- End of Google Website Optimizer Control Script --> 

        <title>Example A/B test with css</title>
        <style type="text/css">
            .variantA {background-color:yellow;}
            .variantB {background-color:#00CCFF;}
            .variantC {background-color:red;}
            #testA .variantB {display:none}
            #testA .variantC {display:none}
            #testB .variantA {display:none}
            #testB .variantC {display:none}
            #testC .variantA {display:none}
            #testC .variantB {display:none}

        </style>
    </head> 

    <body>
        <!—Add as little as possible between utmx_section-->
        <script>utmx_section("sectionA")</script>
        <div id="testA">
        </noscript>
        <!-- TestA -->
        <div class="variantA"><a href="result.php">
                This is dynamic content A which displays a date:
                <?php echo date('l jS \of F Y'); ?>
        </a></div>
        <!-- TestB -->
        <div class="variantB"><a href="result.php">
                this is dynamic content B whic displays the time:
                <?php echo date('h:i:s A'); ?>
        </a></div>
        <!-- TestC -->
        <div class="variantC"><a href="result.php">
                This is dynamic content C which displays the date and time:
                <?php echo date('l js \of FY h:i:s A'); ?>
        </a></div>
    </div>
    <!-- Google Website Optimizer Tracking Script -->
	…optimizer body script…
    <!-- End of Google Website Optimizer Tracking Script -->
</body>
</html>

Test A:

Test B:

Test C:

As you see, when testA is loaded by Google, we just set everything for testB and testC (variantB/variantC) to display:none in css so it just will not be displayed in the browser.
For testB, you hide testA and testC and if you test testC, you hide testA and testB.

Conclusion

• Pro:
• Very easy to set up
• Con:
• When testing many variants, the css becomes big and difficult to maintain
• All the code from the 3 tests will be executed. In this example, that’s not a problem but if you want to test scenario’s which create a heavy load on your server or use code which runs for a long time, this way to test becomes quickly painful.

The Ajax way

This technique is much better to test larger scenarios. You can create an ajax call which will just load the code you need.

You can create the Ajax by hand with a XMLHttpRequest but I prefer using a javascript framework like JQuery which makes the creation of Ajax calls very easy to do. In my example, I’ll put the content received from the Ajax call into the div with id “test”.
The dynamic content of every test is inside it’s own script (a.php, b.php,c.php) which makes this scenario clean and very flexible.

This is my example source code and my test in Optimizer:

<html>
    <head>
        <!-- Google Website Optimizer Control Script -->
        …head script of optimizer…
        <!-- End of Google Website Optimizer Control Script -->

        <script src="jquery-1.4.4.min.js"></script>
        <title>A/B test with Ajax calls</title>
    </head>

    <body>
        <div id="test"></div>
        <script>utmx_section("Ajaxtest")</script>
        <script type="text/javascript">
            $('#test').load('a.php');
        </script>
    </noscript>

    <!-- Google Website Optimizer Tracking Script -->
    ..body script optimizer…
    <!-- End of Google Website Optimizer Tracking Script -->
</body>
</html>

Test A:

Test B:

Test C:

So Google decides wich Ajax call will be made. The appropriate script will be loaded and executed.

Conclusion

• Pro:
• Very easy to set up
• Very flexible
• Only the desired test will be loaded
• Changes can be made in the scripts while the test is running
• Con:
• The content of the test will be retrieved after the page is loaded so this can become slow.

Look at the following code:

//Create an array
$array=array('a','b','c','d','e','f','g');

//Loop over the array by reference
foreach($array as &$a){
}

//Loop again over the array
foreach($array as $a){
}

//Print the array
print_r($array);

What do you think the output would be if you run this piece of code?
Because the array is never changed, the expected result would be:

Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
    [4] => e
    [5] => f
    [6] => g
)

If that was the case, I obviously wouldn’t made this blogpost
The result of the code is:

Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
    [4] => e
    [5] => f
    [6] => f
)

What’s going on??
Well…
When you loop the first time over the array, the variable $a will be referenced to the array $array.
This means that with every iteration $a points to the specified element in the array.
After every element passed the foreach, $a still points to the last element in the array. In this case ‘g’.

Now you have to loop again over the array.
When the first element ‘a’ is passed to the foreach. $a will be set to ‘a’ but there is still a reference to $a from the previous foreach, which holds the value ‘g’. Because it’s a reference, the value of ‘g’ in the array changes to ‘a’.
When the second element ‘b’ is passed to the foreach. $a will be set to ‘b’ but the reference to $a still exists so the value of the referenced $a changes from ‘a’ to ‘b’
And so on.

If you print the value of the array at every iteration, you will have the following output:

Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => a )
Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => b )
Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => c )
Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => d )
Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => e )
Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => f )
Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => f )

What to do??
1. Don’t use references in a foreach. Really. If you have to do it, you propably are doing something wrong.
2. If you do need them, delete them after they are used:

$array=array('a','b','c','d','e','f','g');

//Loop over the array
foreach($array as &$a){
}
//remove the reference
unset($a);
//loop again over the array. The output looks like expected
foreach($array as $a){
        print_r($array);
}

3. If you do need them and you can’t delete it because you need the variable elsewhere. Document your code!!!
This little piece of code is very hard to debug when there’s something wrong. Good documented code can save you a lot of headache.

package be.eek.test.mysql;

import java.io.IOException;
import java.io.InputStream;

public class MysqlBackup {

    /**
    main method is just to create a working example
    **/
    public static void main(String[] args) throws IOException {
        new MysqlBackup().MakeBackup();
    }

    public void MakeBackup() throws IOException {
        String dump = "mysqldump "      //Path to mysql
                + "--host=localhost "       //Mysql hostname
                + "--port=3306 "            //Mysql portnumber
                + "--user=root "            //Mysql username
                + "--password=test "        //Mysql password
                + "--add-drop-table "       //Add a DROP TABLE statement before each CREATE TABLE statement
                + "--add-drop-database "    //Add a DROP DATABASE statement before each CREATE DATABASE statement
                + "--complete-insert "      //Use complete INSERT statements that include column names.
                + "--extended-insert "      //Use multiple-row INSERT syntax that include several VALUES lists
                + "test";                   //Mysql databasename

        Process run = Runtime.getRuntime().exec(dump);

        InputStream in = run.getInputStream();

        int nextChar;
        StringBuffer sb = new StringBuffer();

        while ((nextChar = in.read()) != -1) {
            sb.append((char) nextChar);
        }

        //Here, you can for example write it to a file and save it
        System.out.println(sb);
    }
}

The same thing is also possible in php:

$dump = "mysqldump "
        . "--host=localhost "       //Mysql hostname
        . "--port=3306 "            //Mysql portnumber
        . "--user=root "            //Mysql username
        . "--password=test "        //Mysql password
        . "--add-drop-table "       //Add a DROP TABLE statement before each CREATE TABLE statement
        . "--add-drop-database "    //Add a DROP DATABASE statement before each CREATE DATABASE statement
        . "--complete-insert "      //Use complete INSERT statements that include column names.
        . "--extended-insert "      //Use multiple-row INSERT syntax that include several VALUES lists
        . "test";                   //databasename

$backup = system($dump);
echo $backup;
die();

I wasn’t very happy with these 3 directories because I wanted to categorize my media in other directories. In this post, I will post how I’ve resolved this problem.

First, enable SSH access to the NAS and log in.

My first idea to tackle this issue was to use of symbolic links

ln -s /volume1/MyMusicDirectory /volume1/music

I’ve re-indexed my files on the NAS and everything worked instantly. All the files in MyMusicDirectory where indexed so I was very happy…but not for long.
I noticed quickly that the new files I’ve placed in MyMusicDirectory weren’t auto-indexed by the NAS. I always had to re-index through the webinterface which can take hours when there is a lot of data to index so that was a big issue.
I figured out what the problem was: symbolic links will be considered as files and not as directories so the autoindexer wouldn’t follow the symbolic link.

Up to idea 2: mount –bind
I used mount –bind to create an unbreakable link which normally would be used as a directory by the NAS so the contents could be auto-indexed.

mount --bind /volume1/MyMusicDirectory /volume1/music

It worked!! YES!!
Till I’ve rebooted the NAS. The mount was gone and I had to manually add it again. Not something I want to do at every reboot.

Up to idea 3: changing fstab
The file /etc/fstab will be loaded at startup to mount the filesystem so I’ve added the following rule in the file:

/volume1/MyMusicDirectory /volume1/music bind defaults,bind 0 0

I saved the file and rebooted and it didn’t worked. The fstab file will be overridden at startup with Synology’s default fstab-file so the rule I’ve entered before was deleted.

And then idea 3: The solution
Create a file rc.local

touch /etc/rc.local

open the file and add the following line:

mount --bind /volume1/MyMusicDirectory /volume1/music

Now restart the NAS and you’re done.
The files in MyMusicDirectory will be auto-indexed by the media server.

Xml Attributes

In this first example, I’ll show you how the lifecycle of a bean happens within the xml-configfile.

In the xml-file, we can define an init- and destroy-method to the bean, which will be called automatically by Spring.
Config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean id="attributesTest" class="a.Test" init-method="initMethod" destroy-method="destroyMethod">
    </bean>
</beans>

Main program
In this case, I’ll use AbstractApplicationContext because this Context has a function to destroy the Context which a normal ApplicationContext doesn’t have.

package a;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class XmlAttributesTest {
    public static void main(String[] args) {
        AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("Config.xml");
        ctx.registerShutdownHook();
        Test test =  ctx.getBean("attributesTest",Test.class);
    }
}

Test.java

package a;

public class Test{

    public Test(){
        System.out.println("We are in the constructor of Test");
    }

    public void initMethod(){
        System.out.println("We are in initMethod of Test");
    }

    public void destroyMethod(){
        System.out.println("We are in destroyMethod of Test");
    }

}

The output will be:

We are in the constructor of Test
We are in initMethod of Test
We are in destroyMethod of Test

It’s also possible to declare default init- and destroy-methods in the xml-file. This is done in the beans-tag:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
       default-init-method="initMethod"
       default-destroy-method="destroyMethod">
...

LifeCycles with interfaces

It’s possible to call the lifecyclemethods by implemnting a Spring interface.
It’s very easy to do but I don’t recommend this because when you use the interfaces, your code will be highly coupled to the Spring Framework which isn’t always a good case.
Config.xml
You don’t have to set an init and destroy method in the xml-file

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean id="interfacesTest" class="b.Test">
    </bean>
</beans>

Main program
This is always the same…

package b;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class InterfaceTest {

    public static void main(String[] args) {
        AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("Config.xml");
        ctx.registerShutdownHook();
        Test test =  ctx.getBean("interfacesTest",Test.class);
    }
}

Test.java
We have to implement InitializingBean for init-methods and DisposableBean for destroy-methods

package b;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class Test implements InitializingBean, DisposableBean {

    public Test(){
        System.out.println("We are in the constructor of Test");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("We are in afterPropertiesSet of Test");
    }

    public void destroy() throws Exception {
        System.out.println("We are in destroy of Test");
    }
}

Lifecycle with annotations

Config.xml
Don’t forget to include to enable annotations with the Contextparameters in the xml-file

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

            http://www.springframework.org/schema/context/spring-context-3.0.xsd">
   <context:annotation-config/>

    <bean id="annotationsTest" class="c.Test">
    </bean>

</beans>

Main program
Still the same…

package c;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AnnotationsTest {

    public static void main(String[] args) {
        AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("Config.xml");
        ctx.registerShutdownHook();
        Test test = ctx.getBean("annotationsTest", Test.class);
    }
}

Test.java
We can use the lifecyclemethods with the annotations @PostConstruct for init-methods and @PostDestroy for destroy-methods.

package c;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class Test {

    public Test() {
        System.out.println("We are in the constructor of Test");
    }

    @PostConstruct
    public void start(){
        System.out.println("We are in the start-method of Test");
    }

    @PreDestroy
    public void stop(){
        System.out.println("We are in the stop-method of Test");
    }
}

Putting them all together

It’s possible to use the 3 methods all together
Config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

            http://www.springframework.org/schema/context/spring-context-3.0.xsd">
   <context:annotation-config/>

    <bean id="allTogether" class="d.Test" init-method="initMethod" destroy-method="destroyMethod">
    </bean>
</beans>

Main program

package d;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AllTogetherTest {

    public static void main(String[] args) {
        AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("Config.xml");
        ctx.registerShutdownHook();
        Test test = ctx.getBean("allTogether", Test.class);
    }
}

Test.java
We are using interfaces AND annotations.
It’s even possible to use multiple times the same annotation:

package d;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class Test implements DisposableBean,InitializingBean {

    public void destroy() throws Exception {
        System.out.println("DisposableBean-Interface");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean-Interface");
    }

    @PostConstruct
    public void start(){
        System.out.println("First PostConstruct");
    }

    @PostConstruct
    public void start2(){
        System.out.println("Second PostConstruct");
    }

    @PostConstruct
    public void start3(){
        System.out.println("Third PostConstruct");
    }

    @PreDestroy
    public void stop(){
        System.out.println("PreDestroy");
    }

    public void initMethod(){
        System.out.println("initMethod");
    }

    public void destroyMethod(){
        System.out.println("destroyMethod");
    }
}

The output is:

Third PostConstruct
Second PostConstruct
First PostConstruct
InitializingBean-Interface
initMethod
PreDestroy
DisposableBean-Interface
destroyMethod

So we can conclude that the annotations are processed first, followed by the interfaces and at last the methods from the xml-file.

If you want to log in like this, Firefox will show you a dialog where you have to confirm that you want to login directly into the website.

This is done for some securityreasons because it’s possible, like the dialog says, to trick a user to the wrong site.
Take for instance the following url:
http://www.eek.be&login:password@example.com/badsite
This url looks perfectly valid but if you have a good look at it, you will see that the url is not one of eek.be but one of example.com. So when a user clicks this link, it will be redirected to a page he didn’t expected or worse, a site that looks like the page he thinks he expects which asks him for his creditcard/username/password/…

So this built in security in Firefox is a very good case.
But in some cases, you just want to login to a site without that annoying alertbox. Luckily, In firefox, it’s possible to configure this option.
Go to the options in Firefox by surfing to:

about:config

You should get a warning but you can proceed without any concerns.

Now you have to rightclick inside the optionsscreen and choose new->integer
A popup shows up and you have to fill in the optionsname

network.http.phishy-userpass-length

secondly, you have to give a value to the option.
In this case, the value means how many characters a login can have before the dialog appears. By default it’s 1 in Firefox. In this case I change it to 100 which is enough in most cases.
If you want to disable it always, you have to set the integer to 255.

In this little blogpost, I’ll try to explain the differences between ServletConfig and ServletContext and when you can use them into a Java Web Application.

ServletConfig

ServletConfig is actually very simple. Like stated above, you can retrieve parameters for the servlet which are set at deployment time.
I’ll explain this with a very simple example.

If you have created a servlet with the name “MyServlet” you can add the following 2 variables into the servlet:

    <servlet>
         <servlet-name>MyServlet</servlet-name>
         <servlet-class>servlets.MyServlet</servlet-class>
         <init-param>
             <param-name>variable1</param-name>
             <param-value>I'm var1</param-value>
         </init-param>
         <init-param>
             <param-name>variable2</param-name>
             <param-value>I'm var2</param-value>
         </init-param>
     </servlet>
     <servlet-mapping>
         <servlet-name>MyServlet</servlet-name>
         <url-pattern>/MyServlet</url-pattern>
     </servlet-mapping>

You can retrieve variable2 with the following code:

getServletConfig().getInitParameter("variable2");

Retrieve all the variables of the servlet and loop over them:

Enumeration allvars = getServletConfig().getInitParameterNames();
while (allvars.hasMoreElements()) {
     String next = (String) allvars.nextElement();
     out.println(next + " has the value " + getServletConfig().getInitParameter(next));
}

It’s also possible to retrieve the servlets name through getServletconfig

out.println("The name of the servlet is: " + getServletConfig().getServletName());

ServletContext

ServletContext can be used to retrieve application-wide parameters, get serverparameters and store/retrieve/remove application-wide attributes.

It is possible to call the ServletContext right on or through the ServletConfig. Both are the same so you can choose between them.

if (getServletContext().equals(getServletConfig().getServletContext())) {
       out.println("both calls retrieve the same Context");
}

Just like with ServletConfig, you can set parameters in the Deployment Descriptor. They are initialized on compile time. It’s not possible to remove or add them on runtime.

<context-param>
        <param-name>variable3</param-name>
        <param-value>Im var 3</param-value>
</context-param>

And call them in your servlet just like the ServletConfig parameters:

getServletContext().getInitParameter("variable3")

Unlike ServletConfig, ServletContext can work with attributes. These are parameters or objects which you can set into the servlet and retrieve in every other servlet of your Web Application:

getServletContext().setAttribute("test", "I'm an application-wide String");
..
out.println(getServletContext().getAttribute("test"));
..
getServletContext().removeAttribute("test");

I’ll end this little short tutorial with an example of how you can retrieve serversettings through the Context:

out.println(getServletContext().getContextPath());
out.println(getServletContext().getMajorVersion());
out.println(getServletContext().getRealPath(""));
out.println(getServletContext().getServerInfo());

If there are any more questions, just shoot them

Annotation based DI
It’s possible in Guice to inject a class with the help of annotations. In this example, I create a mainclass which creates an order. Inside the order there will be a payment done. There are 2 types of payments (by card or cash) and they will be injected by Guice.
Payment

public interface Payment {
    public void pay();
}

PaymentCash

public class PaymentCashImpl implements Payment {
    public void pay() {
        System.out.println("I'll pay just plain cash");
    }
}

PaymentCard

public class PaymentCardImpl implements Payment{
    public void pay() {
        System.out.println("I'll pay with a credit card");
    }
}

Order

public class Order {

    private Payment payment;

    public Payment getPayment() {
        return payment;
    }

    public void setPayment(Payment payment) {
        this.payment = payment;
    }

    public void finishOrder(){
        this.payment.pay();
    }
}

Main

public class Main {
    public static void main(String[] args) {
        Order order = new Order();
        Payment payment = new PaymentCardImpl();
        order.setPayment(payment);
        order.finishOrder();
    }
}

There isn’t any Dependency injection in the code above. All the classes are highly coupled into each other. So it’s time to do some magic:
Payment
You can tell through the use of annotations which Payment type is the default implemented class

@ImplementedBy(PaymentCardImpl.class)
public interface Payment {
    public void pay();
}

Order
Inject the payment type in the order. What we here say is: Inject the default paymentimplementation, which is set by the @implementedby annotation, into the payment field.

public class Order {
    @Inject
    private Payment payment;
....

Main
Lastly, we have to rewrite the main class. In this example, we get an order which uses the PaymentCard as payment type

public class Main {
    public static void main(String[] args) {
       Injector injector = Guice.createInjector();
        Order order = injector.getInstance(Order.class);
        order.finishOrder();
    }
}

You can run this code. The output should be -I’ll pay with a credit card-. This code is so cool because if we want to switch to payment with cash at a later point, we just have to change the @implementedBy annotation in the interface and we are done.

Injection types
Guice knows different types of injection. The 3 most used are constructor, field and method injection (Examples are based on the above example)
Constructor injection

import com.google.inject.Inject;

public class Order {
    private Payment payment;

    @Inject
    public Order(Payment payment){
        this.payment=payment;
    }
   ...
}

Method injection

import com.google.inject.Inject;

public class Order {
    private Payment payment;

    @Inject
    public void setPayment(Payment payment) {
        this.payment = payment;
    }
   ...
}

Field injection

public class Order {
    @Inject
    private Payment payment;
   ...
}

Module based DI
It’s also possible to use Modules for injecting data. It’s maybe a little more work but I like it because all the configuration is in the same file. You can compare this with the xml-file in Spring applications.
Payment
Remove the @ImplementedBy annotation in the paymentinterface

public interface Payment {
    public void pay();
}

MyModule
Next, create the Module class. It has to implement Module, which has one method: configure.
The code speaks for its self. You say nothing more than bind Payment to PaymentCard.

public class MyModule implements Module {
    public void configure(Binder arg0) {
        arg0.bind(Payment.class).to(PaymentCardImpl.class);
    }
}

Instead of implementing Module, you can also extend AbstractModule. It’s just a matter of choice.

public class MyModule extends AbstractModule {
    public void configure() {
        bind(Payment.class).to(PaymentCardImpl.class);
    }
}

Main
Lastly, we have to put the module into our injector and we are done.

public class Main {
    public static void main(String[] args) {
        MyModule module = new MyModule();
        Injector injector = Guice.createInjector(module);
        Order order = injector.getInstance(Order.class);
        order.finishOrder();
    }
}

The 4 lines in the main class can be written into 1 single line:

public class Main {
    public static void main(String[] args) {
        Guice.createInjector(new MyModule()).getInstance(Order.class).finishOrder();
    }
}

Subclassing
In Guice, it’s easy to subclass an implementation.
Payment

public interface Payment {
    public void pay();
}

PaymentCardImpl

public class PaymentCardImpl implements Payment{
    public void pay() {
        System.out.println("I'll pay with a credit card");
    }
}

PaymentVisaCard
extend payment card with paymentvisacard

public class PaymentVisaCard extends PaymentCardImpl {
    public void pay() {
        System.out.println("I'll pay with a card from Visa");
    }
}

Nothing special in the Main class
Main

public class Main {
    public static void main(String[] args) {
        Guice.createInjector(new MyModule()).getInstance(Payment.class).pay();
    }
}

MyModule
You can specify the hierarchy in the moduleclass

public class MyModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(Payment.class).to(PaymentCardImpl.class);
        bind(PaymentCardImpl.class).to(PaymentVisaCard.class);
    }
}

If you run this code, the Visa Card will be used.
Annotationbindings
It’s also possible to use annotations for injection
Payment
There’s nothing special in the interface and implementations:

public interface Payment {
    public void pay();
}

PaymentCardImpl

public class PaymentCardImpl implements Payment{
    public void pay() {
        System.out.println("I pay with a card");
    }
}

PaymentCashImpl

public class PaymentCashImpl implements Payment {
    public void pay() {
        System.out.println("I pay cash");
    }
}

Next, we have to created the annotations @cash and @Card
Cash

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

import com.google.inject.BindingAnnotation;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.PARAMETER})
@BindingAnnotation
public @interface Cash { }

Card

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

import com.google.inject.BindingAnnotation;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.PARAMETER})
@BindingAnnotation
public @interface Card { }

Main

public class Main {
    public static void main(String[] args) {
        Guice.createInjector(new PayModule()).getInstance(Order.class).finishOrder();
    }
}

Module
You have to specify which annotations refers to which implementation in the moduleclass

public class PayModule extends AbstractModule{
    @Override
    protected void configure() {
        bind(Payment.class).annotatedWith(Cash.class).to(PaymentCashImpl.class);
        bind(Payment.class).annotatedWith(Card.class).to(PaymentCardImpl.class);
    }
}

Order
Now you can use the annotation in your code to inject the right class

public class Order {

    @Inject
    private @Card Payment payment;
   ...

If you want to chane Cardpayments to Cashpayments, just change the @Card annotation to @Cash

Namedannotationbindings
You can also use named annotations. This is a Guice annotation where the value is specified inside the moduleclass.
The paymentinterface, the Main and the Cash and Card implementations are the same as the previous example.
Module
Give the annotations a name (“Cash” and “Card”)

public class PayModule extends AbstractModule{
    @Override
    protected void configure() {
        bind(Payment.class).annotatedWith(Names.named("Cash")).to(CashPayment.class);
        bind(Payment.class).annotatedWith(Names.named("Card")).to(CardPayment.class);
    }
}

Main

 * @author wim
 */
public class Main {
    public static void main(String[] args) {
        Injector inj = Guice.createInjector(new PayModule());
        Order order = inj.getInstance(Order.class);
        order.getPaymentCard().pay();

        Guice.createInjector(new PayModule()).getInstance(Order.class).getPaymentCash().pay();
    }
}

Order
Now you can use them in your order

public class Order {

    private Payment paymentCash;
    private Payment paymentCard;

    @Inject
    public void setPaymentCash(@Named("Cash") Payment payment){
        this.paymentCash=payment;
    }

    public Payment getPaymentCash(){
        return paymentCash;
    }

    @Inject
    public void setPaymentCard(@Named("Card") Payment payment){
        this.paymentCard=payment;
    }

    public Payment getPaymentCard(){
        return paymentCard;
    }
}

These annotations are very simple but I don’t recommend them. Guice doesn’t check them on spelling or validity so they are kinda error prone.
Instancebinding
With instancebinding, you can easily give a value to an instance
Module
Give a value to a name inside the module

public class MyModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(String.class)
        .annotatedWith(Names.named("PaymentType"))
        .toInstance("...I'm a Visa Card...");
    }
}

Main

public class Main {
    public static void main(String[] args) {
        String text = Guice.createInjector(new MyModule()).getInstance(Order.class).getText();
        System.out.println(text);
    }
}

Order
Use the annotation. The String text will be injected with “…I’m a Visa Card…”.

public class Order {

    @Named("PaymentType")
    @Inject
    private String text;

    public String getText(){
        return text;
    }
}

Providers
The last example is with the use of providers.
A provider can be used when you have to craete an object. You have to annotate it with the @Provides annotation and the return type is the bound type.
Payment

public interface Payment {
    void pay();
    int getAmount();
}

CashPayment

public class CashPayment implements Payment{

    private int amount;

    public void pay() {
        System.out.println("Inside cashpayment");
    }

    public void setAmount(int amount){
        this.amount=amount;
    }

    public int getAmount(){
        return amount;
    }
}

Main

public class Main {
    public static void main(String[] args) {
        Payment payment = Guice.createInjector(new MyModule()).getInstance(Payment.class);
        payment.pay();
        System.out.println(payment.getAmount());
    }
}

MyModule
Inside the module class, we can construct the class and set the amount of payment.

public class MyModule extends AbstractModule{

    @Override
    protected void configure() {
    }

    @Provides
    Payment providePayment(){
        CashPayment pay = new CashPayment();
        pay.setAmount(100);
        return pay;
    }
}

Conclusion
You can do more with Guice than described above but that’s up to you to find out.
I love Guice!! It’s pretty simple and works very good. You don’t have to use XML to bind your classes and it’s very lightweight. If you just wan’t to use Dependency Injection, Guice is in my opinion the number 1.

$ telnet localhost 11211
Trying 127.0.0.1…
Connected to localhost.
Escape character is ‘^]’.
flush_all
OK
quit
Connection to localhost closed by foreign host.
$

You have to log in into the appropriate memcached host and port with telnet. After logged in, you have to use the flush_all command. If this command responses with OK, everything went fine and you can log out of your memcached server using the command quit.

The above command works fine but is a pain in the ass if you have to flush a lot and wants to use your console for other things.
If this is the case, you can run a flush_all in 1 command

echo 'flush_all' | nc localhost 11211

By default, nc (or netcat) creates a TCP socket either in listening mode (server socket) or a socket that is used in order to connect to a server (client mode). Actually, netcat does not care whether the socket is meant to be a server or a client. All it does is to take the data from stdin and transfer it to the other end across the network.