001/* 002 * Copyright 2002-2020 the original author or authors. 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * https://www.apache.org/licenses/LICENSE-2.0 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013 * See the License for the specific language governing permissions and 014 * limitations under the License. 015 */ 016 017package org.springframework.orm.jpa.persistenceunit; 018 019import java.net.URL; 020import java.util.LinkedList; 021import java.util.List; 022import java.util.Properties; 023import javax.persistence.SharedCacheMode; 024import javax.persistence.ValidationMode; 025import javax.persistence.spi.ClassTransformer; 026import javax.persistence.spi.PersistenceUnitTransactionType; 027import javax.sql.DataSource; 028 029import org.springframework.util.ClassUtils; 030 031/** 032 * Spring's base implementation of the JPA 033 * {@link javax.persistence.spi.PersistenceUnitInfo} interface, 034 * used to bootstrap an {@code EntityManagerFactory} in a container. 035 * 036 * <p>This implementation is largely a JavaBean, offering mutators 037 * for all standard {@code PersistenceUnitInfo} properties. 038 * 039 * @author Rod Johnson 040 * @author Juergen Hoeller 041 * @author Costin Leau 042 * @since 2.0 043 */ 044public class MutablePersistenceUnitInfo implements SmartPersistenceUnitInfo { 045 046 private String persistenceUnitName; 047 048 private String persistenceProviderClassName; 049 050 private PersistenceUnitTransactionType transactionType; 051 052 private DataSource nonJtaDataSource; 053 054 private DataSource jtaDataSource; 055 056 private final List<String> mappingFileNames = new LinkedList<String>(); 057 058 private final List<URL> jarFileUrls = new LinkedList<URL>(); 059 060 private URL persistenceUnitRootUrl; 061 062 private final List<String> managedClassNames = new LinkedList<String>(); 063 064 private final List<String> managedPackages = new LinkedList<String>(); 065 066 private boolean excludeUnlistedClasses = false; 067 068 private SharedCacheMode sharedCacheMode = SharedCacheMode.UNSPECIFIED; 069 070 private ValidationMode validationMode = ValidationMode.AUTO; 071 072 private Properties properties = new Properties(); 073 074 private String persistenceXMLSchemaVersion = "2.0"; 075 076 private String persistenceProviderPackageName; 077 078 079 public void setPersistenceUnitName(String persistenceUnitName) { 080 this.persistenceUnitName = persistenceUnitName; 081 } 082 083 @Override 084 public String getPersistenceUnitName() { 085 return this.persistenceUnitName; 086 } 087 088 public void setPersistenceProviderClassName(String persistenceProviderClassName) { 089 this.persistenceProviderClassName = persistenceProviderClassName; 090 } 091 092 @Override 093 public String getPersistenceProviderClassName() { 094 return this.persistenceProviderClassName; 095 } 096 097 public void setTransactionType(PersistenceUnitTransactionType transactionType) { 098 this.transactionType = transactionType; 099 } 100 101 @Override 102 public PersistenceUnitTransactionType getTransactionType() { 103 if (this.transactionType != null) { 104 return this.transactionType; 105 } 106 else { 107 return (this.jtaDataSource != null ? 108 PersistenceUnitTransactionType.JTA : PersistenceUnitTransactionType.RESOURCE_LOCAL); 109 } 110 } 111 112 public void setJtaDataSource(DataSource jtaDataSource) { 113 this.jtaDataSource = jtaDataSource; 114 } 115 116 @Override 117 public DataSource getJtaDataSource() { 118 return this.jtaDataSource; 119 } 120 121 public void setNonJtaDataSource(DataSource nonJtaDataSource) { 122 this.nonJtaDataSource = nonJtaDataSource; 123 } 124 125 @Override 126 public DataSource getNonJtaDataSource() { 127 return this.nonJtaDataSource; 128 } 129 130 public void addMappingFileName(String mappingFileName) { 131 this.mappingFileNames.add(mappingFileName); 132 } 133 134 @Override 135 public List<String> getMappingFileNames() { 136 return this.mappingFileNames; 137 } 138 139 public void addJarFileUrl(URL jarFileUrl) { 140 this.jarFileUrls.add(jarFileUrl); 141 } 142 143 @Override 144 public List<URL> getJarFileUrls() { 145 return this.jarFileUrls; 146 } 147 148 public void setPersistenceUnitRootUrl(URL persistenceUnitRootUrl) { 149 this.persistenceUnitRootUrl = persistenceUnitRootUrl; 150 } 151 152 @Override 153 public URL getPersistenceUnitRootUrl() { 154 return this.persistenceUnitRootUrl; 155 } 156 157 /** 158 * Add a managed class name to the persistence provider's metadata. 159 * @see javax.persistence.spi.PersistenceUnitInfo#getManagedClassNames() 160 * @see #addManagedPackage 161 */ 162 public void addManagedClassName(String managedClassName) { 163 this.managedClassNames.add(managedClassName); 164 } 165 166 @Override 167 public List<String> getManagedClassNames() { 168 return this.managedClassNames; 169 } 170 171 /** 172 * Add a managed package to the persistence provider's metadata. 173 * <p>Note: This refers to annotated {@code package-info.java} files. It does 174 * <i>not</i> trigger entity scanning in the specified package; this is 175 * rather the job of {@link DefaultPersistenceUnitManager#setPackagesToScan}. 176 * @since 4.1 177 * @see SmartPersistenceUnitInfo#getManagedPackages() 178 * @see #addManagedClassName 179 */ 180 public void addManagedPackage(String packageName) { 181 this.managedPackages.add(packageName); 182 } 183 184 @Override 185 public List<String> getManagedPackages() { 186 return this.managedPackages; 187 } 188 189 public void setExcludeUnlistedClasses(boolean excludeUnlistedClasses) { 190 this.excludeUnlistedClasses = excludeUnlistedClasses; 191 } 192 193 @Override 194 public boolean excludeUnlistedClasses() { 195 return this.excludeUnlistedClasses; 196 } 197 198 public void setSharedCacheMode(SharedCacheMode sharedCacheMode) { 199 this.sharedCacheMode = sharedCacheMode; 200 } 201 202 @Override 203 public SharedCacheMode getSharedCacheMode() { 204 return this.sharedCacheMode; 205 } 206 207 public void setValidationMode(ValidationMode validationMode) { 208 this.validationMode = validationMode; 209 } 210 211 @Override 212 public ValidationMode getValidationMode() { 213 return this.validationMode; 214 } 215 216 public void addProperty(String name, String value) { 217 if (this.properties == null) { 218 this.properties = new Properties(); 219 } 220 this.properties.setProperty(name, value); 221 } 222 223 public void setProperties(Properties properties) { 224 this.properties = properties; 225 } 226 227 @Override 228 public Properties getProperties() { 229 return this.properties; 230 } 231 232 public void setPersistenceXMLSchemaVersion(String persistenceXMLSchemaVersion) { 233 this.persistenceXMLSchemaVersion = persistenceXMLSchemaVersion; 234 } 235 236 @Override 237 public String getPersistenceXMLSchemaVersion() { 238 return this.persistenceXMLSchemaVersion; 239 } 240 241 @Override 242 public void setPersistenceProviderPackageName(String persistenceProviderPackageName) { 243 this.persistenceProviderPackageName = persistenceProviderPackageName; 244 } 245 246 public String getPersistenceProviderPackageName() { 247 return this.persistenceProviderPackageName; 248 } 249 250 251 /** 252 * This implementation returns the default ClassLoader. 253 * @see org.springframework.util.ClassUtils#getDefaultClassLoader() 254 */ 255 @Override 256 public ClassLoader getClassLoader() { 257 return ClassUtils.getDefaultClassLoader(); 258 } 259 260 /** 261 * This implementation throws an UnsupportedOperationException. 262 */ 263 @Override 264 public void addTransformer(ClassTransformer classTransformer) { 265 throw new UnsupportedOperationException("addTransformer not supported"); 266 } 267 268 /** 269 * This implementation throws an UnsupportedOperationException. 270 */ 271 @Override 272 public ClassLoader getNewTempClassLoader() { 273 throw new UnsupportedOperationException("getNewTempClassLoader not supported"); 274 } 275 276 277 @Override 278 public String toString() { 279 return "PersistenceUnitInfo: name '" + this.persistenceUnitName + 280 "', root URL [" + this.persistenceUnitRootUrl + "]"; 281 } 282 283}