Skip to main content
Now you are ready to set up your first process application project in the IDE of your choice. The following description uses Eclipse.

​
Terminology: processes vs. decisions

DMN is a modeling language for decisions, whereas BPMN is a language for processes. This tutorial focuses on decisions. However, the Java project contains classes and files with names like ProcessApplication and processes.xml. These are generally applicable and can be used with both processes and decisions.

​
Create a new Maven project

You don’t have to set up the project manually — you can also use a Maven archetype (which is like a project template). See Maven Archetypes for details. The archetype creates a project according to best practices.
In Eclipse, go to File > New > Other…. This opens the New Project Wizard. Select Maven > Maven Project and click Next. Create a new Maven project in Eclipse On the first page of the New Maven Project Wizard, select Create a simple project (skip archetype selection) and click Next. On the second page, configure the Maven coordinates for the project. Since you are setting up a WAR project, ensure you select Packaging: war. When you are done, click Finish. Eclipse sets up a new Maven project. The project appears in the Project Explorer view.

​
Add ASEE Flow Maven dependencies

The next step consists of setting up the Maven dependencies for your new process application. Add the following dependencies to the pom.xml file of your project: 
<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>
  <groupId>org.camunda.bpm.getstarted</groupId>
  <artifactId>dinner-dmn</artifactId>
  <version>0.1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <properties>
    <camunda.version>7.24.0</camunda.version>
    <maven.compiler.release>11</maven.compiler.release>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.camunda.bpm</groupId>
        <artifactId>camunda-bom</artifactId>
        <version>${camunda.version}</version>
        <scope>import</scope>
        <type>pom</type>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <dependency>
      <groupId>org.camunda.bpm</groupId>
      <artifactId>camunda-engine</artifactId>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>jakarta.servlet</groupId>
      <artifactId>jakarta.servlet-api</artifactId>
      <version>6.0.0</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.11.0</version>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
        <version>3.3.2</version>
        <configuration>
          <failOnMissingWebXml>false</failOnMissingWebXml>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>
Now you can perform the first build. Select the pom.xml in the Package Explorer, right-click, and select Run As > Maven Install.
Catch up: get the sources of Step-1
git clone https://github.com/camunda/camunda-get-started-dmn.git
git checkout -f Step-1
Or download as a .zip.

​
Add a process application class

Next, create a package — for example org.camunda.bpm.getstarted.dmn — and add a process application class to it. The process application class constitutes the interface between your application and the process engine. 
package org.camunda.bpm.getstarted.dmn;

import org.camunda.bpm.application.ProcessApplication;
import org.camunda.bpm.application.impl.ServletProcessApplication;

@ProcessApplication("Dinner App DMN")
public class DinnerApplication extends ServletProcessApplication
{
  //empty implementation
}

​
Add a META-INF/processes.xml deployment descriptor

The last step to set up the process application is to add the META-INF/processes.xml deployment descriptor file. This file lets you provide a declarative configuration of the deployment(s) this process application makes to the process engine. This file needs to be added to the src/main/resources/META-INF folder of the Maven project. 
<?xml version="1.0" encoding="UTF-8" ?>

<process-application
    xmlns="http://www.camunda.org/schema/1.0/ProcessApplication"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <process-archive name="dinner-dmn">

    <process-engine>default</process-engine>
    <properties>
      <property name="isDeleteUponUndeploy">false</property>
      <property name="isScanForProcessDefinitions">true</property>
    </properties>
  </process-archive>

</process-application>
At this point you have successfully set up the process application, and you can start modeling your first decision table.
Catch up: get the sources of Step-2
git clone https://github.com/camunda/camunda-get-started-dmn.git
git checkout -f Step-2
Or download as a .zip.

​
Next step

Continue to create a decision table.