Learn Camunda BPMN, DMN with Spring Boot

Compare BPMN workflows with raw code in Camunda BPM, showing how a BPMN file makes process flows easy to understand for non-coders and narrows the developer and analyst gap.

Explore basic BPMN building blocks in Camunda Modeler by creating a simple process with circles and two tasks, connected by arrows: insert user to database and get all users.

Understand the building blocks of a process: tasks, a start event, and an end event, illustrated by inserting a user and retrieving all users via BPMN, Camunda, and Camunda modeler.

Discover how the camunda process engine executes bpmn and dmn files, with public API, bpmn 2.0 core engine, job executor, and persistence layer.

Explore how to integrate the Camunda platform with your application by comparing embedded, shared container, and remote process engine options, and implement the embedded process engine via a jar library.

Learn to create your first spring boot application with camunda by generating a project on start.com, then configure a rest api with xml and json support and web dependencies.

Navigate the Camunda app project structure, review src/main/java with the bootstrapping Spring Boot class, and examine resources for application.yaml and a sample process.bpm, plus pom.xml dependencies.

Explains pom.xml basics, including groupId, artifactId, and version, plus properties like UTF eight and Java version; shows how dependency management with spring boot dependencies and Camunda bom ensures compatible dependencies.

Explore how the Camunda BPM Spring Boot Starter Rest pulls in Camunda BPM libraries and Spring Boot integration, and learn how spin modules enable JSON and XML processing.

Explore pom.xml dependencies for spring boot starter web with embedded tomcat and h2 in-memory database, plus spring boot starter jdbc and the spring boot maven plugin to build and run.

Add two dependencies, Nashorn core and Camunda engine plugin connect, to the pom.xml to enable running JavaScript on the JVM and API calls from Camunda BPM/DMN.

Specify history time to live (TTL) in application.yaml under camunda.bpmn.genericProperties to define how long historic data stays in the database before cleanup, with a value of 5 days.

Create and test your first Spring Boot endpoint using a rest controller at /home, returning 'today is a good day,' and prepare for creating and executing BPMs in future videos.

Create a bpmn file in a Spring Boot project using Camunda modeler, including a start event, a script task that prints a message to the console, and an end event.

Invoke a BPMN process from a controller by accessing the process engine, creating a runtime service, starting a process instance with the BPM id, and executing it.

Expose a get endpoint /execute in a spring boot app, obtain the default Camunda process engine, start a process by key, and execute the BPMN instance with variables in return.

Discover how Nashorn core enables JavaScript execution in Camunda BPM and how to set and access variables from Java to the process instance using global scope or execution.getVariable.

Set a unique business key in each endpoint to identify the endpoint invoking the same BPMN, then access the key via execution.processBusinessKey inside the BPM.

Define a task as a single unit of actual work in Camunda BPMN, performing operations such as printing text, the item name variable in two ways, and the business key.

Learn how to create and configure a script task in Camunda BPMN with Spring Boot, using inline JavaScript to construct and print a user object.

Learn to invoke the existing bpm, create a new tasks endpoint, and execute a process instance using the runtime service in Camunda with Spring Boot.

Explore script task types in camunda BPMN: inline scripts and external resource scripts, using JavaScript, with external files like initialize_department.js for reusable code.

Make a local variable global in Camunda BPMN by returning it via the result variable, enabling access across the entire process and subsequent script tasks.

Learn to create multiple global variables in a single task using the output parameters tab, assigning inline JavaScript values and accessing them across the process.

Use the Camunda execution object to create and access global scope variables across tasks by calling execution.setVariable and execution.getVariable.

Learn how input parameters create task-scoped variables like user obj five in a Camunda script task using JavaScript, and why accessing them outside the task causes a reference error.

Explore how a service task in BPMN invokes external business logic within Camunda, and examine four implementations: Java class, delegate expression, expression, and REST.

Learn to implement a Java delegate for a Camunda service task by creating a Java class that implements JavaDelegate and uses DelegateExecution in the execute method.

Learn to invoke the execute method of a fetch email delegate from a Camunda BPMN service task by wiring the Java class and validating console output.

Learn how to access global and task-scoped variables in Camunda BPMN by using execution.getVariable in a service task and retrieving input parameter user ID input in a delegate.

Rename the fetch email delegate, use execution.setVariable to create a global user email id, then access it in BPMN output parameters and verify the execution order.

Use a delegate to capture an email id and update the global user object in a service task, then print the user obj with id, name, and email.

Learn how service tasks use delegate expressions to decouple class references in camunda bpmn, and implement a java delegate (fetch user role delegate) with an execute method.

Create a service task with a delegate expression using a bean id to invoke a Spring-managed class, fetch user role delegate, and verify its execute method prints the console text.

Assign an execution variable for user role in the delegate, then update the user object's role and print the updated object, illustrating variable scope and output parameters in Camunda BPMN.

Explore how to use a service task with expression implementation to invoke methods on Spring Boot classes from Camunda BPMN, even when the class does not implement the Java delegate.

Create a new service class in com.christian.services to implement getUserDepartment, returning accounts department, logging to console, and wiring the method to a bpmn service task.

Invoke a spring bean method from a camunda bpmn service task using expression syntax. The example uses user department service and its get user department method, wired as a component.

Access the value returned by a method, store it in a global BPM variable, and assign it to the user object's department using a JavaScript script in Camunda BPMN.

Explore service tasks with the connector implementation to call external business logic via a rest api call from a bpm workflow.

Invoke a public api endpoint from Camunda BPMN using the http connector, configuring a service task to use get or post methods and to pass a payload to reqres.in/api/users.

Configure HTTP connector in a Camunda BPM service task by supplying URL and method as input parameters and capturing the API response in an output parameter for printing.

Learn to invoke an API using the post method in Camunda BPMN workflows, including configuring the http connector, setting the endpoint, payload as stringified json, and handling the response.

Discover how the pom.xml dependency Camunda engine plugin connect enables executing JavaScript, using the http connector task with the id http connector, and invoking the API.

Learn to use text annotations in BPMN to document each task with reference text, including inline script, external resource, and service or connector tasks.

Learn how sequence flow acts as the connector between BPMN elements, linking start events, tasks, and end events to determine the next executed task.

Master BPMN sequence flows by distinguishing outgoing and incoming flows: an outgoing flow starts from a task, while an incoming flow ends at an element.

Explore how a bpmn workflow uses multiple outgoing sequence flows to create parallel paths from a single task, leading to task two and task three executing in parallel.

Optimize BPM execution by introducing a dynamic /execute/{processKey} endpoint in Spring Boot, allowing any BPMN to run and reveal its assigned tasks.

Apply conditional sequence flows in a Camunda BPMN model using script conditions on a global coins variable to decide which tasks print number of coins is four or not four.

Run the bpm app via the execute endpoint with the bpm id and observe the console to see how the number of coins drives task execution and sequence flow evaluation.

Switch a sequence flow from script to expression condition type and write an expression inside dollar and curly braces to check if number of coins equals four, triggering the print.

Learn how the default sequence flow in Camunda executes only when all other conditional flows fail, using a script task example with coins and task four, five, and six.

Discover how a gateway controls the flow of execution in a BPMN process, enabling parallel, sequential, or conditional paths after a task.

Explore exclusive gateway in Camunda BPMN, where only one path executes based on conditions; model gateways with script tasks and a simple user object flow.

Learn to implement an exclusive gateway in Camunda BPMN workflows, using conditional sequence flows and a default path to ensure only one execution path runs, with Spring Boot integration.

Demonstrates executing the app with a path where neither condition holds, triggering the default sequence flow and its task, illustrating condition-based routing in Camunda BPMN.

Learn how execution reaches an exclusive gateway, evaluates sequence flows in order as defined in XML, and selects the first true path, with a default flow preventing runtime exceptions.

Change the exclusive gateway to conditional sequence flows. With no true conditions, apply the default sequence flow to continue the process.

Converge multiple execution paths into one using a converging exclusive gateway, avoiding code duplication, and then print the user obj value after convergence.

Create a converging exclusive gateway by joining multiple incoming flows into one outgoing path, and wait for any one path to complete. Then print the user obj.

Print and stringify the user obj in a script task, then run and observe the default flow assigning name Rick, with the app console showing the user obj name value.