db.fruits.find( { name: { $in: [ 'mango', 'apple' ] } } )

Syntax: { $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }
The $or operator performs a logical OR operation on an array of two or more 
<expressions> and selects the documents that satisfy at least one of the <expressions>.

use the $in operator rather than the $or operator when performing equality checks on 
the same field.

db.fruits.find( {name: {$nin: ['mango','apple']}} )

<marquee behavior="scroll" direction="left">
My message 
<marquee>

> db.fruits.find({ "_id" : ObjectId("52d49575e3a91584ad8f614e")})
{ "_id" : ObjectId("52d49575e3a91584ad8f614e"), "name" : "mango", "color" : "yel
low", "rating" : 2, "weight" : 1.03 }

> db.fruits.find( { rating: { $gt: 0 } } )
{ "_id" : ObjectId("52d305ab4e386a0b85ac249a"), "name" : "apple", "color" : "red
", "rating" : 4, "weight" : 2.3 }
{ "_id" : ObjectId("52d49575e3a91584ad8f614e"), "name" : "mango", "color" : "yel
low", "rating" : 2, "weight" : 1.03 }

> db.fruits.find( { rating: { $nin: [1,2,3] } } )
{ "_id" : ObjectId("52d305ab4e386a0b85ac249a"), "name" : "apple", "color" : "red
", "rating" : 4, "weight" : 2.3 }
{ "_id" : ObjectId("52d30d464e386a0b85ac249b"), "name" : "lost", "age" : 12 }
{ "_id" : ObjectId("52d30d524e386a0b85ac249c"), "name" : "INS Viraat", "wt" : 50
00, "displacement" : 190.87 }
>

> db.fruits.find( { rating: { $ne: 1 } } )
{ "_id" : ObjectId("52d305ab4e386a0b85ac249a"), "name" : "apple", "color" : "red
", "rating" : 4, "weight" : 2.3 }
{ "_id" : ObjectId("52d30d464e386a0b85ac249b"), "name" : "lost", "age" : 12 }
{ "_id" : ObjectId("52d30d524e386a0b85ac249c"), "name" : "INS Viraat", "wt" : 50
00, "displacement" : 190.87 }
{ "_id" : ObjectId("52d49575e3a91584ad8f614e"), "name" : "mango", "color" : "yel
low", "rating" : 2, "weight" : 1.03 }
>

> db.fruits.find( { weight: { $not: { $gt: 1.00}}})
{ "_id" : ObjectId("52d30d464e386a0b85ac249b"), "name" : "lost", "age" : 12 }
{ "_id" : ObjectId("52d30d524e386a0b85ac249c"), "name" : "INS Viraat", "wt" : 50
00, "displacement" : 190.87 }
>

{ $not: { $gt: 1.99 } } is different from the $lte operator. { $lte: 1.99 } 
returns only the documents where --- field exists and its value is less 
than or equal to 1.99.

> db.fruits.find( { $nor: [ { color: 'red' }, { rating: 4 } ]  } )
{ "_id" : ObjectId("52d30d464e386a0b85ac249b"), "name" : "lost", "age" : 12 }
{ "_id" : ObjectId("52d30d524e386a0b85ac249c"), "name" : "INS Viraat", "wt" : 50
00, "displacement" : 190.87 }
{ "_id" : ObjectId("52d49575e3a91584ad8f614e"), "name" : "mango", "color" : "yel
low", "rating" : 2, "weight" : 1.03 }
>

publicstatic String DB_NAME = "fruits";
publicstatic String COLLECTION_NAME = "fruits";
publicstatic void main(String[] args) throws UnknownHostException {
      Mongo mongoClient = new Mongo();
      DB targetDB = mongoClient.getDB(DB_NAME);

      DBCollection collection = targetDB.getCollection(COLLECTION_NAME);
DBCursor cursor = collection.find();
System.out.println("Count of  records are : " + cursor.count());
System.out.println("Length of records are : " + cursor.length());
      cursor.close();

      mongoClient.close();
   }

Count of  records are : 4
Length of records are : 4

Count of  records are : 122934447
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
 at java.util.LinkedHashMap.createEntry(LinkedHashMap.java:442)
 at java.util.HashMap.addEntry(HashMap.java:856)
 at java.util.LinkedHashMap.addEntry(LinkedHashMap.java:427)
 at java.util.HashMap.put(HashMap.java:484)
 at org.bson.BasicBSONObject.put(BasicBSONObject.java:281)

public int count() {
if ( _collection == null )
thrownewIllegalArgumentException("why is _collection null");
if ( _collection._db == null )
thrownewIllegalArgumentException("why is _collection._db null");
return(int)_collection.getCount(this._query, this._keysWanted, getReadPreference());
}

public int length() {
  _checkType( CursorType.ARRAY );
_fill( Integer.MAX_VALUE );
return _all.size();
}

publicstatic void queryResultCount() throws UnknownHostException {
      Mongo mongoClient = new Mongo();
      DB targetDB = mongoClient.getDB(DB_NAME);

      DBCollection coll = targetDB.getCollection("Players");
      BasicDBObject query = new BasicDBObject();
      DBCursor cursor = coll.find(query);
cursor.limit(10);
System.out.println("Count of  records are : " + cursor.count());
System.out.println("Size of  records are : " + cursor.size());
      mongoClient.close();
   }

Count of  records are : 122934447
Size of  records are : 10

An index is an on-disk structure associated with a table or view that speeds retrieval 
of rows from the table or view. An index contains keys built from one or more columns 
in the table or view. These keys are stored in a structure (B-tree) that enables SQL 
Server to find the row or rows associated with the key values quickly and efficiently.

By default, creating an index blocks all other operations on a database. When building an index on a 
collection, the database that holds the collection is unavailable for read or write operations until 
the index build completes. Any operation that requires a read or write lock on all databases 
(e.g. listDatabases) will wait for the foreground index build to complete.
For potentially long running index building operations, consider the background operation so that the 
MongoDB database remains available during the index building operation.

>db.Players.ensureIndex( { name: 1}, {background: true,unique:false} )

Background indexing operations run in the background so that other database operations can run 
while creating the index. However, the mongo shell session or connection where you are creating 
the index will block until the index build is complete. To continue issuing commands to the database,
open another connection or mongo instance.

publicstatic void main(String[] args) throws UnknownHostException {
      Mongo mongoClient = new Mongo();
      DB targetDB = mongoClient.getDB(DB_NAME);

      DBCollection collection = targetDB.getCollection(COLLECTION_NAME);
List<DBObject> indexes = collection.getIndexInfo();
System.out.println("Indexes on " + collection.getFullName() + " are : ");
for (DBObject index : indexes) {
System.out.println(index);
      }     
   }

Indexes on fruits.fruits are : 
{ "v" : 1 , "key" : { "_id" : 1} , "ns" : "fruits.fruits" , "name" : "_id_"}
{ "v" : 1 , "key" : { "name" : -1.0} , "ns" : "fruits.fruits" , "name" : "name_-1"}

publicstatic void main(String[] args) throws UnknownHostException {
      Mongo mongoClient = new Mongo();
      DB targetDB = mongoClient.getDB(DB_NAME);

      DBCollection collection = targetDB.getCollection(COLLECTION_NAME);
collection.createIndex(new BasicDBObject("rating", 1).append("unique", true));// create unique index, ascending
List<DBObject> indexes = collection.getIndexInfo();
System.out.println("Indexes on " + collection.getFullName() + " are : ");
for (DBObject index : indexes) {
System.out.println(index);
      }

   }

Indexes on fruits.fruits are : 
{ "v" : 1 , "key" : { "_id" : 1} , "ns" : "fruits.fruits" , "name" : "_id_"}
{ "v" : 1 , "key" : { "name" : -1.0} , "ns" : "fruits.fruits" , "name" : "name_-1"}
{ "v" : 1 , "key" : { "rating" : 1 , "unique" : true} , "ns" : "fruits.fruits" , "name" : "rating_1_unique_"}

Some query operations are not selective. These operations cannot use indexes  effectively 
or cannot use indexes at all. The inequality operators $nin and $ne are not very selective, 
as they often match a large portion of the index. As a result, in most cases, a $nin or $ne 
query with an index may perform no better than a $nin or $ne query that must scan all 
documents in a collection. Queries that specify regular expressions, with inline JavaScript 
regular expressions or $regex operator expressions, cannot use an index with one exception. 
Queries that specify regular expression with anchors at the beginning of a string can use an 
index. 

<beans:bean id="transactionManager"
 class="org.springframework.batch.support.transaction.ResourcelessTransactionManager">
</beans:bean>

<beans:bean id="jobRepository"
 class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean">
<beans:property name="transactionManager" ref="transactionManager"/>
</beans:bean>

<job id="reportJob" job-repository="jobRepository">
<step id="step1">
<tasklet>
<chunk reader="itemReader" writer="itemWriter" processor="personProcessor"
    commit-interval="2"/>
</tasklet>
</step>
</job>

Robin,Varghese
Rohan,Naidu
Roman,Barlan

publicclass Person {
privateString lastName;
privateString firstName;
// setter getters

}

<beans:bean id="fieldSetMapper"
 class="org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper">
<beans:property name="targetType" value="org.robin.learn.sb.data.Person"/>
</beans:bean>

<beans:bean id="lineTokenizer"
 class="org.springframework.batch.item.file.transform.DelimitedLineTokenizer">
<beans:property name="names" value="firstName,lastName"/>
</beans:bean>

<beans:bean id="lineMapper"
 class="org.springframework.batch.item.file.mapping.DefaultLineMapper">
<beans:property name="lineTokenizer" ref="lineTokenizer"/>
<beans:property name="fieldSetMapper" ref="fieldSetMapper"/>
</beans:bean>

<beans:bean id="itemReader"
 class="org.springframework.batch.item.file.FlatFileItemReader">
<beans:property name="resource" value="classpath:sample-data.csv"/>
<beans:property name="lineMapper" ref="lineMapper"/>
</beans:bean>

"Strategy interface for providing the data. Implementations are expected to be 
stateful and will be called multiple times for each batch, with each call 
to read() returning a different value and finally returning null when all 
input data is exhausted. Implementations need not be thread-safe and clients 
of a ItemReader need to be aware that this is the case. "

• a resource which is the input data to process 
• a lineTokenizer which will split the input line into separate tokens and associate them with keys - thus creating a set of key value pairs. 
• a FieldSetMapper which will instantiate the target bean (Person) and set the properties from the key value pairs generated in the previous step. 

publicclass PersonItemProcessor implements ItemProcessor<Person, Person> {

// returning null indicates that the item should not be continued to be
// processed.
public Person process(final Person person) throwsException {
finalString firstName = person.getFirstName().toUpperCase();
finalString lastName = person.getLastName().toUpperCase();
final Person transformedPerson = new Person(firstName, lastName);
System.out.println("Converting (" + person + ") into ("
    + transformedPerson + ")");
return transformedPerson;
 }

}

<beans:bean id="itemWriter"
 class="org.springframework.batch.item.support.ListItemWriter"/>

publicstatic void main(String[] args) {

      ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
      JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
      Job job = (Job) context.getBean("reportJob");

try {
         JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
      } catch (JobExecutionAlreadyRunningException | JobRestartException
            | JobInstanceAlreadyCompleteException | JobParametersInvalidException e) {
         e.printStackTrace();
      }

List<? extends Person> results = ((ListItemWriter<Person>) context.getBean("itemWriter"))
            .getWrittenItems();
for (Person person : results) {
System.out.println("Found <" + person + "> in the result.");
      }
      ((ConfigurableApplicationContext) context).close();
System.out.println("Done");
   }

• A JobLauncher class executes a Job retrieved from a JobRepository passing to it a JobParameters object. 
• For the executed job, the JobLauncher returns us a JobExecution object which is like a report. 
• Every job is composed of one or more steps each of which could be composed of read process and write operations. 

<?xmlversion="1.0"encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/batch"
   xmlns:beans="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="
 http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/batch
 http://www.springframework.org/schema/batch/spring-batch-2.2.xsd">

<beans:bean id="fieldSetMapper"
      class="org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper">
<beans:property name="targetType"
         value="org.robin.learn.spring.batch.data.Person"/>
</beans:bean>

<beans:bean id="lineTokenizer"
      class="org.springframework.batch.item.file.transform.DelimitedLineTokenizer">
<beans:property name="names" value="firstName,lastName"/>
</beans:bean>

<beans:bean id="lineMapper"
      class="org.springframework.batch.item.file.mapping.DefaultLineMapper">
<beans:property name="lineTokenizer" ref="lineTokenizer"/>
<beans:property name="fieldSetMapper" ref="fieldSetMapper"/>
</beans:bean>

<beans:bean id="itemReader"
      class="org.springframework.batch.item.file.FlatFileItemReader">
<beans:property name="resource" value="classpath:sample-data.csv"/>
<beans:property name="lineMapper" ref="lineMapper"/>
</beans:bean>


<beans:bean id="itemWriter"
      class="org.springframework.batch.item.support.ListItemWriter"/>

<beans:bean id="personProcessor"
      class="org.robin.learn.spring.batch.PersonItemProcessor"/>


<job id="reportJob" job-repository="jobRepository">
<step id="step1">
<tasklet>
<chunk reader="itemReader" writer="itemWriter"
               processor="personProcessor" commit-interval="2"/>
</tasklet>
</step>
</job>

<beans:bean id="transactionManager"
      class="org.springframework.batch.support.transaction.ResourcelessTransactionManager">
</beans:bean>

<beans:bean id="jobRepository"
      class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean">
<beans:property name="transactionManager" ref="transactionManager"/>
</beans:bean>

<beans:bean id="jobLauncher"
      class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
<beans:property name="jobRepository" ref="jobRepository"/>
</beans:bean>

</beans:beans>

13:58:13.678 [main] INFO  o.s.b.f.xml.XmlBeanDefinitionReader - Loading XML bean definitions 
from class path resource [spring-config.xml]
...
13:58:14.258 [main] DEBUG o.s.t.i.NameMatchTransactionAttributeSource - Adding transactional method 
[*] with attribute [PROPAGATION_REQUIRED,ISOLATION_DEFAULT]
13:58:14.258 [main] DEBUG o.s.t.i.NameMatchTransactionAttributeSource - Adding transactional method 
[create*] with attribute [PROPAGATION_REQUIRES_NEW,ISOLATION_SERIALIZABLE]
13:58:14.258 [main] DEBUG o.s.t.i.NameMatchTransactionAttributeSource - Adding transactional method 
[getLastJobExecution*] with attribute [PROPAGATION_REQUIRES_NEW,ISOLATION_SERIALIZABLE]
...
13:58:14.278 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Finished creating instance of bean 'jobRepository'
...
13:58:14.368 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Creating instance of bean 'reportJob'
...
13:58:14.378 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Creating instance of bean 'jobLauncher'
13:58:14.398 [main] DEBUG o.s.b.s.t.ResourcelessTransactionManager - Creating new transaction with 
name [org.springframework.batch.core.repository.support.SimpleJobRepository.getLastJobExecution]:
PROPAGATION_REQUIRES_NEW,ISOLATION_SERIALIZABLE
13:58:14.448 [main] DEBUG o.s.b.s.t.ResourcelessTransactionManager - Initiating transaction commit
13:58:14.448 [main] DEBUG o.s.b.s.t.ResourcelessTransactionManager - Committing resourceless transaction on
[org.springframework.batch.support.transaction.ResourcelessTransactionManager$ResourcelessTransaction@6b7fd49c]
13:58:14.508 [main] INFO  o.s.b.c.l.support.SimpleJobLauncher - Job: [FlowJob: [name=reportJob]] 
launched with the following parameters: [{}]
13:58:14.508 [main] DEBUG o.s.batch.core.job.AbstractJob - Job execution starting: JobExecution: id=0, 
version=0, startTime=null, endTime=null,
lastUpdated=Thu Feb 19 13:58:14 CST 2015, status=STARTING, exitStatus=exitCode=UNKNOWN;
exitDescription=, job=[JobInstance: id=0, version=0, Job=[reportJob]], jobParameters=[{}]
13:58:14.518 [main] DEBUG o.s.b.s.t.ResourcelessTransactionManager - Creating new transaction with name
[org.springframework.batch.core.repository.support.SimpleJobRepository.update]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
...
13:58:14.538 [main] INFO  o.s.batch.core.job.SimpleStepHandler - Executing step: [step1]
13:58:14.538 [main] DEBUG o.s.batch.core.step.AbstractStep - Executing: id=1
Converting (firstName: Robin, lastName: Varghese) into (firstName: ROBIN, lastName: VARGHESE)
Converting (firstName: Rohan, lastName: Naidu) into (firstName: ROHAN, lastName: NAIDU)
13:58:14.578 [main] DEBUG o.s.b.c.s.item.ChunkOrientedTasklet - Inputs not busy, ended: false
13:58:14.578 [main] DEBUG o.s.b.core.step.tasklet.TaskletStep - Applying contribution: [
StepContribution: read=2, written=2, filtered=0, readSkips=0, writeSkips=0, processSkips=0, exitStatus=EXECUTING]
...
Converting (firstName: Roman, lastName: Barlan) into (firstName: ROMAN, lastName: BARLAN)
13:58:14.588 [main] DEBUG o.s.batch.core.step.AbstractStep - Step execution success: id=1
...
13:58:14.608 [main] INFO  o.s.b.c.l.support.SimpleJobLauncher - Job: [FlowJob: [name=reportJob]] 
completed with the following parameters: [{}] and the following status: [COMPLETED]
Exit Status : COMPLETED
Found <firstName: ROBIN, lastName: VARGHESE> in the result.
Found <firstName: ROHAN, lastName: NAIDU> in the result.
Found <firstName: ROMAN, lastName: BARLAN> in the result.
Done

publicclass MemItemReader extends ListItemReader<Person> {

   @SuppressWarnings("unchecked")
public MemItemReader(ListItemWriter<Person> writer) {
super((List<Person>) writer.getWrittenItems());

   }

}

publicclass BetterPerson extends Person {
privateString title;
//setter getters
}

publicclass BetterPersonItemProcessor implements ItemProcessor<Person, BetterPerson> {

public BetterPerson process(final Person person) throwsException {

final BetterPerson betterPerson = new BetterPerson();

      betterPerson.setFirstName(person.getFirstName());
      betterPerson.setLastName(person.getLastName());
      betterPerson.setTitle("??");
System.out.println("Converting (" + person + ") into ("
      + betterPerson + ")");
return betterPerson;
   }

}

<job id="reportJob" job-repository="jobRepository">
<step id="step1" next="step2">
<tasklet>
<chunk reader="itemReader" writer="itemWriter"
               processor="personProcessor" commit-interval="2"/>
</tasklet>
</step>
<step id="step2">
<tasklet>
<chunk reader="memItemReader" writer="cvsFileItemWriter"
               processor="betterPersonProcessor" commit-interval="2"/>
</tasklet>
</step>
</job>

Exception in thread "main" org.springframework.beans.factory.parsing.BeanDefinitionParsingException:
 Configuration problem: The element [step2] is unreachable 
Offending resource: class path resource [spring-config.xml]

<beans:bean id="memItemReader" class="org.robin.learn.sb.batch.MemItemReader"
      scope="step">
<beans:constructor-arg ref="itemWriter"/>
</beans:bean>


<beans:bean id="betterPersonProcessor"
      class="org.robin.learn.sb.batch.BetterPersonItemProcessor"/>

<beans:bean id="cvsFileItemWriter"
      class="org.springframework.batch.item.file.FlatFileItemWriter">
<beans:property name="resource" value="file:opt.csv"/>
<beans:property name="shouldDeleteIfExists" value="true"/>
<beans:property name="lineAggregator">
<beans:bean
            class="org.springframework.batch.item.file.transform.DelimitedLineAggregator">
<beans:property name="delimiter" value=","/>
<beans:property name="fieldExtractor">
<beans:bean
                  class="org.springframework.batch.item.file.transform.BeanWrapperFieldExtractor">
<beans:property name="names"
                     value="title, firstName,lastName"/>
</beans:bean>
</beans:property>
</beans:bean>
</beans:property>
</beans:bean>

15:21:16.894 [main] INFO  o.s.batch.core.job.SimpleStepHandler - Executing step: [step2].
...
15:21:16.904 [main] DEBUG o.s.batch.core.scope.StepScope - Creating object in scope=step,
name=scopedTarget.memItemReader
15:21:16.904 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Creating instance of bean 
'scopedTarget.memItemReader'
15:21:16.904 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Returning cached instance 
of singleton bean 'itemWriter'

??,ROBIN,VARGHESE
??,ROHAN,NAIDU
??,ROMAN,BARLAN

"Note that the in-memory repository is volatile and so does not allow restart between JVM instances. 
It also cannot guarantee that two job instances with the same parameters are launched simultaneously, 
and is not suitable for use in a multi-threaded Job, or a locally partitioned Step. So use the 
database version of the repository wherever you need those features."

<beans:bean id="jobRepository"
      class="org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<beansroperty name="transactionManager" ref="transactionManager"/>
<beansroperty name="dataSource" ref="dataSource"/>
</beans:bean>

<beans:bean id="dataSource"
      class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<beans:property name="driverClassName" value="org.postgresql.Driver"/>
<beans:property name="url"
         value="jdbcostgresql://localhost:5433/batchTest"/>
<bean:psroperty name="username" value="postgres"/>
<bean:psroperty name="password" value="#######"/>
</beans:bean>

<beans:bean id="transactionManager"
      class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<beans:property name="dataSource" ref="dataSource"/>
</beans:bean>

11:53:45.589 [main] INFO  o.s.j.support.SQLErrorCodesFactory - SQLErrorCodes loaded: 
[DB2, Derby, H2, HSQL, Informix, MS-SQL, MySQL, Oracle, PostgreSQL, Sybase]
11:53:45.589 [main] DEBUG o.s.j.support.SQLErrorCodesFactory - Looking up default 
SQLErrorCodes for DataSource [org.springframework.jdbc.datasource.DriverManagerDataSource@464d02ee]
11:53:45.589 [main] DEBUG o.s.j.support.SQLErrorCodesFactory - Database product name cached for 
DataSource [org.springframework.jdbc.datasource.DriverManagerDataSource@464d02ee]: name is 'PostgreSQL'
11:53:45.589 [main] DEBUG o.s.j.support.SQLErrorCodesFactory - SQL error codes for 'PostgreSQL' found
11:53:45.590 [main] DEBUG o.s.j.s.SQLErrorCodeSQLExceptionTranslator 
- Translating SQLException with SQL state '42P01', error code '0', message [ERROR: relation 
"batch_job_instance" does not exist
  Position: 39]; SQL was [SELECT JOB_INSTANCE_ID, JOB_NAME from BATCH_JOB_INSTANCE where 
JOB_NAME = ? and JOB_KEY = ?] for task [PreparedStatementCallback]
11:53:45.590 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Initiating transaction rollback

<jdbc:initialize-database data-source="dataSource">
<jdbc:script
         location="org/springframework/batch/core/schema-drop-postgresql.sql"/>
<jdbc:script
         location="org/springframework/batch/core/schema-postgresql.sql"/>
</jdbc:initialize-database>

13:18:00.641 [main] DEBUG o.s.b.f.xml.XmlBeanDefinitionReader - Loaded 20 bean definitions from location pattern [spring-config-db.xml]
...
13:18:00.853 [main] DEBUG o.s.jdbc.datasource.DataSourceUtils - Fetching JDBC Connection from DataSource
13:18:00.853 [main] DEBUG o.s.j.d.DriverManagerDataSource - Creating new JDBC DriverManager Connection to [jdbcostgresql://localhost:5433/batchTest]
13:18:00.928 [main] DEBUG o.s.jdbc.datasource.DataSourceUtils - Returning JDBC Connection to DataSource
13:18:00.928 [main] INFO  o.s.b.c.r.s.JobRepositoryFactoryBean - No database type set, using meta data indicating: POSTGRES
13:18:01.013 [main] DEBUG o.s.t.i.NameMatchTransactionAttributeSource - Adding transactional method [*] with attribute 
[PROPAGATION_REQUIRED,ISOLATION_DEFAULT]
13:18:01.013 [main] DEBUG o.s.t.i.NameMatchTransactionAttributeSource - Adding transactional method [create*] with attribute 
[PROPAGATION_REQUIRES_NEW,ISOLATION_SERIALIZABLE]
13:18:01.013 [main] DEBUG o.s.t.i.NameMatchTransactionAttributeSource - Adding transactional method [getLastJobExecution*] 
with attribute [PROPAGATION_REQUIRES_NEW,ISOLATION_SERIALIZABLE]
...
13:18:01.114 [main] DEBUG o.s.jdbc.datasource.DataSourceUtils - Fetching JDBC Connection from DataSource
13:18:01.114 [main] DEBUG o.s.j.d.DriverManagerDataSource - Creating new JDBC DriverManager Connection to [jdbcostgresql://localhost:5433/batchTest]
13:18:01.132 [main] INFO  o.s.jdbc.datasource.init.ScriptUtils - Executing SQL script from class path resource 
[org/springframework/batch/core/schema-drop-postgresql.sql]
...
13:18:01.143 [main] INFO  o.s.jdbc.datasource.init.ScriptUtils - Executed SQL script from class path resource 
[org/springframework/batch/core/schema-drop-postgresql.sql] in 10 ms.
13:18:01.143 [main] INFO  o.s.jdbc.datasource.init.ScriptUtils - Executing SQL script from class path resource 
[org/springframework/batch/core/schema-postgresql.sql]
13:18:01.479 [main] INFO  o.s.jdbc.datasource.init.ScriptUtils - Executed SQL script from class path resource 
[org/springframework/batch/core/schema-postgresql.sql] in 336 ms.

This is when the job runs:
13:18:01.522 [main] DEBUG o.s.jdbc.core.JdbcTemplate - Executing prepared SQL statement [SELECT JOB_INSTANCE_ID, JOB_NAME
 from BATCH_JOB_INSTANCE where JOB_NAME = ? and JOB_KEY = ?]
13:18:01.531 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Creating new transaction with name 
[org.springframework.batch.core.repository.support.SimpleJobRepository.createJobExecution]: PROPAGATION_REQUIRES_NEW,ISOLATION_SERIALIZABLE
SELECT JOB_INSTANCE_ID, JOB_NAME from BATCH_JOB_INSTANCE where JOB_NAME = ? and JOB_KEY = ?
INSERT into BATCH_JOB_INSTANCE(JOB_INSTANCE_ID, JOB_NAME, JOB_KEY, VERSION) values (?, ?, ?, ?)
INSERT into BATCH_JOB_EXECUTION(JOB_EXECUTION_ID, JOB_INSTANCE_ID, START_TIME, END_TIME,
 STATUS, EXIT_CODE, EXIT_MESSAGE, VERSION, CREATE_TIME, LAST_UPDATED, JOB_CONFIGURATION_LOCATION) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
INSERT INTO BATCH_JOB_EXECUTION_CONTEXT (SHORT_CONTEXT, SERIALIZED_CONTEXT, JOB_EXECUTION_ID) VALUES(?, ?, ?)

13:18:01.583 [main] INFO  o.s.b.c.l.support.SimpleJobLauncher - Job: [FlowJob: [name=reportJob]] launched with the following parameters: [{}]
13:18:01.583 [main] DEBUG o.s.batch.core.job.AbstractJob - Job execution starting: JobExecution: id=1, version=0, startTime=null, endTime=null, 
lastUpdated=Tue Feb 24 13:18:01 CST 2015, status=STARTING, exitStatus=exitCode=UNKNOWN;
exitDescription=, job=[JobInstance: id=1, version=0, Job=[reportJob]], jobParameters=[{}]
13:18:01.586 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Creating new transaction with name 
[org.springframework.batch.core.repository.support.SimpleJobRepository.update]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
SELECT VERSION FROM BATCH_JOB_EXECUTION WHERE JOB_EXECUTION_ID=?
UPDATE BATCH_JOB_EXECUTION set START_TIME = ?, END_TIME = ?,  STATUS = ?, EXIT_CODE = ?, EXIT_MESSAGE = ?, VERSION = ?, 
CREATE_TIME = ?, LAST_UPDATED = ? where JOB_EXECUTION_ID = ? and VERSION = ?
SELECT JOB_EXECUTION_ID, START_TIME, END_TIME, STATUS, EXIT_CODE, EXIT_MESSAGE, CREATE_TIME, LAST_UPDATED, VERSION,
JOB_CONFIGURATION_LOCATION from BATCH_JOB_EXECUTION where JOB_INSTANCE_ID = ? order by JOB_EXECUTION_ID desc
SELECT JOB_EXECUTION_ID, KEY_NAME, TYPE_CD, STRING_VAL, DATE_VAL, LONG_VAL, DOUBLE_VAL, IDENTIFYING 
from BATCH_JOB_EXECUTION_PARAMS where JOB_EXECUTION_ID = ?
SELECT STEP_EXECUTION_ID, STEP_NAME, START_TIME, END_TIME, STATUS, COMMIT_COUNT, READ_COUNT, FILTER_COUNT, WRITE_COUNT, 
EXIT_CODE, EXIT_MESSAGE, READ_SKIP_COUNT, WRITE_SKIP_COUNT, PROCESS_SKIP_COUNT, ROLLBACK_COUNT, LAST_UPDATED, VERSION 
from BATCH_STEP_EXECUTION where JOB_EXECUTION_ID = ? order by STEP_EXECUTION_ID
13:18:01.639 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Initiating transaction commit
SELECT JOB_EXECUTION_ID, START_TIME, END_TIME, STATUS, EXIT_CODE, EXIT_MESSAGE, CREATE_TIME, LAST_UPDATED, VERSION, 
JOB_CONFIGURATION_LOCATION from BATCH_JOB_EXECUTION where JOB_INSTANCE_ID = ? order by JOB_EXECUTION_ID desc
SELECT JOB_EXECUTION_ID, KEY_NAME, TYPE_CD, STRING_VAL, DATE_VAL, LONG_VAL, DOUBLE_VAL, IDENTIFYING 
from BATCH_JOB_EXECUTION_PARAMS where JOB_EXECUTION_ID = ?
SELECT STEP_EXECUTION_ID, STEP_NAME, START_TIME, END_TIME, STATUS, COMMIT_COUNT, READ_COUNT, FILTER_COUNT, 
WRITE_COUNT, EXIT_CODE, EXIT_MESSAGE, READ_SKIP_COUNT, WRITE_SKIP_COUNT, PROCESS_SKIP_COUNT, ROLLBACK_COUNT, LAST_UPDATED, 
VERSION from BATCH_STEP_EXECUTION where JOB_EXECUTION_ID = ? order by STEP_EXECUTION_ID

Initiating transaction commit
SELECT JOB_EXECUTION_ID, START_TIME, END_TIME, STATUS, EXIT_CODE, EXIT_MESSAGE, CREATE_TIME, LAST_UPDATED, VERSION, JOB_CONFIGURATION_LOCATION 
from BATCH_JOB_EXECUTION where JOB_INSTANCE_ID = ? order by JOB_EXECUTION_ID desc]
13:18:01.681 [main] DEBUG o.s.jdbc.core.JdbcTemplate - Executing prepared SQL query
13:18:01.681 [main] DEBUG o.s.jdbc.core.JdbcTemplate - Executing prepared SQL statement [SELECT JOB_EXECUTION_ID, KEY_NAME, TYPE_CD, STRING_VAL, DATE_VAL, 
LONG_VAL, DOUBLE_VAL, IDENTIFYING from BATCH_JOB_EXECUTION_PARAMS where JOB_EXECUTION_ID = ?]
13:18:01.682 [main] DEBUG o.s.jdbc.core.JdbcTemplate - Executing prepared SQL query
13:18:01.682 [main] DEBUG o.s.jdbc.core.JdbcTemplate - Executing prepared SQL statement [SELECT STEP_EXECUTION_ID, STEP_NAME, START_TIME, END_TIME, STATUS,
 COMMIT_COUNT, READ_COUNT, FILTER_COUNT, WRITE_COUNT, EXIT_CODE, EXIT_MESSAGE, READ_SKIP_COUNT, WRITE_SKIP_COUNT, PROCESS_SKIP_COUNT, 
ROLLBACK_COUNT, LAST_UPDATED, VERSION from BATCH_STEP_EXECUTION where JOB_EXECUTION_ID = ? order by STEP_EXECUTION_ID]
13:18:01.683 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Initiating transaction commit
13:18:01.684 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Creating new transaction with name [org.springframework.batch.core.repository.support.SimpleJobRepository.add]: 
PROPAGATION_REQUIRED,ISOLATION_DEFAULT
INSERT into BATCH_STEP_EXECUTION(STEP_EXECUTION_ID, VERSION, STEP_NAME, JOB_EXECUTION_ID, START_TIME, END_TIME, STATUS, COMMIT_COUNT, 
READ_COUNT, FILTER_COUNT, WRITE_COUNT, EXIT_CODE, EXIT_MESSAGE, READ_SKIP_COUNT, WRITE_SKIP_COUNT, PROCESS_SKIP_COUNT, ROLLBACK_COUNT, 
LAST_UPDATED) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)         
INSERT INTO BATCH_STEP_EXECUTION_CONTEXT (SHORT_CONTEXT, SERIALIZED_CONTEXT, STEP_EXECUTION_ID) VALUES(?, ?, ?)
13:18:01.708 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Initiating transaction commit
13:18:01.711 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Creating new transaction with name [org.springframework.batch.core.repository.support.SimpleJobRepository.update]: 
PROPAGATION_REQUIRED,ISOLATION_DEFAULT
UPDATE BATCH_STEP_EXECUTION set START_TIME = ?, END_TIME = ?, STATUS = ?, COMMIT_COUNT = ?, READ_COUNT = ?, FILTER_COUNT = ?, WRITE_COUNT = ?, 
EXIT_CODE = ?, EXIT_MESSAGE = ?, VERSION = ?, READ_SKIP_COUNT = ?, PROCESS_SKIP_COUNT = ?, WRITE_SKIP_COUNT = ?, ROLLBACK_COUNT = ?, LAST_UPDATED = ? 
where STEP_EXECUTION_ID = ? and VERSION = ?
SELECT VERSION FROM BATCH_JOB_EXECUTION WHERE JOB_EXECUTION_ID=?
13:18:01.733 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Initiating transaction commit
Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Converting (firstName: Robin, lastName: Varghese) into (firstName: ROBIN, lastName: VARGHESE)
Converting (firstName: Rohan, lastName: Naidu) into (firstName: ROHAN, lastName: NAIDU)
13:18:01.805 [main] DEBUG o.s.b.c.s.item.ChunkOrientedTasklet - Inputs not busy, ended: false
13:18:01.805 [main] DEBUG o.s.b.core.step.tasklet.TaskletStep - Applying contribution: [StepContribution: read=2, 

written=2, filtered=0, readSkips=0, writeSkips=0, 
processSkips=0, exitStatus=EXECUTING]
UPDATE BATCH_STEP_EXECUTION_CONTEXT SET SHORT_CONTEXT = ?, SERIALIZED_CONTEXT = ? WHERE STEP_EXECUTION_ID = ?
13:18:01.808 [main] DEBUG o.s.b.core.step.tasklet.TaskletStep - Saving step execution before commit: StepExecution: id=1, version=1, name=step1, status=STARTED, 
exitStatus=EXECUTING, readCount=2, filterCount=0, writeCount=2 readSkipCount=0, writeSkipCount=0, processSkipCount=0, commitCount=1, rollbackCount=0, exitDescription=1
UPDATE BATCH_STEP_EXECUTION set START_TIME = ?, END_TIME = ?, STATUS = ?, COMMIT_COUNT = ?, READ_COUNT = ?, FILTER_COUNT = ?, WRITE_COUNT = ?, 
EXIT_CODE = ?, EXIT_MESSAGE = ?, VERSION = ?, READ_SKIP_COUNT = ?, PROCESS_SKIP_COUNT = ?, WRITE_SKIP_COUNT = ?, ROLLBACK_COUNT = ?, LAST_UPDATED = ? 
where STEP_EXECUTION_ID = ? and VERSION = ?]
SELECT VERSION FROM BATCH_JOB_EXECUTION WHERE JOB_EXECUTION_ID=?
13:18:01.810 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Initiating transaction commit
13:18:01.814 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Converting (firstName: Roman, lastName: Barlan) into (firstName: ROMAN, lastName: BARLAN)
13:18:01.834 [main] DEBUG o.s.b.core.step.tasklet.TaskletStep - Applying contribution: [StepContribution: read=1, written=1, filtered=0, readSkips=0, writeSkips=0, processSkips=0, exitStatus=EXECUTING]
UPDATE BATCH_STEP_EXECUTION_CONTEXT SET SHORT_CONTEXT = ?, SERIALIZED_CONTEXT = ? WHERE STEP_EXECUTION_ID = ?
13:18:01.836 [main] DEBUG o.s.b.core.step.tasklet.TaskletStep - Saving step execution before commit: StepExecution: id=1, version=2, name=step1, status=STARTED, 
exitStatus=EXECUTING, readCount=3, filterCount=0, writeCount=3 readSkipCount=0, writeSkipCount=0, processSkipCount=0, commitCount=2, rollbackCount=0, exitDescription=
UPDATE BATCH_STEP_EXECUTION set START_TIME = ?, END_TIME = ?, STATUS = ?, COMMIT_COUNT = ?, READ_COUNT = ?, FILTER_COUNT = ?, 
WRITE_COUNT = ?, EXIT_CODE = ?, EXIT_MESSAGE = ?, VERSION = ?, READ_SKIP_COUNT = ?, PROCESS_SKIP_COUNT = ?, WRITE_SKIP_COUNT = ?, ROLLBACK_COUNT = ?, 
LAST_UPDATED = ? where STEP_EXECUTION_ID = ? and VERSION = ?
SELECT VERSION FROM BATCH_JOB_EXECUTION WHERE JOB_EXECUTION_ID=?
13:18:01.838 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Initiating transaction commit
UPDATE BATCH_STEP_EXECUTION_CONTEXT SET SHORT_CONTEXT = ?, SERIALIZED_CONTEXT = ? WHERE STEP_EXECUTION_ID = ?
13:18:01.861 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Initiating transaction commit
13:18:01.864 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Creating new transaction with name 
[org.springframework.batch.core.repository.support.SimpleJobRepository.update]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
UPDATE BATCH_STEP_EXECUTION set START_TIME = ?, END_TIME = ?, STATUS = ?, COMMIT_COUNT = ?, READ_COUNT = ?, FILTER_COUNT = ?, 
WRITE_COUNT = ?, EXIT_CODE = ?, EXIT_MESSAGE = ?, VERSION = ?, READ_SKIP_COUNT = ?, PROCESS_SKIP_COUNT = ?, WRITE_SKIP_COUNT = ?, 
ROLLBACK_COUNT = ?, LAST_UPDATED = ? where STEP_EXECUTION_ID = ? and VERSION = ?
SELECT VERSION FROM BATCH_JOB_EXECUTION WHERE JOB_EXECUTION_ID=?
13:18:01.886 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Initiating transaction commit
13:18:01.894 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Creating new transaction with name 
[org.springframework.batch.core.repository.support.SimpleJobRepository.updateExecutionContext]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
UPDATE BATCH_STEP_EXECUTION_CONTEXT SET SHORT_CONTEXT = ?, SERIALIZED_CONTEXT = ? WHERE STEP_EXECUTION_ID = ?
UPDATE BATCH_STEP_EXECUTION set START_TIME = ?, END_TIME = ?, STATUS = ?, COMMIT_COUNT = ?, READ_COUNT = ?, FILTER_COUNT = ?, 
WRITE_COUNT = ?, EXIT_CODE = ?, EXIT_MESSAGE = ?, VERSION = ?, READ_SKIP_COUNT = ?, PROCESS_SKIP_COUNT = ?, WRITE_SKIP_COUNT = ?, 
ROLLBACK_COUNT = ?, LAST_UPDATED = ? where STEP_EXECUTION_ID = ? and VERSION = ?
SELECT VERSION FROM BATCH_JOB_EXECUTION WHERE JOB_EXECUTION_ID=?
13:18:01.886 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Initiating transaction commit
13:18:01.894 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Creating new transaction with name 
[org.springframework.batch.core.repository.support.SimpleJobRepository.updateExecutionContext]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
UPDATE BATCH_JOB_EXECUTION_CONTEXT SET SHORT_CONTEXT = ?, SERIALIZED_CONTEXT = ? WHERE JOB_EXECUTION_ID = ?
13:18:01.919 [main] DEBUG o.s.j.d.DataSourceTransactionManager - Initiating transaction commit
...
13:18:01.923 [main] DEBUG o.s.b.c.job.flow.support.SimpleFlow - Completed state=reportJob.step1 with status=COMPLETED
13:18:01.923 [main] DEBUG o.s.b.c.job.flow.support.SimpleFlow - Handling state=reportJob.end1
13:18:01.923 [main] DEBUG o.s.b.c.job.flow.support.SimpleFlow - Completed state=reportJob.end1 with status=COMPLETED
SELECT VERSION FROM BATCH_JOB_EXECUTION WHERE JOB_EXECUTION_ID=?
SELECT COUNT FROM BATCH_JOB_EXECUTION WHERE JOB_EXECUTION_ID = ?
UPDATE BATCH_JOB_EXECUTION set START_TIME = ?, END_TIME = ?,  STATUS = ?, EXIT_CODE = ?, EXIT_MESSAGE = ?, VERSION = ?, CREATE_TIME = ?, 
LAST_UPDATED = ? where JOB_EXECUTION_ID = ? and VERSION = ?
...
13:18:01.948 [main] INFO  o.s.b.c.l.support.SimpleJobLauncher - Job: [FlowJob: [name=reportJob]] 

completed with the following parameters: [{}] and the following status: [COMPLETED]
Exit Status : COMPLETED
Found <firstName: ROBIN, lastName: VARGHESE> in the result.
Found <firstName: ROHAN, lastName: NAIDU> in the result.
Found <firstName: ROMAN, lastName: BARLAN> in the result.
...
Done

public void someMethod() {
List<User> users = getListOfUsers();// some complex code
//Need to sort this List by age ofusers
      users.sort(new Comparator<User>() {

         @Override
publicint compare(User u1, User u2) {
returnInteger.compare(u1.getAge(), u2.getAge());
         }
      });
//Continue processing the sorted list
   }

1. Functional programming involves code that is stateless (Think of HTTP and REST)
2. Functional programming works with immutable data.

@FunctionalInterface
publicinterface Comparator<T> {

public void someMethod() {
List<User> users = getListOfUsers();// some complex code
// Need to sort this List by age ofusers
      users.sort(Comparator.comparing(user -> user.getAge()));
// Continue processing the sorted list
   }

 

 users.sort(Comparator.comparing(User::getAge));

for (User user : users){
System.out.println(user.getName() + " of age "
            + user.getAge() + " has a salary of " + user.getSalary());
}

users.forEach(user -> System.out
            .println(user.getName() + " of age " + user.getAge() 
                        + " has a salary of " + user.getSalary()));

 Represents an operation that accepts a single input argument and returns no
 result. Unlike most other functional interfaces, Consumer is expected
 to operate via side-effects.

      Set<User> highIncomeUsers = new HashSet<>();
      users.forEach(user -> {
if (user.getSalary() > 3000) {
            highIncomeUsers.add(user);
         } else {
System.out.println(user.getName() + " with salary of "
                                   + user.getSalary() + " was skipped");
         }
      });
System.out.println("HIGH INCOME USERS");
      highIncomeUsers.forEach(user->System.out.println(user.getName() 
                                         + " with salary of " + user.getSalary()));

      Set<User> highIncomeUsers = new HashSet<>();
      Consumer<User> highIncomeUserCollector = (user) -> {
if (user.getSalary() > 3000) {
            highIncomeUsers.add(user);
         } else {
System.out.println(user.getName() + " with salary of "
                                 + user.getSalary() + " was skipped");
         }
      };
      highIncomeUserCollector.accept(users.get(0));

publicclass Ticket {

privatestaticint counter = 0;

public Ticket() {
      counter++;
   }

publicstatic Ticket getSpecialTicket() {
// some processing needed to get ticket
      counter++;

      returnnew Ticket();
   }

publicstaticint getTicketCount() {
return counter;
   }

   @Override
publicString toString() {
return"T[" + this.hashCode() +"]";
   }
}

publicstatic void performOperation(){
//get details of operation
//generate a ticket
      Ticket ticket = new Ticket();
//use the ticket instance to perform operation
System.out.println("Ticket " + ticket + " used for operation");
   }

publicstatic void performOperation(Supplier<? extends Ticket> ticketSupplier) {
// get details of operation
// generate a ticket
      Ticket ticket1 = ticketSupplier.get();
// use the ticket instance to perform operation
System.out.println("Ticket " + ticket1 + " used for operation");
//using the second ticket for 
      Ticket ticket2 = ticketSupplier.get();
// use the ticket instance to perform operation
System.out.println("Ticket " + ticket2 + " used for operation");
   }

Represents a supplier of results. 
There is no requirement that a new or distinct result be returned each time the supplier is invoked. 
This is a functional interface whose functional method is get().

publicstatic void main(String[] args) {
performOperation(Ticket::new);
   }

publicstatic void main(String[] args) {
//      performOperation(Ticket::new);
performOperation(Ticket::getSpecialTicket);
   }

Ticket T[617901222] used for operation
Ticket T[1159190947] used for operation

performOperation(()->new Ticket());
performOperation(()-> getSpecialTicket());

• Pure Interface looks so much clean.
• Interface ensures you do not fall to Java's Single Inheritance restriction.
• Contracts should say what and not how - making it an ideal use case for an interface.

• What if I want to provide a default implementation for some methods ?
• I don't like my data objects hierarchy starting with an interface. I prefer a class at the base.
• I don't foresee any use case requiring a second class to be extended by my classes.
• What if I wanted to force all my implementations to use a certain implementation for one of the contracts.
• With abstract classes at the base, it is easy to add a new method with a default implementation. This will ensure that all sub classes that do not care for this method don't break, while the affected ones can go ahead and override.

• Define all the services, Business objects behind interfaces.
• Where there was the possibility (genuine) of some class hierarchies having common code, setup an abstract class, and move the common code there - something I have often seen in web controllers and earlier in servlets ( remember the pre - framework days).
• If needed the design would have a combination of both - a pure interface that defined all the contracts and abstract classes that provided default implementations where possible.

An abstract class is a class that is declared abstract—it may or may not include 
abstract methods. Abstract classes cannot be instantiated, but they can be 
subclassed.

Abstract classes are similar to interfaces. You cannot instantiate them, and they may 
contain a mix of methods declared with or without an implementation. However, with 
abstract classes, you can declare fields that are not static and final, and define public, 
protected, and private concrete methods. With interfaces, all fields are automatically public, 
static, and final, and all methods that you declare or define (as default methods) are public.
In addition, you can extend only one class, whether or not it is abstract, whereas you can 
implement any number of interfaces.

Consider using abstract classes if any of these statements apply to your situation:
    -> You want to share code among several closely related classes.
    -> You expect that classes that extend your abstract class have many common methods 
       or fields, or require access modifiers other than public (such as protected and private).
    -> You want to declare non-static or non-final fields. This enables you to define methods
       that can access and modify the state of the object to which they belong.

Consider using interfaces if any of these statements apply to your situation:
    -> You expect that unrelated classes would implement your interface. For example, 
       the interfaces Comparable and Cloneable are implemented by many unrelated classes.
    -> You want to specify the behavior of a particular data type, but not concerned about who 
       implements its behavior.
    -> You want to take advantage of multiple inheritance of type.

An example of an abstract class in the JDK is AbstractMap, which is part of the 
Collections Framework. 
Its subclasses (which include HashMap, TreeMap, and ConcurrentHashMap) share many methods 
(including get, put, isEmpty, containsKey, and containsValue) that AbstractMap defines.
An example of a class in the JDK that implements several interfaces is HashMap, which 
implements the interfaces Serializable, Cloneable, and Map<K, V>. By reading this 
list of interfaces, you can infer that an instance of HashMap (regardless of the developer 
or company who implemented the class) can be cloned, is serializable (which means that it 
can be converted into a byte stream; see the section Serializable Objects), and has the 
functionality of a map. In addition, the Map<K, V> interface has been enhanced 
with many default methods such as merge and forEach that older classes that have implemented this 
interface do not have to define.

Note that many software libraries use both abstract classes and interfaces; the HashMap class implements 
several interfaces and also extends the abstract class AbstractMap.

interface Contract {
publicvoid method1();
publicvoid commonMethod();
}

abstractclass ContractBase implements Contract {

   @Override
publicvoid commonMethod() {

   }
}

class ContractImpl extends ContractBase {

   @Override
publicvoid method1() {
   }

}

interface Contract {
publicvoid method1();

defaultpublicvoid commonMethod() {
//the common code here
   }
}

class ContractImpl implements Contract {//extends ContractBase {

   @Override
publicvoid method1() {

   }

}

default methods enable you to add new functionality to the interfaces of your libraries and 
ensure binary compatibility with code written for older versions of those interfaces.

interface Contract {
publicvoid method1();

defaultpublicvoid commonMethod() {
//the common code here
   }

staticvoid utilityMethod() {
//This is simply an utility method - implicit public method
   }
}

This makes it easier for you to organize helper methods in your libraries; you can keep 
static methods specific to an interface in the same interface rather than in a separate class.

publicclass User {

privateString name;
privateint age;
privatedouble salary;
//setter getters
}

publicstatic boolean isEligibleToVote(User user) {
return user.getAge() > 18;
   }

   staticPredicate<User> userEligibleToVote = user -> user.getAge() > 18;

publicstatic boolean isEligibleToVote(User user) {
returnuserEligibleToVote.test(user);
   }

static Predicate<User> userEligibleToVote = user -> user.getAge() > 18;
static Predicate<User> userNotEligibleToVote = userEligibleToVote.negate();

static Predicate<User> unemployedUser = user -> user.salary <= 0;

static Predicate<User> unemployedVoter = userEligibleToVote.and(unemployedUser);
static Predicate<User> unemployedOrVoter = userEligibleToVote.or(unemployedUser);

public void testRemoveIf(List<User> users) {
int testAge = 24;
System.out.println("Number of users : " + users.size());
      users.removeIf(user -> user.getAge() > testAge);
System.out.println("Number of users with age < " + testAge + " : " + users.size());
   }

users.sort(Comparator.comparing(User::getAge));

publicstatic void main(String[] args) {      
Function<Ticket, String> ticketKeyValFn = ticket -> ticket.toString();
      Map<Ticket, String> ticketMap = new HashMap<>();
      ticketMap.put(getSpecialTicket(), "For Purchase Operation");
      Ticket ticket = new Ticket();
//this ticket is not in map
System.out.println("Map contains ticket " + ticket + " ? " + ticketMap.containsKey(ticket));
ticketMap.computeIfAbsent(ticket, ticketKeyValFn);
//now ticket is in map
System.out.println("Map contains ticket " + ticket + " ? " + ticketMap.containsKey(ticket));

   }

Map contains ticket T[1159190947] ? false
Map contains ticket T[1159190947] ? true

String value = ticketKeyValFn.apply(new Ticket());

Ticket ticket = new Ticket();

//This is the before function
Function<Ticket, String> ticketKeyValFn = ticketInstance -> ticketInstance.toString();
String sampleOpt = ticketKeyValFn.apply(ticket);
System.out.println("Output of first function is " + sampleOpt);

Function<String, Long> cleanTicketValFn = inp -> Long.valueOf(inp.substring(2,inp.length()-1));
Long no = cleanTicketValFn.apply(sampleOpt);
System.out.println("Output of second function is " + no);

//If using composites
//cleanTicketValFn = the one that executes last - gets a string and returns a Long
Function<Ticket, Long> compositeFn = cleanTicketValFn.compose(ticketKeyValFn);
System.out.println("The ticket Id is " + compositeFn.apply(ticket));

Output of first function is T[617901222]
Output of second function is 617901222
The ticket Id is 617901222

Function<String, Long> toLongFunction = string -> Long.valueOf(string);
Function<Long, Integer> toIntegerCutoffFunction = longVal -> longVal.intValue();
//Now combine the two
Function<String, Integer> compositeFunction = toLongFunction.andThen(toIntegerCutoffFunction);
// Test call
System.out.println(compositeFunction.apply("1234"));

publicstatic void testSingleType() {
String testInp = "Hello";
      Function<String, String> splitter = inp -> inp.substring(inp.length() / 2);
System.out.println(splitter.apply(testInp));// will print 'llo'
   }

Represents an operation on a single operand that produces a result of the
same type as its operand.  This is a specialization of Function for
the case where the operand and result are of the same type.

publicstatic void testSingleType() {
String testInp = "Hello";     
UnaryOperator<String> unaryStyleSplitter = inp -> inp.substring(inp.length() / 2);
System.out.println(unaryStyleSplitter.apply(testInp));// will print 'llo'
   }

BiFunction<String, Character, Long> cleanNumber = (value, character) 

-> Long.valueOf(value.replaceAll(character+"", ""));
System.out.println(cleanNumber.apply("123#45#12", '#'));
//will print 1234512

BiPredicate<Integer, String> isEqual = (no, str) -> (no + "").equals(str);
System.out.println("Is True ? " + isEqual.test(45, "45.06"));

BinaryOperator<String> appendOperator = (a1, a2) -> a1 + "" + a2;
System.out.println("Strings " + "Hi &" + " Robin "
   + "on combining results in "
   + appendOperator.apply("Hi", "Robin"));

Comparator<Ticket> ticketComparator = Comparator.comparing(t -> t.toString());
BinaryOperator<Ticket> maxOperator = BinaryOperator.maxBy(ticketComparator);
BinaryOperator<Ticket> minOperator = BinaryOperator.minBy(ticketComparator);
Ticket t1 = new Ticket();
Ticket t2 = new Ticket();
System.out.println("T1 is " + t1 + " and T2 is "+ t2);
System.out.println("The max of two tickets is " + maxOperator.apply(t1, t2));
System.out.println("The min of two tickets is " + minOperator.apply(t1, t2));

T1 is T[1804094807] and T2 is T[951007336]
The max of two tickets is T[951007336]
The min of two tickets is T[1804094807]

{
Map<Ticket, String> ticketMap = new HashMap<>();
BiConsumer<Ticket, String> mapAdder = (ticket, opName) -> {
   ticketMap.put(ticket, opName);
};
mapAdder.accept(t1, "This is for Entry");
mapAdder.accept(t2, "This is for Exit");
System.out.println("No of entries in map are " + ticketMap.size()); //returns 2

interface A {
defaultString display(String s) {
return s.toLowerCase()+"__";
   }
}

interface B extends A {
defaultString display(String s) {
return s.toLowerCase()+"%%";
   }
}

publicstatic void main(String[] args) {
System.out.println(new C(){}.display("HELLO"));
}

interface C extends B {
//which version will display() execute ?
}

hello%%

interface A {
defaultString display(String s) {
return s.toLowerCase()+"__";
   }
}

interface B  {
defaultString display(String s) {
return s.toLowerCase()+"%%";
   }
}

interface C extends A, B {
//which version will display() execute ?
}

Duplicate default methods named display with the parameters (String) and (String) 
are inherited from the types B and A

interface C extends A, B {

   @Override
defaultString display(String s) {
returnA.super.display(s);
   }
}

hello__

BooleanSupplier booleanSupplier = () -> Boolean.FALSE;
// will always return the value as false
System.out.println(booleanSupplier.getAsBoolean());
DoubleBinaryOperator sumDouble = (a, b) -> (a + b);
System.out.println(2.56 + " + " + 13.45 + " = " + sumDouble.applyAsDouble(2.56, 13.45));
final int[] val = new int[1];
IntConsumer numberSink = num -> val[0] = num;
numberSink.accept(1); // val[1] = 1
numberSink.accept(2);// val[1] = 2
numberSink.accept(3);// val[1] = 3
LongFunction<String> longToString = l -> l + "";
System.out.println(longToString.apply(189L));
LongPredicate longPredicate = l -> l != 0;
System.out.println("A non zero number ? " + longPredicate.test(134l));

false
2.56 + 13.45 = 16.009999999999998
189
A non zero number ? true

1. There is a BooleanSupplier class that supplies boolean values. We also have int,long and double versions of the same.
2. There is a DoubleBinaryOperator that is summing two double primitives. We also have int and long versions of the same.
3. We created an IntConsumer which simply consumes all passed int values. I also observed a double and long version of the class.
4. We used a LongFunction that takes as input long value and transforms it into a different type. We have double and int versions of it.
5. Last I created a LongPredicate that is used to run tests on long values. We also have int and double versions of these.

DoubleToIntFunction dblToIntFunction1 = l -> ((int)(l*100)) +2;
DoubleToIntFunction dblToIntFunction2 = l -> ((int)(l)*100) +2;
System.out.println(dblToIntFunction1.applyAsInt(10.98));//1100
System.out.println(dblToIntFunction2.applyAsInt(10.98));//1002

IntUnaryOperator intSquarer = i -> i * i;
System.out.println("Square of 10 is " + intSquarer.applyAsInt(10)); // 100

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

ObjIntConsumer<String> inserter = (term, times) -> 
 {
for (int i = 0; i < times; i++) {
   contents.add(term);
  }
 };
inserter.accept("Test", 3);// add the string 3 times to the list
ToIntBiFunction<String, Short> computeLength = (str, shortNo) -> str.length() + shortNo;
System.out.println("The value is " + computeLength.applyAsInt("Hello ", newShort((short) 25)));

1. The IntUnaryOperator will be used to apply a transformation on an int value to return an int value. 
2. The ObjIntConsumer consumes a Object and a primitive int value. Similary there are ObjDoubleConsumer and ObjLongConsumer for double and long primitive values respectively.
3. The BiFunction interface has also got an int, long and double variotion where the function transforms the input arguments into primitive values.

publicclass Fruit {

privateString name;
privateString color;
privateint cost;

  @Override
publicint hashCode() {
finalint prime = 31;
int result = 1;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
  }

  @Override
publicboolean equals(Object obj) {
if (this == obj)
returntrue;
if (obj == null)
returnfalse;
if (getClass() != obj.getClass())
returnfalse;
    Fruit other = (Fruit) obj;
if (name == null) {
if (other.name != null)
returnfalse;
    } elseif (!name.equals(other.name))
returnfalse;
returntrue;
  }

// setter getters here 
}

publicstatic void main(String[] args) {
    Set<Fruit> fruitBasket = new HashSet<>();
//Stage 1----------
    fruitBasket.add(new Fruit("Apple", "green", 3));
    fruitBasket.add(new Fruit("Watermelon", "green", 11));

//Stage 2-------------------
//replace a green apple by a red one
    fruitBasket.add(new Fruit("Apple", "red", 3));
    fruitBasket.add(new Fruit("Mango", "yellow", 5));

//Final Display
System.out.println("The fruits in the basket are");
for (Fruit fruit : fruitBasket) {
System.out.println(fruit.getColor() + " colored " +  fruit.getName() + " costs " + fruit.getCost());
    }

  }

The fruits in the basket are
green colored Apple costs 3
green colored Watermelon costs 11
yellow colored Mango costs 5

public boolean add(E e) {
return map.put(e, PRESENT)==null;
    }

Adds the specified element to this set if it is not already present (optional operation).
More formally, adds the specified element e to this set if the set contains no element 
e2 such that (e==null ? e2==null : e.equals(e2)). If this set already contains the 
element, the call leaves the set unchanged and returns false.

publicstatic void main(String[] args) {
    Set<Fruit> fruitBasket = new HashSet<>();
//Stage 1----------


//fruitBasket.add(new Fruit("Apple", "green", 3));
    add(fruitBasket, new Fruit("Apple", "green", 3));
//fruitBasket.add(new Fruit("Watermelon", "green", 11));
    add(fruitBasket, new Fruit("Watermelon", "green", 11));
//Stage 2-------------------
//replace a green apple by a red one
// fruitBasket.add(new Fruit("Apple", "red", 3));
    add(fruitBasket, new Fruit("Apple", "red", 3));
//    fruitBasket.add(new Fruit("Mango", "yellow", 5));
    add(fruitBasket, new Fruit("Mango", "yellow", 5));
//Final Display
System.out.println("The fruits in the basket are");
for (Fruit fruit : fruitBasket) {
System.out.println(fruit.getColor() + " colored " +  fruit.getName() + " costs " + fruit.getCost());
    }    
  }

publicstatic void add(Set<Fruit> fruitBasket, Fruit crtFruit) {
if(fruitBasket.contains(crtFruit)) {
  fruitBasket.remove(crtFruit);
}

    fruitBasket.add(crtFruit);
  }

The fruits in the basket are
red colored Apple costs 3
green colored Watermelon costs 11
yellow colored Mango costs 5

publicclass SimpleFilter implements Filter {

  @Override
publicvoid init(FilterConfig arg0) throws ServletException {
System.out.println("SimpleFilter initialized");
  }

  @Override
publicvoid doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
throwsIOException, ServletException {
String requestUrl = ((HttpServletRequest) servletRequest).getRequestURL().toString();
System.out.println("url trapped in SimpleFilter " + requestUrl);
    filterChain.doFilter(servletRequest, servletResponse);
return;

  }

  @Override
publicvoid destroy() {
System.out.println("SimpleFilter destroyed");
  }
}

<?xmlversion="1.0"encoding="UTF-8"?>
<web-fragmentxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 xmlns:webfragment="http://java.sun.com/xml/ns/javaee/web-fragment_3_0.xsd"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
 http://java.sun.com/xml/ns/javaee/web-fragment_3_0.xsd"
 id="SimpleFilterWebFragment" version="3.0">

<filter>
<filter-name>SimpleFilter</filter-name>
<filter-class>com.simple.SimpleFilter</filter-class>
</filter>

<filter-mapping>
<filter-name>SimpleFilter</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping>

</web-fragment>

The jar structure

publicclass LocalFilter implements Filter {

  @Override
publicvoid init(FilterConfig arg0) throws ServletException {
System.out.println("LocalFilter initialized");
  }

  @Override
publicvoid doFilter(ServletRequest servletRequest, ServletResponse servletResponse, 
      FilterChain filterChain) throwsIOException, ServletException {
String requestUrl = ((HttpServletRequest) servletRequest).getRequestURL().toString();
System.out.println("url trapped in LocalFilter " + requestUrl);
    filterChain.doFilter(servletRequest, servletResponse);
return;

  }

  @Override
publicvoid destroy() {
System.out.println("LocalFilter destroyed");
  }
}

1. SimpleFilter - This filter is placed within the jar and loads based on the web-fragment.
2. LocalFilter - This filter is defined in the web app and loads based on the web.xml

LocalFilter initialized
SimpleFilter initialized
INFO: Server startup in 1076 ms

url trapped in LocalFilter http://localhost:8080/WebFragments/index.jsp
url trapped in SimpleFilter http://localhost:8080/WebFragments/index.jsp