使用 ASM 实现 Java 语言的“多重继承”

publicAddImplementClassAdapter(ClassWriterwriter,
StringenhancedClassName,Class<?>targetClass,
Class<?>...implementClasses){
super(writer);
this.classWriter=writer;
this.implementClasses=implementClasses;
this.originalClassName=targetClass.getName();
this.enhancedClassName=enhancedClassName;
}

//通过visit方法完成增强类的声明部分
publicvoidvisit(intversion,intaccess,Stringname,
Stringsignature,StringsuperName,String[]interfaces){
cv.visit(version,Opcodes.ACC_PUBLIC,
//将Java代码中类的名称替换为虚拟机中使用的形式
enhancedClassName.replace('.','/'),
signature,name,interfaces);
}

publicMethodVisitorvisitMethod(intaccess,Stringname,
Stringdesc,Stringsignature,String[]exceptions){
if(INTERNAL_INIT_METHOD_NAME.equals(name)){
//通过ModifyInitMethodAdapter修改构造方法
MethodVisitormv=classWriter.visitMethod(access,
INTERNAL_INIT_METHOD_NAME,desc,signature,exceptions);
returnnewModifyInitMethodAdapter(mv,originalClassName);
}
returnnull;
}

publicvoidvisitEnd(){
for(Class<?>clazz:implementClasses){
try{
//逐个将实现类的内容添加到增强类中。
ClassReaderreader=newClassReader(clazz.getName());
ClassAdapteradapter=
newImplementClassAdapter(classWriter);
reader.accept(adapter,0);
}catch(IOExceptione){
e.printStackTrace();
}
}
cv.visitEnd();
}

publicvoidvisit(intversion,intaccess,Stringname,
Stringsignature,StringsuperName,String[]interfaces){
//空实现，将该部分内容过滤掉
}

publicMethodVisitorvisitMethod(intaccess,Stringname,
Stringdesc,Stringsignature,String[]exceptions){
//过滤掉实现类中的构造方法
if(AddImplementClassAdapter.INTERNAL_INIT_METHOD_NAME.equals(name)){
returnnull;
}
//其他方法原样保留
returncv.visitMethod(access,name,desc,signature,exceptions);
}

/**
专门用来修改构造方法的方法适配器
*/
publicclassModifyInitMethodAdapterextendsMethodAdapter{
privateStringclassName;
publicModifyInitMethodAdapter(MethodVisitormv,Stringname){
super(mv);
this.className=name;
}
publicvoidvisitMethodInsn(intopcode,Stringowner,
Stringname,Stringdesc){
//将Java代码中的类全限定名替换为虚拟机中使用的形式
if(name.equals(AddImplementClassAdapter.INTERNAL_INIT_METHOD_NAME)){
mv.visitMethodInsn(opcode,className.replace(".","/"),
name,desc);
}
}
}

publicclassSimpleClassLoaderextendsClassLoader{
publicClass<?>defineClass(StringclassName,byte[]byteCodes){
//直接通过父类的defineClass方法加载类的结构
returnsuper.defineClass(className,byteCodes,
0,byteCodes.length);
}
}

/**
异常类
*/
publicclassEnhanceExceptionextendsException{
privateClass<?>enhanceClass;
privateClass<?>[]implementClasses;
//异常类构造方法
publicEnhanceException(Exceptionex,Class<?>ec,Class<?>...imClazz){
super(ex);
this.enhanceClass=ec;
this.implementClasses=imClazz;
}
publicClass<?>getEnhanceClass(){
returnenhanceClass;
}
publicClass<?>[]getImplementClasses(){
returnimplementClasses;
}
}

/**
静态工具方法，在待增强类中加入实现类的内容，返回增强类。
*/
publicstatic<T>Class<T>addImplementation(Class<T>clazz,
Class<?>...implementClasses)throwsEnhanceException{
StringenhancedClassName=clazz.getName()+ENHANCED;
try{
//尝试加载增强类
return(Class<T>)classLoader.loadClass(enhancedClassName);
}
//如果没有找到增强类，则尝试直接在内存中构建出增强类的结构
catch(ClassNotFoundExceptionclassNotFoundException){
ClassReaderreader=null;
try{
reader=newClassReader(clazz.getName());
}catch(IOExceptionioexception){
thrownewEnhanceException(ioexception,
clazz,implementClasses);
}
ClassWriterwriter=newClassWriter(0);
//通过AddImplementClassAdapter完成实现类内容的织入
ClassVisitorvisitor=newAddImplementClassAdapter(
enhancedClassName,clazz,writer,implementClasses);
reader.accept(visitor,0);
byte[]byteCodes=writer.toByteArray();
Class<T>result=(Class<T>)classLoader.defineClass(
enhancedClassName,byteCodes);
returnresult;
}
}

/**
通过待增强类和实现类，得到增强类的实例对象
*/
publicstatic<T>TnewInstance(Class<T>clazz,Class<?>...impls)
throwsEnhanceException{
Class<T>c=addImplementation(clazz,impls);
if(c==null){
returnnull;
}
try{
//通过反射创建实例
returnc.newInstance();
}catch(InstantiationExceptione){
thrownewEnhanceException(e,clazz,impls);
}catch(IllegalAccessExceptione){
thrownewEnhanceException(e,clazz,impls);
}
}

//不用new关键字，而使用EnhanceFactory.newInstance创建增强类的实例
SubClass1obj1=EnhanceFactory.newInstance(SubClass1.class,
TimeRetriever.class,FibonacciComputer.class);
//调用待增强类中的方法
obj1.methodInSuperClass();
obj1.methodDefinedInSubClass1();
//调用实现类中的方法
System.out.println("TheFibonaccinumberof10is"+obj1.compute(10));
System.out.println("Nowis:"+obj1.tellMeTheTime());
System.out.println("--------------------------------------");
//对于SubClass2的增强类实例的创建也是一样的
SubClass2obj2=EnhanceFactory.newInstance(SubClass2.class,
TimeRetriever.class,FibonacciComputer.class);
//调用待增强类中的方法
obj2.methodInSuperClass();
obj2.methodDefinedInSubClass2();
//调用实现类中的方法
System.out.println("TheFibonaccinumberof10is"+obj1.compute(10));
System.out.println("Nowis:"+obj1.tellMeTheTime());