java 设计动态字段,具有动态字段的Java类

I'm looking for clever ways to build dynamic Java classes, that is classes where you can add/remove fields at runtime. Usage scenario: I have an editor where users should be able to add fields to the model at runtime or maybe even create the whole model at runtime.

Some design goals:

Type safe without casts if possible for custom code that works on the dynamic fields (that code would come from plugins which extend the model in unforeseen ways).

Good performance (can you beat HashMap? Maybe use an array and assign indexes to the fields during setup?)

Field "reuse" (i.e. if you use the same type of field in several places, it should be possible to define it once and then reuse it).

Calculated fields which depend on the value of other fields

Signals should be sent when fields change value (no necessarily via the Beans API)

"Automatic" parent child relations (when you add a child to a parent, then the parent pointer in the child should be set for "free").

Easy to understand

Easy to use

Note that this is a "think outside the circle" question. I'll post an example below to get you in the mood :-)

解决方案

The obvious answer is to use a HashMap (or a LinkedHashMap if you care for the order of fields). Then, you can add dynamic fields via a get(String name) and a set(String name, Object value) method.

This code can be implemented in a common base class. Since there are only a few methods, it's also simple to use delegation if you need to extend something else.

To avoid the casting issue, you can use a type-safe object map:

TypedMap map = new TypedMap();

String expected = "Hallo";

map.set( KEY1, expected );

String value = map.get( KEY1 ); // Look Ma, no cast!

assertEquals( expected, value );

List list = new ArrayList ();

map.set( KEY2, list );

List valueList = map.get( KEY2 ); // Even with generics

assertEquals( list, valueList );

The trick here is the key which contains the type information:

TypedMapKey KEY1 = new TypedMapKey( "key1" );

TypedMapKey> KEY2 = new TypedMapKey>( "key2" );

The performance will be OK.

Field reuse is by using the same value type or by extending the key class of the type-safe object map with additional functionality.

Calculated fields could be implemented with a second map that stores Future instances which do the calculation.

Since all the manipulation happens in just two (or at least a few) methods, sending signals is simple and can be done any way you like.

To implement automatic parent/child handling, install a signal listener on the "set parent" signal of the child and then add the child to the new parent (and remove it from the old one if necessary).

Since no framework is used and no tricks are necessary, the resulting code should be pretty clean and easy to understand. Not using String as keys has the additional benefit that people won't litter the code with string literals.