如何在Xcode 9的iOS（Swift）项目中导入并使用Java通用库

Got it, let's break down how to get your Java cross-platform library working in an Xcode 9 Swift project. Since Java and Swift/iOS don't speak the same natively, we need a bridge to connect them. Here are three solid, tested approaches you can try:

1. Use J2ObjC (Google's Java-to-Objective-C Transpiler) #

This is the most straightforward option if you want to keep your Java library as-is. J2ObjC converts Java code to Objective-C, which Swift can seamlessly interact with:

• First, download the J2ObjC tool and configure your terminal's path so you can run its commands easily.
• Convert your Java library (either source files or a compiled JAR) to Objective-C with this command:

  j2objc -d ./objc-output -classpath ./path/to/your/java-library.jar ./path/to/java/source/files/*.java
  

  The -d flag sets where the converted Objective-C files go, and -classpath points to any dependencies your Java library relies on.
• Drag all generated .h and .m files into your Xcode 9 project. Make sure to check "Copy items if needed" when prompted.
• In Xcode's Build Settings:
  • Add the J2ObjC include directory (usually j2objc-*/include in the tool's folder) to Header Search Paths.
  • Link against the j2objc_main.a static library found in the tool's lib folder.
• Create an Objective-C Bridging Header if you don't have one already. Add imports for the converted Objective-C headers here (e.g., #import "YourJavaCoreClass.h").
• Now you can call the converted classes directly in Swift, just like you would any native Swift type!

2. JNI + Objective-C Wrapper (For Low-Level Control) #

If you’re familiar with JNI (Java Native Interface), this approach lets you wrap your Java code in a C/C++ layer, then expose it to Swift via Objective-C:

• Write JNI interface methods in Java to expose your library’s core functionality. Example:

  public class MyJavaLib {
      public native String getAppStatus();
      // Add other native methods for key features
  }
  

• Generate the JNI header file using javah (included with the JDK):

  javah -jni com.yourpackage.MyJavaLib
  

• Implement the JNI methods in C/C++, then compile them into an iOS-compatible static library (.a) using a cross-compiler that targets iOS architectures (arm64 for devices, x86_64 for simulators).
• Import the .a library and JNI header into your Xcode 9 project.
• Write an Objective-C wrapper class to simplify calling the C/C++ JNI methods. Example:

  // MyLibWrapper.h
  #import <Foundation/Foundation.h>
  
  @interface MyLibWrapper : NSObject
  + (NSString *)getAppStatus;
  @end
  

  // MyLibWrapper.m
  #import "MyLibWrapper.h"
  #import "com_yourpackage_MyJavaLib.h"
  
  @implementation MyLibWrapper
  + (NSString *)getAppStatus {
      const char *status = Java_com_yourpackage_MyJavaLib_getAppStatus(NULL, NULL);
      return [NSString stringWithUTF8String:status];
  }
  @end
  

• Add the wrapper’s header to your Objective-C Bridging Header, then call it in Swift:

  let currentStatus = MyLibWrapper.getAppStatus()
  print(currentStatus)
  

3. Kotlin Multiplatform (Modern Long-Term Solution) #

If you’re open to migrating your Java library to Kotlin, Kotlin Multiplatform (KMP) lets you build a single library that works natively for both Android and iOS:

• Use Android Studio’s built-in Java-to-Kotlin converter to port your library code to Kotlin.
• Create a new Kotlin Multiplatform project, then move your converted code into the commonMain source set.
• Configure the iOS target in your build.gradle.kts file to generate an iOS framework.
• Build the framework, then drag it into your Xcode 9 project.
• In Swift, import the framework and call its methods directly—no extra bridging required!

Quick Xcode 9 Notes #

Since Xcode 9 uses Swift 4, double-check that your bridging headers and converted code are compatible. Also, ensure your static libraries/frameworks include all required architectures (arm64 for devices, x86_64 for simulators) and that you’re targeting a supported iOS version (Xcode 9 works with iOS 8.0+).

Pick the approach that best fits your team’s skills: J2ObjC is ideal for keeping your Java library untouched, JNI offers fine-grained control, and KMP is a great choice if you want to modernize your cross-platform setup.

内容的提问来源于stack exchange，提问作者user6644763