I'm creating a grails service that will interact with a 3rd party REST API via a Java library. The Java library requires credentials for the REST API by means of a url, username and password.
I'd like to store these credentials in configuration/Config.groovy
, make them available to a service and ensure that credentials are available to the service before it requires them.
I appreciate that grailsApplication.config
is available to controllers and that through a method of a service the relevant config values can be provided to the service, such as this:
package example class ExampleController { def exampleService def index = { } def process = { exampleService.setCredentials(grailsApplication.config.apiCredentials) exampleService.relevantMethod() } }
package example import com.example.ExampleApiClient; class ExampleService { def credentials def setCredentials(credentials) { this.credentials = credentials } def relevantMethod() { def client = new ExampleApiClient( credentials.baseUrl, credentials.username, credentials.password ) return client.action(); } }
I feel this approach is slightly flawed as it depends on a controller calling setCredentials()
. Having the credentials made available to the service automagically would be more robust.
Is either of these two options viable (I currently not familiar enough with grails):
Inject grailsApplication.config.apiCredentials
into the service in the controller when the service is created?
Provide some form of contructor on the service that allows the credentials to be passed in to the service at instantiation time?
Having the credentials injected into the service is ideal. How could this be done?
Grails supports "dependency injection by convention". In other words, you can use the property name representation of the class name of a service to automatically inject them into controllers, tag libraries, and so on. As an example, given a service called BookService, if you define a property called bookService in a controller as follows:
Grails provides a "service layer", which are classes that encapsulate business logic and are wired (using dependency injection) into the application context, so that any controller can inject and use them. Services are the preferred vehicle for most application logic, not controllers.
There are several ways in which you can customize the Application class. By default Grails will scan all known source directories for controllers, domain class etc., however if there are packages in other JAR files you wish to scan you can do so by overriding the packageNames () method of the Application class:
You can also use Grails' Interactive Mode to run the Grails runtime, from which you can issue any Grails command without waiting for the runtime to spin up for each task. In this guide we will be preferring the Grails wrapper for most commands.
The grailsApplication
object is available within services, allowing this:
package example import com.example.ExampleApiClient; class ExampleService { def grailsApplication def relevantMethod() { def client = new ExampleApiClient( grailsApplication.config.apiCredentials.baseUrl grailsApplication.config.apiCredentials.username, grailsApplication.config.apiCredentials.password ) return client.action(); } }
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With