A JTable Subclass that Displays a Table of the JavaBeans Properties of Any Specified Class

package flanagan.david;
 
/*
 * Copyright (c) 2000 David Flanagan. All rights reserved. This code is from the book Java Examples
 * in a Nutshell, 2nd Edition. It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or
 * implied. You may study, use, and modify it for any non-commercial purpose. You may distribute it
 * non-commercially as long as you retain this notice. For a commercial use license, or to purchase
 * the book (recommended), visit http://www.davidflanagan.com/javaexamples2.
 */
 
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.util.Arrays;
import java.util.Comparator;
 
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.SwingConstants;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
 
/**
 * This class is a JTable subclass that displays a table of the JavaBeans properties of any
 * specified class.
 */
public class PropertyTable extends JTable {
    /** This main method allows the class to be demonstrated standalone */
    public static void main(String[] args) {
	// Specify the name of the class as a command-line argument
	Class beanClass = null;
	try {
	    // Use reflection to get the Class from the classname
	    beanClass = Class.forName("javax.swing.JLabel");
	} catch (Exception e) { // Report errors
	    System.out.println("Can't find specified class: " + e.getMessage());
	    System.out.println("Usage: java TableDemo <JavaBean class name>");
	    System.exit(0);
	}
 
	// Create a table to display the properties of the specified class
	JTable table = new PropertyTable(beanClass);
 
	// Then put the table in a scrolling window, put the scrolling
	// window into a frame, and pop it all up on to the screen
	JScrollPane scrollpane = new JScrollPane(table);
	JFrame frame = new JFrame("Properties of JavaBean: ");
	frame.getContentPane().add(scrollpane);
	frame.setSize(500, 400);
	frame.setVisible(true);
    }
 
    /**
     * This constructor method specifies what data the table will display (the table model) and uses
     * the TableColumnModel to customize the way that the table displays it. The hard work is done
     * by the TableModel implementation below.
     */
    public PropertyTable(Class beanClass) {
	// Set the data model for this table
	try {
	    setModel(new JavaBeanPropertyTableModel(beanClass));
	} catch (IntrospectionException e) {
	    System.err.println("WARNING: can't introspect: " + beanClass);
	}
 
	// Tweak the appearance of the table by manipulating its column model
	TableColumnModel colmodel = getColumnModel();
 
	// Set column widths
	colmodel.getColumn(0).setPreferredWidth(125);
	colmodel.getColumn(1).setPreferredWidth(200);
	colmodel.getColumn(2).setPreferredWidth(75);
	colmodel.getColumn(3).setPreferredWidth(50);
 
	// Right justify the text in the first column
	TableColumn namecol = colmodel.getColumn(0);
	DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
	renderer.setHorizontalAlignment(SwingConstants.RIGHT);
	namecol.setCellRenderer(renderer);
    }
 
    /**
     * This class implements TableModel and represents JavaBeans property data in a way that the
     * JTable component can display. If you've got some type of tabular data to display, implement a
     * TableModel class to describe that data, and the JTable component will be able to display it.
     */
    static class JavaBeanPropertyTableModel extends AbstractTableModel {
	PropertyDescriptor[] properties; // The properties to display
 
	/**
	 * The constructor: use the JavaBeans introspector mechanism to get information about all
	 * the properties of a bean. Once we've got this information, the other methods will
	 * interpret it for JTable.
	 */
	public JavaBeanPropertyTableModel(Class beanClass) throws java.beans.IntrospectionException {
	    // Use the introspector class to get "bean info" about the class.
	    BeanInfo beaninfo = Introspector.getBeanInfo(beanClass);
	    // Get the property descriptors from that BeanInfo class
	    properties = beaninfo.getPropertyDescriptors();
	    // Now do a case-insensitive sort by property name
	    // The anonymous Comparator implementation specifies how to
	    // sort PropertyDescriptor objects by name
	    Arrays.sort(properties, new Comparator() {
		public int compare(Object p, Object q) {
		    PropertyDescriptor a = (PropertyDescriptor) p;
		    PropertyDescriptor b = (PropertyDescriptor) q;
		    return a.getName().compareToIgnoreCase(b.getName());
		}
 
		public boolean equals(Object o) {
		    return o == this;
		}
	    });
	}
 
	// These are the names of the columns represented by this TableModel
	static final String[] columnNames = new String[] { "Name", "Type", "Access", "Bound" };
 
	// These are the types of the columns represented by this TableModel
	static final Class[] columnTypes = new Class[] { String.class, Class.class, String.class, Boolean.class };
 
	// These simple methods return basic information about the table
	public int getColumnCount() {
	    return columnNames.length;
	}
 
	public int getRowCount() {
	    return properties.length;
	}
 
	public String getColumnName(int column) {
	    return columnNames[column];
	}
 
	public Class getColumnClass(int column) {
	    return columnTypes[column];
	}
 
	/**
	 * This method returns the value that appears at the specified row and column of the table
	 */
	public Object getValueAt(int row, int column) {
	    PropertyDescriptor prop = properties[row];
	    switch (column) {
	    case 0:
		return prop.getName();
	    case 1:
		return prop.getPropertyType();
	    case 2:
		return getAccessType(prop);
	    case 3:
		return new Boolean(prop.isBound());
	    default:
		return null;
	    }
	}
 
	// A helper method called from getValueAt() above
	String getAccessType(PropertyDescriptor prop) {
	    java.lang.reflect.Method reader = prop.getReadMethod();
	    java.lang.reflect.Method writer = prop.getWriteMethod();
	    if ((reader != null) && (writer != null))
		return "Read/Write";
	    else if (reader != null)
		return "Read-Only";
	    else if (writer != null)
		return "Write-Only";
	    else
		return "No Access"; // should never happen
	}
    }
}