Java by experience

The builder pattern in Kotlin

2018-09-25T03:06:00.003-07:00

Introduction

The most of you are probably familiar with the builder pattern. I used this pattern a couple of times in Java later on with the @Builder annotation from the Lombok project. I am aware of the fact that the annotations of Lombok project are also usable in Kotlin. This is just for fun or when you are not using Lombok for what reason suits you.

the code

For this example I used a data class called Address. I am aware that it lacks some fields but that is not important in this explanation. Ok, lets get down to it:

data class Address(
//The class members that will contain the data.
val addressLine1: String,
val addressLine2: String = "",
val city: String,
val zip: String,
//The builder class
class Builder {
private lateinit var addressLine1: String
private var addressLine2: String = ""
private var city: String = ""
private var state: String = ""
//The assignment to the class members.
fun addressLine1(addressLine1: String) = apply { this.addressLine1 = addressLine1 }
fun addressLine2(addressLine2: String) = apply { this.addressLine2 = addressLine2 }
fun city(city: String) = apply { this.city = city }
fun country(country: String) = apply { this.country = country }

//The build method we need to call.
fun build() = Address(
addressLine1,
addressLine2,
city,
state,
country
)
}

//The instanciation of the Adress class.
val address:Address = Address
// calling the builder class.
.Builder()
//filling the fields with data.
.addressLine1("Address1")
.addressLine2("Address2")
.city("City")
.country("Country")
//calling the build method
.build()

// Voila data
println(address.addressLine1)

Conclusion

As allways, with a new way you have to get used to the fact that things are different. If you are new to Kotlin this might look magical to you. At least it did to me. Now I am working with Kotlin for a while I am used to the syntax. I am capable of doing stuff in Kotlin I did not think I would ever do.

Have fun!

rpc call to bitcoind

2018-02-13T13:28:00.000-08:00

Introduction

Lately, in the news you can find a lot of material about bitcoins or the technique behind it. I have been reading a lot about this the last couple of months. It made me curious howto connect to the bitcoind myself. It must be possible too connect to the daemon and get that information yourself. I know, curiousity killed the cat. But I am still alive. Lets dive into the code and see what we should do.

The example

So lets get started with the fun shall we? The surprising part is that it was less difficult then I thought it would be. Too get the right parts of all the different examples together and make it work was the hardest part.

First of all we need the bitcoind. We can install the daemon and ask if it is still alive. That is why I prefer too install bitcoin-qt. This has an interface where you can see some things like if it is running on testnet. Install it like:

sudo add-apt-repository ppa:bitcoin/bitcoin 
sudo apt-get update
sudo apt-get install bitcoin-qt

place in the ~/.bitcoin folder the file bitcoin.conf. The content should be als followed to run on testnet:

## bitcoin.conf configuration file. Lines beginning with # are comments.
### Uncomment and edit options you wish to use.

## JSON-RPC options (for controlling a running bitcoin-qt/bitcoind process)

# server=1 tells Bitcoin to accept JSON-RPC commands.
server=1

# You must set rpcuser and rpcpassword to secure the JSON-RPC api
# You should create your own new random password.
# The username and password MUST NOT be the same.

rpcuser=user
rpcpassword=password

# How many seconds bitcoin will wait for a complete RPC HTTP request
# after the HTTP connection is established.
rpctimeout=30

# By default, only RPC connections from localhost are allowed. Specify
# as many rpcallowip= settings as you like to allow connections from
# other hosts (and you may use * as a wildcard character):
#rpcallowip=10.1.1.*
#rpcallowip=192.168.1.*

# Listen for RPC connections on this TCP port:
rpcport=8332

# You can use bitcoind to send commands to bitcoin-qt/bitcoind
# running on another host using this option:
rpcconnect=127.0.0.1

# Use Secure Sockets Layer (also known as TLS or HTTPS) to communicate
# with Bitcoin -server or bitcoind
#rpcssl=1

# OpenSSL settings used when rpcssl=1
rpcsslciphers=TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:@STRENGTH
rpcsslcertificatechainfile=server.cert
rpcsslprivatekeyfile=server.pem

## Network-related settings:

# Run on the test network instead of the real bitcoin network.
testnet=1

# Connect via a socks proxy
#proxy=127.0.0.1:9050

# Select the version of socks proxy to use (4-5, default: 5)
#socks=5

# Use proxy to reach tor hidden services (default: same as -proxy)
#tor=

##############################################################
## Quick Primer on addnode vs connect ##
## Let's say for instance you use addnode=4.2.2.4 ##
## addnode will connect you to and tell you about the ##
## nodes connected to 4.2.2.4. In addition it will tell##
## the other nodes connected to it that you exist so ##
## they can connect to you. ##
## connect will not do the above when you 'connect' to it.##
## It will *only* connect you to 4.2.2.4 and no one else.##
## ##
## So if you're behind a firewall, or have other problems ##
## finding nodes, add some using 'addnode'. ##
## ##
## If you want to stay private, use 'connect' to only ##
## connect to "trusted" nodes. ##
## ##
## If you run multiple nodes on a LAN, there's no need for##
## all of them to open lots of connections. Instead ##
## 'connect' them all to one node that is port forwarded ##
## and has lots of connections. ##
## Thanks goes to [Noodle] on Freenode. ##
##############################################################

# Use as many addnode= settings as you like to attempt connection to specific peers
#addnode=69.164.218.197
#addnode=10.0.0.2:8333

# or use as many connect= settings as you like to connect ONLY to specific peers:
#connect=69.164.218.197
#connect=192.168.1.20:8333

# Do not use Internet Relay Chat to find peers.
noirc=0

# Maximum number of inbound+outbound connections.
#maxconnections=125

# Miscellaneous options

# Pre-generate this many public/private key pairs, so wallet backups will be valid
# after future transactions.
#keypool=100

# Add an optional transaction fee every time you send bitcoins.
#paytxfee=0.01

# Add timestamps to debug.log
#logtimestamps=1

# User interface options

# Start Bitcoin minimized
#min=1

# Minimize to the system tray
minimizetotray=0

I post a lot of options so you can play with it if you like.

The whole thing is actually working on apache httpClient:

<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.3</version>
</dependency>


To start we have too do some boilerplate coding:



//To start with a Logger is like coffee in the morning.

Logger log = LoggerFactory.getLogger(RpcServer.class.getName());
//We have to provide some cred. too login to the bitcoind

//The username and password should match the ones in the conf file.

CredentialsProvider credsProvider = new BasicCredentialsProvider();
credsProvider.setCredentials(
        new AuthScope("127.0.0.1", 8332),
        new UsernamePasswordCredentials("user", "password"));

//Building a HttpClient for the start of the communication.

CloseableHttpClient client = HttpClients.custom()
        .setDefaultCredentialsProvider(credsProvider)
        .build();


//Setting up the request to the server. get ip and port from the

//~/.bitcoin/bitcoin.conf.


HttpPost request = new HttpPost("http://127.0.0.1:8332");

// no we start with the interesting part:

try {
    //This is the most interesting part. Here we setup the 
    //rpc call to the daemon. 
request.setEntity(new StringEntity("{\"jsonrpc\":\"1.0\" + 
,\"id\":\"curltext\",\"method\":\"getblockchaininfo\",\"params\":[]}"));
    // retrieving the response from the daemon
    HttpResponse response = client.execute(request);
    // converting the result to a string and print it.
    ByteArrayOutputStream byteArrayOutputStream = 
new ByteArrayOutputStream();
    response.getEntity().writeTo(byteArrayOutputStream);
    String theString = new String(byteArrayOutputStream.toByteArray());
    log.info(theString);
} catch (UnsupportedEncodingException e) {
    log.error("wrong url", e);
} catch (ClientProtocolException e) {
    log.error("wrong protocol", e);
} catch (IOException e) {
    log.error("io", e);
}

Conclusion

After a day of searching it was blissfully simple.

I enjoyed talking to the legendary bitcoin daemon and

get some information out of it. This is still a simple method.

The daemon has some more complex ones where you also might need some

parameters. At the line of request.setEntity, in the json part there

is also a parameter section. You can address all the parameters there.

Don't forget too change the method section.

For this see:

https://bitcoin.org/en/release/v0.15.0

Have fun!

spring boot service with Kotlin

2017-08-26T14:58:00.000-07:00

Introduction

Kotlin is a fairly new programming language orignally developed by jetbrains and these days supported on android by Google. Also since spring 5.0 is it possible to write kotlin programs in spring (also spring boot applications). Kotlin runs on the jvm and is easily compatible with excisting java classes.

The jvm it runs on at the moment I am writing this, is Java 6. No, dont worry the clever part is, that the team behind Kotlin found ways to make the features up to Java 8 available in te last version of Kotlin (1.1.4). The style of programming is more the kind of functional programming.

Unfortunally I cannot cover Kotlin complete in this post but It will give you a rough Idea How it works and how powerfull it is.

Lets play with some examples:

Example 1: Hello world

fun main(args: Array<String>) {
    println("hello world")
}

A view small points that should get our attention:


There is no class definition around the main method.
The declartion of the function is not void but fun
the args arguments is not an String[] array but an Array type.
The definition of the args is first the name : type.
The println() command. In java: System.out.println().

in this small example we allready see a lot of differences which actually 


lead to less code lines (lazy programmers like me love that).

The way the args types are declared, also goes for the declaration 

of the var types some examples:




val double: Double = 10.0 // 64 bit
val float: Float = 10.0F // or f, 32 bit
val long: Long = 10L // 64 bit
val int: Int = 10 // 32 bit
val hexadecimal = 0x0F // Prefix '0x'
val binary = 0b01 // Prefix '0b'





Example 2 calling a java class: 




// The java class

public class Test {

    public String hello() {
        return "Hello";
    }
}

// The Kotlin code:


//To declare a var you use var. To declare a constant you use val.
// Here we declare the java class defined above.
var test = Test();

fun main(args:Array<String>) {
    //Here we call the hello method declared in the Test class.
    println(test.hello());
}

Example 3: the spring boot service:

The best part of this is that the project can be an 
maven project as usual or any other build tool you desire.


The pom file needs:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>LATEST_VERSION</version>
</parent>

The code looks like follows:

//The main function comparable with what we know from Java.
//The point of interest is that the main function needs to be
//declared outside the class application. Otherwise the method
// will not be seen as a main method.
fun main(args: Array<String>) {
    SpringApplication.run(Application::class.java, *args)
}

// The class declaration simular to what we know in Java 
//with some small adjustements. By default a class is final
//in Kotlin. To undo this we need the keyword open. Spring Boot
// requires that.

@SpringBootApplication
open class Application() {
}
// finally the rest controller It has all the characteristics 
//I described earlier. Like the fun definition of the function etc.
 For the rest it is code as we know it from Spring.
@RestControllerclass CustomerController {

    @RequestMapping(value =  "/test")
    fun test(): String {
        return   "Hello world";
    }

}

To make this example work create an .kt file and
compile it with:
 kotlinc your_file.kt -include-runtime -d your_file.jar 
and run it with:

java -jar your_file.jar

Or use an ide that does this kind of work for you (leasy me again)



Conclusion:

With Kotlin we produce significant less lines of code and still have the power that we used to. Important is that Kotlin has a wide range of support from compagnies and frameworks which make our lives as programmers easier. I hope you will play a bit with it and enjoy it as much As I did. At last but not least I would like to thank Shaun Thomas from Sytac for giving a wonderfull presentation about Kotlin which enlightened me to write this post.

Have fun!

autocomplete with javascript

2016-07-13T13:26:00.000-07:00

introduction

Every now and then as a java programmer you run into a java script piece. I have to admit that java script and myself are not good friends for ages now. Every time I have to do something with java script I cry in silence. So I started a nice Java project to work out some java script stuff and see If I could deal with it (call me a masochist). One of the things that kept me wandering around for a while was how to build a autocomplete that calls a service. I found a lot of examples with prefab list. After digging around a lot I found an example that connected to a service. It was not working so i started trying and finally i got it working.

The solution

//jquery libraries needed.

<script src="<c:url value="https://code.jquery.com/jquery-3.0.0.min.js" />"

type="text/javascript"></script>
<script src="https://code.jquery.com/ui/1.12.0/jquery-ui.js"></script>
<link rel="stylesheet" href="//code.jquery.com/ui/1.12.0/themes/base/

jquery-ui.css">

// the html label and input that gonna function as autocomplete.

// the css class is coming from jquer ui.

<div class="ui-widget">

  <td><label for="autocompleteChars">Autocomplete: </label></td>
  <td><input id="autocompleteChars"></td>

</div>

// The array that is gonna contain the service result.

var autoCompleteContent;
$( function() {

    //coupling the autocomplete to the html input.
    $("#autocompleteChars").autocomplete({
        source: function( request, response ) {
            $.post({
                        url: "<the url to the service>"

+ document.getElementById('autocompleteChars').value,
                        dataType: "json",

                        // if the request was successfull.
                        success: function( data ) {
                            response( $.map( data, function( item ) {

                                //reïnitializing the array to empty the previous.

                                autoCompleteContent = new Array();

                                //looping through the results from the service. 
                                for(index=0; index<item.length; index++) {

                                    //creating the layout of an autocomplet line.
                                    var autoComplete =  item[index]['element1']

                                     + '  ' + item[index]['element2'];

                                    // adding it to the array
                                    autoCompleteContent.push(autoComplete);
                                }

                                //return the list as desired to the html input.
                                return autoCompleteContent;
                            }));
                        }
                    })

                     // if the request fails.
                    .fail(function(response) {
                        console.log('Error: ' + response.responseText);
                    });
        },
        minLength: 1    });
});

Conclusion

The prove I found in fighting this little piece of code was that I found out

 that I am still the plumber in the backend. I just love building stuff in

the backend and sometimes just popup at the frontend to do a trick or two but

to move silently back again. I am happy that I finished this piece and made

it work. There are many ways to rome even in the javascript world.

You find some of those roads by google. But with the most of them you never get

to Rome. I hope that I can help some other java developers with this, that just

as me, allways struggle with javascript.

Have fun!

Alternative implementation of an Interface with lambda

2016-06-21T07:53:00.001-07:00

Introduction

Normally to have an implementation of an Interface is extra work

Create a class
Implement the Interface
Implementing the method(s)

I always thought of this as the boring part except implementing the method(s)

So I was fooling a bit around with Lambda's in Java and figured a way of interface implementation without creating an extra class for it. I thought that this way might be nice when the implementation of the Interface happens only ones. Like in Spring when you use Inversion of Control.

Lets have a look at how it could be done with Lambda's

The solution to the problem

First of all you create the Interface:

public interface WorkerInterface {
  //The method to implement

  void doSomeWork();
}

Secondary the class that is having the interface and the implemented method:

public class LambdaTest {
    //The method that executes the Interfaces method.
    private void execute(WorkerInterface worker) {
        worker.doSomeWork();
    }

    //Just the plain old main to start up this class.
    public static void main(String [] args) {
        LambdaTest lambdaTest = new LambdaTest();
        lambdaTest.run();
    }

    private void run() {
        //A list with names to start this examples
        List<String> names = new ArrayList<>();
        names.add("Test1");
        names.add("Test2");
        names.add("Test3");
        //The lambda way to do a for loop
        //With the first arrow you assign name to the execute method.
         names.forEach(name ->
        //With the second arrow you assign the execute method.
        // to the implementation you had in mind.
        execute( () ->
       System.out.println(name) ));
    }
}


Conclusion




As you can see this works quite easy. By using a double assignment one assign the data to the execute method and the other to assign the execute method to the implementation, it is possible to make an Interface method execute something without an extra class file. 




Have fun!

Apache HttpClient connect

2016-01-31T04:04:00.000-08:00

Introduction

As sometimes needed you want one service to communicate with the other without interference of the frontend. One of the ways to do that is to setup a connection through the apache httpClient. In our project we allready did that but with an old version of te HttpClient. Therefore we needed to upgrade to the latest version. At this point in time it is 4.5.1. The only downside of this client is, that it is still not upgraded to HTTP 2.0. read the specs here. But we did it anyway in the hope that the coming version would use the HTTP 2.0 specifications.

The solutution

This solution is not giving you the whole shabang but it gives you a good idea howto setup a basic configuration that works and will help you to setup through a proxy or not.

//The maven part:

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.1</version>
</dependency>
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpcore</artifactId>
    <version>4.4.4</version>
</dependency>

//If you in need of a proxy set it up like this with ofcourse the right adress and

//port.

HttpHost proxy = new HttpHost("proxy", 8080, "http");
// Configure the request with timeouts and in this case a proxy.

//If you don't need a proxy you can leave that particular part out

RequestConfig config = RequestConfig.custom()
        .setConnectionRequestTimeout(30000)
        .setSocketTimeout(30000)
        .setProxy(proxy)
        .build();

//Instead of using the HttpMethod in the old version we now

//should use the HttpGet or the HttpPost HttpGet httpget =

new HttpGet("http://yourservice/getEverything");
httpget.setConfig(config);

//This is one of the ways to setup a HttpClient.

//there are many more ways as you will find in these examples.

HttpClient client = HttpClientBuilder.create()
        .build();

// retrieving the response as HttpResponse and printout

//the http statusHttpResponse response = client.execute(httpget);
System.out.println(response.getStatusLine());

Conclusion

It is not so hard to set this up once you have an idea of what you need to do. I been searching the internet for a some examples. The sad story of this search was that there a lot of old examples out there. I only hope that this library is soon updated to http 2.0.

retrieve the end date from a certificate

2016-01-13T12:24:00.000-08:00

Introduction

This week we had a really nice challenge. As most companies we use certificates. They help us to keep the connections secure. The downside of certificates is that they need to be renewed now and then. It is so easy to notice an expired certificate by undesirable behaviour of the connection. If this happens your already to late. To be ahead of this, we decided to do a check up on this particular certificate.

The solution

To start of all you need an object of the type Certificate. In this mather I start with an certificate, which needed to be read from disk:

//Take the file from disk as an inputStream using the classloader for this.

InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("testCertificate/testCertificate.pem");

//getting the CertificateFactory of the type x.509

//(X509Certificate is the only child of Certificate)

CertificateFactory certFactory = CertificateFactory.getInstance("X.509");
Certificate certificate = certFactory.generateCertificate(inputStream);

// setting up the keystore with an default type. You can also use:

`//getInstance(String type,Provider provider)`
`//getInstance(String type, String provider)` `//` Type could be pkcs12 or jks these are archive file formats for storing many //cryptography objects as a single file. // types could be SUN or bc (bouncy castle).

KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());

//adding the certificate to the keystore with an alias

keyStore.setCertificateEntry("alias", certificate);

// creating the date object outside the scope of the try we can return it later.

Date notAfter = null;

try {
// initializing the keystore with null to prevent exceptions to be thrown later on.

keyStore.load(null);

//checking if the keystore has an alias and retrieve the first one.

//(we only have one). If you know the alias you can loose this piece of code.

    if(keyStore.aliases().hasMoreElements()) {
        Enumeration<String> aliasses = keyStore.aliases();
        String alias = aliasses.nextElement();

// cast it to the X509Certificate That has the getNotAfter method. Certificate

//doesn't have that.

X509Certificate certificate = (X509Certificate) keyStore.getCertificate(alias);

// assigning the date to the end date of the certificate.

notAfter = certificate.getNotAfter();
    }
} catch (KeyStoreException ke) {
    log.error("could not read keystore or certificate", ke);
} catch (CertificateException ce) {
    log.error("no certifications in keystore", ce);
} catch (NoSuchAlgorithmException nse) {
    log.error("wrong algorythm for certificate.", nse);
} catch (IOException ioe) {
    log.error("could not read certificate.", ioe);
}

// returning the end date.

return notAfter;

Conclusion

To understand what is happening in this particular piece of code acquires some time and dedication. The fun part starts when you understand it. I still enjoy the moments where I crack a case like this and understand why it is needed to be done like this. I hope you enjoy it also.

Have fun!

testing log statements

2016-01-12T12:56:00.000-08:00

Introduction

Testing can sometimes make your head spin. For example when a method is a void and you are not allowed to use powermock.

The thing with a method like that, is that it is not returning an Object on which you can test on.

If you are lucky it might have a parameter that changes during the execution of the method.

Sometimes it has a log statement based on a Exception or on an event captured in an if statement, that happened during execution.

That gives also opportunities. Let me show how.

The solution

For working with log files the best thing to do is approach them with log appenders.

//We start with a mock appender:

@Mockprivate Appender mockAppender;
//Creating a rootlogger to hold all the appenders. 
ch.qos.logback.classic.Logger root = 
(ch.qos.logback.classic.Logger) LoggerFactory.getLogger 
(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
 
 // appending the ArgumentMatcher to the mockAppender. 
Mockito.verify(mockAppender).doAppend(Mockito.argThat 
(new ArgumentMatcher<Object>() { 
//implementing the matches method to see if the
// log text appears in the log file 
@Overridepublic boolean matches(final Object argument) {
return ((LoggingEvent) argument).getFormattedMessage()
//The text we want to search. 
.contains("test logging text that should be found");}}));

The conclusion

Void methods could be still a call for an asperine when it comes to testing. There are some helpful methods I believe that this is one of them. I used it this time to test a method that checked if an certificate was expired. This way I could pump up the test coverage of my code.

Have fun!

A bit of Reflection

2015-12-18T14:57:00.003-08:00

Introduction

In all the years I have been programming one of the dullest things I found to do was writing and maintaining converters. I had a couple of discussion about the subject. The point that always came up as a defence to not use bean mappers like Dozer was the fact that they used Reflection under the hood. I agree up to some level that the use of Reflection in production code should not be used in production code. The interesting point is that most of the third party libraries are using Reflection under the hood. Every library that uses Annotations for example are using it. Think about Spring, all the JPA libraries, log4j, Junit etc...
So why not for something like bean mapping. So lets see if we can build one our selfs.

The solution

A bean mapper is meant to copy values from one bean to the other. So what you need to accomplish this is to know the field names of the "other" bean.

The solution is actually not that complicated What I did was create a couple of Annotations and a handler.

If the field names are different you can pass the name of the fields in the "other" bean by using an annotation.

The Annotations look like this:

//The rentention policy tells when this Annotation should be used.

@Retention(RetentionPolicy.RUNTIME)

//The target tells where the annation should be placed. In this case field only.
@Target(ElementType.FIELD)
public @interface Copy {

    // the string that contains the value given to the Annotation.
    public String copyTo();

}

If the field names are the same you can do it without an annotation.

I show that later.

If you dont want the fields to be copied you can use simply another annotation that prevents the field to be part of the copy process:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface IgnoreCopy {
}

The annotation in use look something like this:

// copying with a different field name

@Copy(copyTo = "testString2")
private String testString;
// copying wit the same fieldname
private String testStringNoAnnotation;

should not be copied.
@IgnoreCopyprivate String notToCopy;

To copy the values first of all you need the fields of the bean to copy from:

//Use the getDeclaredFields instead of the getFields. Otherwise you can't find

//the field you are searching for.

Field[] fields = copyFrom.getClass().getDeclaredFields();

//looping through the fields to find the annotation if needed.

for(Field field : fields) {

    //The annotation if the field names are different.
    Copy copy = field.getAnnotation(Copy.class);

    //The annotation to see if the field shouldn't be copied. 
    IgnoreCopy ignoreCopy = field.getAnnotation(IgnoreCopy.class);
    if(ignoreCopy == null) {
        if ( copy != null) {

            //the actual method to copy with different field name 
            addValueToField(copyFrom,copyTo, field, copy.copyTo());
        } else {
            //the actual method to copy with the same  field name 
            addValueToField(copyFrom, copyTo, field, field.getName());
        }
    }
}

private void addValueToField(final Object copyFrom,

final Object copyTo, final Field field, final String name) {
    try {

        // Searching for the field in the "other" bean
        Field copyToField = copyTo.getClass().getDeclaredField(name);

        // The fields are private so we make them accessible
        copyToField.setAccessible(true);
        field.setAccessible(true);

        // The actual copying of the values
        copyToField.set(copyTo, field.get(copyFrom));

        //stop the accessibility of the fields. 
        copyToField.setAccessible(false);
        field.setAccessible(false);
    } catch (NoSuchFieldException e) {
        log.error("could not find field " + name);
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        log.error("could not access field " + name);
        e.printStackTrace();
    }
}

// I added two more methods that are helpfull with the cherry picking.

/** * checks if ignorefield is set in the target.class

* @param copyTo the target class.

* @param fieldName the fieldname to be set.

* @return a boolean if the field is right to set.

*/

 private boolean ignoreCopyToField(final Object copyTo, final String fieldName) {
    Field field = null;

    // A list of fieldnames to prevent the NoSuchFieldException

         List<String> fieldNames = checkFieldExists(copyTo);
        IgnoreCopy ignoreCopy = null;
        try {

            // check if the field exists in the target class.

           if (fieldNames.contains(fieldName)) {

                // retrieve the field with the name

                field = copyTo.getClass().getDeclaredField(fieldName);

                // retrieve the annotation from the field
                ignoreCopy = field.getAnnotation(IgnoreCopy.class);
            }
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }        return  ignoreCopy != null;
}

/** * creates a list that has all the fieldnames in it.

* @param copyTo the target class

* @return a list that has all the fieldnames in it

*/

private List<String> checkFieldExists(Object copyTo) {
    List<String> fieldNames = new ArrayList<String>();
    Field[] fields = copyTo.getClass().getDeclaredFields();
    for (Field field1: fields) {
        fieldNames.add(field1.getName());
    }
    return fieldNames;
}

Conclusion

The choice to be made is more of a philosophic one. Is it worth to add some more reflection to the project at hand. I think the decision is to use it where it is useful. If it can save you writing and maintaining miles of boring code my advice would be to do it. In many cases it allready happens. So think about and work this out for your self. The code to build this is short and simple.

The original source code can be downloaded here

The jar file can ben downloaded here

Have fun!

Sorting data

2015-02-10T03:28:00.001-08:00

Introduction:

In the issue I had at hand we needed to sort the data to create a matrix. So actually we needed to morph a list to a matrix form.

The problems:

At first hand I was thinking about using the states of the data to figure out where in the matrix it should find its place. As soon I made a drawing about my idea, I stopped working at it. I needed to create a complex structure with a lot of if statements. I understood that, if I choose this way I might run into a lot of bugs. I needed to think harder.

The solution:

I turned the whole idea around and looked at it from the other side. Instead of creating the matrix directly from the list I could something like a pre-sort. The next question obvisiouly would be: How the hell do I do that? The answer was actually quite simple looking back at the issue. I took a LinkedhashMap and a Treemap. I made sure that the query returned everything sorted by date.

In the LinkedHashmap I used as a key the date and the Treemap. The LinkedHashmap keeps things in order of incoming. So it kept the order of the query I created by date. The second ordering would be by currency where the payment was in done. This I used as a key in the TreeMap together with the rest of the object. The Treemap sorts on aliphatic or numeric order using the black and red sorting algorithm.

Now All I had to do was write a double loop for both of the maps and put the data I needed in place.

Conclusion:

Sometimes it is better to make that drawing and have a better look at what you need to-do. I believe that part is the greatest joy in my job. Create something that gives me the proud feeling.

Have fun!

saving passwords the save way

2015-01-30T02:55:00.001-08:00

Introduction:

Every time I search on security matters, I always find the things to prevent attacks from the outside. These issues are important there is no doubt about that. But the one issue that kept running around my mind was one of the jobs where they got into your database. That is the place where an unwanted visitor should stay away. One of the last resort solutions to prevent this unwanted visitor to steal your customer data is to hash the passwords and encrypt the data in that database. The downside of this technique is that most of the encrypting and hashing methods all ready have white papers. So the only thing is: that buys you a bit more time before they got to your data.

Part of the solution:

I did not solve the whole case of steeling data yet. I did found away to store passwords strongly protected in my database. The solution is quite simple: don't store the real password in the database but an abstraction of that password. Every character has an ASCII number changing the characters in the password into numbers gives you the possibility to calculate with them like this:

double key = 0;
char[] passwordChars= password.toCharArray();
for (char keyPart : passwordChars) {
key += Character.getNumericValue(keyPart);
}

Now you have a nummeric value of a password. How far you will calculate this is upto you.
The next question is ofcourse what to do with a number. The simple thing is that you can allready store this number into the database and you have an abstraction of the password. But the fun is to push it a bit further. You can create an hashmap that has a double as a key and a String as a value.
With the calculated number you get the string value out of the database. and store that as a password.

Something like this:
private Map<Double, String> falsePasswords = new HashMap<Double, String>();
and fill it with nice long strings with a lot of weird characters:
falsePasswords.put(1.0, "*(_)((UIiuyuUITYFTYR%R&$%&%tituyutyr867987yuyuiyo8&)*0");
I would make this a lon list of false passwords and create a calculation on the password that gives a good range of false passwords.

To make it look like a real password you can hash it and make the unwanted visitor think that he can decrypt all your passwords.

Conclusion:

The solution to most of the problems are not that hard. In this case a simple calculation and a hashmap brought the solution.

Have fun!

Spring-boot rest/jpa full blown

2015-01-12T06:40:00.001-08:00

Introduction

For a while I was looking for a suiting solution where I could use spring rest services combined with the Spring/JPA repositories. What I actual was looking for was a query driven rest service where I did not had to convert one bean to another. This awfull boilerplate code and is a maintainance nightmare.

After a lot of searching I ran into Spring-boot where the got a couple of steps further than I was looking for. After studying it for a while I got used to their ideas and must say I like them.

While I was searching I ran into a lot of examples but none of them was showing me how to deal with spring-boot in a professional and serious mather. So i picked up a lot from the reference guide and put the pieces of the puzzle together.

The configuration
I build the whole story in Maven for the gradle fans have a look at the reference guide. There is fully explained howto do it in gradle.

The basiscs of spring-boot is the simple fact that they provide you with a super pom for maven where you can cherry pick the parts you really like to use. Here are the cherries I picked from that tree:

The project pom
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<parent>
<artifactId>abstractservice</artifactId>
<groupId>com.purat.services</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>userservice</artifactId>
<packaging>jar</packaging>

<properties>
<tomcat.version>8.0.3</tcat.version>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<start-class>com.purat.Application</start-class>
<spring-boot-version>1.1.10.RELEASE</spring-boot-version>
</properties>
// The super pom provided by spring-boot
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.1.10.RELEASE</version>
</parent>

<dependencies>
// these are the depedency to deliver all the necessary jpa libraries to approach the database.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency
//This is the library to deliver all the necassary rest libraries. To create for example your own endpoints
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
//This is the library that gives us the web application part.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
//This is the library that gives us the production-ready parts. For more details look at boot-starter-actuator
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
//For the database I used postgress.
<dependency>
<groupId>postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>9.0-801.jdbc4</version>
</dependency>
// For handling the getters and setters I used lombock.
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.12.6</version>
<scope>compile</scope>
</dependency>
</dependencies> <build>
<pluginManagement>
<plugins>
//This plugin is responsible for the kind of packaging you desire. You can choose a war or a jar
This plugin will build it with the desired content.
To deploy a war file there are still a couple of steps to take. You can find the description for that here:
traditional deployment
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build>

<repositories>
<repository>
<id>spring-releases</id>
<name>Spring Releases</name>
<url>https://repo.spring.io/libs-release</url>
</repository>
<repository>
<id>org.jboss.repository.releases</id>
<name>JBoss Maven Release Repository</name>
<url>https://repository.jboss.org/nexus/content/repositories/releases</url>
</repository>
</repositories>

<pluginRepositories>
<pluginRepository>
<id>spring-releases</id>
<name>Spring Releases</name>
<url>https://repo.spring.io/libs-release</url>
</pluginRepository>
</pluginRepositories>
</project>

The Application class and application.properties

Despite of what you see on the internet I like to keep the Application class to a bare minimum. We need this baby only to start the project up after we build a war or a jar.

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

import org.springframework.context.ConfigurableApplicationContext;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

/**

* Created by compurat on 1/11/15.

//Indicates that a class declares one or more @Bean methods and may be processed by the Spring container to generate bean definitions and service requests for those beans at runtime.

@Configuration

// This annotation configures and uses the standard beans that are on the classpath of the diverse libraries.

@EnableAutoConfiguration

//Configures component scanning directives for use with @Configuration classes.

@ComponentScan

public class Application {

public static void main(String[] args) {

//This is the only line you need to start up you application.

ConfigurableApplicationContext context = SpringApplication.run(Application.class);

}

The application.properties file under the resources folder:

The way this works, looks to me like the Wicket framework.

//The configuration of the database

spring.datasource.url=jdbc:postgresql://localhost:5432/people

spring.datasource.username=Pieter

spring.datasource.password=Pieter01

spring.datasource.driver-class-name=org.postgresql.Driver

spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect

hibernate.hbm2ddl.auto=create-drop

spring.jpa.show-sql=true

// Setting the end point properties give it an id,give the possibility to shut the endpoints down and sensitive is security wise. Does an endpoint need username and password to be approached.

endpoints.beans.id=springbeans

endpoints.beans.sensitive=false

endpoints.shutdown.enabled=true

//Tomcat serverlog enabling and patterns.

server.tomcat.access-log-enabled=true

server.tomcat.access-log-pattern=%a asdasd

The log file propeties.

logging.file= logging/userservice.log

logging.level.org.springframework.web: DEBUG

logging.level.org.hibernate: ERROR

Basicly we now have ready to run spring-boot webservice with JPA. It does not work yet we still need to fill in the missing pieces here.

The application

Lets start with the rest endpoint. That is where it all begins. This is the profile endpoint and does not take any parameters in this case. But it give you an idea how an endpoint in spring-boot works:

import com.purat.data.People;

import com.purat.data.repository.PeopleRepository;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

/**

* Created by compurat on 1/11/15.

//Tells spring that this is obvious a rest controller

@RestController

//Tells spring what the base url is.

@RequestMapping("peopleservice")

public class ProfileEndpoint {

@Autowired

//spring/jpa repository to approsch the database

private PeopleRepository peopleRepository;

//Tells spring what the endpoint url is.

@RequestMapping("/profile")

public Person profile() {

The jpa entity

Person person

//The query parameter names are in the repository method name. in this case EmailadressAndPassword

= peopleRepository.findByEmailadressAndPassword("pieter.roskam@gmail.com","Roskam01");

If you Return the entity in the rest controller spring will underwater serialize the object to an json file.

return person;

}

As second part I like to handle the jpa entity:

import lombok.Getter;

import lombok.Setter;

import javax.persistence.Entity;

import javax.persistence.Id;

/**

* Created by compurat on 1/11/15.

//Lombock getters and setters keep you code nice and clean.

@Getter

@Setter

//What table to approach

@Entity(name="people")

public class Person {

// the unique id and all the fields as named in the table.

@Id

private long id;

private String firstname;

private String lastname;

private String address;

private String housenumber;

private String postalcode;

private String city;

private String telephone;

private String verification;

private String emailadress;

private String password;

}

As third and last part I would like to show the jpa repository:

package com.purat.data.repository;

import com.purat.data.User;

import org.springframework.data.repository.CrudRepository;

The spring/jpa repository gives some benefits. For simple queries you can use the parameter names in the method, but for more complicated queries you can also use the @Query annotation to write a jql query .

public interface PeopleRepository extends CrudRepository<Person,Long> {

User findByEmailadressAndPassword(String emailadress, String password);

}

Conclusion

Spring-boot took a complete new road to developing and deploying rest services. The most interesting part is probably that you can have a rest service in a jar file. That was a mind boggle to me for a while. The secret lies in the fact that it is a self executing jar. While starting up your Application class it will also startup tomcat if you configured it right (dependencies and properties file).

The second part that might be of interest, is the fact that it looks like that the separation of tiers is gone. But if you look closely it is not:

1. The separation of the database is still intact because it is hidden behind the spring/jpa repositories. They are not reachable from the outside.

2. The entity bean seams to be exposed at the frontend but again that is not completely true. The bean will be serialized to a json file by Spring. That is the only visible thing on the outside. The only one that should reach this service is the frontend. Which is also separate.

I love the part that you can package a rest service into a jar. You put it somewhere on your server and start it with java -jar servicewhatever.jar. That will fire up everything you build for this rest service.

have fun!

Execution Framework introduction

2014-10-26T14:06:00.002-07:00

Introduction:

In the execution service there are many ways to do a trick I have been googling around and found a lot of words but none of them explains well what is what and why.

Solvation:

Most of the executor service are obtained through the Executors class like:
Executors.newCachedThreadPool();
This threadpool provides you with the number of threads that you need. It reuses threads that come available again.
Executors.newFixedThreadPool(10);
This threadpool only provides you with the number of threads that you have declared 10 in my example.
Executors.newSingleThreadExecutor();
This threadpool contains one single thread and all given tasks will be executed in sequence.

Except ofr the SingleThreadExecutor() all of the others deal the same way if it becomes to lists. As soon you expose a list to one of the named threadpools the behaviour is as follows:

Lets say we take a CachedThreadPool or a FixedThreadPool we expose a list of elements to the executorservice initialized with one of the above named pools. The first element of that is exposed for threading it will be spread over all the available threads. As soon the task is done, the next element of the list will use all of the threads. This is a good thing if that is what you desire. But what if you want to share all the elements of the list shared over different threads. In other words every element of the list should be worked on at the same moment in parallel.

This is where the only pool comes in that can do that is the ForkJoinPool (since java 7). This pool is not obtained through the Executors class but is instanciated on its own like :

ForkJoinPool forkJoinPool = new ForkJoinPool(3); The constructor takes a int as argument to initialize the number of threads, 3 in my example. The ForkJoinPool uses the work-stealing philosophy. This means that if a thread is running out of jobs, it will visit one of the neighbor threads and see if he can help him out.

Conclusion:

If you want to work a single task in different threads the ExecutionService is what you need. If you need different tasks work in paralel the same time, you should use the ForkJoinPool.

If you are using a version of Java lesser then 7, you can try this trick with google guava. I worked at this time with version 18.0 and that worked fine. Here is a piece of example code:

//Java class
ExecutorService executorService = Executors.newCachedThreadPool();

//Guava class

ExecutionList executionList = new ExecutionList();

//code to execute

executionList.add( new myRunnable(), executorService);
executionList.execute();

Have fun!

reading method from stack

2014-10-11T08:11:00.001-07:00

Introduction:

One of my colleagues came up with the idea to setup logging through AOP. I always encourage ideas like that. This might set you on the wrong foot. This blog is not about how to deal with AOP. This little part is about how to read the method name from the stack so it can be written to a log.

The difficulty came that certain classes should log the method name with a certain pattern and other method names not. This made it hard to solve with the patterns available in the Loggger settings.

The solution:

The idea sounds simple. I worked it a bit more out to be comply to the open closed design way. Because what I learned in composite designing is that every object should interfere as less as possible with other objects. In other words, It should be as independent as possible. The only way to achieve this is to use reflection.

There we open another discussion when and where should we use reflection. The fist rule I is simple If there is another solution that is as valid use that one. If there is not another valid option then use reflection. So why reflection in this matter?

There are two ways to solve this:

hardcode every method name also as a constant in the class that needs to log the method name.
Use Reflection to get the name of the stack.

So this how we solved it:

String methodname = Thread.currentThread().getStackTrace()[1].getMethodName();

Logger.info(methodName);

The .currentThread() is a static method from Thread from which you can get the stack called in that Thread. In my example there was only one thread.

The 1 refers to the position of the method you desire from the stack. The further back you want the higher this number becomes. The only bummer in this story is that you cannot obtain the names that have been given to the parameters of the required method. The jvm creates new instances of them and name them like arg0, arg1 etc...

Conclusion:

Knowing what you are doing is very important. It also shows everytime that things in Java are not that hard ones you understand the concepts. This is something you probably not gonne use a lot but when you need it, it is handy.

Have fun!

Node.js reading json from rest service

2014-09-20T06:22:00.002-07:00

Introduction:

The concept of a java script server is in my opinion revolutionary because of the fact that frontend technology also can be separated from the backend as a specialism. But what good is the one without the other. Creating a presentation is no good without data. But what good is data if we cannot present it. So in this matter I would show you that it is possible to combine the best of both worlds.

The solution:

In my previous post I described how to install a nodejs server and create an hello world application.
Because connecting to a rest service is a bit more complex we need to do some actions before we can start:

create an folder for example rest-api
cd rest-api

We need the superagent library:
npm install superagent@0.17.0 --save-dev

After this we can start building up the server:
// initializing the http package.
var http = require("http"),
//making the port available through a parameter
port = process.argv[2] || 8888;
// initializing the superagent package
var superagent = require('superagent');
// creating the http server
http.createServer(function(request, response) {
//retrieving the rest url throught the superagent package
superagent.get('http://localhost:8080/hello')
.end(function(e, res){
//writing the res.text response from the rest server to the response which is the browser client response.
response.write(res.text, "binary");
response.end();
})
//make the server listen to the port that is declared in my case 8090 or the standard port 8888
}).listen(parseInt(port, 10));
//just a friendly console message.
console.log("Static file server running at\n => http://localhost:" + port + "/\nCTRL + C to shutdown");

Conclusion:

The world of javascript is not that different from the world of Java these days. There is this virtual machine, it is getting Object Oriented in a kind of way and you have to know your way in the library wilderness. This makes the gap between the two worlds smaller. There are still differences between the way of working between these kind of frontend technologies and Java as allways the devil is in the details.

Have fun!

Hello world with node.js

2014-09-05T04:43:00.002-07:00

Introduction:

In my previous post I wrote about the clean separation of concerns by using a javascript server like node.js. In the past I worked on a project where they used node.js but personally I never got involved. I wrote the backend part of the system where we used rest services that returned json as an answer for the node.js server (javascript can handle json).

So curiousity killed the cat but made man kind evolve. So I tried to set this up on my linux machine. Googled around a bit and found the answers to my questions.

Installation:

actually on linux it is pretty basic if you have git running:

My attempt under debian:

git clone --depth 1 git://github.com/joyent/node.git
cd node
git checkout v0.4.11
export JOBS=2
mkdir ~/local
./configure --prefix=$HOME/local/node
make
make install
echo 'export PATH=$HOME/local/node/bin:$PATH' >> ~/.profile
echo 'export NODE_PATH=$HOME/local/node:$HOME/local/node/lib/node_modules' >> ~/.profile
source ~/.profile

My attempt under ubuntu:

sudo apt-get install curl
curl -sL https://deb.nodesource.com/setup | sudo bash -
sudo apt-get install nodejs

(The path under ubuntu will bie /usr/bin/node)

After you done litterly this (take care of the $PATH ELEMENTS. You need to replace them with the real path where you put the node server).

after this you can create a test.js in any folder you like containing:

//require is the import in java

var http = require('http');

// Configure our HTTP server to respond with Hello World to all requests.

//creating the http server

var server = http.createServer(function (request, response) {

//bare writing to the response like in the old days with Java.

response.writeHead(200, {"Content-Type": "text/plain"});

response.end("Hello World\n");

});

// Listen on port 8000, IP defaults to 127.0.0.1

server.listen(8090);

// Put a friendly message on the terminal

console.log("Server running at http://127.0.0.1:8090/");

After you saved the file you have to tell nodejs that he has to start this application:

./node test.js in your console in the node directory
Start a browser on the desired port 8090 in my case

The result should be hello world on a snowy white page.

have fun!

separating the frontend from the backend

2014-09-02T01:08:00.001-07:00

Introduction

Through the years I seen a couple of application architectures. Some of them had the multi tier design but where still one war file. I never seen that as a bad design. That was the best available way. The fun part of a way like that was that the architect had to defend the borders between the layers. That is where the weak point in this architecture lies. It is easy for a developer, for what ever reason, to cross the borders and start mixing the responsibilities of the different tiers. This is the first step of downgrading an well setup application to a kind of chaos architecture.

As allways in time ideas improve. A couple of years ago we suddenly had SOA. The backend logic was pushed back into REST or SOAP services with a separate project that was the frontend. The downside of this architecture was, that the html code was still infected with tags from java frameworks. Fore example
JSF had is own XHTML and even the newer like Wicket have there own tags. The most Frontend guys dont like that. They know html and they dont want to know about all the java frameworks.

The other downside of weaving the java frameworks into html is: that if the compagny decides that in some cases it should not be Java but something like PHP or Ruby etc... they still endup with a java frontend framework.

Now we enter a time where the possibilities to separate the frontend from the backend in a sharper and smarter way. It is possible to run a frontend tier completely on a javascript based server like node.js. Here is a list of js solutions.

The architecture:

Behind teh node js server part you can build as many java rest services as needed. Now we have a complete separation from the frontend and the backend. On the node.js server it is also possible to declare small html objects like textboxes or buttons etc...

Conclusion:

There are allready compagnies working on a application architecture like this or have in place. It requires to see the frontend as separate specialism and for that you need people that know how to deal with a frontend architecture like this. As a backend developer you have to let te responsibility for the frontend go and concentrate on what you can do actually the best backend development.

Have fun!

From String to calculation

2014-08-11T23:47:00.000-07:00

Introduction:

After the marshalling drill I have been thinking about how can we do small changes in xml without marshalling. The only other option I could come up with is xpath queries combined with element value changes. For primitive type changes this is a good idea but what if someone needs some complex calculations with a value from the xml file. Even this can be done.

The solution:

What I could think of was some kind of calculation template in a String something

//The numbers to calculate.
int number1 = 40;
int number2 = 2;

//Creating the javascript engine
ScriptEngineManager mgr = new ScriptEngineManager();
ScriptEngine engine = mgr.getEngineByName("JavaScript");

//The calculation template can be more complex
String calcuationTemplate = "%d * %d";
calcuationTemplate = String.format(calcuationTemplate, number1,number2);
try {
//The actual calculation
System.out.println(engine.eval(calcuationTemplate));
} catch (ScriptException e) {
e.printStackTrace();
}
}

The conclusion:

After some googling and trying I found that yet again this is pretty simple. With this I can do as much math I like in a very simple way. The only thing I still have to take care of is a difference between the numbers that have been given and the numbers that are retrieved from the xml file.

have fun!

replace diacritic characters

2014-08-08T03:27:00.001-07:00

Introduction:

We had a request to remove all the diacritic from a String. As usual Java has a nice solution for this.

Solution:

String str = "ÚÝâ";

String nfdNormalizedString = Normalizer.normalize(str, Normalizer.Form.NFD);
Pattern pattern = Pattern .compile("\\p{InCombiningDiacriticalMarks}+");

System.out.println(pattern.matcher(nfdNormalizedString).replaceAll(""));

result: UYa

The Normalizer class according to the javadoc:

This class provides the method normalize which transforms Unicode
text into an equivalent composed or decomposed form, allowing for easier
sorting and searching of text.

Normalizer.Form.NFD

This is an Enum that tells the Normalizer class what kind of normalisation you want there are:

/**

* Canonical decomposition.

NFD,

/**

* Canonical decomposition, followed by canonical composition.

NFC,

/**

* Compatibility decomposition.

NFKD,

/**

* Compatibility decomposition, followed by canonical composition.

NFKC

The NFD variant decomposes the Ú in U and ' this makes it possible to do a regular expression like

Pattern pattern = Pattern .compile("\\p{InCombiningDiacriticalMarks}+");

At last but not least the question we had was: what in heavens name is \\p{InCombiningDiacriticalMarks}

This answer we found at stackoverflow:

\p{InCombiningDiacriticalMarks} is a Unicode block property. In JDK7, you will be able to write it using the two-part notation \p{Block=CombiningDiacriticalMarks}, which may be clearer to the reader. It is documented here in UAX#44: “The Unicode Character Database”.

Conclusion:

The code we build today is just a tip of the iceberg. The functionality that the Normalizer can bring is much more. I hope in the future I can do some other stuff with this.

Have fun!

open closed Marshalling with Jaxb

2014-08-05T03:51:00.000-07:00

Introduction

One of the things we had to tackle this week was some marshalling issue with a zillion small xml files. The feast of legacy. It was a very depressing thought to create separate marshalling objects for each of them. That Idea popped faster out of my head then in. After some thinking we came up with a component that could do all of the xml files

The solution

The idea I came up with is very simple it is base on Jaxb marshalling which is quit powerfull in the way that the code you need to write is very small. Also the speed of marshalling and unmarshalling is quit fast.

To get this to work you need the following dependencies:

<dependencies>
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.1</version>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-impl</artifactId>
<version>2.1</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.14.4</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
</dependency>
//This one you only need when you want to use xpath queries
<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>eclipselink</artifactId>
<version>2.5.0</version>
</dependency>
</dependencies>

The one and only class for marshalling and unmarshalling:

package nl.lostlemon.Marshal;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.PropertyException;
import javax.xml.bind.Unmarshaller;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;

//The Type is to make it possible to instanciate this class with different marshalling beans.
public class Marshalling<T> {

// Notice that T is the return typed bean. The xm is an inputStream. Jaxb can deal with that. It improves performance
public T unMarshall(final InputStream xmlStream, final Class clazz) {
T value = null;
try {
//create an unmarshaller
Unmarshaller unmarshal = JAXBContext.newInstance(clazz).createUnmarshaller();
//read the xml input stream into Jaxb
XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(xmlStream);
//marshall the xml file into a JavaBean
value = (T)unmarshal.unmarshal(reader, clazz).getValue();
} catch (JAXBException e) {
e.printStackTrace();
} catch (XMLStreamException e) {
e.printStackTrace();
}

return value;
}
//Notice that the parameter is also The T of type.
public ByteArrayOutputStream marshal(final T type) {
//Create the return type for this method.
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
try {
//Create a marshaller
Marshaller marshaller = JAXBContext.newInstance(type.getClass()).createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
//Create the xml in the form of an outputstream to boost performance
marshaller.marshal(type, outputStream);
} catch (PropertyException e1) {
e1.printStackTrace();
} catch (JAXBException e1) {
e1.printStackTrace();
}
return outputStream;
}
}

Running the following tests:

//This test uses the BookBean with an xml containing a single book.

@Test

public void testUnmarshallingXpath() {

InputStream inputStream = this.getClass().getResourceAsStream("testSingle.xml");

Marshalling<SingleBookBean> marshalling = new Marshalling<SingleBookBean>();

SingleBookBean bookBean = marshalling.unMarshall(inputStream,SingleBookBean.class);

Assert.assertTrue(bookBean.getTitle() != null);

}

// The BookBean the @Getter and @Setter is from Lombok.

// Take care of the

@XmlRootElement(name = "book")

@XmlAccessorType(XmlAccessType.FIELD) These are the identifiers to tell JaxB what to do. The XmlRootElement refers to the xml rootelement in the xml file.

@Getter

@Setter

@XmlRootElement(name = "book")

@XmlAccessorType(XmlAccessType.FIELD)

public class BookBean {

// These are the exact same names as the xml Elements

private String author;

private String title;

}

//The single xml file:

<book>

<title>witches abroad</title>

<author>Terry Pratchet</author>

</book>

//This test is using the books bean with an xml containing multiple books.

@Test

public void testUnmarshallingList() {

long start = Calendar.getInstance().getTimeInMillis();

InputStream inputStream = this.getClass().getResourceAsStream("test.xml");

Marshalling<Books> marshalling = new Marshalling();

Books books = marshalling.unMarshall(inputStream,Books.class);

//Assert.assertTrue(books.getBookBeans().size() == 3);

long stop = Calendar.getInstance().getTimeInMillis();

long elapsedTime = (stop-start);

System.out.println("number of elements " + books.getBookBeans().size() + " elapsed time " + elapsedTime + " ms");

}

// The Books bean based on the same principle as the BookBean.
@XmlRootElement(name = "catalog")
@XmlAccessorType(XmlAccessType.FIELD)
public class Books {

@Getter
@Setter
@XmlElement(name = "book", type = BookBean.class)
private List<BookBean> bookBeans;
}

//the multiple books xml file:
<catalog>
<book id="bk101">
<author>Gambardella, Matthew</author>
<title>XML Developer's Guide</title>
<genre>Computer</genre>
<price>44.95</price>
<publish_date>2000-10-01</publish_date>
<description>An in-depth look at creating applications
with XML.</description>
</book>
<book id="bk102">
<author>Ralls, Kim</author>
<title>Midnight Rain</title>
<genre>Fantasy</genre>
<price>5.95</price>
<publish_date>2000-12-16</publish_date>
<description>A former architect battles corporate zombies,
an evil sorceress, and her own childhood to become queen
of the world.</description>
</book>
<book id="bk103">
<author>Corets, Eva</author>
<title>Maeve Ascendant</title>
<genre>Fantasy</genre>
<price>5.95</price>
<publish_date>2000-11-17</publish_date>
<description>After the collapse of a nanotechnology
society in England, the young survivors lay the
foundation for a new society.</description>

</book>

</catalog>

//The marshalling test with the books bean:

@Test

public void testMarshallingList() {

Books books = new Books();

List<BookBean> bookBeans = new ArrayList<BookBean>();

for(int i=0;i<100000;i++) {

BookBean bookBean = new BookBean();

bookBean.setAuthor("J.R.R Tolkien");

bookBean.setTitle("The hobbit");

bookBeans.add(bookBean);

}

books.setBookBeans(bookBeans);

long start = Calendar.getInstance().getTimeInMillis();

Marshalling<Books> marshalling = new Marshalling<Books>();

}

// The marshalling test with the BookBean.

@Test

public void testMarshalling() {

BookBean bookBean = new BookBean();

bookBean.setAuthor("Terry Pratchet");

bookBean.setTitle("Witches abroad");

Marshalling<BookBean> marshalling = new Marshalling<BookBean>();

String xml = marshalling.marshal(bookBean).toString();

}

Conclusion:

Using Java typing in combination with a usefull library in the open closed principal, saves you a lot of code writing and maintainance. I had real pleassure to write in such a small piece of code so much power.

Have fun!

Email Validation

2014-06-24T01:37:00.000-07:00

Introduction

I was strugling with the apache commons email validator. This litle baby was not working according the specs they gave me. After a while I gave up on that and descided against my own rules to build it myself. What I mean with against my own rules is: Dont build if it is out there in a proper library. But in this case I had an exception.

The best way to solve this issue was to use a regular expression. Not my favorite but mighty handy when you need them.

Solution:

The scary part:

For those who have no experience with R.E. this might look like cursing in a comic :).

"^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]+)$";

Lets analyze this:First lets have a look at the structure and later on we spill some information about the details.
The first thing you might notice in the structure are blocks like these [_A-Za-z0-9-\\+]+the A-Z, a-z or 0-9 this means that it contains an character in capitals (A-Z), or in non-capitals(a-z)or digits from 0-9. if the notation is like:[_A-Za-z0-9] It will only search for one character each.if you add a + it means iterate till you can find no more.if you add {2} or {2,5} instead of a + it means only 2 characters or from 2 to 5 characters.
In the case of the email validator you also need one .(dot) and one @ as you can see they are not followed by the annotations I described to iterate for more.
Some of the details:
^ the carrot sign before the brackets means "Starts with" So in this case It can be a multiple underscores, characters or numbers.
The ^ inside the brackets means not like [^A-Z] everything but capitals.
The * is the same as + occurs 1 or more times (iteration).
The $ checks if the end of line is following.

Conclusion:

It still looks like cursing in a comic or something that gives you an headache. But it is the way forward if you want to check a string on patterns. This whole exercise is useless without execution. So you still need to use the Pattern and Matcher class (Examples all over the internet).
Or use the String.matches method. Will do two.

Have fun!

scraping html with selenium server

2014-06-09T03:34:00.001-07:00

Introduction:

In this case I tried to create a server that is capable of getting the values from an html file. The first part what is needed I describe here.

The first part is of course to get the html from the url. This part you can do with Selenium Server, this is an java library which integrates selenium into the virtual machine. This is actual not the hardest part. The hardest part I am working currently namely to get crappy html a bit xml compliant.

The example:

public class Scraper {
private static final String BROWSER = "*firefox";
private static final String SERVER = "localhost";
private static final int PORT = 4444;
private static final String SLASHES = "//";
private static final String SLASH = "/";

private DefaultSelenium selenium;
private String url;
public Scraper(String url) {
this.url = url;
}

public void startScraper() {
//This is to separate the server from the page where you want to start
int startPosition = url.indexOf(SLASHES) + SLASHES.length();
//this turns http://google.nl/search into google.nl/search
String tmpUrl = url.substring(startPosition);
int endPosition = tmpUrl.indexOf(SLASH);
//this turns http://google.nl/search into google.nl
String baseUrl = url.substring(0, endPosition + startPosition);
//this turns http://google.nl/search into /search
String pageUrl = url.substring(endPosition + startPosition, url.length());
//instanciate selenium with a port, your browser and the baseUrl
selenium = new DefaultSelenium(SERVER, PORT, BROWSER, baseUrl);
try {
//instanciate the selenium server
SeleniumServer server = new SeleniumServer();
server.start();
selenium.start();
//open the page you like search in this example
selenium.open(pageUrl);
} catch (Exception e) {
e.printStackTrace();
}
}

//This method is the first part for xml compliancy.
//In my case the data I want is allways in the body.
public String createHTmlOutPutStream () {
String htmlSource = selenium.getHtmlSource();
int start = htmlSource.indexOf("<body");
int stop = htmlSource.indexOf("</body>") + 7 ;
htmlSource = htmlSource.substring(start,stop);

return htmlSource;
}

// This method fills every textfield if you know the name
public void populateTextField(String fieldName, String text) {
selenium.type(fieldName, text);
}

// This method clicks the button for you
public void clickButton(String buttonName) {
selenium.click(buttonName);
}

// This method runs through every option in a dropdown list.
public void chooseDropDownAll(String dropDownName) {
String[] options = selenium.getSelectOptions("dropDownName");
for (String option : options) {
selenium.select("dropDownName", option);
}
}
// This method only picks one option in the dropdown list.
public void chooseDropDownSpecific(String dropDownName, String optionName) {
selenium.select("dropDownName", optionName);
}

}

Conclusion:

With those two libraries:
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-firefox-driver</artifactId>
<version>2.42.0</version>
</dependency>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-server</artifactId>
<version>2.42.0</version>

you will be capable of doing this trick. This only a small set of possibilities to discover.
You should try it, the next thing what I want to do is to write a test that does the login and the first search for me on the project I am working on right now. This because I like programming and not logging in :).

Have fun!

Jpa another way of persisting

2014-05-04T07:47:00.001-07:00

Introduction:

To deal with persistence in Java is getting less complicated by the tools that are being offered to us. The complication lies in the fact what to choose and what kind of strategy should you choose. In my previous blog I opened the doors to JPA which i denied to exist for a couple of years. "Just another Hibernate" was my defense. Looking at it from a historical point of view, My thoughts where based on some points. Hibernate was there together with toplnk and EJB to deal with ORM before JPA. These three tools where the bases for the reference called JPA. At last I opened that small and started being interested in JPA. I have to admit it is getting to me. I really like the way the things have been setup. A lot of people that tried to explain to me that JPA gave more freedom, have been shot by me as evangelists. The fun part of the story is, that not there preaching but a project that was using JPA brought me the light.

The example:

There are a couple of ways to deal with persistence in JPA. The most easy and fun one are repositories. I have them on my list to be study. But for now there is SQL, HQL (hibernate) and JQL (jpa). Sql gives you the straight forward way to acces an database something select * from customers or update customers set name = 'john doe' where id = 1 should look familiair. In JQL this looks pretty much the same but you are not talking to the database but to the objects that are representing the database in the application called entities.

So we have a simple Java pojo for customers with a customer name (I like it simple :)):
Lets use Lombok for fun:

public class Customer {

@Id
@GeneratedValue
@Getter
@Setter
private long id;
//lombok annotations.
@Getter
@Setter
private String name;

}

//Now we make it persistable:
@Entity
//the table to point to the name is not mandotory if the class has the same name as the database table.
@Table(name="customer")
public class Customer {

@Id
@GeneratedValue
@Getter
@Setter
private long id;
//lombok annotations.
@Getter
@Setter
@Column //you could also use the name attribute if the column name in the table difffers from the class //member name.
private String name;

}

if JPA is configured correctly this class is coupled to the table now by the ORM of JPA.

But now my customers are hooked up with the products they bought from me That is going to give me an N to N relation ship. 1 customer can buy multiple products and 1 product could been bought by multiple customers. An N to N relation ship can only achieved through a coupling table in the database. It would be really annoying if the represenation of your class model should be one on one with the database. This means that you would need to model all your coupling tables which yo are not going to need to present your data.

One of the things we can do is Model it with @named queries in JPA That would look something like this:

@Entity
//the table to point to the name is not mandotory if the class has the same name as the database table.
@Table(name="customer")
//The JPA named query
@NamedQuery(name = "selectPrdFromCustomer" , query = "select c.products from Customers c where c.id = ?1 ") })
public class Customer {

private long id;
//lombok annotations.
@Getter
@Setter
@Column //you could also use the name attribute if the column name in the table difffers from the class //member name.
private String name;

//lombok annotations.
@Getter
@Setter

//ManyToMany is the equilevant for N to N cascading all means get all the data you can on all the levels allowed.

@ManyToMany(cascade = CascadeType.ALL)

//The CUSTOMER_PRODUCT table is the coupling table. The join collumn is the collumn where the id from this class should couple with. the inverseJoinColum is the id of the products where it should couple to.

@JoinTable(name = "CUSTOMER_PRODUCT", joinColumns = @JoinColumn(name = "product_id"), inverseJoinColumns = @JoinColumn(name = "id"))

Private List<Products> products

}

At this point you can that a normal sql query has been handled on Entity level. The interesting part is that this sql query is separated on two different places. The named query is taking responsibility for the selecting part while the ManyToMany and the JoinTable is taking the responsibility for the coupling part.

As last you can create an PersistenceController or manager and that would need to do something like this:

Public PersistenceController {

@PersistenceContext

private EntityManager em;

@Setter

@Getter

private long customerId;

public List<String getProductNames() {

public List<String> product name = em.createNamedQuery("selectPrdFromCustomer").setParameter(1, customerId).getSingleResult();

//The getSingleResult is only applicable if you really want to have one result instead of an list but then the type of the method should be also String and not al list.

}

Conclusion:

Ones you know how to deal with persistence like this it is easy. But to learn it can give you a bad hadache. It is worth the effort That is for sure. Just try the example that has been given and have FUN!

peristence future arrived

2014-04-26T08:18:00.002-07:00

Introduction:

Traditionally Java and databases have been on friends. Starting with the java persistence libraries where soon enough we could use prepared statements to secure the way we queried the database. After that the world of Java was shocked with the birth of ORM toolings. These babies really decoupled the whole data tier from the rest and saved a lot of work. Implementations of JPA and Eclipse (Top) link helped the word easy up the way of persistence. That the future is allways one step away is common knowledge these days. But in some cases the future allready catched up with me before I realize this. m
In the case of JPA repositories that happened. I figured this technique out the last couple of weeks and I am already in love with it. They pushed things a little bit further then my imagination would go. It is not Star trek yet but still quite impressive.

The concept:

The Idea behind this to diminish the boiler plate coding further. The benefits of this I can bring down to two points:

After configuring this right which is a bit more work, the coding comes down to allmost nothing.
Because of the fact that the persistence part is mostly configuration, the repositories them selves can (not necessarily) function as a complete database tier.

The configuration is a combination between JPA and spring in my example. There might be other implementations out there where I don't have knowledge of.

The configuration:

The configuration I set up is a mix of spring and maven:

Maven pom part:

<spring.version>4.0.3.RELEASE</spring.version>

</properties>

<groupId>com.jolbox</groupId>

<artifactId>bonecp</artifactId>

<version>0.8.0.RELEASE</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-beans</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context-support</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-jdbc</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-orm</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-tx</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-web</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-webmvc</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>cglib</groupId>

<artifactId>cglib</artifactId>

</dependency>

<groupId>org.springframework.data</groupId>

<artifactId>spring-data-jpa</artifactId>

<version>1.5.1.RELEASE</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-test</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-core</artifactId>

<version>4.3.4.Final</version>

</dependency>

<groupId>postgresql</groupId>

<artifactId>postgresql</artifactId>

</dependency>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-entitymanager</artifactId>

<version>4.3.5.Final</version>

//could not load the JPA from here so I did it separate.

<groupId>javax.transaction</groupId>

</exclusion>

</exclusions>

</dependency>

//The jpa libary that is needed for hibernate.

<groupId>javax.transaction</groupId>

</dependency>

the persistence xml which needs to be placed in src/main/resources/META-INF.

<?xml version="1.0" encoding="UTF-8"?>

<persistence xmlns="http://java.sun.com/xml/ns/persistence"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"

version="2.0">

<persistence-unit name="dataSource" transaction-type="RESOURCE_LOCAL">

<class>com.shops.data.info.CustomerInfo</class>

//optional parameters.

</properties>

</persistence-unit>

</persistence>

The spring context file:

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:jpa="http://www.springframework.org/schema/data/jpa"

xsi:schemaLocation="http://www.springframework.org/schema/beans

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

http://www.springframework.org/schema/data/jpa

http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

<jpa:repositories base-package="THE REPOSITORY PACKAGE"/>

</bean>

</bean>

</bean>

</beans>

The repository part:

You can have multiple repositories. How to deal with the number of repositories depends completely on the fact how you want to deal delete with your data.

Here is al single example:

import com.my.web.shop.dataobjects.CustomerInfo;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.stereotype.Repository;

import javax.transaction.Transactional;

import java.util.List;

@Repository

@Transactional

interface CustomerRepository extends JpaRepository<CustomerInfo, Long > {

public List<CustomerInfo> findByEmailadressAndPassword(String email, String password);

public List<CustomerInfo> findByEmailadress(String email);

}

In this litle piece of code you find some astonishing things first of all after creating this interface, I did not create an implementation. Creating your own repository is not necessary in the most cases. As a matter of fact if you create an Repository on your own, you be at the point where we would start writing this extra boiler plate code we done for years.

Under water this interface is hooked up with the CrudRepository of Spring. This baby gives you allmost everything you need. All the basic database actions as select, update, delete and insert are there.

The second part you might find different is the naming of the methods. This is actually one of the most amazing parts. In the name of the method you declare the fields which you want to use in your sql statement. The parameters represent the values. So the first method would build under water: where emailAdress = "a@b.nl" and password = "myPassword.". If you have a big query the name of your method would become very long. Luckily there is another way to deal with queries. The @Query annotation helps to solve this problem. It could look something like this:

//The D.O. for the myShop customers.

@Entity

@Table(name = "customers")

public class CustomerInfo implements Serializable{

@Id

@GeneratedValue

private long id;

@Column

private String emailadress;

@Column

private String password;

@Id

public Long getId() {

return id;

}

public String getPassword() {

return password;

}

public void setId(Long id) {

this.id = id;

}

public void setPassword(String password) {

this.password = password;

}

public String getEmailadress() {

return emailadress;

}

public void setEmailadress(String emailadress) {

this.emailadress = emailadress;

}

// The D.O that couples that couples the customer to the test data. And contains the test data.

@Entity

@Table(name = "test")

public class Test implements Serializable {

@Id

@GeneratedValue

private long id;

@Column

private String label;

@Column(name = "customer_id")

private long customersId;

@OneToMany()

@JoinColumn(name="id")

private List<CustomerInfo> customerInfo;

public long getId() {

return id;

}

public void setId(long id) {

this.id = id;

}

public String getLabel() {

return label;

}

public void setLabel(String label) {

this.label = label;

}

public long getCustomersId() {

return customersId;

}

public void setCustomersId(long customersId) {

this.customersId = customersId;

}

//The test data repository

import com.shops.data.info.Test;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.data.jpa.repository.Query;

import org.springframework.stereotype.Repository;

import javax.transaction.Transactional;

import java.util.List;

/**

* Created by compurat on 4/19/14.

@Repository

@Transactional

interface TestRepository extends JpaRepository<Test, Long > {

@Query("SELECT t.label FROM Test t left join t.customerInfo c where t.id=(?1)")

public String findById(long id);

}

As you can see the findById method is not acting on the method name and the parameter value but will act on the @Query that we put on top of it. The last part of the query works in a simular way as we know with PreparedStatement. The questionmark tells the compiler this a placeholder an d the number tells which parameter in line it needs to pickup. In this case we only have one parameter. Not enough space for a mistake :).

There is another piece that might have caught your eye. There is a join in this query. It took me a while to figure out how that worked. The secret lies in the simple fact that you have to divide the join over two places.

@OneToMany()

@JoinColumn(name="id")

private List<CustomerInfo> customerInfo; defines this part of the join. It tells: listen there is a join coming up. In this case it is a OneToMany but it can also be @ManyToMany or @OneToOne. The @JoinColumn tells to connect to a certainfield in the CustomerInfo class.
The left join t.customerInfo c in the @Query part tells to actually execute the join. As you might notice the ON part from sql is not translated here. That is one of the parts That still puzzles me.How is it known to couple to? For the rest As allways as you understand the concept You find out it was not as hard as you expected first.

Conclusion:

The concept itself and the amazement it gave me leveled up the steepness for me to understand it. But now I am happy I gave it time and picked up the things I allready know now. The concept to me is still a bit futuristic. But the fact it is here and I love to use it. The power of this is amazing.

Have fun!

Test with Wicket and Spring

2014-03-25T08:12:00.001-07:00

Introduction:

I started working with Wicket and as a Java developer I like the concept. I think when there are really front end developers working, it is harder to defend the fact that you want to use wicket. Wicket brings it own html notations. Most frontenders are not keen on that. For working with Wicket there is a very good starting point: the wicket free guide. The interesting part starts when you are about to use DI and Wicket. Setting that up is not to hard The web.xml should look like this:

<web-app>
<display-name>MyApp</display-name>
<filter>
<filter-name>MyAppFilter</filter-name>
<filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class>
<init-param>
<param-name>applicationClassName</param-name>
<param-value>com.my.app.MyApp</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>MyAppFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>

For maven just get the latest version of wicket and spring and you be up and running in no time.

The problem:

The thing i ran into was the part where I wanted to start testing with Wicket using some DI to deal with some Classes which otherwise would end up in a very complex design. So the thing I cooked up after reading a lot of examples on the internet that didn't work.

The spring test config in src/test/resources:

<?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-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<bean id="classa" class="com.myapp.ClassA">
</bean>
<bean id="classb" class="com.myapp.ClassB">
</bean>
<bean id="wicketApplication" class="com.myapp.MyWicketApp">
</bean>
</beans>

The Junit test:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:myApp-test-context.xml" })
public class LoginTest {

private WicketTester wicketTester;

@Inject

// this stub is inheriting from an abstract class which is enhiriting from the wicket

WebApplication otherwise I cannot DI with the same type. The real app is also inheriting from

that abstract class

private AmyApp myAppStub;

@Before

public void init() {

wicketTester = new WicketTester(myAppStub);

}

The mock Application:

public class MyAppStub extends AmyApp {
private final ApplicationContextMock applicationContextMock = new ApplicationContextMock();
//injecting the classes from the test context.
@Inject
private ClassA classa;
@Inject
private ClassB classb;

protected ApplicationContextMock getApplicationContextMock() {
return applicationContextMock;
}

@Override
public Class<? extends Page> getHomePage() {
// TODO Auto-generated method stub
return null;
}

@Override
public void init() {
//Adding the injected classes to the context mock so they will be used during testing.
applicationContextMock.putBean("classa",
classa);
applicationContextMock.putBean("classb",
classb);
//adding the applicationmock to spring
getComponentInstantiationListeners().add(
new SpringComponentInjector(this, applicationContextMock));
}

}

Conclusion:

After I figured out how this baby works it is not that hard anymore to test with wicket. All you have to do is figure out the right pieces of the puzzle. In all the other examples the same pieces where missing.

I hope This helps.

Have Fun!