jodd.proxetta.asm.ProxettaMethodBuilder Maven / Gradle / Ivy
// Copyright (c) 2003-2014, Jodd Team (jodd.org). All Rights Reserved.
package jodd.proxetta.asm;
import jodd.asm.AsmUtil;
import jodd.asm5.MethodVisitor;
import jodd.asm5.AnnotationVisitor;
import static jodd.asm5.Opcodes.ACC_ABSTRACT;
import static jodd.asm5.Opcodes.ACC_NATIVE;
import static jodd.asm5.Opcodes.GETFIELD;
import static jodd.asm5.Opcodes.INVOKESPECIAL;
import static jodd.asm5.Opcodes.ARETURN;
import static jodd.asm5.Opcodes.POP;
import static jodd.asm5.Opcodes.POP2;
import static jodd.asm5.Opcodes.INVOKEVIRTUAL;
import static jodd.asm5.Opcodes.INVOKEINTERFACE;
import static jodd.asm5.Opcodes.INVOKESTATIC;
import static jodd.asm5.Opcodes.ALOAD;
import jodd.proxetta.ProxettaException;
import jodd.proxetta.ProxyTarget;
import static jodd.proxetta.asm.ProxettaAsmUtil.*;
import static jodd.proxetta.JoddProxetta.executeMethodName;
import jodd.asm.AnnotationVisitorAdapter;
import jodd.asm.EmptyClassVisitor;
import jodd.asm.EmptyMethodVisitor;
import jodd.proxetta.ProxyTargetReplacement;
import java.util.List;
@SuppressWarnings({"AnonymousClassVariableHidesContainingMethodVariable"})
public class ProxettaMethodBuilder extends EmptyMethodVisitor {
public static final String TARGET_CLASS_NAME = ProxyTarget.class.getSimpleName(); // extract ProxyTarget name for recognition
protected final MethodSignatureVisitor msign;
protected final WorkData wd;
protected final List aspectList;
public ProxettaMethodBuilder(MethodSignatureVisitor msign, WorkData wd, List aspectList) {
this.msign = msign;
this.wd = wd;
this.aspectList = aspectList;
createFirstChainDelegate_Start();
}
// ---------------------------------------------------------------- visits
/**
* Copies target method annotations.
*/
@Override
public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
AnnotationVisitor destAnn = methodVisitor.visitAnnotation(desc, visible); // [A4]
return new AnnotationVisitorAdapter(destAnn);
}
@Override
public AnnotationVisitor visitAnnotationDefault() {
AnnotationVisitor destAnn = methodVisitor.visitAnnotationDefault();
return new AnnotationVisitorAdapter(destAnn);
}
@Override
public AnnotationVisitor visitParameterAnnotation(int parameter, String desc, boolean visible) {
AnnotationVisitor destAnn = methodVisitor.visitParameterAnnotation(parameter, desc, visible);
return new AnnotationVisitorAdapter(destAnn);
}
/**
* Finally, builds proxy methods if applied to current method.
*/
@Override
public void visitEnd() {
createFirstChainDelegate_Continue(tmd);
for (int p = 0; p < tmd.proxyData.length; p++) {
tmd.selectCurrentProxy(p);
createProxyMethod(tmd);
}
}
// ---------------------------------------------------------------- creating
protected TargetMethodData tmd;
protected MethodVisitor methodVisitor;
/**
* Starts creation of first chain delegate.
*/
protected void createFirstChainDelegate_Start() {
// check invalid access flags
int access = msign.getAccessFlags();
if ((access & AsmUtil.ACC_FINAL) != 0) { // detect final
throw new ProxettaException("Unable to create proxy for final method: " + msign +". Remove final modifier or change the pointcut definition.");
}
// create proxy methods
tmd = new TargetMethodData(msign, aspectList);
access &= ~ACC_NATIVE;
access &= ~ACC_ABSTRACT;
methodVisitor = wd.dest.visitMethod(
access, tmd.msign.getMethodName(), tmd.msign.getDescription(), tmd.msign.getRawSignature(), null);
}
/**
* Continues the creation of the very first method in calling chain that simply delegates invocation to the first proxy method.
* This method mirrors the target method.
*/
protected void createFirstChainDelegate_Continue(TargetMethodData tmd) {
methodVisitor.visitCode();
if (tmd.msign.isStatic) {
loadStaticMethodArguments(methodVisitor, tmd.msign);
methodVisitor.visitMethodInsn(INVOKESTATIC, wd.thisReference, tmd.firstMethodName(), tmd.msign.getDescription());
} else {
loadSpecialMethodArguments(methodVisitor, tmd.msign);
methodVisitor.visitMethodInsn(INVOKESPECIAL, wd.thisReference, tmd.firstMethodName(), tmd.msign.getDescription());
}
visitReturn(methodVisitor, tmd.msign, false);
methodVisitor.visitMaxs(0, 0);
methodVisitor.visitEnd();
}
/**
* Creates proxy methods over target method, For each matched proxy, new proxy method is created
* by taking advice bytecode and replaces usages of {@link jodd.proxetta.ProxyTarget}.
*
* Invocation chain example: {@code name -> name$p0 -> name$p1 -> name$p4 -> super}.
*/
public void createProxyMethod(final TargetMethodData td) {
final ProxyAspectData aspectData = td.getProxyData();
int access = td.msign.getAccessFlags();
access &= ~ACC_NATIVE;
access &= ~ACC_ABSTRACT;
access = ProxettaAsmUtil.makePrivateFinalAccess(access);
final MethodVisitor mv = wd.dest.visitMethod(access, td.methodName(), td.msign.getDescription(), null, null);
mv.visitCode();
//*** VISIT ADVICE - called for each aspect and each method
aspectData.getAdviceClassReader().accept(new EmptyClassVisitor() {
@Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
if (name.equals(executeMethodName) == false) {
return null;
}
return new HistoryMethodAdapter(mv) {
@Override
public void visitFieldInsn(int opcode, String owner, String name, String desc) {
if (owner.equals(aspectData.adviceReference)) {
owner = wd.thisReference; // [F5]
name = adviceFieldName(name, aspectData.aspectIndex);
}
super.visitFieldInsn(opcode, owner, name, desc);
}
@Override
public void visitVarInsn(int opcode, int var) {
var += (var == 0 ? 0 : td.msign.getAllArgumentsSize());
super.visitVarInsn(opcode, var); // [F1]
}
@Override
public void visitIincInsn(int var, int increment) {
var += (var == 0 ? 0 : td.msign.getAllArgumentsSize());
super.visitIincInsn(var, increment); // [F1]
}
@Override
public void visitInsn(int opcode) {
if (opcode == ARETURN) {
visitReturn(mv, td.msign, true);
return;
}
if (traceNext == true) {
if ((opcode == POP) || (opcode == POP2)) { // [F3] - invoke invoked without assignment
return;
}
}
super.visitInsn(opcode);
}
@SuppressWarnings({"ParameterNameDiffersFromOverriddenParameter"})
@Override
public void visitMethodInsn(int opcode, String string, String mname, String mdesc) {
if ((opcode == INVOKEVIRTUAL) || (opcode == INVOKEINTERFACE) || (opcode == INVOKESPECIAL)) {
if (string.equals(aspectData.adviceReference)) {
string = wd.thisReference;
mname = adviceMethodName(mname, aspectData.aspectIndex);
}
} else
if (opcode == INVOKESTATIC) {
if (string.equals(aspectData.adviceReference)) {
string = wd.thisReference;
mname = adviceMethodName(mname, aspectData.aspectIndex);
} else
if (string.endsWith('/' + TARGET_CLASS_NAME) == true) {
if (isInvokeMethod(mname, mdesc)) { // [R7]
if (td.isLastMethodInChain()) { // last proxy method just calls super target method
if (wd.isWrapper() == false) {
// PROXY
loadSpecialMethodArguments(mv, td.msign);
mv.visitMethodInsn(INVOKESPECIAL, wd.superReference, td.msign.getMethodName(), td.msign.getDescription());
} else {
// WRAPPER
mv.visitVarInsn(ALOAD, 0);
mv.visitFieldInsn(GETFIELD, wd.thisReference, wd.wrapperRef, wd.wrapperType);
loadVirtualMethodArguments(mv, td.msign);
if (wd.wrapInterface) {
mv.visitMethodInsn(INVOKEINTERFACE, wd.wrapperType.substring(1, wd.wrapperType.length() - 1), td.msign.getMethodName(), td.msign.getDescription());
} else {
mv.visitMethodInsn(INVOKEVIRTUAL, wd.wrapperType.substring(1, wd.wrapperType.length() - 1), td.msign.getMethodName(), td.msign.getDescription());
}
}
prepareReturnValue(mv, td.msign, aspectData.maxLocalVarOffset); // [F4]
traceNext = true;
} else { // calls next proxy method
loadSpecialMethodArguments(mv, td.msign);
mv.visitMethodInsn(INVOKESPECIAL, wd.thisReference, td.nextMethodName(), td.msign.getDescription());
visitReturn(mv, td.msign, false);
}
return;
}
if (isArgumentsCountMethod(mname, mdesc)) { // [R2]
ProxyTargetReplacement.argumentsCount(mv, td.msign);
return;
}
if (isArgumentTypeMethod(mname, mdesc)) { // [R3]
int argIndex = this.getArgumentIndex();
ProxyTargetReplacement.argumentType(mv, td.msign, argIndex);
return;
}
if (isArgumentMethod(mname, mdesc)) { // [R4]
int argIndex = this.getArgumentIndex();
ProxyTargetReplacement.argument(mv, td.msign, argIndex);
return;
}
if (isSetArgumentMethod(mname, mdesc)) { // [R5]
int argIndex = this.getArgumentIndex();
checkArgumentIndex(td.msign, argIndex);
mv.visitInsn(POP);
storeMethodArgumentFromObject(mv, td.msign, argIndex);
return;
}
if (isCreateArgumentsArrayMethod(mname, mdesc)) { // [R6]
ProxyTargetReplacement.createArgumentsArray(mv, td.msign);
return;
}
if (isCreateArgumentsClassArrayMethod(mname, mdesc)) { // [R11]
ProxyTargetReplacement.createArgumentsClassArray(mv, td.msign);
return;
}
if (isTargetMethod(mname, mdesc)) { // [R9.1]
mv.visitVarInsn(ALOAD, 0);
return;
}
if (isTargetClassMethod(mname, mdesc)) { // [R9]
ProxyTargetReplacement.targetClass(mv, td.msign);
//ProxyTargetReplacement.targetClass(mv, wd.superReference);
return;
}
if (isTargetMethodNameMethod(mname, mdesc)) { // [R10]
ProxyTargetReplacement.targetMethodName(mv, td.msign);
return;
}
if (isTargetMethodSignatureMethod(mname, mdesc)) {
ProxyTargetReplacement.targetMethodSignature(mv, td.msign);
return;
}
if (isTargetMethodDescriptionMethod(mname, mdesc)) {
ProxyTargetReplacement.targetMethodDescription(mv, td.msign);
return;
}
if (isInfoMethod(mname, mdesc)) {
ProxyTargetReplacement.info(mv, td.msign);
return;
}
if (isReturnTypeMethod(mname, mdesc)) { // [R11]
ProxyTargetReplacement.returnType(mv, td.msign);
return;
}
if (isReturnValueMethod(mname, mdesc)) {
castToReturnType(mv, td.msign);
return;
}
if (isTargetMethodAnnotationMethod(mname, mdesc)) {
String[] args = getLastTwoStringArguments();
// pop current two args
mv.visitInsn(POP);
mv.visitInsn(POP);
ProxyTargetReplacement.targetMethodAnnotation(mv, td.msign, args);
return;
}
if (isTargetClassAnnotationMethod(mname, mdesc)) {
String[] args = getLastTwoStringArguments();
// pop current two args
mv.visitInsn(POP);
mv.visitInsn(POP);
ProxyTargetReplacement.targetClassAnnotation(mv, td.msign.getClassInfo(), args);
return;
}
}
}
super.visitMethodInsn(opcode, string, mname, mdesc);
}
};
}
}, 0);
}
}