相当于Java中的#define？

Question

我正在编写一个库，如果包含特定库，则需要一些代码。由于此代码分散在项目各处，因此如果用户不必自己注释/取消注释所有内容，那就太好了。

在 C 中，这很容易，只需在标头中添加 #define，然后用 #ifdefs 包围代码块。当然，Java 没有 C 预处理器......

澄清一下 - 几个外部库将与我的一起分发。我不想将它们全部包含在内以最小化可执行文件的大小。如果开发人员确实包含一个库，我需要能够使用它，如果没有，那么它可以被忽略。

在 Java 中执行此操作的最佳方法是什么？

Answer 1

嗯，Java 语法与 C 非常接近，您可以简单地使用 C 预处理器，它通常作为单独的可执行文件提供。

但无论如何，Java 并不是真正在编译时做事。我以前处理类似情况的方法就是反思。在您的情况下，由于对可能不存在的库的调用分散在整个代码中，因此我将创建一个包装器类，将所有对库的调用替换为对包装器类的调用，然后在包装器类中使用反射调用库（如果存在）。

Answer 2

使用 常量：

本周我们创建了一些常量
具有使用的所有好处
C 预处理器的功能
定义编译时常量和
条件编译代码。

Java已经摆脱了整个
文本预处理器的概念（如果
你把Java看作是Java的“后代”
C/C++）。然而，我们可以得到最好的
至少有一些 C 的好处
Java 预处理器的特点：
常量和条件编译。

Answer 3

我不相信真的有这样的事情。大多数真正的 Java 用户会告诉您这是一件好事，并且应该不惜一切代价避免依赖条件编译。

我不太同意他们的观点...

您可以使用可以从编译行定义的常量，这会产生一些效果，但并不是全部。 （例如，你不能有无法编译的东西，但你仍然想要在 #if 0 内...（不，注释并不总能解决这个问题，因为嵌套注释可能很棘手... ））。

我认为大多数人会告诉你使用某种形式的继承来做到这一点，但这也可能非常难看，有很多重复的代码......

也就是说，你总是可以设置你的 IDE 来抛出你的 java在将其发送到 javac 之前通过预处理器...

Answer 4

“最小化我的可执行文件大小”

“可执行文件大小”是什么意思？

如果您指的是运行时加载的代码量，那么您可以通过类加载器有条件地加载类。因此，无论如何，您都会分发替代代码，但只有在缺少它所代表的库时才会实际加载它。您可以使用适配器（或类似的）来封装 API，以确保几乎所有代码都完全相同，并且根据您的情况加载两个包装类之一。 Java 安全 SPI 可能会给您一些如何构建和实现的想法。

如果您指的是 .jar 文件的大小，那么您可以执行上述操作，但告诉您的开发人员如何从 jar 中删除不必要的类，以防他们知道不需要这些类。

Answer 5

我还有一种最好的说法。

你需要的是一个最终变量。

public static final boolean LibraryIncluded= false; //or true - manually set this

然后在代码中说：

if(LibraryIncluded){
    //do what you want to do if library is included
}
else
{
    //do if you want anything to do if the library is not included
}

这将像#ifdef一样工作。任何一个块都将出现在可执行代码中。其他的将在编译时本身被消除

Answer 6

使用属性来做这种事情。

使用 Class.forName 之类的东西来标识类。

当您可以轻松地将属性直接转换为类时，请勿使用 if 语句。

Answer 7

根据您正在做的事情（信息不够），您可以执行以下操作：

interface Foo
{
    void foo();
}

class FakeFoo
    implements Foo
{
   public void foo()
   {
       // do nothing
   }
}

class RealFoo
{
    public void foo()
    {
        // do something
    }
}

然后提供一个类来抽象实例化：

class FooFactory
{
    public static Foo makeFoo()
    {
        final String   name;
        final FooClass fooClass;
        final Foo      foo;

        name     = System.getProperty("foo.class");
        fooClass = Class.forName(name);
        foo      = (Foo)fooClass.newInstance();

        return (foo);
    }
}

然后使用 -Dfoo.name=RealFoo|FakeFoo 运行 java

忽略 makeFoo 方法中的异常处理并你可以用其他方法来做……但想法是一样的。

这样，您就可以编译 Foo 子类的两个版本，并让开发人员在运行时选择他们希望使用的版本。

Answer 8

我看到您在这里指定了两个相互排斥的问题（或者，更有可能的是，您选择了一个，而我只是不明白您做出了哪一个选择）。

您必须做出选择：您是否发布源代码的两个版本（如果库存在则发布一个版本，如果库不存在则发布一个版本），或者您是否发布单个版本并希望它能够与库一起使用（如果库存在） 。

如果您想要一个版本来检测库的存在并使用它（如果可用），那么您必须在分布式代码中拥有访问它的所有代码——您无法删除它。由于您将问题等同于使用 #define，所以我认为这不是您的目标——您想要发布 2 个版本（#define 可以工作的唯一方法）

因此，使用 2 个版本您可以定义一个库接口。这可以是一个包装您的库并将所有调用转发给您的库的对象，也可以是一个接口——无论哪种情况，该对象都必须在两种模式的编译时存在。

public LibraryInterface getLibrary()
{
    if(LIBRARY_EXISTS) // final boolean
    {
        // Instantiate your wrapper class or reflectively create an instance             
        return library; 
    }
    return null;
}

现在，当您想要使用您的库（在 C 中拥有 #ifdef 的情况）时，您会看到：

if(LIBRARY_EXISTS)
    library.doFunc()

库是在这两种情况下都存在的接口。由于它始终受到 LIBRARY_EXISTS 的保护，因此它将编译出来（甚至不应该加载到类加载器中——但这取决于实现）。

如果您的库是由第 3 方提供的预打包库，您可能必须将 Library 设为一个包装类，将其调用转发到您的库。由于如果 LIBRARY_EXISTS 为 false，您的库包装器永远不会被实例化，因此它甚至不应该在运行时加载（哎呀，如果 JVM 足够智能，它甚至不应该被编译，因为它总是受到最终常量的保护。）但请记住在这两种情况下，包装器必须在编译时可用。

Answer 9

如果有帮助，请查看 j2me Polish 或 在中使用预处理器指令用于 eclipse 的 BlackBerry JDE 插件？

这是针对移动应用程序的，但可以重复使用，不是吗？

Answer 10

在 Java 中没有办法做你想做的事。您可以预处理 Java 源文件，但这超出了 Java 的范围。

你能不能抽象出差异然后改变实现吗？

根据您的澄清，听起来您也许能够创建一个工厂方法，该方法将返回来自外部库之一的对象或“存根”类，其函数将执行您在“不可用”中所做的操作” 条件代码。

Answer 11

正如其他人所说，Java 中没有 #define/#ifdef 这样的东西。但是，关于您拥有可选外部库的问题，如果存在，您将使用这些库，如果没有，则不使用，使用代理类可能是一种选择（如果库接口不是太大）。

我必须为 AWT/Swing 的 Mac OS X 特定扩展（在 com.apple.eawt.* 中找到）执行此操作。当然，如果应用程序在 Mac OS 上运行，这些类仅位于类路径上。为了能够使用它们，但仍然允许在其他平台上使用相同的应用程序，我编写了简单的代理类，它只提供与原始 EAWT 类相同的方法。在内部，代理使用一些反射来确定真正的类是否位于类路径上并且会传递所有方法调用。通过使用 java.lang.reflect.Proxy 类，您甚至可以创建并传递外部库中定义的类型的对象，而无需在编译时使用它。

例如，com.apple.eawt.ApplicationListener 的代理看起来像这样：

public class ApplicationListener {

    private static Class<?> nativeClass;

    static Class<?> getNativeClass() {
        try {
            if (ApplicationListener.nativeClass == null) {
                ApplicationListener.nativeClass = Class.forName("com.apple.eawt.ApplicationListener");
            }

            return ApplicationListener.nativeClass;
        } catch (ClassNotFoundException ex) {
            throw new RuntimeException("This system does not support the Apple EAWT!", ex);
        }
    }

    private Object nativeObject;

    public ApplicationListener() {
        Class<?> nativeClass = ApplicationListener.getNativeClass();

        this.nativeObject = Proxy.newProxyInstance(nativeClass.getClassLoader(), new Class<?>[] {
            nativeClass
        }, new InvocationHandler() {

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                String methodName = method.getName();

                ApplicationEvent event = new ApplicationEvent(args[0]);

                if (methodName.equals("handleReOpenApplication")) {
                    ApplicationListener.this.handleReOpenApplication(event);
                } else if (methodName.equals("handleQuit")) {
                    ApplicationListener.this.handleQuit(event);
                } else if (methodName.equals("handlePrintFile")) {
                    ApplicationListener.this.handlePrintFile(event);
                } else if (methodName.equals("handlePreferences")) {
                    ApplicationListener.this.handlePreferences(event);
                } else if (methodName.equals("handleOpenFile")) {
                    ApplicationListener.this.handleOpenFile(event);
                } else if (methodName.equals("handleOpenApplication")) {
                    ApplicationListener.this.handleOpenApplication(event);
                } else if (methodName.equals("handleAbout")) {
                    ApplicationListener.this.handleAbout(event);
                }

                return null;
            }

        });
    }

    Object getNativeObject() {
        return this.nativeObject;
    }

    // followed by abstract definitions of all handle...(ApplicationEvent) methods

}

如果您只需要外部库中的几个类，那么所有这些才有意义，因为您必须在运行时通过反射来完成所有操作。对于较大的库，您可能需要某种方法来自动生成代理。但是，如果您确实如此依赖于大型外部库，则应该在编译时需要它。

Peter Lawrey 的评论：（抱歉编辑，很难将代码放入评论中）

以下示例按方法是通用的，因此您不需要了解所涉及的所有方法。您还可以按类使其通用，这样您只需要编写一个 InvocableHandler 类即可涵盖所有情况。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    String methodName = method.getName();
    ApplicationEvent event = new ApplicationEvent(args[0]);
    Method method = ApplicationListener.class.getMethod(methodName, ApplicationEvent.class);
    return method.invoke(ApplicationListener.this, event);
}

Answer 12

在 Java 中，可以使用多种方法来实现相同的结果：

• 依赖注入

• 注释

• 反射

Java 方法是将不同的行为放入通过接口抽象的一组单独的类中，然后在运行时插入所需的类。另请参阅：

• 工厂模式

• 构建器模式

• 策略模式