MethodHandle简单使用

原文来自:fair-jm.iteye.com 转截请注明出处

 

最近看了一些MethodHandle的使用 东西很杂 七拼八凑 有一些自己的理解可能有错误

因为是七拼八凑的 一些来源我已经记不清楚了...以下买标注哪里的主要来自于《深入理解java7》的迷你书 还有小部分是API或者网上其他的文章中的

 

 

http://www.jdon.com/idea/java/invokedynamic.html 写道

invokedynamic字节码则改变了这种方式，JVM允许其在运行时再进行方法的这种绑定检查，这样，你能够拦截一个根本不存在的方法调用，然后将控制流程转移到另外一个方法里，做些其他事情

MethodHandle 允许对一个方法产生引用，如同对象引用一样，这样避免了繁重的反射。

性能更好 创建MethodHandle时就实现方法检测 而不是调用invoke()时

一般Java类都在编译时检查类型，而invokedynamic的调用不是在编译阶段检查，而是在运行时检查。要做到这点，我们需要定义一个bootstrap，这样在不存在的方法和我们实际方法搭起桥梁。

当我们通过InvokeDynamic调用不存在的方法getDate()时， JVM会使用bootstrap方法来获得真正方法的MethodHandle，然后调用它。JVM缓存了MethodHandle 能提高性能，第一次动态调用将在bootstrap方法中搜索。当然，首先得注册告诉JVM我们的bootstrap方法, 这时得用Linkage.registerBootstrapMethod(String methodName) 方法.                                                                 //注：在现在的JDK7中并未有InvokeDynamic这个类....Linkage似乎也被移除了...

 

Java虚拟机规范 (周志明大大等翻译的版本) 写道

invokevirtual指令用于调用对象的实例方法，根据对象的实际类型进行分派（虚方法分派），这也是Java语言中最常见的方法分派方式。

invokeinterface指令用于调用接口方法，它会在运行时搜索一个实现了这个接口方法的对象，找出适合的方法进行调用。

invokespecial指令用于调用一些需要特殊处理的实例方法，包括实例初始化方法（§2.9）、私有方法和父类方法。

invokestatic指令用于调用类方法（static方法）。

   介绍这个主要是MethodHandlers.LookUp类中的一些方法和这些有点联系。

   关于以上这些指令在代码中具体的出现请见下面的例子:

  

interface SampleInterface {  
    void sampleMethodInInterface();  
}  
 
class S implements SampleInterface {  
    public void sampleMethodInInterface() {}  
    public void normalMethod() {}  
	public void fatherMethod() {}  
    public static void staticSampleMethod() {}  
}
 
class Sample extends S {  
    public void sampleMethodInInterface() {}  
    public void normalMethod() {}  
    public static void staticSampleMethod() {}  
}  

class MethodInvokeTypes {  
    public void invoke() {  
        S sample = new Sample();          ---> 4: invokespecial #3    // Method Sample."<init>":()V
        sample.sampleMethodInInterface(); ---> 9: invokevirtual #4    // Method S.sampleMethodInInterface:()V
        Sample newSample = new Sample();  --->16: invokespecial #3    // Method Sample."<init>":()V
        newSample.normalMethod();         --->21: invokevirtual #5    // Method Sample.normalMethod:()V
        Sample.staticSampleMethod();      --->24: invokestatic  #6    // Method Sample.staticSampleMethod:()V
		newSample.fatherMethod();         --->28: invokevirtual #7    // Method Sample.fatherMethod:()V
    }  
} 

 

 

 

方法调用的流程:

1）名称：要调用的方法的名称一般是由开发人员在源代码中指定的符号名称。这个名称同样会出现在编译之后的字节代码中。

2）链接：链接包含了要调用方法的类。这一步有可能会涉及类的加载。

3）选择：选择要调用的方法。在类中根据方法名称和参数选择要调用的方法。

4）适配：调用者和接收者对调用的方式达成一致，即对方法的类型声明达成共识。

 

MethodHandle实例:

 

        String a="abcd";
		MethodType mt=MethodType.methodType(String.class,int.class,int.class);
		MethodHandle handle=MethodHandles.lookup().findVirtual(String.class,"substring",mt);
		System.out.println(handle.invoke(a,1,2)); //输出b

 除了invoke方法可以调用外,要注意invokeExact()这个要求严格匹配的方法:

 

以上改成:handle.invokeExact(a,1,2) 是错误的 一定要写成(String)handle.invokeExact(a,1,2)

 

 

MethodType的一些使用:

 

		MethodType mt=MethodType.methodType(void.class,int.class,double.class);
		System.out.println(mt);
		System.out.println(mt.wrap());
		System.out.println(mt.unwrap());
		System.out.println(mt.generic());
		System.out.println(mt.toMethodDescriptorString());
		System.out.println(mt.erase());
		输出:
		(int,double)void
		(Integer,Double)Void
		(int,double)void
		(Object,Object)Object
		(ID)V

 

 

 

句柄获取:

获得方法句柄通过java.lang.invoke.MethodHandles.Lookup类来完成

findConstructor就是查找构造器的

findVirtual就是查找一般函数的(同invokeVirtual)

findStatic 就是查找静态方法的(同invokeStatic)

以及findSpecial查找私有方法的

获取属性的话通过findGetter或者fingStaticGetter就可以了

 

 

findConstructor的演示(内部类):

 

(这是一个错误的例子):
public class TestMH {
	
	class Person{
		private String name;
		private int age;
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
	}
	
	public static void main(String[] args) throws Throwable {
		MethodHandles.Lookup lookup=MethodHandles.lookup();
		MethodHandle mh=lookup.findConstructor(Person.class, MethodType.methodType(void.class));
		Person p=(Person)mh.invokeExact();
		System.out.println(p);
	}

}

 这样的代码会提示:

 

Exception in thread "main" java.lang.NoSuchMethodException: no such constructor: com.cc.dynamic.TestMH$Person.<init>()void/newInvokeSpecial

原因很简单..内部类默认会把外部类的实例传入构造方法 那么自然就不会有参数为空的构造方法了 如下:

 // Method descriptor #12 (Lcom/cc/dynamic/TestMH;)V

  // Stack: 2, Locals: 2

  TestMH$Person(com.cc.dynamic.TestMH arg0);

在内部类里的方法中都会加入这个参数 如果加个String的参数的构造函数进去:

public TestMH$Person(com.cc.dynamic.TestMH arg0, java.lang.String name);

改正也很简单:

 

	public static void main(String[] args) throws Throwable {
		MethodHandles.Lookup lookup=MethodHandles.lookup();
		MethodHandle mh=lookup.findConstructor(Person.class, MethodType.methodType(void.class,TestMH.class));
		Person p=(Person)mh.invokeExact(new TestMH());
		System.out.println(p);
	}

 

 

 

findSpecial演示:

 

public class TestMH {

	private String privateInfo(){
		return "10";
	}
	
	public static void main(String[] args) throws Throwable {
		MethodHandle mh=MethodHandles.lookup().findSpecial(TestMH.class, "privateInfo", MethodType.methodType(String.class),TestMH.class);
		System.out.println(mh.invoke(new TestMH()));
	}
}

 如果调用其它类里的私有方法 则会出现错误 

 

把参数写成:

 

//Person中的私有方法
MethodHandle mh=MethodHandles.lookup().findSpecial(Person.class, "privateInfo", MethodType.methodType(String.class),Person.class);

 或者:

 

 

//Person中的私有方法
MethodHandle mh=MethodHandles.lookup().findSpecial(Person.class, "privateInfo", MethodType.methodType(String.class),TestMH.class);

 都会出错

 

有哪位可以告知下为什么吗?

折衷的方式可以通过反射:

 

		Method m=Person.class.getDeclaredMethod("privateInfo");
		m.setAccessible(true); //破坏掉
		MethodHandle mh=MethodHandles.lookup().unreflect(m);
		System.out.println(mh.invoke(new Person()));

 

 

 

findGetter演示:

 

	MethodHandles.Lookup lookUp=MethodHandles.lookup();
	MethodHandle mh=lookUp.findGetter(Person.class, "name",String.class);
	System.out.println(mh.invoke(new Person()));

Person的name是public的 private会报错(没有访问权限) 这种方式获取的域是可以写成 t.x的形式域

 

 

 

 

通过其他方式生成MethodHandle:

 

	public static void main(String[] args) throws Throwable {
		MethodHandle mh=MethodHandles.constant(String.class, "hello");
		System.out.println((String)mh.invokeExact());
	}  //这种方式生成一个返回指定类型的内容的方法句柄
	
   MethodHandle mh=MethodHandles.identity(String.class);
   System.out.println((String)mh.invokeExact("hello"));  //这种方式生成一种输入什么返回什么的方法句柄

 

 

 

函数柯里化的实现:

 

	public static MethodHandle curry(int number,MethodHandle mh){
		return MethodHandles.insertArguments(mh, 0, number);
		
	}
	public static int add(int a,int b){
		return a+b;
	}
	public static void main(String[] args) throws Throwable {
		MethodType mt=MethodType.methodType(int.class,int.class,int.class);
		MethodHandle mh=MethodHandles.lookup().findStatic(TestMH.class,"add",mt);
		mh=curry(10,mh); //让int add(int,int) 变为int add(5,int)
		System.out.println(mh.invoke(10));
	}

 

 

 

 

MethodHandles中一些其他的方法:

dropArguments:用来忽略传递的参数的 第一个参数是MethodHandle对象  第二个参数是忽略参数的起始位置，接下去的参数是忽略参数的类型(和传入的要匹配)

(代码来自API中)

 

  public void testDrop() throws Throwable{
	  MethodHandle cat = MethodHandles.lookup().findVirtual(String.class,
			  "concat", MethodType.methodType(String.class, String.class));
			assertEquals("xy", (String) cat.invokeExact("x", "y"));
			MethodHandle d0 = dropArguments(cat, 0, String.class);
			assertEquals("yz", (String) d0.invokeExact("x", "y", "z"));
			MethodHandle d1 = dropArguments(cat, 1, String.class);
			assertEquals("xz", (String) d1.invokeExact("x", "y", "z"));
			MethodHandle d2 = dropArguments(cat, 2, String.class);
			assertEquals("xy", (String) d2.invokeExact("x", "y", "z"));
			MethodHandle d12 = dropArguments(cat, 1, int.class, boolean.class);
			assertEquals("xz", (String) d12.invokeExact("x", 12, true, "z"));
  }

 

 

 

filterArguments:过滤参数的 与其说是过滤其实是对参数进行一下预处理

 @Test
  public void testFilter() throws Throwable{
	  MethodHandle cat = lookup().findVirtual(String.class,
			  "concat", MethodType.methodType(String.class, String.class));
			MethodHandle upcase = lookup().findVirtual(String.class,
			  "toUpperCase", MethodType.methodType(String.class));
			assertEquals("xy", (String) cat.invokeExact("x", "y"));
			MethodHandle f0 = filterArguments(cat, 0, upcase);
			assertEquals("Xy", (String) f0.invokeExact("x", "y")); // Xy
			MethodHandle f1 = filterArguments(cat, 1, upcase);
			assertEquals("xY", (String) f1.invokeExact("x", "y")); // xY
			MethodHandle f2 = filterArguments(cat, 0, upcase, upcase);
			assertEquals("XY", (String) f2.invokeExact("x", "y")); // XY

 

 

 

其实MethodHandle的内容很多

我这边只是罗列了下基础的使用 还有很多的例如SwitchPoint还有功能更强大的invokedynamic等 

作为基础的笔记 放在这里 给有需要的人 如果笔记哪里错了 麻烦帮忙指正一下