What is Sanitizer-Lib and how does it work?

Sanitizer-Lib is a Java library that replaces manual input sanitization code with declarative annotations. You annotate your DTO fields with @Sanitize and specify sanitizers like TrimSanitizer or LowerCaseSanitizer. The library automatically sanitizes data during JSON deserialization or JPA entity persistence.

Does Sanitizer-Lib work with Spring Boot?

Yes. Add the sanitizer-spring dependency and Spring Boot auto-configuration handles everything. It integrates with Jackson for automatic sanitization during JSON deserialization and with JPA entity lifecycle hooks for database-level sanitization.

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.

What input sanitization problem does every Java developer face?

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

How does Sanitizer-Lib solve input sanitization with annotations?

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.

What key features does Sanitizer-Lib offer?

🚀 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
}

How does Sanitizer-Lib work in a real e-commerce application?

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);
    }
}

How do you create custom sanitizers for domain-specific 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"
}

How does Sanitizer-Lib help with PCI compliance and sensitive data?

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 did I build Sanitizer-Lib?

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! ⭐

Keep Reading

Sanitizer-Lib is Now Live on Maven Central — The library is now on Maven Central with signed artifacts and zero extra repository config needed.
10 Essential Java Libraries Beyond Lombok — More libraries that eliminate boilerplate and make your Java code cleaner.

Happy coding! ☕✨