Sanitizer-Lib: The Java Library That Eliminates Input Sanitization Boilerplate Forever

Ever tired of writing the same input sanitization code over and over again? Scattered trim(), toLowerCase(), and validation logic across your controllers, services, and entities?

I was too. That's why I created Sanitizer-Lib - a simple, powerful Java library that eliminates sanitization boilerplate with declarative annotations.

The Problem Every Java Developer Faces

We've all written code like this:

@PostMapping("/users")
public ResponseEntity<User> createUser(@RequestBody CreateUserRequest request) {
    // Manual sanitization everywhere 😤
    String email = request.getEmail();
    if (email != null) {
        email = email.trim().toLowerCase();
    }
 
    String firstName = request.getFirstName();
    if (firstName != null) {
        firstName = firstName.trim();
        firstName = Character.toUpperCase(firstName.charAt(0)) +
                   firstName.substring(1).toLowerCase();
    }
 
    // ... more boilerplate code
    User user = new User(email, firstName);
    return ResponseEntity.ok(userService.save(user));
}

Problems with this approach:

🔄 Repetitive boilerplate code
🐛 Easy to forget sanitization in some places
🧪 Hard to test consistently
📈 Maintenance nightmare as the app grows

The Solution: Sanitizer-Lib

With Sanitizer-Lib, the same code becomes:

public class CreateUserRequest {
    @Sanitize(using = {TrimSanitizer.class, LowerCaseSanitizer.class})
    private String email;
 
    @Sanitize(using = {TrimSanitizer.class, TitleCaseSanitizer.class})
    private String firstName;
 
    // Getters and setters
}
 
@PostMapping("/users")
public ResponseEntity<User> createUser(@RequestBody CreateUserRequest request) {
    // Data is automatically sanitized! ✨
    User user = new User(request.getEmail(), request.getFirstName());
    return ResponseEntity.ok(userService.save(user));
}

Clean. Simple. Automatic.

Key Features That Make It Awesome

🚀 Zero Configuration Setup

Add the dependency and you're ready to go. Spring Boot auto-configuration handles everything:

<dependency>
    <groupId>io.github.rabinarayanpatra.sanitizer</groupId>
    <artifactId>sanitizer-spring</artifactId>
    <version>1.0.22</version>
</dependency>

🎯 Built-in Sanitizers for Common Use Cases

TrimSanitizer - Removes leading/trailing whitespace
LowerCaseSanitizer - Converts to lowercase (perfect for emails)
TitleCaseSanitizer - Proper title case formatting
CreditCardMaskSanitizer - Masks card numbers for security

🔗 Seamless Spring Boot Integration

Works automatically with Jackson during JSON deserialization:

// POST /api/users with JSON: {"email": "  JOHN@EXAMPLE.COM  "}
public class UserDto {
    @Sanitize(using = {TrimSanitizer.class, LowerCaseSanitizer.class})
    private String email; // Becomes: "john@example.com"
}

🗄️ JPA Entity Protection

Sanitize data before it hits your database:

@Entity
@EntityListeners(SanitizationEntityListener.class)
public class User {
    @Sanitize(using = {TrimSanitizer.class, LowerCaseSanitizer.class})
    private String email;
 
    @Sanitize(using = CreditCardMaskSanitizer.class)
    private String cardNumber; // Automatically masked before save
}

Real-World Example: E-commerce Product

Here's how Sanitizer-Lib works in a real application:

public class ProductRequest {
    @Sanitize(using = {TrimSanitizer.class, TitleCaseSanitizer.class})
    private String name;        // "  apple iphone  " → "Apple Iphone"
 
    @Sanitize(using = {TrimSanitizer.class, LowerCaseSanitizer.class})
    private String category;    // "  ELECTRONICS  " → "electronics"
 
    @Sanitize(using = TrimSanitizer.class)
    private String description; // Preserves case, removes whitespace
}
 
@RestController
public class ProductController {
 
    @PostMapping("/products")
    public Product createProduct(@RequestBody ProductRequest request) {
        // All fields are automatically sanitized during JSON parsing!
        return productService.create(request);
    }
}

Custom Sanitizers for Your Business Logic

Need domain-specific sanitization? Create custom sanitizers easily:

@Component
public class PhoneNumberSanitizer implements FieldSanitizer<String> {
 
    @Override
    public String sanitize(String input) {
        if (input == null) return null;
 
        // Remove all non-digits
        String digits = input.replaceAll("[^0-9]", "");
 
        // Format US phone numbers
        if (digits.length() == 10) {
            return String.format("(%s) %s-%s",
                digits.substring(0, 3),
                digits.substring(3, 6),
                digits.substring(6));
        }
 
        return digits;
    }
}
 
// Usage
public class ContactDto {
    @Sanitize(using = PhoneNumberSanitizer.class)
    private String phone; // "555-123-4567" → "(555) 123-4567"
}

Security First: PCI Compliance Made Easy

Handle sensitive data safely with built-in security sanitizers:

@Entity
@EntityListeners(SanitizationEntityListener.class)
public class Payment {
 
    @Sanitize(using = CreditCardMaskSanitizer.class)
    private String cardNumber; // "1234567890123456" → "**** **** **** 3456"
 
    @Sanitize(using = {TrimSanitizer.class, TitleCaseSanitizer.class})
    private String cardholderName;
}

Why I Built This Library

As a Java developer, I was frustrated with:

Repetitive Code - Writing the same sanitization logic everywhere
Inconsistency - Different sanitization rules across the codebase
Maintenance - Updating sanitization logic in multiple places
Testing - Ensuring sanitization works correctly everywhere

Sanitizer-Lib solves all these problems with a clean, declarative approach that's:

✅ Consistent - Same sanitization rules everywhere
✅ Maintainable - Change logic in one place
✅ Testable - Easy to unit test sanitizers
✅ Performant - Minimal overhead
✅ Flexible - Easy to extend with custom sanitizers

Architecture: Clean and Modular

Sanitizer-Lib follows a modular design:

sanitizer-lib/
├── sanitizer-core/    ← Core API and built-in sanitizers
├── sanitizer-spring/  ← Spring Boot integration
└── sanitizer-jpa/     ← JPA entity lifecycle hooks

This allows you to use only what you need:

Just core? Use sanitizer-core
Spring Boot app? Add sanitizer-spring
Need JPA integration? Include sanitizer-jpa

Getting Started in 2 Minutes

1. Add the Dependency

<dependency>
    <groupId>io.github.rabinarayanpatra.sanitizer</groupId>
    <artifactId>sanitizer-spring</artifactId>
    <version>1.0.15</version>
</dependency>

2. Annotate Your Fields

public class UserRegistrationDto {
    @Sanitize(using = {TrimSanitizer.class, LowerCaseSanitizer.class})
    private String email;
 
    @Sanitize(using = {TrimSanitizer.class, TitleCaseSanitizer.class})
    private String fullName;
}

3. That's It!

Your data is automatically sanitized during JSON deserialization. No configuration needed.

Performance and Production Ready

Sanitizer-Lib is built for production use:

🚀 Fast - Minimal overhead, efficient processing
🔒 Secure - Built-in sanitizers for sensitive data
📊 Observable - Integrates with Spring Boot Actuator
🧪 Well-Tested - Comprehensive test suite
📚 Documented - Clear documentation and examples

Contributing and Roadmap

Sanitizer-Lib is open source and welcomes contributions!

Current features:

✅ Spring Boot integration
✅ JPA entity lifecycle hooks
✅ Built-in sanitizers
✅ Custom sanitizer support
✅ Maven Central deployment

Planned features:

🔄 Validation integration
🎯 More built-in sanitizers
📈 Performance optimizations
🔧 Configuration properties

Try It Today!

Ready to eliminate sanitization boilerplate from your Java applications?

Quick Start:

# Add to your Spring Boot project
<dependency>
    <groupId>io.github.rabinarayanpatra.sanitizer</groupId>
    <artifactId>sanitizer-spring</artifactId>
    <version>1.0.22</version>
</dependency>

Resources:

📚 GitHub: github.com/rabinarayanpatra/sanitizer-lib
📦 Maven Central: Available now
📖 Documentation: Comprehensive examples in the README
🐛 Issues: Report bugs and request features on GitHub

Conclusion

Sanitizer-Lib transforms tedious, error-prone sanitization code into clean, declarative annotations. With zero configuration and powerful Spring Boot integration, it's the missing piece your Java applications need.

Stop writing sanitization boilerplate. Start using Sanitizer-Lib.

What sanitization challenges are you facing in your Java projects? Try Sanitizer-Lib and let me know how it works for you! ⭐

Happy coding! ☕✨