AccessibleMembersLookup.java revision 1612:0da44ab8c417
1/* 2 * Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26/* 27 * This file is available under and governed by the GNU General Public 28 * License version 2 only, as published by the Free Software Foundation. 29 * However, the following notice accompanied the original version of this 30 * file, and Oracle licenses the original version of this file under the BSD 31 * license: 32 */ 33/* 34 Copyright 2009-2013 Attila Szegedi 35 36 Licensed under both the Apache License, Version 2.0 (the "Apache License") 37 and the BSD License (the "BSD License"), with licensee being free to 38 choose either of the two at their discretion. 39 40 You may not use this file except in compliance with either the Apache 41 License or the BSD License. 42 43 If you choose to use this file in compliance with the Apache License, the 44 following notice applies to you: 45 46 You may obtain a copy of the Apache License at 47 48 http://www.apache.org/licenses/LICENSE-2.0 49 50 Unless required by applicable law or agreed to in writing, software 51 distributed under the License is distributed on an "AS IS" BASIS, 52 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 53 implied. See the License for the specific language governing 54 permissions and limitations under the License. 55 56 If you choose to use this file in compliance with the BSD License, the 57 following notice applies to you: 58 59 Redistribution and use in source and binary forms, with or without 60 modification, are permitted provided that the following conditions are 61 met: 62 * Redistributions of source code must retain the above copyright 63 notice, this list of conditions and the following disclaimer. 64 * Redistributions in binary form must reproduce the above copyright 65 notice, this list of conditions and the following disclaimer in the 66 documentation and/or other materials provided with the distribution. 67 * Neither the name of the copyright holder nor the names of 68 contributors may be used to endorse or promote products derived from 69 this software without specific prior written permission. 70 71 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 72 IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 73 TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 74 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER 75 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 76 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 77 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 78 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 79 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 80 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 81 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 82*/ 83 84package jdk.dynalink.beans; 85 86import java.lang.reflect.Method; 87import java.lang.reflect.Modifier; 88import java.util.Arrays; 89import java.util.Collection; 90import java.util.HashMap; 91import java.util.LinkedHashSet; 92import java.util.Map; 93import java.util.Set; 94 95/** 96 * Utility class for discovering accessible methods and inner classes. Normally, a public member declared on a class is 97 * accessible (that is, it can be invoked from anywhere). However, this is not the case if the class itself is not 98 * public, or belongs to a restricted-access package. In that case, it is required to lookup a member in a publicly 99 * accessible superclass or implemented interface of the class, and use it instead of the member discovered on the 100 * class. 101 */ 102class AccessibleMembersLookup { 103 private final Map<MethodSignature, Method> methods; 104 private final Set<Class<?>> innerClasses; 105 private final boolean instance; 106 107 /** 108 * Creates a mapping for all accessible methods and inner classes on a class. 109 * 110 * @param clazz the inspected class 111 * @param instance true to inspect instance methods, false to inspect static methods. 112 */ 113 AccessibleMembersLookup(final Class<?> clazz, final boolean instance) { 114 this.methods = new HashMap<>(); 115 this.innerClasses = new LinkedHashSet<>(); 116 this.instance = instance; 117 lookupAccessibleMembers(clazz); 118 } 119 120 /** 121 * Returns an accessible method equivalent of a method. 122 * 123 * @param m the method whose accessible equivalent is requested. 124 * @return the accessible equivalent for the method (can be the same as the passed in method), or null if there is 125 * no accessible method equivalent. 126 */ 127 Method getAccessibleMethod(final Method m) { 128 return m == null ? null : methods.get(new MethodSignature(m)); 129 } 130 131 Collection<Method> getMethods() { 132 return methods.values(); 133 } 134 135 Class<?>[] getInnerClasses() { 136 return innerClasses.toArray(new Class<?>[0]); 137 } 138 139 /** 140 * A helper class that represents a method signature - name and argument types. 141 */ 142 static final class MethodSignature { 143 private final String name; 144 private final Class<?>[] args; 145 146 /** 147 * Creates a new method signature from arbitrary data. 148 * 149 * @param name the name of the method this signature represents. 150 * @param args the argument types of the method. 151 */ 152 MethodSignature(final String name, final Class<?>[] args) { 153 this.name = name; 154 this.args = args; 155 } 156 157 /** 158 * Creates a signature for the given method. 159 * 160 * @param method the method for which a signature is created. 161 */ 162 MethodSignature(final Method method) { 163 this(method.getName(), method.getParameterTypes()); 164 } 165 166 /** 167 * Compares this object to another object 168 * 169 * @param o the other object 170 * @return true if the other object is also a method signature with the same name, same number of arguments, and 171 * same types of arguments. 172 */ 173 @Override 174 public boolean equals(final Object o) { 175 if(o instanceof MethodSignature) { 176 final MethodSignature ms = (MethodSignature)o; 177 return ms.name.equals(name) && Arrays.equals(args, ms.args); 178 } 179 return false; 180 } 181 182 /** 183 * Returns a hash code, consistent with the overridden {@link #equals(Object)}. 184 */ 185 @Override 186 public int hashCode() { 187 return name.hashCode() ^ Arrays.hashCode(args); 188 } 189 190 @Override 191 public String toString() { 192 final StringBuilder b = new StringBuilder(); 193 b.append("[MethodSignature ").append(name).append('('); 194 if(args.length > 0) { 195 b.append(args[0].getCanonicalName()); 196 for(int i = 1; i < args.length; ++i) { 197 b.append(", ").append(args[i].getCanonicalName()); 198 } 199 } 200 return b.append(")]").toString(); 201 } 202 } 203 204 private void lookupAccessibleMembers(final Class<?> clazz) { 205 boolean searchSuperTypes; 206 207 if(!CheckRestrictedPackage.isRestrictedClass(clazz)) { 208 searchSuperTypes = false; 209 for(final Method method: clazz.getMethods()) { 210 final boolean isStatic = Modifier.isStatic(method.getModifiers()); 211 if(instance != isStatic) { 212 final MethodSignature sig = new MethodSignature(method); 213 if(!methods.containsKey(sig)) { 214 final Class<?> declaringClass = method.getDeclaringClass(); 215 if(declaringClass != clazz && CheckRestrictedPackage.isRestrictedClass(declaringClass)) { 216 //Sometimes, the declaring class of a method (Method.getDeclaringClass()) 217 //retrieved through Class.getMethods() for a public class will be a 218 //non-public superclass. For such a method, we need to find a method with 219 //the same name and signature in a public superclass or implemented 220 //interface. 221 //This typically doesn't happen with classes emitted by a reasonably modern 222 //javac, as it'll create synthetic delegator methods in all public 223 //immediate subclasses of the non-public class. We have, however, observed 224 //this in the wild with class files compiled with older javac that doesn't 225 //generate the said synthetic delegators. 226 searchSuperTypes = true; 227 } else { 228 // don't allow inherited static 229 if (!isStatic || clazz == declaringClass) { 230 methods.put(sig, method); 231 } 232 } 233 } 234 } 235 } 236 for(final Class<?> innerClass: clazz.getClasses()) { 237 // Add both static and non-static classes, regardless of instance flag. StaticClassLinker will just 238 // expose non-static classes with explicit constructor outer class argument. 239 // NOTE: getting inner class objects through getClasses() does not resolve them, so if those classes 240 // were not yet loaded, they'll only get loaded in a non-resolved state; no static initializers for 241 // them will trigger just by doing this. 242 innerClasses.add(innerClass); 243 } 244 } else { 245 searchSuperTypes = true; 246 } 247 248 // don't need to search super types for static methods 249 if(instance && searchSuperTypes) { 250 // If we reach here, the class is either not public, or it is in a restricted package. Alternatively, it is 251 // public, but some of its methods claim that their declaring class is non-public. We'll try superclasses 252 // and implemented interfaces then looking for public ones. 253 final Class<?>[] interfaces = clazz.getInterfaces(); 254 for(int i = 0; i < interfaces.length; i++) { 255 lookupAccessibleMembers(interfaces[i]); 256 } 257 final Class<?> superclass = clazz.getSuperclass(); 258 if(superclass != null) { 259 lookupAccessibleMembers(superclass); 260 } 261 } 262 } 263} 264