A production-ready console-based trivia game in Java that fetches questions from the Open Trivia Database API and provides an interactive Q&A experience with comprehensive logging and error handling.

This application follows enterprise-grade best practices:

• Structured logging with timestamps and severity levels
• Log level control (DEBUG, INFO, WARNING, ERROR)
• Request tracing with attempt counters
• Comprehensive error reporting with stack traces

• Strong typing with generics
• Input validation throughout application
• Graceful error recovery and handling
• Proper resource management with try-with-resources

• Automatic retry logic with exponential backoff (3 attempts)
• Connection timeout handling (10 seconds)
• Network error recovery
• Graceful degradation on API failures

• HTML entity decoding for proper question/answer display
• Answer verification and immediate feedback
• Score tracking with percentage calculation
• Detailed results breakdown

• Modular class-based design
• Separation of concerns (API, Game, UI, Logger)
• Easy to extend and customize
• Configuration constants at the top

• Java: Java 21 LTS (latest long-term support)
• Build Tool: Apache Maven 3.8+
• HTTP: Java HttpClient (built-in, no external dependency)
• JSON: Google Gson 2.10.1
• Execution: Maven or direct JAR execution

• Java 21 JDK or later
• Windows, macOS, or Linux
• Internet connection (for live version only)

• Maven 3.8.0 or later
• Java 21 JDK

# Clone or download the project
cd trivia-qa

# Build the project
mvn clean compile

# Run demo (no internet)
mvn exec:java -Dexec.mainClass="com.trivia.app.TriviaAppDemo"

# Or run live version
mvn exec:java -Dexec.mainClass="com.trivia.app.TriviaApp"

# Build fat JAR with all dependencies
mvn clean package

# Run the JAR
java -jar target/trivia-qa-app.jar

# Run demo version
java -cp "target/trivia-qa-app.jar:target/lib/*" com.trivia.app.TriviaAppDemo

1. Import project into IntelliJ IDEA, Eclipse, or VS Code
2. Right-click on TriviaApp.java or TriviaAppDemo.java
3. Select "Run" or press Ctrl+Shift+F10

# Compile
mvn clean compile

# Run demo (no internet required)
mvn exec:java -Dexec.mainClass="com.trivia.app.TriviaAppDemo"

# Compile
mvn clean compile

# Run live (requires internet)
mvn exec:java -Dexec.mainClass="com.trivia.app.TriviaApp"

# Build
mvn clean package

# Run
java -jar target/trivia-qa-app.jar

trivia-qa/
├── pom.xml                          # Maven configuration
├── src/
│   └── main/
│       └── java/
│           └── com/trivia/app/
│               ├── TriviaApp.java   # Live version (main app)
│               └── TriviaAppDemo.java # Demo version with mock data
├── target/                          # Build output
│   └── trivia-qa-app.jar           # Executable JAR
└── README.md                        # This file

• ✓ Fetches 10 random trivia questions from Open Trivia Database
• ✓ Displays questions with difficulty level and category
• ✓ Multiple-choice answers (randomized for variety)
• ✓ Immediate feedback on each answer
• ✓ Final score report with percentage
• ✓ Detailed question-by-question breakdown

• ✓ Automatic retry on network failure (3 attempts)
• ✓ Timeout handling (10 seconds)
• ✓ Graceful error messages
• ✓ Input validation
• ✓ Connection error recovery

• ✓ Demo mode with 5 built-in questions
• ✓ Works without internet connection
• ✓ Perfect for testing and learning
• ✓ Identical game logic to live version

• ✓ Well-commented source code
• ✓ Clean architecture with separation of concerns
• ✓ Easy to customize and extend
• ✓ Comprehensive logging and debugging support

Edit these constants in TriviaApp.java to customize behavior:

class Config {
    public static final String API_ENDPOINT = "<https://opentdb.com/api.>php?amount=10";
    public static final int REQUEST_TIMEOUT = 10000;        // milliseconds
    public static final int MAX_RETRIES = 3;                // retry attempts
    public static final int RETRY_DELAY = 1000;            // milliseconds between retries
}

In TriviaApp.java or TriviaAppDemo.java:

// More verbose
private static final Logger logger = new Logger("trivia_app", LogLevel.DEBUG);

// Less verbose
private static final Logger logger = new Logger("trivia_app", LogLevel.WARNING);

Change the endpoint to filter by difficulty or category:

// Easy questions
public static final String API_ENDPOINT = "<https://opentdb.com/api.php?>amount=10&difficulty=easy";

// Sports category
public static final String API_ENDPOINT = "<https://opentdb.com/api.php?>amount=10&category=21";

// Hard history questions
public static final String API_ENDPOINT = "<https://opentdb.com/api.php?>amount=10&category=23&difficulty=hard";

• Gson (2.10.1) - JSON serialization/deserialization
• Java HttpClient - Built-in HTTP client (no external dependency)

• java.util.* - Collections framework
• java.net.http.* - HTTP client and request handling
• java.util.logging.* - Logging framework
• java.text.* - Date formatting

• Structured logging with timestamps
• Configurable severity levels
• Console and error stream separation

• Encapsulates question data
• HTML entity decoding
• Answer shuffling logic

• API response wrapper
• Deserialization and error handling

• Game state management
• Score tracking
• Answer verification

• User interface logic
• Input handling and validation
• Output formatting

• Resilient HTTP communication with HttpClient
• Retry logic with configurable backoff
• Timeout handling
• JSON deserialization with Gson

Logger (Observability)
├── LogLevel enum

Domain Models (Type Safety)
├── Question
├── TriviaResponse
├── TriviaQuestionDto
├── AnswerRecord

API Client (Resilience)
├── TriviaAPIClient

Game Logic (Business Rules)
├── TriviaGame

Console UI (User Experience)
├── ConsoleUI

Main Applications
├── TriviaApp (live)
└── TriviaAppDemo (demo)

The application handles:

• HttpTimeoutException: Request timeout with retry
• IOException: Network unavailability with retry
• JsonSyntaxException: Invalid JSON responses
• IllegalArgumentException: API error codes
• NumberFormatException: Invalid user input
• Game State Errors: Graceful handling of edge cases

All errors are logged with appropriate detail levels:

2024-10-31 15:41:44 - trivia_app - INFO - Fetching questions from API (attempt 1/3)
2024-10-31 15:41:44 - trivia_app - WARNING - Connection error on attempt 1
2024-10-31 15:41:45 - trivia_app - INFO - Successfully fetched 10 questions
2024-10-31 15:41:45 - trivia_app - DEBUG - Correct answer. Score: 5/10

public static TriviaResponse fromJson(TriviaResponseDto dto)

for (int attempt = 1; attempt <= Config.MAX_RETRIES; attempt++)

class TriviaQuestionDto
class TriviaResponseDto

private final String category;
private final String difficulty;

class TriviaGame { /* state management */ }

# Build with all dependencies
mvn clean package

# Create fat JAR
mvn clean package shade:shade

# Install locally for other projects
mvn install

# Generate javadoc
mvn javadoc:javadoc

# Clean build
mvn clean

# Compile
mvn compile

# Run tests (if added)
mvn test

# Build
mvn build

# Package
mvn package

# Run application
mvn exec:java -Dexec.mainClass="com.trivia.app.TriviaApp"

# Run demo
mvn exec:java -Dexec.mainClass="com.trivia.app.TriviaAppDemo"

# Run with demo profile
mvn exec:java -P demo

# Install to local repository
mvn install

# Generate documentation
mvn javadoc:javadoc

# Show dependency tree
mvn dependency:tree

1. Run demo version first
2. Verify all questions display correctly
3. Test invalid input handling
4. Check score calculation accuracy
5. Verify final results display

Add debug prints or use IDE debugger:

# Run with verbose output
mvn -X exec:java -Dexec.mainClass="com.trivia.app.TriviaAppDemo"

• Install Maven from https://maven.apache.org/download.cgi
• Add Maven bin directory to PATH

• Set JAVA_HOME environment variable to JDK installation
• On Linux/macOS: export JAVA_HOME=/path/to/jdk21
• On Windows: Set via System Properties > Environment Variables

• Check internet connection for live version
• Use demo version if offline: mvn exec:java -Dexec.mainClass="com.trivia.app.TriviaAppDemo"

• Run: mvn dependency:resolve
• Or: mvn clean install

• Enter numbers 1-4 only
• Press Enter after each input

class CustomTriviaClient extends TriviaAPIClient {
    public CustomTriviaClient() {
        super("<https://custom-api.com/trivia", 10000);>
    }
}

class TimedTriviaGame extends TriviaGame {
    private final int secondsPerQuestion = 30;
    // Implement timed logic
}

class ScorePersistence {
    public void saveScore(int score, String playerName) { }
    public List<String> getLeaderboard() { }
}

✓ Strong Type System ✓ Comprehensive Error Handling ✓ Structured Logging Throughout ✓ Clean Code Principles Applied ✓ SOLID Design Patterns Implemented ✓ Well-Commented Source Code ✓ Production-Ready Architecture ✓ Java 21 Features Used

• Leaderboard/score persistence (database)
• Multiple game modes (timed, survival, etc.)
• Difficulty filtering at startup
• Category selection menu
• Player profile management
• Spring Boot REST API wrapper
• Metrics collection (Micrometer)
• Unit test suite (JUnit 5)
• Configuration file support (YAML/properties)
• Docker containerization

• Record Classes: Concise data carriers
• Text Blocks: Multi-line strings
• Pattern Matching: Enhanced type checking
• Virtual Threads: Lightweight concurrency
• Module System: Organized codebase

• Java: https://docs.oracle.com/en/java/javase/21/
• Maven: https://maven.apache.org/
• Gson: https://github.com/google/gson
• HttpClient: https://openjdk.java.net/groups/net/httpclient/

• Oracle Java Documentation: https://docs.oracle.com/javase/
• Maven Getting Started: https://maven.apache.org/guides/getting-started/
• Gson User Guide: https://github.com/google/gson/blob/master/README.md

• Stack Overflow: https://stackoverflow.com/questions/tagged/java
• GitHub: https://github.com/topics/java
• Reddit: https://reddit.com/r/java

MIT License - Free to use and modify

This is a demonstration project. Feel free to:

• Modify the code
• Add new features
• Improve performance
• Submit pull requests

For issues or questions:

1. Check the Troubleshooting section above
2. Review the source code comments
3. Consult the official Java documentation
4. Search Stack Overflow for similar issues

This Java implementation demonstrates:

✓ Modern Java 21: Latest features and patterns ✓ Async HTTP: HttpClient with proper timeout handling ✓ Error Handling: Comprehensive exception management ✓ Logging: Structured logging with severity levels ✓ API Integration: RESTful API consumption with retry logic ✓ Clean Architecture: Separation of concerns and SOLID principles ✓ Best Practices: Production-ready code patterns

Ready to play trivia?

# Quick start
mvn clean compile
mvn exec:java -Dexec.mainClass="com.trivia.app.TriviaAppDemo"

Made with ❤️ following enterprise architecture best practices.