What's New in Intershop Studio 4.3.3

Product Version


Product To Version




1 Introduction

Main novelties of the Intershop Studio 4.3.3 are a better pipeline and pipelet management.

2 Continuous Integration

2.1 Gradle Support

Intershop Studio now supports cartridge builds and dependency management using Gradle build files.

Along with the pre-installation of the Eclipse Gradle features (See http://www.gradle.org/tooling) this integration includes cartridge dependent class path handling, additional cartride types and cartridge build launches.

2.1.1 Cartridge Project Setup

In order to use Gradle features with cartridges the source project needs to include the nature org.springsource.ide.eclipse.gradle.core.nature in its natures section.

Example *.project excerpt:






 See migration hints.

2.1.2 Cartridge Gradle Dependencies

Cartridges that use Gradle build support have to use the new classpath container Cartridge Gradle Dependencies which automatically contains the libraries and dependent projects that are declared in the build.gradle file.

 See migration hints.

2.1.3 Gradle Repository Cartridges

Cartridge dependencies that are resolved using Gradle can be shown in the Cartridge Explorer. The cartridges displayed in the folder Gradle Repository Cartridges are computed using all cartridge source project dependencies.

2.1.4 Cartridge Build

New launch configurations can be used to build a cartridge within Intershop Studio. The project Build Cartridge automatically takes care about that.

Alternatively you might use the new Gradle Tasks view.

2.1.5 Migration Hints

In order to perform necessary changes in the *.project and *.classpath files of cartridge projects the action Refresh/Reset Cartridge Classpath can be used.

Select Reset and confirm with OK in the next dialog.



You must not use Gradle dependency management (e.g., if you use the Import|Gradle Project wizard). You still can use Gradle|Refresh All, but not Gradle|Enable Dependency Management.

3 Pipeline Management

3.1 Node Comments

Node Comments are now shown near the node.

3.2 Comment Tool

The editor palette contains a tool to create a new node comment or to edit an existing one.

3.3 Generic Pipeline Nodes

The pipeline concept allows to use pipelets to define business steps. Since its first appearance pipelets were not really enhanced and modernized in terms of technology, development user-friendliness, usage, new Java concepts (e.g., annotations, code injection)

Despite the fact that there really exist many drawbacks and problems with pipelets: E.g., the inconvenient and error prone usage of configuration values, the poor error handling, the unnecessary restriction of the possible output states, the error prone usage of the pipeline dictionary and many others. Along with these problems it is not possible to, e.g., define other node types such as Start or Decision and Interaction nodes using pipelets. Generic pipeline nodes address all these problems. They can be of any node type but also make no usage of the pipeline dictionary and do not use a separate descriptor file.

For more detailed information on the idea of generic pipeline nodes see: Concept - Pipeline Nodes.

3.4 Node Definition

Generic pipeline nodes are defined in a simple POJO-like Java class. Pipelet node specific properties are expressed using annotions. The following simple example shows how properties (configuration values), input and output connectors can be defined:

Calculation Start Node
package com.intershop.test.pipelinenode;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import com.intershop.beehive.pipeline.capi.annotation.PipelineNode;
import com.intershop.beehive.pipeline.capi.annotation.PipelineNodeInput;
import com.intershop.beehive.pipeline.capi.annotation.PipelineNodeOutput;
import com.intershop.beehive.pipeline.capi.annotation.PipelineNodeParameter;

 * A pipeline node that creates the input value for further calculations within
 * a pipeline.
@PipelineNode(type = Types.StartNode)
public class CalculationStartNode
    public final static String OUTPUT_NAME = "Output";
    public final static String INPUT_NAME = "Input";

     * The name of this Start Node
    private String name;

    @PipelineNodeOutput(name = OUTPUT_NAME)
    private Output output;

    @PipelineNodeInput(name = INPUT_NAME)
    public Output start(Input input)
        int cnt = input.getCount();
        List<Long> l = new ArrayList<>(cnt);
        for (int i = 1; i <= cnt; ++i)
        String calculation = input.getCalculation();
        output.setCalculation(calculation == null ? CalculatorNode.Calculations.SUM.toString() : calculation);
        return output;
    interface Input
        int getCount();
        String getCalculation();
    interface Output
        void setNumbers(Collection<Long> numbers);
        void setCalculation(String calculation);

Node the usage of the annotations:

@PipelineNode: Declares this type as definition of a Pipeline Node.
The attribute 'type=Types.StartNode' marks this node as Start Node.
@PipelineNodeParameter: Declare a Pipeline Node property (Configuration value).
The pipeline engine will inject the value according to its value set in the Pipeline
@PipelineNodeInput: An input connector that is defined as method that takes exactly one parameter.
This method gets invoked by the pipeline engine.
The input data type has to be an interface.
The pipeline engine will inject an object of that type.
The getter methods of this object will access matching objects in the current Pipeline Dictionary.
Dependent on the return type the pipeline engine will chose the right output connector.
@PipelineNodeOutput: An output data type.
The pipeline engine considers bean setters and puts their values into the Pipeline Dictionary.


All methods, attributes etc should have a Javadoc because this is used by the Pipeline Editor as documentation.

3.5 Pipeline Node Annotation Processor

Intershop Studio as well as Intershop Commerce Suite use annotation processors to create descriptors and to extract model information that are part of such annotated pipeline nodes.

In order to use generic pipeline nodes make sure that this annotation processor is available. This processor needs to be enabled using the project properties dialog:

These properties are saved in a file ./settings/org.eclipse.jdt.apt.core.prefs.

This annotation processor is triggered by the Intershop Studio/Eclipse Java builder and writes the output into a source folder (e.g., .apt_generated). This means that you should either use: Window|Preferences: General|Workspace: [x] Build automatically or invoke Project|Build Project.

3.6 View Enhancements

The Pipelet View as well as the Cartridge Explorer now also show pipelets/pipeline nodes that are defined as Generic Pipeline Nodes.

3.7 Generic Nodes in the Pipeline Editor

You can add pipelet/pipeline nodes to a pipeline using drag&drop from the Pipelet View or Cartridge Explorer.


3.8 Secure Call Mode

Start nodes which are public now provide an option Secure. If this flag is set, the server only accepts secure HTTPS connections (requires Intershop 7.4 or later). Such secure start nodes are decorated with a small key image in all Intershop views as well as in the Visual Pipeline Editor.

4 Miscellaneous

4.1 Cartridge Qualified References

Since Intershop 7.4. pagelet element references need to be cartridge qualified. Therefore, these references cannot be overridden. This means that such references start with the Cartridge name followed by ':'. The editor, properties views, element hyper-linking, content assist as well as other features now support this element reference style.

See the following example of a non resolvable slot inclusion there quick fixes might be used in order to select an existing slot. The presented slot references use the fully qualified syntax:

4.2 Pagelet Model Validation

A validation rule has been added that issues errors if a pagelet model does not use cartridge-qualified references.

You can easily fix this kind of errors using the Quick Fix option:

4.3 Further Changes


The Editing Pipeline property of the pagelet definitions is not used anymore and thus is hidden in the Properties View. Pagelet models now can use the additional property Overrides in order to explicitly override another pagelet model.

4.4 Multiple Paths in IS_SOURCE

Intershop Studio now supports multiple paths in IS_SOURCE. Multiple paths have to be separated using the path separator character defined for the platform (System.getProperty("path.separator")).

The following features make use of the multiple paths:

4.4.1 New Cartride Wizard

4.4.2 Import Cartridge Project

4.4.3 Intershop Classpath Containers

Source attachments of libraries inside Intershop classpath containers (e.g., required cartridge) are computed using these paths. The preference Cartridge Source Code Locations can still be used for additional source code locations.

5 Comming Soon!

5.1 [This is a technical preview!]

5.1.1 Visual Themes in Pipeline Editor

The Visual Pipeline Editor now features an additional visual theme called Node Icons. To switch the themes:

  1. Right-click to open the context menu.
  2. Select the action Appearance Theme.
    Alternatively use the Visual pieline Editor's toolbar drop-down.

6 Removed

6.1 Removed

6.1.1 Web Service Based Pipelet Creation

In former versions it was possible to create a pipelet based on a Axis2 Web Service stub. This functionality has been removed.

6.1.2 Pipeline WSDD Editor

In former versions it was possible to create and edit pipeline WSDD files and to open the WebService Explorer on such files. This functionality has been removed.


The information provided in the Knowledge Base may not be applicable to all systems and situations. Intershop Communications will not be liable to any party for any direct or indirect damages resulting from the use of the Customer Support section of the Intershop Corporate Web site, including, without limitation, any lost profits, business interruption, loss of programs or other data on your information handling system.

Customer Support
Knowledge Base
Product Resources
Support Tickets