diff options
Diffstat (limited to 'sandbox/old/contrib/persistence/common/src/main/java/org/apache/tuscany/service/persistence/common/PersistenceContextProcessor.java')
-rw-r--r-- | sandbox/old/contrib/persistence/common/src/main/java/org/apache/tuscany/service/persistence/common/PersistenceContextProcessor.java | 161 |
1 files changed, 161 insertions, 0 deletions
diff --git a/sandbox/old/contrib/persistence/common/src/main/java/org/apache/tuscany/service/persistence/common/PersistenceContextProcessor.java b/sandbox/old/contrib/persistence/common/src/main/java/org/apache/tuscany/service/persistence/common/PersistenceContextProcessor.java new file mode 100644 index 0000000000..9d247fae43 --- /dev/null +++ b/sandbox/old/contrib/persistence/common/src/main/java/org/apache/tuscany/service/persistence/common/PersistenceContextProcessor.java @@ -0,0 +1,161 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.tuscany.service.persistence.common; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Proxy; +import java.net.URI; +import java.util.Properties; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.PersistenceContext; +import javax.persistence.PersistenceContextType; +import javax.persistence.PersistenceProperty; +import javax.transaction.TransactionManager; + +import org.osoa.sca.annotations.Reference; + +import org.apache.tuscany.spi.ObjectFactory; +import org.apache.tuscany.spi.component.RegistrationException; +import org.apache.tuscany.spi.deployer.DeploymentContext; +import org.apache.tuscany.spi.idl.InvalidServiceContractException; +import org.apache.tuscany.spi.idl.java.InterfaceJavaIntrospector; +import org.apache.tuscany.spi.implementation.java.AbstractPropertyProcessor; +import org.apache.tuscany.spi.implementation.java.ImplementationProcessorService; +import org.apache.tuscany.spi.implementation.java.JavaMappedProperty; +import org.apache.tuscany.spi.implementation.java.ProcessingException; +import org.apache.tuscany.spi.model.ServiceContract; + +import org.apache.tuscany.core.component.ComponentManager; + +/** + * Annotation processor for injecting <code>PersistenceUnit</code> annotations on properties. + * + * @version $Rev$ $Date$ + */ +public class PersistenceContextProcessor extends AbstractPropertyProcessor<PersistenceContext> { + + /** + * Transaction Manager + */ + private TransactionManager transactionManager; + private ComponentManager componentManager; + private InterfaceJavaIntrospector introspector; + + /** + * Persistence unit builder + */ + private PersistenceUnitBuilder builder = new DefaultPersistenceUnitBuilder(); + + /** + * Injects the implementation processor service. + * + * @param service Implementation processor service. + */ + public PersistenceContextProcessor(@Reference ImplementationProcessorService service) { + super(PersistenceContext.class, service); + } + + @Reference + public void setTransactionManager(TransactionManager transactionManager) { + this.transactionManager = transactionManager; + } + + @Reference + public void setComponentManager(ComponentManager componentManager) { + this.componentManager = componentManager; + } + + @Reference + public void setIntrospector(InterfaceJavaIntrospector introspector) { + this.introspector = introspector; + } + + /** + * Defaults to the field name. + */ + @Override + protected String getName(PersistenceContext persistenceContext) { + return null; + } + + /** + * Initializes the property. + */ + @SuppressWarnings("unchecked") + protected <T> void initProperty(JavaMappedProperty<T> property, + PersistenceContext annotation, + DeploymentContext context) throws ProcessingException { + + String unitName = annotation.unitName(); + URI unitUri = context.getComponentId().resolve(unitName); + EntityManagerFactory emf = (EntityManagerFactory) componentManager.getComponent(unitUri); + + if (emf == null) { + emf = builder.newEntityManagerFactory(unitName, context.getClassLoader()); + try { + ServiceContract<EntityManagerFactory> contract = + (ServiceContract) introspector.introspect(EntityManagerFactory.class); + componentManager.registerJavaObject(unitUri, contract, emf); + } catch (RegistrationException e) { + throw new ProcessingException(e); + } catch (InvalidServiceContractException e) { + throw new ProcessingException(e); + } + } + ObjectFactory factory = new EmObjectFactory(emf, annotation); + property.setDefaultValueFactory(factory); + + } + + private class EmObjectFactory implements ObjectFactory<EntityManager> { + + private EntityManagerFactory emf; + private PersistenceContext annotation; + + public EmObjectFactory(EntityManagerFactory emf, PersistenceContext annotation) { + this.emf = emf; + this.annotation = annotation; + } + + public EntityManager getInstance() { + + PersistenceContextType type = annotation.type(); + if (type == PersistenceContextType.TRANSACTION) { + + Properties props = new Properties(); + for (PersistenceProperty property : annotation.properties()) { + props.put(property.name(), property.value()); + } + + Class[] interfaces = new Class[]{EntityManager.class}; + InvocationHandler handler = new EntityManagerProxy(props, emf, transactionManager); + EntityManager em = + (EntityManager) Proxy.newProxyInstance(getClass().getClassLoader(), interfaces, handler); + return em; + + } else { + throw new UnsupportedOperationException("Extended persistence contexts not supported"); + } + + } + + } + +} |