How to Use Google Java Format with Spotless

 

Introduction

Bringing Order to Chaos: Google Java Format and Spotless in Action—Automating Code Formatting for a Cleaner, More Efficient Codebase.

We've all been there. You push your code, feeling like a rockstar, only to be met with a wave of nitpicky code review comments: "Indentation is off," "Use spaces, not tabs," "Dude, who puts a curly brace on the same line?"

It's a never-ending battle—unless you have an enforcer. Enter Google Java Format, the ultimate formatting referee that settles these debates once and for all. But who has time to manually run a formatter on every file? That's where Spotless comes in, automating the entire process and ensuring every commit is clean, compliant, and free of formatting drama.

In this guide, we’ll walk you through setting up Google Java Format with Spotless in both Gradle and Maven projects. By the end, you'll wonder how you ever coded without it!

Why Use Google Java Format?

Imagine merging your feature branch and seeing a pull request filled with hundreds of unnecessary diffs—tabs switched to spaces, misplaced brackets, random newlines. It's like your code went on a formatting rollercoaster.

With Google Java Format, you:

• Automate Code Formatting – Because life's too short for manual indentation fixes.

• Ensure Consistency – No more "tabs vs. spaces" holy wars.

• Simplify Integration – Works like a charm with Gradle and Maven.

• Reduce Merge Conflicts – Fewer unnecessary changes mean happier developers.

So let’s set it up and finally move on to actual coding.

Setting Up Google Java Format with Spotless in Gradle

Step 1: Add the Spotless Plugin to build.gradle

First, install the Spotless plugin.

If using Kotlin DSL (build.gradle.kts):

plugins {
    id("com.diffplug.spotless") version "6.0.0"
}

If using Groovy DSL (build.gradle):

plugins {
    id 'com.diffplug.spotless' version '6.0.0'
}

Step 2: Configure Spotless to Use Google Java Format

Now, set Spotless to auto-format your Java files.

Kotlin DSL (build.gradle.kts)

spotless {
    java {
        target("src/**/*.java")
        googleJavaFormat()
    }
}

Groovy DSL (build.gradle)

spotless {
    java {
        target 'src/**/*.java'
        googleJavaFormat()
    }
}

Step 3: Apply Formatting

Run this to format all Java files:

gradle spotlessApply

Check for compliance before committing:

gradle spotlessCheck

If it fails, just run spotlessApply to fix everything automagically. 🚀

Setting Up Google Java Format with Spotless in Maven

Step 1: Add the Spotless Plugin to pom.xml

For Maven users, add this to your <build> section:

<build>
    <plugins>
        <plugin>
            <groupId>com.diffplug.spotless</groupId>
            <artifactId>spotless-maven-plugin</artifactId>
            <version>2.35.0</version>
            <executions>
                <execution>
                    <goals>
                        <goal>apply</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <formats>
                    <format>
                        <includes>
                            <include>src/**/*.java</include>
                        </includes>
                        <googleJavaFormat/>
                    </format>
                </formats>
            </configuration>
        </plugin>
    </plugins>
</build>

Step 2: Apply Formatting

Run:

mvn spotless:apply

To check compliance:

mvn spotless:check

Now your Java files are always in top shape!

Customizing Spotless

Need more control? Here are some tweaks.

Use a Specific Google Java Format Version

By default, Spotless grabs the latest version, but you can lock it down:

Gradle

spotless {
    java {
        googleJavaFormat("1.15.0")
    }
}

Maven

<configuration>
    <googleJavaFormat>
        <version>1.15.0</version>
    </googleJavaFormat>
</configuration>

Exclude Certain Files

Want to keep specific files untouched? No problem.

Gradle

spotless {
    java {
        target("src/**/*.java")
        googleJavaFormat()
        exclude("src/main/java/com/example/IgnoreThisFile.java")
    }
}

Maven

<excludes>
    <exclude>src/main/java/com/example/IgnoreThisFile.java</exclude>
</excludes>

Enforce Formatting in CI/CD

Make sure no rogue formatting sneaks into your codebase!

GitHub Actions Integration

Create a .github/workflows/spotless.yml file:

name: Spotless Check
on: [push, pull_request]
jobs:
  check-format:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
          java-version: '17'
      - name: Set up Gradle
        uses: gradle/gradle-build-action@v2
      - name: Run Spotless Check
        run: ./gradlew spotlessCheck

For Maven:

- name: Run Spotless Check
  run: mvn spotless:check

Now every PR will be checked before it gets merged. No more formatting surprises! 🎉

Conclusion

Imagine a world where formatting discussions never waste another second of your time. That world is here. Google Java Format + Spotless means you spend more time writing great code and less time arguing over curly braces.

Now, it’s your turn! Have you tried Google Java Format with Spotless? What’s your biggest formatting headache? Drop a comment below—we’d love to hear your thoughts!

🚀 Looking for more Java productivity tips? Check out our other posts:

• How to Automate Code Quality Checks in Java

• Top 10 Gradle Plugins for Java Developers

• Debugging Like a Pro: Best Tools for Java Devs

Happy coding, and may your commits always be spotless! 😎

Checkstyle vs. Spotless: The Ultimate Showdown – Which One Will Save Your Sanity?

 

Introduction

👋 Picture this: You’ve spent hours working on a feature. You push your code, feeling like a rockstar. Then – BAM! 🚨 Your CI/CD pipeline fails. Why? Because you forgot a space after a comma.

Or maybe your curly brace is on the wrong line. Or you used tabs instead of spaces. The horror! 😱

At this point, you have two choices:

1. Spend another 30 minutes fixing tiny formatting errors while silently questioning your career choices.
2. Use a tool that fixes these problems automatically, so you never have to think about them again.

Enter Checkstyle vs. Spotless – the ultimate battle between code enforcer and code fixer. Which one should you use? And if you're stuck with Checkstyle, how can you escape and move to Spotless? Let’s dive in.

---

🥊 Checkstyle vs. Spotless: What’s the Difference?

Imagine you’re a chef 🍳 in a high-end restaurant:

• Checkstyle is the angry head chef 👨‍🍳 screaming at you for chopping onions the wrong way. He won’t fix it for you, but he’ll make sure you know you messed up.
• Spotless is the friendly sous-chef 🤝 who quietly steps in and fixes your sloppy cuts before the dish goes out.

Both serve a purpose, but they work very differently:

Feature	Checkstyle 🛑 (The Code Inspector)	Spotless ✅ (The Code Fixer)
What It Does	Reports coding violations	Automatically fixes formatting issues
Configuration	Uses checkstyle.xml to define strict rules	Uses formatters like Google Java Format, Prettier, Eclipse
Does It Fix Code?	❌ No, just complains	✅ Yes, auto-fixes mistakes
Best For	Teams that want strict linting	Developers who want pain-free formatting

🔥 So Which One Should You Use?

• Checkstyle if you love suffering and enjoy fixing the same formatting issues over and over.
• Spotless if you want a happier, stress-free coding experience where everything is automatically formatted.
• Both! Some teams use Spotless for formatting and Checkstyle for rule enforcement that Spotless doesn’t cover.

---

🤔 Why Should You Migrate from Checkstyle to Spotless?

Let me tell you a real-life developer horror story.

👩‍💻 Emma, a junior dev, joins a team that uses Checkstyle. Excitedly, she writes her first piece of code. She submits a pull request, and suddenly...

🚨 “Checkstyle violations detected!” 🚨

She scrolls through 500+ errors:

• "Method must be ordered alphabetically." 🤯
• "Expected 1 blank line, found 2." 😵
• "Line is too long (81 characters instead of 80)." 😡

After an entire afternoon of fixing spaces, brackets, and commas, she finally gets it to pass.

Then she discovers Spotless. She runs one command, and BOOM – all formatting issues are gone in seconds. 🎉

Don’t be like early Emma. Be like Smart Emma™. Switch to Spotless.

---

🛠️ How to Migrate from Checkstyle to Spotless in a Maven Project

Step 1: Yeet Checkstyle Out of Your pom.xml

Find the Checkstyle plugin in your pom.xml and delete it:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-checkstyle-plugin</artifactId>
    <version>3.1.2</version>
    <executions>
        <execution>
            <phase>validate</phase>
            <goals>
                <goal>check</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <configLocation>checkstyle.xml</configLocation>
    </configuration>
</plugin>

💀 RIP, Checkstyle. You won’t be missed.

---

Step 2: Add Spotless to pom.xml

Now, add this beautiful, sanity-saving plugin under <plugins>:

<plugin>
    <groupId>com.diffplug.spotless</groupId>
    <artifactId>spotless-maven-plugin</artifactId>
    <version>2.44.0</version>
    <executions>
        <execution>
            <goals>
                <goal>apply</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <java>
            <googleJavaFormat/>
        </java>
    </configuration>
</plugin>

🚀 This does two magical things:

1. It automatically formats your Java code to Google's style guide.
2. It saves you hours of manual formatting pain.

---

Step 3: Run Spotless and Watch the Magic Happen

To instantly fix all formatting issues, run:

mvn spotless:apply

And just like that... 💥

🎉 Your code is perfectly formatted, no manual effort required! 🎉

---

🏆 The Final Verdict: Checkstyle vs. Spotless

• If you love pain, use Checkstyle.
• If you love productivity, use Spotless.
• If your team has trust issues and wants a mix of both, go ahead and use both.

At the end of the day, coding should be fun, not frustrating. The less time you spend fighting formatting issues, the more time you have for actual problem-solving.

👉 Are you using Checkstyle or Spotless? Have a formatting horror story? Drop a comment below! Let’s hear it. 🎤👇

🔗 Related Reads:

• Maven Best Practices for Java Projects
• How to Use Google Java Format with Spotless
• Why You Should Automate Code Formatting

💡 If you found this helpful, share it with your team so they don’t waste their lives fixing formatting issues. 🚀

Creating Views in Databricks: A Deep Dive with Humor and Real-World Scenarios

 

Introduction

Picture this: You walk into your favorite coffee shop, and the barista already knows your order. No need to list out the exact ratio of oat milk to espresso every time—you just say, "the usual," and boom, your coffee appears. Wouldn’t it be nice if databases worked that way too? Well, guess what? They do! That’s where views in Databricks come in.

Views act like that barista shortcut—reusable, predefined queries that save you from repeating complex SQL logic over and over. In this guide, we’re going to make Databricks views as easy to understand as ordering your morning caffeine fix—with humor, real-world examples, and practical insights. Let’s dive in! ☕🚀

---

What Are Views in Databricks?

Think of a view as your data assistant. You wouldn’t want to go grocery shopping and have to milk a cow every time you need dairy, right? Instead, you get the neatly packaged carton from the store. Similarly, views let you predefine complex queries and serve them up neatly whenever you need.

A view in Databricks is a virtual table that doesn’t store data but allows structured access to data using a SQL query. It’s a simple way to reuse logic, enforce security, and improve performance.

Why Use Views? Because Sanity Matters!

1. Simplifies Complex Queries: Think of it as using Google Maps instead of manually checking a paper map with a magnifying glass.
2. Enhances Security & Access Control: Give interns access to read-only views, so they don’t "accidentally" drop your production tables. 🚨
3. Optimizes Performance: Like meal prepping for the week instead of cooking from scratch every night.
4. Ensures Data Consistency: Your reports will always match, reducing those awkward "Wait, why do our numbers look different?" moments in meetings.

---

Types of Views in Databricks

Different situations call for different types of views. Let’s explore them with fun analogies.

1. Temporary Views (Like a Sticky Note)

Temporary views exist only while your session is active. It’s like writing something on a sticky note—you use it, but once the meeting (session) is over, it’s gone.

Example:

CREATE TEMP VIEW temp_customer_view AS
SELECT customer_id, name, age FROM customers WHERE age > 25;

2. Global Temporary Views (Like a Shared Netflix Account)

A global temporary view is available across all sessions in the same cluster, like how multiple people can log into the same Netflix account (until someone changes the password!).

Example:

CREATE GLOBAL TEMP VIEW global_customer_view AS
SELECT customer_id, name, age FROM customers WHERE age > 25;

To query a global temporary view:

SELECT * FROM global_temp.global_customer_view;

3. Permanent Views (Like a Library Book)

Permanent views are stored in the Databricks metastore, meaning they persist and can be accessed anytime—like a library book that doesn’t magically disappear overnight.

Example:

CREATE VIEW customer_view AS
SELECT customer_id, name, age FROM customers WHERE age > 25;

---

Creating Views in Databricks: A Step-by-Step Guide

Let’s say you’re running an e-commerce business and want to analyze sales trends. Instead of running the same clunky SQL query every time, create a view!

1. Using SQL

Your marketing team constantly asks, "Hey, which products are selling best?" Instead of retyping the query every time, create a reusable view:

CREATE VIEW sales_summary AS
SELECT product_id, SUM(sales_amount) AS total_sales
FROM sales
GROUP BY product_id;

Now, every time they need this information, they can simply run:

SELECT * FROM sales_summary;

2. Using Python (PySpark)

If you’re the Python person in your team, here’s how you’d do the same thing in PySpark.

from pyspark.sql import SparkSession

# Initialize Spark Session
spark = SparkSession.builder.appName("DatabricksViews").getOrCreate()

# Load Data
df = spark.read.format("csv").option("header", "true").load("/mnt/data/sales.csv")

# Create a Temporary View
df.createOrReplaceTempView("sales_view")

# Query the View
result = spark.sql("SELECT * FROM sales_view")
result.show()

---

Managing Views Without Losing Your Mind

Listing Views

Want to know what views exist? It’s like checking which WiFi networks are available:

SHOW VIEWS;

To filter views within a database:

SHOW VIEWS IN my_database;

Altering a View

Need to tweak the query? It’s like updating your Spotify playlist:

ALTER VIEW sales_summary AS
SELECT product_id, COUNT(sales_id) AS total_sales
FROM sales
GROUP BY product_id;

Dropping a View

Views, like bad habits, should be dropped when they no longer serve you:

DROP VIEW IF EXISTS sales_summary;

For temporary views in PySpark:

spark.catalog.dropTempView("sales_view")

---

Best Practices: The Secret Sauce for Efficient Views

🚀 1. Use Permanent Views for Reusability

If multiple teams frequently access a dataset, permanent views ensure consistency and avoid repeated queries.

📈 2. Optimize for Performance

Instead of deeply nested views (which can slow things down like a 56K modem), consider caching frequently used queries.

🔒 3. Enforce Security Controls

Need to hide sensitive columns? Use a restricted view:

CREATE VIEW customer_restricted_view AS
SELECT customer_id, name FROM customers;

Now, no one gets to see credit card details—because that would be bad. Really bad. 🚨

⚡ 4. Avoid Nesting Views

Over-nesting is like stacking too many Jenga blocks—it’s going to collapse at some point. Keep it simple.

🔄 5. Leverage Delta Tables for Large Datasets

If your dataset is bigger than your morning coffee intake, consider Delta Lake tables instead of standard views for better performance.

---

Conclusion: Views Make Life Easier (and Saner)

Databricks views are your secret weapon for simplifying queries, improving security, and making data analysis smoother than a fresh cup of coffee. Whether you’re an analyst tired of running the same query 100 times a day, a data engineer optimizing workflows, or just someone who loves a good SQL trick, views are here to make your life easier.

So the next time you find yourself copy-pasting SQL like a mad scientist, stop. Create a view. Save time. Stay sane. 🚀☕