All Downloads are FREE. Search and download functionalities are using the official Maven repository.

net.bytebuddy.implementation.auxiliary.MethodCallProxy Maven / Gradle / Ivy

Go to download

Easy Redis Java client and Real-Time Data Platform. Valkey compatible. Sync/Async/RxJava3/Reactive API. Client side caching. Over 50 Redis based Java objects and services: JCache API, Apache Tomcat, Hibernate, Spring, Set, Multimap, SortedSet, Map, List, Queue, Deque, Semaphore, Lock, AtomicLong, Map Reduce, Bloom filter, Scheduler, RPC

There is a newer version: 3.40.2
Show newest version
/*
 * Copyright 2014 - Present Rafael Winterhalter
 *
 * 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 net.bytebuddy.implementation.auxiliary;

import net.bytebuddy.ByteBuddy;
import net.bytebuddy.ClassFileVersion;
import net.bytebuddy.build.HashCodeAndEqualsPlugin;
import net.bytebuddy.description.annotation.AnnotationDescription;
import net.bytebuddy.description.annotation.AnnotationValue;
import net.bytebuddy.description.field.FieldDescription;
import net.bytebuddy.description.field.FieldList;
import net.bytebuddy.description.method.MethodDescription;
import net.bytebuddy.description.method.ParameterDescription;
import net.bytebuddy.description.modifier.Visibility;
import net.bytebuddy.description.type.TypeDefinition;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.description.type.TypeVariableToken;
import net.bytebuddy.dynamic.DynamicType;
import net.bytebuddy.dynamic.scaffold.InstrumentedType;
import net.bytebuddy.dynamic.scaffold.MethodGraph;
import net.bytebuddy.dynamic.scaffold.TypeValidation;
import net.bytebuddy.dynamic.scaffold.subclass.ConstructorStrategy;
import net.bytebuddy.implementation.Implementation;
import net.bytebuddy.implementation.MethodAccessorFactory;
import net.bytebuddy.implementation.bytecode.ByteCodeAppender;
import net.bytebuddy.implementation.bytecode.Duplication;
import net.bytebuddy.implementation.bytecode.StackManipulation;
import net.bytebuddy.implementation.bytecode.TypeCreation;
import net.bytebuddy.implementation.bytecode.assign.Assigner;
import net.bytebuddy.implementation.bytecode.member.FieldAccess;
import net.bytebuddy.implementation.bytecode.member.MethodInvocation;
import net.bytebuddy.implementation.bytecode.member.MethodReturn;
import net.bytebuddy.implementation.bytecode.member.MethodVariableAccess;
import net.bytebuddy.utility.RandomString;
import net.bytebuddy.jar.asm.MethodVisitor;
import net.bytebuddy.jar.asm.Opcodes;

import java.io.Serializable;
import java.util.*;
import java.util.concurrent.Callable;

import static net.bytebuddy.matcher.ElementMatchers.isConstructor;

/**
 * A method call proxy represents a class that is compiled against a particular method which can then be called whenever
 * either its {@link java.util.concurrent.Callable#call()} or {@link Runnable#run()} method is called where the method
 * call proxy implements both interfaces.
 * 

 

* In order to do so, the method call proxy instances are constructed by providing all the necessary information for * calling a particular method: *
    *
  1. If the target method is not {@code static}, the first argument should be an instance on which the method is called.
  2. *
  3. All arguments for the called method in the order in which they are required.
  4. *
*/ @HashCodeAndEqualsPlugin.Enhance public class MethodCallProxy implements AuxiliaryType { /** * The prefix of the fields holding the original method invocation's arguments. */ private static final String FIELD_NAME_PREFIX = "argument"; /** * The special method invocation to invoke from the auxiliary type. */ private final Implementation.SpecialMethodInvocation specialMethodInvocation; /** * Determines if the generated proxy should be serializableProxy. */ private final boolean serializableProxy; /** * The assigner to use for invoking a bridge method target where the parameter and return types need to be * assigned. */ private final Assigner assigner; /** * Creates a new method call proxy for a given method and uses a default assigner for assigning the method's return * value to either the {@link java.util.concurrent.Callable#call()} or {@link Runnable#run()} method returns. * * @param specialMethodInvocation The special method invocation which should be invoked by this method call proxy. * @param serializableProxy Determines if the generated proxy should be serializableProxy. */ public MethodCallProxy(Implementation.SpecialMethodInvocation specialMethodInvocation, boolean serializableProxy) { this(specialMethodInvocation, serializableProxy, Assigner.DEFAULT); } /** * Creates a new method call proxy for a given method. * * @param specialMethodInvocation The special method invocation which should be invoked by this method call proxy. * @param serializableProxy Determines if the generated proxy should be serializableProxy. * @param assigner An assigner for assigning the target method's return value to either the * {@link java.util.concurrent.Callable#call()} or {@link Runnable#run()}} methods' * return values. */ public MethodCallProxy(Implementation.SpecialMethodInvocation specialMethodInvocation, boolean serializableProxy, Assigner assigner) { this.specialMethodInvocation = specialMethodInvocation; this.serializableProxy = serializableProxy; this.assigner = assigner; } /** * Creates a linked hash map of field names to their types where each field represents a parameter of the method. * * @param methodDescription The method to extract into fields. * @return A map of fields in the order they need to be loaded onto the operand stack for invoking the original * method, including a reference to the instance of the instrumented type that is invoked if applicable. */ private static LinkedHashMap extractFields(MethodDescription methodDescription) { LinkedHashMap typeDescriptions = new LinkedHashMap(); int currentIndex = 0; if (!methodDescription.isStatic()) { typeDescriptions.put(fieldName(currentIndex++), methodDescription.getDeclaringType().asErasure()); } for (ParameterDescription parameterDescription : methodDescription.getParameters()) { typeDescriptions.put(fieldName(currentIndex++), parameterDescription.getType().asErasure()); } return typeDescriptions; } /** * Creates a field name for a method parameter of a given index. * * @param index The index for which the field name is to be created. * @return The name for the given parameter. */ private static String fieldName(int index) { return FIELD_NAME_PREFIX + index; } /** * {@inheritDoc} */ public String getSuffix() { return RandomString.hashOf(specialMethodInvocation.getMethodDescription().hashCode()) + (serializableProxy ? "S" : "0"); } /** * {@inheritDoc} */ public DynamicType make(String auxiliaryTypeName, ClassFileVersion classFileVersion, MethodAccessorFactory methodAccessorFactory) { MethodDescription accessorMethod = methodAccessorFactory.registerAccessorFor(specialMethodInvocation, MethodAccessorFactory.AccessType.DEFAULT); LinkedHashMap parameterFields = extractFields(accessorMethod); DynamicType.Builder builder = new ByteBuddy(classFileVersion) .with(TypeValidation.DISABLED) .with(PrecomputedMethodGraph.INSTANCE) .subclass(Object.class, ConstructorStrategy.Default.NO_CONSTRUCTORS) .name(auxiliaryTypeName) .modifiers(DEFAULT_TYPE_MODIFIER) .implement(Runnable.class, Callable.class).intercept(new MethodCall(accessorMethod, assigner)) .implement(serializableProxy ? new Class[]{Serializable.class} : new Class[0]) .defineConstructor().withParameters(parameterFields.values()) .intercept(ConstructorCall.INSTANCE); for (Map.Entry field : parameterFields.entrySet()) { builder = builder.defineField(field.getKey(), field.getValue(), Visibility.PRIVATE); } return builder.make(); } /** * A precomputed method graph that only displays the methods that are relevant for creating a method call proxy. */ protected enum PrecomputedMethodGraph implements MethodGraph.Compiler { /** * The singleton instance. */ INSTANCE; /** * The precomputed method graph. */ private final transient MethodGraph.Linked methodGraph; /** * Creates the precomputed method graph. */ PrecomputedMethodGraph() { LinkedHashMap nodes = new LinkedHashMap(); MethodDescription callMethod = new MethodDescription.Latent(TypeDescription.ForLoadedType.of(Callable.class), "call", Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, Collections.emptyList(), TypeDescription.Generic.OfNonGenericType.ForLoadedType.of(Object.class), Collections.emptyList(), Collections.singletonList(TypeDescription.Generic.OfNonGenericType.ForLoadedType.of(Exception.class)), Collections.emptyList(), AnnotationValue.UNDEFINED, TypeDescription.Generic.UNDEFINED); nodes.put(callMethod.asSignatureToken(), new MethodGraph.Node.Simple(callMethod)); MethodDescription runMethod = new MethodDescription.Latent(TypeDescription.ForLoadedType.of(Runnable.class), "run", Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, Collections.emptyList(), TypeDescription.Generic.OfNonGenericType.ForLoadedType.of(void.class), Collections.emptyList(), Collections.emptyList(), Collections.emptyList(), AnnotationValue.UNDEFINED, TypeDescription.Generic.UNDEFINED); nodes.put(runMethod.asSignatureToken(), new MethodGraph.Node.Simple(runMethod)); MethodGraph methodGraph = new MethodGraph.Simple(nodes); this.methodGraph = new MethodGraph.Linked.Delegation(methodGraph, methodGraph, Collections.emptyMap()); } /** * {@inheritDoc} */ public MethodGraph.Linked compile(TypeDefinition typeDefinition) { return methodGraph; } /** * {@inheritDoc} */ @Deprecated public MethodGraph.Linked compile(TypeDescription typeDescription) { return methodGraph; } /** * {@inheritDoc} */ public MethodGraph.Linked compile(TypeDefinition typeDefinition, TypeDescription viewPoint) { return methodGraph; } /** * {@inheritDoc} */ @Deprecated public MethodGraph.Linked compile(TypeDescription typeDefinition, TypeDescription viewPoint) { return methodGraph; } } /** * An implementation for a constructor of a {@link net.bytebuddy.implementation.auxiliary.MethodCallProxy}. */ protected enum ConstructorCall implements Implementation { /** * The singleton instance. */ INSTANCE; /** * A reference of the {@link Object} type default constructor. */ private final MethodDescription objectTypeDefaultConstructor; /** * Creates the constructor call singleton. */ ConstructorCall() { objectTypeDefaultConstructor = TypeDescription.ForLoadedType.of(Object.class).getDeclaredMethods().filter(isConstructor()).getOnly(); } /** * {@inheritDoc} */ public InstrumentedType prepare(InstrumentedType instrumentedType) { return instrumentedType; } /** * {@inheritDoc} */ public ByteCodeAppender appender(Target implementationTarget) { return new Appender(implementationTarget.getInstrumentedType()); } /** * The appender for implementing the {@link net.bytebuddy.implementation.auxiliary.MethodCallProxy.ConstructorCall}. */ @HashCodeAndEqualsPlugin.Enhance protected static class Appender implements ByteCodeAppender { /** * The instrumented type being created. */ private final TypeDescription instrumentedType; /** * Creates a new appender. * * @param instrumentedType The instrumented type that is being created. */ private Appender(TypeDescription instrumentedType) { this.instrumentedType = instrumentedType; } /** * {@inheritDoc} */ public Size apply(MethodVisitor methodVisitor, Context implementationContext, MethodDescription instrumentedMethod) { FieldList fieldList = instrumentedType.getDeclaredFields(); StackManipulation[] fieldLoading = new StackManipulation[fieldList.size()]; int index = 0; for (FieldDescription fieldDescription : fieldList) { fieldLoading[index] = new StackManipulation.Compound( MethodVariableAccess.loadThis(), MethodVariableAccess.load(instrumentedMethod.getParameters().get(index)), FieldAccess.forField(fieldDescription).write() ); index++; } StackManipulation.Size stackSize = new StackManipulation.Compound( MethodVariableAccess.loadThis(), MethodInvocation.invoke(ConstructorCall.INSTANCE.objectTypeDefaultConstructor), new StackManipulation.Compound(fieldLoading), MethodReturn.VOID ).apply(methodVisitor, implementationContext); return new Size(stackSize.getMaximalSize(), instrumentedMethod.getStackSize()); } } } /** * An implementation for a method of a {@link net.bytebuddy.implementation.auxiliary.MethodCallProxy}. */ @HashCodeAndEqualsPlugin.Enhance protected static class MethodCall implements Implementation { /** * The method that is accessed by the implemented method. */ private final MethodDescription accessorMethod; /** * The assigner to be used for invoking the accessor method. */ private final Assigner assigner; /** * Creates a new method call implementation. * * @param accessorMethod The method that is accessed by the implemented method. * @param assigner The assigner to be used for invoking the accessor method. */ protected MethodCall(MethodDescription accessorMethod, Assigner assigner) { this.accessorMethod = accessorMethod; this.assigner = assigner; } /** * {@inheritDoc} */ public InstrumentedType prepare(InstrumentedType instrumentedType) { return instrumentedType; } /** * {@inheritDoc} */ public ByteCodeAppender appender(Target implementationTarget) { return new Appender(implementationTarget.getInstrumentedType()); } /** * The appender for implementing the {@link net.bytebuddy.implementation.auxiliary.MethodCallProxy.MethodCall}. */ @HashCodeAndEqualsPlugin.Enhance(includeSyntheticFields = true) protected class Appender implements ByteCodeAppender { /** * The instrumented type that is implemented. */ private final TypeDescription instrumentedType; /** * Creates a new appender. * * @param instrumentedType The instrumented type to be implemented. */ private Appender(TypeDescription instrumentedType) { this.instrumentedType = instrumentedType; } /** * {@inheritDoc} */ public Size apply(MethodVisitor methodVisitor, Context implementationContext, MethodDescription instrumentedMethod) { FieldList fieldList = instrumentedType.getDeclaredFields(); List fieldLoadings = new ArrayList(fieldList.size()); for (FieldDescription fieldDescription : fieldList) { fieldLoadings.add(new StackManipulation.Compound(MethodVariableAccess.loadThis(), FieldAccess.forField(fieldDescription).read())); } StackManipulation.Size stackSize = new StackManipulation.Compound( new StackManipulation.Compound(fieldLoadings), MethodInvocation.invoke(accessorMethod), assigner.assign(accessorMethod.getReturnType(), instrumentedMethod.getReturnType(), Assigner.Typing.DYNAMIC), MethodReturn.of(instrumentedMethod.getReturnType()) ).apply(methodVisitor, implementationContext); return new Size(stackSize.getMaximalSize(), instrumentedMethod.getStackSize()); } } } /** * A stack manipulation that creates a {@link net.bytebuddy.implementation.auxiliary.MethodCallProxy} * for a given method an pushes such an object onto the call stack. For this purpose, all arguments of the proxied method * are loaded onto the stack what is only possible if this instance is used from a method with an identical signature such * as the target method itself. */ @HashCodeAndEqualsPlugin.Enhance public static class AssignableSignatureCall extends StackManipulation.AbstractBase { /** * The special method invocation to be proxied by this stack manipulation. */ private final Implementation.SpecialMethodInvocation specialMethodInvocation; /** * Determines if the generated proxy should be serializableProxy. */ private final boolean serializable; /** * Creates an operand stack assignment that creates a * {@link net.bytebuddy.implementation.auxiliary.MethodCallProxy} for the * {@code targetMethod} and pushes this proxy object onto the stack. * * @param specialMethodInvocation The special method invocation which should be invoked by the created method * call proxy. * @param serializable Determines if the generated proxy should be serializableProxy. */ public AssignableSignatureCall(Implementation.SpecialMethodInvocation specialMethodInvocation, boolean serializable) { this.specialMethodInvocation = specialMethodInvocation; this.serializable = serializable; } /** * {@inheritDoc} */ public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext) { TypeDescription auxiliaryType = implementationContext .register(new MethodCallProxy(specialMethodInvocation, serializable)); return new Compound( TypeCreation.of(auxiliaryType), Duplication.SINGLE, MethodVariableAccess.allArgumentsOf(specialMethodInvocation.getMethodDescription()).prependThisReference(), MethodInvocation.invoke(auxiliaryType.getDeclaredMethods().filter(isConstructor()).getOnly()) ).apply(methodVisitor, implementationContext); } } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy