模拟Java中静态方法调用的静态抽象和动态链接

Question

简介

作为免责声明，我读过 为什么静态方法不能Java 中的抽象，即使我恭敬地不同意关于“逻辑矛盾”的公认答案，我也不想要任何关于静态抽象有用性的答案，只是我的答案问题；）

我有一个类层次结构，表示数据库中的一些表。每个类都继承Entity 类，该类包含许多用于访问数据库、创建查询、转义字符等的实用方法。

类的每个实例都是数据库中的一行。

问题

现在，为了分解尽可能多的代码，我想为每个类添加有关相关列和表名的信息。这些信息必须无需类实例即可访问，并将在Entity 中用于构建查询等。

存储这些数据的明显方法是每个类中的静态方法返回的静态字段。问题是你不能强制类实现这些静态方法，也不能在 Java 中对静态方法调用进行动态链接。

我的解决方案

1. 使用 HashMap 或任何类似的数据结构来保存信息。问题：如果信息丢失，错误将出现在运行时而不是编译时。
2. 对实用程序函数使用并行类层次结构，其中每个相应的类都可以实例化并使用动态链接。问题：代码繁重，如果类不存在，则会出现运行时错误

问题：

您将如何应对抽象方法上缺少抽象静态和动态链接的情况？

在完美的世界中，如果缺少类的信息，并且应该可以从实体类中轻松访问数据，则给定的解决方案应该生成编译错误。

答案不需要是 Java，C# 也可以，并且欢迎任何关于如何在没有任何语言的特定代码的情况下做到这一点的见解。

需要明确的是，除了简单性之外，我没有任何要求。没有什么必须是静态的。我只想从 Entity 检索表和列名称来构建查询。

一些代码

class Entity {
    public static function afunction(Class clazz) { // this parameter is an option
        // here I need to have access to table name of any children of Entity
    }
}

class A extends Entity {
    static String table = "a";
}

class B extends Entity {
    static String table = "b";
}

Answer 1

您应该将 Java 注释与 javac 注释处理器结合使用，因为它是最有效的解决方案。然而，它比通常的注释范例稍微复杂一些。

此链接向您展示了如何实现将在编译时使用的注释处理器。

如果我重用你的例子，我会这样做：

@Target(ElementType.TYPE)
@Retention(RetentionType.SOURCE)
@interface MetaData {
  String table();
}

abstract class Entity {}

@MetaData(table="a")
class A extends Entity {}

@MetaData(table="b")
class B extends Entity {}

class EntityGetter {
  public <E extends Entity> E getEntity(Class<E> type) {
    MetaData metaData = type.getAnnotation(MetaData.class);
    if (metaData == null) {
      throw new Error("Should have been compiled with the preprocessor.");
      // Yes, do throw an Error. It's a compile-time error, not a simple exceptional condition.
    }
    String table = metaData.table();
    // do whatever you need.
  }
}

在你的注释处理中，你应该检查注释是否设置，值是否正确，并使编译失败。

完整的文档可在 包javax.annotation.processing。

此外，如果您搜索“java 注解处理”，还可以在 Internet 上找到一些教程。

我不会更深入地讨论这个主题，因为我自己以前从未使用过该技术。

Answer 2

我遇到了和你一样的问题，现在正在使用以下方法。将有关列的元数据存储为注释并在运行时解析它们。将此信息存储在地图中。如果您确实希望出现编译时错误，大多数 IDE（例如 Eclipse）都支持自定义构建器类型，可以在构建时验证类。

您还可以使用java附带的编译时注释处理工具，它也可以集成到IDE构建中。阅读并尝试一下。

Answer 3

在 Java 中，与“静态类”最相似的方法是静态枚举。

enum 元素作为静态常量传递，因此可以从任何静态上下文访问它们。

enum 可以定义一个或多个私有构造函数，接受一些初始化参数（因为它可以是表名、一组列等）。

enum类可以定义抽象方法，这些方法必须由具体元素实现才能编译。

public enum EntityMetadata {

    TABLE_A("TableA", new String[]{"ID", "DESC"}) {

        @Override
        public void doSomethingWeirdAndExclusive() {

            Logger.getLogger(getTableName()).info("I'm positively TableA Metadata");

        }
    },
    TABLE_B("TableB", new String[]{"ID", "AMOUNT", "CURRENCY"}) {

        @Override
        public void doSomethingWeirdAndExclusive() {

            Logger.getLogger(getTableName()).info("FOO BAR message, or whatever");

        }
    };  

    private String tableName;
    private String[] columnNames;

    private EntityMetadata(String aTableName, String[] someColumnNames) {
        tableName=aTableName;
        columnNames=someColumnNames;
    }

    public String getTableName() {
        return tableName;
    }

    public String[] getColumnNames() {
        return columnNames;
    }


    public abstract void doSomethingWeirdAndExclusive();

}

然后，要访问具体的实体元数据，这就足够了：

EntityMetadata.TABLE_B.doSomethingWeirdAndExclusive();

您还可以从 Entity 实现引用它们，强制每个实体引用 EntityMetadata 元素：

abstract class Entity {

    public abstract EntityMetadata getMetadata();

}

class A extends Entity {

   public EntityMetadata getMetadata() {
       return EntityMetadata.TABLE_A;
   }
}

class B extends Entity {

   public EntityMetadata getMetadata() {
       return EntityMetadata.TABLE_B;
   }
}

IMO，这种方法将是快速且轻量。

它的阴暗面是，如果您的枚举类型需要非常复杂，具有许多不同的参数，或者一些不同的复杂重写方法，则枚举的源代码可能会变得有点混乱。

Answer 4

我的想法是跳过表格的东西，并与“没有抽象静态方法”相关。使用“伪抽象静态”方法。

首先定义一个在执行抽象静态方法时会发生的异常：

public class StaticAbstractCallException extends Exception {

  StaticAbstractCallException (String strMessage){
    super(strMessage);
   }

   public String toString(){
    return "StaticAbstractCallException";
   }  
} // class

“抽象”方法意味着它将在子类中被重写，因此您可能需要定义一个基类，其中的静态方法被假定为“抽象”。

abstract class MyDynamicDevice {
   public static void start() {
       throw new StaticAbstractCallException("MyDynamicDevice.start()"); 
   }

   public static void doSomething() {
       throw new StaticAbstractCallException("MyDynamicDevice.doSomething()"); 
   }

   public static void finish() {
       throw new StaticAbstractCallException("MyDynamicDevice.finish()"); 
   }

   // other "abstract" static methods
} // class

...
最后，定义覆盖“伪抽象”方法的子类。

class myPrinterBrandDevice extends MyDynamicDevice {

   public static void start() {
       // override MyStaticLibrary.start()
   }

   /*
   // ops, we forgot to override this method !!!
   public static void doSomething() {
       // ...
   }
   */

   public static void finish() {
       // override MyStaticLibrary.finish()
   }

   // other abstract static methods
} // class

当调用静态 myStringLibrary doSomething 时，将产生异常。

Answer 5

我确实知道一个解决方案可以提供您想要的一切，但这是一个巨大的黑客，我现在不想在自己的代码中使用：

如果 Entity 可能是抽象的，只需添加提供元数据的方法即可基类并声明它们抽象。

否则创建一个接口，使用提供所有数据的方法，就像这样，

public interface EntityMetaData{
    public String getTableName();
    ...
}

但是实体的所有子类都必须实现这个接口。

现在您的问题是从静态实用程序方法中调用这些方法，因为您在那里没有实例。所以你需要创建一个实例。使用 Class.newInstance() 是不可行的，因为您需要一个空构造函数，并且可能会进行昂贵的初始化或在构造函数中发生副作用的初始化，您不想触发。

我建议的技巧是使用 Objenesis 实例化您的类。该库允许实例化任何类，而无需调用构造函数。也不需要空构造函数。他们通过内部一些巨大的修改来做到这一点，这些修改适用于所有主要的 JVM。

因此，您的代码将如下所示：

public static function afunction(Class clazz) {
    Objenesis objenesis = new ObjenesisStd();
    ObjectInstantiator instantiator = objenesis.getInstantiatorOf(clazz);
    Entity entity = (Entity)instantiator.newInstance();
    // use it
    String tableName = entity.getTableName();
    ...
}

显然，您应该使用 Map 缓存您的实例，这将运行时成本降低到几乎为零（在缓存映射中进行单次查找）。

我在自己的一个项目中使用 Objenesis，它使我能够创建一个漂亮、流畅的 API。这对我来说是一个巨大的胜利，所以我忍受了这个黑客攻击。所以我可以告诉你，它确实有效。我在许多具有许多不同 JVM 版本的环境中使用了我的库。

但这不是好的设计！我建议不要使用这样的 hack，即使它现在有效，它可能会在下一个 JVM 中停止。然后你将不得不祈祷 Objenesis 的更新......

如果我是你，我会重新考虑我的设计导致整个需求。或者放弃编译时检查而使用注释。

Answer 6

您对静态方法的要求不会为干净的解决方案留下太多空间。一种可能的方法是混合静态和动态，并以节省 RAM 为代价损失一些 CPU：

class Entity {
   private static final ConcurrentMap<Class, EntityMetadata> metadataMap = new ...;

   Entity(EntityMetadata entityMetadata) {
      metadataMap.putIfAbsent(getClass(), entityMetadata);
   }

   public static EntityMetadata getMetadata(Class clazz) {
      return metadataMap.get(clazz);
   }
}

我更想要的方法是浪费引用但使其动态：

class Entity {
   protected final EntityMetadata entityMetadata;

   public Entity(EntityMetadata entityMetadata) {
      this.entityMetadata=entityMetadata;
   }
}

class A extends Entity {
  static {
     MetadataFactory.setMetadataFor(A.class, ...);
  }

  public A() {
     super(MetadataFactory.getMetadataFor(A.class));
  }
}

class MetadataFactory {
   public static EntityMetadata getMetadataFor(Class clazz) {
      return ...;
   }

   public static void setMetadataFor(Class clazz, EntityMetadata metadata) {
      ...;
   }
}

您甚至可以摆脱 EntityMetadata 完全位于 Entity 中，仅保留在工厂。是的，它不会强制在编译时为每个类提供它，但您可以在运行时轻松强制执行。编译时错误很严重，但它们毕竟不是圣牛，因为如果类没有提供相关的元数据部分，您总是会立即收到错误。

Answer 7

我会将实体的所有元数据（表名、列名）抽象到实体本身不知道的服务中。比将这些信息放在实体内部要干净得多

MetaData md = metadataProvider.GetMetaData<T>();
String tableName = md.getTableName();

Answer 8

首先，让我告诉你我同意你的观点，我希望有一种方法来强制静态方法出现在类中。
作为解决方案，您可以通过使用自定义 ANT 任务来“延长”编译时间，该任务检查此类方法是否存在，并在编译时间中出现错误。当然，它不会对您在 IDE 内部提供帮助，但您可以使用可自定义的静态代码分析器（如 PMD）并创建自定义规则来检查相同的内容。
然后进行 java 编译（好吧，几乎编译）并进行编辑时错误检查。
动态链接模拟……嗯，这更难。我不确定我明白你的意思。你能写一个你期望发生的事情的例子吗？