001 /** 002 * 003 * Licensed to the Apache Software Foundation (ASF) under one or more 004 * contributor license agreements. See the NOTICE file distributed with 005 * this work for additional information regarding copyright ownership. 006 * The ASF licenses this file to You under the Apache License, Version 2.0 007 * (the "License"); you may not use this file except in compliance with 008 * the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, software 013 * distributed under the License is distributed on an "AS IS" BASIS, 014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 015 * See the License for the specific language governing permissions and 016 * limitations under the License. 017 */ 018 package org.apache.camel.component.jpa; 019 020 import org.apache.camel.Consumer; 021 import org.apache.camel.Exchange; 022 import org.apache.camel.Expression; 023 import org.apache.camel.NoTypeConversionAvailableException; 024 import org.apache.camel.Processor; 025 import org.apache.camel.Producer; 026 import org.apache.camel.builder.ExpressionBuilder; 027 import org.apache.camel.impl.DefaultExchange; 028 import org.apache.camel.impl.ScheduledPollEndpoint; 029 import org.apache.camel.util.IntrospectionSupport; 030 import org.springframework.orm.jpa.JpaTemplate; 031 032 import javax.persistence.EntityManager; 033 import javax.persistence.EntityManagerFactory; 034 import javax.persistence.Persistence; 035 import java.util.Map; 036 037 /** 038 * @version $Revision: 541335 $ 039 */ 040 public class JpaEndpoint extends ScheduledPollEndpoint<Exchange> { 041 private EntityManagerFactory entityManagerFactory; 042 private String persistenceUnit = "camel"; 043 private JpaTemplate template; 044 private Expression<Exchange> producerExpression; 045 private int maximumResults = -1; 046 private Class<?> entityType; 047 private Map entityManagerProperties; 048 049 public JpaEndpoint(String uri, JpaComponent component) { 050 super(uri, component); 051 entityManagerFactory = component.getEntityManagerFactory(); 052 } 053 054 public Exchange createExchange() { 055 return new DefaultExchange(getContext()); 056 } 057 058 public Producer<Exchange> createProducer() throws Exception { 059 return new JpaProducer(this, getProducerExpression()); 060 } 061 062 public Consumer<Exchange> createConsumer(Processor processor) throws Exception { 063 JpaConsumer consumer = new JpaConsumer(this, processor); 064 configureConsumer(consumer); 065 return consumer; 066 } 067 068 @Override 069 public void configureProperties(Map options) { 070 super.configureProperties(options); 071 Map emProperties = IntrospectionSupport.extractProperties(options, "emf."); 072 if (emProperties != null) { 073 setEntityManagerProperties(emProperties); 074 } 075 } 076 077 public boolean isSingleton() { 078 return false; 079 } 080 081 // Properties 082 //------------------------------------------------------------------------- 083 public JpaTemplate getTemplate() { 084 if (template == null) { 085 template = createTemplate(); 086 } 087 return template; 088 } 089 090 public void setTemplate(JpaTemplate template) { 091 this.template = template; 092 } 093 094 public Expression<Exchange> getProducerExpression() { 095 if (producerExpression == null) { 096 producerExpression = createProducerExpression(); 097 } 098 return producerExpression; 099 } 100 101 public void setProducerExpression(Expression<Exchange> producerExpression) { 102 this.producerExpression = producerExpression; 103 } 104 105 public int getMaximumResults() { 106 return maximumResults; 107 } 108 109 public void setMaximumResults(int maximumResults) { 110 this.maximumResults = maximumResults; 111 } 112 113 public Class<?> getEntityType() { 114 return entityType; 115 } 116 117 public void setEntityType(Class<?> entityType) { 118 this.entityType = entityType; 119 } 120 121 public EntityManagerFactory getEntityManagerFactory() { 122 if (entityManagerFactory == null) { 123 entityManagerFactory = createEntityManagerFactory(); 124 } 125 return entityManagerFactory; 126 } 127 128 public void setEntityManagerFactory(EntityManagerFactory entityManagerFactory) { 129 this.entityManagerFactory = entityManagerFactory; 130 } 131 132 public Map getEntityManagerProperties() { 133 if (entityManagerProperties == null) { 134 entityManagerProperties = System.getProperties(); 135 } 136 return entityManagerProperties; 137 } 138 139 public void setEntityManagerProperties(Map entityManagerProperties) { 140 this.entityManagerProperties = entityManagerProperties; 141 } 142 143 public String getPersistenceUnit() { 144 return persistenceUnit; 145 } 146 147 public void setPersistenceUnit(String persistenceUnit) { 148 this.persistenceUnit = persistenceUnit; 149 } 150 151 // Implementation methods 152 //------------------------------------------------------------------------- 153 protected JpaTemplate createTemplate() { 154 return new JpaTemplate(getEntityManagerFactory()); 155 } 156 157 protected EntityManagerFactory createEntityManagerFactory() { 158 return Persistence.createEntityManagerFactory(persistenceUnit, getEntityManagerProperties()); 159 } 160 161 protected EntityManager createEntityManager() { 162 return getEntityManagerFactory().createEntityManager(); 163 } 164 165 protected TransactionStrategy createTransactionStrategy() { 166 EntityManagerFactory emf = getEntityManagerFactory(); 167 return JpaTemplateTransactionStrategy.newInstance(emf, getTemplate()); 168 //return new DefaultTransactionStrategy(emf); 169 } 170 171 protected Expression<Exchange> createProducerExpression() { 172 final Class<?> type = getEntityType(); 173 if (type == null) { 174 return ExpressionBuilder.bodyExpression(); 175 } 176 else { 177 return new Expression<Exchange>() { 178 public Object evaluate(Exchange exchange) { 179 Object answer = exchange.getIn().getBody(type); 180 if (answer == null) { 181 Object defaultValue = exchange.getIn().getBody(); 182 if (defaultValue != null) { 183 throw new NoTypeConversionAvailableException(defaultValue, type); 184 } 185 186 // if we don't have a body then 187 // lets instantiate and inject a new instance 188 answer = exchange.getContext().getInjector().newInstance(type); 189 } 190 return answer; 191 } 192 }; 193 } 194 } 195 }