Usually in our Ratpack application we use a registry to store components that we want to use in our application code.
The calling code for the registry doesn't need to know how the registry is implemented.
Ratpack support Google Guice for example, but Spring is also supported.
This means we can define the components for our registry using Spring and we only have to tell Ratpack where to look for the Spring configuration files.
Ratpack provides for us the ratpack.spring.Spring class with the static method spring.
This method returns a Ratpack registry implementation we can use in our application.
To enable Spring support we must add the Ratpack spring-boot dependency to our build file:
Continue reading →
If you have read my previous post about caching, The (non)sense of caching, and have not been discouraged by it, I invite you to build your own cache.
In this post we will build a simple cache implementation that refreshes its data automatically, using Java EE features.
Let's describe the situation.
We are building a service that uses an external resource with some reference data.
The data is not frequently updated and it's allright to use data that's up to 1 hour old.
The external resource is very slow, retrieving the data takes about 30 seconds.
Our service needs to respond within 2 seconds.
Obviously we can't call the resource each time we need it. To solve our problem we decide to introduce some caching.
We are going to retrieve the entire dataset, keep it in memory and allow retrieval of specific cached values by their corresponding keys.
Continue reading →
Groovy has a lot of nice and useful gems.
One of them is the FileTreeBuilder class.
With this class we can create directories and files using a nice DSL with a builder syntax.
The code already reflects the hierarchy of the directory structure, which makes it so more readable.
We can use an explicit way of referring to methods in the FileTreeBuilder class, but there is also support for a more dynamic version, where Groovy's dynamic nature comes to play.
In the first example we use the explicit method names.
We can use the method dir to create directories and the method file to create a file.
We can specify a name for the file and also contents:
Continue reading →
When we write software it is good practice to also write tests.
Either before writing actual code or after, we still need to write tests.
In Grails we can use the test-app command to execute our tests.
If we specify the extra option -continuous Grails will monitor the file system for changes in class files and automatically compiles the code and executes the tests again.
This way we only have to start this command once and start writing our code with tests.
If we save our files, our code gets compiled and tested automatically. We can see the output in the generated HTML report or on the console.
Suppose we have our Grails interactive shell open and we type the following command:
Continue reading →
Because Grails 3 is based on Spring Boot we can use a lot of the functionality of Spring Boot in our Grails applications.
For example we can start Grails 3 with a random available port number, which is useful in integration testing scenario's.
To use a random port we must set the application property server.port to the value 0.
If we want to use the random port number in our code we can access it via the @Value annotation with the expression ${local.server.port}.
Let's create a very simple controller with a corresponding integration test.
The controller is called Sample:
Continue reading →
Gradle 2.13 added a new method to get a property value: findProperty.
This method will return a property value if the property exists or null if the property cannot be found.
Gradle also has the property method to return a property value, but this method will throw an exception if the property is missing.
With the new findProperty method and the Groovy elvis operator (?:) we can try to get a property value and if not found return a default value.
In the following example we have a task that tries to print the value of the properties sampleOld and sampleNew.
We use the findProperty for sampleNew and the property method for sampleOld:
Continue reading →
Since Grails 3 we use Gradle as the build system.
This means we also use Gradle to define dependencies we need.
The default Gradle build file that is created when we create a new Grails application contains the Gradle dependency management plugin via the Gradle Grails plugin.
With the dependency management plugin we can import a Maven Bill Of Materials (BOM) file.
And that is exactly what Grails does by importing a BOM with Grails dependencies.
A lot of the versions of these dependencies can be overridden via Gradle project properties.
To get the list of version properties we write a simple Gradle task to print out the values:
Continue reading →
IntelliJ IDEA 2016.1 introduced better support for Gradle source sets. Each source set in our project becomes a module in the IntelliJ IDEA project. And each module has it's own dependencies, also between source sets. For example if we simply apply the java plugin in our project we already get two source sets: main and test. For compiling the test sources there is a dependency to the main source set. IntelliJ now knows how to handle this.
Let's create a sample Gradle build file with an extra custom source set and see what we get in IntelliJ IDEA. In the following example build file we add the source set api. This source set contains interfaces without implementations. The implementations for the interfaces are in the default main source set. Finally we have some tests in the test source set that depend on the classes generated by the api and main source sets.
Continue reading →
To create IntelliJ IDEA project files with Gradle we first need to apply the idea plugin. We can then further customise the created files. In this blog post we will add a Spring facet to the generated module file. By adding the Spring facet IntelliJ IDEA can automatically search for Spring configuration files. We can then use the Spring view to see which beans are configured in our project.
In the following example build file we use the withXml hook. This method is invoked just before the XML file is generated. We get an argument of type XmlProvider. From the XmlProvider we can access the XML as org.w3c.dom.Element, StringBuilder or groovy.util.Node. We use Node to alter the XML. We check if a FacetManager component is available. We need this to add a facet of type Spring.
Continue reading →
When we use the IDEA plugin in Gradle we can generate IntelliJ IDEA project files. We can customise the generated files in different ways. One of them is using a simple DSL to configure certain parts of the project file. With the DSL it is easy to set the version control system (VCS) used in our project.
In the next example build file we customise the generated IDEA project file and set Git as the version control system. The property is still incubating, but we can use it to have a proper configuration.
Continue reading →
When we run tests in IntelliJ IDEA the code is compiled by IntelliJ IDEA and the JUnit test runner is used. We get a nice graphical overview of the tasks that are executed and their results. If we use Gradle as the build tool for our project we can tell IntelliJ IDEA to always use Gradle for running tests.
We must open the Preferences or Settings dialog window. There we can search for Gradle and then look for Build, Execution, Deployment | Build Tools | Gradle | Runner:
Continue reading →
To quickly start with a Spring project we can use the website start.spring.io.
Via a user interface we can set project properties and at the end we have a project archive (Zip or gzipped Tar file) or build file (pom.xml or build.gradle).
We can also directory access an URL to create the output files and we set the properties via request parameters.
This way you can share a link with someone and if they click on it they will download the generated project archive or build files.
We can choose different base URLs depending on the type of project archive we want.
To get a Zip file we use http://start.spring.io/starter.zip and to get a gzipped Tar file we use http://start.spring.io/starter.tgz.
To create a Gradle build file with all the configuration for a project we use http://start.spring.io/build.gradle.
For a Maven POM XML file we use the URL hhttp://start.spring.io/pom.xml.
Continue reading →
