Learn Share Learn & Repeat

Server Sent Events - Concept

noreply@blogger.com ({ Neeraj : Sidhaye }) — Mon, 11 Feb 2019 00:36:00 +0530

This post describes basics of

SSE concepts,
SSE use cases,
How does SSE work,
Message Formats,
SSE code on Client side and Server side
SseEmitter connection keep alive time,
Auto Re-connect mechanism

If you already know basics concepts, please refer to my post on
Server Sent Event - Development and Test Automation, which completely focused on E2E SSE development and addressing the challenges of testing SSE, preciously on how to automate SSE automation tests.

As always, you could refer to code here from my git hub account at BeTheCodeWithYou and refer to repository Spring-Boot-SSE

Please give star to the repo if you liked it :-)

Alright, so, with this post let's continue to talk on SSE basics

SSE Concept:-
Server Sent Events are the events ( data ) sent from server to the client over HTTP connection.

This connection is one directional connection from server to client. Meaning that, once the client connects to server, then there after server will send
any real-time notifications generated on the server side, to the client.

Client can be mobile app or browser based app, or any client that support HTTP Connection.

SSE use cases:-
you would have seen SSE use cases around you in day to day life

1) Continuous update about train time notifications on the display panel on the platform.
2) Continuous Rolling of Stock updates
3) Real time counter increment of your social media 'likes' icon.
and could be more...

How does SSE work:-
Client initiates a connection to server over http, this can be done by "client calling a rest end point on the server, in return, the response should have content-type header values as "text/event-stream".

This tells the client, that a connection is established and stream is opened for sending events from the server to the client.

In the browser you have a special object called, "EventSource", that handles the connection and converts the responses into events.

Message-Formats:-
SSE only supports text data. Meaning, server can only send text data to the client.
Binary streaming, while possible, is inefficient with SSE. In that case, WebSocket would be good choice for binary data transfer.

SSE code on Client side and server side:-

Client Side Code
EventSource object is the core object supported by browser.
To open a connection to the server, client will need to instantiate EventSource object.
const eventSource = new EventSource('http://localhost:8080/subscribe/');

Browser sends this GET request with accept header text/event-stream.
The response to this request, must contain header content-type with
value text/event-stream and response must be encoded with UTF-8.

To process these events in the browser an application needs to register a listener for the message event.

The property data of the event object contains the message

eventSource.onmessage = event => {
const msg = JSON.parse(event.data);
// access your attributes from the msg.
};

Client api supports certain events like open and error.

Open event occurs as soon as 200 response is received by client for /subscribe GET call.

error event is received by client, when there is any network error or server terminates the connection.

Server Side Code
Http Response to the above GET request on /subscribe end point must contain the Content-Type header with the value text/event-stream.

Spring Boot supports SSE by providing SseEmitter object. It was introduced in spring version 4.2 ( spring boot 1.3 ).

Create a spring boot application from start.spring.io and select web as dependency.

You can have a controller with rest end point GET with /subscribe allows client to establish connection.

Another rest end point POST with /event allows us to submit new events on the server.
This POST with /events or similar end point, can be called from any other server side component to send real time notification.

This /event end point, will then send event to connected clients.

Each client connection is represented with it's own instance of SseEmitter.

One limitation with spring SSE is , it does not give you tools to manage
these SseEmitter instances. So, for this example, I have used a list that stores SseEmitter objects and release objects on errors, completion or timeout scenarios.

SseEmitter object is created as below

SseEmitter emitter = new SseEmitter();

SseEmitter connection keep alive time:-

By default, Spring Boot with the embedded Tomcat server keeps the SSE HTTP connection open for 30 seconds.

we can override this 30 seconds via configurations.

spring.mvc.async.request-timeout=50000

this entry will keep the HTTP connection open for 50 seconds.

Alternatively, you can directly use SseEmitter constructor to pass this timeout value as below

SseEmitter emitter = new SseEmitter(150_000L);
//keep connection open for 150 seconds

Auto Re-connect mechanism

The nice thing about Server-Sent Events is that they have a built in re-connection feature. Meaning that, if the connection is dropped due to server error then client will automatically tries to re-connect after 3 seconds.

The browser tries to send reconnect requests forever until he gets a 200 HTTP response back.

It's a browser feature to wait for 3 seconds and then automatically reconnect.
This 3 seconds of time can be changed by the server by sending a new time value in the retry header attribute together with the message.

A client can be told to stop reconnecting using the HTTP 204 No Content response code.

Hope you liked this basic concept walk through of SSE.
Please follow reading on the next post on Server Sent Event - Development and Test Automation

Server Sent Events - Development & Test Automation

noreply@blogger.com ({ Neeraj : Sidhaye }) — Mon, 11 Feb 2019 00:35:00 +0530

This post is a next part of the my earlier post SSE basics.
In this post, I will get into SSE code and how we can automate it's testing.

Please refer to my github account at BeTheCodeWithYou and clone the repository Spring-Boot-SSE to directly run the application.

please give repo a star if it did help you ✌️

The need of creating this repository was apparent due to SSE Test challenges and I couldn't find anything fitted together!!

So, think about if you have a client connected to server over SSE but how do you make sure that your client or clients are getting events which are generated on the server and essentially how do you automate this test?? 😨

Important point to understand is that, here we are testing our server side components to make sure that it is able to send events to all the connected clients and able to release sse emitter objects when clients have initiated connection close. We have simulated the client ( UI ) with java library so that we can automate this approach. 👊

In your application code, you will have client code which will make use of browser supported EventSource object to establish SSE connection with server.

To test it, you will normally open browser, making a connection to SSE channel and then wait for the push notification to receive on the browser when an event is triggered on the server.

To test with multiple clients, you might open multiple browsers and do the same tests.

Challenges with this manual tests of SSE are:-

can you automate this test behaviour?
can you assert that message received by the client is correct?
can you run this test steps with any build tools? 🏃
could be more ....

To solve this challenge, I thought that it would be nice I find a java equivalent of EventSource object, so that I can write a client ( java based and not the browser ) that establish SSE connection. But then the next issue was, how do I assert because without which test is not complete!!

So, I found an open source library which support java equivalent of EventSource Object.

For Test automation and Assertions, I used ZeroCode TDD framework, which allows easiest way of calling a REST end point and importantly directly calling a java method and asserting what you expected.

Let's see in SSE in Action ☀️ running the tests

I approached this by creating gradle multi module project with Spring Boot.

Project code consists of below framework and libraries,

gradle

Spring Boot

Sprint REST API

ZeroCode Framework

okhttp-eventsournce

In the multi module gradle project, I have got 3 projects

see-client
sse-server
see-test-automation

Project structure setup

Sse-client

Project setup

Establish a SSE connection to REST endpoint exposed by sse-server project. This is achieved with EventSource java object .

This project has ClientEventHandler which overrides a onMessage method. When server push an event, onMessage method gets invoked and you can retrieve message here.

For simplicity, I have just added sse-client project code into sse-test-automation project, but you can always define dependencies of sse-client into sse-test-automation project as well.

sse-server - in action

click to open on gif, it doesn't run

This project exposes two rest end points.

/subscribe for allowing client to establish SSE connection.

    @GetMapping("/subscribe")
    public SseEmitter subscribeForEvents() {
     ...
    }

/events for triggering events on the server, which in turn publish events to subscribed clients.

@PostMapping("/events")
    public void pushNewEventsToClients(@RequestBody String eventData) throws IOException {
     ...
    }

sse-test-automation

project Setup

This module automates three activities together

a) client subscription for SSE connection,

b) triggering message on the server, and

c) asserting if the client has received the published events.

sse-test-automation project is the key of part of this repository, because that's the whole purpose of creating this repository to talk about SSE automation testing.

Assertions

As soon as client receives a message, in ClientEventHandler class, onMessage method gets called and there I am adding the message data received in the HashMap.

and then i have written a public method which returns size of the map.

See this code of file event_publish.json, how assertions is achieved.

Creating multiple Clients for SEE connection

This is achieve with the help of ZeroCode framework, which allows to create parallel threads. Refer to file parallel_load.properties

number.of.threads=3 ( to launch 2 clients and 1 server thread )

ramp.up.period.in.seconds=5 ( launch these 3 thread in gap of 5 seconds )

loop.count=1 ( do it once, so you will have total 3 threads )

How to RUN

I have created a TestSuite class, which does everything for us!!

It reads the paralle_load.properties and then create client 1 which connects to the server over SSE.

It then creates another client, client 2 which connects to server over SSE.

It then push message on the server side by calling REST end point.

Refer code here for TestSuite.java

Kotlin dev - Spring Boot REST API with Kotlin

noreply@blogger.com ({ Neeraj : Sidhaye }) — Sun, 11 Nov 2018 01:05:00 +0530

Let's talk about Kotlin in this article. I have been reading on Kotlin since last few weeks, so wanted to code in Kotlin to actually feel the difference in compared to java code.

Finally, developed a very simple REST API in Kotlin with Spring Boot + Spring Data + H2 in memory DB.
Kotlin and Spring Boot play well together.

You will also notice in the Code Walk through section that, there is NO controller, NO service class in the project!! That's magic of spring's @RepositoryRestResource. I explained below in details.

I will try to write down my notes, on what I have learnt so far in Kotlin as on day 0.

I have no experience on Kotlin but what I read and looked into the Kotlin code on github projects, this is definitely to practice on.

An obvious question, you would ask is, Why Kotlin?

In short,
Why Kotlin -

Kotlin compiles to bytecode, so it can perform just as well as Java.
More succinct than Java.
Kotlin's Data classes are clearly more concise than Java's value classes.
Classes are final by default which corresponds to Effective Java Item 17. You would need to explicitly put open if you want to make class inheritable.
Abstract classes are open by default.
One of Kotlin’s key features is null-safety - which cleanly deals with null values at compile time rather than bumping into the famous NullPointerException at runtime.
Primary constructor vs. secondary constructors. If you need more than one constructor then only you would go for secondary otherwise most of the Kotlin class would have primary constructor.
Kotlin can also be used as a scripting language.
Kotlin and Java are inter-operable, so it's easy to do a trial of Kotlin on just a small part of your codebase.
Kotlin uses aggressive type inference to determine the types of values and expressions for which type has been left unstated. This reduces language verbosity relative to Java.
Kotlin is fully supported by Google for use with their Android operating system.

Two points below, reference from Wiki:

According to Jetbrains blog, Kotlin is used by Amazon Web Services, Pinterest, Coursera, Netflix, Uber, and others. Corda, a distributed ledger developed by a consortium of well-known banks (such as Goldman Sachs, Wells Fargo, J.P. Morgan, Deutsche Bank, UBS, HSBC, BNP Paribas, Société Générale), has over 90% Kotlin in its codebase.
According to Google, Kotlin has already been adopted by several major developers — Expedia, Flipboard, Pinterest, Square, and others — for their Android production apps.

Code walk through

Project code is on my Kotlin Github Repo , which is a simple REST API using Kotlin and Spring Boot

Clone - https://github.com/BeTheCodeWithYou/SpringBoot-Kotlin.git

Kotlin
Spring Boot
Spring Data
H2 in-memory DB
Gradle

Understanding build.gradle

org.jetbrains.kotlin:kotlin-gradle-plugin -

compiles Kotlin sources and modules.

org.jetbrains.kotlin:kotlin-allopen

This is interesting part here. In Kotlin, by default all classes are final.
Now, in order to make a class inheritable, you have to annotate with open keyword.
And the problem is, lot of other libraries like Spring, test libraries ( Mockito etc ) requires classes and methods to be non-final. In Spring, such classes mainly to include @Configuration classes and @Bean methods.

Rule is simple, you need to annotate @Configuration and @Bean methods to mark them open but this approach is tedious and error-prone, hence Kotlin has come up with compiler plugin to automate this process through this dependency.

org.jetbrains.kotlin:kotlin-noarg and
apply plugin: 'kotlin-jpa'

In order to be able to use Kotlin immutable classes, we need to enable Kotlin JPA plugin. It will generate no-arg constructors for any class annotated with @Entity

apply plugin: 'kotlin'
To target the JVM, kotlin plugin needs to be applied.

apply plugin: 'kotlin-spring'
Required for Spring Kotlin integration

Compiler options

Spring nullability annotations provide null-safety for the whole Spring Framework API to Kotlin developers, with the advantage of dealing with null related issues at compile time and this feature can be enabled by adding the -Xjsr305 compiler flag with the strict options.

and also, configures Kotlin compiler to generate Java 8 bytecode.

compileKotlin {
kotlinOptions {
freeCompilerArgs = ["-Xjsr305=strict"]
jvmTarget = "1.8"
}
}

compile("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
Is the Java 8 variant of Kotlin standard library

compile('com.fasterxml.jackson.module:jackson-module-kotlin')
Adds support for serialization/deserialization of Kotlin classes and data classes.

compile("org.jetbrains.kotlin:kotlin-reflect")
Is Kotlin reflection library

Spring Boot Gradle plugin automatically uses the Kotlin version declared on the Kotlin Gradle plugin, hence the version is not defined explicitly on the dependencies section.

All remaining entries are self explanatory.

Kotlin Coding

Spring Boot Application

/src/main/kotlin/

com.xp.springboot.kotlin.SpringBootKotlinRestApiApplication.kt

Notice that, missing semicolon.
You need open and close braces of class only if you have @Bean otherwise just a class with name is required.
runapplication is a top level function.

Creating Data Class

Then we create our model by using Kotlin data classes which are designed to hold data and automatically provide equals(), hashCode(), toString(), componentN() functions and copy().

Also, you could define multiple entities in the same data class.

var is like general variable and its known as a mutable variable in kotlin and can be assigned multiple times.
There is another type val, is like constant variable and its known as immutable in kotlin and can be initialized only single time and moreover, val is read-only and you are not allowed to explicitly write to val.

Creating a Repository

Yes, just the one liner to define repository interface with spring data curd repository.

The interesting spring annotation here is RepositoryRestResource.
This comes by adding spring-boot-starter-data-rest dependency.

If you would have noticed, there is NO Controller , NO Service and this project is exposing below REST endpoints with HATEOAS enabled.

GET - http://localhost:8080/parkrun/runners
POST - http://localhost:8080/parkrun/runners
GET - http://localhost:8080/parkrun/runners/2
DELETE - http://localhost:8080/parkrun/runners/1

It's the magic of @RepositoryRestResource.
Apply collectionResourceRel to define custom resource label else annotation will use default as per the model class name ( /parkRunners ).

At runtime, Spring Data REST will create an implementation of this interface automatically. Then it will use the @RepositoryRestResource annotation to direct Spring MVC to create RESTful endpoints at /parkRunners.

Running the Application

Once you have the jar ready after gradle clean bulid. Just run the app using

java -jar SpringBootKotlinRestAPI-0.0.1-SNAPSHOT.jar

and hit the below url

http://localhost:8080/parkrun

Response:

{
"_links": {
"runners": {
"href": "http://localhost:8080/parkrun/runners"
},
"profile": {
"href": "http://localhost:8080/parkrun/profile"
}
}

}

Hit the url http://localhost:8080/parkrun/runners on GET

Response:

{ "_embedded": { "runners": [ { "firstName": "NEERAJ", "lastName": "SIDHAYE", "gender": "M", "runningClub": "RUNWAY", "totalRuns": "170", "_links": { "self": { "href": "http://localhost:8080/parkrun/runners/1" }, "parkRunner": { "href": "http://localhost:8080/parkrun/runners/1" } } } ] }, "_links": { "self": { "href": "http://localhost:8080/parkrun/runners" }, "profile": { "href": "http://localhost:8080/parkrun/profile/runners" } } }

Hit the profile url and see what you get

http://localhost:8080/parkrun/profile/runners

{ "alps": { "version": "1.0", "descriptors": [ { "id": "parkRunner-representation", "href": "http://localhost:8080/parkrun/profile/runners", "descriptors": [ { "name": "firstName", "type": "SEMANTIC" }, { "name": "lastName", "type": "SEMANTIC" }, { "name": "gender", "type": "SEMANTIC" }, { "name": "runningClub", "type": "SEMANTIC" }, { "name": "totalRuns", "type": "SEMANTIC" } ] }, { "id": "get-runners", "name": "runners", "type": "SAFE", "rt": "#parkRunner-representation" }, { "id": "create-runners", "name": "runners", "type": "UNSAFE", "rt": "#parkRunner-representation" }, { "id": "patch-parkRunner", "name": "parkRunner", "type": "UNSAFE", "rt": "#parkRunner-representation" }, { "id": "get-parkRunner", "name": "parkRunner", "type": "SAFE", "rt": "#parkRunner-representation" }, { "id": "delete-parkRunner", "name": "parkRunner", "type": "IDEMPOTENT", "rt": "#parkRunner-representation" }, { "id": "update-parkRunner", "name": "parkRunner", "type": "IDEMPOTENT", "rt": "#parkRunner-representation" } ] } }

SonarCloud Integration with SpringBoot-Maven

noreply@blogger.com ({ Neeraj : Sidhaye }) — Sun, 4 Nov 2018 04:38:00 +0530

In this article, I am writing up detailed steps on how you scan your code with SonarCloud by running maven sonar locally.

It's a very important phase, where we should configure sonar quality gates at very early stage of the development, so as to eliminate last time surprises!

More importantly, the point is, if you do sonar configuration at later stage then fixing sonar issues becomes more complex due to high code density and then you will have to perform more regression and integration tests to make sure that sonar fixes are not breaking existing functionalities. Hence, get sonar configured at early stage and FAIL FAST!

Let's get started,

1) SonarCloud Configuration

This involves below steps,

Creating an organization,

Adding project to your organization,

Generating security token

Before you being, go to https://sonarcloud.io and create your account.

Once you logged in, follow below steps

Creating an organization

A) On the top right, click on the + icon and select "Create New Organization"

B) You will see screen as below, fill up the details and click "continue"

C) On the next screen, select a free plan and click on "create organization"

D) You will see screen as below,

Adding project to your organization,

E) Click on "Create New Project" and on the next screen, you will have two tabs "select repositories" and "create manually"

you can select your github repository or create project manually.

If you don't have your github project, that's fine, go ahead with selecting option, "Create Manually" and enter below details and click "Create"

Organization - <Write org name, which we just created on step 1.B above >

Project Name - < any name you like>

Project Key- < this will be value of groupId.artifactId from your pom.xml >

F) Once you create project into your organization, you will see screen as below.

Generating security token

G) Click on "Configure Analysis" from above screen, and you will see below screen

H) Generate the token and then copy your token. On the next screen, you will see option to choose your project language and build technology.

Once you select maven or gradle, it will show your the command to run sonar with maven or gradle, which I have explained in below in "Using the Code" section.

This ends all your SonarCloud configuration, Let's move next and see how we can generate sonar report on the SonarCloud by running maven on local project.

2) Using the Code

Step 1:- Add sonar dependency

Go to your pom.xml and add the below plugin to enable SonarQube on your project.

<groupId>org.sonarsource.scanner.maven</groupId>

<artifactId>sonar-maven-plugin</artifactId>

<phase>verify</phase>

<goals>

<goal>sonar</goal>

</goals>

</execution>

</executions>

</plugin>

Step 2:- Run below command to scan your code against the SonarCloud Server

mvn clean verify -P sonar \
-Dsonar.host.url=https://sonarcloud.io \
-Dsonar.organization=<organization-name created on step 1.B above> \
-Dsonar.login=<token generated on step 1.G above>

Step 3: - Analyze maven output

You will see code is compiling and all your test cases running

Spring Application starting and running all the integration test cases written using ZeroCode framework.

All your test cases passed and now maven sonar plugin doing the magic and scanning your code against sonar rules.

You can see in highlighted text that, sonar sensors are running on the code, like JoCoCoSensor, checking Vulnerabilities, Java securitySenor etc etc.

Finally, you see build is success and you can see the report on the SonarCloud.

Notice now that, on the SonarCloud, you can see your project is now showing up the code quality metrics. Just refresh your project on SonarCloud and see below metrics.

Click on the project and look into the details of the reported issues,

Fix issues, run mvn sonar again on the local and when you see code is clean, then you are all good for commit->push.

Hope this helps. Leave your thoughts on the comments section.

Develop ZeroDefect API's with ZeroCode!

noreply@blogger.com ({ Neeraj : Sidhaye }) — Sat, 20 Oct 2018 05:32:00 +0530

This post details about how you can configure your mindset and achieve possibility of developing and delivering zero defects API with TDD, Writing and automating Integration Test Cases along with Build pipeline strategy.

In projects, we always talk about code quality, and hence we scan our code against various tools like FindBug, SonarQube, we write unit test cases ( min 80% coverage ), we write Integration test cases, we apply profiling and etc etc.

We do all this setup, with a GOAL for achieving less number of defects with quality deliverable as much as we could. yeah?

Now, even after having these code quality gates in place, we still find defects, some basics defect which shouldn't be there at all, contract related issues, integration issues, some of due to load/performance, some of due to memory issues and etc etc and It DOES happen!!

but WHY? In my experience so far, it may be due to following factors:-

Problem Statement

1) Involvement of QA at later stage. Normally they gets on boarded when you see your code integrated and working at least locally and ready to deploy on CIT or SIT, whatever.

2) Less focus on writing Integration Test cases in the BEGINNING.

3) Automation of Integration Test cases.

4) Takes time to correct/update integration test cases when defects comes because we introduced integration test cases at later stage!

5) Load and performance Testing kicks-In at very later stage.

6) Application Profiling kicks-In at later phase when testers reports issues.

You might have more points to add and in-fact you would have addressed few of them at right time but in general this is what we see happening!

In order to find solution of those 6 points listed above, please have a read on the below approach and the framework I have used in sample project code to make it possible. I am sure, you would easily map solutions to above points when you read on below.

Solution Approach - Code & Automate Integration Test Cases

Once your API’s contract are ready (probably draft is also perfect, because design gets evolve as you move on, so don't wait! )

1) Involve QA in the BEGINNING and make them comfortable with API contracts with the same comfort as of Developers.

2) Create Two projects of each API’s.

a) "API Build" - Project with implementation of API’s contracts practicing TDD with unit tests. Developers own this.

b) "API Integration Test" - Project with Integration Test Cases.

Writing JSON part of this project will be owned by QA and JAVA part will be owned by developers,.

You will see below, how QA can contribute in writing up integration test cases from day 1!

Java developer will focus on mocking up external API calls and boundaries of the system

( when external api’s or boundary systems are not ready to integrate ).

Later, you will just switch same test cases to run against actual test env of boundary systems/api’s.

3) Setup two Jenkins build jobs for each API ( “API Build” and “API integration Test”) because I don’t want my API Build project failure because of API Integration Test project failure hence the separation. Make sense?

4) Develop both of these projects in parallel - It would be obvious that API Integration Test project will finish sooner with basic integration test cases in place and hence eventually you will end up building TDD on your Jenkins build.

5) FAIL FAST approach - Schedule ( daily and then later hourly ) Jenkin Builds for API Integration Test project. Initially, you will see more failures on API Integration Test projects because “API Build” is still in development mode. Which is what the intention towards FAIL FAST approach!

6) Feel Good - As the “API Build” project development progresses, you will see more tests passing on the “API Integration Tests” project. Feel good about it! YES PLEASE.

7) Write Performance Test cases - The moment you see some comfort on the “API Integration Test” build, Immediately GET your QA involved in writing Performance Testing test case scenarios.

With the framework, I have used in my sample gitgub code, it is very easy to write performance test cases with it's simplest ever form using JSON and yes QA can do it very well and very quickly. They would just need NFR !

8) Introduce Integration Test Suites - Now, its time to write various Test Suites for testing logically related functionality together and independently.

Think of creating various test suites, for example -

A) Functionality Based Test Suites - something like Verify-ALLGET-Operations-TestSuite, Verify-ALLPOST-Operations-TestSuites, OR Verify-AccountCreationJounery-TestSuite wihch could involve account creation, fetch newly created account details, test 400, 404, 500 cases with account creation journey etc.

B) Performance based Test Suites - something like, Verify-GradualLoad-ALLGET-Operations-TestSuite ( increase load gradually with 5 sec gap, 2 sec gap, 0.2 sec gap etc ),

Verify-ParallelLoad-ALLGET-Operations-TestSuite ( increase load parallel - 100 requests in 100secs i.e. each request in 1 sec gap, looping twice, meaning 200 parallel requests)

9) FAIL-FAST again on Performance Test now! - See more failures on API Integration Test project for Load Test Suites. Fix issues on API Build project and reduce failures.

10) Feel Good again on Performance Test - As you fix issues, you will definitely see more confidence on your application on the performance side.

11) Add more and more tests to API Integration Tests project, Fail again, Feel good again, and keep it RUNNING!

Using the code

I have explored effective and efficient way of writing integration and performance test cases with an open source framework. Please follow details.

I have developed a very simple REST API using Spring Boot, Spring Data, H2 In-memory DB with Maven.

Clone sample project from my GitHub account https://github.com/BeTheCodeWithYou/SpringBoot-ZeroCode-Integration

clone -> https://github.com/BeTheCodeWithYou/SpringBoot-ZeroCode-Integration.git

Once you clone, go to your local repo and run below

mvn clean install

check the test results in /target folder

running the application
Java -jar SpringbootRestInMemoryDB-1.0.0-SNAPSHOT.jar.jar

Code walk-through

Once you import the project into IDE, it will look like as below. Highlighted once are the integration tests related code. That’s all and easy!

1) add dependency

<dependency>
<groupId>org.jsmart</groupId>
<artifactId>zerocode-rest-bdd</artifactId>
<version>1.2.6</version>
<scope>test</scope>
</dependency>

refer list of available versions here ZeroCode Maven Central

2) src/test/java - Organize integration test cases in faster ever possible way!

2.a) /integrationtests - TestGetOperations.java

As you see below, you just need to provide JSON file location, where the actual test case preset with asserts and this is the JSON, which will be created by QA as I mentioned in point 2.b in the solution approach section above. You will see all the details about @TargetEnv and @RunWith on the github with README.md

2.b) /testconfig - Custom class which runs spring app. you will just need to write start method in you spring main class.

Spring main class with start method, being called by E2eJunitRunner above

2.c) / testsuite - This runs the entire test suite i.e. picking all tests under "resources/integration_tests" folder and sub-folders.

As you see below, @EnvProperty is very interesting here. It allows you to run your test suite against multiple environments without any code change. All details are on the github with REAME.md file.

3) src/test/resources - Write Test cases in JSON formats for your API end points with assertions. Plenty of variations available for assertions of the response body, headers, custom response headers etc

One sample ( /reintegration_tests/get/get_new_parkrunner_by_parkrunid_test.json ) here from the project looks like this. You can see that request and response body can be re-used very easily.

4) Reports - See your test reports from the /target folder. Very interactive reports.

Thanks for your time and hope you finds this article useful as best practice for developing your API's.

Feel free to provide comments and suggestions on improving this best practice

JAVA 8 | Stream Basics

noreply@blogger.com ({ Neeraj : Sidhaye }) — Sat, 15 Sep 2018 20:20:00 +0530

Java 8 stream have always been the most exciting concept to understand and apply. I have got a chance to apply streams api's in my project and thoroughly enjoyed it.

This post is about, covering basic streams concepts to the best of my experience. I will try to keep it as simple as possible for easy understanding.

Before we begin on streams, it would be good if we take a look at concept of
Map , Filter & Reduce algorithm.

This concept is a generic and not related to java but will help us to understand stream in a much better and quicker way.

Let's understand this algorithm with an example. Again, I always prefer example with my passion being Running! :-)

So, let's say, we need to find out Average age of Runners older than 40.
If we solve this scenario with Map, Filter and Reduce algorithm, it will comprises below steps,

Step 1 -> Mapping
Creates a List of Runner and Returns a List of Integer. Here, size of the returned list will be same but it will have integer holding Runners Age.

Takes List<Runner> and returns List<Integer> =
Resulting List type differs but Size is same.

Step 2 -> Filtering
Now, you are telling that, filter out List<Integer> which returns only Runner with age greater than 40.

Takes List<Integer> and returns List<Integer> =
Resulting List type same, but size differs after filter is applied.

Step 3 -> Reduce
At this step, you will just apply aggregation function ( here Avg ) on the filtered list from step 2.
Takes List<Integer> and returns Average Age of Runner older than 40.

This is how Streams works internally!

Let's understand some basics of Streams

What is Stream all about

# An Object on which we define operations, like Map, Filter and Reduce are operations.

# An Object which does NOT hold any data and that's the biggest difference between Collection and Stream.

# An Object that should not change data that it processes.
when I say, should not, meaning it a rule, one should follow while working with streams. Compiler will never report anything here!

# An object which is capable of processing data in one pass.
Suppose you have stream of Account collection, now while processing this stream, there should not be any intermediary collection created as part of this processing.

# Is a typed Interface
public interface Stream<T> extends BaseStream<T, Stream<T>>

Stream interface can take any of type of data for streaming, it could be stream of String, Integer, Customer etc etc.

# Efficient data Processing - Large or small amount of data
Efficiently process data - in Parallel and in Pipelined ( avoiding intermediary computations ).

public class StreamBasic {

public static void main(String ... args) {

//Creating Stream of Strings

Stream<String> stream = Stream.of("Sprint", "TempoRun", "NegativeSplit", "LongRun", "Intervals"); // MAP



//Prints all elements of Streams

/*stream.forEach( s -> System.out.println(s));*/



// Applied Predicate with only string lenght > 10

Predicate<String> p = s -> s.length() > 10;



//filter strings greater than of lenght 10*/

/*stream

.filter(p)

.forEach(System.out::println); */



List<String> runTypes = new ArrayList<>();



Predicate<String> p1 = Predicate.isEqual("LongRun");

Predicate<String> p2 = Predicate.isEqual("TempoRun");



//Prints only elements from stream when p1 or p2 is present

/* stream

.filter(p1.or(p2))

.forEach(s -> System.out.println(s)); */



/*prints stream elements using Peek method and then applying filter with only p1 or p2 predicates and finally adding result to the list*/

stream

.peek(System.out::println)

.filter(p1.or(p2))

.forEach(runTypes::add);

System.out.println("List size=>"+runTypes.size());



}

}

You would have noticed that there is only one stream can operate at a time, so if you have two streams in operation ( say, two streams.filter statement ) then you will get a runtime error as below

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed

Java 8 - Auto closure of resource stream

noreply@blogger.com ({ Neeraj : Sidhaye }) — Sun, 9 Sep 2018 20:11:00 +0530

Java 8 at it's best! Yes and handles memory leaks scenarios very effectively.

Memory leaks scenarios should be handled by programmer very carefully and here java 8 comes to rescue for taking care some of scenario out of the box.

Before I begin, let me quickly put short note on what is referred to as memory leak in a java application.

Memory leak is scenario in which garbage collector is not able to release objects. You would think what are these objects would be, yeah?!
so, such object are those objects which are created by the application and not in use by the application but are being referenced from the code!
Yes, such objects eats up memory and hence leads to out of memory error because GC won't be able to release them because of their reference.

I will try to cover Memory Leak in detail on my other post, so for now, let's proceed with how java 8 handles few of the memory leak scenario out of the box.

Consider a scenario when you are reading large text file by opening a connection to URL and reading contents over inputstream.

Below code sample, leads to memory leak because buffered reader is never closed.

Java 8, comes to rescue and provides capability to auto closure of steams.
see the modified version of above code with java 8.

Functional Interface

noreply@blogger.com ({ Neeraj : Sidhaye }) — Sun, 9 Sep 2018 17:02:00 +0530

Functional interface as concept is not new to java 8! It was there with earlier java version as well.

Any interface with only single abstract method is called Functional Interface. Yes!

We already have such functional interface available like Runnable, Comparator , Callable and few others. All these interfaces have exactly one abstract method, hence they all are functional interface.

Now, in JAVA 8, functional interface is enhanced and made it more powerful along with Lambda expression.
In short, Lambda expression is (param list ) - > method body

There are new functional interfaces have been introduced in java 8.

java.util.function a new package introduced in java 8.
This package has multiple functional interfaces for various scenario usage.

functional interface can provide target type in multiple context, such as assignment context, method invocation and cast context.

stream.filter(e -> e.getSize(0) > 10 ); // method invocation

Predicate<String> pre = String::isEmpty; // assignment context

stream.map((ToIntFunction) e -> e.getSize()) // cast context

MDB vs JMS listener

noreply@blogger.com ({ Neeraj : Sidhaye }) — Thu, 20 Apr 2017 21:32:00 +0530

Notes around MDB ( Message Driven Bean) vs Standard JMS listener, and their advantages and limitations around concurrency, scalability etc.

Concurrency

JMS Listener - JMS has NO built-in mechanism to handle more than one incoming request at a time. Meaning that, if you have JMS listener which is listening a queue, where loads of messages coming in, then your JMS listener will consume one message at a time, which results in picking up messages one by one, which might cause message piling up on queue!

MDB - The main advantage that MDBs have over simple JMS message consumers is that the EJB container can instantiate multiple MDB instances to handle multiple messages simultaneously.

Now, in order to handle concurrently in JMS listener you have two options:-

a) Dynamic scaling of JMS listener by spawning multiple threads for JMS listener via configuration.

This can be done by adding property concurrency="15-40" to <jms:listener-container>
This sets concurrentConsumer to 15 and maxConcurrentConsumer to 40 in the properties of DefalutMessagingListenerContainer ( DMLC ) of Spring.

Above configuration instructs DMLC to always start up a minimum of 15 consumers. When a new message has been received, if the maxConcurrentConsumers has not been reached and the value of the idleConsumerLimit property has not been reached, then a new consumer is created to process the message.
This behavior from the DMLC continues up to the limit set by the maxConcurrentConsumers property. When no messages are being received and the consumers become idle, the number of consumers is automatically decreased

b) Deploy JMS listener on multiple JVM instances.This allows multiple consumers listening to queue.

IMP Note-> One should NOT increase number of concurrent consumers for a JMS topic. This leads to concurrent consumption of same message, which is NOT desirable.

MDB Limitation

MDB can be linked to listen from only one queue or topic whereas standard JMS listener can be linked to listen to multiple queues or topic.

In order to allow a MDB to listen to multiple queues or topic, you will have to deploy multiple MDB classes.

XA, Non-XA transaction and 2PC Protocol

noreply@blogger.com ({ Neeraj : Sidhaye }) — Thu, 9 Mar 2017 11:43:00 +0530

Wisely choose transaction type while designing your application. Transaction, a key aspect of any application should be taken care well in advance. Here are few tips while choosing between XA and Non-XA transaction.

XA transactions

XA transaction is like global transaction.
When you have multiple resources involved for a single transaction, you should be using XA transaction.Multiple resource means, 2 or more databases or JMS listener and a database etc.
Transaction manager (TM) is responsible for bringing multiple resources under a single transaction.
Transaction manger is the capability of the container.
TM uses 2PC (Two phase commit) pattern for committing the transaction.
The resources (JMS, DB etc ) involved in the transaction should have capability to support 2PC pattern otherwise XA will not work.

NON-XA transaction

Non-XA transaction is like a local transaction.
Use this approach when a single resource is doing all it’s transaction work itself.

What is 2PC ( TWO Phase commit ) Protocol?

2PC is used to make sure the transactions are in sync when you have 2 or more DBs.
Assume I have two databases ( DB-1 and DB-2) using 2PC, both of these databases are in two different locations.
Now, before DB-1 and DB-2 are ready to commit transactions, they will notify transaction manager that they are ready to commit ( PHASE 1 ). So when the transaction manager is acknowledge, it will send a signal to DB-1 and DB-2 telling them go ahead for commit (PHASE – 2 )..

Important note-> Two phase commit does not guarantee that a distributed transaction can't fail, but it does guarantee that it can't fail silently without the TM being aware of it.

Microservices/API design principles

noreply@blogger.com (Unknown) — Mon, 14 Nov 2016 21:47:00 +0530

My notes on MicroService design principles.

Microservice design principles - microservies has nothing to do with physical size or lines of code!!! It's about minimizing complexity.

"instead of having single complex service for your systems, design bunch of small services based on specific business capabilities. Small service means, it should minimize complexity, should serve a focused purpose and should minimize inter-service communication"

Design principles for MicroServices

1) Develop and Deployed independently
Each service shuould be developed and deployed independently. Deployment of one service should not impact other services and a each service should have it's own code base.

You are doing wrong if
you find a need to deploy services together
you have one code base for multiple services
you need to send notification to before you deploy a service

2) Data ownership

Service should have it's own databased or preferably set of tables that is manged by only a specific service.
should avoid scenario where multiple services are writing and reading from the same set of tables, any changes to table would require changes in all services.
having each service has it's own data ownership introduce loose coupling between service and database.
key point is , services should NOT have knowledge of each others underlying database.

Having own database for a services allows to choose right database technologies based on service functionality.

3) loosely coupled from all other services,

once you adhere to point 1 and 2, you have already initiated loose coupling but there are more on loose coupling:-
minimal dependency on other services
communication with other services should be over exposed public interfaces( API, events etc )
such interfaces or API should NOT expose internal details

4) Follow High cohesion methodology

closely related functionality must stay together in a single service. this minimizes intercommunication between services.

5) Resilient service

Single point of failure in system should NOT impact multiple services. if you have a service with independent data ownership, loose coupling, independent deployable artifact, it is a step towards resilient system!

Remember- Total resilience in the face of all situations is NOT possible.Implement what is feasible in the short term and work to achieve greater resilience in stages.

6) shared library

carefully watch out implications of shared library introduction to your services.
You are doing something wrong when changes to shared library requires updates to all services simultaneously.

7) Introduce Asynchronous workers
very important design principle - introduce asynchronous workers to minimize impact on primary service API.
example-> A batch job can be introduced in a service as an asynchronous worker which is responsible to process high volume request, re-try mechanism for failed request etc.
This asynchronous worker provide following benefits:-

speed up the primary request path
spread load to asynchronous worker in case of high volume request
reduce error scenarios on primary API

8) Service Versioning

An API is never going to be completely stable. Change is inevitable!!

it's always a best practice to version your service.

Versioning can be added to header or in the service url.

Following technique can be used to maintain service version:-

The URL has a major version number (v1), but the API has date based sub- versions which can be chosen using a custom HTTP request header. In this case, the major version provides structural stability of the API as a whole while the sub-versions accounts for smaller changes (field deprecations, endpoint changes, etc).

Risk Storming

noreply@blogger.com (Unknown) — Tue, 4 Oct 2016 00:38:00 +0530

Risk Storming - Collaborative and Visual Technique for identifying technical risk

My notes

1) Draw you app design on board - high level to show each like component, class, container etc
2) Identify risk individually - each and every member of team has different view of looking at risk!
3) Highlight risk at component/flow/integration level
4) Discuss and Priorities

Excellent write up by Simon here @ Risk Storming.

Java EE - the next inception!

noreply@blogger.com (Unknown) — Thu, 31 Mar 2016 09:13:00 +0530

Read this article on WebSphere and found this interesting about basics of how IBM WebSphere Application Server Liberty profile works, and how its architecture differs significantly from that of older Java EE application servers

Please read here complete article at Java EE, the next inception: A primer to WebSphere Liberty for Java EE developers

Portlet Preferences Usage - Best Practices

noreply@blogger.com (Unknown) — Tue, 19 Nov 2013 19:13:00 +0530

PortletPreferences should be used very carefully and in situations only when there is a valid use case for it.
So ideally, one should have good knowledge of portlet preference and most imortantly, where to apply it.

The PortletPreferences object provides the ability to store information persistently about how a client wants to use a particular portlet.

For example, with the stock portlet, a user can provide stock code information to the portlet, and the portlet will store that information persistently using the PortletPreferences object. The next time the user visits the view mode of the portlet, the stock details for that user's choice will be displayed.
Persistently storing this information, is all done behind the scenes for you by the portal framework.

So when you use portlet preference, did you ever think about where does portlet preference gets stored? In hard drive, some KB's data in DB or as CLOB or something that is not efficient.
So how to store portlet preference is completely upto portal vendors and hence we as a developer or DB administrator don't have much control over the data which is stored in portlet preference.

Let's talk about application efficiency, where in if you want to store just a Boolean flag and if you choose to store it in portlet preference, you don't know how it will be stored and what size it would use for storage compared to if we chose to use our own DB to store the flag which would just take few tiny bit of space.

Furthermore, mining information from data stored in portlet prefernce is almost very difficult.

So, If you don't know how the portal stores your PortletPreferences data, and you don't know how the portal ties a particular preference to a particular user, you're going to have a pretty hard time mining your own data.

The best use of portlet preference could fall in below situations where a user wants

1) To have red background.
2) configurable pagination numbers
3) configurable TimeZone
4) configurable portotol ( http or https etc )
5) Configurable fonts etc.

Conclusion -

Use portlet preference for simple configurable parameters
Don't ever use preference to store information where it would become impossible to do data mining from preference storage because you don't have control over preference storage.

Dynamic Registration of Servlets and Filters at application startup

noreply@blogger.com (Unknown) — Wed, 23 Oct 2013 17:48:00 +0530

Recently I read about one of the nice feature of JAVA EE 6 - Dynamic Registration of Servlets and Filters at application startup.

I then thought of use cases around this feature.
I think, this is mostly desinged for framework creators but developers could also get benefits from this.

You can use this fefature by using new methods introduced in the ServletContext class which are able to programmatically add servlets and servlet filters to a web application during startup.

The methods are addServlet() method to add a servlet to the web application, and the corresponding addFilter() method to add a servlet filter.

Here's an example, which dynamically registers a Servlet as soon as the ServletContextListener is triggered:

//Register Servlet

public class MyServletContextListener implements ServletContextListener {

@Override

public void contextInitialized(ServletContextEvent sce) {

ServletContext sc = sce.getServletContext();

// Register Servlet here

ServletRegistration sr = sc.addServlet("DynamicServlet",

"com.sample.DynamicServlet");

sr.setInitParameter("servletInitParamName", "servletInitParamValue");

sr.addMapping("/mydynamicServlet");

}

The same steps can be used to register a Filter named MyDynamicFilter bound to the class com.sample.TestFilter:

// Register Filter

FilterRegistration fr = sc.addFilter("DynamicFilter","com.sample.TestFilter");

fr.setInitParameter("filterInitName", "filterInitValue");

fr.addMappingForServletNames(EnumSet.of(DispatcherType.REQUEST),

true, "DynamicServlet");

Would be great if readers of this post, could suggest creative use cases which could add useful functionality to an applications.

How to programatically refresh data from LDAP

noreply@blogger.com (Unknown) — Thu, 17 Oct 2013 19:04:00 +0530

Came across to this article which very well details out, how one can Programatically refresh date from LDAP.

The articles also have a Sample Code to programatically refresh data from the LDAP.

I am sure, this would be helpful for those who encounter this use case.

Handling users with multiple roles while Login to portal

noreply@blogger.com (Unknown) — Wed, 9 Oct 2013 15:50:00 +0530

Problem Statement-

When you have got scenario where in, a user is belonging to multiple roles and you want him/her to select his choice of role while login to portal.

Solution-
This situation can be solved by developing a custom login portlet and make use of Authentication Filters.

Here is how this would work,
User login using your custom login portlet with his userid & password.

Once user submit, control goes to authentication filter and there you connect to your user repository to fetch user roles and preset a screen ( next screen of login portlet ) to select his roles.

When user selects his roles and click Login, control again goes to authentication filter and there you authentication user and redirect user to portal landing page.

I hope that helps.Feel free to post your queries here.

How to change the WPS URL

noreply@blogger.com (Unknown) — Tue, 21 Aug 2012 21:03:00 +0530

There might be situations when you want to change portal entry url.
After portal installation you will see portal url as

http://hostname:10039/wps/portal ( for Anonymous users) and
http://hostname:10039/wps/myportal ( for Authenticated users).

In the above url,

wps is the WPSContextRoot
portal is the WpsDefaultHome
myportal is the WpsPersonalizedHome

Now, if you want to change the url and want to look like

http://hostname:10039/mynewcontextroot/mynewWpsDefaultHome
( for Anonymous users)

http://hostname:10039/mynewcontextroot/mynewWpsPersonalizedHome
( for Authenticated users).

You would require to make changes in the
wkplc.properties and wkplc_comp.properties files, located in the wp_profile_root/ConfigEngine/properties

For complete details, please go through the following documentation

http://publib.boulder.ibm.com/infocenter/wpdoc/v6r1/index.jsp?topic=/com.ibm.wp.ent.doc_v615/config/cfg_intr.html

Above changes are for wps 6.1.5. If you want to make change in some other wps version, please refer to respective WPS version info center.

All about XMLAccess

noreply@blogger.com (Unknown) — Sun, 12 Aug 2012 23:29:00 +0530

Recently, I came across to an article which tells everything about XMLAccess.

I would strongly recommend to go through this XMLAccess article to understand XML Access concepts in detail.

Many thanks to Fang and Joe for this wonderful article.

Web security concepts and considerations for WPS Administrators

noreply@blogger.com (Unknown) — Thu, 17 May 2012 23:39:00 +0530

Recently I read an article on Web Security concepts on WPS.

The article covers various concepts like Authentication, Authorization, SSO, ESM, Sessions, Step Up Authentication and many more.

Thought as per article heading, it is specifically for WPS Admin but I would strongly recommend to go through complete article even if you are from portlet development.

Please read article here at Web Security concepts on WPS

InterPortlet Communication - Best Practice Matrix

noreply@blogger.com (Unknown) — Fri, 13 Jan 2012 19:34:00 +0530

I published "InterPortlet Communication - Best Practice Matrix" on IBM portal wiki.

This IPC Matrix helps to choose best practice for various scenarios of IPC.

Persisting user navigational states in WPS 7

noreply@blogger.com (Unknown) — Sat, 10 Dec 2011 09:41:00 +0530

You might have come across to situations where you would want WPS to persist user navigational states like

Portlet states:

    Normal
    Minimized
    Maximized

Portlet modes:

    config
    edit_defaults
    edit
    view
    help

Page selection:

    The last page that was active before the user logged out.

With the persistent session state feature, portal users can resume and continue a previously interrupted working session at the same state where they left the session. When the user logs out or the session times out, the portal stores the current navigational state into the database.

Resuming the session state is only possible if either the portal theme login link or WebSphere Application Server TAI based authentication is used to login to the portal.

Please have a look at detail article at Configuring user session persistance

How to know what all objects are stored in session at any point of time

noreply@blogger.com (Unknown) — Tue, 22 Nov 2011 20:43:00 +0530

You might want to know at any point of time that how many objects are stored in session along with their size. This would be most useful when you are analyzing application performance or working on performance tuning area.
This would also be useful in debugging when your application is throwing java.io.NotSerializableException.

There is a servlet called com.ibm.ws.webcontainer.httpsession.SessionInspectServlet that ships with WAS located in com.ibm.ws.webcontainer.jar. This jar is placed under <WPS_ROOT>/AppServer/plugins/.
SessionInspectorServlet can be used to list down what all objects are stored in session along with size of the objects.

In order to use SessionInspectServlet, you would need to enable “Serving servlets by class name”, you can set this value in the ibm-web-ext.xmi
By default this value is true, you can see sample ibm-web-ext.xmi file below and can see that serveServletsByClassnameEnabled value is true.

<?xml version="1.0" encoding="UTF-8"?>

<webappext:WebAppExtension xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:webappext="webappext.xmi" xmi:id="WebAppExtension_1320397630802" reloadInterval="3" reloadingEnabled="true" additionalClassPath="" fileServingEnabled="true" directoryBrowsingEnabled="false" serveServletsByClassnameEnabled="true">

</webappext:WebAppExtension>

To list down session objects stored in session, you would required to hit below URL

http://localhost:10039/wps/<context-root>/SessionInspector/servlet/com.ibm.ws.webcontainer.httpsession.SessionInspectServlet

here, context root would be context root of your application. You can specify this while installing your WAR through portal admin console OR you can also find out this value inside application.xml located under <WPS_ROOT>/wp_profile/installedApps/<NODE>/<EAR NAME>/META-INF/

You would see list of your session objects and their size as shown in the screen shot.

How to get HttpServletRequest and HttpServletResponse from portlet request

noreply@blogger.com (Unknown) — Thu, 17 Nov 2011 20:26:00 +0530

There are some scenario when you want to get httpServletRequest or httpServletReponse from portletRequest.

IBM provides an utility class which gives you what you are looking for.

Yes, there is a PortletUtil class available in the com.ibm.ws.portletcontainer.portlet package, through which you can directly get httpServletRequest, httpServletResponse, ServletContext and many more servlet object you want.

Code to get HttpServletRequest from portletRequest/renderRequest/actionRequest.

HttpServletRequest httpServletRequest = PortletUtils.getHttpServletRequest(renderRequest);

There are couple of utility methods available in PortletUtil which gives you ServletContext, ServletConfig, PortletWindow, PortletApplicationDefinition etc.

How to reset JSF Portlets to initial state

noreply@blogger.com (Unknown) — Sat, 22 Oct 2011 20:26:00 +0530

For a JSF based portlet, if you have a scenario where a user is navigating between screens and that portlet is having 2 or 3 screens, if the user went to 3rd screen and he comes back and clicked on the link it is going to 3rd screen instead of 1st screen.

To render 1st jsp from within portlet,we specify init parameter for first jsp in portlet.xml as follows

<init-param>

<name>com.ibm.faces.portlet.page.view</name>

<value>/jsp/html/view/HelloView.jsp</value>

</init-param>

Now in case, when you want to reset JSF Portlets to its initial view when user comes back, set "com.ibm.faces.portlet.page.view" attributed to session.

portletSession.setAttribute("com.ibm.faces.portlet.page.view", <path of jsp to render>);