import org.hibernate.persister.entity.SingleTableEntityPersister; //导入依赖的package包/类
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 );
}
 

import org.hibernate.persister.entity.SingleTableEntityPersister; //导入依赖的package包/类
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);
	}
}
 

import org.hibernate.persister.entity.SingleTableEntityPersister; //导入依赖的package包/类
/**
 * @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;
    }
}
 

import org.hibernate.persister.entity.SingleTableEntityPersister; //导入依赖的package包/类
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;
}
 

import org.hibernate.persister.entity.SingleTableEntityPersister; //导入依赖的package包/类
@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;
			}
		});
	}
 

import org.hibernate.persister.entity.SingleTableEntityPersister; //导入依赖的package包/类
@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());
//		}
	}
 

import org.hibernate.persister.entity.SingleTableEntityPersister; //导入依赖的package包/类
public Class<? extends EntityPersister> singleTableEntityPersister() {
	return SingleTableEntityPersister.class;
}