Java AfterBurnerImpossibleException类代码示例

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
/**
 * Add/Inserts java instructions into a given method of a given class.
 * @param insertableMethod contains all information to perform byte code injection.
 * @throws CannotCompileException if the source contained in insertableMethod can't be compiled.
 * @throws AfterBurnerImpossibleException if something else goes wrong, wraps other exceptions.
 */
public void addOrInsertMethod(InsertableMethod insertableMethod) throws CannotCompileException, AfterBurnerImpossibleException {
    log.info("InsertableMethod : " + insertableMethod);
    // create or complete onViewCreated
    String targetMethodName = insertableMethod.getTargetMethodName();
    CtClass classToTransform = insertableMethod.getClassToInsertInto();
    CtMethod targetMethod = extractExistingMethod(classToTransform,
            targetMethodName);
    log.info("Method : " + targetMethod);
    if (targetMethod != null) {
        InsertableMethodInjectorEditor injectorEditor = new InsertableMethodInjectorEditor(
                classToTransform, insertableMethod);
        targetMethod.instrument(injectorEditor);
        if (!injectorEditor.isSuccessful) {
            throw new CannotCompileException("Transformation failed. Insertion method not found.: " + targetMethodName);
        }
    } else {
        classToTransform.addMethod(CtNewMethod.make(
                insertableMethod.getFullMethod(), classToTransform));
    }
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
/**
 * Inserts java instructions into all constructors a given class.
 * @param insertableConstructor contains all information about insertion.
 * @throws CannotCompileException if the source contained in insertableMethod can't be compiled.
 * @throws AfterBurnerImpossibleException if something else goes wrong, wraps other exceptions.
 */
public void insertConstructor(InsertableConstructor insertableConstructor) throws CannotCompileException, AfterBurnerImpossibleException,
NotFoundException {
    // create or complete onViewCreated
    List<CtConstructor> constructorList = extractExistingConstructors(insertableConstructor);
    log.info("constructor : " + constructorList.toString());
    if (!constructorList.isEmpty()) {
        for (CtConstructor constructor : constructorList) {
            constructor
            .insertBeforeBody(insertableConstructor
                    .getConstructorBody(constructor
                            .getParameterTypes()));
        }
    } else {
        throw new AfterBurnerImpossibleException("No suitable constructor was found in class " + insertableConstructor.getClassToInsertInto().getName() + ". Add a constructor that is accepted by the InsertableConstructor. Don't use non static inner classes.");
    }
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
private InsertableMethodInjectorEditor(CtClass classToTransform, InsertableMethod insertableMethod) throws AfterBurnerImpossibleException {
    this.classToTransform = classToTransform;
    String insertionAfterMethod = insertableMethod
            .getInsertionAfterMethod();
    String insertionBeforeMethod = insertableMethod
            .getInsertionBeforeMethod();
    if (insertionBeforeMethod == null && insertionAfterMethod == null) {
        throw new AfterBurnerImpossibleException(
                "Error in class "
                        + insertableMethod.getClass()
                        + " both insertionBeforeMethod && insertionAfterMethod are null.");
    } else if (insertionBeforeMethod != null) {
        insertionMethod = insertionBeforeMethod;
        insertAfter = false;
    } else {
        insertionMethod = insertionAfterMethod;
        insertAfter = true;
    }
    bodyToInsert = insertableMethod.getBody();
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
@Test(expected=NotFoundException.class)
public void testDoIt_calls_afterburner_with_after_override_when_no_method() throws CannotCompileException, AfterBurnerImpossibleException, NotFoundException {
    //GIVEN
    afterBurnerMock = EasyMock.createMock(AfterBurner.class);

    CtClass targetClass = ClassPool.getDefault().makeClass(
            "Target" + TestCounter.testCounter++);

    //WHEN
    builder = new InsertableMethodBuilder(afterBurnerMock, signatureExtractorMock);

    CtClass classToInsertInto = targetClass;
    String targetMethod = "foo";
    String body = "";

    builder
    .insertIntoClass(classToInsertInto.toClass())
    .afterOverrideMethod(targetMethod)
    .withBody(body)
    .doIt();

    //THEN
    fail();
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
@Test(expected=NotFoundException.class)
public void testDoIt_calls_afterburner_with_before_override_when_no_method() throws CannotCompileException, AfterBurnerImpossibleException, NotFoundException {
    //GIVEN
    afterBurnerMock = EasyMock.createMock(AfterBurner.class);

    CtClass targetClass = ClassPool.getDefault().makeClass(
            "Target" + TestCounter.testCounter++);

    //WHEN
    builder = new InsertableMethodBuilder(afterBurnerMock, signatureExtractorMock);

    CtClass classToInsertInto = targetClass;
    String targetMethod = "foo";
    String body = "";

    builder
    .insertIntoClass(classToInsertInto.toClass())
    .beforeOverrideMethod(targetMethod)
    .withBody(body)
    .doIt();

    //THEN
    fail();
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
@Test(expected = AfterBurnerImpossibleException.class)
public void testCheckAllFields_should_throw_exceptions_if_no_full_method_defined() throws AfterBurnerImpossibleException {
    //GIVEN
    CtClass classToInsertInto = CtClass.intType;
    String targetMethod = "";
    String insertionBeforeMethod = "";
    String body = "";
    builder
        .insertIntoClass(classToInsertInto)
        .inMethodIfExists(targetMethod)
        .beforeACallTo(insertionBeforeMethod)
        .withBody(body);

    //WHEN
    builder.checkFields();

    //THEN
    fail("Should have thrown exception");
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
@Test
public void testDoIt_calls_afterburner() throws CannotCompileException, AfterBurnerImpossibleException, NotFoundException {
    //GIVEN
    afterBurnerMock = EasyMock.createMock(AfterBurner.class);
    afterBurnerMock.insertConstructor((InsertableConstructor) EasyMock.anyObject());
    EasyMock.replay(afterBurnerMock);

    builder = new InsertableConstructorBuilder(afterBurnerMock);

    CtClass classToInsertInto = CtClass.intType;
    String body = "";

    //WHEN
    builder
        .insertIntoClass(classToInsertInto)
        .withBody(body)
        .doIt();

    //THEN
    EasyMock.verify(afterBurnerMock);
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
@Test
public void testCheckAllFields_should_succeed_with_all_fields_defined() throws AfterBurnerImpossibleException {
    //GIVEN
    CtClass classToInsertInto = CtClass.intType;
    String body = "";

    //WHEN
    InsertableConstructor constructor = builder
            .insertIntoClass(classToInsertInto)
            .withBody(body)
            .createInsertableConstructor();

    //THEN
    assertNotNull(constructor);
    assertEquals(classToInsertInto, constructor.getClassToInsertInto());
    assertEquals(body, constructor.getConstructorBody(null));
    assertTrue(constructor.acceptParameters(null));
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
private void injectStuffInClass(final CtClass clazz, List<ViewBinding> views,
    List<FragmentBinding> fragments)
    throws NotFoundException, ClassNotFoundException, CannotCompileException,
    AfterBurnerImpossibleException {

  // create or complete onViewCreated
  List<CtConstructor> constructorList =
      JavassistUtils.extractValidConstructors(clazz, injectViewFilter);
  if (constructorList != null && !constructorList.isEmpty()) {
    log.debug("constructor : " + constructorList.toString());
    for (CtConstructor constructor : constructorList) {
      int indexValidParam =
          findValidParamIndex(constructor.getParameterTypes(), injectViewFilter);
      //indexValidParam is > 0 at this stage
      constructor.insertBeforeBody(
          createInjectedBodyWithParam(constructor.getParameterTypes(), indexValidParam,
              views, fragments));
    }
  } else {
    log.warn(
        "No suitable constructor was found in class {}. Add a constructor with a single argument : Activity, Fragment or View. Don't use non static inner classes.",
        clazz.getName());
  }
  clazz.detach();
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
private void debugLifeCycleMethods(CtClass classToTransform, CtMethod[] methods)
    throws CannotCompileException, AfterBurnerImpossibleException, NotFoundException {
  for (CtMethod lifeCycleHook : methods) {
    String methodName = lifeCycleHook.getName();

    int accessFlags = lifeCycleHook.getMethodInfo().getAccessFlags();
    boolean isFinal = (accessFlags & AccessFlag.FINAL) == AccessFlag.FINAL;
    boolean canOverride = !isFinal && (AccessFlag.isPublic(accessFlags)
        || AccessFlag.isProtected(accessFlags)
        || AccessFlag.isPackage(accessFlags));
      
      log.info("Method name: " + methodName);

      if(!supportedMethods.contains(methodName))
          continue;


      if (canOverride && methodName.startsWith("on")) {
      log.info("Overriding " + methodName);
      try {
       String body = "com.github.stephanenicolas.lxglifecycle.ActivityListenerUtil.internal._" + methodName + "(this);";
          
        afterBurner.afterOverrideMethod(classToTransform, methodName, body);
        log.info("Override successful " + methodName);
      } catch (Exception e) {
        logMoreIfDebug("Override didn't work ", e);
      }
    } else {
      log.info(
          "Skipping " + methodName + ". Either it is final, private or doesn't start by 'on...'");
    }
  }
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
protected void checkFields() throws AfterBurnerImpossibleException {
    boolean hasInsertionMethod = insertionBeforeMethod != null
            || insertionAfterMethod != null;
    if (classToInsertInto == null || targetMethod == null
            || !hasInsertionMethod || body == null || fullMethod == null) {
        throw new AfterBurnerImpossibleException(
                "Builder was not used as intended. A field is null.");
    }
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
public InsertableMethod createInsertableMethod() throws AfterBurnerImpossibleException {
    checkFields();
    doInsertBodyInFullMethod();

    InsertableMethod method = new SimpleInsertableMethod(
            classToInsertInto, targetMethod, insertionBeforeMethod,
            insertionAfterMethod, body, fullMethod);
    return method;
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
private List<CtConstructor> extractExistingConstructors(final InsertableConstructor insertableConstructor) throws NotFoundException, AfterBurnerImpossibleException {
    List<CtConstructor> constructors = new ArrayList<CtConstructor>();
    CtConstructor[] declaredConstructors = insertableConstructor
            .getClassToInsertInto().getDeclaredConstructors();
    for (CtConstructor constructor : declaredConstructors) {
        CtClass[] paramClasses = constructor.getParameterTypes();
        if (insertableConstructor.acceptParameters(paramClasses)) {
            constructors.add(constructor);
        }
    }
    return constructors;
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
@Test
public void testDoIt_calls_afterburner() throws CannotCompileException, AfterBurnerImpossibleException {
    //GIVEN
    afterBurnerMock = EasyMock.createMock(AfterBurner.class);
    afterBurnerMock.addOrInsertMethod((InsertableMethod) EasyMock.anyObject());
    EasyMock.replay(afterBurnerMock);

    builder = new InsertableMethodBuilder(afterBurnerMock, null);

    CtClass classToInsertInto = CtClass.intType;
    String targetMethod = "";
    String insertionAfterMethod = "";
    String fullMethod = "";
    String body = "";

    //WHEN
    builder
        .insertIntoClass(classToInsertInto)
        .inMethodIfExists(targetMethod)
        .afterACallTo(insertionAfterMethod)
        .withBody(body)
        .elseCreateMethodIfNotExists(fullMethod)
        .doIt();

    //THEN
    EasyMock.verify(afterBurnerMock);
}
 

import com.github.stephanenicolas.afterburner.exception.AfterBurnerImpossibleException; //导入依赖的package包/类
@Test
public void testDoIt_calls_afterburner_with_after_override() throws CannotCompileException, AfterBurnerImpossibleException, NotFoundException {
    //GIVEN
    afterBurnerMock = EasyMock.createMock(AfterBurner.class);
    afterBurnerMock.addOrInsertMethod((InsertableMethod) EasyMock.anyObject());
    EasyMock.replay(afterBurnerMock);
    signatureExtractorMock = EasyMock.createMock(CtMethodJavaWriter.class);
    EasyMock.expect(signatureExtractorMock.invokeSuper((CtMethod) EasyMock.anyObject())).andReturn("super.foo()");
    EasyMock.expect(signatureExtractorMock.createJavaSignature((CtMethod) EasyMock.anyObject())).andReturn("public void foo()");
    EasyMock.replay(signatureExtractorMock);

    CtClass targetClassAncestor = ClassPool.getDefault().makeClass(
            "TargetAncestor" + TestCounter.testCounter++);
    targetClassAncestor.addMethod(CtNewMethod.make("public void foo() { }", targetClassAncestor));

    CtClass targetClass = ClassPool.getDefault().makeClass(
            "Target" + TestCounter.testCounter++);
    targetClass.setSuperclass(targetClassAncestor);
    targetClass.addMethod(CtNewMethod.make("public void foo() { super.foo(); }", targetClass));

    //WHEN
    builder = new InsertableMethodBuilder(afterBurnerMock, signatureExtractorMock);

    CtClass classToInsertInto = targetClass;
    String targetMethod = "foo";
    String body = "";
    builder
        .insertIntoClass(classToInsertInto)
        .afterOverrideMethod(targetMethod)
        .withBody(body)
        .doIt();

    //THEN
    EasyMock.verify(afterBurnerMock);
}