Java Stuff

Spring api docs using swagger

2017-11-28T10:37:00.003-08:00

Just want to write a quick post on need for API specifications for your REST services. This is especially important if you are adopting microservices .

How to provide documentation for your api's ? What information is required and how to provide this information that can be easily understood and used by other teams? .

This concept is same as WSDL when using a SOAP service , the interesting thing is when ever we want to consume a soap service immediately WSDL comes to mind . But so far I haven't seen this adoption to REST based service . Industry is moving towards a micro-service model and light weight api's become ubiquitous this becomes a compelling need.

Swagger comes to the rescue in providing specifications for defining the interface to the rest service.
https://en.wikipedia.org/wiki/OpenAPI_Specification. Most important thing is when you use a framework like spring you don't have to understand swagger to the extent of writing them manually . Spring can do that for you .

Here is how you do it

Include swagger library in pom.xml ( version I use in 2.7.0 , you can use the latest )

<groupId>io.springfox</groupId>

<artifactId>springfox-swagger2</artifactId >

</dependency>

Enable swagger Configuration . I am using Swagger 2 , use the version that is accepted with in your organization

@Configuration

@EnableSwagger2

public class SwaggerConfig {

@Bean

public Docket api() {

return new Docket(DocumentationType.SWAGGER_2)

.select()

.apis(RequestHandlerSelectors.any())

.paths(PathSelectors.any())

.build();

}

Now when you start your spring boot application
the api docs are available , it provides all the information for your consumers

http://localhost:8080/v2/api-docs

All these data along with the model objects are now part of my specification . I can share this information with other teams that want to consume my service .

As your application grows and model changes the documentation is automatically reflected with the latest information .

Here is an complete example in github
https://github.com/arun2dot0/simple-rest-service-swagger

Spring Integration file processing using DSL

2017-11-15T12:37:00.002-08:00

Simple Example of File processing using Spring Integration

Here is my use case , watch directory for new file and process files of certain format ( e.g *.txt ) . Process them and send to Message queue .

Spring integration can be used for both file processing and message queue . This blog provides example for watching file folder for changes and invoking a message

Its elegant and straight forward , example here watches directory in a certain directory and then process the files of type text .

https://github.com/arun2dot0/spring-file-process

Note : Example here will get you started , if you need to implement in load balanced environment , the "AcceptOnceFileListFilter" may not be enough , you will need persistent storage and use "FileSystemPersistentAcceptOnceFileListFilter"

Fun with IOT

2017-07-14T14:36:00.000-07:00

Publish -> Analyze -> Utilize

First project that I wanted to try when I looked at GrovePi and the connectors .

Architecture has 3 main components

Edge - Get data temperature , light and humid readings and publish to the server
Data Platform - Consume the data provided by Edge and store . Provide api to get analysis on the data
Client - this can be anything that consumes rest api , mobile app or Alexa ( its fun this way !)

Edge

Raspberry Pi and GrovePi module with the connectors act as the Edge .
Python module continuously reads the readings every minute and pushes
to the server using Rest api .

You need : Raspberry and Grove pi with the Grove Sensors for Temp/Humidity ,light and Sound
Github Link : https://github.com/arun2dot0/APIPython

Data Platform

API interfaces to consume the data from edge and store . Developed using Spring Boot
Data can be stored in any db of your choice based on the analytical needs .
This project I have used Redis to store maximum of
100 values to provide simple analytics ( Average and Latest readings) on that data .
Readings are also exposed as rest api .

You need : Cloud setup ( google cloud or aws ) . I setup my server in google cloud . If you need same setup
details are in the github link
Github Link :https://github.com/arun2dot0/metrics-rest-service-redis.git

Client

Rest API exposed can be consumed by mobile app . Its fun to integrate with Alexa to
get the readings . You will find the details in github link

Alexa : you will need to create aws account and code using aws lambda
Github Link :https://github.com/arun2dot0/AlexaSensorDataNodeJS

It's a fun project and just to get hands on IOT . Edge , Platform and Client
are totally decoupled and can be easily changed for a different use case .
Although it's a simple project it get exposure to variety of technologies
Python , Java , Spring Boot , Redis , Node js and AWS Lambda's

Demo

Did you find it useful , did you try it , hack it , improve it ?
do share in the comments below

IoT hands on using AWS Lamba - Spring Boot - RaspberryPi GrovePi

2017-06-06T15:37:00.003-07:00

Started playing with the GrovePi Starter kit for RaspberryPi.
I chose GrovePi this as there is no complex wiring, have a look at how nicely it fits the Raspberry pi .

I got involved and able to get some sensor data easily using GrovePi Software, checkout
projects in
https://github.com/DexterInd/GrovePi

Here is the tutorial on the first project ..
https://www.dexterindustries.com/GrovePi/projects-for-the-raspberry-pi/raspberry-pi-led-tutorial/

Journey starts ...

After that I did couple of others , like home weather display and twitter feed .
I got excited now I want to do more , I want to do analytics . So was thinking about gathering data from sensors- temperature , humidity , sound and light readings and send it to thecloud for doing analytics . Python was new to me , but want to use it any way as I can learn a new language.It was easy and I wasn't stuck with any thing .It was fun learning as well .
Go Python !

Data Layer

Now I have to push data to a Data layer . Why not use an instance in Google Cloud (they are giving 300$ in free credit!) .Rest API in cloud will be based on Java and Spring Boot .
Data will be stored in redis , as I don't want to store a lot of data . Just last 100 readings
or so and get the current and average readings from the sensors ( this project info is in http://ajaxrocks.blogspot.com/2017/07/fun-with-iot.html ) for this but current integration is only for PubNub

Alexa Skill

While all this was going on , I see Alexa app demos . So I started looking into that
as well . Started building a sample app , using AWS Lambda's .. hey!! ..always want to get my hands on server-less programming as well . Alexa sample app Tutorial used node js .. this is good , I can sharpen my node js skills . Okay I built the sample app .. It was so much fun , the sample app used Facts as an array (that are hardcoded ) . When you invoke it using Alexa , it chooses one of the Fact
randomly . Fun part is you change all the facts and then keep asking facts !! . See programming can be fun

Picture Time ..

Concept is actually the time triggered to take

picture instead of LED blink

Messaging using PubNub

While all this was going on , I learnt about PubNub in DevNetCreate conference
It provides Infrastructure as a Service for doing messaging . they have SDK for almost all the languages I use .Cool , now I can invoke the GroveSensors ( Light on ! ) using PubNub message . Tried it it worked great .. hey .. Next part if you haven't already guessed I can use Alexa to invoke it .. Yeah !

Rewiring to use API

All set now I invoke , node js call to PubNub worked great .Deployed to AWS , now it just doesn't want to work !! Hmmmm... may be I am doing something wrong .. setup security , network interfaces .. still not working .. Don't know what the real reason was .Why waste time on this , let me set this up as a rest api in google cloud and use Alexa skill ( node js) to call that api... hey that can work .... setup the api .. changed the alexa app and everything worked like a charm

Shoutout to Alexa SDK, Google Cloud , PubNub , Raspberry Pi and Grove Pi ... Thanks Guys

Architecture

Learn it ,Use it , Hack it

This project was fun , it also helped understand technologies involved with IOT better .
Learn new languages in a very pragmatic way . I have all the code I used in the github links
, so play with them , hack them for your use case , make them better ..

github links

Code for AWS Lambda ( Node js)
https://github.com/arun2dot0/AlexaNodeJS.git
Code for API ( I setup in google cloud)
https://github.com/arun2dot0/metrics-rest-service-redis.git
Code for Raspberry pi ( Python )
https://github.com/arun2dot0/PubNubPython.git

Simple framework to Test your REST API

2016-09-23T15:06:00.002-07:00

REST api testing made easy .

I am constantly involved in developing backend services for team and
worked on simple framework to test the services. Here is thought behind the framework .

Http Responses Validation

Services provide a response to indicate if the request was successful .
Usual Check is HTTP Status =200 . Also usually part of JSON response is used to validate
eg "status":"OK" . Framework adapts to these conditions and would validate the response for all request . More test can be easily added on top of base validation

Set URL , HTTP Headers once

Base URL and the HTTP Headers to be setup can be setup once
and can be reused for all the tests .

Use Mustache templates to define HTTP Post and Put Payload

payload for POST and PUT are usually JSON and this can be easily setup as templates
This is the one from my example
{
"firstName":"{{firstName}}",
"lastName":"{{lastName}}",
"phone":"{{phone}}",
"email":"{{email}}"
}
Data for the template can be driven from JSON.
Framework converts JSON -> Java Object and Object is used to populate the template .

Example of JSON data to populate the above template
{
"firstName":"Arun",
"lastName":"Selvamami",
"phone":"000-000-000",
"email":"arun2dot0@gmail.com"
}

Easily setup for multiple environments

You can rerun the test for other environments by setting up different data
and changing the Base url

framework is powered by RestAssured , hamcrest and mustache

Check out the code at https://github.com/arun2dot0/TestRest

AngularJS

2015-01-19T12:02:00.002-08:00

AngularJS has been attracting a lot of attention for all the good reasons , this article is to look at angular features and compare it to other frameworks .

Two-Way Binding

Let's look at the best and the dominating factor on why you should look at AngularJS . Its the two way binding . Most Javascript frameworks adapt the Model-View paradigm and the View is rendered from the model when the page is rendered . But what happens after that when the model changes or view gets updates? there are callbacks that the UI developers have to work with to make sure that the View is in sync with the model and the model gets updated with changes in View . But AngularJS provides this capability by default without any callbacks the Two-way binding is provided by default ( for Code - Have a look at the example provided under Directive )

Simple JS

All the code for angular js doesn't require you to understand any new syntax or framework . Its all fully Javascript. So you will already understand most of the code even without knowing angular

Easy to adapt and get Started

Requires simple js include angular.js , angular-animation.js
Example

<html ng-app>

<body>
  <h1>Hello {{1 + 2}}</h1>

<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.2.19/angular.js">
</script>
</body>

</html>

Advantages

Reduce boilerplate

Use default structure that is self explanatory

Easy to test

Directive

Directives are the AngularJS way of dealing with DOM manipulation and providing the two-way binding , they are also responsible for rendering and providing reusable UI widgets. They can be used for simple things like reusing HTML snippets or to more complex things like modifying the behavior of existing elements (like ng-show, ng-class) or integrating with third-party components like charts . Let's look at an example of ng-repeat
Example

<div ng-repeat=‘item in cart.items’>
          <span ng-bind=‘item.name’></span>
          <button ng-click=‘cart.delete($index)’>delete</button>
  </div>
 javascript

 var myApp = angular.module(‘coolApp’,[]);
 myApp.controller(‘CartCtrl’ , function () {
                                              this.items =[{ name:’Choclate’},
                                                                  { name:’bread’},
                                                                   { name:’Cofee’}];
 this.delete = function(index) {
                                              this.items.splice(index,1);
                       };
 });

The delete function just changes the model without any updates to the View, why ? because there is no need to do this , the view is automatically updated based on changes to the model . This is the power of two-way binding

Databinding

Databinding is achieved in javascript by using the double curly brackets - {{}} .

Best way to understand this is by an example

Example

hello.js 
   this.greeting =‘Hello!’;

hello.html 
   {{greeter.greetings}}
   <input ng-model=‘greeter.greetings'>

ng-cloak can be used to avoid unset values on load , can also be done by ng-bind

Controller (ng-controller)

Controller is a specialized Directive ng-controller and does the following

Expose model to View
Expose functions to handle UX
Update model to change the view
Instantiate once per use in templates
Can request $scope

$scope - can be nested , without proper $scope read can be propagated to the nested levels however write is always local to the method . To avoid this use $scope

myapp.Controller(‘GreetCtrl’ , function ( $scope ) {

$scope.greeter = { greeting:’Hi’}

});

$watch(expression,callback ) - executes callback when expression changes

$apply - used when the model changes outside the angular control

Filters

Mainly used for formatting the output and the built in filters for currency and date

Example

custom filters can be added using

myApp.filter( ‘myfilter’ , function() { …});

Server Interaction

basically done by using $http or by $resource (for REST) , there are also other options

Restangular
Angular Fire
Breeze JS

Example

$http.get(‘/someurl’);
$http.get(‘/someurl’).success( function ( data,status,header,config)  { ….})
                                 .error( function ( data,status,header,config)  { ….}).

- specifies where angular is work on the view

$routeProvider for configuration specific to url , following can be configured

Controller
Template
URL
custom values

MongoDB

2015-01-15T12:24:00.003-08:00

Just a few years back all data was usually stored in relational db , like Oracle or MySQL. Application developers had some form of understanding about the database and the tables and using them . Relational Databases supported ACID (Atomicity, Consistency, Isolation, Durability) and were the right choice for some of the applications . The transaction and join capabilities came at a cost of performance and scalability , which couldn't be solved easily without hardware upgrades and admin intervention . NoSQL databases provides a alternative with Replication and scalability features built in , and would provide a lot better alternative for high-traffic , performance oriented systems .Article is to describe features of MongoDB with examples and the limitations

Comparison with Relational DB

Relational DB is normalized and unused columns are left as null's . Table relations are not easily recognizable by just looking at data and usually would require understanding of the table design and the mapping information .

Comparing to Mongo DB , there is no defined schema . Actual data represents the structure and optional values are simply left blank . Flexible design provides easily understanding but there is replication of data when dealing with relations ,this is the tradeoff.

MongoDB can horizontally scale like web servers . De-Normalized focussed on performance vs Join and Best Suited for - caching , event logging and High volume traffic.Scaled for reading and writing using replicated set and Sharding

MongoDB is not ideal for - Transactional applications , ad-hoc business intelligence , problems that require SQL .

Features

MongoDB stores data as documents (BSON) and not rows . Rows are flat vs Documents that has embedded structure with other documents and arrays . Arrays can also have arrays inside

References can be achieved in MongoDB like Relational databases, however its up to the user to maintain the relational reference - Mongo doesn’t support the relational integrity

MapReduce functions are available and are written in JavaScript .

Advantages

Replication and HA capabilities built-in . Its a Considerable advantage when moving to production as the data can scale horizontally
Map reduce and Aggregation framework is built in
GRID FS - can use Mongo as File system . Provides a way to use Mongo just as file system. Effective when the application requires File . Working with Java the document can be accessed by java.io.File ,File can be breaker to chunks . When sharing however chunks cannot be stored in different shard

BSON

Actual data ( Documents ) are stored as BSON ( Binary JSON ) .Driver takes care of transforming JSON >< BSON.

ObjectID

ObjectID - unique id for each document . It can be generated without locking or sequencing and is unique every time irrespective of the number of machines used. uses Time,machine id and process id and sequence for generation of object id . ObjectID is created if not provided during insert .

Index

Mongo uses 3 kinds of indexes

normal using Strings numbers
text based indexing
Geospatial index based on location , very useful for location based searches .Insert has to capture the location based on 2d or 2dsphere and search can be based on

$near around a point
min and max range within 2d space
around a particular area ( circle , box or arbitrary polygon ) using $within

First index from the scan is used for query and other attempts to find the scan are disregarded after the index is found .

Index can be ensured using ensureIndex . query can also use hints ( not a good idea because query analyzer knows best )

Examples

db.collection.find(username:’foo’, city:’New York’}).hint({‘username’:1})

e.g

db.posts.ensureIndex({“comments.author”:1})
db.posts.find({“comments.author”:”eliot”})

Sort on large amount of data without index will result in error

Full table scans - bad - so use indexes

Sparse index

introduced in mongo 2.0 to reduce storage of null fields

downside can’t answer “not in index” queries.

Arrays

Multiple data fields e.g author for books can be represented as an array .

Index on array works on each field ( each array item ) and also the array as a whole . This makes retrieval of data much easier

Search can be powerful as the matching items can be easily searched from one table

$Operators

$in

$or

$set ( for update ) -for array the item that matches can be individually updated e.g {$set:{“author.$.company”:”abc corp”}}

Examples

Example of some of the basic commands used in MongoDB

show dbs
show collections
  system.indexes special collection 
db.scores.findOne()
db.scores.distinct(“name”)
db.scores.count()
db.scores.count({“name”:”exam”})

fields returned can be included  (or) excluded but not both 
db.scores.find({“score”:{$gt:95}}, {“score”,1,_id:0})
sort  can be done by specifying field name and order ( 1 for ascending)  and (-1 for desc )

student ascending
 db.scores.find({“score”:{$gt:95}}, {“score”,1,“student”,1,_id:0}).sort({“student”:1})
student ascending and score descending 
 db.scores.find({“score”:{$gt:95}}, {“score”,1,“student”,1,_id:0}).sort({“student”:1,”score”,-1})

unset example
update all grade - first param {} is for all 
 db.scores.update({},{$unset:{“grade”:1}},false,true)
 
push / pull  ( to push items to array or pull items to array ) 
 add array item
db.books.update({“_id”: ObjectId(“16 digit text”)},
                            {$push:{“tags”:”classic and important”}})

addToSet can be added only once 
db.books.update({“_id”: ObjectId(“16 digit text”)},
                            {$addToSet:{“tags”:”classic and important”}})

 delete array item
db.books.update({“_id”: ObjectId(“16 digit text”)},
                            {$pull:{“tags”:”classic and important”}})

pullAll pushAll for multiple items

$inc - increment a field by a given value 
mongo figures out the increment value - takes away issue of atomicity that may be required to be done with web server

Deployment

RAM - frequently used data is stored in Ram for faster retrieval . Disk access is 100 times more slower than RAM .

Deployment trick - fetch required data forcibly using query to have the data available in RAM for the users

Production should be 64 bit as 32 bit supports only 2gb limit

Mongo will pre allocate data so file systems matter - posix_fallocate() on linux system works fine with just marking start and end on memory map

reading data from memory will have padding to allow changes in data to be written to disk .

toString on any mongo data has the JSON information , this is very useful for debugging

Driver's and working with applications

Native driver - How to

uses DBObject - Map interface with key value pair - Key -> “string” and Value -> Object of Mongo Data

ODM - Object Document mapping

Morphia - Like JPA , Annotation Driven and Written for Mongo so it’s customized for Mongo

Spring-Data-Document - less strongly coupled as its used for all NoSQL databases , recommended for Spring veterans

Mongo has support for Hadoop and hadoop components - Pig , Hive

Capped Collection

designed for replication , No id , No Deletes , maintained in serration order , Updates only for it won’t grow above padding

Tailable Cursors

like tail -f in unix , efficient , “Await” cursor can pull data until more documents arrive to the particular query

findAndModify - can use in specialized scenario where changed information is required back from Mongo

Sharding and Replication

Scaling is not just about adding servers it has the following components

Operations/Sec

Storage needs go up - Capacity and IOPs

Complexity goes up

Optimization and tuning is based of 

Schema and Index Design

O/S Tuning

Hardware

Vertical Scaling - Expensive and may be impossible when dealing with certain cloud based systems

Scaling can be done by 

Schema & Index Design

Sharding

Replication

Schema 

Use Embedded vs linking , facts to consider

Round trip to DB
Disk seek time
size of data to R/W

Use Partition vs full document writes ( $set uses partial write )

Use Partial vs full document read

 Index 

Mongo can use only one index at a time for a query

Index common query , but do not over index . (A) and (A,B) are equivalent

Right-balanced index

Sharding

Automatic partitioning and management

Range based

Convert to sharded system with no downtime

Fully consistent

e.g of adding shard based on age

 db.runCommand({ addshard:”shard1”});

 db.runCommand({ ShardCollection:”mydb.blogs”, key:{age:1}})

ranges are stored as chunks

chunks are created automatically 

shard’s can be added as many as required using 

 db.runCommand({ addshard:”shard2”});

shard can also be removed

Shard has no downtime and automatic balancing as data is written

Insert must have shard key

Update must have shard key

Query with Shard key routed to the right node

  - no Shard key scattered and gathered

Indexed query 

   - with shard key rated in order

   - without shard key is distributed sort and merge

Replication

Replica set is not Master/Slave as in master/slave a new master has to be switched  if the master is down

Replica Set works as

cluster of N Servers
Any(one) can be primary
Automatic failover, recovery
All writes to Primary
Read can be to Primary(default) or Secondary
There has to be at least 2 or More replica set so that Primary can be elected
if Primary fails then negotiation happens for the new Primary 

Node can be 

  Normal ( priority:1}  or Passive { priority:0 }  - cannot become primary 

  Can also be Arbiter - can vote but cannot hold any data 

  Can be hidden { hidden:true }

  Can allow tags ( after 2.0 version ) e.g tags { “dc”:”ny”, “rack” :”123”}

slaveOk()

   -driver sends read request to the secondary 

   -write always happens to primary 

Java - 

    DB.slaveOk() or Collection.slaveOk()

Read are consistent in Primary

Read for secondary are eventually consistent

Java8

2014-12-16T15:02:00.002-08:00

Lambda's and Functional Interfaces

Java 8 is a major improvement and has rich set of features since Java5 . Main draw back with java language was it lacked functional style of programming . Java8 Fixed this , following set of examples to lambda's and other features introduced in java8 .

Lambda expressions are basically anonymous methods , Java can now do functional composition in addition to object composition .

Example of Imperative style

public static void printArray(List arrtoprint)
{
for( int i =0; i< arrtoprint.size(); i++)
{
System.out.println(arrtoprint.get(i));
}
}

public static void printArrayJava5(List arrtoprint)
{
for( String s:arrtoprint)
{
System.out.println(s);
}
}

both use external iterators , and boundary conditions , algorithm of looping are all controlled by the code.

Example of Declarative ( functional) Style

Implementation uses internal iterators

public static void printArrayJava8(List arrtoprint)
{
arrtoprint.forEach(System.out::println);
}
lot of things inferred in the above implementation

Descriptive syntax to show print element for each string element in arraylist

arrtoprint.forEach((String e)->System.out.println(e));

Can be shortened to this format , print the element in the arraylist
arrtoprint.forEach(System.out.println(e));

Can be further shortened to this .There is only one element to print , so not even have to mention that

arrtoprint.forEach(System.out::println);

Why this is better

Declarative style , values go through mutation - constantly changed

Imperative Style , No mutation - can be parallelized easily

Remove the mechanics - e.g looping can be sequential , or be concurrent or lazy

Implementation done through java interface Consumer

values.forEach( new Consumer() {

public accept(Interger value)

{

System.out.println(value);

}

});

Example with return

Functional style can also be used with methods that have a return , example for sorting the implementation would be

arrtosort.sort((e1,e2)-> e1.compareTo(e2));

return is not required when there is only one variable to be returned . Descriptive syntax for this would be

arrtosort..sort( ( e1, e2 ) -> {
int result = e1.compareTo( e2 );
return result;
} );

Example using stream

Java 8 provides a new API (called Streams) that supports many parallel operations to process data and resembles the way you might think in database query languages—you express what you want in a higher-level manner, and the implementation (here the Streams library) chooses the best low-level execution mechanism. As a result, it avoids the need for you to write code that uses synchronized, which is not only highly error prone but is also more expensive than you may realize on multicore CPUs.Here is an example to filter out only even numbers from a arraylist of integers and print them

public static void printEvenFunctional(List intArr)

{

intArr.stream().filter(e->e%2!=0).forEach(System.out::println);

}

This makes use of the Predicate interface java.util.function.Predicate .

Descriptive syntax would be

public static void printEvenFunctionalDescriptive(List intArr)

{

intArr.stream().filter(

new CheckInt()

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

}

CheckInt class would be

class CheckInt implements Predicate

{

public boolean test(Integer i)

{

return i%2==0 ;

}

Stream api allows code to be written that is

Declarative— More concise and readable
Composable— Greater flexibility
Parallelizable— Better performance

parallelStream

above example uses sequential stream , it can be changed to parallelStream by just changing

intArr.stream()
to
intArr.parallelStream()

Optional

Java8 introduces new class java.util.Optional . Its the idea inspired from Scala and Haskell and it attempts to solve the problem

public class Person{

Optional phone ;

public Optional getCellphone()

{

return phone;

}

ifPresent / orElse

price = phone.orElse( defaultPhone ).getPrice();

phone.ifPresent( p -> System.out.println("Phone is present for person") );

can also be applied on streams as shown below

employee.stream()
.filter(Employee::isRelocated)
.findAny()
.ifPresent( e -> System.out.println(e.getName() );

Google App Engine Maven setup

2013-11-15T23:55:00.002-08:00

Maven Setup for Google App Engine

Playing with Google App Engine to setup simple Spring application .It's simple to setup simple Servlet application through Eclipse plugin but I don't want to maintain dependency in eclipse , got to have Maven . It's little tricky to setup , so here is the info .

Download AppEngine ( Not just the Eclipse plugin for gae )
Setup Maven master password and google password as encrypted value
pom.xml

Password Setup

Setup the master password and the google password .Details for setting up password explained here

http://maven.apache.org/guides/mini/guide-encryption.html#How_to_create_a_master_password.

Your settings-security.xml and settings.xml has to be updated . Provided mine below for reference

settings-security.xml

<settingsSecurity>
 <master>encryptedvaluehere</master>
</settingsSecurity>

Settings.xml

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
                      http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <localRepository/>
  <interactiveMode/>
  <usePluginRegistry/>
  <offline/>
  <pluginGroups/>
  <servers>
      <server>
            <id>appengine.google.com</id>
            <username>emailhere</username>
            <password>encryptedvaluehere</password>
        </server>
  </servers>
  <mirrors/>
  <proxies/>
  <profiles/>
  <activeProfiles/>
</settings>

pom.xml

Specify the Google App Engine home in gae.home tag.
Enter the group and artifact id
mvn gae:deploy will deploy the application to the app engine

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>
    <packaging>war</packaging>
    <version>1.0</version>
  
    
    <groupId>entergroupid</groupId>
    <artifactId>enterartifactid</artifactId>

   <pluginRepositories>
        <pluginRepository>
            <id>maven-gae-plugin-repo</id>
            <name>Maven Google App Engine Repository</name>
            <url>http://maven-gae-plugin.googlecode.com/svn/repository/</url>
        </pluginRepository>
        <pluginRepository>
            <id>google-staging</id>
            <name>Google Staging</name>
            <url>https://oss.sonatype.org/content/repositories/comgoogleappengine-1004/</url>
        </pluginRepository>
    </pluginRepositories>

 <repositories>
        <repository>
            <id>google-maven-repo</id>
            <name>Maven Google App Engine Repository</name>
            <url>http://maven-gae-plugin.googlecode.com/svn/repository/</url>
        </repository>
        <repository>
            <id>codehaus</id>
            <name>codehaus</name>
            <url>http://repository.codehaus.org/org/codehaus/groovy/</url>
        </repository>
  <repository>
   <id>repository.springsource.release</id>
   <name>SpringSource GA Repository</name>
   <url>http://repo.springsource.org/release</url>
  </repository>
 </repositories>
    

    <properties>
        <appengine.app.version>1</appengine.app.version>
        <appengine.target.version>1.8.6</appengine.target.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring-framework.version>3.1.2.RELEASE</spring-framework.version>
     <spring-integration.version>2.1.3.RELEASE</spring-integration.version>
     <spring-ws.version>2.1.0.RELEASE</spring-ws.version><!--2.1.0.RELEASE-->
     <spring-security-version>3.1.2.RELEASE</spring-security-version>
     <enunciate.version>1.27</enunciate.version>
     <gae.version>1.8.6</gae.version>
    <gae.port>9090</gae.port>
    <net.kindleit.version>0.9.6-SNAPSHOT</net.kindleit.version>
       <gae.home>/Library/appengine/appengine-java-sdk-${gae.version}</gae.home>
     <webappDirectory>${project.build.directory}/${project.build.finalName}</webappDirectory>
    
    </properties>

    <dependencies>
        <!-- Compile/runtime dependencies -->
        <dependency>
            <groupId>com.google.appengine</groupId>
            <artifactId>appengine-api-1.0-sdk</artifactId>
            <version>${appengine.target.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        
             <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring-framework.version}</version>
    </dependency>
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring-framework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring-framework.version}</version>
    </dependency>
        
     <dependency>
         <groupId>org.codehaus.enunciate</groupId>
         <artifactId>enunciate-rt</artifactId>
         <version>${enunciate.version}</version>
      </dependency>

        <!-- Test Dependencies -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-all</artifactId>
            <version>1.9.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.google.appengine</groupId>
            <artifactId>appengine-testing</artifactId>
            <version>${appengine.target.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.google.appengine</groupId>
            <artifactId>appengine-api-stubs</artifactId>
            <version>${appengine.target.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
      
    <build>
         <sourceDirectory>src</sourceDirectory>
          <resources>
        <resource>
          <directory>src/resources</directory>
        </resource>
      </resources>   
         <outputDirectory>target/${project.artifactId}-${project.version}/WEB-INF/classes</outputDirectory> 
                          
        <plugins>
           <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.1</version>
         <configuration>
            <source>1.6</source>
            <target>1.6</target>
          </configuration> 
        </plugin> 
        
             <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.4</version>
                <configuration>
                    <webResources>
              <resource>
                <directory>src/resources</directory>
              </resource>
            </webResources>
                </configuration>
            </plugin> 
 
             <plugin>
                <groupId>com.google.appengine</groupId>
                <artifactId>appengine-maven-plugin</artifactId>
                <version>${gae.version}</version>
                <configuration>
                   <fullScanSeconds>1</fullScanSeconds>
                   <server>preview.appengine.google.com</server>
                </configuration>
            </plugin> 
            
         
         
             <plugin>
                <groupId>net.kindleit</groupId>
                <artifactId>maven-gae-plugin</artifactId>
                <version>0.9.2</version>
                <configuration>
                    <unpackVersion>${gae.version}</unpackVersion>
                    <serverId>appengine.google.com</serverId>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>net.kindleit</groupId>
                        <artifactId>gae-runtime</artifactId>
                        <version>${gae.version}</version>
                        <type>pom</type>
                    </dependency>
                </dependencies>
            </plugin>
            
               <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-release-plugin</artifactId>
                <version>2.2.2</version>
                <configuration>
                    <goals>gae:deploy</goals>
                </configuration>
            </plugin>
         
            
        </plugins>
    </build>

    
  
</project>

Spring Integration - Calling SOAP Service using Gateway , Channel and Chain

2013-11-12T14:33:00.000-08:00

WebService using Spring Integration

Article to show WebService call ( SOAP ) using Spring Integration . It uses Gateway , Channel and Router

What you will need

1. Schema or WSDL to generate the Marshaller and UnMarshaller Objects .

2. Java Interface to Call WebService

3. Bean configuration defining gateway , channel , router etc

4. Java Transformer

Refer to the example in github
https://github.com/arun2dot0/spring-integration-consumer

Generation of Marshaller and UnMarshaller

Marshaller and a UnMarshaller are basically Java representation of the Request and Response , these can be generated by xjc utility on schema (or) wsimport on WSDL. If you don't have the schema , it can be generated by the xml using many tools like http://www.freeformatter.com/ Here is example of generating them from schema using ant ( uses xjc )

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

<project name = "mywsproject" 
        default = "generate">
 <property file = "build.properties"/>
 
  <fileset id = "tools" 
           dir = "tools">
    <include name = "**/*.jar"/>
  </fileset> 
 
 <taskdef name = "xjc" classname = "com.sun.tools.xjc.XJCTask">
   <classpath>
     <fileset refid = "tools"/>
   </classpath>
 </taskdef>
 
 <target name = "generate">
  <xjc schema = "src/main/xml/country.xsd" 
      destdir = "src/main/java" 
      package = "com.my.services.model"/>
 </target> 
</project>

WSDL will have the schema and "wsimport" utility will generate the Classes for Marshaling and Un-Marshaling ( details of the wsimport utility can be found here http://ajaxrocks.blogspot.com/2013/08/jax-ws-call-ws-using-maven.html) . If you are generating using the WSDL there will be the WebService and PortType classes , delete them after generation .

Java Interface to Call WebService

Interface to call the webservice , it uses the generated classes . My case the class is GetCountryRequest and GetCountryResponse

package com.my.services.api;
import javax.xml.bind.annotation.XmlElement;
import io.spring.guides.gs_producing_web_service.GetCountryRequest;
import io.spring.guides.gs_producing_web_service.GetCountryResponse;
public interface MyService {
GetCountryResponse  countryRequest(GetCountryRequest request);
}

Stuff to Configure ( full xml shown below )

Gateway

Specify's the interface and map the method to the header

<int:gateway id="myService" service-interface="com.my.services.api.MyService"
  default-request-channel="myService_routingChannel">
  <int:method name="countryRequest">
   <int:header name="REQUEST_TYPE" value="countryRequest" />
  </int:method>
 </int:gateway>

Publish-Subscribe Channel

Specify the Channel to map this way we can map the header value to the channel

<int:publish-subscribe-channel id="myService_routingChannel" />

Header-Value Router

Route the call based on the header value to the chain

 <int:header-value-router input-channel="myService_routingChannel" header-name="REQUEST_TYPE">
  <int:mapping value="countryRequest" channel="myService_countryRequestChannel" />
 </int:header-value-router>
 
 <int:channel id="myService_countryRequestChannel" />

Chain

Service-Activation - transformer and the method to be called in the java class
Soap-Action ( ws:header-enricher ) - soap-action to be called ( you will find this in the wsdl ). Example this one is commented out as soap-action is empty . You need to provide this otherwise
outbound-gateway - WebService end point with message-sender and unmarshaller

 <int:chain input-channel="myService_countryRequestChannel"
output-channel="myService_countryRequestOutputChannel" >
 
  <int:service-activator ref="MyWSTransformer"
   method="countryRequestSOAPRequest" />
 
  <!--  <ws:header-enricher>
   <ws:soap-action value="" />
  </ws:header-enricher> -->
 
  <ws:outbound-gateway
   uri="http://localhost:8080/ws"
   message-sender="MY.SOAP-MessageSender"  unmarshaller="myrequestJAXBUnMarshaller"/>
 </int:chain>

Outbound gateway

Configure the outbound gateway

  <ws:outbound-gateway

   uri="${my.purchase.url}"

   message-sender="MY.SOAP-MessageSender"  unmarshaller="mypurchaseJAXBUnMarshaller"/>

 </int:chain>

Authentication can also be added using

 <beans:bean id = "org.apache.commons.httpclient.Credentials-Service"
               class = "org.apache.commons.httpclient.UsernamePasswordCredentials"
               c:userName = "${userName}"
               c:password = "${password}"/>

and specify the ref as credentials-ref in the ws:outbound-gateway

Full XML

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

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans  xmlns:int="http://www.springframework.org/schema/integration"
 xmlns:http="http://www.springframework.org/schema/integration/http"
 xmlns:ws="http://www.springframework.org/schema/integration/ws"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xmlns:beans="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:si-xml="http://www.springframework.org/schema/integration/xml"
  xmlns:oxm = "http://www.springframework.org/schema/oxm"
 xsi:schemaLocation="
  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
  http://www.springframework.org/schema/integration/http http://www.springframework.org/schema/integration/http/spring-integration-http.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/integration/ws http://www.springframework.org/schema/integration/ws/spring-integration-ws.xsd
     http://www.springframework.org/schema/integration/xml http://www.springframework.org/schema/integration/xml/spring-integration-xml.xsd
     http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm.xsd">
 

<!-- <beans:bean id="myManager"
     class="com.my.services.manager.MyServiceImpl" >
    <beans:property name="myService" ref="myService" />
 </beans:bean>
  -->
  <beans:bean id="MyWSTransformer"
     class="com.my.services.transformer.MyWSTransformer" />
 
 <beans:bean id="MY.SOAP-MessageSender"
  class="org.springframework.ws.transport.http.HttpComponentsMessageSender">
  <beans:property name="connectionTimeout" value="3000" />
  <beans:property name="readTimeout" value="5000" />
 </beans:bean>
 
  <int:publish-subscribe-channel id="myService_routingChannel" />
  
 <int:gateway id="myService" service-interface="com.my.services.api.MyService"
  default-request-channel="myService_routingChannel">
  <int:method name="countryRequest">
   <int:header name="REQUEST_TYPE" value="countryRequest" />
  </int:method>
 </int:gateway>
  
 <int:header-value-router input-channel="myService_routingChannel" header-name="REQUEST_TYPE">
  <int:mapping value="countryRequest" channel="myService_countryRequestChannel" />
 </int:header-value-router>
 
 <int:channel id="myService_countryRequestChannel" />
 
 <int:chain input-channel="myService_countryRequestChannel"
output-channel="myService_countryRequestOutputChannel" >
 
  <int:service-activator ref="MyWSTransformer"
   method="countryRequestSOAPRequest" />
 
  <!--  <ws:header-enricher>
   <ws:soap-action value="" />
  </ws:header-enricher> -->
 
  <ws:outbound-gateway
   uri="http://localhost:8080/ws"
   message-sender="MY.SOAP-MessageSender"  unmarshaller="myrequestJAXBUnMarshaller"/>
 </int:chain>
 
 
   <si-xml:unmarshalling-transformer id="countryRequestUnmarshaller"
  input-channel="myService_countryRequestOutputChannel"
  unmarshaller="myrequestJAXBUnMarshaller" />
 
   <oxm:jaxb2-marshaller id = "myrequestJAXBUnMarshaller">
    <oxm:class-to-be-bound name = "io.spring.guides.gs_producing_web_service.GetCountryResponse"/>
   <oxm:class-to-be-bound name = "io.spring.guides.gs_producing_web_service.Country"/>
   <oxm:class-to-be-bound name = "io.spring.guides.gs_producing_web_service.Currency"/>
  <!--   <oxm:class-to-be-bound name = "io.spring.guides.gs_producing_web_service.GetCountryRequest"/> -->
  
 </oxm:jaxb2-marshaller>  
 
 
</beans:beans>

Java Transformer

Transformer has the method that makes the SOAP Request call , its clear if you look at the requestXML string.
GetCountryRequest is already marshaled and available as a input parameter .

package com.my.services.transformer;



import java.text.SimpleDateFormat;
 
import java.util.Calendar;
 

import org.slf4j.Logger;
 
import org.slf4j.LoggerFactory;
 
import org.springframework.integration.annotation.Header;
import org.springframework.stereotype.Component;

import io.spring.guides.gs_producing_web_service.GetCountryRequest;
 
 
@Component
public class MyWSTransformer {
 
 static private final Logger logger = LoggerFactory.getLogger(MyWSTransformer.class);
 
 public static String countryRequestSOAPRequest(GetCountryRequest request)
 
 {
 
 logger.info("Calling MyWSTransformer with GetCountryRequest " +request.getName());
  String requestXml =" <gs:getCountryRequest xmlns:gs=\"http://spring.io/guides/gs-producing-web-service\">"+
         "  <gs:name>"+request.getName()+"</gs:name> "+
      " </gs:getCountryRequest>";
    
  return requestXml; 
 
 }
 
}

jBPM process after workflow node using ActionHandler

2013-10-24T15:30:00.002-07:00

jBPM process after workflow node using ActionHandler

Simple article to show how to do processing after each workflow node and also send values from workflow to ActionHandler

<node name="Process Node">
  <action class="org.jboss.soa.esb.services.jbpm.actionhandlers.EsbActionHandler">
   <esbCategoryName>
    ESB_PROCESSOR_QUOTE
   </esbCategoryName>
  </action>
  <event type="node-leave">
                    <action class="event.CustomNodeComplete">
                              <actionName>Quote Successful</actionName>
                     </action>
         </event>
  <transition to="Complete"></transition>
 </node>

Workflow ProcessDefinition

actionName is passed to the ActionHandler and execute method will be called if workflow node completes successfully

ActionHandler

public class  CustomNodeComplete implements ActionHandler {


 private static final long serialVersionUID = -6446921306976005512L;
 String actionName;
 
 
 @Override
 public void execute(ExecutionContext execContext) throws Exception {

     //actionName  from workflow available

     // send notification
 }

jBPM Node for Decision using ActionHandler

2013-10-22T18:17:00.000-07:00

jBPM use non-decision node to choose workflow path

You can use the decision node to choose one of the workflow path . This is to show a workaround if you have constrains using the decision node. Shown below simple workflow and can either branch to "Yes" path or "No" path based on the decision by Node - ValidQuote

Process Definition

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

<process-definition  xmlns=""  name="Quote Process">


 <start-state name="Start">
  <transition to="Process Quote"></transition>
 </start-state>



 <node name="Process Quote">
  <action class="org.jboss.soa.esb.services.jbpm.actionhandlers.EsbActionHandler">
   <esbServiceName>
    ProcessQuote
   </esbServiceName>
   <esbCategoryName>
    ESB_PROCESS_QUOTE
   </esbCategoryName>
  </action>
  <transition to="ValidQuote"></transition>
 </node>

 <node name="ValidQuote">
  <action name="ValidQuote" class="event.ValidQuote"></action>
  <transition to="Log-NotifyCSR" name="No"></transition>
  <transition to="EmailCustomer" name="Yes"></transition>
 </node>

 <node name="EmailCustomer">
  <action class="org.jboss.soa.esb.services.jbpm.actionhandlers.EsbActionHandler">
   <esbCategoryName>
    ESB_EMAIL
   </esbCategoryName>
  </action>
  <transition to="Complete"></transition>
 </node>

 <node name="Log-NotifyCSR">
  <action class="org.jboss.soa.esb.services.jbpm.actionhandlers.EsbActionHandler">
   <esbCategoryName>
    ESB_CSR
   </esbCategoryName>
  </action>
  <transition to="Complete"></transition>
 </node>

 <end-state name="Complete"></end-state>


</process-definition>

Action Handler ( defined in the ValidQuote)

package event;
import org.jbpm.graph.exe.ExecutionContext;

public class  ValidQuote implements ActionHandler {

 @Override
 public void execute(ExecutionContext execContext) throws Exception {

 if( somecondition...)
  execContext.leaveNode("Yes");
 else
  execContext.leaveNode("No");
 }

}

SOAP UI Dynamic mock service using Groovy Script

2013-10-16T15:14:00.001-07:00

SOAP UI Dynamic mock service using Groovy Script

Create dynamic mock service using SOAP UI . You will just need the WSDL . You should be familiar using the soap ui and creating the mock service . Following is to only make it dynamic

Create a SoapUI project using the WSDL . Right click and select the mock service .
Select the WebService Method and Open the Response that has to be customized
Create two files for Success and Error response and place them in folder {Project-Path}/responses
WebService Response ( Right portion of the Soap UI Window )will be made dynamic based on request. Delete everything from mock response and replace with${content} . This value will be dynamically rendered from groovy script
Choose Dispatch -> Script , and then choose Dynamic Reponse
Use the groovy script below , to render Success and Error Responses .

It works in the following way ,

if quotenumber is 9999 - send Error response
anything else - send Success Response

Now you can create more test cases and test them by changing the input in the xml . Providing the input , output and the script below

Input ( for ref )

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:test="http://www.testing.com/WS/quoteWS">

  <soapenv:Header/>

  <soapenv:Body>

     <test:Quote>

        <QuoteRequest>

           <quoteNumber>9999</quoteNumber>

           <quoteTitle>?</quoteTitle>

           <quotePrice>?</quotePrice>

        </QuoteRequest>

     </test:Quote>

  </soapenv:Body>

</soapenv:Envelope>'

Output

Success

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:test="http://www.testing.com/WS/quoteWS">

  <soapenv:Header/>

  <soapenv:Body>

     <test:QuoteResponse>

        <QuoteReply>

           <status>Success</status>

           <!--Optional:-->

           <errorCode>0</errorCode>

           <!--Optional:-->

           <errorMessage></errorMessage>

           <!--Optional:-->

           <errorDetail></errorDetail>

        </QuoteReply>

     </test:QuoteResponse>

  </soapenv:Body>

</soapenv:Envelope>

Error

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:test="http://www.testing.com/WS/quoteWS">

  <soapenv:Header/>

  <soapenv:Body>

     <test:QuoteResponse>

        <QuoteReply>

           <status>ERROR</status>

           <!--Optional:-->

           <errorCode>11</errorCode>

           <!--Optional:-->

           <errorMessage>Failed</errorMessage>

           <!--Optional:-->

           <errorDetail>Something failed </errorDetail>

        </QuoteReply>

     </test:QuoteResponse>

  </soapenv:Body>

</soapenv:Envelope>

Groovy Script

import com.eviware.soapui.support.GroovyUtils

import groovy.xml.XmlUtil

log.info 'start'

def groovyUtils = new GroovyUtils(context)

def xmlParser = new XmlParser()

def responseContent

def requestXmlHolder = groovyUtils.getXmlHolder(mockRequest.getRequestContent())

requestXmlHolder.declareNamespace("test","http://www.testing.com/WS/quoteWS")

def quoteNumber = requestXmlHolder.getNodeValue("//test:Quote/QuoteRequest[1]/quoteNumber[1]")

log.info  quoteNumber



if(quoteNumber == '9999')

{

responseContent = xmlParser.parse(groovyUtils.projectPath +"/responses/error-response.xml")


}

else

{

responseContent = xmlParser.parse(groovyUtils.projectPath +"/responses/success-response.xml")

}

context.content = XmlUtil.serialize(responseContent)

log.info 'complete'

Spring Webservice using WebServiceTemplate

2013-10-09T16:31:00.001-07:00

WebServiceTemplate

Here is the bean

 <bean id="wsTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">
                <property name="defaultUri" value="http://localhost:8080/quote_test"/>
                <property name="marshaller" ref="QuoteRequestJAXBMarshaller"/>                 
                <property name="unmarshaller" ref="QuoteResponseJAXBMarshaller"/>
        </bean>

You will need Marshaller and Unmarshaller , its part of oxm
include these in the header

  xmlns:oxm = "http://www.springframework.org/schema/oxm"

setup the marshaller and unmarshaller

  
<oxm:jaxb2-marshaller id = "QuoteRequestJAXBMarshaller">
    <oxm:class-to-be-bound name = "com.quote.services.model.Quote"/>
  </oxm:jaxb2-marshaller>  
  
  <oxm:jaxb2-marshaller id = "QuoteResponseJAXBMarshaller">
    <oxm:class-to-be-bound name = "com.quote.services.model.QuoteResponse"/>
  </oxm:jaxb2-marshaller>

Marshaller and a UnMarshaller can be generated by xjc utility on schema (or) wsimport on WSDL. If you don't have the schema , it can be generated by the xml using many tools like http://www.freeformatter.com/ Here is example of xjc using ant

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

<project name = "mywsproject" 
        default = "generate">
 <property file = "build.properties"/>
 
  <fileset id = "tools" 
           dir = "tools">
    <include name = "**/*.jar"/>
  </fileset> 
 
 <taskdef name = "xjc" classname = "com.sun.tools.xjc.XJCTask">
   <classpath>
     <fileset refid = "tools"/>
   </classpath>
 </taskdef>
 
 <target name = "generate">
  <xjc schema = "src/main/xml/quote.xsd" 
      destdir = "src/main/java" 
      package = "com.quote.services.model"/>
 </target> 
</project>

WSDL will have the schema and "wsimport" utility will generate the Classes for Marshaling and Un-Marshaling ( details of the wsimport utility can be found here http://ajaxrocks.blogspot.com/2013/08/jax-ws-call-ws-using-maven.html) ,after generation delete the webservice and webservice port type classes .

No matter which way you use for generating the classes , you have to review and look for JAXBElement. Basically if jaxb-api can't find the type of the element , it will generate as JAXBElement , so your response instead of a "QuoteResponse" will be JAXBElement< QuoteResponse > . It can be fixed by commenting the create method in the ObjectFactory class

 
//   @XmlElementDecl(namespace = "http://www.test.com/WS/QuoteWS", name = "QuoteResponse")
//   public JAXBElement<QuoteResponse> createQuoteResponse(QuoteResponse value) {
//       return new JAXBElement<QuoteResponse>( , QuoteResponse.class, null, value);
//   
}

This also can happen with the attributes . Example below "errorMessage" is string but not defined correctly in the schema so it become a JAXBElement . Comment these out and create them as String , generate getters and Setters

 

//   @XmlElementRef(name = "errorMessage", type = JAXBElement.class)
//    protected JAXBElement<String> errorMessage;

Calling from Java Service , is now easy as calling a method and getting a response

@Service("myQuoteService")
public class QuoteServiceImpl {
    @Autowired
    private WebServiceOperations wsTemplate;
    
    
    public QuoteResponse generateQuote()
    {
     Quote quote = new Quote();
     quote.setPrice("99.99");
     quote.setAmount("100");
     
     QuoteRequest quoterequest = new QuoteRequest();
     quoterequest.setQuote(quote);
     
     return  (QuoteResponse)wsTemplate.marshalSendAndReceive(quoterequest);
     
    }
}

Spring Webservice using JAXWS and JaxWsPortProxyFactoryBean

2013-10-08T21:43:00.002-07:00

Calling WebService using JaxWsPortProxyFactoryBean

This is probably the easiest way to call the webservice . Generate the necessary classes for the webservice by using the "wsimport" utility ( have a look at http://ajaxrocks.blogspot.com/2013/08/jax-ws-call-ws-using-maven.html) . Then you can configure the bean to use the generated classes as shown

<bean  id="myWebservice" class="org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean">
            <property name="serviceInterface" value="com.myws.proxy.MyTestWebService" />
            <property name="wsdlDocumentUrl" value="wsdl/mytest-service.wsdl" />
            <property name="namespaceUri" value="http://mycompany.com/myservice" />
            <property name="serviceName" value="MyTestService" />
            <property name="endpointAddress" value="http://www.test.com/webservices/mytest-service?wsdl" />
            <property name="username" value="username"/>  
            <property name="password" value="password"/>  
        </bean>

Use username and password if required otherwise it can be removed . Just wire this bean to your class and call the webservice

JaxWsPortProxyFactoryBean is part of spring-web utility ,You have to include the following in your pom.xml

   <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-web</artifactId>
         <version>3.2.3.RELEASE</version>
       </dependency>

Garbage Collection Mechanisms and Collectors

2013-10-03T06:52:00.004-07:00

Why is Garbage Collecition desirable ?

GC - Programmer not responsible for freeing objects
Eliminates areas of instability , delay and maintenance

No GC - "memory management contract"
Uncoordinated libraries, frameworks , utilities

GC is efficient for allocating and freeing memory
% of CPU can be tuned for GC
Dead Objects cost nothing to collect
GC will find all dead objects ( don't worry about complexity )

Rate 1 sec per live GB - most JVM
General Usage Heap Size use - 1 -4GB

Improve Garbage Collection

Architecture
Object Pooling
Off heap storage
Distributed heaps

Types of Garbage Collection

Concurrent Collector - runs with your application
Parallel Collector - more than 1 thread to do GC
Stop-the-World - GC when application is stopped
Incremental - performs as small discrete operations
Mostly - mix of GC techniques

Precise vs Conservative Collector
Conservative - unaware of object references
Precise - fully identify object references at time collector needs to run
( required for moving objects )

Commercial all Garbage Collectors are Precise

Safepoint

GC Safepoint - point or rage in thread execution where the collector can identify all the
thread's execution stack
- Bring a thread to safe point , to reach a safe point but not to stop
Global Safepoint - all threads are at safe point - need of Stop-the-World

Precise

Identify live objects
Reclaim resources by dead objects
Periodically relocate live objects

Mechanisms

Mark/Sweep/Compact - Old Generation

Mark - start from "roots" and paint anything reachable as "live" , anything not reachable is dead
Sweep - identify "dead" objects and put in free list
Compact - contiguous dead space between objects may become too large ( similar to "swiss cheesed")
1. move live objects to get contiguous empty space -"relocate"
2. Correct all object references -"remap"

requires 2x only the full GC has to be run , can be stopped and restarted
Its not Monolithic .
Linear to heap size

Copying Collectors

Copy Collectors - move from space a to b , copy happens by "root"reference and copies reachable objects.Monolithic - Start can't be stopped . Copy requires 2x memory .
Linear to live-set

Generational Collection

  - Weak generational hypothesis -"most objects die young"
Focus collection efforts
  - use moving collector : work is linear to the live set
  - live set in the young generation is a small % of space
  - Promote objects that live long enough to older generations

Moving collector for recent objects , and use Mark sweep for old objects - Efficient and works for most objects

- Required "Remembered set" - say to track all references into the young generation
basically multiple roots for different collectors . Move surviving objects to old generation

"Remembered set" needs memory for execution

"Card Marking"-  bit to generate oldGen is a suspect

Empty memory == CPU power

Concurrent Marking - may take a while and you may be left with no free memory
Incremental Compaction

HotSpot  - ParallelGC  ( Default Collector )

Monolithic STW copy NewGen
Monolithic STW Mark/Sweep/Compact OldGen

HotSpot - CocMarkSweepGC ( aka CMS )

Monolithic STW copy NewGen ( ParNew )
Mostly Concurrent , non-Compacting OldGen
Fallback to Full Collection ( Monolithic STW )

HotSpot G1GC ( aka "Garbage First")

Monolithic STW copying NewGen
Mostly Concurrent,OldGen marker

STW mostly incremental compacting olden
Fallback to Full Collections

When there is a "Application Memory Wall" phenomenon its important to look at GC and Tuning

JSON String to Object transformer

2013-10-02T16:10:00.002-07:00

Consider you have a Simple Json with two values ( lable and value ) to read and these have to map to the POJO Class - ContentType .

JSON Data

[

    {
        "label": "Movies",
        "value": "movie"
    },
    {
        "label": "TV Shows",
        "value": "tvshow"
    }

]

POJO

public class ContentType {
 
 
 private String label;
 private String value;

 public String getLabel() {
  return label;
 }
 public void setLabel(String label) {
  this.label = label;
 }
 public String getValue() {
  return value;
 }
 public void setValue(String value) {
  this.value = value;
 }

}

Jackson ObjectMapper for Reading

It can be reaad by using the Jackson mapper , as shown below . reply - has the POJO string shown above

ObjectMapper mapper = new ObjectMapper();   
List<contenttype> ctl = mapper.readValue(reply, List.class);

Package : org.codehaus.jackson.map

Library can be included in the project by using the following in the pom.xml or just get the latest from http://jackson.codehaus.org/

pom.xml

 
    <dependency>
      <groupid>org.codehaus.jackson</groupid>
      <artifactid>jackson-mapper-asl</artifactid>
      <version>1.9.13</version>
    </dependency>
    
    <dependency>
      <groupid>org.codehaus.jackson</groupid>
      <artifactid>jackson-core-asl</artifactid>
      <version>1.9.13</version>
    </dependency>

Using Generics you can have a utility to parse data in JSON and get String data from POJO

 
package util;

import java.util.ArrayList;
import java.util.HashMap;

import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.type.TypeFactory;
import org.codehaus.jackson.map.DeserializationConfig;

public class JsonStringConverter {
  
 public static final <E> String getAsJSON(E inClass) throws Exception {
     ObjectMapper mapper = new ObjectMapper();
     return mapper.writeValueAsString(inClass) ; 
 }
 
 public  static final <E> E parseAsInputClassForArrayList(String json,Class outClass) throws Exception {
  ObjectMapper mapper = new ObjectMapper();
  TypeFactory t = TypeFactory.defaultInstance();
  mapper.configure(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
     return (E) mapper.readValue(json,t.constructCollectionType(ArrayList.class,outClass));  
 }
 
 public  static final <E> E parseAsInputClassForSimpleClass(String json,Class outClass) throws Exception {
  ObjectMapper mapper = new ObjectMapper();
     return (E) mapper.readValue(json,outClass);  
 }
 
 public  static final <E> E parseAsInputClassForHashMap(String json,Class key,Class outClass) throws Exception {
  ObjectMapper mapper = new ObjectMapper();
  TypeFactory t = TypeFactory.defaultInstance();
  mapper.configure(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
     return (E) mapper.readValue(json,t.constructMapType(HashMap.class,key,outClass));  
 }
 
}

Force Stop server using Script

2013-10-02T12:34:00.004-07:00

You have scripts to stop / start servers and sometimes due to memory leak or other reasons the server just doesn't shutdown . Script doesn't work because of this.

Work around ? , is to kill the process .

for tomcat

ps xu | grep 'tomcat' | grep -v grep | awk '{ print $2 }' | xargs kill -9

for jboss , you can use 'Standalone' keyword if you are using jboss7 or try to find the unique name from the process description

ps xu | grep 'Standalone' | grep -v grep | awk '{ print $2 }' | xargs kill -9

Memcached debugging using telnet

2013-10-02T12:20:00.002-07:00

Telnet for Memcached

You can use telnet for doing some debugging for Memcache .

Connect using telnet , port is usually 11211

telnet {memcachehost}  11211

commands

general purpose to find version , memory etc

stats

Remove everything

flush_all

Keys - there is no way to list all the keys

get the stats items using

stats items

request cache dump of each slab id with limit

stats cachedump 3 10

3 refers to the slab id

10 limit

exit

quit

Delete/Clear Solr

2013-09-24T20:29:00.002-07:00

Here is the simple shell script I use for clearning everything from Solr .

!/bin/sh
URL="http://user:password@host:portnum/solr.master/core/update"
DATA="<delete><query>*:*</query></delete>"
echo Posting "\"$DATA\"" to "\"$URL\"" with commit=true
curl $URL?commit=true -H "Content-Type: text/xml" --data-binary $DATA
echo Complete

JAX-WS Call WS using Maven

2013-08-23T16:19:00.001-07:00

Use Maven to Generate all Stubs using "wsimport" utility . After generating the webservice you can call the service using Java class. This method will can be easily reused , you just have to use different wsdl url every time you have to consume the webservice and modify the java code , it's light weight and no need to use any third party libraries . So you will need the following

wsdl file
pom.xml
Java Class

First step is to copy the wsdl file and place it in the src/wsdl directory
Setup the pom.xml pom.xml
Folder : Project root dir

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.myws.testconsumews</groupId>
 <artifactId>TestWSConsume</artifactId>
 <packaging>war</packaging>
 <version>1.0-SNAPSHOT</version>

 <name>Test Webservice</name>
 <url>http://maven.apache.org</url>
 
 
 <build>
  
  <plugins>
   
   <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>jaxws-maven-plugin</artifactId>
    <version>1.7</version>
    <executions>
     
      <execution>
      <id>generate-stubs</id>
      <phase>generate-sources</phase>
      <goals>
       <goal>wsimport</goal>
      </goals>
      <configuration>
          <wsdlDirectory>src/wsdl</wsdlDirectory>
       <wsdlFiles>
        <wsdlFile>myservice.wsdl</wsdlFile>
       </wsdlFiles>
       <wsdlLocation>http://localhost:8080/TestWS/myservice?wsdl</wsdlLocation>
        <sourceDestDir>src/main/java</sourceDestDir>
                       <packageName>com.myservice.proxy</packageName>
                  </configuration>
       
     </execution> 
    </executions>
   </plugin>
   <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.2</version>
     <configuration>
     <failOnMissingWebXml>false</failOnMissingWebXml>
    </configuration>
   </plugin>

  </plugins>
 </build>
</project>

run "mvn generate-sources" command , this will generate the files in src/main/java folder . Its specified as <sourceDestDir>src/main/java</sourceDestDir> in pom.xml
Stubs are generated ,You can call the webservice with following Java program

package com.myservice.client;

import com.myservice.proxy.MyService;
import com.myservice.proxy.MyServiceService;

public class CallMyService {
 
 
 
 public static void main(String[] args) {
  MyServiceService mss = new MyServiceService();
  MyService serv = mss.getMyServicePort();
   
     System.out.println(serv.sayHello());
 }
 
 
  
}

Now that was simple right . So what if you want to generate numerous webservice clients for testing and scripting needs you can simply reuse the pom.xml ( change the wsdl file ) , generate the stubs and change the program to call the new webservice .
Note
If your webservice requires authentication , you can set that up as shown below

     ((BindingProvider) serv).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, userName);
      ((BindingProvider) serv).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, passWord);

Cheers, hope that was helpful

JAX-WS Create WS using Maven

2013-08-22T15:44:00.001-07:00

Article describes setting up JAX-WS using Maven and various ways to deploy the webservice . Creating WS using JAX-WS is super simple , simply annotate the class with @WebService and its basically done. Simpicity is good not only for development but also creating mock services and testing error cases. Maven makes it more reusable be able to distibute easily to developers. Also maven takes care of wsgen and dependent libraries. I use Tomcat 7 and running Java 6 . If you are using Java7 , wsgen fails ( yeah it has to be fixed) , so till then configure the IDE to use Java6 for the project
Java Code - Your WebService ( Simple .. basically you can return POJO or collection of objects for practical use case)
folder - src/main/java

package com.services;

import javax.jws.WebMethod;
import javax.jws.WebService;
@WebService

public class MyService {

 @WebMethod
 public String sayHello()
 {
  return "Hello World";
 }
}

Pom.xml
folder - project folder

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.myws.testws</groupId>
 <artifactId>TestWS</artifactId>
 <packaging>war</packaging>
 <version>1.0-SNAPSHOT</version>

 <name>Test Webservice</name>
 <url>http://maven.apache.org</url>
 
 <dependencies>
    <dependency>
  <groupId>com.sun.xml.ws</groupId>
  <artifactId>jaxws-rt</artifactId>
  <version>2.1.3</version>
  </dependency>
 </dependencies>

 <build>
  
  <plugins>
   <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.2</version>
     <configuration>
     <failOnMissingWebXml>false</failOnMissingWebXml>
    </configuration>
   </plugin>
   <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>jaxws-maven-plugin</artifactId>
    <version>1.7</version>
    <executions>
     <execution>
      <id>generate-wsdl</id>
      <phase>process-classes</phase>
      <goals>
       <goal>wsgen</goal>
      </goals>
      <configuration>
       <sei>com.services.MyService</sei>
       <genWsdl>true</genWsdl>
      </configuration>
     </execution>
    
    </executions>
   </plugin>

   
  </plugins>
 </build>
</project>

Running it using EndPoint
Using Endpoint just use the publisher and WebService is running .

package com.services;

import javax.xml.ws.Endpoint;
 

public class MyServicePublisher{
 
 public static void main(String[] args) {
    Endpoint.publish("http://localhost:8888/TestWS/MyService", new MyService());
    }
 
}

test service : http://localhost:888/TestWS/MyService?wsdl
Running it in Tomcat.
My preferred method is to run it in tomcat . You will need couple of more files
web.xml
folder :src/webapp/WEB-INF

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, 
Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/j2ee/dtds/web-app_2_3.dtd">
 
<web-app>
    <listener>
        <listener-class>
                com.sun.xml.ws.transport.http.servlet.WSServletContextListener
        </listener-class>
    </listener>
    <servlet>
        <servlet-name>myservice</servlet-name>
        <servlet-class>
         com.sun.xml.ws.transport.http.servlet.WSServlet
        </servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>myservice</servlet-name>
        <url-pattern>/myservice</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>120</session-timeout>
    </session-config>
</web-app>

sun-jaxws.xml
folder :src/webapp/WEB-INF

<?xml version="1.0" encoding="UTF-8"?>
<endpoints
  xmlns="http://java.sun.com/xml/ns/jax-ws/ri/runtime"
  version="2.0">
  <endpoint
      name="MyService"
      implementation="com.services.MyService"
      url-pattern="/myservice"/>
</endpoints>

Deploy the war file to tomcat
test deployment : http://localhost:8080/TestWS/myservice?wsdl

Spring Mongo Integration

2013-08-10T22:34:00.002-07:00

Setting up and using MongoDB in the Spring application is a simple two step process.Specify the Mongo template in the application configuration , then customize the ApplicationConfig . Step 1 Include the Mongo configuration in the application context

<mongo:db-factory id="mongoDbFactory" dbname="my-store" />
 
 <mongo:mapping-converter id="mongoConverter" base-package="springdata.mongodb">
  <mongo:custom-converters base-package="springdata.mongodb" />
 </mongo:mapping-converter>
 
 <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
  <constructor-arg ref="mongoDbFactory" />
  <constructor-arg ref="mongoConverter" />
  <property name="writeConcern" value="SAFE" />
 </bean>
 
 <mongo:repositories base-package="springdata.mongodb" />

Step2 Setup the ApplicationConfig in the base-package

@ComponentScan
@EnableMongoRepositories
class ApplicationConfig extends AbstractMongoConfiguration {

 
 @Override
 protected String getDatabaseName() {
 return "my-store";
 
 }

 
 @Override
 public Mongo mongo() throws Exception {

  Mongo mongo = new Mongo();
  mongo.setWriteConcern(WriteConcern.SAFE);

  return mongo;
 }

}

After the two steps the Mongo can be included in the application by simply autowiring

@Autowired Mongo mongo;

Spring Integration to Consume and Publish REST

2013-08-10T18:51:00.002-07:00

Spring Integration using gateways makes it possible to consume services from multiple sources and expose them as api's . API's can be exposed with or without further processing . Lets look at an example without Processing .

If you need a code ref you can find it here https://github.com/arun2dot0/spring-integration-example

getFoo is a Restful service consumed by Spring and exposes back as service .
First thing to define is the publish-subscribe-channel ,then configure the input-channel with all the mappings .Example shows the method getFoo but there can be many mappings added for each of the service .

Next step is to specify the gateway to accept the incoming request to the channel . Service interface with the list of interface methods is specified .

Finally the http-oubound gateway is defined with the url , http-method with the transformer.
Transformer can be easily implemented by json-to-object trasnfromation as show.

Update :
It can be done using Java DSL as well and you can find the implementation here
https://github.com/arun2dot0/spring-integration-example-dsl
DSL uses newer version of spring integration and http library .

Spring Configuration

<?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:p="http://www.springframework.org/schema/p"  
 xmlns:int="http://www.springframework.org/schema/integration"  
 xmlns:http="http://www.springframework.org/schema/integration/http"
 xsi:schemaLocation="http://www.springframework.org/schema/beans   
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
 http://www.springframework.org/schema/integration/http http://www.springframework.org/schema/integration/http/spring-integration-http-2.1.xsd 
http://www.springframework.org/schema/integration   
http://www.springframework.org/schema/integration/spring-integration-2.1.xsd">  
  
<!-- Channel for incoming request-->
<int:publish-subscribe-channel id="pubsubChannel"></int:publish-subscribe-channel>
 
 <!-- Define header with all the necessary mapping--> 
<int:header-value-router input-channel="pubsubChannel" header-name="REQUEST_TYPE">
 <int:mapping value="getFoo" channel="getFooChannel"/>
</int:header-value-router> 

<int:channel id="getFooChannel"/>

<!-- Simple facade method which accepts messages into channel -->
<int:gateway  id="firstGatewayID" service-interface="services.api.FirstGatewayService"     default-request-channel="pubsubChannel" >
  <!--Provide method in the gateway -->
 <int:method name="getFoo">
   <int:header name="REQUEST_TYPE" value="getFoo"/>
  </int:method>
</int:gateway>  


 <!--outbound gateway to get data from url-->
<http:outbound-gateway id="getFooGateway" 
                   url="http://somehost.com/GetFoo" 
                request-channel="getFooChannel" 
                reply-channel="getFooChannel_response"
                http-method="GET" 
                expected-response-type="java.lang.String">
 </http:outbound-gateway>
 
 <int:json-to-object-transformer input-channel="getFooChannel_response" type="model.FooResponse"/>  
</beans>

Java Code

Gateway Service

package services.api;
import org.springframework.integration.annotation.Header;
import org.springframework.integration.annotation.Payload;
public interface FirstGatewayService {
 @Payload("new java.util.Date()")
 public FooResponse getFoo();
}

Response

package model;
import org.codehaus.jackson.annotate.JsonProperty;
public class FooResponse {
 @JsonProperty("status")
 boolean status;
 @JsonProperty("data")
 String data;
 public boolean isStatus() {
  return status;
 }
 public void setStatus(boolean status) {
  this.status = status;
 }
 public String getData() {
  return data;
 }
 public void setData(String data) {
  this.data = data;
 }
}

Controller

@Autowired
private FirstGatewayService gatewayService;
@Override
 @RequestMapping(value = <url to access>, method = RequestMethod.GET)
 public @ResponseBody BaseResponse getFoo() {
  return gatewayService.getFoo();
 }

Embedding images in E-Mail

2010-08-12T16:17:00.000-07:00

We have been using XML XSL transformation for generating the emails and it was working well . XML Provides the data and Styling is provided in XSL . It becomes tricky when including images . One easy way to do is to include images as URL . This may not be the right approach as the user may not be online when looking a the email and can be lost during forwarding .

Best way is to use javax.mail.internet.MimeMultipart and set the images as header .
Here is the example
XSL to include images will look like this



<img>

<xsl:attribute name="src">cid:image1</xsl:attribute>

<xsl:attribute name="border">0</xsl:attribute>

</img>

Include the images in the email service after the transformation



MimeMultipart multipart = new MimeMultipart();

BodyPart messageBodyPart = new MimeBodyPart();



messageBodyPart.setContent("All Email contents from Transformation", "text/html");

multipart.addBodyPart(messageBodyPart);



// add first image

messageBodyPart = new MimeBodyPart();

DataSource fds = new FileDataSource

("C:\\image_path");

messageBodyPart.setHeader("Content-ID","<image1>");

messageBodyPart.setDataHandler(new DataHandler(fds));

multipart.addBodyPart(messageBodyPart);



//add another image

messageBodyPart = new MimeBodyPart();

DataSource fds1 = new FileDataSource

("C:\\image-path");

messageBodyPart.setHeader("Content-ID","<image2>");

messageBodyPart.setDataHandler(new DataHandler(fds1));

multipart.addBodyPart(messageBodyPart);



message.setContent(multipart);

You will see the image replaced .Images are downloaded with the message and is replaced where the tag is used . It's solves all the issues related to using them as URL.

Java Stuff

Spring api docs using swagger

Spring Integration file processing using DSL

Simple Example of File processing using Spring Integration

Fun with IOT

Publish -> Analyze -> Utilize

Edge

Data Platform

Client

Demo

IoT hands on using AWS Lamba - Spring Boot - RaspberryPi GrovePi

Journey starts ...

Data Layer

Alexa Skill

Messaging using PubNub

Rewiring to use API

Architecture

Learn it ,Use it , Hack it

github links

Simple framework to Test your REST API

Http Responses Validation

Set URL , HTTP Headers once

Use Mustache templates to define HTTP Post and Put Payload

Easily setup for multiple environments

AngularJS

Two-Way Binding

Simple JS

Easy to adapt and get Started

Advantages

Reduce boilerplate Use default structure that is self explanatory Easy to test

Directive

Databinding

Controller (ng-controller)

Filters

Server Interaction

MongoDB

Comparison with Relational DB

Features

Advantages

BSON

Actual data ( Documents ) are stored as BSON ( Binary JSON ) .Driver takes care of transforming JSON >< BSON.

ObjectID

Index

First index from the scan is used for query and other attempts to find the scan are disregarded after the index is found .

Index can be ensured using ensureIndex . query can also use hints ( not a good idea because query analyzer knows best )

Arrays

Examples

Deployment

Driver's and working with applications

Sharding and Replication

Java8

Lambda's and Functional Interfaces

Example of Imperative style

Example of Declarative ( functional) Style

Why this is better

Example with return

Example using stream

parallelStream

Optional

ifPresent / orElse

Google App Engine Maven setup

Maven Setup for Google App Engine

Password Setup

Directory

pom.xml

Spring Integration - Calling SOAP Service using Gateway , Channel and Chain

WebService using Spring Integration

Generation of Marshaller and UnMarshaller

Java Interface to Call WebService

Stuff to Configure ( full xml shown below )

Gateway

Publish-Subscribe Channel

Header-Value Router

Chain

Outbound gateway

Full XML

Java Transformer

jBPM process after workflow node using ActionHandler

jBPM process after workflow node using ActionHandler

Workflow ProcessDefinition

Reduce boilerplate

Use default structure that is self explanatory

Easy to test