Interoperability with Java

Clojure is not “Java with different syntax,” but it is also not a foreign runtime. It is a JVM language that can use the entire Java ecosystem when it makes sense.

This chapter shows how to call Java code, create objects, implement interfaces, and work with common Java types. More importantly, it teaches boundary design: keep interop localized so most of your code stays idiomatic Clojure and easy to test.

For Java engineers, think of this as building adapters: treat Java APIs as an edge you integrate with, not the center of your Clojure program.

In this section

• Calling Java Methods from Clojure
  Interop call forms (`.`, `Class/staticMethod`) and how to avoid reflection surprises.
  • Java Interop Syntax: Mastering Clojure's Java Interoperability
    Explore the syntax for interacting with Java from Clojure, including calling static and instance methods, accessing fields, and handling Java objects.
  • Accessing Java Fields and Properties in Clojure
    Explore how to access Java fields and properties using Clojure's interop features, leveraging your Java knowledge to seamlessly integrate Clojure into your projects.
  • Java Constructors and Object Creation in Clojure
    Learn how to create Java objects in Clojure using constructors, with examples and comparisons to Java.
• Creating Java Objects
  Construct Java objects and configure them cleanly (often with doto) at interop boundaries.
  • Implementing Interfaces with `proxy` in Clojure
    Learn how to use the `proxy` macro in Clojure to create anonymous classes that implement Java interfaces or extend classes, bridging the gap between Clojure and Java.
  • Clojure `reify` for Interface Implementations: A Guide for Java Developers
    Learn how to use Clojure's `reify` to implement Java interfaces and protocols efficiently, with examples and comparisons to Java.
  • Extending Java Classes in Clojure: A Comprehensive Guide
    Explore how to extend Java classes using Clojure's gen-class, compile Clojure code into Java classes, and understand when to apply these techniques effectively.
• Implementing Interfaces and Extending Classes
  Use reify/proxy when a Java API needs an object callback or interface implementation.
  • Defining Classes with `gen-class` in Clojure for Java Interoperability
    Explore how to define classes in Clojure using `gen-class` for seamless Java interoperability. Learn to specify methods, handle constructors, and create classes that can be instantiated from Java code.
  • Overriding Methods in Clojure: A Guide for Java Developers
    Learn how to override methods in Clojure when extending Java classes or implementing interfaces, with examples and comparisons to Java.
  • Compiling and Using Generated Classes: A Guide for Java Developers
    Learn how to compile Clojure code using `gen-class` into Java bytecode, package it, and use the generated classes in Java applications.
• Handling Java Exceptions
  Use try/catch/finally for Java interop and wrap errors with ex-info when helpful.
  • Catching Java Exceptions in Clojure: A Comprehensive Guide
    Learn how to effectively catch and handle Java exceptions in Clojure using try, catch, and finally constructs. Explore examples and best practices for seamless Java-Clojure interoperability.
  • Throwing Exceptions in Clojure: A Guide for Java Developers
    Learn how to throw exceptions in Clojure, understand exception propagation, and integrate with Java code effectively.
  • Exception Translation Strategies in Clojure and Java Interoperability
    Explore strategies for translating exceptions between Clojure and Java, including creating custom exceptions and wrapping Java exceptions in Clojure exceptions.
• Accessing Java Libraries
  Add Maven dependencies and use Java libraries from Clojure without turning your code into Java-in-Lisp.
  • Leveraging Java Standard Libraries in Clojure
    Learn how to effectively use Java standard library classes in Clojure for collections, I/O, networking, and concurrency utilities.
  • Adding External Java Libraries to Clojure Projects
    Learn how to seamlessly integrate external Java libraries into your Clojure projects using dependencies in project.clj or deps.edn, and explore examples of calling code from popular Java libraries.
  • Handling Method Overloading in Clojure: A Guide for Java Developers
    Explore how Clojure handles Java method overloading, using type hints to resolve ambiguities and enhance performance.
• Integrating Clojure Code in Java Applications
  Call Clojure from Java safely by treating namespaces as a stable API boundary.
  • Compiling Clojure Code for Java Use: A Comprehensive Guide
    Learn how to compile Clojure code into Java bytecode, including Ahead-of-Time (AOT) compilation, and package it into JAR files for seamless integration with Java applications.
  • Invoking Clojure Functions from Java: A Comprehensive Guide
    Learn how to seamlessly call Clojure functions from Java, leveraging compiled classes and the Clojure Java API for dynamic invocation.
  • Managing Classpaths and Dependencies in Clojure and Java Integration
    Learn how to effectively manage classpaths and dependencies when integrating Clojure and Java codebases, ensuring seamless interoperability and efficient development.
• Data Type Conversion Between Java and Clojure
  Convert collections, null/nil, numbers, arrays, and common Java types at the boundary.
  • Primitive Types and Wrappers: Understanding Clojure and Java Interoperability
    Explore how Clojure handles Java primitive types and their wrapper classes, including automatic boxing and unboxing, and ensuring correct type usage.
  • Java Collections Interoperability in Clojure: Conversion Techniques and Best Practices
    Explore seamless conversion between Java collections and Clojure collections, enhancing interoperability and leveraging the strengths of both languages.
  • Handling Arrays in Clojure: Java Interoperability and Beyond
    Explore how to handle Java arrays in Clojure, including creation, access, and modification. Learn about functions like make-array, to-array, and aget, and understand the nuances of Java-Clojure interoperability.
  • Handling `null` Values in Clojure: A Guide for Java Developers
    Explore how Clojure represents Java's `null` as `nil`, and learn strategies for handling `nil` safely in your Clojure applications.
• Performance Considerations in Interop
  Keep interop out of hot loops, avoid reflection, and measure before optimizing.
  • Reflection and Performance Overheads in Clojure and Java Interoperability
    Explore how Clojure's reflection impacts performance when calling Java methods and learn how to use type hints to optimize speed.
  • Type Hinting and Avoiding Reflection in Clojure for Java Interoperability
    Learn how to use type hints in Clojure to optimize Java interoperability and avoid reflection, enhancing performance.
  • Clojure and Java Interoperability: Benchmarks and Profiling
    Explore tools and techniques for profiling Clojure applications interacting with Java code, identifying bottlenecks, and optimizing performance.
• Case Studies and Examples
  See interop patterns applied to real JVM libraries: adapters, boundaries, and testing strategy.
  • Integrating Clojure into a Java Application: A Comprehensive Guide
    Explore the integration of Clojure into existing Java applications, enhancing functionality and leveraging Clojure's strengths. Learn about the process, challenges, and best practices for seamless interoperability.
  • Java Libraries in Clojure: Seamless Integration for Enhanced Functionality
    Explore how to integrate Java libraries into Clojure projects, leveraging Java's extensive ecosystem to enhance Clojure applications. Learn through a detailed example using Apache POI for Excel manipulation.
  • Building Hybrid Systems with Java and Clojure
    Explore the integration of Java and Clojure in hybrid systems, leveraging the strengths of both languages for robust and efficient applications.
• Best Practices for Interoperability
  Design the boundary: isolate Java types, handle nulls, avoid reflection, and keep the core idiomatic.
  • Code Organization for Clojure and Java Interoperability
    Learn best practices for organizing code when mixing Clojure and Java, focusing on separating concerns, clear module boundaries, and consistent naming conventions.
  • Exception Handling Across Languages: Best Practices for Clojure and Java Interoperability
    Explore best practices for handling exceptions across Clojure and Java, ensuring seamless interoperability and robust error management.
  • Testing Interoperable Code: Strategies for Clojure and Java Integration
    Explore comprehensive strategies for testing interoperable code involving Clojure and Java components. Learn about unit testing, integration testing, and the use of test doubles or mocks to ensure robust and reliable software.
  • Maintaining Interoperable Systems: Best Practices for Clojure and Java Integration
    Explore best practices for maintaining systems that integrate Clojure and Java, focusing on dependency management, documentation, and team collaboration.