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