@Override protected boolean isLazy(DependencyDescriptor descriptor) { Class<?> type = descriptor.getDependencyType(); RepositoryConfiguration<?> configuration = configurations.get(type.getName()); if (configuration == null) { return super.isLazy(descriptor); } boolean lazyInit = configuration.isLazyInit(); if (lazyInit) { LOG.debug("Creating lazy injection proxy for {}…", configuration.getRepositoryInterface()); } return lazyInit; } }
private String registerCustomImplementation(BeanDefinitionRegistry registry, ResourceLoader resourceLoader) { String beanName = configuration.getImplementationBeanName(); // Already a bean configured? if (registry.containsBeanDefinition(beanName)) { return beanName; } AbstractBeanDefinition beanDefinition = detectCustomImplementation(registry, resourceLoader); if (null == beanDefinition) { return null; } if (LOG.isDebugEnabled()) { LOG.debug("Registering custom repository implementation: " + configuration.getImplementationBeanName() + " " + beanDefinition.getBeanClassName()); } beanDefinition.setSource(configuration.getSource()); registry.registerBeanDefinition(beanName, beanDefinition); return beanName; }
@Override public Streamable<String> getBasePackages() { return config.getImplementationBasePackages(); } };
private Stream<RepositoryFragmentConfiguration> registerRepositoryFragmentsImplementation( RepositoryConfiguration<?> configuration) { ImplementationDetectionConfiguration config = configuration .toImplementationDetectionConfiguration(metadataReaderFactory); return fragmentMetadata.getFragmentInterfaces(configuration.getRepositoryInterface()) // .map(it -> detectRepositoryFragmentConfiguration(it, config)) // .flatMap(Optionals::toStream) // .peek(it -> potentiallyRegisterFragmentImplementation(configuration, it)) // .peek(it -> potentiallyRegisterRepositoryFragment(configuration, it)); }
.rootBeanDefinition(configuration.getRepositoryFactoryBeanClassName()); builder.getRawBeanDefinition().setSource(configuration.getSource()); builder.addConstructorArgValue(configuration.getRepositoryInterface()); builder.addPropertyValue("queryLookupStrategyKey", configuration.getQueryLookupStrategyKey()); builder.addPropertyValue("lazyInit", configuration.isLazyInit()); builder.setLazyInit(configuration.isLazyInit()); configuration.getRepositoryBaseClassName()// .ifPresent(it -> builder.addPropertyValue("repositoryBaseClass", it)); configuration.getNamedQueriesLocation().ifPresent(definitionBuilder::setLocations); builder.addPropertyValue("namedQueries", definitionBuilder.build(configuration.getSource())); ParsingUtils.getSourceBeanDefinition(fragmentsBuilder, configuration.getSource()));
/** * Builds a new {@link BeanDefinitionBuilder} from the given {@link BeanDefinitionRegistry} and {@link ResourceLoader} * . * * @param registry must not be {@literal null}. * @param resourceLoader must not be {@literal null}. * @return */ public BeanDefinitionBuilder build(BeanDefinitionRegistry registry, ResourceLoader resourceLoader) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null!"); Assert.notNull(resourceLoader, "ResourceLoader must not be null!"); String factoryBeanName = configuration.getRepositoryFactoryBeanName(); factoryBeanName = StringUtils.hasText(factoryBeanName) ? factoryBeanName : extension .getRepositoryFactoryClassName(); BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(factoryBeanName); builder.addPropertyValue("repositoryInterface", configuration.getRepositoryInterface()); builder.addPropertyValue("queryLookupStrategyKey", configuration.getQueryLookupStrategyKey()); NamedQueriesBeanDefinitionBuilder definitionBuilder = new NamedQueriesBeanDefinitionBuilder( extension.getDefaultNamedQueryLocation()); if (StringUtils.hasText(configuration.getNamedQueriesLocation())) { definitionBuilder.setLocations(configuration.getNamedQueriesLocation()); } builder.addPropertyValue("namedQueries", definitionBuilder.build(configuration.getSource())); String customImplementationBeanName = registerCustomImplementation(registry, resourceLoader); if (customImplementationBeanName != null) { builder.addPropertyReference("customImplementation", customImplementationBeanName); builder.addDependsOn(customImplementationBeanName); } return builder; }
/** * Registers a generic repository factory bean for a bean with the given name and the provided configuration context. * * @param parser * @param name * @param context */ private void registerGenericRepositoryFactoryBean( RepositoryConfiguration<XmlRepositoryConfigurationSource> configuration, ParserContext parser) { RepositoryBeanDefinitionBuilder definitionBuilder = new RepositoryBeanDefinitionBuilder(configuration, extension); try { BeanDefinitionBuilder builder = definitionBuilder.build(parser.getRegistry(), parser.getReaderContext() .getResourceLoader()); extension.postProcess(builder, configuration.getConfigurationSource()); AbstractBeanDefinition beanDefinition = builder.getBeanDefinition(); beanDefinition.setSource(configuration.getSource()); RepositoryBeanNameGenerator generator = new RepositoryBeanNameGenerator(); generator.setBeanClassLoader(parser.getReaderContext().getBeanClassLoader()); String beanName = generator.generateBeanName(beanDefinition, parser.getRegistry()); if (LOG.isDebugEnabled()) { LOG.debug("Registering repository: " + beanName + " - Interface: " + configuration.getRepositoryInterface() + " - Factory: " + extension.getRepositoryFactoryClassName()); } BeanComponentDefinition definition = new BeanComponentDefinition(beanDefinition, beanName); parser.registerBeanComponent(definition); } catch (RuntimeException e) { handleError(e, configuration.getConfigurationSource().getElement(), parser.getReaderContext()); } }
private Optional<String> registerCustomImplementation(RepositoryConfiguration<?> configuration) { ImplementationLookupConfiguration lookup = configuration.toLookupConfiguration(metadataReaderFactory); String beanName = lookup.getImplementationBeanName(); // Already a bean configured? if (registry.containsBeanDefinition(beanName)) { return Optional.of(beanName); } Optional<AbstractBeanDefinition> beanDefinition = implementationDetector.detectCustomImplementation(lookup); return beanDefinition.map(it -> { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Registering custom repository implementation: " + lookup.getImplementationBeanName() + " " + it.getBeanClassName()); } it.setSource(configuration.getSource()); registry.registerBeanDefinition(beanName, it); return beanName; }); }
configurationsByRepositoryName.put(configuration.getRepositoryInterface(), configuration); LOG.trace(REPOSITORY_REGISTRATION, extension.getModuleName(), beanName, configuration.getRepositoryInterface(), configuration.getRepositoryFactoryBeanClassName()); beanDefinition.setAttribute(FACTORY_BEAN_OBJECT_TYPE, configuration.getRepositoryInterface());
private void potentiallyRegisterFragmentImplementation(RepositoryConfiguration<?> repositoryConfiguration, RepositoryFragmentConfiguration fragmentConfiguration) { String beanName = fragmentConfiguration.getImplementationBeanName(); // Already a bean configured? if (registry.containsBeanDefinition(beanName)) { return; } if (LOGGER.isDebugEnabled()) { LOGGER.debug(String.format("Registering repository fragment implementation: %s %s", beanName, fragmentConfiguration.getClassName())); } fragmentConfiguration.getBeanDefinition().ifPresent(bd -> { bd.setSource(repositoryConfiguration.getSource()); registry.registerBeanDefinition(beanName, bd); }); }
/** * Loads the repository interface contained in the given {@link RepositoryConfiguration} using the given * {@link ClassLoader}. * * @param configuration must not be {@literal null}. * @param classLoader can be {@literal null}. * @return the repository interface or {@literal null} if it can't be loaded. */ @Nullable private Class<?> loadRepositoryInterface(RepositoryConfiguration<?> configuration, @Nullable ClassLoader classLoader) { String repositoryInterface = configuration.getRepositoryInterface(); try { return org.springframework.util.ClassUtils.forName(repositoryInterface, classLoader); } catch (ClassNotFoundException | LinkageError e) { LOGGER.warn(String.format(CLASS_LOADING_ERROR, getModuleName(), repositoryInterface, classLoader), e); } return null; } }
Pattern pattern = Pattern.compile(".*\\." + configuration.getImplementationClassName()); for (String basePackage : configuration.getBasePackages()) { definitions.addAll(provider.findCandidateComponents(basePackage));
private void potentiallyRegisterRepositoryFragment(RepositoryConfiguration<?> configuration, RepositoryFragmentConfiguration fragmentConfiguration) { String beanName = fragmentConfiguration.getFragmentBeanName(); // Already a bean configured? if (registry.containsBeanDefinition(beanName)) { return; } if (LOGGER.isDebugEnabled()) { LOGGER.debug("Registering repository fragment: " + beanName); } BeanDefinitionBuilder fragmentBuilder = BeanDefinitionBuilder.rootBeanDefinition(RepositoryFragment.class, "implemented"); fragmentBuilder.addConstructorArgValue(fragmentConfiguration.getInterfaceName()); fragmentBuilder.addConstructorArgReference(fragmentConfiguration.getImplementationBeanName()); registry.registerBeanDefinition(beanName, ParsingUtils.getSourceBeanDefinition(fragmentBuilder, configuration.getSource())); } }
/** * Returns the final lookup configuration for the given {@link RepositoryConfiguration}. * * @param config must not be {@literal null}. * @return */ default ImplementationLookupConfiguration forRepositoryConfiguration(RepositoryConfiguration<?> config) { Assert.notNull(config, "RepositoryConfiguration must not be null!"); return new DefaultImplementationLookupConfiguration(this, config.getRepositoryInterface()) { /* * (non-Javadoc) * @see org.springframework.data.repository.config.DefaultImplementationLookupConfiguration#getBasePackages() */ @Override public Streamable<String> getBasePackages() { return config.getImplementationBasePackages(); } }; } }