Build tools (Maven, Gradle, npm) in Jenkins - Step-by-Step Execution

Process Flow - Build tools (Maven, Gradle, npm)

Start Build Request

↓

Select Build Tool

↓

Maven

↓

Run Build Command

↓

Compile Code & Resolve Dependencies

↓

Run Tests

↓

Package Artifacts

↓

Build Success or Failure

↓

End

The build process starts by choosing a tool (Maven, Gradle, or npm), running its commands to compile, test, and package code, then ends with success or failure.

Execution Sample

Jenkins

mvn clean install
# or
gradle build
# or
npm install && npm run build

These commands run the build process using Maven, Gradle, or npm respectively.

Process Table

Step	Build Tool	Command Run	Action	Result
1	Maven	mvn clean install	Clean previous build, compile code, run tests, package	Build success
2	Gradle	gradle build	Compile code, resolve dependencies, run tests, package	Build success
3	npm	npm install	Install dependencies from package.json	Dependencies installed
4	npm	npm run build	Run build script (e.g., transpile, bundle, run tests)	Build success
5	All	N/A	Check build status	Success or failure reported

💡 Build process ends after packaging and test results determine success or failure.

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
Build Status	Not started	Success (Maven)	Success (Gradle)	Dependencies installed (npm)	Success (npm build)	Success or failure

Key Moments - 3 Insights

Why do npm builds often have two commands instead of one?

npm separates installing dependencies (npm install) from running the build script (npm run build), unlike Maven or Gradle which combine steps. See execution_table rows 3 and 4.

What happens if tests fail during the build?

The build stops and reports failure at the test step, so packaging does not happen. This is implied in the 'Build success' or 'failure' result in the execution_table.

Why do Maven and Gradle commands look simpler than npm's two-step process?

Maven and Gradle commands like 'mvn clean install' or 'gradle build' combine cleaning, compiling, testing, and packaging in one command, while npm splits install and build scripts.

Visual Quiz - 3 Questions

Look at the execution table, what is the result after running 'npm install'?

A Build success

B Tests run

C Dependencies installed

D Packaging complete

💡 Hint

Check execution_table row 3 under 'Result' column.

At which step does the build tool run tests?

A Step 1 and 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Action' column in execution_table rows 1 and 2 mentioning 'run tests'.

If tests fail during Maven build, what happens next?

A Build continues to packaging

B Build stops and reports failure

C Dependencies reinstall automatically

D npm commands run next

💡 Hint

Refer to key_moments about test failure stopping the build.

Concept Snapshot

Build tools automate compiling, testing, and packaging code.
Maven and Gradle use single commands like 'mvn clean install' or 'gradle build'.
npm separates dependency install ('npm install') and build ('npm run build').
Build success depends on passing tests and packaging.
Failures stop the build early.

Full Transcript

Build tools like Maven, Gradle, and npm help automate software building. The process starts by selecting a tool and running its build commands. Maven and Gradle combine cleaning, compiling, testing, and packaging in one command. npm splits installing dependencies and running build scripts into two commands. The build runs tests and packages the code. If tests fail, the build stops and reports failure. Success means the code is compiled, tested, and packaged correctly.