Java 类org.hibernate.persister.entity.SingleTableEntityPersister 实例源码

public static void bindSubclass(Element node, Subclass subclass, Mappings mappings,
        java.util.Map inheritedMetas) throws MappingException {

    bindClass( node, subclass, mappings, inheritedMetas );
    inheritedMetas = getMetas( node, inheritedMetas, true ); // get meta's from <subclass>

    if ( subclass.getEntityPersisterClass() == null ) {
        subclass.getRootClass()
                .setEntityPersisterClass( SingleTableEntityPersister.class );
    }

    log.info(
            "Mapping subclass: " + subclass.getEntityName() +
            " -> " + subclass.getTable().getName()
        );

    // properties
    createClassProperties( node, subclass, mappings, inheritedMetas );
}

public static EntityPersister createClassPersister(
        PersistentClass model, 
        CacheConcurrencyStrategy cache, 
        SessionFactoryImplementor factory,
        Mapping cfg)
throws HibernateException {
    Class persisterClass = model.getEntityPersisterClass();
    if (persisterClass==null || persisterClass==SingleTableEntityPersister.class) {
        return new SingleTableEntityPersister(model, cache, factory, cfg);
    }
    else if (persisterClass==JoinedSubclassEntityPersister.class) {
        return new JoinedSubclassEntityPersister(model, cache, factory, cfg);
    }
    else if (persisterClass==UnionSubclassEntityPersister.class) {
        return new UnionSubclassEntityPersister(model, cache, factory, cfg);
    }
    else {
        return create(persisterClass, model, cache, factory, cfg);
    }
}

/**
 * @param entityClass Entity class for which the table name is required.
 * @return Table name if the entity class is a single table.
 */
@Override
public String getTableName(Class<? extends Serializable> entityClass) {
    SessionFactory sf = emf.unwrap(HibernateEntityManagerFactory.class).getSessionFactory();
    ClassMetadata metadata = sf.getClassMetadata(entityClass);
    if (metadata instanceof SingleTableEntityPersister) {
        SingleTableEntityPersister step = (SingleTableEntityPersister) metadata;
        return step.getTableName();
    } else {
        return null;
    }
}

public List<String> getTablesNames() {
    SessionFactory factory = this.getSessionFactory();
    Map<String, ClassMetadata> map = factory.getAllClassMetadata();
    List<String> names = new ArrayList<>(map.size());
    names.addAll(map.values().stream().map(step -> ((SingleTableEntityPersister) step).getTableName()).collect(Collectors.toList()));
    return names;
}

@Override
    public void run() {
//      SessionFactory sessionFactory = factory.getBean("");
        @SuppressWarnings("unchecked")
        final Map<String, SingleTableEntityPersister> map 
            = getHibernateTemplate().getSessionFactory().getAllClassMetadata();

        getHibernateTemplate().execute(new HibernateCallback<Void>() {

            @Override
            public Void doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Transaction tnx = null;
                try {
                    tnx = session.beginTransaction();

                    for (SingleTableEntityPersister v : map.values()) {
                        session.createSQLQuery("analyze table " + v.getTableName()).executeUpdate();
                        session.createSQLQuery("optimize table " + v.getTableName()).executeUpdate();
                    }
                    tnx.commit();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally{
                    if (tnx != null && tnx.isActive()) {
                        tnx.rollback();
                    }
                }
                return null;
            }
        });
    }

@Test
    public void test() {
        System.out.println("TestDB.test()");
        Map<String, SingleTableEntityPersister> map = psItemDAO.getSessionFactory().getAllClassMetadata();
        for (Map.Entry<String, SingleTableEntityPersister> e : map.entrySet()) {
            System.out.println(e.getKey() + "   " + e.getValue().getRootTableName());
            System.out.println("analyze table " + e.getValue().getTableName());
        }
//      for (Map.Entry<String, String> e : map.entrySet()) {
//          System.out.println(e.getKey() + "   " + e.getValue());
//      }
    }

/**
 * @param entityClass Entity class for which the table name is required.
 * @return Table name if the entity class is a single table.
 */
@Override
public String getTableName(Class<? extends Serializable> entityClass) {
    SessionFactory sf = emf.unwrap(HibernateEntityManagerFactory.class).getSessionFactory();
    ClassMetadata metadata = sf.getClassMetadata(entityClass);
    if (metadata instanceof SingleTableEntityPersister) {
        SingleTableEntityPersister step = (SingleTableEntityPersister) metadata;
        return step.getTableName();
    } else {
        return null;
    }
}

public Class<? extends EntityPersister> singleTableEntityPersister() {
    return SingleTableEntityPersister.class;
}