java 反射 封装_jOOR: jOOR 在java原生的反射基础上进行了简单的封装，使得反射使用方便不少！ 举个简单的列子，供大家参考...

Overview

jOOR stands for jOOR Object Oriented Reflection. It is a simple wrapper for the java.lang.reflect package.

jOOR's name is inspired by jOOQ, a fluent API for SQL building and execution.

Dependencies

None!

Download

For use with Java 9+

org.jooq

joor

0.9.13

For use with Java 8+

org.jooq

joor-java-8

0.9.13

For use with Java 6+

org.jooq

joor-java-6

0.9.13

Simple example

// All examples assume the following static import:

import static org.joor.Reflect.*;

String world = onClass("java.lang.String") // Like Class.forName()

.create("Hello World") // Call most specific matching constructor

.call("substring", 6) // Call most specific matching substring() method

.call("toString") // Call toString()

.get(); // Get the wrapped object, in this case a String

Proxy abstraction

jOOR also gives access to the java.lang.reflect.Proxy API in a simple way:

public interface StringProxy {

String substring(int beginIndex);

}

String substring = onClass("java.lang.String")

.create("Hello World")

.as(StringProxy.class) // Create a proxy for the wrapped object

.substring(6); // Call a proxy method

Runtime compilation of Java code

jOOR has an optional dependency on the java.compiler module and simplifies access to javax.tools.JavaCompiler through the following API:

Supplier supplier = Reflect.compile(

"com.example.HelloWorld",

"package com.example;\n" +

"class HelloWorld implements java.util.function.Supplier {\n" +

" public String get() {\n" +

" return \"Hello World!\";\n" +

" }\n" +

"}\n").create().get();

// Prints "Hello World!"

System.out.println(supplier.get());

Comparison with standard java.lang.reflect

jOOR code:

Employee[] employees = on(department).call("getEmployees").get();

for (Employee employee : employees) {

Street street = on(employee).call("getAddress").call("getStreet").get();

System.out.println(street);

}

The same example with normal reflection in Java:

try {

Method m1 = department.getClass().getMethod("getEmployees");

Employee[] employees = (Employee[]) m1.invoke(department);

for (Employee employee : employees) {

Method m2 = employee.getClass().getMethod("getAddress");

Address address = (Address) m2.invoke(employee);

Method m3 = address.getClass().getMethod("getStreet");

Street street = (Street) m3.invoke(address);

System.out.println(street);

}

}

// There are many checked exceptions that you are likely to ignore anyway

catch (Exception ignore) {

// ... or maybe just wrap in your preferred runtime exception:

throw new RuntimeException(e);

}

Similar projects

Everyday Java reflection with a fluent interface:

Reflection modelled as XPath (quite interesting!)