org.rapidpm.proxybuilder.type.dymamic.virtual.DynamicProxyGenerator Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of rapidpm-dynamic-cdi Show documentation
Dynamic Dependency Injection with different ways to manage the resolver-strategy
There is a newer version: 01.02.00-RPM
/*
 * Copyright [2014] [www.rapidpm.org / Sven Ruppert ([email protected])]
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

package org.rapidpm.proxybuilder.type.dymamic.virtual;


import org.rapidpm.proxybuilder.type.dymamic.virtual.VirtualDynamicProxyInvocationHandler.ServiceFactory;
import org.rapidpm.proxybuilder.type.dymamic.virtual.VirtualDynamicProxyInvocationHandler.ServiceStrategyFactory;
import org.rapidpm.proxybuilder.type.dymamic.virtual.creationstrategy.*;

import java.lang.reflect.Proxy;

import static org.rapidpm.proxybuilder.type.dymamic.virtual.CreationStrategy.NONE;

public class DynamicProxyGenerator {

  private Class subject; // Interface
  private CreationStrategy creationStrategy; // StrategyFactory Selector
  private ServiceFactory serviceFactory;

  private DynamicProxyGenerator() {
  }

  private DynamicProxyGenerator(final Builder builder) {
    subject = builder.subject;
    creationStrategy = builder.creationStrategy;
    serviceFactory = builder.serviceFactory;
  }

  public static  Builder newBuilder() {
    return new Builder<>();
  }

  public I make() {

    VirtualDynamicProxyInvocationHandler dynamicProxy = VirtualDynamicProxyInvocationHandler
        .newBuilder()
        .withServiceStrategyFactory(createStrategyFactory())
        .withServiceFactory(serviceFactory)
        .build();

    final Object newProxyInstance = Proxy
        .newProxyInstance(
            subject.getClassLoader(),
            new Class[]{subject},
            dynamicProxy);
    return subject.cast(newProxyInstance);
  }

  private ServiceStrategyFactory createStrategyFactory() {
    ServiceStrategyFactory serviceStrategyFactory;
    switch (creationStrategy) {
      case NONE:
        serviceStrategyFactory = new ServiceStrategyFactoryNotThreadSafe<>();
        break;
      case SOME_DUPLICATES:
        serviceStrategyFactory = new ServiceStrategyFactorySomeDuplicates<>(); //missing
        break;
      case SYNCHRONIZED:
        serviceStrategyFactory = new ServiceStrategyFactorySynchronized<>();
        break;
      case NO_DUPLICATES:
        serviceStrategyFactory = new ServiceStrategyFactoryNoDuplicates<>(); //missing
        break;
      case METHOD_SCOPED:
        serviceStrategyFactory = new ServiceStrategyFactoryMethodScoped<>();
        break;
      default:
        serviceStrategyFactory = new ServiceStrategyFactoryNotThreadSafe<>();
    }
    return serviceStrategyFactory;
  }

  public static final class Builder {
    private Class subject;
    private CreationStrategy creationStrategy = NONE;
    private ServiceFactory serviceFactory;

    private Builder() {
    }

    public Builder withSubject(final Class subject) {
      this.subject = subject;
      return this;
    }

    public Builder withCreationStrategy(final CreationStrategy creationStrategy) {
      this.creationStrategy = creationStrategy;
      return this;
    }

    public Builder withServiceFactory(final ServiceFactory serviceFactory) {
      this.serviceFactory = serviceFactory;
      return this;
    }

    public DynamicProxyGenerator build() {
      return new DynamicProxyGenerator<>(this);
    }
  }
}