Why we use Introspection in Java Beans?

[taher]

Hello folks,
I have recently started doing the Java Beans. So I don't have much knowledge about the Beans. I know that the introspection is one feature of the Java beans. But I don't know more about the introspection. I always get confused while this feature comes. Can anyone please explain me why we use Introspection in Java Beans.?? Any other information related to this topic would also be helpful.

[Warner]

You can say that an Introspection is the automatic process of analyzing a bean's design patterns to reveal the bean's properties, events, and methods. By using this you can control the publishing and discovery of bean operations and properties. The JavaBeans API architecture supplies a set of classes and interfaces to provide introspection. Bean introspection is the process of discovering the properties, methods and events a Java Bean provides. The discovering is done by using the reflection API.

[Deabelos]

The Introspector class provides a standard way for tools to learn about the properties, events, and methods supported by a target Java Bean. The BeanInfo interface of the java.beans package defines a set of methods that allow bean implementors to provide explicit information about their beans. Using this is very useful for the developer. Because by specifying BeanInfo for a bean component, a developer can hide methods, specify an icon for the toolbox, provide descriptive names for properties, define which properties are bound properties, etc. Due to which the user cannot see the coding that are used by the developer.

[MELTRONICS]

Using an Introspection in Java Beans is very useful for the developers. The following are some useful purpose for using an Introspection in Java Beans :

1. Reuse - If you are implementing the appropriate interfaces and extending the appropriate classes, the component with reuse potential are provided by you that possibly exceeds your expectations.
2. Portability - Since you are doing every thing in Java platform, so you can write components once, reuse them everywhere.

[kyosang]

The following sample of coding in an example represents code to perform introspection :

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;

public class BeanDemo
{
    private final String name = "BeanDemo";
    private int size;

    public String getName()
    {
        return this.name;
    }

    public int getSize()
    {
        return this.size;
    }

    public void setSize( int size )
    {
        this.size = size;
    }

    public static void main( String[] args )
            throws IntrospectionException
    {
        BeanInfo info = Introspector.getBeanInfo( BeanDemo.class );
        for ( PropertyDescriptor pd : info.getPropertyDescriptors() )
            System.out.println( pd.getName() );
    }
}