This page (revision-1) was last changed on 01-Jul-2014 07:15 by Dieter Käppel

Only authorized users are allowed to rename pages.

Only authorized users are allowed to delete pages.

Page revision history

Version Date Modified Size Author Changes ... Change note
1 01-Jul-2014 07:15 3 KB Dieter Käppel

Page References

Incoming links Outgoing links
Emit ...nobody

Version management

Difference between version and

At line 1 added 108 lines
Dieses Tool unterstützt das Generieren von Bytecode für [Java]. Emit ist aus dem [Intersult Maven Repository] zu beziehen. Wesentlicher Design-Aspekt ist das einfache Benutzen und ein schlankes Paket.
!!!Schnelle Reflection
Die Klasse FastMethod erzeugt einen Reflection-Code, der deutlich schneller ist, als der JVM-Code:
{{{
public class FastMethodTest {
public static final long N = 10000000000L;
@Test
public void testInvoke() throws Exception {
FastMethod fastMethod = FastMethod.create(FastMethodTest.class, "someMethod");
String result = (String)fastMethod.invoke(this);
Assert.assertEquals("test-value", result);
}
public void testFastMethod() throws Exception {
FastMethod method = FastMethod.create(FastMethodTest.class, "someMethod");
method.invoke(this);
long begin = System.nanoTime();
for (long i = 0; i < N; ++i) {
method.invoke(this);
}
long duration = System.nanoTime() - begin;
System.out.println("FastMethod: " + duration / 1000000000D + " s");
}
public void testMethod() throws Exception {
Method method = FastMethodTest.class.getDeclaredMethod("someMethod");
method.invoke(this);
long begin = System.nanoTime();
for (long i = 0; i < 10000000000L; ++i) {
method.invoke(this);
}
long duration = System.nanoTime() - begin;
System.out.println("Method: " + duration / 1000000000D + " s");
}
public String someMethod() {
return "test-value";
}
}
}}}
!!!Interceptor
Damit kann man Klassen wrappen und Methodenaufrufe abfangen:
{{{
public class ProxyTest extends TestCase {
public static class Test {
private String field;
public String getField() {
return field;
}
public void setField(String field) {
this.field = field;
}
@Override
public String toString() {
return String.valueOf(field);
}
}
public static class TestInterceptor implements Interceptor {
public Object get(Object object, String name) {
System.out.println("interceptor getter: " + name);
return "interceptor value";
}
public void set(Object object, String name, Object value) {
System.out.println("interceptor setter: " + name + " = " + value);
}
}
public void testCreateProxyClass() throws Exception {
TestInterceptor testInterceptor = new TestInterceptor();
Class<? extends Test> testProxyClass = Proxy.createProxyClass(Test.class);
Test testProxy = testProxyClass.getConstructor(new Class[] {Interceptor.class}).newInstance(testInterceptor);
String text = testProxy.getField();
System.out.println(text);
testProxy.setField("set value");
}
}
}}}
!!!Class Builder
Damit kann man komplette Klassen dynamisch emittieren:
{{{
public class ClassBuilderTest extends TestCase {
public static class TestBase {
public String test() {
return "Test base";
}
}
public void testClassBuilder() throws InstantiationException, IllegalAccessException {
ClassBuilder<TestBase> classBuilder = new ClassBuilder<TestBase>("org.ksoft.emit.builder.Test", TestBase.class);
classBuilder.addMethod(EnumSet.of(Modifier.Public), "test", String.class).addStatement(
new Statement.Return(
new Statement.StringConstant("Test overwritten")
)
);
TestBase test = classBuilder.newInstance();
String string = test.test();
System.out.print(string);
}
}
}}}