{"id":7920,"date":"2014-11-20T05:55:43","date_gmt":"2014-11-20T13:55:43","guid":{"rendered":"http:\/\/localhost\/exoblog\/?p=7920"},"modified":"2023-06-05T16:49:42","modified_gmt":"2023-06-05T14:49:42","slug":"developing-juzu-portlets-step-2-viewing-and-posting-secrets","status":"publish","type":"post","link":"https:\/\/www.exoplatform.com\/blog\/developing-juzu-portlets-step-2-viewing-and-posting-secrets\/","title":{"rendered":"Developing Juzu portlets – Step 2: viewing and posting secrets"},"content":{"rendered":"

\"02-Juzu-tutorial-series\"<\/a><\/p>\n

Previous step:
\n– Learn how to develop great Juzu portlets for eXo Platform!<\/a><\/em><\/p>\n

In the previous blog post, you learned how to start a simple Juzu project and deploy it in eXo Platform<\/a>.<\/p>\n

In this blog post, we will start to play with Juzu and add some functionality to our application.
\n<\/p>\n

Introduction<\/h2>\n

It\u2019s time to tell you a little bit more about the JuZcret application<\/strong>.<\/p>\n

First of all we have secret. A secret is a simple message<\/strong> but it can also be enhanced by an image<\/strong> (to illustrate the secret better).<\/p>\n

Our application will manage a list of secrets and display them. Of course any user can also share<\/strong> their secrets using an add<\/strong> secret button.<\/p>\n

In later steps, we will allow connected users to like and comment on secrets<\/strong>, but these features are not included in Step 2.<\/p>\n

Create our model<\/h2>\n

This does not require any Juzu stuff. We just need to create a simple Secret bean<\/strong> containing a default constructor with getters and setters.<\/p>\n

In the org.juzu.tutorial package, add a new package named models. In this new package, create a Secret class<\/strong> as below:<\/p>\n

\"01-model\"<\/a><\/p>\n

Secret<\/h3>\n
package org.juzu.tutorial.models;\n\nimport java.io.Serializable;\nimport java.util.Date;\n\npublic class Secret implements Serializable {\n\n   private String message;\n\n   private String imageURL;\n\n   private Date createdDate;\n\n   public Secret() {}\n\n   public String getMessage() { return message; }\n\n   public void setMessage(String message) { this.message = message; }\n\n   public String getImageURL() { return imageURL; }\n\n   public void setImageURL(String imageURL) { this.imageURL = imageURL; }\n\n   public Date getCreatedDate() { return createdDate; }\n\n   public void setCreatedDate(Date createdDate) { this.createdDate = createdDate; }\n}<\/pre>\n
Create our service<\/h2>\n
We need to create an application bean to manage all the secrets: the SecretService<\/strong>!<\/p>\n
The SecretService bean will contain all the logic for our application, like getting the list of secrets and adding a secret.<\/p>\n
In the org.juzu.tutorial<\/span> package, add a new package named services. In this new package, create the interface SecretService and its implementation SecretServiceMemImpl<\/span> as below:<\/p>\n
\"02-service\"<\/a><\/p>\n
The SecretService interface<\/h3>\n
package org.juzu.tutorial.services;\n\nimport java.util.List;\n\nimport org.juzu.tutorial.models.Secret;\n\npublic interface SecretService {\n\n    List<Secret> getSecrets();\n\n    void addSecret(String message, String imageUrl);\n}<\/pre>\n
The SecretService implementation<\/h3>\n
Note: In step 2, we will implement a simple in-memory data-saving implementation for simplicity. Real persistence is only for real aspirant Juzu developers not for rookies \ud83d\ude09 and will be covered later in step 5.<\/em><\/p>\n
package org.juzu.tutorial.services;\n\nimport org.juzu.tutorial.models.Secret;\n\nimport java.util.Date;\nimport java.util.List;\n\npublic class SecretServiceMemImpl implements SecretService {\n\n    private List<Secret> secretsList;\n\n    @Override\n    public List<Secret> getSecrets() {\n    return secretsList;\n    }\n\n    @Override\n    public void addSecret(String message, String imageUrl) {\n    Secret secret = new Secret();\n    secret.setMessage(message);\n    secret.setImageURL(imageUrl);\n    secret.setCreatedDate(new Date());\n    secretsList.add(secret);\n    }\n}<\/pre>\n
Display secrets<\/h2>\n
Now that our SecretService application bean is ready, we would like to use it.<\/p>\n
But as before, we first need to declare it. And declaring a custom bean in Juzu is very simple.<\/p>\n
Binding the application bean<\/h3>\n
Remember step 1, when I told you about the configuration file for our application named package-info.java.<\/p>\n
This Java file is the home for the package level annotation<\/strong>. This is where we will declare our new application bean. Replace the file package-info.java<\/span> with:<\/p>\n
@juzu.Application\n@Bindings({\n        @Binding(value = org.juzu.tutorial.services.SecretService.class, implementation = org.juzu.tutorial.services.SecretServiceMemImpl.class, scope = Scope.SINGLETON)\n})\npackage org.juzu.tutorial;\n\nimport juzu.Scope;\nimport juzu.plugin.binding.Binding;\nimport juzu.plugin.binding.Bindings;<\/pre>\n
In a Juzu application, we can have several kinds of bean: controllers, templates, plugins and application services<\/strong> (don\u2019t worry, each of these will be covered in a different step).<\/p>\n
All these different types of bean are managed by the container<\/strong>, which means that it is the job of the IOC container<\/strong> to manage the service lifecycle (instantiation, inject dependencies, \u2026) and to inject them where you need them.<\/p>\n
For instance, you can directly inject and use a template in a controller by adding the @Inject annotation<\/strong> when you declare it:<\/p>\n
@Inject\n@Path(\"index.gtmpl\")\nTemplate index;<\/pre>\n
However, if you want to use a custom bean, like our SecretService, you first need to declare it in the package-info.java<\/span> using the @Binding annotation<\/strong>.<\/p>\n
And that\u2019s it. Now we can use the SecretService bean anywhere in our application, simply by using the @Inject<\/span> annotation.<\/p>\n
Scoped binding<\/h3>\n
It\u2019s time for a lesson! Let\u2019s talk a little bit about scoped binding in Juzu<\/strong>.<\/p>\n
As you can see, we have declared our service as a singleton<\/strong>:<\/p>\n
scope = Scope.SINGLETON<\/pre>\n
By declaring the service bean<\/strong> as a singleton<\/strong> in package-info.java<\/span>, I have overridden the scope annotation<\/strong> the bean could declare.<\/p>\n
The annotation scope is optional in package-info.java<\/span>. If the scope is not specified, it is determined from the bean, which should be annotated with a scope.<\/p>\n
For instance, in our case, the following declaration in package-info.java<\/span>:<\/p>\n
@Bindings({\n        @Binding(value = org.juzu.tutorial.services.SecretService.class, implementation = org.juzu.tutorial.services.SecretServiceMemImpl.class, scope = Scope.SINGLETON)\n})<\/pre>\n
will give us the exact same result as this declaration:<\/p>\n
@Bindings({\n        @Binding(value = org.juzu.tutorial.services.SecretService.class, implementation = org.juzu.tutorial.services.SecretServiceMemImpl.class)\n})\nand add in SecretServiceMemImpl the @Singletion annotation:\n@Singleton\npublic class SecretServiceMemImpl implements SecretService {\n\n...\n}<\/pre>\n
It\u2019s recommended to add a scope in package-info.java, since it gives more fine-grained control and on opening the file you have a quick overview of the composition of the project.<\/p>\n
Abstract bean binding<\/h3>\n
Let\u2019s have another talk, this time about abstract bean binding<\/strong> in Juzu.<\/p>\n
In our example, we need to set the implementation member<\/strong> of the @Binding annotation because SecretService is an interface.<\/p>\n
If an application bean<\/strong> doesn\u2019t have an interface, then you don\u2019t need to set the implementation member. For instance, in our case, we may directly use this implementation:<\/p>\n
@Bindings({\n        @Binding(value = org.juzu.tutorial.services.SecretServiceImpl.class, scope = Scope.SINGLETON)\n})<\/pre>\n
Ok, that\u2019s enough explanation. Let\u2019s go back to the code.<\/p>\n
Develop the controller<\/h3>\n
We already developed the new application bean, SecretService, and we declared it in package-info.java. Now it\u2019s time to use it with a new controller<\/strong> named JuZcretApplication,<\/strong> which will allow us to display a list of secrets.<\/p>\n
In the org.juzu.tutorial package<\/span>, create a new java class JuZcretApplication:<\/p>\n
package org.juzu.tutorial;\n\npublic class JuZcretApplication {\n\n}<\/pre>\n
The JuZcretApplication controller bean<\/strong> must be the default controller<\/strong> for our application. Right now we have two controller beans in our project:<\/p>\n