image.png

    1. /*
    2.  * Licensed to the Apache Software Foundation (ASF) under one
    3.  * or more contributor license agreements.  See the NOTICE file
    4.  * distributed with this work for additional information
    5.  * regarding copyright ownership.  The ASF licenses this file
    6.  * to you under the Apache License, Version 2.0 (the
    7.  * "License"); you may not use this file except in compliance
    8.  * with the License.  You may obtain a copy of the License at
    9.  *
    10.  *     http://www.apache.org/licenses/LICENSE-2.0
    11.  *
    12.  * Unless required by applicable law or agreed to in writing, software
    13.  * distributed under the License is distributed on an "AS IS" BASIS,
    14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    15.  * See the License for the specific language governing permissions and
    16.  * limitations under the License.
    17.  */
    19. package org.apache.flink.table.runtime.generated;
    21. import java.io.Serializable;
    23. import static org.apache.flink.util.Preconditions.checkNotNull;
    25. /**
    26.  * A wrapper for generated class, defines a {@link #newInstance(ClassLoader)} method
    27.  * to get an instance by reference objects easily.
    28.  */
    29. public abstract class GeneratedClass<T> implements Serializable {
    31.     private final String className;
    32.     private final String code;
    33.     private final Object[] references;
    35.     private transient Class<T> compiledClass;
    37.     protected GeneratedClass(String className, String code, Object[] references) {
    38.         checkNotNull(className, "name must not be null");
    39.         checkNotNull(code, "code must not be null");
    40.         checkNotNull(references, "references must not be null");
    41.         this.className = className;
    42.         this.code = code;
    43.         this.references = references;
    44.     }
    46.     /**
    47.      * Create a new instance of this generated class.
    48.      */
    49.     @SuppressWarnings("unchecked")
    50.     public T newInstance(ClassLoader classLoader) {
    51.         try {
    52.             return compile(classLoader).getConstructor(Object[].class)
    53.                     // Because Constructor.newInstance(Object... initargs), we need to load
    54.                     // references into a new Object[], otherwise it cannot be compiled.
    55.                     .newInstance(new Object[] {references});
    56.         } catch (Exception e) {
    57.             throw new RuntimeException(
    58.                 "Could not instantiate generated class '" + className + "'", e);
    59.         }
    60.     }
    62.     @SuppressWarnings("unchecked")
    63.     public T newInstance(ClassLoader classLoader, Object... args) {
    64.         try {
    65.             return (T) compile(classLoader).getConstructors()[0].newInstance(args);
    66.         } catch (Exception e) {
    67.             throw new RuntimeException(
    68.                     "Could not instantiate generated class '" + className + "'", e);
    69.         }
    70.     }
    72.     /**
    73.      * Compiles the generated code, the compiled class will be cached in the {@link GeneratedClass}.
    74.      */
    75.     public Class<T> compile(ClassLoader classLoader) {
    76.         if (compiledClass == null) {
    77.             // cache the compiled class
    78.             compiledClass = CompileUtils.compile(classLoader, className, code);
    79.         }
    80.         return compiledClass;
    81.     }
    83.     public String getClassName() {
    84.         return className;
    85.     }
    87.     public String getCode() {
    88.         return code;
    89.     }
    91.     public Object[] getReferences() {
    92.         return references;
    93.     }
    95.     public Class<T> getClass(ClassLoader classLoader) {
    96.         return compile(classLoader);
    97.     }
    98. }
    • 所有生成的代码都是通过 newInstance方法实例化，在实例化的的过程中会使用janino的SimpleCompiler编译文本的代码生成对应的 Class 类，然后通过这个 Class类实例化对象，在这个过程中对生成的 Class类是有缓存的。
    • 在包org.apache.flink.table.planner.codegen中有生成各种code代码的 code generator 代码生成 - 图2