/**
* Perform Spring-based scanning for entity classes, registering them as annotated classes with
* this {@code Configuration}.
*
* @param packagesToScan one or more Java package names
* @throws HibernateException if scanning fails for any reason
*/
public void scanPackages(String... packagesToScan) throws HibernateException {
try {
for (String pkg : packagesToScan) {
String pattern =
ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
+ ClassUtils.convertClassNameToResourcePath(pkg)
+ RESOURCE_PATTERN;
Resource[] resources = resourcePatternResolver.getResources(pattern);
MetadataReaderFactory readerFactory =
new CachingMetadataReaderFactory(resourcePatternResolver);
for (Resource resource : resources) {
if (resource.isReadable()) {
MetadataReader reader = readerFactory.getMetadataReader(resource);
String className = reader.getClassMetadata().getClassName();
if (matchesFilter(reader, readerFactory)) {
addAnnotatedClasses(resourcePatternResolver.getClassLoader().loadClass(className));
}
}
}
}
} catch (IOException ex) {
throw new MappingException("Failed to scan classpath for unlisted classes", ex);
} catch (ClassNotFoundException ex) {
throw new MappingException("Failed to load annotated classes from classpath", ex);
}
}
/**
* Perform Spring-based scanning for entity classes.
*
* @see #setPackagesToScan
*/
private SpringPersistenceUnitInfo buildDefaultPersistenceUnitInfo() {
SpringPersistenceUnitInfo scannedUnit = new SpringPersistenceUnitInfo();
scannedUnit.setPersistenceUnitName(this.defaultPersistenceUnitName);
scannedUnit.excludeUnlistedClasses();
if (this.packagesToScan != null) {
for (String pkg : this.packagesToScan) {
try {
String pattern =
ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
+ ClassUtils.convertClassNameToResourcePath(pkg)
+ ENTITY_CLASS_RESOURCE_PATTERN;
Resource[] resources = this.resourcePatternResolver.getResources(pattern);
MetadataReaderFactory readerFactory =
new CachingMetadataReaderFactory(this.resourcePatternResolver);
for (Resource resource : resources) {
if (resource.isReadable()) {
MetadataReader reader = readerFactory.getMetadataReader(resource);
String className = reader.getClassMetadata().getClassName();
if (matchesFilter(reader, readerFactory)) {
scannedUnit.addManagedClassName(className);
}
}
}
} catch (IOException ex) {
throw new PersistenceException("Failed to scan classpath for unlisted classes", ex);
}
}
}
if (this.mappingResources != null) {
for (String mappingFileName : this.mappingResources) {
scannedUnit.addMappingFileName(mappingFileName);
}
}
return scannedUnit;
}
public Set<Class> doScan(String basePackage) {
Set<Class> classes = new HashSet<Class>();
try {
String packageSearchPath =
ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
+ ClassUtils.convertClassNameToResourcePath(
SystemPropertyUtils.resolvePlaceholders(basePackage))
+ DEFAULT_RESOURCE_PATTERN;
Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
for (int i = 0; i < resources.length; i++) {
Resource resource = resources[i];
if (resource.isReadable()) {
MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
if ((includeFilters.size() == 0 && excludeFilters.size() == 0)
|| matches(metadataReader)) {
try {
classes.add(Class.forName(metadataReader.getClassMetadata().getClassName()));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
} catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return classes;
}
@Test
public void testPlainInterface() throws Exception {
MetadataReader metadataReader = factory.getMetadataReader("org.test.spring.PlainInterface");
ClassMetadata metadata = metadataReader.getClassMetadata();
assertEquals("org.test.spring.PlainInterface", metadata.getClassName());
assertEquals(0, metadata.getInterfaceNames().length);
assertFalse(metadata.hasEnclosingClass());
assertNull(metadata.getEnclosingClassName());
assertTrue(metadata.hasSuperClass());
assertEquals("java.lang.Object", metadata.getSuperClassName());
}
@Test
public void testSubtypeOfGenericSupertype() throws Exception {
MetadataReader metadataReader = factory.getMetadataReader("org.test.spring.GenericSubtype");
ClassMetadata metadata = metadataReader.getClassMetadata();
assertEquals("org.test.spring.GenericSubtype", metadata.getClassName());
assertEquals(0, metadata.getInterfaceNames().length);
assertFalse(metadata.hasEnclosingClass());
assertNull(metadata.getEnclosingClassName());
assertTrue(metadata.hasSuperClass());
assertEquals("org.test.spring.GenericSupertype", metadata.getSuperClassName());
}
/**
* Perform Spring-based scanning for entity classes, registering them as annotated classes with
* this {@code Configuration}.
*
* @param packagesToScan one or more Java package names
* @throws HibernateException if scanning fails for any reason
*/
public LocalSessionFactoryBuilder scanPackages(String... packagesToScan)
throws HibernateException {
Set<String> entityClassNames = new TreeSet<String>();
Set<String> converterClassNames = new TreeSet<String>();
Set<String> packageNames = new TreeSet<String>();
try {
for (String pkg : packagesToScan) {
String pattern =
ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
+ ClassUtils.convertClassNameToResourcePath(pkg)
+ RESOURCE_PATTERN;
Resource[] resources = this.resourcePatternResolver.getResources(pattern);
MetadataReaderFactory readerFactory =
new CachingMetadataReaderFactory(this.resourcePatternResolver);
for (Resource resource : resources) {
if (resource.isReadable()) {
MetadataReader reader = readerFactory.getMetadataReader(resource);
String className = reader.getClassMetadata().getClassName();
if (matchesEntityTypeFilter(reader, readerFactory)) {
entityClassNames.add(className);
} else if (converterTypeFilter != null
&& converterTypeFilter.match(reader, readerFactory)) {
converterClassNames.add(className);
} else if (className.endsWith(PACKAGE_INFO_SUFFIX)) {
packageNames.add(
className.substring(0, className.length() - PACKAGE_INFO_SUFFIX.length()));
}
}
}
}
} catch (IOException ex) {
throw new MappingException("Failed to scan classpath for unlisted classes", ex);
}
try {
ClassLoader cl = this.resourcePatternResolver.getClassLoader();
for (String className : entityClassNames) {
addAnnotatedClass(cl.loadClass(className));
}
for (String className : converterClassNames) {
ConverterRegistrationDelegate.registerConverter(this, cl.loadClass(className));
}
for (String packageName : packageNames) {
addPackage(packageName);
}
} catch (ClassNotFoundException ex) {
throw new MappingException("Failed to load annotated classes from classpath", ex);
}
return this;
}
@Test
public void testSubClassOfBinaryType() throws Exception {
MetadataReader metadataReader =
factory.getMetadataReader("org.test.spring.SubClassOfBinaryType");
ClassMetadata metadata = metadataReader.getClassMetadata();
assertEquals("org.test.spring.SubClassOfBinaryType", metadata.getClassName());
assertEquals(0, metadata.getInterfaceNames().length);
assertFalse(metadata.hasEnclosingClass());
assertNull(metadata.getEnclosingClassName());
assertTrue(metadata.hasSuperClass());
assertEquals("org.springframework.core.SpringVersion", metadata.getSuperClassName());
}
@Test
public void testSubClass() throws Exception {
MetadataReader metadataReader =
factory.getMetadataReader("org.test.spring.SubClassWithoutAnnotation");
ClassMetadata metadata = metadataReader.getClassMetadata();
assertEquals("org.test.spring.SubClassWithoutAnnotation", metadata.getClassName());
assertEquals(0, metadata.getInterfaceNames().length);
assertFalse(metadata.hasEnclosingClass());
assertNull(metadata.getEnclosingClassName());
assertTrue(metadata.hasSuperClass());
assertEquals("org.test.spring.SimpleConfigurationClass", metadata.getSuperClassName());
}
@Test
public void testSimpleClass() throws Exception {
MetadataReader metadataReader = factory.getMetadataReader("org.test.spring.NoAnnotations");
ClassMetadata metadata = metadataReader.getClassMetadata();
assertEquals("org.test.spring.NoAnnotations", metadata.getClassName());
assertEquals(0, metadata.getInterfaceNames().length);
assertFalse(metadata.hasEnclosingClass());
assertNull(metadata.getEnclosingClassName());
assertTrue(metadata.hasSuperClass());
assertEquals("java.lang.Object", metadata.getSuperClassName());
assertTrue(metadata instanceof JdtConnectedMetadata);
IType type = JdtUtils.getJavaType(project, "org.test.spring.NoAnnotations");
assertEquals(type, ((JdtConnectedMetadata) metadata).getJavaElement());
}
private Class<?> loadClass(
ClassLoader loader, MetadataReaderFactory readerFactory, Resource resource) {
try {
MetadataReader reader = readerFactory.getMetadataReader(resource);
return ClassUtils.forName(reader.getClassMetadata().getClassName(), loader);
} catch (ClassNotFoundException ex) {
handleFailure(resource, ex);
return null;
} catch (LinkageError ex) {
handleFailure(resource, ex);
return null;
} catch (Throwable ex) {
if (this.logger.isWarnEnabled()) {
this.logger.warn("Unexpected failure when loading class resource " + resource, ex);
}
return null;
}
}
public Collection<SourceClass> getMemberClasses() throws IOException {
Object sourceToProcess = this.source;
if (sourceToProcess instanceof Class<?>) {
Class<?> sourceClass = (Class<?>) sourceToProcess;
try {
Class<?>[] declaredClasses = sourceClass.getDeclaredClasses();
List<SourceClass> members = new ArrayList<SourceClass>(declaredClasses.length);
for (Class<?> declaredClass : declaredClasses) {
members.add(asSourceClass(declaredClass));
}
return members;
} catch (NoClassDefFoundError err) {
// getDeclaredClasses() failed because of non-resolvable dependencies
// -> fall back to ASM below
sourceToProcess = metadataReaderFactory.getMetadataReader(sourceClass.getName());
}
}
// ASM-based resolution - safe for non-resolvable classes as well
MetadataReader sourceReader = (MetadataReader) sourceToProcess;
String[] memberClassNames = sourceReader.getClassMetadata().getMemberClassNames();
List<SourceClass> members = new ArrayList<SourceClass>(memberClassNames.length);
for (String memberClassName : memberClassNames) {
try {
members.add(asSourceClass(memberClassName));
} catch (IOException ex) {
// Let's skip it if it's not resolvable - we're just looking for candidates
if (logger.isDebugEnabled()) {
logger.debug(
"Failed to resolve member class ["
+ memberClassName
+ "] - not considering it as a configuration class candidate");
}
}
}
return members;
}
public static void main(String[] args) throws Exception {
try {
ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
AnnotationConfiguration config =
new AnnotationConfiguration()
.configure(new File("D:/gjxt/source/news/config/hibernate/hibernate.cfg.xml"));
config.setProperty("output", "C:\\ddl.txt");
String[] packagesToScan = {"com.team.cmc.domain.model"};
for (String pkg : packagesToScan) {
String pattern =
ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
+ ClassUtils.convertClassNameToResourcePath(pkg)
+ "/**/*.class";
Resource[] resources = resourcePatternResolver.getResources(pattern);
MetadataReaderFactory readerFactory =
new CachingMetadataReaderFactory(resourcePatternResolver);
for (Resource resource : resources) {
if (resource.isReadable()) {
MetadataReader reader = readerFactory.getMetadataReader(resource);
String className = reader.getClassMetadata().getClassName();
if (matchesFilter(reader, readerFactory)) {
config.addAnnotatedClass(
resourcePatternResolver.getClassLoader().loadClass(className));
}
}
}
}
SessionFactory sessionFactory = config.buildSessionFactory();
session = sessionFactory.openSession();
tx = session.beginTransaction();
SchemaExport schemaExport = new SchemaExport(config);
schemaExport.setOutputFile("c:\\a.txt");
schemaExport.create(true, true);
System.out.println("Table created.");
tx.commit();
//
// config = new Configuration().configure(new File(
// "src/hibernate.cfg.xml"));
//
// System.out.println("Creating tables...");
//
// SessionFactory sessionFactory = config.configure()
// .buildSessionFactory();
// session = sessionFactory.openSession();
// tx = session.beginTransaction();
//
// SchemaExport schemaExport = new SchemaExport(config);
// schemaExport.create(true, true);
//
// System.out.println("Table created.");
//
// tx.commit();
} catch (HibernateException e) {
e.printStackTrace();
try {
tx.rollback();
} catch (HibernateException e1) {
e1.printStackTrace();
}
} finally {
}
}
@Override
public boolean match(MetadataReader mdr, MetadataReaderFactory arg1) throws IOException {
ComponentScan cs = TestConfiguration.class.getAnnotation(ComponentScan.class);
return SpringUtils.includedInBasePackageClasses(mdr.getClassMetadata().getClassName(), cs);
}
/**
* @author:shaochuan.wangsc
* @date:2010-3-24
*/
private void scan(WebModuleConfigurer webModuleConfigurer) {
try {
String pattern =
ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
+ ClassUtils.convertClassNameToResourcePath(
webModuleConfigurer.getModuleBasePackage())
+ webModuleConfigurer.getContextPackage()
+ RESOURCE_PATTERN;
Resource[] resources = this.resourcePatternResolver.getResources(pattern);
MetadataReaderFactory readerFactory =
new CachingMetadataReaderFactory(this.resourcePatternResolver);
//
for (Resource resource : resources) {
if (resource.isReadable()) {
MetadataReader reader = readerFactory.getMetadataReader(resource);
ClassMetadata classMetadata = reader.getClassMetadata();
//
if (classMetadata.isConcrete()) {
String className = classMetadata.getClassName();
if (!(BeanUtils.isWidget(className) || BeanUtils.isController(className))) {
continue;
}
//
AutowireCapableBeanFactory beanFactory =
applicationContext.getAutowireCapableBeanFactory();
Object clazz =
beanFactory.createBean(
classLoader.loadClass(className),
AutowireCapableBeanFactory.AUTOWIRE_NO,
false);
//
if (clazz instanceof FreeMarkerWidget) {
String widget = className.replace(webModuleConfigurer.getModuleBasePackage(), "");
widget = ClassUtils.convertClassNameToResourcePath(widget);
widget = BeanUtils.stripEndString(widget, BeanUtils.WIDGET_BEAN_SUFFIX);
String widgetKey = BeanUtils.makeControllerOrWidgetMappingKey(widget);
webModuleConfigurer.getWidgetMap().put(widgetKey, (FreeMarkerWidget) clazz);
widgets.put(widgetKey, (FreeMarkerWidget) clazz);
}
//
if (clazz instanceof Controller) {
String controller = className.replace(webModuleConfigurer.getModuleBasePackage(), "");
controller = ClassUtils.convertClassNameToResourcePath(controller);
controller = BeanUtils.stripEndString(controller, BeanUtils.CONTROLLER_BEAN_SUFFIX);
String controllerKey = BeanUtils.makeControllerOrWidgetMappingKey(controller);
String controllerRule =
webModuleConfigurer.getContextPackage() + CONTROLLERS_PACKAGE + SLASH;
if (controllerKey.startsWith(controllerRule)) {
//
controllerKey =
controllerKey.replaceFirst(controllerRule, webModuleConfigurer.getContext());
//
if ("/index".equals(controllerKey)) {
webModuleConfigurer.getControllerMap().put("/", (Controller) clazz);
controllers.put("/", (Controller) clazz);
defaultListableBeanFactory.registerSingleton("/", (Controller) clazz);
}
//
String controller_key = BeanUtils.processControllerKey(controllerKey);
String controller_keyv = controller_key + webModuleConfigurer.getUriExtension();
//
webModuleConfigurer.getControllerMap().put(controller_keyv, (Controller) clazz);
controllers.put(controller_keyv, (Controller) clazz);
defaultListableBeanFactory.registerSingleton(controller_keyv, (Controller) clazz);
}
}
}
}
}
} catch (IOException e) {
logger.error("Failed to scan classpath for unlisted classes", e);
throw new RuntimeException("Failed to scan classpath for unlisted classes", e);
} catch (ClassNotFoundException e) {
logger.error("Failed to load classes from classpath", e);
throw new RuntimeException("Failed to load classes from classpath", e);
}
}
@Override
public boolean match(MetadataReader mdr, MetadataReaderFactory arg1) throws IOException {
String clsname = mdr.getClassMetadata().getClassName();
ComponentScan cs = IntegrationTestConfiguration.class.getAnnotation(ComponentScan.class);
return includedInBasePackageClasses(clsname, cs);
}
