@Override
protected void doOpen() throws Exception {
Assert.notNull(resource, "Input resource must be set");
Assert.notNull(recordSeparatorPolicy, "RecordSeparatorPolicy must be set");
noInput = true;
if (!resource.exists()) {
if (strict) {
throw new IllegalStateException(
"Input resource must exist (reader is in 'strict' mode): " + resource);
}
logger.warn("Input resource does not exist " + resource.getDescription());
return;
}
if (!resource.isReadable()) {
if (strict) {
throw new IllegalStateException(
"Input resource must be readable (reader is in 'strict' mode): " + resource);
}
logger.warn("Input resource is not readable " + resource.getDescription());
return;
}
reader = bufferedReaderFactory.create(resource, encoding);
for (int i = 0; i < linesToSkip; i++) {
String line = readLine();
if (skippedLinesCallback != null) {
skippedLinesCallback.handleLine(line);
}
}
noInput = false;
}
/**
* 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;
}
/** method adds all the method names to map with annotation attribute value as key */
private static void findAnnotationMethods(
final Class<? extends Annotation> annotationClass, final String attributeName)
throws IOException {
final String basePackagePath =
ClassUtils.convertClassNameToResourcePath(
new StandardEnvironment().resolveRequiredPlaceholders(SEARCH_PACKAGE));
final String packageSearchPath =
ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + basePackagePath + "/" + RESOURCE_PATTERN;
final Resource[] resources = resourcePatternResolver.getResources(packageSearchPath);
for (final Resource resource : resources) {
if (resource.isReadable()) {
final MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
final Set<MethodMetadata> metadataSet =
metadataReader.getAnnotationMetadata().getAnnotatedMethods(annotationClass.getName());
if (metadataSet != null && metadataSet.size() > 0) {
for (final MethodMetadata metadata : metadataSet) {
final Map<String, Object> attributes =
metadata.getAnnotationAttributes(annotationClass.getName());
final JobName attributeValue = (JobName) attributes.get(attributeName);
final String className = metadata.getDeclaringClassName();
final String[] mapVal = {className, metadata.getMethodName()};
targetMethosMap.put(attributeValue.toString(), mapVal);
}
}
}
}
}
public void setAdsResource(Resource resource)
throws ParserConfigurationException, IOException, SAXException {
advertisementBlocks.clear();
if (resource != null && resource.exists() && resource.isReadable()) {
final DocumentBuilder builder = BUILDER_FACTORY.newDocumentBuilder();
final Document document = builder.parse(resource.getInputStream());
final Element root = document.getDocumentElement();
final String client = root.getAttribute("client");
final NodeList blocks = root.getElementsByTagName("block");
for (int i = 0; i < blocks.getLength(); i++) {
final Element block = (Element) blocks.item(i);
final String name = block.getAttribute("name");
final NodeList items = block.getElementsByTagName("item");
for (int j = 0; j < items.getLength(); j++) {
final Element item = (Element) items.item(j);
final String slot = item.getAttribute("slot");
final Language language = Language.byCode(item.getAttribute("language"));
final int width = Integer.valueOf(item.getAttribute("width"));
final int height = Integer.valueOf(item.getAttribute("height"));
advertisementBlocks.put(
new AdsBlockKey(name, language),
new AdvertisementBlock(client, slot, width, height, AdvertisementProvider.GOOGLE));
}
}
}
}
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;
}
private PluginConfiguration[] locatePluginConfigurations() throws Exception {
List<PluginConfiguration> pluginConfigs = new LinkedList<PluginConfiguration>();
// first we see if the config is etc exists
if (m_configResource != null && m_configResource.isReadable()) {
LogUtils.infof(this, "Found Drools Plugin config file %s.", m_configResource);
pluginConfigs.add(new PluginConfiguration(m_configResource));
}
// then we look in each plugin dir for a config
File[] pluginDirs = getPluginDirs();
for (File pluginDir : pluginDirs) {
File configFile = new File(pluginDir, PLUGIN_CONFIG_FILE_NAME);
if (!configFile.exists()) {
LogUtils.errorf(
this,
"Drools Plugin directory %s does not contains a %s config file. Ignoring plugin.",
pluginDir,
PLUGIN_CONFIG_FILE_NAME);
} else {
LogUtils.infof(
this,
"Found Drools Plugin directory %s containing a %s config file.",
pluginDir,
PLUGIN_CONFIG_FILE_NAME);
pluginConfigs.add(new PluginConfiguration(new FileSystemResource(configFile)));
}
}
return pluginConfigs.toArray(new PluginConfiguration[0]);
}
// Copies a set of resources to a given directory. The set is specified
// by an Ant-style path-matching pattern.
public void copyGrailsResources(Object destDir, Object pattern, boolean overwrite)
throws FileNotFoundException, IOException {
new File(destDir.toString()).mkdirs();
Resource[] resources = resolveResources("classpath:" + pattern);
for (Resource resource : resources) {
if (resource.isReadable()) {
copyGrailsResource(destDir + "/" + resource.getFilename(), resource, overwrite);
}
}
}
/**
* Scan the class path for candidate components.
*
* @param basePackage the package to check for annotated classes
* @return a corresponding Set of autodetected bean definitions
*/
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
try {
String packageSearchPath =
ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
+ resolveBasePackage(basePackage)
+ "/"
+ this.resourcePattern;
Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
if (resource.isReadable()) {
try {
MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Identified candidate component class: " + resource);
}
candidates.add(sbd);
} else {
if (debugEnabled) {
logger.debug("Ignored because not a concrete top-level class: " + resource);
}
}
} else {
if (traceEnabled) {
logger.trace("Ignored because not matching any filter: " + resource);
}
}
} catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to read candidate component class: " + resource, ex);
}
} else {
if (traceEnabled) {
logger.trace("Ignored because not readable: " + resource);
}
}
}
} catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
/**
* 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;
}
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 isReadable() {
return delegate.isReadable();
}
public static Map<String, PirsfDatRecord> parse(final Resource pirsfDatFileResource)
throws IOException {
LOGGER.debug("Running PIRSF data file parser...");
if (pirsfDatFileResource == null) {
throw new NullPointerException("Resource to the PIRSF dat file is null");
}
if (!pirsfDatFileResource.exists()) {
throw new IllegalStateException(pirsfDatFileResource.getFilename() + " does not exist");
}
if (!pirsfDatFileResource.isReadable()) {
throw new IllegalStateException(pirsfDatFileResource.getFilename() + " is not readable");
}
// Result map
final Map<String, PirsfDatRecord> data = new HashMap<String, PirsfDatRecord>();
BufferedReader reader = null;
try {
// Read input file line by line
reader = new BufferedReader(new InputStreamReader(pirsfDatFileResource.getInputStream()));
String line;
PirsfDatRecord pirsfDatRecord = null;
int row = 1;
while ((line = reader.readLine()) != null) {
Matcher modelStart = PIRSF_DAT_PATTERN_SUPERFAM.matcher(line);
if (modelStart.find()) {
// New accession without sub families
final String modelAccession = line.substring(1);
pirsfDatRecord = new PirsfDatRecord(modelAccession);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Found a new model accession without sub families: " + modelAccession);
}
// Reset row attributes
row = 1;
} else if (row == 2) {
// Model name
final String modelName = line;
pirsfDatRecord.setModelName(modelName);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Set model name to " + modelName);
}
} else if (row == 3) {
final String[] values = line.split("\\s+");
pirsfDatRecord.setValues(values);
} else if (row == 4 && line.startsWith("BLAST: ")) {
int index = line.indexOf(":");
if (index > -1 && line.length() >= index + 1) {
line = line.substring(index + 1).trim();
}
final boolean isBlastRequired = line.equalsIgnoreCase("YES");
pirsfDatRecord.setBlastRequired(isBlastRequired);
data.put(pirsfDatRecord.getModelAccession(), pirsfDatRecord);
} else {
modelStart = PIRSF_DAT_PATTERN_SUBFAM.matcher(line);
if (modelStart.find()) {
// New accession with sub families
row = 1;
pirsfDatRecord = parseSubFamilyLine(line);
} else {
LOGGER.warn("Unexpected line in pirsf.dat: " + line);
}
}
row++;
}
} finally {
if (reader != null) {
reader.close();
}
}
return data;
}
/**
* @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
protected void doParse(
Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
Map<String, ParsingModuleInfo> scripts =
parseSpecificBeans(element, parserContext, builder.getRawBeanDefinition(), ns(LANG_URI));
ElementSelector searchFolders = and(sameNs(element), name("search-folders"));
ElementSelector searchFiles = and(sameNs(element), name("search-files"));
for (Element subElement : subElements(element)) {
String prefix = null;
String typeName = null;
String moduleName = null;
Pattern scriptNamePattern = null;
String scriptResourceName = null;
String language = null;
if (searchFolders.accept(subElement)) {
String folderName =
assertNotNull(
normalizePathName(subElement.getAttribute("folders")),
"no folder name provided for search-folders");
// 取prefix
prefix = getPrefix(folderName);
if (prefix != null) {
folderName = folderName.substring(prefix.length() + 1);
}
// folderName不以/开始
if (folderName.startsWith("/")) {
folderName = folderName.substring(1);
}
scriptNamePattern = compilePathName(folderName);
typeName =
assertNotNull(trimToNull(subElement.getAttribute("type")), "no type name provided");
language = trimToNull(subElement.getAttribute("language"));
scriptResourceName = folderName + "/**/*.*";
log.trace(
"Searching in folders: {}, moduleType={}, language={}",
new Object[] {folderName, typeName, language == null ? "auto" : language});
} else if (searchFiles.accept(subElement)) {
String fileName =
assertNotNull(
normalizePathName(subElement.getAttribute("files")),
"no script file name provided for search-files");
// fileName不以/结尾
assertTrue(!fileName.endsWith("/"), "invalid script file name: %s", fileName);
// 取prefix
prefix = getPrefix(fileName);
if (prefix != null) {
fileName = fileName.substring(prefix.length() + 1);
}
// fileName不以/开始
if (fileName.startsWith("/")) {
fileName = fileName.substring(1);
}
scriptNamePattern = compilePathName(fileName);
typeName =
assertNotNull(trimToNull(subElement.getAttribute("type")), "no type name provided");
moduleName =
assertNotNull(trimToNull(subElement.getAttribute("name")), "no module name provided");
language = trimToNull(subElement.getAttribute("language"));
scriptResourceName = fileName;
log.trace(
"Searching for script files: {}, moduleType={}, moduleName={}, language={}",
new Object[] {fileName, typeName, moduleName, language == null ? "auto" : language});
}
if (scriptResourceName != null) {
scriptResourceName =
prefix == null ? scriptResourceName : prefix + ":" + scriptResourceName;
// 扫描scripts
ResourcePatternResolver resolver =
new PathMatchingResourcePatternResolver(
parserContext.getReaderContext().getResourceLoader());
int found = 0;
try {
Resource[] resources = resolver.getResources(scriptResourceName.replace('?', '*'));
BeanDefinitionDefaults defaults = getBeanDefinitionDefaults(subElement, parserContext);
ParsingModuleMatcher matcher =
new ParsingModuleMatcher(scripts, scriptNamePattern, typeName, moduleName) {
@Override
protected String getName(String name, String itemName) {
String ext = getExt(itemName);
if (ext != null && name.endsWith("." + ext)) {
return name.substring(0, name.length() - ext.length() - 1);
}
return name;
}
};
for (Resource resource : resources) {
if (resource.isReadable()) {
URI uri = resource.getURI();
if (uri == null) {
continue;
}
String resourceName = uri.normalize().toString();
if (matcher.doMatch(resourceName)) {
BeanDefinition scriptBean =
createScriptBean(subElement, parserContext, resourceName, language, defaults);
String beanName =
matcher.generateBeanName(resourceName, parserContext.getRegistry());
parserContext.getRegistry().registerBeanDefinition(beanName, scriptBean);
found++;
}
}
}
} catch (IOException e) {
parserContext
.getReaderContext()
.error("Failed to scan resources: " + scriptResourceName, subElement, e);
return;
}
log.debug("Found {} module scripts with pattern: {}", found, scriptResourceName);
}
}
postProcessItems(element, parserContext, builder, scripts, "search-folders or search-files");
}
