Vaadin 7 on Grails 2.x
  • Introduction
  • Project setup
    • Command Line
    • IntelliJ IDEA
    • Eclipse
    • NetBeans
    • Plugin Configuration
    • Clean up
    • Best Practices
  • Database
    • GORM
      • Create Domain Model
      • Transactions
      • LazyInitializationException
      • Open Session In View I.
      • Open Session In View II.
      • Table Container
    • Groovy SQL
      • Create Sql
      • Execute SQLs
    • MyBatis
      • Configuration
      • Basics
    • JdbcTemplate
      • Create Beans
      • Usage
    • Clean Up With Alternatives
  • Architecture
    • Model View Presenter
  • Spring Autowiring
    • Create Simple Application
    • Application With Navigator
  • UI
    • Re-using GORM Validations
    • Async Push
    • Multiple application
    • SASS Compilation
    • Widgetset Compilation
  • Spring Security
    • Spring Security Dependency
    • Spring Security Basics
    • Secured Navigator
  • Localization
    • Localization Basics
    • Custom MessageSource
  • REST
    • Without using root URL
    • Using root URL for Vaadin app
  • Plugin development
    • Github
    • Development
Powered by GitBook
On this page
  • Step 1
  • Step 2
  • Step 3
  • Step 4
  • Step 4
  • Step 5
  • Step 6

Was this helpful?

  1. Localization

Custom MessageSource

PreviousLocalization BasicsNextREST

Last updated 5 years ago

Was this helpful?

Example code is available on .

We might want to define a custom MessageSource that will return a localized message. If a message is missing, we might want to log information about missing localization (in logs or database) or we might want to provide other way to fetch the localized labels.

In this toturial we will show way to load localization from database.

Step 1

Enable OSIV in VaadinConfig.groovy. Add or comment out the following line.

openSessionInViewFilter = 'org.springframework.orm.hibernate4.support.OpenSessionInViewFilter'

Step 2

Create new domain object that will hold localization data. Run grails create-domain app.Message command.

  • key holds the localization key that we will you in our application to refer a localized string

  • value is localized string, for example a label in English

  • locale defines in what language is value string

package app

class Message {

    String key
    String value
    Locale locale
}

Step 3

Create localized key-value pair for given language in BootStrap.groovy.

import app.Message

class BootStrap {

    def init = { servletContext ->

        Message home = new Message(key: 'home', value: 'Home', locale: Locale.ENGLISH)
        home.save(failOnError: true)
    }
    def destroy = {
    }
}

Step 4

Implement a new message source that will use GORM domain object, Message in our case, to load the localized messages. When a value is not found, we will return the key in brackets.

package app.i18n

import app.Message
import org.codehaus.groovy.grails.context.support.PluginAwareResourceBundleMessageSource
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.support.AbstractMessageSource

import java.text.MessageFormat

class JdbcMessageSource extends AbstractMessageSource {

    @Autowired
    PluginAwareResourceBundleMessageSource messageBundleMessageSource

    @Override
    protected MessageFormat resolveCode(String code, Locale l) {
        Message message = Message.findByKeyAndLocale(code, l)

        MessageFormat format
        if (message) {
            format = new MessageFormat(message.value, message.locale)
        } else {
            format = messageBundleMessageSource.resolveCode(code, l)
            if (!format) {
                format = new MessageFormat("[$code]", l)
            }
        }
        return format
    }
}

Step 4

Open grails-app/conf/spring/resources.groovy and add a new bean messageSource and messageBundleMessageSource that we use to get the localization in case the localization is not found in database.

import app.i18n.JdbcMessageSource
import org.codehaus.groovy.grails.context.support.PluginAwareResourceBundleMessageSource

beans = {

    messageSource(JdbcMessageSource)

    messageBundleMessageSource(PluginAwareResourceBundleMessageSource) {
        basenames = "WEB-INF/grails-app/i18n/messages"
    }
}

Step 5

Now we can use standard Grails.i18 method to get localized strings.

package app

import com.vaadin.grails.Grails
import com.vaadin.server.VaadinRequest
import com.vaadin.ui.Label
import com.vaadin.ui.UI
import com.vaadin.ui.VerticalLayout

class MyUI extends UI {

    @Override
    protected void init(VaadinRequest r) {

        VerticalLayout layout = new VerticalLayout()
        layout.setMargin(true)

        Label lbl1 = new Label(Grails.i18n('do.not.exist', Locale.ENGLISH))
        layout.addComponent(new Label(lbl1))

        Label lbl2 = new Label(Grails.i18n('home', Locale.ENGLISH))
        layout.addComponent(new Label(lbl2))

        setContent(layout)
    }
}

Step 6

Run the application grails run-app and open it in the browser . Then we will see the messages in the console.

Login screen
github.com/vaadin-on-grails/custom-messagesource
http://localhost:8080/custom-messagesource