Category: java Beanutils

Java BeanUtils – Nested Property Access ”; Previous Next Description You can access the value of nested property of the bean by concatenating the property names of the access path by using “.” separators. You can get and set the values of Nested property by using the below methods: PropertyUtils.getNestedProperty(Object, String) PropertyUtils.setNestedProperty(Object, String, Object) Parameters: Object: It is a bean whose property to be obtained or modified. String: It is a name of the nested property to be obtained or modified. Example In this example, you”ll see how to get and set the values of nested property. We will be creating three classes; SubBean, AppLayer1Bean for beans and BeanUtilsDemo as a main program to run. import org.apache.commons.beanutils.PropertyUtils; public class BeanUtilsDemo { public static void main(String args[]){ try{ // create the bean AppLayer1Bean nested = new AppLayer1Bean(); // set a SubBean which is part of another bean SubBean sb = new SubBean(); sb.setStringProperty(“Hello World from SubBean”); nested.setSubBean(sb); // accessing and setting nested properties PropertyUtils.setNestedProperty( nested, “subBean.stringProperty”, “Hello World from SubBean, set via Nested Property Access”); System.out.println( PropertyUtils.getNestedProperty(nested, “subBean.stringProperty”)); } catch(Exception e){ System.out.println(e); } } } Now we will create another class called SubBean.java as shown below: public class SubBean { private int intProperty; private String stringProperty; public void setIntProperty(int intProperty) { this.intProperty = intProperty; } public int getIntProperty() { return this.intProperty; } public void setStringProperty(String stringProperty) { this.stringProperty = stringProperty; } public String getStringProperty() { return this.stringProperty; } } Create the one more class AppLayer1Bean.java along with the below code: public class AppLayer1Bean { private SubBean subBean; public void setSubBean(SubBean subBean) { this.subBean = subBean; } public SubBean getSubBean(){ return this.subBean; } } Output Let”s carry out the following steps to see how above code works: Save the above first code as BeanUtilsDemo.java. Now execute the code using Run option or Ctrl+f11 and output as below gets displayed. PropertyUtils Method Signatures The following methods are provided by the PropertyUtils class, which accepts any arbitrary combinations of simple, indexed and mapped property access to get and set the value of the property of the specified bean. PropertyUtils.getProperty(Object, String) PropertyUtils.setProperty(Object, String, Object) Parameters: Object: It is a bean whose property to be obtained or modified. String: It is a name of the indexed and/or nested property to be obtained or modified. Example The following simple program illustrates the use of getProperty and setProperty methods: import org.apache.commons.beanutils.PropertyUtils; public class PropertyUtilsTest { public static void main(String args[]){ try{ Tv Color = new Tv(); PropertyUtils.setProperty(Color, “color”, “Black”); String value = (String) PropertyUtils.getProperty(Color, “color”); System.out.println(“The color value of Tv is: ” + value); } catch(Exception ex){ ex.printStackTrace(); } } public static class Tv{ private String color; public String getColor(){ return color; } public void setColor(String color){ this.color = color; } } } Run the code as specified in the above example and you would get the below output: Print Page Previous Next Advertisements ”;

Java BeanUtils – Basic Property Access ”; Previous Next Description You can access the basic properties by using the following ways: Simple Property Indexed Property Mapped Property Simple Property You can get and set the simple property values by using the below API signatures: PropertyUtils.getSimpleProperty(Object, String) PropertyUtils.SetSimpleProperty(Object, String, Object) Parameters: Object: It is a bean object that specifies the bean property to be extracted. String: It is a string name that specifies the name of the property to be extracted. Indexed Property You can use two options for creating indexed properties; first option is building the subscript into property name and second option is defining the subscript in a separate argument to call the method. The indexed properties can be get and set by using the below methods: PropertyUtils.getIndexedProperty(Object, String) PropertyUtils.getIndexedProperty(Object, String, int) PropertyUtils.setIndexedProperty(Object, String, Object) PropertyUtils.setIndexedProperty(Object, String, int, Object) Parameters: Object: It is a bean object that specifies the bean property to be extracted. String: It is a string name that specifies the name of the property to be extracted. int: It sets an index of the property value. Object: It specifies the value for an indexed property element. Mapped Property You can get and set the mapped property values by using the below API signatures. If you have any extra argument, then it can be written within parentheses as (“(” and “)”) instead of using square brackets. PropertyUtils.getMappedProperty(Object, String) PropertyUtils.getMappedProperty(Object, String, String) PropertyUtils.setMappedProperty(Object, String, Object) PropertyUtils.setMappedProperty(Object, String, String, Object) Parameters: Object: It is a bean object that specifies the bean property to be extracted. String: It is a name of the property value that should be set for Mapped property. String: It defines the key of the property value to be set. Object: It specifies the value of property to be set. Example The below example demonstrates use of above properties in the beanUtils: import org.apache.commons.beanutils.PropertyUtils; import java.util.ArrayList; import java.util.List; public class BeanUtilsPropertyDemo{ public static void main(String args[]){ try{ // Creating the bean and allows to access getter and setter properties MyBean myBean = new MyBean(); // Setting the properties on the myBean PropertyUtils.setSimpleProperty(myBean, “stringProp”, “Hello!This is a string”); PropertyUtils.setSimpleProperty(myBean, “floatProp”, new Float(25.20)); // Getting the simple properties System.out.println(“String Property: ” + PropertyUtils.getSimpleProperty(myBean, “stringProp”)); System.out.println(“Float Property: ” + PropertyUtils.getSimpleProperty(myBean, “floatProp”)); // Here we will create a list for the indexed property List list = new ArrayList(); list.add(“String value 0”); list.add(“String value 1”); myBean.setListProp(list); // get and set this indexed property PropertyUtils.setIndexedProperty(myBean, “listProp[1]”, “This is new string value 1”); System.out.println(“List Property[1]: ” + PropertyUtils.getIndexedProperty(myBean, “listProp[1]”)); }catch(Exception e){ System.out.println(e); } } } Now we will create one more class called MyBean.java for the bean class: import java.util.ArrayList; import java.util.List; public class MyBean { private String stringProp; private float floatProp; //indexed property @SuppressWarnings(“rawtypes”) private List listProp = new ArrayList(); public void setStringProp(String stringProp) { this.stringProp = stringProp; } public String getStringProp() { return this.stringProp; } public void setFloatProp(float floatProp) { this.floatProp = floatProp; } public float getFloatProp() { return this.floatProp; } public void setListProp(List<?> listProp) { this.listProp = listProp; } public List<?&gt getListProp() { return this.listProp; } } Output Let”s carry out the following steps to see how above code works: Save the above first code as BeanUtilsPropertyDemo.java. Now execute the code using Run option or Ctrl+f11 and output as below gets displayed. Print Page Previous Next Advertisements ”;

Java BeanUtils Tutorial Job Search The Java BeanUtils are the components of the Apache Commons which are derived from JavaAPI and provides component architecture for the Java language. The Java BeanUtils design patterns uses utility classes that helps to get and set the property values on Java classes for retrieving and defining the bean properties. This tutorial covers most of the topics required for a basic understanding of Java BeanUtils and to get a feel of how it works. Audience This tutorial has been prepared for the beginners to help them understand the basic to advanced concepts related to Java BeanUtils. Prerequisites Before you start practicing various types of examples given in this reference, we assume that you are already aware about computer programs and computer programming languages. Print Page Previous Next Advertisements ”;

Java BeanUtils – Operating On Collections ”; Previous Next Description The Commons-Collections are build upon interfaces, implementations and utilities. It contains Closure interface in the code that can be applied on the arbitrary input object and code permits to apply Closures to contents of collection. There is Closure called BeanPropertyValueChangeClosure sets specified property to specified value. This value can be combined with commons-collections in which all the beans will have specified property to specified value in the collection. For instance, you can set the myCar property to TRUE for entire collection as shown below: //creating the closure BeanPropertyValueChangeClosure closure = new BeanPropertyValueChangeClosure( “myCar”, Boolean.TRUE ); //updating the Collection CollectionUtils.forAllDo( myCollection, closure ); Print Page Previous Next Advertisements ”;

Java BeanUtils – Utility Objects & Classes ”; Previous Next Description The utility classes such as BeanUtils, ConvertUtils and PropertyUtils can be accessed through utility objects and shares the same caches and registered converters. You can instantiate corresponding class with same functionality for each static utility class. Static utility classes are the classes having only static methods performing some operations on the objects that are passed as parameters. Typically such classes have no state. The following table shows the Static Utility Classes and Utility Objects: S.N. Static Utility Class Utility Object 1 BeanUtils BeanUtilsBean 2 ConvertUtils ConvertUtilsBean 3 PropertyUtils PropertyUtilsBean Print Page Previous Next Advertisements ”;

Java BeanUtils – Locale Aware Conversions ”; Previous Next Description The regular classes available in org.apache.commons.beanutils are not assigned for any specific event. These classes provide a clear interface to make use of situations very easily where the locale is not main thing. You can use Locale-aware extensions of beanutils classes which helps localization, from the org.apache.commons.beanutils.locale package. Print Page Previous Next Advertisements ”;

Java BeanUtils – Comparing Beans ”; Previous Next Description In Apache Commons Beanutils, you can compare the JavaBean objects by using the BeanComparator class based on a specified shared property value. This can be done by using the org.apache.commons.beanutils.BeanComparator comparator. Example The below example shows how to compare the two different beans. We will be creating two objects and set the first object to “BMW” and the other object to “AUDI”. Then, we will compare the objects by using the BeanComparator by calling its compare() method. Note: For BeanComparator, commons-collection and commons-logging jar files need to be included. package com.javadb.apachecommons.beanutils; import org.apache.commons.beanutils.BeanComparator; public class BeanComparatorExample { public static void main(String[] args) { Car car1 = new Car(); car1.setBrand(“BMW”); Car car2 = new Car(); car2.setBrand(“AUDI”); BeanComparator comparator = new BeanComparator(“brand”); System.out.println(“The value after comparing two beans is: ” + comparator.compare(car1, car2)); } } Now we will create one more class with the below code and save it as Car.java. package com.javadb.apachecommons.beanutils; public class Car { private String brand; public String getBrand() { return brand; } public void setBrand(String brand) { this.brand = brand; } } Output Save the above first code as BeanComparatorExample.java. Now execute the code using Run option or Ctrl+f11 and output as below gets displayed. Print Page Previous Next Advertisements ”;

Java BeanUtils – Create Custom Converters ”; Previous Next Description BeanUtils package allows creating your own string object to convert for any java class and the registered converters can be used by all the BeanUtils methods. The following are the steps to create and register your own converter: First create a class which will implements the Converter interface and the java.lang.Class object of an application class (such as the class which need to be converted and incoming string value to be converted) should be accepted by convert() method. The instance of your converter class should be registered by calling ConvertUtils.register() method at the creation time of an application. Syntax public <T> T convert(Class<T> type, Object value); Parameters: T: It indicates desired result type. type: It indicates that data type to which the value should be converted. value: It indicates an input value to be converted The above method will either return the converted value or it will throw an exception, if conversion cannot be performed successfully. Print Page Previous Next Advertisements ”;

Java BeanUtils – Basic DynaBeans ”; Previous Next Description The implementation of BasicDynaBean and BasicDynaClass specifies the capacity of dynamic property to provide the set of properties dynamically. You can start with DynaClass to establish the set of properties. A newInstance() method will create a new DynaBean instances to DynaClass and occupy its initial values as shown in the below example. Example The below example shows usage of basic DynaBean implementation: package com.javadb.apachecommons; import org.apache.commons.beanutils.BasicDynaClass; import org.apache.commons.beanutils.DynaBean; import org.apache.commons.beanutils.DynaClass; import org.apache.commons.beanutils.DynaProperty; public class DynaBeanExample { private final String NR_OF_WHEELS = “numberOfWheels”; private void runExample() { DynaClass dynaClass = new BasicDynaClass(“Car”, null, new DynaProperty[] { new DynaProperty(NR_OF_WHEELS, Integer.TYPE) }); try { DynaBean car = dynaClass.newInstance(); car.set(NR_OF_WHEELS, 4); System.out.println(“Number of wheels: ” + car.get(NR_OF_WHEELS)); System.out.println(“DynaBean is instance of DynaClass: ” + car.getDynaClass().getName()); } catch (IllegalAccessException | InstantiationException ex) { System.err.println(ex.getMessage()); } } public static void main(String[] args) { DynaBeanExample ac = new DynaBeanExample(); ac.runExample(); } } Output Let”s carry out the following steps to see how above code works: Save the above first code as DynaBeanExample.java. Now execute the code using Run option or Ctrl+f11 and output as below gets displayed. Print Page Previous Next Advertisements ”;

Java BeanUtils – Suppressing Properties ”; Previous Next Description You can suppress the specific properties by using the bean introspection mechanism. The specialized BeanIntrospector interface is implemented by the type called SuppressPropertiesBeanIntrospector which suppresses the special class properties of Java beans. The collection of property names need to be provided which are not accessible on the beans while creating an instance. If these properties are identified by the other BeanIntrospector, then they will be removed while bean class processing. You can use a special class property for suppressing the properties for all beans which is genearted from getClass() method and inherited from Object and uses naming pattern for property get methods. In most of situations, an instance of SuppressPropertiesBeanIntrospector can be used to suppress the specific properties and can be achieved by using the SUPPRESS_CLASS constant of SuppressPropertiesBeanIntrospector. Print Page Previous Next Advertisements ”;