7.21. BeanUtil¶

7.21.1. Module list¶

<dependency>
  <groupId>com.nablarch.framework</groupId>
  <artifactId>nablarch-core-beans</artifactId>
</dependency>

7.21.2. How to use¶

BeanUtil can be used to implement operations for arbitrary Java Beans.

An usage example of BeanUtil is shown below.

Bean definition

public class User {
    private Long id;
    private String name;
    private Date birthDay;
    private Address address;
    // Getter and setter are omitted
}

public class Address {
    private String postNo;
    // Getter and setter are omitted
}

public class UserDto {
    private String name;
    private String birthDay;
    // Getter and setter are omitted
}

Usage example of BeanUtil

Examples of several APIs are shown below. For details, see Javadoc of BeanUtil.

final User user = new User();
user.setId(1L);
user.setName("Name");
user.setBirthDay(new Date());

final Address address = new Address();
address.setPostNo("1234");
user.setAddress(address);


// Specify the property name and get the value (1 can be acquired).
// The value is obtained through getter.
final Long id = (Long) BeanUtil.getProperty(user, "id");

// Specify the property name and configure the value (value of the name property is changed to "new name")
// Value is configured through setter.
BeanUtil.setProperty(user, "name", "New name");

// Transfer values while creating another Bean.
// The value is transferred to the property of UserDto that matches the property name of User.
// Value is transferred using getters and setters.
// Properties that do not exist in the destination are ignored.
// If the property type of the destination is different, type conversion will be performed by ConversionUtil.
final UserDto dto = BeanUtil.createAndCopy(UserDto.class, user);

// Transfer the property value to Map.
// Map key is the property name and the value is the value acquired by getter.
// The value of the nested Bean is transferred with the key name separated by "." (Map-> Map is not nested)
// For example, address.postNo
final Map<String, Object> map = BeanUtil.createMapAndCopy(user);
final String postNo = (String) map.get("address.postNo");     // 1234 can be acquired.

// Transfer the value of Map to Bean.
// Transfer the Map value using the property setter that matches the Map key.
// When transferring values to nested Bean, Map key names must be separated by ".". (Nested Map-> Map cannot be handled)
// For example, by defining address.postNo and key name, the value is set in postNo property of User.address.
final Map<String, Object> userMap = new HashMap<String, Object>();
userMap.put("id", 1L);
userMap.put("address.postNo", 54321);
final User user = BeanUtil.createAndCopy(User.class, userMap);
final String postNo2 = user.getAddress()
                      .getPostNo();             // 54321 can be acquired.

public class ItemsForm<D extends Serializable> {
    private List<D> items;
    public List<D> getItems() {
        return items;
    }
    public void setItems(List<D> items) {
        this.items = items;
    }
}

public class Item implements Serializable {
    // Properties omitted
}

// When not to override in the concrete class.
// Calling BeanUtil.createAndCopy(BadSampleForm.class, map)
// throws a runtime exception because it does not support
// type parameters of List type.
public class BadSampleForm extends ItemsForm<Item> {
}

// When overridden by a concrete class.
// BeanUtil.createAndCopy(GoodSampleForm.class, map) works correctly.
public static class GoodSampleForm extends ItemsForm<Item> {
    @Override
    public List<Item> getItems() {
        return super.getItems();
    }
}

7.21.3. Type conversion rules of BeanUtil¶

BeanUtil performs property type conversion when data is migrated from Java Beans object or Map object to another Java Beans object.

When data is transferred from Map object to Java Beans object, if . is included in the key of the Map object, its property is treated as a nested object.

For type conversion rules, refer to the Converter implementation class that is placed below the nablarch.core.beans.converter package.

7.21.4. Add type conversion rules¶

The following steps are required to add type conversion rules.

1. Implement the following interfaces as necessary to implement the type conversion process.

• Converter
• ExtensionConverter

2. Create implementation class ConversionManager . To set rules in addition to the standard type conversion rules, create an implementation class for ConversionManager that has ConversionManager as a property.

public class SampleConversionManager implements ConversionManager {

    private ConversionManager delegateManager;

    @Override
    public Map<Class<?>, Converter<?>> getConverters() {
        Map<Class<?>, Converter<?>> converters = new HashMap<Class<?>, Converter<?>>();

        // Standard converter
        converters.putAll(delegateManager.getConverters());

        // Converter created this time
        converters.put(BigInteger.class, new CustomConverter());

        return Collections.unmodifiableMap(converters);
    }

    @Override
    public List<ExtensionConverter<?>> getExtensionConvertor() {
        final List<ExtensionConverter<?>> extensionConverters =
            new ArrayList<ExtensionConverter<?>>(delegateManager.getExtensionConvertor());
        extensionConverters.add(new CustomExtensionConverter());
        return extensionConverters;
    }

    public void setDelegateManager(ConversionManager delegateManager) {
        this.delegateManager = delegateManager;
    }
}

3. Configure implementation class ConversionManager in the component configuration file.

   Point

   • The component name should be conversionManager.

   <component name="conversionManager" class="sample.SampleConversionManager">
     <property name="delegateManager">
       <component class="nablarch.core.beans.BasicConversionManager" />
     </property>
   </component>
   

7.21.5. Specify the format allowed during type conversion¶

During type conversion, format of date and numerics can be canceled by specifying the allowable format. For example, a string type value (1,000,000) with commas can be converted to a numeric type (1000000).

The following three specification methods are available to specify the permitted formats. The priority is higher for the method based on the order of description.

• Configure when calling BeanUtil
• Configure annotation to property unit
• Default configuration (system common configuration)