具体来说，动态上下文的诸多行为会依赖于一个动态工厂，此注解即应用于一个字段或者局部变量，亦或者是一个方法参数之上，其上下文语义与java变量，字段和方法参数无异， 10 | * 请注意，当注解用于java静态字段时，此标记同样会具有静态上下文，反之亦然，即您不能在静态上下文内访问非静态上下文工厂标识 11 | * 12 | *
对于同一个上下文内的多次设置上下文标记，则在访问动态工厂时，会选择在此之前的最后一个标记使用*/ 13 | @Retention(RetentionPolicy.SOURCE) 14 | @Target({ElementType.FIELD, ElementType.LOCAL_VARIABLE, ElementType.PARAMETER}) 15 | public @interface ContextMaker { 16 | } 17 | -------------------------------------------------------------------------------- /annotations/src/main/java/dynamilize/annotations/DynamicContext.java: -------------------------------------------------------------------------------- 1 | package dynamilize.annotations; 2 | 3 | import dynamilize.DynamicClass; 4 | 5 | import java.lang.annotation.ElementType; 6 | import java.lang.annotation.Retention; 7 | import java.lang.annotation.RetentionPolicy; 8 | import java.lang.annotation.Target; 9 | 10 | /**动态上下文标记，携带此注解的类型会被视为一个具有动态化语义的上下文 11 | *
具体来说，这个注解是类型内局部动态语义的最外层标记，所有局部动态语义声明的注解都需要其所在的环境具有此注解标记的外层 12 | *
本注解本身没有实际作用，关于这个注解支持的局部语义注解可参见：： 13 | *
具体来说，一个具备此注解的类，其中声明的各种方法语句的上下文都会被调整为适配到{@link DynamicClass#visitClass(Class, JavaHandleHelper)}的语义， 14 | * 并保存其对应的动态类型对象及名称。该注解并不会递归的处理被标记类中的内部类，但是被标记的类中不能有任何非静态的内部类 15 | *
此标记转换的动态类类名由DynamilizeClass.{@link DynamilizeClass#className()}给出，默认使用标记的类类名，细节请参阅这个注解属性
16 | *
17 | *
18 | *
19 | *
警告：此注解转换的动态类型标记可能并不能可靠的加载，在您使用这个注解生成的动态类之前，请通过调用类的任意字段/方法来确保此类型已加载
20 | *特别注意，在注解{@link NewDynamic}中传递该类的NAME常量并不能使jvm加载这个类，因为NAME会被转化为常量提供给注解参数， 21 | * 因此在通过上下文注解引用的该动态类并不能可靠的加载此动态类
22 | *以下是注解的工作细节： 25 | *
此外，被标记为动态类型记录的类也可以扩展一个动态类型记录，这会对INSTANCE字段的初始化产生影响，具体来说，初始化语句都是调用{@link DynamicClass#visit(String, Class, DynamicClass, JavaHandleHelper)} 41 | * 来直接获取动态类型实例，而扩展会影响的就是其最后一个参数，直观来看
{@code
42 | * //一个没有扩展的动态类型记录中，INSTANCE的等价初始化语句是这样的：
43 | * public static final DynamicClass INSTANCE = DynamicClass.visit(NAME, .class, null, $helper$);
44 | * //而有扩展一个父类的动态类型记录中，INSTANCE的等价初始化语句是这样的：
45 | * public static final DynamicClass INSTANCE = DynamicClass.visit(NAME, .class, .INSTANCE, $helper$);
46 | * }
47 | * 值得关注的是其中的字段{@code $helper$}，这个字段是保存用于访问java类使用的辅助器的静态字段，
48 | * 您同样必须在原始的类型定义中创建指定名称的java静态字段，否则将无法通过编译，关于选择这个字段的细节，请参阅DynamilizeClass.{@link DynamilizeClass#helperField()}
49 | *
50 | * 另外，在您使用这个注解标记类型时，将类型标记为abstract并实现{@link DynamilizedClass}接口是一种不错的选择，该接口包含了INSTANCE字段和NAME字段，
51 | * 这是一种魔法操作，例如，在java中，您可以直接对被标记的类调用INSTANCE字段和NAME字段，但这是通过类转移的调用，实际上会指向{@link DynamilizedClass}接口的字段，
52 | * 但是在注解处理后，被标记类中会被添加这两个字段，从外部访问这个类型的INSTANCE和NAME字段的目标就会被确定而非重定向到DynamilizedClass接口,
53 | * 具体细节请参阅{@link DynamilizedClass}*/
54 | @Retention(RetentionPolicy.SOURCE)
55 | @Target(ElementType.TYPE)
56 | public @interface DynamilizeClass {
57 | /**应用于动态类的名称，这会为此类的NAME字段设置值，默认在不设置这个名称的情况下，注解处理器会使用被标记的类的完整类名作为该动态类的名称*/
58 | String className() default " 您可以根据需要设置此选项，假如内存性能十分重要，则推荐设为false，否则通常来说设为true都能提升时间性能，尤其是在动态类型多次扩展嵌套的情况下*/
65 | boolean signatureMethods() default true;
66 |
67 | /**辅助类型动态声明的魔法接口，通常在您对一个类型标记为{@link DynamilizeClass}时，建议将类型设置为abstract并添加实现此接口
68 | * 接口扩展自{@link DynamicObject}，以便在您描述类型行为时可以直接使用动态对象的方法，值得注意的是，
69 | * 您在此上下文中调用属于{@link DynamicObject}的API是不会被再次转化为动态调用动态方法的，即这些API会被注解处理器略过，仅仅将调用对象重定向到self参数
70 | * 此外，该接口中定义了两个常量字段和一个方法，字段用作在java语义中直接引用该类型的INSTANCE字段和NAME字段，在经过注解处理器处理后这两个字段不会被重定向到该接口。
71 | * 方法{@link DynamilizedClass#super$()}则是对动态super指针的虚拟引用，以便您可以以动态描述的方法那样调用super池的行为，对这个方法的调用在注解处理后会被转化为对sup参数的引用*/
72 | interface DynamilizedClass 具体来讲，此注解的作用即将形如 实例化动态代理对象声明的参数从注解的属性内提供，此注解的参数：
17 | * 另外，如果您声明的变量类型是{@link dynamilize.DynamicObject}，同时将右侧表达式添加类型转换到DynamicObject，此时生成的语句将直接获取原始的动态对象，
38 | * 而不调用其{@code objSelf()}方法，举例来说，假设：
39 | * 关于此注解的作用细节，请参阅本注解的参数说明*/
49 | @Retention(RetentionPolicy.SOURCE)
50 | @Target({ElementType.FIELD, ElementType.LOCAL_VARIABLE})
51 | public @interface NewDynamic {
52 | /**创建动态对象使用的{@linkplain dynamilize.DynamicMaker 动态工厂}引用语句，这会直接被整合为一段java语句插入到newInstance调用中，
53 | * 默认使用动态上下文中被标记的动态工厂，并且通常情况下也不推荐设置直接引用语句*/
54 | String refDynamicMaker() default " 此类行为可能完全打破模块化的访问保护，本身是不安全的，若不是必要情况，请尽量避免使用该类
13 | * 此类仅在JDK9之后可用，避免在更早的版本引用此类的方法，且此类仅在desktop平台可用，安卓平台不可使用此类的任何行为
14 | *
15 | * @author EBwilson */
16 | @SuppressWarnings({"unchecked"})
17 | public class Demodulator{
18 | private static final long fieldFilterOffset = 112L;
19 |
20 | private static final Unsafe unsafe;
21 |
22 | private static final Field opensField;
23 | private static final Field exportField;
24 |
25 | private static final Method exportNative;
26 |
27 | static{
28 | try{
29 | Constructor 方法入口的运行实际上是对样版方法的引用，因此需要确保样版方法所在的类始终有效，方法入口会生成这个方法的入口函数提供给动态对象使用
8 | *
9 | * @author EBwilson */
10 | @SuppressWarnings("unchecked")
11 | public class JavaMethodEntry implements IFunctionEntry{
12 | private final String name;
13 | private final FunctionType type;
14 | private final Function defFunc;
15 |
16 | /**直接通过目标方法创建方法入口，并生成对方法引用的句柄提供给匿名函数以描述此函数行为
17 | *
18 | * @param invokeMethod 样版方法*/
19 | public JavaMethodEntry(Method invokeMethod){
20 | this.name = invokeMethod.getName();
21 | this.type = FunctionType.inst(invokeMethod);
22 |
23 | defFunc = (self, args) -> {
24 | try {
25 | return invokeMethod.invoke(self.objSelf(), args.args());
26 | } catch (InvocationTargetException|IllegalAccessException e) {
27 | throw new RuntimeException(e);
28 | }
29 | };
30 | }
31 |
32 | @Override
33 | public String getName(){
34 | return name;
35 | }
36 |
37 | @Override
38 | public 参数表对象为可复用对象，引用完毕后请使用{@link ArgumentList#recycle()}回收对象以减少堆内存更新频率
8 | *
9 | * @author EBwilson */
10 | public class ArgumentList{
11 | public static int MAX_INSTANCE_STACK = 2048;
12 |
13 | public static final Stack 对于一个{@linkplain DynamicClass 动态类}的实例，实例的数据池一定会有一个父池，这个池以动态类的直接超类描述的信息进行初始化。
7 | * 访问池信息无论如何都是以最近原则，即若本池内没有找到数据，则以距离实例的池最近的具有此变量/函数的父池的数据为准
8 | *
9 | * @author EBwilson*/
10 | @SuppressWarnings({"unchecked"})
11 | public class DataPool{
12 | private static final String init = " 通常来说你不应该在{@link DynamicMaker}之外的任何地方实例化此类型
27 | *
28 | * @param superPool 此池的父池*/
29 | public DataPool(DataPool superPool){
30 | this.superPool = superPool;
31 | }
32 |
33 | public void init(DynamicObject self, Object... args){
34 | DynamicClass curr = self.getDyClass();
35 | HashSet
实例化变量的动态化语句标志，用于声明一个java语义的动态对象实例化语句
10 | * {@code
11 | * [modifiers] Type variableName = new Type(的语句转换为创建一个动态代理对象，这可以是字段声明，亦可以是方法中的局部变量声明，其中等号右侧必须是一个new语句。
13 | *
注意，右侧的new语句不得携带匿名扩展块，在未来的更新中可能会添加对此的支持
14 | *
假如您实例化的是一个非静态内部类，形如{@code outer.new Inner(
18 | *
23 | * 使用上述的参数，此注解会将一个满足条件的语句变换为创建动态对象，例如：
24 | * {@code
25 | * //假设，在上文已经标记了一个动态工厂"maker"
26 | * @NewDynamic(dynClassName = "SampleDyc", impls = {Collection.class, Runnable.class})
27 | * Object dyObj = new Object();
28 | * }
29 | * 那么，经过处理编译后的等效代码是这样的：
30 | * {@code
31 | * Object dyObj = maker.newInstance(Object.class, new Class[]{Collection.class, Runnable.class}, (Class[])null, DynamicClass.get("SampleDyc")).objSelf();
32 | * }
33 | * 如果在new调用构造函数时有传入参数，参数会正确的添加在上述的语句最后一个参数处。一个比较特殊的地方在于，为了内存性能，
34 | * 您传递的接口列表（额外接口和切面接口）都会被处理为一个存在于类中的静态常量以供重复调用，对于列表接口类型相同的一组接口会复用同一个常量接口表
35 | *
36 | *
37 | * {@code
40 | * @NewDynamic(dynClassName = "SampleDyc", impls = {Collection.class, Runnable.class})
41 | * DynamicObject
43 | * 那么，经过处理编译后的等效代码是这样的：
44 | * {@code
45 | * DynamicObject
47 | * 简单来说这个注解的作用就是让您更便捷的使用java语句创建一个动态代理对象，而不需要使用maker的{@code newInstance(...)}方法
48 | * {@code
31 | * new DynamicFactory().setDefaultGenerator().setDefaultHelper().getMaker();
32 | * }
33 | *
34 | * @see DynamicFactory#setDefaultGenerator()
35 | * @see DynamicFactory#setDefaultHelper()
36 | * @return 一个由默认声明生产的动态生成器*/
37 | public static DynamicMaker getDefault(){
38 | return DEFAULT.getMaker();
39 | }
40 |
41 | /**获取{@linkplain DynamicMaker 动态生成器}实例
42 | *
43 | * @throws NullPointerException 若有必要的属性尚未设置*/
44 | public DynamicMaker getMaker(){
45 | PackageAccHandler handler = this.handler;
46 |
47 | AbstractClassGenerator generator = this.generator;
48 |
49 | Objects.requireNonNull(helper);
50 | Objects.requireNonNull(generator);
51 |
52 | return handler == null? new DynamicMaker(helper) {
53 | @Override
54 | protected