测试 Java 类的非公有成员变量和方法

                
public class A {
    private String name = null;
    private void calculate() {
    }
}

                
public class A {
    String name = null;
    private void calculate() {
    }
}

                
//获得指定变量的值
public static Object getValue(Object instance, String fieldName) 
    throws  IllegalAccessException, NoSuchFieldException {

    Field field = getField(instance.getClass(), fieldName);
    // 参数值为true，禁用访问控制检查
    field.setAccessible(true);
    return field.get(instance);
} 

//该方法实现根据变量名获得该变量的值
public static Field getField(Class thisClass, String fieldName) 
    throws NoSuchFieldException {

    if (thisClass == null) {
        throw new NoSuchFieldException("Error field !");
    }
}

                
public static Method getMethod(Object instance, String methodName, Class[] classTypes) 
    throws  NoSuchMethodException {

    Method accessMethod = getMethod(instance.getClass(), methodName, classTypes);
    //参数值为true，禁用访问控制检查
    accessMethod.setAccessible(true);

    return accessMethod;
}

private static Method getMethod(Class thisClass, String methodName, Class[] classTypes) 
    throws NoSuchMethodException {

    if (thisClass == null) {
        throw new NoSuchMethodException("Error method !");
    } try {
        return thisClass.getDeclaredMethod(methodName, classTypes);
    } catch (NoSuchMethodException e) {
        return getMethod(thisClass.getSuperclass(), methodName, classTypes);
            
    }
}

//调用含单个参数的方法
public static Object invokeMethod(Object instance, String methodName, Object arg) 
    throws NoSuchMethodException,
    IllegalAccessException, InvocationTargetException {

    Object[] args = new Object[1];
    args[0] = arg;
    return invokeMethod(instance, methodName, args);
}
 
//调用含多个参数的方法
public static Object invokeMethod(Object instance, String methodName, Object[] args) 
    throws NoSuchMethodException,
    IllegalAccessException, InvocationTargetException {
    Class[] classTypes = null;
    if (args != null) {
        classTypes = new Class[args.length];
        for (int i = 0; i < args.length; i++) {
            if (args[i] != null) {
                classTypes[i] = args[i].getClass();
            }
        }
    }
    return getMethod(instance, methodName, classTypes).invoke(instance, args);
}

                
public class A {
    protected String s = null;
    public A() {
	
    }
    private void method() {
        s = "word";
        System.out.println("this is mock test");
    }
    public void makeWord() {
        String prefix = s;
        System.out.println("prefix is:" + prefix);
    }
}

                
// 增加工厂方法的类 A
public class A {
    protected String s = null;

    public A getA() {
        return new A();
    }

    private void method() {
        s = "word";
        System.out.println("this is mock test");
    }

    public void makeWord() {
        String prefix = s;
        System.out.println("prefix is:" + prefix);
    }
}
//伪类，在运行时替换类 A
public class MockA extends A{

    public String   s = null;
	
    public MockA(){

    }
}
//测试类
public class TestA extends TestCase{
	
    public void setup(){
     
    }
    public void teardown(){
     
    }
    public void makeWordTest(){
        A a = new MockA();
        a.s = "test";
        a.makeWord();
    }
}

                
//伪类，在运行时替换类A
public class MockA extends A{

    public MockA(){
        super();
        s = "test";
    }
}
//测试类
public class TestA extends TestCase{
	
    public void setup(){

    }
    public void teardown(){

    }
    public void makeWordTest(){
        A a = new MockA();
        a.makeWord();
    }
}

                
class A{
    private String number = “”;
    public void method() {
        if(number.eaquals(“prefix”))
            System.out.println("method..."+number);
        else
            System.out.println(number +”is null”);    
    }

    private void makePaper() {
        number=”prefix”;
        System.out.println("makePaper...");
    }
}

                
//修改变量的修饰符
public class AccessClassAdapter extends ClassAdapter {
    public AccessClassAdapter(ClassVisitor cv) {    
        super(cv);
    }
    public FieldVisitor visitField(final int access, String name,         
        final String desc, final String signature, 
        final Object value) {
        int privateAccess = access;

        //找到名字为number的变量
        if (name.equals("number"))
            privateAccess = Opcodes.ACC_PUBLIC;

        //修字段的修饰符为public：在职责链传递过程中替换调用参数
        return cv.visitField(privateAccess, name, desc, 
            signature, value);
    }
    public static void main(String[] args) throws Exception {
        ClassReader cr = new ClassReader("A");
        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
        ClassAdapter classAdapter = new AccessClassAdapter(cw);
        cr.accept(classAdapter, ClassReader.SKIP_DEBUG);
        byte[] data = cw.toByteArray();
        //生成新的字节码文件
        File file = new File("A.class");
        FileOutputStream fout = new FileOutputStream(file);
        fout.write(data);
        fout.close();
    }
}