Esempio n. 1
0
  /**
   * Registers all annotations specifying in {@link ComponentServiceContext}
   *
   * @param serviceHandler the {@link ServiceHandler}
   * @param annotation the {@link ComponentServiceContext} annotation.
   * @param getProvider if <b>true</b>, the suitable validator will be gotten from the given {@link
   *     Provider}, if <b>false</b>, the instance will be instantiated basing on <code>
   *     default constructor</code> specifying in corresponding object class.
   * @param provider the specified {@link Provider} container, if <code>getInject argument</code> is
   *     <b>true</b> and provider is null, one runtime-exception will be thrown.
   */
  @SuppressWarnings("unchecked")
  private static void registerAnnotationInCSC(
      ServiceHandler serviceHandler,
      ComponentServiceContext annotation,
      boolean getProvider,
      Provider provider) {

    if (getProvider == true && provider == null) {
      throw new JGentleRuntimeException("Provider must not be null while getProvider is true.");
    }
    Class<Annotation>[] annoList = (Class<Annotation>[]) annotation.annotations();
    Class<?>[] validators = annotation.validators();
    if (annoList.length != 0) {
      if (annoList.length < validators.length) {
        throw new JGentleRuntimeException(
            "invalid validators configuration in annotation: " + annotation);
      }
      for (int i = 0; i < annoList.length; i++) {
        if (i < validators.length) {
          AnnotationValidator<Annotation> validator;
          if (getProvider == false)
            validator =
                (AnnotationValidator<Annotation>) ReflectUtils.createInstance(validators[i]);
          else {
            validator = (AnnotationValidator<Annotation>) provider.getBean(validators[i]);
          }
          serviceHandler.registerAnnotation(annoList[i], validator);
        } else {
          serviceHandler.registerAnnotation(annoList[i]);
        }
      }
    }
  }
Esempio n. 2
0
  /**
   * Registers all system annotations.
   *
   * @param serviceHandler the given {@link ServiceHandler}
   */
  private static void registerAnnotations(ServiceHandler serviceHandler) {

    // Đăng kí thông tin các annotation của core JGentle vào danh sách
    // annotation registered
    serviceHandler.registerAnnotations(RegisterAnnotationInjecting.class);
    // Đăng kí thông tin tất cả các annotation của AOP System vào danh sách
    // annotation registered.
    serviceHandler.registerAnnotations(RegisterAnnotationAOP.class);
    // Đăng kí thông tin tất cả các annotation của JGentle Context vào danh
    // sách annotation registered.
    serviceHandler.registerAnnotations(RegisterAnnotationContext.class);
  }
Esempio n. 3
0
  /**
   * Builds the context.
   *
   * @param serviceHandler the aoh
   * @param serviceProvider the service provider
   * @param configurations the configurations
   * @return the context
   */
  protected static Context buildContext(
      ServiceHandler serviceHandler, boolean serviceProvider, Configurable... configurations) {

    List<Map<String, Object>> OLArray = new ArrayList<Map<String, Object>>();
    ArrayList<Configurable> cfgInstanceList = new ArrayList<Configurable>();
    for (Configurable config : configurations) {
      try {
        config.setDefinitionManager(serviceHandler.getDefinitionManager());
        // Thực thi các xử lý được chỉ định bởi ATC
        config.initAnnotationConfig();
        cfgInstanceList.add(config);
      } catch (IllegalArgumentException e) {
        e.printStackTrace();
      } catch (IllegalAccessException e) {
        e.printStackTrace();
      } catch (InvocationTargetException e) {
        e.printStackTrace();
      } catch (ClassNotFoundException e) {
        e.printStackTrace();
      }
      OLArray.add(config.getOptionsList());
    }
    Context result = null;
    if (!serviceProvider) {
      result = new ProviderCoreCreator(serviceHandler, OLArray);
    } else {
      result = new ServiceProviderImpl(serviceHandler, OLArray);
    }
    ((Provider) result).setConfigInstances(cfgInstanceList);
    return result;
  }
Esempio n. 4
0
  /**
   * Instantiates a {@link ServiceProvider}.
   *
   * @param configClasses a specified configurable class or a set of specified configurable classes
   * @param argsType the argument types of specified constructor of configurable class
   * @param args the argument objects need to be passed to constructor of configurable class.
   * @return the service provider
   */
  @SuppressWarnings("unchecked")
  public static ServiceProvider buildServiceProvider(
      Class<?>[] argsType, Object[] args, Class<? extends Configurable>... configClasses) {

    /*
     * Khởi tạo services context
     */
    ServiceProvider result = (ServiceProvider) buildContext(true, argsType, args, configClasses);
    /*
     * Thực thi các xử lý trước khi khởi tạo CSC
     */
    List<Configurable> configInstances = result.getConfigInstances();
    for (BeforeInitContext obj : JGentle.beforeInitContextList) {
      obj.beforeInitContext(
          result, configInstances.toArray(new Configurable[configInstances.size()]));
    }
    // Thực thi init trên csc
    // Thực thi init method trên mỗi CSC của services context vừa khởi tạo.
    Collection<ComponentServiceContextType<Configurable>> csclist = result.getCSCList().values();
    for (ComponentServiceContextType<Configurable> csc : csclist) {
      invokeCSCInit(result, csc, configInstances);
    }
    /*
     * Thực thi các xử lý khởi tạo CSC
     */
    List<Class<? extends ComponentServiceContextType<?>>> cscClassList = null;
    cscClassList = new ArrayList<Class<? extends ComponentServiceContextType<?>>>();
    for (Configurable instance : configInstances) {
      cscClassList.addAll(instance.getCscClassList());
    }
    // Duyệt qua từng danh sách Object Class của danh sách các CSC class.
    for (Class<? extends ComponentServiceContextType<?>> clazz : cscClassList) {
      Definition defCSC = result.getDefinitionManager().getDefinition(clazz);
      // Khởi tạo CSC và thực thi init
      ComponentServiceContextType<Configurable> comp = null;
      comp = (ComponentServiceContextType<Configurable>) result.getBean(clazz);
      invokeCSCInit(result, comp, configInstances);
      /*
       * Xử lý thông tin chỉ định trong @ComponentServiceContext nếu có
       */
      ComponentServiceContext anno = null;
      if (defCSC.isAnnotationPresent(ComponentServiceContext.class)) {
        anno = defCSC.getAnnotation(ComponentServiceContext.class);
      }
      if (anno != null) {
        // Thực thi đăng kí annotation nếu có.
        if (!anno.beforeConfigure()) {
          JGentle.registerAnnotationInCSC(result.getServiceHandler(), anno, true, result);
        }
        // Khởi tạo và đăng kí service Class
        Class<? extends ServiceClass> scClazz = anno.serviceClass();
        if (!result.getDefinitionManager().containsDefinition(scClazz)) {
          result.getDefinitionManager().loadDefinition(scClazz);
        }
        if (result
            .getDefinitionManager()
            .getDefinition(scClazz)
            .isAnnotationPresent(BeanServices.class)) {
          throw new JGentleRuntimeException(
              "Service Class "
                  + scClazz.getName()
                  + " must be annotated with @BeanServices annotation !");
        }
        String domain =
            result
                .getDefinitionManager()
                .getDefinition(scClazz)
                .getAnnotation(BeanServices.class)
                .domain();
        ServiceHandler aoh = result.getServiceHandler();
        if (!aoh.containsDomain(domain)) {
          try {
            aoh.newDomain(domain);
          } catch (JGentleException e) {
            e.printStackTrace();
          }
        }
        aoh.addService(result, scClazz, domain);
      }
      // Thực thi add CSC vào ServiceProvider hiện hành.
      result.addCSContext(
          anno == null || (anno != null && anno.value().equals(NullClass.class))
              ? clazz
              : anno.value(),
          comp);
    }
    /*
     * Xóa bỏ toàn bộ các beforeInitContext object
     */
    beforeInitContextList.clear();
    return result;
  }