Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.flink.api.java; import org.apache.flink.annotation.Internal; import org.apache.flink.api.common.InvalidProgramException; import org.apache.flink.util.InstantiationUtil; import org.objectweb.asm.ClassReader; import org.objectweb.asm.ClassVisitor; import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; import java.lang.reflect.Field; /** * The closure cleaner is a utility that tries to truncate the closure (enclosing instance) * of non-static inner classes (created for inline transformation functions). That makes non-static * inner classes in many cases serializable, where Java's default behavior renders them non-serializable * without good reason. */ @Internal public class ClosureCleaner { private static Logger LOG = LoggerFactory.getLogger(ClosureCleaner.class); /** * Tries to clean the closure of the given object, if the object is a non-static inner * class. * * @param func The object whose closure should be cleaned. * @param checkSerializable Flag to indicate whether serializability should be checked after * the closure cleaning attempt. * * @throws InvalidProgramException Thrown, if 'checkSerializable' is true, and the object was * not serializable after the closure cleaning. * * @throws RuntimeException A RuntimeException may be thrown, if the code of the class could not * be loaded, in order to process during teh closure cleaning. */ public static void clean(Object func, boolean checkSerializable) { if (func == null) { return; } final Class<?> cls = func.getClass(); // First find the field name of the "this$0" field, this can // be "this$x" depending on the nesting boolean closureAccessed = false; for (Field f : cls.getDeclaredFields()) { if (f.getName().startsWith("this$")) { // found a closure referencing field - now try to clean closureAccessed |= cleanThis0(func, cls, f.getName()); } } if (checkSerializable) { try { InstantiationUtil.serializeObject(func); } catch (Exception e) { String functionType = getSuperClassOrInterfaceName(func.getClass()); String msg = functionType == null ? (func + " is not serializable.") : ("The implementation of the " + functionType + " is not serializable."); if (closureAccessed) { msg += " The implementation accesses fields of its enclosing class, which is " + "a common reason for non-serializability. " + "A common solution is to make the function a proper (non-inner) class, or" + "a static inner class."; } else { msg += " The object probably contains or references non serializable fields."; } throw new InvalidProgramException(msg, e); } } } public static void ensureSerializable(Object obj) { try { InstantiationUtil.serializeObject(obj); } catch (Exception e) { throw new InvalidProgramException("Object " + obj + " is not serializable", e); } } private static boolean cleanThis0(Object func, Class<?> cls, String this0Name) { This0AccessFinder this0Finder = new This0AccessFinder(this0Name); getClassReader(cls).accept(this0Finder, 0); final boolean accessesClosure = this0Finder.isThis0Accessed(); if (LOG.isDebugEnabled()) { LOG.debug(this0Name + " is accessed: " + accessesClosure); } if (!accessesClosure) { Field this0; try { this0 = func.getClass().getDeclaredField(this0Name); } catch (NoSuchFieldException e) { // has no this$0, just return throw new RuntimeException("Could not set " + this0Name + ": " + e); } try { this0.setAccessible(true); this0.set(func, null); } catch (Exception e) { // should not happen, since we use setAccessible throw new RuntimeException("Could not set " + this0Name + " to null. " + e.getMessage(), e); } } return accessesClosure; } private static ClassReader getClassReader(Class<?> cls) { String className = cls.getName().replaceFirst("^.*\\.", "") + ".class"; try { return new ClassReader(cls.getResourceAsStream(className)); } catch (IOException e) { throw new RuntimeException("Could not create ClassReader: " + e.getMessage(), e); } } private static String getSuperClassOrInterfaceName(Class<?> cls) { Class<?> superclass = cls.getSuperclass(); if (superclass.getName().startsWith("org.apache.flink")) { return superclass.getSimpleName(); } else { for (Class<?> inFace : cls.getInterfaces()) { if (inFace.getName().startsWith("org.apache.flink")) { return inFace.getSimpleName(); } } return null; } } } /** * This visitor walks methods and finds accesses to the field with the reference to * the enclosing class. */ class This0AccessFinder extends ClassVisitor { private final String this0Name; private boolean isThis0Accessed; public This0AccessFinder(String this0Name) { super(Opcodes.ASM5); this.this0Name = this0Name; } public boolean isThis0Accessed() { return isThis0Accessed; } @Override public MethodVisitor visitMethod(int access, String name, String desc, String sig, String[] exceptions) { return new MethodVisitor(Opcodes.ASM5) { @Override public void visitFieldInsn(int op, String owner, String name, String desc) { if (op == Opcodes.GETFIELD && name.equals(this0Name)) { isThis0Accessed = true; } } }; } }