EntityPersistTransformer (stumps 1.0-SNAPSHOT API)

java.lang.Object
- com.neurosys.modules.etl.EntityPersistTransformer<E>

Type Parameters:

E - of Entity type

All Implemented Interfaces:

FailFastAware, RealTimeWriter<E>, Writer, org.apache.commons.collections.Transformer

Direct Known Subclasses:

AreaPersistTransformer, EntityBabyPersistTransformer, ProductPersistTransformer, RelatedEntityPersistTransformer
```
public class EntityPersistTransformer<E>
extends Object
implements org.apache.commons.collections.Transformer, RealTimeWriter<E>, FailFastAware
```
Persist an Entity and return the Persisted Entity using the auto wired EntityManager.
Additionally this Transformer is capable of:
- Collecting Exceptions in exceptions and messages if failFast is false
- Persisting the entity under a TransactionDefinition, if provided via setTransactionDef(TransactionDefinition). It uses the autowired PlatformTransactionManager for this
Author:

Arjun Dhar

See Also:

RealTimeWriter, FailFastAware

Field Summary

Fields
Modifier and Type	Field and Description
`protected javax.persistence.EntityManager`	`em`
`protected Collection<Throwable>`	`exceptions`
`protected boolean`	`failFast`
`protected Collection<String>`	`messages`
`protected org.springframework.transaction.PlatformTransactionManager`	`tm`

Constructor Summary

Constructors
Constructor and Description

EntityPersistTransformer()

Constructors
Constructor and Description
`EntityPersistTransformer()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`close()` Any cleanup
`Collection<Throwable>`	`getExceptions()` If not in fail fast mode, will collect the exceptions and we can always query the exceptions
`Collection<String>`	`getMessages()` Any updates/messages that are not Error like
`org.springframework.transaction.TransactionDefinition`	`getTransactionDef()`
`protected E`	`handleException(RuntimeException e)`
`void`	`init()`
`boolean`	`isExecuteUnderTransaction()` If true, will execute persist under 1 transaction and will apply `transactionDef`.
`boolean`	`isFailFast()` If true will exit on first exception else will collect exceptions
`boolean`	`isInitialized()` Check if Writer is already Initialized
`void`	`setExceptions(Collection<Throwable> exceptions)`
`void`	`setExecuteUnderTransaction(boolean executeUnderTransaction)` If true, will execute persist under 1 transaction and will apply `transactionDef`.
`void`	`setFailFast(boolean failFast)` If true will exit on first exception else will collect exceptions
`void`	`setMessages(Collection<String> messages)`
`void`	`setTransactionDef(org.springframework.transaction.TransactionDefinition transactionDef)`
`Object`	`transform(Object input)`
`Collection<E>`	`write(Collection<E> input)` Write a Buffer of records at a given time.
`E`	`write(E record)` Write a record

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - failFast
```
protected boolean failFast
```
  - exceptions
```
protected Collection<Throwable> exceptions
```
  - messages
```
protected Collection<String> messages
```
  - tm
```
@Autowired
protected org.springframework.transaction.PlatformTransactionManager tm
```
  - em
```
protected javax.persistence.EntityManager em
```
- Constructor Detail
  - EntityPersistTransformer
```
public EntityPersistTransformer()
```
- Method Detail
  - init
```
public void init()
```
  - handleException
```
protected E handleException(RuntimeException e)
```
  - write
```
public Collection<E> write(Collection<E> input)
```
    Description copied from interface: RealTimeWriter
    
    Write a Buffer of records at a given time. Multiple write() may be called in sequence to append to end Sink/File.
    
    Specified by:
    
    write in interface RealTimeWriter<E>
    
    Parameters:
    
    input - as Collection of records to be written to sink.
  - write
```
public E write(E record)
```
    Description copied from interface: RealTimeWriter
    
    Write a record
    
    Specified by:
    
    write in interface RealTimeWriter<E>
  - transform
```
public Object transform(Object input)
```
    Specified by:
    
    transform in interface org.apache.commons.collections.Transformer
  - setFailFast
```
public void setFailFast(boolean failFast)
```
    Description copied from interface: FailFastAware
    
    If true will exit on first exception else will collect exceptions
    
    Specified by:
    
    setFailFast in interface FailFastAware
  - isFailFast
```
public boolean isFailFast()
```
    Description copied from interface: FailFastAware
    
    If true will exit on first exception else will collect exceptions
    
    Specified by:
    
    isFailFast in interface FailFastAware
  - getExceptions
```
public Collection<Throwable> getExceptions()
```
    Description copied from interface: FailFastAware
    
    If not in fail fast mode, will collect the exceptions and we can always query the exceptions
    
    Specified by:
    
    getExceptions in interface FailFastAware
    
    Returns:
  - setExceptions
```
public void setExceptions(Collection<Throwable> exceptions)
```
    Specified by:
    
    setExceptions in interface FailFastAware
  - getMessages
```
public Collection<String> getMessages()
```
    Description copied from interface: FailFastAware
    
    Any updates/messages that are not Error like
    
    Specified by:
    
    getMessages in interface FailFastAware
    
    Returns:
  - setMessages
```
public void setMessages(Collection<String> messages)
```
    Specified by:
    
    setMessages in interface FailFastAware
  - getTransactionDef
```
public org.springframework.transaction.TransactionDefinition getTransactionDef()
```
    See Also:
    
    executeUnderTransaction
  - setTransactionDef
```
public void setTransactionDef(org.springframework.transaction.TransactionDefinition transactionDef)
```
    See Also:
    
    executeUnderTransaction
  - close
```
public void close()
           throws Exception
```
    Description copied from interface: RealTimeWriter
    
    Any cleanup
    
    Specified by:
    
    close in interface RealTimeWriter<E>
    
    Throws:
    
    Exception
  - isInitialized
```
public boolean isInitialized()
```
    Description copied from interface: RealTimeWriter
    
    Check if Writer is already Initialized
    
    Specified by:
    
    isInitialized in interface RealTimeWriter<E>
    
    Returns:
  - isExecuteUnderTransaction
```
public boolean isExecuteUnderTransaction()
```
    If true, will execute persist under 1 transaction and will apply transactionDef.
    If multiple entities are involved then keep false.
    
    See Also:
    
    transactionDef
    
    Default value:
    
    false
  - setExecuteUnderTransaction
```
public void setExecuteUnderTransaction(boolean executeUnderTransaction)
```
    If true, will execute persist under 1 transaction and will apply transactionDef.
    If multiple entities are involved then keep false.
    
    See Also:
    
    transactionDef
    
    Default value:
    
    false

Class EntityPersistTransformer<E>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

failFast

exceptions

messages

tm

em

Constructor Detail

EntityPersistTransformer

Method Detail

init

handleException

write

write

transform

setFailFast

isFailFast

getExceptions

setExceptions

getMessages

setMessages

getTransactionDef

setTransactionDef

close

isInitialized

isExecuteUnderTransaction

setExecuteUnderTransaction