Selbst in Java möchte ich true mit == 1 && a == 2 && a == 3 ausgeben (graue Magie, die weniger schwarze Magie ist)

Der folgende Artikel hat mich inspiriert.

Ich möchte true auch in Java mit == 1 && a == 2 && a == 3 --Qiita ausgeben Ich möchte true in Java mit == 1 && a == 2 && a == 3 (PowerMockito Edition) --Qiita ausgeben Ich möchte true auch in Java mit a == 1 && a == 2 && a == 3 (Black Magic) --Qiita ausgeben Ich möchte true auch in Java mit a == 1 && a == 2 && a == 3 (schwarze Ausgabe) ausgeben - Qiita

Da es von Proxy der Java-Standardbibliothek realisiert wurde, ist es erforderlich, die Schnittstelle zu implementieren.

Einstiegspunkt

public static void main(String... args) throws Exception {
	{
		System.out.println("Zuallererst, wenn Sie es normal ausführen ...");
		Judge judge = new JudgeImpl();
		test(judge);
	}
	{
		System.out.println("Wenn Sie den Proxy beißen ...");
		Judge judge = new AlwaysTrue.Builder()
				.addInterface(Judge.class)
				.build(JudgeImpl.class);
		test(judge);
	}
}

private static void test(Judge judge){
	System.out.println( judge.judge(1) );
	System.out.println( judge.judge(2) );
	System.out.println( judge.judge(3) );
}

Beurteilungslogik

public class JudgeImpl implements Judge{
    public boolean judge(int a) {
        if (a == 1 && a == 2 && a == 3) {
            return true;
        } else {
            return false;
        }
    }
}

Die Zielschnittstelle zum Umschreiben des Verarbeitungsergebnisses

public interface Judge {
    public boolean judge(int a);
}

Proxy-Klasse, die das Verarbeitungsergebnis neu schreibt

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

/**In der durch die addInterface-Methode angegebenen Schnittstelle
Der Rückgabewert ist(B|b)Wenn es eine boolesche Methode gibt, ist das Ergebnis wahr*/
public class AlwaysTrue{

	public static class Builder{
		List<Class<?>> interfaces = new ArrayList<>();
		public Builder addInterface(Class<?> interfaze) {
			interfaces.add(interfaze);
			return this;
		}
		private Class<?>[] getInterfacesArray(){
			Class<?>[] clazzArr = new Class[interfaces.size()];
			for( int i =0;i<interfaces.size();i++) {
				clazzArr[i] = interfaces.get(i);
			}
			return clazzArr;
		}

		public <E> E build(Class<?> clazz) throws Exception {
			Object normalInstance = clazz.newInstance();
			Object prankInstance = Proxy.newProxyInstance(
					clazz.getClassLoader(),
					getInterfacesArray(),
					new AlwaysTrueHandler(normalInstance));
			@SuppressWarnings("unchecked")
			E o = (E)prankInstance;
			return o;
		}
	}

	private static class AlwaysTrueHandler implements InvocationHandler {
		private Object normalInstance;
		public AlwaysTrueHandler( Object normalInstance){
			this.normalInstance = normalInstance;
		}
		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			Object normalValue =  method.invoke(normalInstance, args);
			if( method.getReturnType() == Boolean.class
					|| method.getReturnType() == boolean.class ){
				System.out.println("Ja wirklich`"+normalValue+"`Ich habe gehört, du willst zurückkehren`true`Ich werde zurückkommen!");
				return true;
			}
			return normalValue;
		}
	}
}

Ausführungsergebnis

Zuallererst, wenn Sie es normal ausführen ...
false
false
false
Wenn Sie den Proxy beißen ...
Ja wirklich`false`Ich habe gehört, du willst zurückkehren`true`Ich werde zurückkommen!
true
Ja wirklich`false`Ich habe gehört, du willst zurückkehren`true`Ich werde zurückkommen!
true
Ja wirklich`false`Ich habe gehört, du willst zurückkehren`true`Ich werde zurückkommen!
true