This article explains how to declare Maven dependencies for Spring Boot Admin, adds Russian language support for internationalization, and resolves a bug where setting the log level for service instances fails due to an incorrect Accept header.
Learn why Maven dependency conflicts occur, how the shortest‑path rule selects versions, and step‑by‑step methods—including exclusion tags, Maven Helper plugin, and IDE dependency graphs—to identify and eliminate conflicting JARs, ensuring a single consistent version in your project.
This article provides a comprehensive guide to Maven, covering installation steps, environment variable setup, configuration files, command syntax, build lifecycle, plugin goals, and verification, enabling Java developers to effectively use Maven for project builds and management.
This article compares Gradle and Maven, explains Gradle's advantages for large Java projects, introduces Groovy's benefits, walks through a complete build.gradle example, covers closures, dependency configurations, the Gradle wrapper, and essential tasks, providing practical code snippets and usage tips.
This article explains why coding standards are essential, introduces PMD and Alibaba's p3c plugin, and provides a detailed, code‑rich tutorial on designing, implementing, testing, and packaging custom Java static‑analysis rules to enforce @RequestMapping conventions.
This article explains what Maven dependency conflicts are, why they occur when different libraries require different versions of the same jar, and provides practical methods—including exclusion tags, the Maven Helper plugin, and IDE visual tools—to identify and eliminate these conflicts for stable Java builds.
This guide walks through diagnosing GPG signing failures caused by expired keys during a swagger‑spring‑boot‑starter release, shows how to inspect the current keyring, edit the key, extend its validity, and finally re‑run Maven deploy to publish artifacts.
This article provides a detailed tutorial on using Cucumber-JVM for Android SDK automated testing, covering framework basics, Gherkin syntax, step definitions, parameter handling, tag usage, Maven setup, and execution methods with code examples.
This guide explains how to integrate springdoc-openapi with Spring Boot to automatically generate OpenAPI 3 documentation, customize paths, combine with Swagger UI, use Maven plugins, support WebFlux, apply JSR‑303 bean validation, and document error responses via @ControllerAdvice, providing complete code snippets and configuration examples.
This article explains how to configure the JaCoCo Maven plugin to generate separate code coverage reports for unit and integration tests, including plugin setup in the POM, execution configurations, and integration with Maven Surefire and Failsafe plugins, plus Maven commands to produce the reports.
This tutorial walks you through creating a custom Spring Boot starter, covering project structure, naming conventions, auto‑configuration module, property management, Maven setup, sample usage, and best practices, enabling you to package reusable cross‑cutting functionality for any Spring application.
This comprehensive guide explains why Maven is essential for Java projects, details its core concepts, walks through installation, creates a first Maven project, covers common commands, repository layout, dependency scopes, lifecycle phases, Eclipse integration, and advanced features like transitive dependencies and version management.
The article analyses frequent Jenkins build failures caused by missing or outdated Maven dependencies, explains why they succeed locally but fail on CI, and proposes an AI‑driven dependency management feature for DevOps platforms to automatically detect and guide users toward proper artifact deployment.
This guide walks through creating a Spring Boot starter from scratch, covering Maven project setup, defining service and utility classes, configuring properties, implementing auto‑configuration with conditional annotations, registering the starter via spring.factories, and consuming it in another Spring Boot application.
This article demonstrates how to create a Spring Boot multi‑module Maven project, covering the setup of an aggregate parent pom, creation of sub‑modules, implementation of controller, service, repository, and entity layers, configuration files, packaging, and deployment steps.
This tutorial shows how to add iText and XHTMLRenderer dependencies, create a PDF utility class that supports Chinese fonts, configure Maven resources to avoid placeholder conflicts, and resolve Docker build issues, all illustrated with a working demo image.
This guide explains how to configure Jenkins to pull Java code from Git, compile and package it with Maven, transfer the artifact to a test server via SCP, and restart Tomcat, providing a complete CI/CD pipeline for Java applications.
This article explains the origins and motivations of Delta Lake, details its ACID transaction support, schema enforcement, metadata handling, versioning, and unified batch‑and‑stream processing, and provides a step‑by‑step Maven and Spark code tutorial for creating, updating, and querying Delta tables.
This guide explains how to use Swagger2Markup to convert Swagger-generated API specifications into static documentation formats such as AsciiDoc, Markdown, Confluence markup, and HTML, covering both Java code and Maven plugin approaches, deployment options, and example configurations for Spring Boot projects.
This article compiles essential Spring Boot interview questions covering its distinction from Spring, Maven setup, starter modules, disabling and registering auto‑configurations, conditional beans, packaging as JAR/WAR, startup logic, external configuration sources, testing nuances, and the powerful Actuator monitoring features.
This guide introduces the canal‑kafka integration package, outlines its constraints, and provides a step‑by‑step tutorial with Maven dependencies and Java source code for a SimpleCanalClient, a Kafka producer, and a server class, enabling a functional demo of Canal to Kafka data streaming.
An overview of the most widely used Java build tools—Ant with Ivy, Maven, and Gradle—detailing their histories, core features, advantages, limitations, and typical usage scenarios, along with links to official sites and a brief note on related CI platforms.
This article walks you through creating a Quarkus‑based microservice with REST endpoints, input validation, unit testing, inter‑service communication, health checks, Swagger UI, local execution, and finally deploying the services to OpenShift using S2I and native image builds.
This tutorial explains what a Maven private repository is, walks through setting up Nexus as a private repo using Docker, and shows how to configure Maven and deploy both project artifacts and third‑party JARs, enabling faster, secure builds for Java enterprise projects.
This guide explains how to set up Maven, Ant, Gradle, and NPM in Jenkins, covering system prerequisites, installation steps, Jenkins configuration, and frequently used build commands for each tool.
This tutorial walks through installing JDK and Maven on a CentOS server, cloning a Spring Boot Hello World project, building it with Maven, installing Docker, creating a Dockerfile, building and running the Docker image, and finally managing the container lifecycle.
This article explains why adding spring-boot-devtools can trigger a ClassCastException due to its dual classloader mechanism, demonstrates how to reproduce the issue in a Maven multi‑module project, and provides two practical solutions: customizing the RestartClassLoader or removing the devtools dependency.
This article provides a thorough introduction to Maven, covering why to use it, its core concepts, installation steps, creating the first project, repository management, dependency scopes, lifecycle phases, Eclipse integration, advanced dependency features, and build configuration with practical code examples.
This guide explains how to configure a Jenkins slave Docker image by installing JDK, Maven, and other build tools, adding the agent.jar, setting environment variables, and providing a startup Bash script to launch the Jenkins agent within the container.
This article explains Maven’s repository types, dependency declarations, version handling, conflict resolution strategies, best practices for early detection, standard directory layout, lifecycle phases, and scope definitions, providing essential knowledge for Java developers to master Maven in real-world projects.
This comprehensive guide details how to configure IntelliJ IDEA—including Maven settings, code style, keymap shortcuts, plugin installation, version control integration, encoding, live templates, and productivity features such as presentation mode and inject language—to streamline Java development and improve coding efficiency.
This tutorial walks through preparing the environment, configuring Docker remote access, creating a Spring Boot project with Maven, writing Dockerfile and related configuration files, building the image, and running the container, demonstrating how to deploy a Java web application to Docker using IntelliJ IDEA.
This guide explains why Maven is a must‑have Java build tool, walks through its installation, project structure, core commands, repository handling, dependency scopes, lifecycle phases, Eclipse integration, and advanced features, providing clear code examples and configuration snippets.
This guide explains how to transition from Gradle to Maven for a Java‑Groovy mixed project, covering folder renaming, essential Maven dependencies and plugins, manifest configuration, and a note on optional local‑jar settings to successfully build an executable JAR in IntelliJ.
This article demonstrates how the non‑atomic i++ operation can cause race conditions in Java, using a simple multithreaded test and the vmlens tool to visualize the conflicting accesses and explain the underlying thread‑safety issue.
This guide walks Java developers through the key differences between IntelliJ IDEA and Eclipse, explains why IDEA eliminates the workspace concept, and provides step‑by‑step instructions for configuring default project settings, JDK, Maven, version control, auto‑import, Tomcat, shortcuts, and other productivity features.
This guide explains how developers can commit code, update the Maven pom, use Jenkins to read the pom, upload artifacts to Nexus, and retrieve the latest package URL, illustrating a complete CI/CD workflow for a Spring Boot application.
This guide explains how to install a set of useful IntelliJ IDEA plugins—including FindBugs‑IDEA, Maven Helper, VisualVM Launcher, GenerateAllSetter, Rainbow Brackets, Translation, and Alibaba Java Coding Guidelines—by configuring the IDE, restarting it, and verifying successful loading through visual cues and practical usage examples.
This article explains the historical problems Maven solves, describes Maven repository types, default settings, project structure, common commands, pom.xml elements, dependency scopes, transitive dependencies, conflict resolution strategies, and how to exclude unwanted artifacts, providing a comprehensive guide for Java developers.
This guide compares IntelliJ IDEA and Eclipse, explains the workspace shift, walks through default and project-specific configurations for JDK, Maven, Git, Tomcat, and presents a collection of practical shortcuts and UI tweaks to boost Java development productivity.
Apache Flink 1.8.0 introduces incremental state cleanup with TTL, updates Hadoop support, deprecates TableEnvironment static methods, adds new Kafka deserialization schema, modifies Maven dependencies, and provides several configuration and Table API enhancements for better stream‑processing performance and compatibility.
This article explains Maven's role as a Java build and dependency management tool, covering its repository concepts, mirrors, lifecycle phases, coordinates, conflict resolution strategies, aggregation and inheritance mechanisms, plugin configuration, and common command-line usage to improve developer productivity.
This article provides a comprehensive tutorial on Spring Boot, covering its purpose, key advantages, project setup with Maven, essential configuration files, integration of JdbcTemplate, JPA, MyBatis, JSP, AOP, and task scheduling, all illustrated with complete Java code snippets.
This article explains why Lombok was created to eliminate repetitive Java code, shows how to add the Maven dependency, configure IDE support, describes its annotation‑processing mechanism, and demonstrates the most common Lombok annotations with before‑and‑after code examples.
This guide explains how to integrate Maven, Ant, Gradle, and NPM with Jenkins, covering prerequisites, installation steps, Jenkins configuration, and common build commands for each tool, including setting environment variables, creating Jenkinsfiles, and verifying the setup with test builds.
This article provides a comprehensive overview of Maven, covering its repository types, local and remote configurations, dependency management including scopes and conflict resolution, best practices for avoiding issues, and the standard Maven lifecycle, enabling developers to master Maven for Java projects.
This comprehensive tutorial explains Maven's repository types, dependency management, conflict resolution strategies, best practices for adding dependencies, standard directory layout, lifecycle phases, and scope definitions, helping Java developers confidently master Maven for multi‑module projects.
This tutorial walks you through setting up a Spring Boot 2.1.3 project using Maven, covering environment prerequisites, two creation methods (Spring Initializr and IntelliJ IDEA plugin), project structure, configuration, essential dependencies, a HelloWorld REST controller, unit testing, and important deployment tips.
This tutorial walks you through creating a Spring Boot project with Spring Initializr, explains its lightweight advantages, shows how to set up the project structure, configure Maven dependencies, implement a simple HTTP endpoint, and write unit tests, all using Java and Maven.
This guide explains the purpose of the mica-boot-test component, shows how to add its Maven or Gradle dependency, and provides two example test classes demonstrating the use of @MicaBootTest with either @RunWith(MicaSpringRunner.class) or inheritance from MicaBaseTest.
This article explains how to select the appropriate Spring Cloud Alibaba version by clarifying its relationship with Spring Boot and Spring Cloud, provides a Maven BOM snippet, a compatibility matrix, and points to a comprehensive tutorial series for building micro‑service applications.
Spring Cloud Greenwich.RELEASE is now available via Maven Central, introducing Java 11 compatibility, new projects like Spring Cloud GCP and Kubernetes, while announcing EOL for Edgware and Finchley, moving many Netflix modules into maintenance mode, and providing extensive updates across Sleuth, Config, Vault, OpenFeign, and other components with migration guidance.
This article explains why consumer‑driven contract testing is essential for API and microservice integration, describes how Spring Cloud Contract automates contract generation, stub publishing, and independent testing for providers and consumers, and shares practical tips, configuration details, and verification steps.
This guide explains how to build a Spring Boot starter that automatically counts and logs the number of entries for each entity at application startup, covering starter concepts, Maven setup, code implementation, auto‑configuration, and integration into a main project.
This article explains why migrating a Spring Boot app from Java 8 to Java 11 is necessary, compares OpenJDK and commercial licenses, outlines Spring's Java‑11 support, and provides detailed migration steps, dependency updates, and Maven/Gradle configuration changes.
This tutorial walks you through creating Maven custom archetype templates, developing and using custom plugins, and configuring build profiles for environment‑specific packaging, providing step‑by‑step commands, code snippets, and visual guides for Java backend projects.
This article details how to build an automated testing framework for algorithm interfaces with TestNG, Maven, Allure Report, Excel data-driven inputs, and Jenkins integration, covering project setup, plugin configuration, test execution, and report generation to streamline repetitive testing tasks.
This article presents a curated list of fundamental and advanced tools—including JIRA, Git, Jenkins, Selenium, Groovy, Spock, Maven, Gradle, Docker, and Linux—that Java developers with any experience level should master to improve productivity, testing, build automation, and deployment.
This article explains how to implement Java Instrumentation using a custom Java agent to achieve AOP‑style method timing without Spring, covering Instrument concepts, Maven manifest configuration, Agent entry points, JDK Attach API loading, class file transformers, annotation processing, and integration with QTrace for full‑stack tracing.
This article details the design of a reusable Java backend framework called lyyzoo, covering coding standards, Maven module hierarchy, dependency management, core utility classes, and Spring configuration for web, JPA, and transaction support, providing a comprehensive guide for building enterprise applications.
This article walks through the complete backend development of a gas purchase‑sale‑stock management system, covering entity and database design, Maven multi‑module project setup, Spring and web.xml configuration, environment‑specific property handling with a portable‑config Maven plugin, and a sample login controller implementation using Java, Spring MVC, and ExtJS.
This article presents a detailed case study of a mid‑size development team’s front‑end and back‑end technology stack, server environment, project workflow, and management practices, aiming to share practical solutions and lessons learned for building and maintaining enterprise‑grade Java applications.
This article explains how to dynamically modify a Java project's properties at runtime without restarting the JVM by attaching a custom Java agent, configuring Maven dependencies, and using JConsole or Telnet for property updates.
This tutorial walks through creating a lightweight Java web project using Maven, Spring, SpringMVC, MyBatis, and SpringBoot in IntelliJ IDEA, covering project setup, datasource configuration, Spring annotations, MyBatis integration, deployment settings, and optional Redis and Druid components.
This article introduces a lightweight Java wrapper around Alibaba's EasyExcel library that enables one‑line Excel import and export, explains required Maven dependencies, essential utility classes, and provides complete code examples for reading, writing single‑sheet and multi‑sheet workbooks with custom model mappings.
This article provides a comprehensive, question‑driven guide to Spring Boot, covering its differences from Spring and Spring MVC, auto‑configuration, starter projects, embedded servers, Maven plugins, DevTools, static resources, Spring Data, REST support, request mapping nuances, and profile‑based configuration for building production‑ready Java backend applications.
This article systematically outlines the essential steps and considerations for creating a classic Java web application, covering environment preparation, Maven scaffolding, logging and database dependencies, DAO design with MyBatis, Spring integration, service-layer best practices, and RESTful controller implementation.
This article introduces a modular Java web crawler framework built with Maven, explains its package structure (db, model, util, parse, main), details the data flow from URL fetching to HTML parsing using HttpClient and Jsoup, and provides a complete example that extracts book information from JD.com and stores it in MySQL.
This guide shows how to change a Spring Boot project’s packaging to WAR, remove the embedded Tomcat, add the servlet‑api dependency, create a servlet initializer, build the WAR with Maven, and deploy it to an external Tomcat server for verification.
This article explains how to download, configure, and compile the Nexus repository manager from source, then details the structure and strategy of its local storage directories, providing insights into its blob, cache, database, and other components.
This article introduces Spring Boot, explains its key features, walks through creating a Maven project with a complete pom.xml, adds essential dependencies and plugins, shows how to write a basic @RestController application, and demonstrates various ways to run and hot‑reload the service.
This article provides a comprehensive guide to Maven, covering its installation, the structure and purpose of local and remote repositories, step‑by‑step project creation, detailed explanation of the pom.xml file, essential Maven commands, and best‑practice tips for Java developers.
This article explains the shortcomings of traditional distributed microservice testing, introduces consumer‑driven contract testing, outlines the evolution of a distributed R&D model, and provides a step‑by‑step guide with code samples for implementing Spring Cloud Contract in both provider and consumer services.
This article provides an in-depth explanation of Maven's settings.xml file, covering its purpose, default locations, top‑level elements, single‑level configurations such as localRepository and offline mode, plugin groups, servers, mirrors, proxies, profile activation, properties, repositories, and active profiles, helping readers configure Maven effectively.
This guide walks through troubleshooting Ubuntu 14.04 network manager incompatibility, configuring campus network access, setting up an SSH server, adjusting Vim tabs, installing Java JDK, Maven, Zsh, and various utilities, plus tips for grub configuration, system monitoring, and software enhancements on an old machine.
This step‑by‑step guide shows how to create a simple Spring Boot application, configure Gradle or Maven builds, write MockMvc tests, and use Spring REST Docs to automatically generate up‑to‑date API documentation snippets that can be included in Asciidoctor‑based docs.
This article explains how to correctly configure Maven dependencies for Spring 3 (and briefly for Spring 4), detailing the framework’s five module groups, their individual jars, dependency relationships, and providing ready‑to‑use XML snippets for both core and web projects.
This comprehensive guide explains Maven's core concepts, project structure, repository types, installation steps, common commands, lifecycle phases, creating new Maven projects, POM file details, dependency management, and various Maven project types, providing developers with a complete reference for effective build automation.
This guide walks through extracting Java source files from a deployed WAR package, decompiling the bytecode with free tools, and reorganizing the output into a Maven‑compatible web project structure so the application can be maintained and extended.
This tutorial provides a step‑by‑step walkthrough for setting up Apache RocketMQ 4.2 on a 64‑bit Linux system, covering environment prerequisites, downloading source, building binaries, starting NameServer and Broker, sending and receiving messages, and shutting down the services.
This article demonstrates how to use Google's ZXing Core library in a Java Maven project to generate QR code images, create random verification codes, and decode QR codes from files, providing complete code examples and step-by-step instructions.
This guide explains how to use Swagger2Markup to convert Swagger JSON from a Spring Boot project into AsciiDoc and then into static HTML, covering Maven dependencies, a JUnit test for document generation, and the Asciidoctor plugin configuration for final deployment.
This tutorial walks through creating a Maven project in IntelliJ IDEA, configuring Maven settings, adding required dependencies, setting up Spring, MyBatis, FreeMarker, Log4j, and web.xml, and integrating Spring MVC to build a complete SSM framework application.
This guide explains how to break down a 5‑million‑line Maven codebase into modules, configure SonarQube scanning, and integrate it into a Jenkins CI/CD pipeline for fast, automated code‑quality analysis.
This guide walks through cloning the LanguageTool repository, building it with Maven, extracting the required JARs, creating a servlet that uses JLanguageTool to check English text, handling language‑code issues by packaging META‑INF resources, and finally testing the service with curl.
This guide walks you through configuring Jenkins to build a SpringBoot Maven project, automating post‑build steps, managing the workspace, and securely transferring the resulting JAR to another server using SSH keys or an Expect script.
Alibaba’s Dubbo framework has launched its first version after resuming maintenance, addressing critical issues such as graceful shutdown, monitoring blockages, dynamic configuration bugs, routing errors, async leaks, and concurrency limits, while also upgrading core Maven dependencies like Spring, Zookeeper, Hessian, and more.
This article explains the layered server‑side architecture model, the role of each layer, the MVC pattern and its communication flows, Maven‑based project modularization, and an overview of Service‑Oriented Architecture, providing a practical guide for designing flexible backend systems.
This tutorial walks through setting up Drools 7, configuring Maven dependencies, kmodule.xml, and writing a simple Hello World rule test that demonstrates product discount calculation using the new KIE API.
This article introduces Apache Maven as a vital Java build tool, explaining its standard project layout, automatic and transitive dependency management, installation, IDE integration, pom.xml configuration, common commands, and a brief comparison with Gradle, providing essential knowledge for Java developers.
This comprehensive guide walks you through MapReduce fundamentals, the complete execution flow, and seven hands‑on Hadoop projects—including WordCount, custom serialization, custom partitioning, grouping comparators, file merging, multiple outputs, join operations, and friend‑graph analysis—while providing environment setup steps, Maven commands, and Hadoop CLI examples.
This tutorial explains how to configure Jenkins with the Generic Webhook Trigger plugin to automatically start builds whenever code is pushed to the develop branch of a Gitee (Git@OSC) repository, covering preparation, job setup, security settings, and webhook configuration.
Learn step‑by‑step how to install Jenkins on Windows, configure the service port, create a Maven job with Subversion source control, set up build triggers, post‑build actions, and email notifications, then run and monitor builds through the Jenkins web UI.
This tutorial walks readers through setting up the development environment, generating a Jenkins plugin skeleton with Maven, understanding the project structure and Jelly view files, writing the plugin code, debugging, and finally packaging and deploying the custom plugin to a Jenkins server.
This guide explains how to set up Jenkins to run Maven builds for different environments (dev, beta, prod), including commands to skip tests, deploy to Nexus, and specify profile parameters, with screenshots illustrating the correct configuration to avoid common errors.
This article explains the common pitfalls of manual Java deployment, introduces the concept of a closed‑loop Java application, and provides step‑by‑step Maven‑assembly and Spring Boot configurations, scripts, and code examples for both non‑web and web projects to achieve automated, reproducible deployments.
This guide walks you through adding a Maven proxy repository, setting its remote URL and identifiers, and updating its index, providing clear step‑by‑step instructions with screenshots to help Java backend developers configure their build environment quickly.
This guide explains Nexus repository types—Hosted, Proxy, and Group—and provides step‑by‑step instructions with screenshots for adding a JBoss public proxy repository to Nexus so Maven can retrieve JBoss artifacts efficiently.
The article recounts how a developer observed repetitive Ant build scripts across projects, identified common build steps and path inconsistencies, proposed standardized directory conventions and XML‑based dependency declarations, leading to the creation of Maven and a shift toward convention‑over‑configuration in Java backend development.
Based on an analysis of 47,251 dependency declarations from 3,862 popular GitHub Java projects, this article presents the 100 most widely used Java libraries, highlights the top 20, examines the rise of Spring components, and discusses notable JSON and other standout libraries.
