java - una - obtener datos de un jtable

Obtener el nombre de la tabla del modelo en Hibernate

Question

¿Cómo obtengo el nombre de la tabla para un modelo en Hibernate?

Aparentemente solía haber un método getTableName() en ClassMetadata , pero se ha eliminado.

Hay un getClassMapping(String entityName) en Configuration , pero no sé cómo puedo (o si debería) usar Configuration desde mi implementación DAO.

Mi implementación de DAO es una subclase de HibernateGeneralGenericDao .

ACTUALIZACIÓN: Resulta que puedo hacer lo que intento sin el nombre de la tabla. Sin embargo, voy a mantener la pregunta abierta (y probar las respuestas tal como vienen) por el bien de referencia.

Answer 1

Es un poco raro pero funciona:

ClassMetadata hibernateMetadata = sessionFactory.getClassMetadata(pClassName);

if (hibernateMetadata == null)
{
    return;
}

if (hibernateMetadata instanceof AbstractEntityPersister)
{
     AbstractEntityPersister persister = (AbstractEntityPersister) hibernateMetadata;
     String tableName = persister.getTableName();
     String[] columnNames = persister.getKeyColumnNames();
}

Answer 2

Puede obtener el nombre de cada tabla en su proyecto con esta función:

public Set<String> getTablesName() {
    Set<String> names = new HashSet<>();
    SessionFactory sessionFactory = emf.unwrap(SessionFactory.class);

    Map<String, ClassMetadata> classMetadataMap = sessionFactory.getAllClassMetadata();
    for (ClassMetadata classMetadata : classMetadataMap.values()) {
        AbstractEntityPersister aep = (AbstractEntityPersister) classMetadata;
        String tableName = aep.getTableName();
        if (StringUtils.isBlank(tableName) || StringUtils.containsWhitespace(tableName)) {
            continue;
        }
        names.add(tableName);
    }
    return names;
}

Answer 3

Si está utilizando la anotación Table, podría hacer algo como esto:

Table table = Entity.class.getAnnotation(Table.class);
String tableName = table.name();

Answer 4

Usando la configuración, puede llamar al método GetClassMapping () para un tipo específico, que le daría cierta información de asignación para ese tipo.

(Al menos, este es el caso en NHibernate, pero supongo que esto será similar en Hibernate).

Answer 5

o mostrar una lista de todas las columnas y todas las entidades en la GUI, necesitaba cargar dinámicamente una lista completa de tabla, entidad, atributos y nombres de columnas, tipos, setters, getters e incluso etiquetas agradables y así lo hice basado en @ La solución Tom Redfem refactorizada con java 8 stream:

public void loadHibernateMetadata() throws ClassNotFoundException {
    Map<String, ClassMetadata> hibernateMetadata = sessionFactory.getAllClassMetadata();        

    hibernateMetadata.values()
        .stream()
        .filter(metadata -> metadata != null && metadata instanceof AbstractEntityPersister)
        .map(AbstractEntityPersister.class::cast)
        .forEach( persister -> createNewnParam(persister));
        ;

}

y luego crea el método NewParam es:

private void createNewParam(AbstractEntityPersister persister) {
    try {
        Class<?> $class = Class.forName(persister.getEntityName());


        List<String> getterNameRoster = Lists.newArrayList($class.getMethods())
                .stream()
                .filter( method -> method.getName().startsWith("get") || method.getName().startsWith("is"))
                .map(getterName -> getterName.getName())
                .collect(toList())
                ;

        List<String> setterNameRoster = Lists.newArrayList($class.getMethods())
                .stream()
                .filter( method -> method.getName().startsWith("set") )
                .map(setterName -> setterName.getName())
                .collect(toList())
                ;           

        Iterable<AttributeDefinition> attrs = persister.getAttributes();
        attrs.forEach(a -> {        

            String columnName = persister.getPropertyColumnNames(a.getName())[0];
            org.hibernate.type.Type hibernateType =persister.getPropertyType(a.getName());

            Optional<String> optionalGetter = getterNameRoster.stream()
                            .filter(getterStr -> getterStr.equalsIgnoreCase( String.format("get%s", a.getName()) ) ||
                                                 getterStr.equalsIgnoreCase( String.format("is%s", a.getName())) )
                            .findFirst()                                
                            ;

            String getterName = optionalGetter.isPresent() ? optionalGetter.get() : new String("");

            Optional<String> optionalSetter = setterNameRoster.stream()
                                .filter(setterStr -> setterStr.equalsIgnoreCase( String.format("set%s", a.getName()) ))                 
                                .findFirst()                                    
                                ;
            String setterName = optionalSetter.isPresent() ? optionalSetter.get() : new String("");


            Param param = new Param(persister.getEntityName(), 
                                                        persister.getTableName().replaceAll("/"", "").toUpperCase(), 
                                                        columnName.replaceAll("/"", "").toUpperCase(),
                                                        a.getName(),
                                                        getterName, 
                                                        setterName, 
                                                        hibernateType.getName(), 
                                                        capitalizeFirstLetter(splitCamelCase(a.getName()))
                                                        );
            hibernateParamList.add(param);
            logger.debug(param.toString());
        });

    } catch (ClassNotFoundException e) {
        logger.error(String.format("error occured generating the params %s" , e));
    }
}

y dos métodos de Ayuda de cadena para generar etiquetas agradables, que pueden ser irrelevantes para esta publicación

private String splitCamelCase(String s) {
   return s.replaceAll(
      String.format("%s|%s|%s",
         "(?<=[A-Z])(?=[A-Z][a-z])",
         "(?<=[^A-Z])(?=[A-Z])",
         "(?<=[A-Za-z])(?=[^A-Za-z])"
      ),
      " "
   );
}

private String capitalizeFirstLetter(String s) {
    return Character.toUpperCase(s.charAt(0)) + s.substring(1);
}

Y por supuesto en mi WebAppConfig.class obtengo la sesión de fábrica

public SessionFactory sessionFactory() {
  LocalSessionFactoryBuilder builder =
            new LocalSessionFactoryBuilder(dataSource());
  builder.addProperties(hibernateProperties());
  builder.scanPackages(new String[] { "com....model" });
  SessionFactory sessionFactory = builder.buildSessionFactory();

  return sessionFactory;

}

Tal vez podamos optimizar las transmisiones un poco más, pero para mí fue bastante rápido y fácil.

Answer 6

tal vez use SessionFactory.getClassMetadata ?

Answer 7

Configuration cfg = new Configuration().configure();    
cfg.addResource("com/struts/Entities/User.hbm.xml");
cfg.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLDialect");
Mappings m=cfg.createMappings();
System.out.println(">> class: "+m.getClass(className));
System.out.println("User table name:: "+m.getClass("User").getTable().getName());