Introspection in Java

Introspection refers to the ability of an object to examine and manipulate its own properties, methods, and events. JavaBeans are a type of Java object that follows certain naming conventions and design patterns to enable easy introspection and manipulation of their properties.

• Introspection is the process of analyzing a Java Bean to determine its capabilities
• To perform introspection,
  • Java has provided a set of predefined classes and interfaces that are available inside the java.beans package.
  • Some Classes and Interfaces are:
    • BeanInfo
    • SimpleBeanInfo
    • BeanDescriptor
    • PropertyDescriptor
    • MethodDescriptor

All the classes and interfaces are available inside java.beans package and these can be found here.

Key points to remember

• Introspection is not used in application development but it is most useful while developing products like Java Bean Builder.
• If we want to analyze all the capabilities of a bean then we have to create an object of BeanInfo
• To create a BeanInfo object we can use the getBeanInfo() method from the Introspector class.

Example

Let’s create a Student bean class. You can visit Java Bean to know more detail about it.

public class Student {
	private int rollNo;
	private String name;
	private char gender;

	public int getRollNo() {
		return rollNo;
	}

	public void setRollNo(int rollNo) {
		this.rollNo = rollNo;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public char getGender() {
		return gender;
	}

	public void setGender(char gender) {
		this.gender = gender;
	}
}

Initializing BeanInfo

BeanInfo beanInfo = Intospector.getBeanInfo(Student.class);

Methods in the BeanInfo interface

Let’s see the demo of the implementation of the above method:

public class IntrospectionDemo {
	public static void main(String[] args) throws IntrospectionException {
		BeanInfo beanInfo = Introspector.getBeanInfo(Student.class);
		BeanDescriptor beanDescriptor = beanInfo.getBeanDescriptor();
		System.out.println("Bean Name: "+ beanDescriptor.getName());
		
		PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
		System.out.println("Properties/Variables:");
		for(PropertyDescriptor propteryDescriptor: propertyDescriptors) {
			System.out.print(propteryDescriptor.getName()+" \t");
		}
		
		System.out.println();
		
		MethodDescriptor[] methodDescriptors = beanInfo.getMethodDescriptors();
		System.out.println("Methods:");
		for(MethodDescriptor methodDescriptor: methodDescriptors) {
			System.out.print(methodDescriptor.getName()+" \t");
		}
		System.out.println();
	}
}

Output

Bean Name: Student
Properties/Variables:
class 	gender 	name 	rollNo 	
Methods:
getClass 	getName 	setRollNo 	setGender 	getGender 	setName 	wait 	notifyAll 	notify 	wait 	hashCode 	wait 	equals 	toString 	getRollNo 	

In the above output, we can see all the methods from the Object class as well.

Conclusion

In this post, we learn how introspection can be implemented in Java to analyze the Java Bean.