These conventions ensure modules and components are easy to identify and organize, enhancing maintenance. All conventions are compliant with standard Java Programming Language code conventions.

* **Classes & Interfaces**: Use PascalCase (mixed case with the first letter of each internal word capitalized).

* **Example**: `UserRegistrationService, ContactInfoBean.`

* **Methods**: Use camelCase (mixed case with a lower case first letter) and start with a verb.

* **Example**: `calculateTotal(), performLogin().`

* **Variables & Attributes**: Use camelCase; avoid single-letter names except for loop counters.

* **Example**: `isAccountActive.`

* **Constants & Enumerated Values**: Use UPPER_SNAKE_CASE (upper case with words separated by underscores).

* **Example**: `MAX_RETRY_ATTEMPTS, VISA.`

* **Packages**: Use all-lowercase ASCII letters.

* **Example**: `com.enovate.paymentsystem.service.`

* **J2EE Application (EAR):** Packaged as an Enterprise Archive with a .ear extension.

* **Archive Name:** All-lowercase ASCII letters.

* **Example**: `paymentsystem.ear.`

* **Display Name**: Expanded application name in mixed case followed by "EAR".

* **Example**: `<display-name>PaymentSystemEAR</display-name>.`

* **EJB Modules:** Packaged as JAR files with a .jar extension.

* **Archive Name**: `<module-name>-ejb.jar.`

* **Client Archive**: `<module-name>-ejb-client.jar.`

* **Display Name**: `<expanded-module-name> JAR.`

* **Web Modules:** Packaged as Web Archives with a .war extension.

* **Archive Name:** `<module-name>.war.`

* **Display Name**: `<expanded-module-name> WAR.`

* **Local Interface:** `<component-name> or <component-name>Local.`

* **Local Home Interface:** `<component-name>Home or <component-name>LocalHome.`

* **Remote Interface:** `<component-name>Remote.`

* Implementation Class: `<component-name>Bean.`

* Primary Key Class: `<component-name>PK.`

* **Message Driven Beans (MDB)**:

* **Implementation Class:** `<component-name>Bean.`

* **Display Name:** `<expanded-component-name> MDB.`

* **Display Name:** `<expanded-component-name> Servlet.`

* **Implementation Class:** `<component-name>Filter.`

* **Listeners:** Implementation class should be `<component-name>Listener.`

* **File Name:** Must begin with a lower-case letter; avoid verb-only names.

* **Example:** `performLogin.jsp.`

* **Tag Files:** `/WEB-INF/tags/file.tag.`

* **Service Name:** PascalCase base name of the EJB or JAX-RPC endpoint.

* Example: `WeatherService.`

* **Service Endpoint Interface:** `<service-name>SEI.`

* **EJB Implementation:** `<service-name>Bean.`

* **JAX-RPC Implementation:** `<service-name>Impl.`

* Configuration:

* **WSDL File:** `<service-name>.wsdl.`

* **Mapping File:** `<all-lower-case-service-name>-mapping.xml.`

* **EJB References**: Logical name for JNDI lookup of home interfaces.

* Format: `ejb/<component-name>.`

* **Web Service References:** `service/<service-name>.`

* **JDBC**: `jdbc/<resource-name>.`

* **JMS**: `jms/<resource-name> [Queue|Topic].`

* **Mail**: `mail/<resource-qualifier>.`

* **Environment Entries**: `param/<parameter-name>.`

* **Database schema:** Use lower_case_with_underscores (e.g. `payment_system_db`).

* **Database tables:** Use lower_case_with_underscores (e.g. `payment_records`).

* **Database columns:** Use lower_case_with_underscores (e.g. `payment_id`).

* **XML Elements:** Follow class naming (`PascalCase`).

* **XML Attributes:** Follow variable naming (`camelCase`).

* **Alternative XML Notation:** Element names in lower case separated by hyphens (e.g., `<credit-card>`).

* **Application**: `application.xml.`

* **Web**: `web.xml.`

* **EJB**: `ejb-jar.xml.`

* **Manifest Files:** Prototype names used in source directories to distinguish files before they are renamed to `MANIFEST.MF` in the archive.

* EJB Manifest: `ejb-jar-manifest.mf.`

* **Dependency Injection (CDI)**: Use @Inject instead of manual JNDI lookups (relative to java:comp/env) where supported.

* **REST Services**: Prefer Jakarta REST (JAX-RS) over new Servlet implementations for service interfaces.

* **Persistence**: Utilize JPA @Entity POJOs to replace legacy CMP Entity Beans.

* **Validation**: Use Bean Validation annotations (@NotNull, @Size) to replace manual validation in Web components.

* **Controller (JAX-RS):** Handles HTTP requests/responses. Use DTOs (Data Transfer Objects) here; never expose JPA Entities directly to the client.

* **Service Layer (EJB/CDI):** Contains the "What" of the application. Transaction boundaries (@Transactional) start here.

* **Repository Layer (JPA):** Contains the "How" of data retrieval. Purely for CRUD and queries.

To prevent `"Spaghetti Code,"` all Java EE applications must follow a Layered Architecture.

* **Presentation Layer (Web/API):** REST Controllers or Servlets. No business logic.

* **Business Layer (Service):** Core logic and transaction boundaries (@Transactional).

* **Data Access Layer (Repository/DAO):** Database interactions using JPA/Hibernate.

* **Prefer Constructor Injection:** It makes the code immutable and easier to unit test without a container.

public class OrderService {

* **Scope Awareness:** Use @RequestScoped for web-related beans and @ApplicationScoped for singleton-like services. Avoid @SessionScoped unless strictly necessary for stateful web apps to save memory.

* **Fetch Type:** Always default to FetchType.LAZY for @OneToMany and @ManyToMany relationships to avoid the "N+1" select problem.

* **Use Named Queries:** This allows the JPA provider to pre-compile the query.

public class User { ... }

* **Avoid System.out.println for SQL**: Use the persistence property javax.persistence.schema-generation.database.action and standard logging.

* **Proper Status Codes**: * 201 Created for successful POSTs.

* **Version your APIs:** Always include a version in the URL path.

* **Example**: `@Path("/v1/orders"`

* **Specific Exceptions:** Catch FileNotFoundException rather than a generic Exception.

* **Custom Exceptions:** Create domain-specific exceptions (e.g., `UserNotFoundException`) to provide better context to the API consumer.

* **Global Exception Mapper**: Use `ExceptionMapper<T>` to catch internal exceptions and return a clean JSON response to the user.

public class EntityNotFoundMapper implements ExceptionMapper<EntityNotFoundException> {

* **Bad**: `logger.info("User " + name + " logged in");`

* **Good**: `logger.info("User {} logged in", name);`

* **Principle of Least Privilege: **Class members should be private by default.

* **Sensitive Data**: Never log passwords, credit card numbers, or PII (Personally Identifiable Information).

* **Bean Validation:** Use standard constraints to keep logic clean.

public class UserDTO {

* **Encoding**: Always specify UTF-8 encoding for all web responses to prevent character corruption.

* **No Hardcoded Credentials**: All passwords, API keys, and DB URLs must be stored in environment variables or a microprofile-config.properties file.