How do I access Map element using Spring EL?

In the previous example, How do I access collections members using Spring EL?, you have seen how to access a member of a collection using Spring EL square-braces [] operator. In this post you will learn how to use the same operator to access an element of a Map object.

For demonstration we will use the same Book class in the previous example to create the bean. The class without the corresponding getters and setters is as follow:

package org.kodejava.example.spring.model;

public class Book {
    private Long id;
    private String title;
    private String author;
    private String type;

    //
    // Getters & Setters
    //
}

Next, let’s create the spring configuration file. In this configuration file we create a map using the <util:map> with the map id of books and add some key-value pair entries in the map.

<?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:util="http://www.springframework.org/schema/util"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

    <util:map id="books">
        <entry key="0-201-61622-X" value="The Pragmatic Programmer"/>
        <entry key="978-1-934356-56-2" value="Hello, Android"/>
        <entry key="978-1-933988-69-6" value="Secret of The JavaScript Ninja"/>
        <entry key="978-1-449-37017-6" value="Java EE 7 Essentials"/>
        <entry key="9781935182962" value="Spring Roo in Action"/>
    </util:map>

    <bean id="book1" class="org.kodejava.example.spring.model.Book"
            p:title="#{books['9781935182962']}"/>
    <bean id="book2" class="org.kodejava.example.spring.model.Book"
            p:title="#{books['978-1-933988-69-6']}"/>
</beans>

After defining the map you can see how we access an element of the map. We use the square-braces operator [], we use the same operator as we are accessing a collection member. But instead of passing the index to the operator we pass the key of the map element that we are going to read.

<bean id="book2" class="org.kodejava.example.spring.model.Book"
            p:title="#{books['978-1-933988-69-6']}"/>

Finally to run the configuration you’ll need to create the following class:

package org.kodejava.example.spring;

import org.kodejava.example.spring.model.Book;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpELMapExample {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spel-map.xml");

        Book book1 = (Book) context.getBean("book1");
        Book book2 = (Book) context.getBean("book2");

        System.out.println("book1.getTitle() = " + book1.getTitle());
        System.out.println("book2.getTitle() = " + book2.getTitle());
    }
}

And example of output produced by this code can be seen below:

INFO: Loading XML bean definitions from class path resource [spel-map.xml]
book1.getTitle() = Spring Roo in Action
book2.getTitle() = Secret of The JavaScript Ninja

How do I access collections members using Spring EL?

In another posts about Spring EL examples you have learn the basic of Spring EL. In this post you will see another powerful examples of Spring EL. We are going to demonstrate how to use Spring EL to access collection members.

By using Spring EL you can select a single reference member of a collection. You can also select members of collection based on the values of their properties. Another thing you can do is extract properties out of the collection members to create another collection object.

To demonstrate this we are going to create a simple bean / pojo as our collection object. We will create a Book class with some properties (id, title, author).

package org.kodejava.example.spring.model;

public class Book {
    private Long id;
    private String title;
    private String author;
    private String type;

    //
    // Getters & Setters
    //
}

Next, we need to create the spring configuration file. In this configuration we will create a collection of books using the <util:list> element. And we also create a bean with its properties is obtained from one of the collection objects.

<?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:util="http://www.springframework.org/schema/util"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    <util:list id="books">
        <bean class="org.kodejava.example.spring.model.Book"
                p:title="Essential C# 4.0" p:author="Michaelis"/>
        <bean class="org.kodejava.example.spring.model.Book"
              p:title="User Stories Applied" p:author="Mike Cohen"/>
        <bean class="org.kodejava.example.spring.model.Book"
              p:title="Learning Android" p:author="Marco Gargenta"/>
        <bean class="org.kodejava.example.spring.model.Book"
              p:title="The Ruby Programming Language"
              p:author="David Flanagan &amp; Yukihiro Matsumoto"/>
        <bean class="org.kodejava.example.spring.model.Book"
              p:title="Einstein" p:author="Walter Isaacson"/>
    </util:list>

    <bean id="book" class="org.kodejava.example.spring.model.Book">
        <property name="title" value="#{books[1].title}"/>
        <property name="author" value="#{books[1].author}"/>
    </bean>
</beans>

In the configuration above you have seen how we set the title and author of the book bean. We use the square-braces operator ([]) to access collection’s member by their index. It’s look like this:

<property name="title" value="#{books[1].title}"/>
<property name="author" value="#{books[1].author}"/>

Which can be read as: please give me the collection object at index number 1 and take the value of its title and author to be assigned to the book bean. And as you might already know that a collection object in Java is always zero-based index. So this will give us the book with title User Stories Applied.

And finally let’s create an example class that run our spring configuration above. It’s simply load the spell-collection.xml configuration we create above. Get a bean from the loaded ApplicationContext and print out its properties, title and author properties.

package org.kodejava.example.spring;

import org.kodejava.example.spring.model.Book;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpELCollectionExample {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spel-collection.xml");

        Book book = (Book) context.getBean("book");
        System.out.println("book.getTitle() = " + book.getTitle());
        System.out.println("book.getAuthor() = " + book.getAuthor());
    }
}

Executing the code above will give you the following result:

INFO: Loading XML bean definitions from class path resource [spel-collection.xml]
book.getTitle() = User Stories Applied
book.getAuthor() = Mike Cohen

How do I do pattern matching using regular expression in Spring EL?

In this Spring Expression Language example we are going to learn how to use regular expression or regex to check if a text matches a certain pattern. Spring EL support regular expression using the matches operator.

The matches operator will check if the value has a pattern defined by the regex string and it returns the evaluation result as a boolean value true if the text matches the regex or false if otherwise.

For example we can use the matches operator to check is a the given email address is a valid email address. As can be seen in the following example:

<property name="emailValid" 
          value="#{user.email matches '^[_A-Za-z0-9-]+(.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(.[A-Za-z0-9]+)*(.[A-Za-z]{2,})$'}"/>

This configuration will evaluate the user.email property to check if the email pattern matches with the given regular expression. If matches then the emailValid property will be set to true otherwise it will be false.

Let’s see the complete example. Here are the spring configuration file, the User bean and a simple class for running the configuration file.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="user" class="org.kodejava.example.spring.model.User">
        <constructor-arg name="email" value="kodejava@gmail.com"/>
        <property name="emailValid"
                  value="#{user.email matches '^[_A-Za-z0-9-]+(.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(.[A-Za-z0-9]+)*(.[A-Za-z]{2,})$'}"/>
    </bean>
</beans>

The User bean is a simple pojo with two properties, a string email property and a boolean validEmail property.

package org.kodejava.example.spring.model;

public class User {
    private String email;
    private boolean emailValid;

    public User() {
    }

    public User(String email) {
        this.email = email;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public boolean isEmailValid() {
        return emailValid;
    }

    public void setEmailValid(boolean emailValid) {
        this.emailValid = emailValid;
    }
}

And finally the application class.

package org.kodejava.example.spring;

import org.kodejava.example.spring.model.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpELRegexExample {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spel-regex.xml");

        User user = (User) context.getBean("user");
        System.out.println("user.getEmail()     = " + user.getEmail());
        System.out.println("user.isEmailValid() = " + user.isEmailValid());
    }
}

When we run the code we will obtain the following result:

INFO: Loading XML bean definitions from class path resource [spel-regex.xml]
user.getEmail()     = kodejava@gmail.com
user.isEmailValid() = true

How do I use ternary operator in Spring EL?

In this example you will learn how to use ternary operator in Spring Expression Language. The ternary operator will evaluate a Spring EL to one value if a condition is true and to another value if the condition is false. Ternary operator is written using the ?: symbols, just as what you do in Java. The test condition is placed on the left side of the ? symbol while the evaluating expression is placed between the : symbol.

As an example let’s see how to use the ternary operator in a spring configuration file.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="book1" class="org.kodejava.example.spring.model.Book">
        <property name="type" value="Novel"/>
    </bean>
    <bean id="book2" class="org.kodejava.example.spring.model.Book">
        <property name="type" value="#{book1.type != null ? book1.type : 'Novel'}"/>
    </bean>
    <bean id="book3" class="org.kodejava.example.spring.model.Book">
        <property name="type" value="#{book1.type ?: 'Novel'}"/>
    </bean>
</beans>

In the configuration you’ll see that there are two way to use the operator. On the book2 bean we use the common usage of the operator. We check if the book1.type is not equal to null, if this is true then we take the book1.type as the value otherwise we just assign the type to 'Novel'.

There are some duplication in the first example. As you can see we call the boo1.type twice in that line of code. Actually the Spring EL version can give you a shorter one. Instead of doing like before you can just use the ternary operator like what we use in the book3 bean. So we can type book1.type ?: 'Novel'. Which will give us the same result.

Having the configuration created you will also need the Book class. So here is the Book class definition.

package org.kodejava.example.spring.model;

public class Book {
    private String type;

    public Book() {
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

Finally let’s now create a class to run the spring configuration. This class basically just load the spring configuration file spel-ternary.xml and get some beans, the Book bean from the application context and print out the value of its type property.

package org.kodejava.example.spring;

import org.kodejava.example.spring.model.Book;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpELTernaryOperatorExample {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spel-ternary.xml");

        Book book1 = (Book) context.getBean("book1");
        Book book2 = (Book) context.getBean("book2");
        Book book3 = (Book) context.getBean("book3");

        System.out.println("book1.getType() = " + book1.getType());
        System.out.println("book2.getType() = " + book2.getType());
        System.out.println("book3.getType() = " + book3.getType());

    }
}

And here are the execution output that you’ll get.

INFO: Loading XML bean definitions from class path resource [spel-ternary.xml]
book1.getType() = Novel
book2.getType() = Novel
book3.getType() = Novel

How do I use logical expression in Spring EL?

In the previous example you have learnt How do I compare values in Spring EL?. Where you saw how to compare two simple values for equality, less-than or greater-than, etc. In practice you might need to combine one or more of this comparison into a more complex logical expressions.

Spring EL also provides several operators that can be used to do this kind of logical operations. These operators are shown in the following table.

Operator Description
and A logical AND operation; the result will be true of both sides are true.
or A logical OR operation; the result will be true if at least on side is true.
not or ! A logical NOT operation; it will negates the expression value.

Here is a example using the logical and operator in the spring configuration file:

<property name="largeGlass"
          value="#{smallGlass.maxVolume ge 20 and smallGlass.maxVolume le 30}"/>

The configuration above will set the largeGlass property above to true if the glass maxVolume is greater-that-or-equal to 20 and less-than-or-equal to 30. It will only be considered as a large glass if the volume is between 20 and 30. So we use the logical and operator in that expression to evaluate the value for the largeGlass property. Now let’s see the complete example.

First let’s define the MyGlass pojo.

package org.kodejava.example.spring.model;

public class MyGlass {
    private boolean empty;
    private boolean halfEmpty;
    private int volume;
    private int maxVolume;
    private boolean largeGlass;

    public MyGlass() {
    }

    public MyGlass(int volume, int maxVolume) {
        this.volume = volume;
        this.maxVolume = maxVolume;
    }

    public boolean isEmpty() {
        return empty;
    }

    public void setEmpty(boolean empty) {
        this.empty = empty;
    }

    public boolean isHalfEmpty() {
        return halfEmpty;
    }

    public void setHalfEmpty(boolean halfEmpty) {
        this.halfEmpty = halfEmpty;
    }

    public int getVolume() {
        return volume;
    }

    public void setVolume(int volume) {
        this.volume = volume;
    }

    public int getMaxVolume() {
        return maxVolume;
    }

    public void setMaxVolume(int maxVolume) {
        this.maxVolume = maxVolume;
    }

    public boolean isLargeGlass() {
        return largeGlass;
    }

    public void setLargeGlass(boolean largeGlass) {
        this.largeGlass = largeGlass;
    }
}

After creating the pojo, let’s now create our spring configuration file where we define the smallGlass bean and the largeGlass bean.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="smallGlass" class="org.kodejava.example.spring.model.MyGlass">
        <constructor-arg name="volume" value="5"/>
        <constructor-arg name="maxVolume" value="10"/>
        <property name="largeGlass"
                  value="#{smallGlass.maxVolume ge 20 and smallGlass.maxVolume le 30}"/>
    </bean>
    <bean id="largeGlass" class="org.kodejava.example.spring.model.MyGlass">
        <constructor-arg name="volume" value="5"/>
        <constructor-arg name="maxVolume" value="30"/>
        <property name="largeGlass"
                  value="#{largeGlass.maxVolume ge 20 and largeGlass.maxVolume le 30}"/>
    </bean>
</beans>

And finally let’s create a class to run this configuration file in the console:

package org.kodejava.example.spring.spel;

import org.kodejava.example.spring.model.MyGlass;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpELLogicalExpression {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spel-logical-expression.xml");
        MyGlass smallGlass = (MyGlass) context.getBean("smallGlass");
        MyGlass largeGlass = (MyGlass) context.getBean("largeGlass");

        System.out.println("smallGlass.isLargeGlass() = " + smallGlass.isLargeGlass());
        System.out.println("largeGlass.isLargeGlass() = " + largeGlass.isLargeGlass());
    }
}

This code will give you the following output when executed:

INFO: Loading XML bean definitions from class path resource [spel-logical-expression.xml]
smallGlass.isLargeGlass() = false
largeGlass.isLargeGlass() = true