Java中反射机制探索

忙里偷闲，做了一些反射机制中的测试。。。。
问题一： 即使在非并发的情况下，单例模式能保证单例么？
先来一个最简单的单例模式：

public class Singleton {

	private static Singleton instance = new Singleton();
	private Singleton() {
	}

	public static Singleton getInstance(){
		return instance;
	}
}

测试类：

import java.lang.reflect.Constructor;

public class TestSingleton {
	public static void main(String[] args) {
		try {
			Constructor<?> con = Class.forName(Singleton.class.getName()).getDeclaredConstructor();
			con.setAccessible(true);
			Singleton single1 = (Singleton)con.newInstance();
			Singleton single2 = (Singleton)con.newInstance();
			System.out.println("single1.equals(single2):"+single1.equals(single2));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

结果：

single1.equals(single2):false

结论：在反射的情况下，单例模式失效，这是因为通过反射可以获取私有属性，通过调用相应的setAccessible()方法，可以使private属性失效。那么如何能保证的确只能有一个实例呢？在我认为，如果某一程序故意通过反射来绕过单例的限制，则它要么是恶意程序，要么是一个逻辑错误，可以直接抛runtimeException，来让程序终止，否则一旦生成多个实例，后果是不可控的。个人改进如下：

public class Singleton {

	private static Singleton instance = new Singleton();
	private static boolean flag = true;
	private Singleton() {
		if(flag){
			//other code here.....
			flag = !flag;
			return;
		}else{
			throw new RuntimeException("dulpicated instance of "+ Singleton.class.getName());
		}
	}

	public static Singleton getInstance(){
		return instance;
	}
}

再次运行test程序，结果如下：

Exception in thread "main" java.lang.ExceptionInInitializerError
	at java.lang.Class.forName0(Native Method)
	at java.lang.Class.forName(Class.java:169)
	at test1.TestSingleton.main(TestSingleton.java:8)
Caused by: java.lang.RuntimeException: dulpicated instance of test1.Singleton
	at test1.Singleton.<init>(Singleton.java:13)
	at test1.Singleton.<clinit>(Singleton.java:5)
	... 3 more

这样就可以保证只有一个实例，当然如果有更好的方案，欢迎提出～～～
问题二：在反射时，如果我直接调用私有方法，会出现什么情况？
代码：

public class Reflection {
		private void test(){
			System.out.println("test1 private private method");
		}
		public void test2(){
			System.out.println("test2 public sssssssssssssss");
		}
		public static void test3(){
			System.out.println("test333333 sttic sssssssssssssss");
		}
}
测试代码一：
public class TestReflection {
	public static void main(String[] args) {
		try {

			Class<?> clazz = Class.forName(Reflection.class.getName());
			Method m = clazz.getDeclaredMethod("test");
			Reflection ref = new Reflection();
			m.invoke(ref);
                     } catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

测试结果：

[java.lang.IllegalAccessException: Class test1.TestReflection can not access a member of class test1.Reflection with modifiers "private"
	at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:65)
	at java.lang.reflect.Method.invoke(Method.java:588)
	at test1.TestReflection.main(TestReflection.java:13)

改进后的测试代码：
在执行m.invoke(ref)之前先调用 m.setAccessible(true), 即

m.setAccessible(true);
m.invoke(ref);

问题三： 如果方法中有两个重载方法，分别为test(int a), test(Integer a),如何通过反射调用相应的test方法？
代码：

public class Reflection {
		public void test(int a){
			System.out.println(a+"int parameter method");
		}
		public void test(Integer a){
			System.out.println(a+"Integer parameter method");
		}
}

实现代码：

import java.lang.reflect.Method;

public class TestReflection {
	public static void main(String[] args) {
		try {

			Class<?> clazz = Class.forName(Reflection.class.getName());
			Method m1 = clazz.getDeclaredMethod("test",Integer.class);
			Method m2 = clazz.getDeclaredMethod("test",int.class);
			System.out.println(int.class);
			System.out.println(Integer.class);
			Reflection ref = new Reflection();
			Integer in = Integer.valueOf(3);
			m1.invoke(ref,1);
			m1.invoke(ref,in);
			m2.invoke(ref,1);
			m2.invoke(ref,in);
			
			ref.test(1);
			ref.test(in);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

结果输出：

int
class java.lang.Integer
1Integer parameter method
3Integer parameter method
1int parameter method
3int parameter method
1int parameter method
3Integer parameter method

结论一：int 和Integer对象是可以自动转换的，但是在反射情况下，作为参数时二者是不同的类型的。
结论二：在test(int i)和test(Integer in)同时存在的情况下，如果调用的是方法中是Integer对象，则不进行自动拆包转换，而是直接调用test(Integer in)方法，否则自动拆包调用test(int i)方法。即：

Integer in = Integer.valueOf(2);
ref.test(in)//调用的是test(Integer in)，如果此方法不存在则调用test(int i).

以上是对反射做的一些学习，如果有不对的地方，欢迎大家指点拍砖～～

这个flag真蛋疼啊..人家再改你个flag不是照样绕过去..

恩，你说的对，这样子是自欺欺人。。。你有什么好的办法没。。。。

public enum Singleton {
	instance();
	
	private Singleton() {
		
	}
	
	public void method() {
		System.out.println("instance method");
	}
	
	public static Singleton getInstance() {
		return instance;
	}
}

这个，反射不出来吧

楼主分析也太牛逼了，调用它的构造器然后构造两个对象来比较他们相等，如果要是相等才奇怪，你用反射应该也是调用你的单例方法去生成对象啊，都不知道你在搞什么

LZ的第二句话就点题了。。

好吧，我告诉你我是在搞什么。。。我的目的就是绕过单例模式的限制生成两个两个不同的对象。。。。


按这个逻辑来说，测试人员测出来的issue都是因为他们没有按照编码人员的思维来测试？这有点儿说不过去吧。。。

恩，对。我在CSDN上面看到这样一句话：
Java 的 enum 是 singleton class (只能有一个 instance)。Java 通过编译器和 JVM 联手来防止enum 产生超过一个class：不能利用 new、clone()、de-serialization、以及 Reflection API 来产生enum 的 instance。