The default folder for external .jar files in a local project is ./lib.

On a server, external .jar files can also be placed on the classpath of the application container.

You should add the .jar files to classpath. Open Project Properties dialog Project → Properties. Switch to Java Build Path → Libraries. Click Add JARs... and select the .jar files.

All .java and .class files should reside in a shared sandbox.

If you click the Algorithm attribute value, a dialog for editing of build-in java code opens. Use the Switch to Java editor button to convert the transformation in Java to a .java file. The file is opened as a new tab having Java editor with syntax highlighting associated.

Transformation required by the component must extend the org.jetel.component.AbstractGenericTransform class.

Following are methods of the AbstractGenericTransform class:

One single record is represented by the DataRecord class.

DataRecord record;

To create a data record not connected to any particular port, use the static method newRecord() of DataRecordFactory. It requires record metadata.

String metadataId = getGraph().getDataRecordMetadataByName("recordName1");
DataRecordMetadata metadata = getGraph().getDataRecordMetadata(metadataId);
DataRecord record = DataRecordFactory.newRecord(metadata);

To read a record from the input port, use readRecordFromPort() function. The index of the input port (starting from 0) is specified in the parameter of the function.

record = readRecordFromPort(0);

The function returns null if no other records are available.

while ((record = readRecordFromPort(0)) != null) {
    // Do something
}

To write a record to the output port, use the writeRecordToPort() function. Parameters define the index of the output port and record to be written.

writeRecordToPort(0, record);

If you create a component with a variable number of the input or output ports, use

getComponent().getInputPortsMaxIndex()

or

getComponent().getOutputPortsMaxIndex()

to get the maximal index of input or output ports.

Note that the first input port has index 0. A component with N input ports has N-1 as the maximal index of input port.

Data field is represented by the DataField class. You can get fields of data record using getFields() of DataRecord. You can get a particular field using getField() taking the field index or field name as a parameter.

DataRecord record;
DataField dataField1;
dataField1 = record.getField(0);
DataField dataField2;
dataField2 = record.getField("field2");

Use getValue() and setValue() methods of DataField to work with field values.

DataField field = record.getField(0);
String value = field.getValue();
field.setValue("some new value");

There are two classes necessary to work with metadata: DataRecordMetadata and DataFieldMetadata. DataRecordMetadata represents metadata of the whole record whereas DataFieldMetadata represents metadata of particular field.

Use getMetadata() method of DataRecord to get access to metadata of a record.

DataRecord record;
record = ...
DataRecordMetadata metadata = record.getMetadata();

Use getMetadata() method of DataField to get access to metadata of a field.

DataField dataField;
dataField = ...
DataFieldMetadata fieldMetadata = dataField.getMetadata();

To use metadata depending on its name, use getDataRecordMetadataByName() to get metadata id and subsequently use getDataRecordMetadata() to get metadata corresponding to the id.

String metadataId = getGraph().getDataRecordMetadataByName("recordName1");
DataRecordMetadata metadata = getGraph().getDataRecordMetadata(metadataId);

To read a value from a dictionary, use the getValue() function, to write to a dictionary use the setValue() function:

Dictionary dictionary = getGraph().getDictionary();
dictionary.setValue("mykey1", "NewValue");
String s = dictionary.getValue("mykey2");

The LookupTable interface gives you an access to lookup tables. Use put() to insert a data record into an existing lookup table. Note that getLookupTable() requires lookup table ID. The parameter is not the lookup table name!

LookupTable lookup = getGraph().getLookupTable("LookupTable0");
DataRecord record = ...;
lookup.put(record);

Use createLookup() to search for items matching the key.

LookupTable lt;
lt = ...

DataRecord patternRecord = DataRecordFactory.newRecord(lt.getMetadata());
patternRecord.getField(0).setValue("keyToBeSearchedPart1");
patternRecord.getField(2).setValue("keyToBeSearchedPart2");
String [] lookupFields = {"field1", "field3"};
RecordKey recordKey = new RecordKey(lookupFields, lt.getMetadata());
Lookup lookup;
lookup = lt.createLookup(recordKey, patternRecord);
lookup.seek();

while (lookup.hasNext()){
    DataRecord record = lookup.next();
    // process the result found
    writeRecordToPort(0, record);
}

Graph parameters can be obtained from TransformationGraph using getGraphParameters(). To get a particular parameter use getGraphParameter() with the parameter name.

TransformationGraph graph = getGraph();
GraphParameters graphParameters = graph.getGraphParameters();
GraphParameter graphParameter = graphParameters.getGraphParameter("MY_PARAMETER");

Use getValue() or getValueResolved() to get the parameter value.

String value = graphParameter.getValue();
String valueResolved = graphParameter.getValueResolved(RefResFlag.REGULAR);

You can get a value of component attributes using the getProperty() functions applied on TypedProperties.

String myStringValue = getProperties().getStringProperty("myCustomPropertyName1");

Integer myIntegerValue = getProperties().getIntProperty("myCustomPropertyName2");

A sequence is accessible from TransformationGraph via the getSequence() function with the sequence ID as a parameter.

Sequence seq = getGraph().getSequence("Sequence0");

Use nextValueInt(), nextValueLong() or nextValueString() to increment the sequence and return the incremented value. A first call of any of the nextValue*() functions initializes the sequence to the initial sequence value and returns an unincremented initial value.

String sequenceValue = seq.nextValueString();
int sequenceValueInt = seq.nextValueInt();
long sequenceValueLong = seq.nextValueLong();

To get the last value returned by functions above use currentValueInt() currentValueLong() or currentValueString(). If none of the nextValue*() functions have been called before, the current value is the start value of the sequence.

String sequenceValue = seq.currentValueString();
int sequenceValueInt = seq.currentValueInt();
long sequenceValueLong = seq.currentValueLong();

Database connections are accessible via the getDBConnection() method of AbstractGenericTransform. The method requires connection name or connection ID as a parameter.

Connection connection = getDBConnection("myUniqueID");

The getDBConnection(String) method is available since 4.7.0-M2. The access to database connection in earlier versions was different.

If you work with paths, use the getFile() function to resolve the path correctly.

String param = getProperties().getStringProperty("InputFile");
File file = getFile(param);

You can access files via streams. Use getOutputStream() or getInputStream();

String param = getProperties().getStringProperty("InputFile");
InputStream is = getInputStream(param);

String param = getProperties().getStringProperty("OutputFile");
OutputStream os = getOutputStream(param, true);

Use the log() function to log messages of important events of your Java-defined transformation.

getLogger().log(Level.INFO, "Some message" );

Create a component removing empty directories.

package jk;

import java.io.File;

import org.jetel.component.AbstractGenericTransform;

/**
 * This is an example custom component. It shows how you can remove empty
 * directories.
 */
public class CustomJavaComponentExample01 extends AbstractGenericTransform {

    private void removeEmptyDirectories(File dir) {
        if (!dir.isDirectory() || !dir.canRead() || !dir.canWrite()) {
        return;
        }

        for (File f : dir.listFiles()) {
            if (f.isDirectory()) {
                removeEmptyDirectories(f);
                if (f.listFiles().length == 0) {
                f.delete();
                }
            }
        }
    }

    @Override
    public void execute() {
        String directory = getProperties().getStringProperty("Directory");
        File dir = getFile(directory);
        removeEmptyDirectories(dir);
    }

}

The component has to have one input port and one output port connected. Each port should have metadata assigned. The component has the attribute Multiplier having integral value.

@Override
public ConfigurationStatus checkConfig(ConfigurationStatus status) {
    super.checkConfig(status);

    if (getComponent().getInPorts().size() != 1 || getComponent().getOutPorts().size() != 1) {
        status.add("One input and one output port must be connected!", Severity.ERROR, getComponent(), Priority.NORMAL);
        return status;
    }

    DataRecordMetadata inMetadata = getComponent().getInputPort(0).getMetadata();
    DataRecordMetadata outMetadata = getComponent().getOutputPort(0).getMetadata();
    if (inMetadata == null || outMetadata == null) {
        status.add("Metadata on input or output port not specified!", Severity.ERROR, getComponent(), Priority.NORMAL);
    }

    if (!getProperties().containsKey("Multiplier")) {
        status.add("Multiplier property is missing or is not set.", Severity.ERROR, getComponent(), Priority.NORMAL, "Multiplier");
        return status;
    }

    try {
        Integer.parseInt(getProperties().getStringProperty("Multiplier"));
    } catch(Exception e){
        status.add("Multiplier is not integer!", Severity.ERROR, getComponent(), Priority.NORMAL, "Multiplier");
    }

    return status;
}