Eu sei que Deus ajuda quem cedo madruga, mas na boa, isso não é pra mim!

Microsoft PowerToys for Windows XP

http://www.microsoft.com/windowsxp/downloads/powertoys/xppowertoys.mspx

Objetos como Arquivos (Objects like Files)

Objetos como Arquivos (Objects like Files)
Buneas,,
A idéia que surgiu é trabalhar objetos (registros do banco de dados) como se manipula os arquivos em um sistema operacional.

1. Criar uma lixeira (tabela) genérica para se colocar os objetos excluídos através de serializable (utilizar uma coluna para armazenar os objetos).
2. Permitir a Clonagem
3. Permitir importar campos em comum mesmo entre objetos diferentes (como na área de transferência do Windows)
4. Permitir criar rascunhos (drafts) de registros sem ter que guardar de fato na tabela principal
5. Utilizar recursão para solucionar problemas de referência entre objetos
6. Utilizar um conceito semelhante ao Outlook permitindo abrir e editar vários objetos ao mesmo tempo
   
7. Utilizar o conceito de desfazer/refazer (ctrl+z e ctrl+y) para as operações em cima de objetos (tabelas) como atualização ou deleção

Teoricamente utilizando-se serializable e reflection seria possível a construção de um framework genérico, que poderia ser aplicado a qualquer sistema e que permitiria as operações básicas (mesmas feitas com arquivos) ser aplicadas a todas (ou quase todas) as classes Entity de uma aplicação.
Por enquanto é só uma idéia,, ainda estou tentando convencer conhecidos que é boa! Se conseguir parto para a implementação.

(Generic Recycle Copy Past Files Serializable Java)

DynamicTableModel - Evoluindo a Idéia de Algo Flexível

Melhorando um pouco o Table Model do swing, deixando ele um pouco mais compatível com o JPA e mais simples de utilizar sem precisar carregar um punhado de bibliotecas. Sei que o código poderia ser mais bem otimizado, porém, o objetivo foi a facilidade de utilização. Comecei seguindo idéias que vi na web, porém resolvi seguir um caminho próprio.

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.table.AbstractTableModel;

public class DynamicTableModel extends AbstractTableModel {

    private String[] columnNames = null;
    private List data = null;

    public List getData() {
        return data;
    }

    public void setData(List dataset) throws IntrospectionException {
        initModel(dataset);
    }
    private Class c = null;

    public Class getC() {
        return c;
    }

    public String[] getColumnNames() {
        return columnNames;
    }

    public DynamicTableModel(List dataset) throws IntrospectionException {
        super();
        initModel(dataset);
    }

    private void initModel(List dataset) throws IntrospectionException {
        System.out.println("dataset.size() = " + dataset.size());
        if (dataset.size() > 0) {
            c = dataset.get(0).getClass();
            System.out.println(c.getName());

            PropertyDescriptor[] p = java.beans.Introspector.getBeanInfo(c, Object.class).getPropertyDescriptors();
            columnNames = new String[p.length];
            System.out.println("p.length = " + p.length);
            for (int i = 0; i < p.length; i++) {
                // coloca o nome na coluna
                String s = p[i].getName();
                s = s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
                System.out.println("s = " + s);
                columnNames[i] = s;
            }
            this.data = dataset;
        }
    }

    @Override
    public Class getColumnClass(int c) {
        System.out.println("getColumnClass(int c) = " + c);
        return getValueAt(0, c).getClass();
    }

    public int getColumnCount() {
        if (columnNames == null) {
            return 0;
        } else {
            System.out.println("getColumnCount = " + columnNames.length);
            return columnNames.length;
        }
    }

    public int getRowCount() {
        if (data == null) {
            return 0;
        } else {
            return data.size();
        }
    }

    @Override
    public String getColumnName(int col) {
        return columnNames[col];
    }

    public Object getObjectAtRow(int row) {
        Object o = null;
        if (data.size() > 0 && row < data.size()) {
            o = data.get(row);
        }
        return o;
    }

    public List Object> getObjectAtRows(int[] rows) {
        ArrayList Object> os = new ArrayList Object>();
        if (data.size() > 0) {
            for (int i : rows) {
                if (data.size() > i) {
                    os.add(data.get(i));
                }
            }
        }
        return os;
    }

    public Object getValueAt(int row, int col) {
        Object o = null;
        if (data.size() > 0 && row < data.size()) {
            try {
                Object oRow = data.get(row);
                Method method = c.getMethod("get" + columnNames[col], new Class[]{});
                Class t = method.getReturnType();
                if (t.isPrimitive()) {
                    System.out.println("t.getName() = " + t.getName());
                    if (t.equals(java.lang.Integer.TYPE) || t.getName().equals("int")) {
                        o = new Integer(method.invoke(oRow, new Object[]{}).toString());
                    } else if (t.equals(java.lang.Boolean.TYPE) || t.getName().equals("boolean")) {
                        o = new Boolean(method.invoke(oRow, new Object[]{}).toString());
                    } else if (t.equals(java.lang.Float.TYPE) || t.getName().equals("float")) {
                        o = new Integer(method.invoke(oRow, new Object[]{}).toString());
                    } else if (t.equals(java.lang.Long.TYPE) || t.getName().equals("long")) {
                        o = new Integer(method.invoke(oRow, new Object[]{}).toString());
                    } else {
                        o = oRow;
                    }
                } else {
                    System.out.println("Nao primitivo t.getName() = " + t.getName());
                    if (t.getName().equals("java.lang.String")) {
                        o = new String(method.invoke(oRow, new Object[]{}).toString());
                    } else {
                        o = oRow;
                    }
                }
            } catch (Exception ex) {
                System.out.println("ex = " + ex);
                Logger.getLogger(DynamicTableModel.class.getName()).log(Level.SEVERE, null, ex);
            }

        }
        return o;
    }
}

Método genérico para popular um jTable direto da lista que vem do JPA

Buenas,,
É um exemplo de um método genérico pra popular um jTable a partir dos dados que vem do JPA (List através de uma query do EntityManager). Este método utiliza o net.sf.jga.swing.GenericTableModel para auxiliar na conversão. Att,

package util;

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.util.List;
import net.sf.jga.swing.GenericTableModel;

/**
 *
 * @author esr
 */
public class DataModel {
    static public GenericTableModel getTableModel(List l) throws IntrospectionException {
        GenericTableModel model = null;
        if (l.size() > 0) {
            Class c = l.get(0).getClass();
            model = new GenericTableModel(c, l);
            for (PropertyDescriptor p : java.beans.Introspector.getBeanInfo(c, Object.class).getPropertyDescriptors()) {
                String s = p.getName();
                s = s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
                model.addColumn(p.getPropertyType(), s);
            }
        }
        return model;
    }
}

--------------------
exemplo de chamada:

jTable1.setModel(util.DataModel.getTableModel(lista));

Qualquer semelhança com a realidade não passa de mera coincidência 2

JPA List e List JSF

Adaptei um método publicado aqui para fazer a conversão genérica de um List (que é o retorno de uma consulta JPA) para um List que é utilizado pelos comboboxes no JSF. O método é um draft, pode ser otimizado, mas em fim, é uma sugestão. Penso que facilita a vida.
Para se utilizar, se passa a lista, uma o nome do campo ID (como string) e o nome do campo de descrição (também como string). O retorno é um List

public List<SelectItem> getItems(List entities, String idGetMthdName, String descGetMthdName) {
        List<SelectItem> items = new Vector<SelectItem>();
        try {
            Method idMthd = null, nameMthd = null;
            for (int i = 0; i < entities.size(); i++) {
                Object entity = entities.get(i);
                // On the first run, initialize reflection methods for object
                if (idMthd == null) {
                    Class entityClass = entity.getClass();
                    idMthd = entityClass.getMethod(idGetMthdName, new Class[]{});
                    nameMthd = entityClass.getMethod(descGetMthdName, new Class[]{});
                }
                // Retrieve values on the 
                //Integer id = (Integer)idMthd.invoke(entity, new Object[]{});
                String id = (String) idMthd.invoke(entity, new Object[]{});
                String name = (String) nameMthd.invoke(entity, new Object[]{});
                //System.out.println("id=" + id);
                //System.out.println("name=" + name);
                // Add key information to select item list
               // System.out.println("------------------------");
                SelectItem item = new SelectItem();
                item.setLabel(name);
                item.setValue(id.toString());
                items.add(item);
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //System.out.println("Fim");
        return items;
    }