How to use

PersistenceAnnotationBeanPostProcessor

in

org.springframework.orm.jpa.support

@Bean
public PersistenceAnnotationBeanPostProcessor persistenceAnnotationBeanPostProcessor() {
  return new PersistenceAnnotationBeanPostProcessor();
}

private InjectionMetadata findPersistenceMetadata(String beanName, final Class<?> clazz, @Nullable PropertyValues pvs) {
  // Fall back to class name as cache key, for backwards compatibility with custom callers.
  String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
  // Quick check on the concurrent map first, with minimal locking.
  InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
  if (InjectionMetadata.needsRefresh(metadata, clazz)) {
    synchronized (this.injectionMetadataCache) {
      metadata = this.injectionMetadataCache.get(cacheKey);
      if (InjectionMetadata.needsRefresh(metadata, clazz)) {
        if (metadata != null) {
          metadata.clear(pvs);
        }
        metadata = buildPersistenceMetadata(clazz);
        this.injectionMetadataCache.put(cacheKey, metadata);
      }
    }
  }
  return metadata;
}

/**
 * Find an EntityManagerFactory with the given name in the current Spring
 * application context, falling back to a single default EntityManagerFactory
 * (if any) in case of no unit name specified.
 * @param unitName the name of the persistence unit (may be {@code null} or empty)
 * @param requestingBeanName the name of the requesting bean
 * @return the EntityManagerFactory
 * @throws NoSuchBeanDefinitionException if there is no such EntityManagerFactory in the context
 */
protected EntityManagerFactory findEntityManagerFactory(@Nullable String unitName, @Nullable String requestingBeanName)
    throws NoSuchBeanDefinitionException {
  String unitNameForLookup = (unitName != null ? unitName : "");
  if (unitNameForLookup.isEmpty()) {
    unitNameForLookup = this.defaultPersistenceUnitName;
  }
  if (!unitNameForLookup.isEmpty()) {
    return findNamedEntityManagerFactory(unitNameForLookup, requestingBeanName);
  }
  else {
    return findDefaultEntityManagerFactory(requestingBeanName);
  }
}

private EntityManagerFactory resolveEntityManagerFactory(@Nullable String requestingBeanName) {
  // Obtain EntityManagerFactory from JNDI?
  EntityManagerFactory emf = getPersistenceUnit(this.unitName);
  if (emf == null) {
    // Need to search for EntityManagerFactory beans.
    emf = findEntityManagerFactory(this.unitName, requestingBeanName);
  }
  return emf;
}

  private EntityManager resolveExtendedEntityManager(Object target, @Nullable String requestingBeanName) {
    // Obtain EntityManager reference from JNDI?
    EntityManager em = getPersistenceContext(this.unitName, true);
    if (em == null) {
      // No pre-built EntityManager found -> build one based on factory.
      // Obtain EntityManagerFactory from JNDI?
      EntityManagerFactory emf = getPersistenceUnit(this.unitName);
      if (emf == null) {
        // Need to search for EntityManagerFactory beans.
        emf = findEntityManagerFactory(this.unitName, requestingBeanName);
      }
      // Inject a container-managed extended EntityManager.
      em = ExtendedEntityManagerCreator.createContainerManagedEntityManager(
          emf, this.properties, this.synchronizedWithTransaction);
    }
    if (em instanceof EntityManagerProxy && beanFactory != null && requestingBeanName != null &&
        beanFactory.containsBean(requestingBeanName) && !beanFactory.isPrototype(requestingBeanName)) {
      extendedEntityManagersToClose.put(target, ((EntityManagerProxy) em).getTargetEntityManager());
    }
    return em;
  }
}

@Test
public void testSinglePersistenceContextFromJndi() {
  EntityManager mockEm = mock(EntityManager.class);
  EntityManager mockEm2 = mock(EntityManager.class);
  Map<String, String> persistenceContexts = new HashMap<>();
  persistenceContexts.put("System", "pc1");
  Map<String, String> extendedPersistenceContexts = new HashMap<>();
  extendedPersistenceContexts .put("System", "pc2");
  ExpectedLookupTemplate jt = new ExpectedLookupTemplate();
  jt.addObject("java:comp/env/pc1", mockEm);
  jt.addObject("java:comp/env/pc2", mockEm2);
  DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
  PersistenceAnnotationBeanPostProcessor bpp = new PersistenceAnnotationBeanPostProcessor();
  bpp.setPersistenceContexts(persistenceContexts);
  bpp.setExtendedPersistenceContexts(extendedPersistenceContexts);
  bpp.setJndiTemplate(jt);
  bf.addBeanPostProcessor(bpp);
  bf.registerBeanDefinition(DefaultPrivatePersistenceContextField.class.getName(),
      new RootBeanDefinition(DefaultPrivatePersistenceContextField.class));
  bf.registerBeanDefinition(DefaultPublicPersistenceContextSetter.class.getName(),
      new RootBeanDefinition(DefaultPublicPersistenceContextSetter.class));
  DefaultPrivatePersistenceContextField bean1 = (DefaultPrivatePersistenceContextField)
      bf.getBean(DefaultPrivatePersistenceContextField.class.getName());
  DefaultPublicPersistenceContextSetter bean2 = (DefaultPublicPersistenceContextSetter)
      bf.getBean(DefaultPublicPersistenceContextSetter.class.getName());
  assertSame(mockEm, bean1.em);
  assertSame(mockEm2, bean2.em);
}

@Test
public void testFieldOfWrongTypeAnnotatedWithPersistenceUnit() {
  PersistenceAnnotationBeanPostProcessor pabpp = new PersistenceAnnotationBeanPostProcessor();
  try {
    pabpp.postProcessProperties(null, new FieldOfWrongTypeAnnotatedWithPersistenceUnit(), "bean");
    fail("Can't inject this field");
  }
  catch (IllegalStateException ex) {
    // Ok
  }
}

@Deprecated
@Override
public PropertyValues postProcessPropertyValues(
    PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) {
  return postProcessProperties(pvs, bean, beanName);
}

@Test
public void testPersistenceUnitsFromJndiWithDefaultUnit() {
  EntityManagerFactoryWithInfo mockEmf2 = mock(EntityManagerFactoryWithInfo.class);
  Map<String, String> persistenceUnits = new HashMap<>();
  persistenceUnits.put("System", "pu1");
  persistenceUnits.put("Person", "pu2");
  ExpectedLookupTemplate jt = new ExpectedLookupTemplate();
  jt.addObject("java:comp/env/pu1", mockEmf);
  jt.addObject("java:comp/env/pu2", mockEmf2);
  DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
  PersistenceAnnotationBeanPostProcessor bpp = new PersistenceAnnotationBeanPostProcessor();
  bpp.setPersistenceUnits(persistenceUnits);
  bpp.setDefaultPersistenceUnitName("System");
  bpp.setJndiTemplate(jt);
  bf.addBeanPostProcessor(bpp);
  bf.registerBeanDefinition(DefaultPublicPersistenceUnitSetter.class.getName(),
      new RootBeanDefinition(DefaultPublicPersistenceUnitSetter.class));
  bf.registerBeanDefinition(DefaultPublicPersistenceUnitSetterNamedPerson.class.getName(),
      new RootBeanDefinition(DefaultPublicPersistenceUnitSetterNamedPerson.class));
  DefaultPublicPersistenceUnitSetter bean = (DefaultPublicPersistenceUnitSetter)
      bf.getBean(DefaultPublicPersistenceUnitSetter.class.getName());
  DefaultPublicPersistenceUnitSetterNamedPerson bean2 = (DefaultPublicPersistenceUnitSetterNamedPerson)
      bf.getBean(DefaultPublicPersistenceUnitSetterNamedPerson.class.getName());
  assertSame(mockEmf, bean.emf);
  assertSame(mockEmf2, bean2.emf);
}

@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
  InjectionMetadata metadata = findPersistenceMetadata(beanName, bean.getClass(), pvs);
  try {
    metadata.inject(bean, beanName, pvs);
  }
  catch (Throwable ex) {
    throw new BeanCreationException(beanName, "Injection of persistence dependencies failed", ex);
  }
  return pvs;
}

/**
 * Return a specified persistence unit for the given unit name,
 * as defined through the "persistenceUnits" map.
 * @param unitName the name of the persistence unit
 * @return the corresponding EntityManagerFactory,
 * or {@code null} if none found
 * @see #setPersistenceUnits
 */
@Nullable
protected EntityManagerFactory getPersistenceUnit(@Nullable String unitName) {
  if (this.persistenceUnits != null) {
    String unitNameForLookup = (unitName != null ? unitName : "");
    if (unitNameForLookup.isEmpty()) {
      unitNameForLookup = this.defaultPersistenceUnitName;
    }
    String jndiName = this.persistenceUnits.get(unitNameForLookup);
    if (jndiName == null && "".equals(unitNameForLookup) && this.persistenceUnits.size() == 1) {
      jndiName = this.persistenceUnits.values().iterator().next();
    }
    if (jndiName != null) {
      try {
        return lookup(jndiName, EntityManagerFactory.class);
      }
      catch (Exception ex) {
        throw new IllegalStateException("Could not obtain EntityManagerFactory [" + jndiName + "] from JNDI", ex);
      }
    }
  }
  return null;
}

@Test
public void testSinglePersistenceUnitFromJndi() {
  Map<String, String> persistenceUnits = new HashMap<>();
  persistenceUnits.put("Person", "pu1");
  ExpectedLookupTemplate jt = new ExpectedLookupTemplate();
  jt.addObject("java:comp/env/pu1", mockEmf);
  DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
  PersistenceAnnotationBeanPostProcessor bpp = new PersistenceAnnotationBeanPostProcessor();
  bpp.setPersistenceUnits(persistenceUnits);
  bpp.setJndiTemplate(jt);
  bf.addBeanPostProcessor(bpp);
  bf.registerBeanDefinition(DefaultPublicPersistenceUnitSetter.class.getName(),
      new RootBeanDefinition(DefaultPublicPersistenceUnitSetter.class));
  bf.registerBeanDefinition(DefaultPublicPersistenceUnitSetterNamedPerson.class.getName(),
      new RootBeanDefinition(DefaultPublicPersistenceUnitSetterNamedPerson.class));
  DefaultPublicPersistenceUnitSetter bean = (DefaultPublicPersistenceUnitSetter)
      bf.getBean(DefaultPublicPersistenceUnitSetter.class.getName());
  DefaultPublicPersistenceUnitSetterNamedPerson bean2 = (DefaultPublicPersistenceUnitSetterNamedPerson)
      bf.getBean(DefaultPublicPersistenceUnitSetterNamedPerson.class.getName());
  assertSame(mockEmf, bean.emf);
  assertSame(mockEmf, bean2.emf);
}

  @Override
  public void postProcessBeanFactory(
      ConfigurableListableBeanFactory beanFactory) throws BeansException {
    String[] classes = daoImplClasses.split(",");
    BeanDefinitionRegistry registry = ((BeanDefinitionRegistry) beanFactory);
    PersistenceAnnotationBeanPostProcessor pabpp = new PersistenceAnnotationBeanPostProcessor();
    if (classes != null && classes.length > 0) {
      for (String line : classes) {
        if (!"".equals(line)) {
          try {
            String[] split = line.split("\\|");
            String className = split[0];
            Class<?> clazz = Class.forName(className);
            BeanDefinition definition = new RootBeanDefinition(
                clazz);
            registry.registerBeanDefinition(clazz.getSimpleName(),
                definition);
            pabpp.postProcessMergedBeanDefinition(
                (RootBeanDefinition) definition, clazz, clazz
                    .getSimpleName());

          } catch (Exception e) {
            throw new RuntimeException(e);
          }
        }
      }
    }
  }
}

private EntityManager resolveEntityManager(@Nullable String requestingBeanName) {
  // Obtain EntityManager reference from JNDI?
  EntityManager em = getPersistenceContext(this.unitName, false);
  if (em == null) {
    // No pre-built EntityManager found -> build one based on factory.
    // Obtain EntityManagerFactory from JNDI?
    EntityManagerFactory emf = getPersistenceUnit(this.unitName);
    if (emf == null) {
      // Need to search for EntityManagerFactory beans.
      emf = findEntityManagerFactory(this.unitName, requestingBeanName);
    }
    // Inject a shared transactional EntityManager proxy.
    if (emf instanceof EntityManagerFactoryInfo &&
        ((EntityManagerFactoryInfo) emf).getEntityManagerInterface() != null) {
      // Create EntityManager based on the info's vendor-specific type
      // (which might be more specific than the field's type).
      em = SharedEntityManagerCreator.createSharedEntityManager(
          emf, this.properties, this.synchronizedWithTransaction);
    }
    else {
      // Create EntityManager based on the field's type.
      em = SharedEntityManagerCreator.createSharedEntityManager(
          emf, this.properties, this.synchronizedWithTransaction, getResourceType());
    }
  }
  return em;
}

PersistenceAnnotationBeanPostProcessor bpp = new PersistenceAnnotationBeanPostProcessor();
bpp.setPersistenceContexts(persistenceContexts);
bpp.setExtendedPersistenceContexts(extendedPersistenceContexts);
bpp.setDefaultPersistenceUnitName("System");
bpp.setJndiTemplate(jt);
bf.addBeanPostProcessor(bpp);
bf.registerBeanDefinition(DefaultPrivatePersistenceContextField.class.getName(),

@Test
public void testSetterOfWrongTypeAnnotatedWithPersistenceUnit() {
  PersistenceAnnotationBeanPostProcessor pabpp = new PersistenceAnnotationBeanPostProcessor();
  try {
    pabpp.postProcessProperties(null, new SetterOfWrongTypeAnnotatedWithPersistenceUnit(), "bean");
    fail("Can't inject this setter");
  }
  catch (IllegalStateException ex) {
    // Ok
  }
}

private EntityManagerFactory resolveEntityManagerFactory(@Nullable String requestingBeanName) {
  // Obtain EntityManagerFactory from JNDI?
  EntityManagerFactory emf = getPersistenceUnit(this.unitName);
  if (emf == null) {
    // Need to search for EntityManagerFactory beans.
    emf = findEntityManagerFactory(this.unitName, requestingBeanName);
  }
  return emf;
}

@Deprecated
@Override
public PropertyValues postProcessPropertyValues(
    PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) {
  return postProcessProperties(pvs, bean, beanName);
}

@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
  InjectionMetadata metadata = findPersistenceMetadata(beanName, beanType, null);
  metadata.checkConfigMembers(beanDefinition);
}

return lookup(jndiName, EntityManager.class);