Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2012 International Business Machines Corp.
   * 
   * See the NOTICE file distributed with this work for additional information
   * regarding copyright ownership. Licensed under the Apache License, 
   * Version 2.0 (the "License"); you may not use this file except in compliance
   * with the License. You may obtain a copy of the License at
   * 
   *   http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
 */
 package com.ibm.jbatch.container.services.impl;
 
 import java.util.List;
 import java.util.Map;
 
 
 
 
 	private final static Logger logger = Logger.getLogger(DelegatingBatchArtifactFactoryImpl.class.getName());
 	private final static String CLASSNAME = DelegatingBatchArtifactFactoryImpl.class.getName();
 	
     protected static IBatchArtifactFactory preferredArtifactFactory = ServicesManagerImpl.getInstance().getPreferredArtifactFactory();
   
 
 	// TODO - surface constants
 	private final static String BATCH_XML = "META-INF/batch.xml";
 	private final static QName BATCH_ROOT_ELEM = new QName("http://xmlns.jcp.org/xml/ns/javaee""batch-artifacts");
 
 	// Uses TCCL
 	public Object load(String batchId) {
         String methodName = "load";
 
         if (.isLoggable(.)) {
             .entering(methodName"Loading batch artifact id = " + batchId);
         }
 
         if (.isLoggable(.)) {
             .log(."Delegating to preferred artifact factory" + );
         }
 
         //If preferred artifact factory is different from this one, use the preferred factory.
         if (!.getClass().equals(this.getClass())) {
             Object artifact = .load(batchId);
             if (artifact != null) {
                 return artifact;
             }
         }
         
         if (.isLoggable(.)) {
             .log(."Preferred artifact factory failed to load artifact " + batchId +". Defaulting to batch.xml.");
         }
         
         ClassLoader tccl = Thread.currentThread().getContextClassLoader();
 
         if (.isLoggable(.)) {
             .fine("TCCL = " + tccl);
         }
 
         ArtifactMap artifactMap = initArtifactMapFromClassLoader(tccl);
 
 		Object loadedArtifact = null;
         if (artifactMap != null) {
         	loadedArtifact = artifactMap.getArtifactById(batchId);
         }
 
 		if (loadedArtifact == null) {
 	            .log(."Artifact not found in batch.xml, trying classloader");
 	        }
 			
 			try {
 				Class<?> artifactClass = Thread.currentThread().getContextClassLoader().loadClass(batchId);
 				if(artifactClass != null) {
 					loadedArtifact = artifactClass.newInstance();
 				}
catch (ClassNotFoundException e) {
				throw new BatchContainerRuntimeException("Tried but failed to load artifact with id: " + batchIde);
catch (InstantiationException e) {
				throw new BatchContainerRuntimeException("Tried but failed to load artifact with id: " + batchIde);
catch (IllegalAccessException e) {
				throw new BatchContainerRuntimeException("Tried but failed to load artifact with id: " + batchIde);
			}
		}
		DependencyInjectionUtility.injectReferences(loadedArtifact, ProxyFactory.getInjectionReferences());
			.exiting(methodName"For batch artifact id = " + batchId + ", loaded artifact instance: " +
					loadedArtifact + " of type: " + loadedArtifact.getClass().getCanonicalName());
		}
		return loadedArtifact;
	}
        ArtifactMap artifactMap = new ArtifactMap();
        
        InputStream is = getBatchXMLStreamFromClassLoader(loader);
        if (is == null) {
        	return null
        } else {
        	artifactMap = populateArtifactMapFromStream(artifactMapis);
        }
        
        return artifactMap;
    }
	}
	/*
	 * Non-validating (e.g. that the artifact type is correct) load
	 * 
	 * TODO - add some logging to the parsing
	 */
		XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
		try {
			XMLStreamReader xmlStreamReader = xmlInputFactory.createXMLStreamReader(is);
				.finest("Loaded XMLStreamReader = " + xmlStreamReader);
			}
			boolean processedRoot = false;
			// We are going to take advantage of the simplified structure of a
			// line
			// E.g.:
			// <batch-artifacts>
			//   <item-processor id=MyItemProcessor class=jsr352/sample/MyItemProcessorImpl/>
			//   ..
			// </batch-artifacts>
			//
			// and have much simpler logic than general-purpose parsing would
			// require.
			while (xmlStreamReader.hasNext()) {
				int event = xmlStreamReader.next();
				// Until we reach end of document
				if (event == ) {
					break;
				}
				// At this point we have either:
				//    A) just passed START_DOCUMENT, and are at START_ELEMENT for the root, 
				//       <batch-artifacts>, or 
				//    B) we have just passed END_ELEMENT for one of the artifacts which is a child of
				//       <batch-artifacts>.
				//   
				//  Only handle START_ELEMENT now so we can skip whitespace CHARACTERS events.
				//
				if (event == ) {
					if (!processedRoot) {
						QName rootQName = xmlStreamReader.getName();
						if (!rootQName.equals()) {
							throw new IllegalStateException("Expecting document with root element QName: " + 
", but found root element with QName: " + rootQName);
else {
							processedRoot = true;
						}
else {
						// Should only need localName
						String annotationShortName = xmlStreamReader.getLocalName();
						String id = xmlStreamReader.getAttributeValue(null"id");
						String className = xmlStreamReader.getAttributeValue(null"class");
						tempMap.addEntry(annotationShortNameidclassName);
						// Ignore anything else (text/whitespace) within this
						// element
						while (event != ) {
							event = xmlStreamReader.next();
						}
					}
				}
			}
			xmlStreamReader.close();
			is.close();
			return tempMap;
catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	private class ArtifactMap {
		private Map<StringClass<?>> idToArtifactClassMap = new HashMap<StringClass<?>>();
		// Maps to a list of types not a single type since there's no reason a single artifact couldn't be annotated
		// with >1 batch artifact annotation type.
		/*
		 * Init already synchronized, so no need to synch further
		 */
		private void addEntry(String batchTypeNameString idString className) {
			try {
					Class<?> artifactClass = Thread.currentThread().getContextClassLoader().loadClass(className);
					.put(idartifactClass);
					List<StringtypeList = new ArrayList<String>();
					typeList.add(batchTypeName);                    
					.put(idtypeList);                    
else {
					Class<?> artifactClass = Thread.currentThread().getContextClassLoader().loadClass(className);
					// Already contains entry for this 'id', let's make sure it's the same Class
					// which thus must implement >1 batch artifact "type" (i.e. contains >1 batch artifact annotation).
					if (!.get(id).equals(artifactClass)) {
							Class<?> alreadyLoaded = .get(id); 
							.severe("Attempted to load batch artifact with id: " + id + ", and className: " + className + 
									".   Found: " + artifactClass + ", however the artifact id: " + id + 
									" is already associated with: " + alreadyLoaded + ", of className: " +
									alreadyLoaded.getCanonicalName());
						}
						throw new IllegalArgumentException("Already loaded a different class for id = " + id);
					}
					typeList.add(batchTypeName);
				}
catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
		private Object getArtifactById(String id) {
			Object artifactInstance = null;
			try {
				Class<?> clazz = .get(id);
				if (clazz != null) {
					artifactInstance = (.get(id)).newInstance();	
				}
catch (IllegalAccessException e) {
				throw new BatchContainerRuntimeException("Tried but failed to load artifact with id: " + ide);
catch (InstantiationException e) {
				throw new BatchContainerRuntimeException("Tried but failed to load artifact with id: " + ide);
			}
			return artifactInstance;
		}
		}
	}
	public void init(IBatchConfig batchConfigthrows BatchContainerServiceException {
		// TODO Auto-generated method stub
	}
	public void shutdown() throws BatchContainerServiceException {
		// TODO Auto-generated method stub
	}
New to GrepCode? Check out our FAQ X