求助：如何创建支持动态添加属性的Java Bean对象？

Hey, great question—this is totally doable, but you’ll need to step beyond the standard static Java Bean setup since regular Java classes have fixed properties defined at compile time. Let’s walk through the best approaches tailored to your need for getter methods to feed table data.

1. Use a Map-backed Class (Simplest & Most Maintainable) #

The easiest way is to create a class that wraps a Map to store your dynamic boolean values, then add flexible getter methods that let you retrieve values by index or name (since your original objects have a name field). This avoids complex reflection or bytecode generation, and works seamlessly with most table components if you set up a custom table model.

Here’s a concrete example:

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DynamicEnabledBean {
    private final Map<String, Boolean> enabledValues = new HashMap<>();
    private final List<YourOriginalObject> sourceList;

    // Assume YourOriginalObject has getName(), isEnabled(), getId() methods
    public DynamicEnabledBean(List<YourOriginalObject> sourceList) {
        this.sourceList = sourceList;
        // Populate the map with name -> enabled pairs
        for (YourOriginalObject obj : sourceList) {
            enabledValues.put(obj.getName(), obj.isEnabled());
        }
    }

    // Getter by object name (matches your original data's identifier)
    public Boolean getEnabledByName(String name) {
        return enabledValues.getOrDefault(name, false);
    }

    // Getter by index (useful if your table columns are ordered by list position)
    public Boolean getEnabledByIndex(int index) {
        if (index < 0 || index >= sourceList.size()) {
            throw new IndexOutOfBoundsException("Invalid property index: " + index);
        }
        String targetName = sourceList.get(index).getName();
        return enabledValues.getOrDefault(targetName, false);
    }

    // Helper method to get the total number of dynamic properties
    public int getEnabledPropertyCount() {
        return sourceList.size();
    }
}

Why this works: #

• You can easily scale this as your list grows—just pass the updated list to the bean constructor.
• For table components like Swing’s JTable, you can create a custom AbstractTableModel that uses getEnabledByIndex() to populate cell values, and getEnabledPropertyCount() to set the column count.

2. Dynamic Proxy for "Traditional" Getter Methods #

If your table component strictly requires individual getter methods (like getEnabled1(), getEnabled2(), etc.), you can use Java’s dynamic proxy to generate a bean-like object at runtime that handles these method calls.

Here’s how to implement it:

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DynamicBeanFactory {
    // Assume YourOriginalObject is your source object type
    public static Object createDynamicEnabledBean(List<YourOriginalObject> sourceList) {
        Map<String, Boolean> propertyMap = new HashMap<>();

        // Map getter method names to enabled values (e.g., "enabled1" -> true/false)
        for (int i = 0; i < sourceList.size(); i++) {
            String propertyName = "enabled" + (i + 1);
            propertyMap.put(propertyName, sourceList.get(i).isEnabled());
        }

        InvocationHandler handler = (proxy, method, args) -> {
            String methodName = method.getName();
            // Handle getter methods (e.g., getEnabled1())
            if (methodName.startsWith("get")) {
                String propertyName = methodName.substring(3, 4).toLowerCase() + methodName.substring(4);
                return propertyMap.getOrDefault(propertyName, false);
            }
            throw new UnsupportedOperationException("Unsupported method: " + methodName);
        };

        // Generate a proxy object (you can define a marker interface if needed)
        return Proxy.newProxyInstance(
            DynamicBeanFactory.class.getClassLoader(),
            new Class<?>[]{DynamicEnabledMarker.class},
            handler
        );
    }

    // Marker interface to type the proxy object (optional but helpful)
    public interface DynamicEnabledMarker {}
}

Notes: #

• This uses reflection to intercept getter calls, so there’s a small performance hit compared to the Map approach.
• You’ll need to make sure your table component can reflectively discover these dynamic getters (some components scan for methods matching the getXXX() pattern).

3. Third-Party Libraries for Dynamic Beans #

If you don’t want to roll your own solution, libraries like Apache Commons BeanUtils or Spring’s BeanWrapper simplify creating dynamic beans with runtime properties.

Using Spring’s BeanWrapper:

import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
import java.util.List;

public class SpringDynamicBeanCreator {
    public static Object createDynamicBean(List<YourOriginalObject> sourceList) {
        Object dynamicBean = new Object(); // Empty object to hold dynamic properties
        BeanWrapper wrapper = new BeanWrapperImpl(dynamicBean);

        for (int i = 0; i < sourceList.size(); i++) {
            String propertyName = "enabled" + (i + 1);
            wrapper.setPropertyValue(propertyName, sourceList.get(i).isEnabled());
        }

        return dynamicBean;
    }
}

Why this helps: #

• BeanWrapper handles the heavy lifting of managing dynamic properties, and you can retrieve values with wrapper.getPropertyValue("enabled1").
• If your table component integrates with Spring, this can fit neatly into your existing setup.

Key Consideration: Table Component Adaptation #

Don’t overlook the fact that many Java table components (like Swing’s JTable, JavaFX’s TableView) support custom data models. Instead of forcing a dynamic bean, you could create a custom TableModel that directly reads from your original ArrayList—this is often simpler and more performant.

For example, in Swing:

import javax.swing.table.AbstractTableModel;
import java.util.List;

public class EnabledTableModel extends AbstractTableModel {
    private final List<YourOriginalObject> data;

    public EnabledTableModel(List<YourOriginalObject> data) {
        this.data = data;
    }

    @Override
    public int getRowCount() {
        return 1; // Since all booleans are in one row
    }

    @Override
    public int getColumnCount() {
        return data.size();
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        return data.get(columnIndex).isEnabled();
    }

    @Override
    public String getColumnName(int column) {
        return data.get(column).getName(); // Use original object's name as column header
    }
}

This model directly feeds your table without needing a dynamic bean at all!

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