动态 Java 程序的 DLL？

发布于 2024-10-10 04:45:17 字数 477 浏览 0 评论 0原文

我目前正在开发一个 Java 项目，其中有一组数据希望以多种自定义格式输出。我为每种格式都有一个类，它获取原始数据并进行相应的转换。然而，一开始我只实现了其中的两种或三种格式，但希望允许在以后添加更多格式，而不必对应用程序进行大规模重建。

我的想法是为每个格式类创建一个 DLL，并让我的应用程序传递要转换为每个格式类的数据。这样，我可以稍后创建一个 DLL 并让我的主应用程序访问它。（我很乐意听取任何替代方法，因为之前在 C++/C# 中完成此操作的人感觉这是合乎逻辑的解决方案，但它可能不适用于 Java）

我的问题是我完全不知道如何这样做 - 在 C++/C# 中，我可以用几行代码编写它，但我不确定它如何与 Java 一起工作。冒着问一个非常模糊的问题的风险，我该怎么做？

非常感谢您的回答，并将提供饼干和茶。：）

提前致谢， M

编辑：抱歉，只是补充一下：我也不确定如何创建 DLL，该项目必须使用 Java 来首先读取该 DLL。谢谢。 :)

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

单调的奢华 2024-10-17 04:45:17

看起来我们需要的是某种插件架构，而不是使用 DLL 本身。

除非有必要，否则我不建议使用 DLL 的原因之一是，将 Java 代码与本机代码链接需要使用 Java 本机接口 (JNI)，这可能比纯 Java 解决方案需要更多的努力。

一种相对简单的方法是使用 Java 的反射功能。

根据给出的信息，我可能会遵循以下原则：

定义输出格式的接口。
创建一个实现该接口的 Java 类。
从类路径获取该类。
使用反射动态加载类。（使用 类.newInstance 方法可以实例化由 ClassLoader 加载的 class 文件中的对象。）

通过这些步骤，就可以实现一个简单的插件当需要支持新格式时，不需要完全重建。

第 1 步：定义接口

假设我们最终得到如下接口：

public interface Outputter {
  public void write(Data d);
}

第 2 步：创建一个实现类

然后，我们将创建一个实现类。

public class TextOutputter {
  public void write(Data d) {
    // ... output data to text
  }
}

然后，编译上述内容，我们最终会得到一个名为 TextOutputter.class 的 class 文件。

第 3 步：使类在类路径中可用

运行主应用程序时，我们需要在类路径。通常，我们会告诉 JVM 一份要考虑作为类路径的位置列表，其中应该包括上面的 class 文件。

完成后，我们应该能够使用反射加载上述类。

第 4 步：使用反射动态加载类

现在，当我们真正想要加载上述类时，我们会执行如下操作：

// Note: We load the class by specifying the fully-qualified class name!
Class<?> clazz = Class.forName("TextOutputter");

// Then, we instantiate the class.
// Note that the following method will call the no-argument constructor.
Outputter outputter = clazz.newInstance();      

// Now, we can give data to the TextOutputter object that we loaded dynamically.
outputter.write(...);

Class.forName 方法用于尝试从默认的 ClassLoader 中查找 TextOutputter 类。一旦我们获得 Class表示，然后我们可以实例化该类的对象。

可以使用 Class.newInstance 方法。如果应使用除无参构造函数之外的其他构造函数，则必须获取该类的构造函数以继续从那里实例化对象。

然后，通过反射实例化的对象被放入 Outputter 变量中，因此可以在 TextOutputter 上调用 write 方法。

添加更多格式需要执行上述过程，但只需更改完全限定的类名（例如对于String，FQCN 为java.lang.String）即可加载不同的类。

简而言之，这就是动态加载 class 文件并从应用程序中使用它所需要的。

（顺便说一句，我实际上并没有编译上面的代码，所以可能会有一些错误，但我希望我能说明它所需要的过程。）

Rather than using a DLL per se, it seems like what is wanted is a plugin architecture of some sort.

One reason why I wouldn't recommend using a DLL unless it is necessary is that linking Java code with native code will require using the Java Native Interface (JNI) which would probably require more effort than a pure Java solution.

One relatively simple way to do so is to use the reflection capabilities of Java.

From the information given, I would probably go along the lines of the following:

Define an interface for the output format.
Create a Java class implementing the interface.
Have the class available from the classpath.
Dynamically load the class using reflection. (Using the Class.newInstance method can instantiate objects from class files loaded by the ClassLoader.)

With these steps, it would be possible to implement a simplistic plugin which wouldn't require a full rebuild when support for a new format is required.

Step 1: Define the interface

Let's say we end up with an interface like the following:

public interface Outputter {
  public void write(Data d);
}

Step 2: Make an implementation class

Then, we'll make an implementation class.

public class TextOutputter {
  public void write(Data d) {
    // ... output data to text
  }
}

Then, compiling the above, we'll end up with a class file called TextOutputter.class.

Step 3: Make the class available from the classpath

When running the main application, we'll need to have the above TextOutputter.class in the classpath. Normally, one would tell the JVM a list of places to consider as the classpath, and that should include the above class file.

Once that is done, we should be able to load the above class using reflection.

Step 4: Dynamically load the class using reflection

Now, when we actually want to load the above class, we'd do something like the following:

// Note: We load the class by specifying the fully-qualified class name!
Class<?> clazz = Class.forName("TextOutputter");

// Then, we instantiate the class.
// Note that the following method will call the no-argument constructor.
Outputter outputter = clazz.newInstance();      

// Now, we can give data to the TextOutputter object that we loaded dynamically.
outputter.write(...);

The Class.forName method is used to attempt to find the TextOutputter class from the default ClassLoader. Once we obtain the class as a Class representation, we can then instantiate an object of that class.

Instantiating the object can be performed by using the Class.newInstance method. If something other than the no-argument constructor should be used, the Constructor of the class would have to be obtained proceed to instantiate the object from there.

The object instantiates via reflection is then placed into a Outputter variable, so the write method can be called on the TextOutputter.

Adding more formats would entail the above process, but changing the fully-qualified class name (e.g. for String, the FQCN is java.lang.String) is all that is needed to load up a different class.

In a nutshell, that's what it will take to dynamically load class files and use it from your application.

(Just as a side note, I did not actually compile the above code, so there may be some errors here and there, but I hope I could illustrate the process it will take.)

回复收藏 0 原文