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.jooby.internal; import java.io.InputStream; import java.lang.reflect.Constructor; import java.lang.reflect.Executable; import java.lang.reflect.Method; import java.util.Arrays; import java.util.HashMap; import java.util.Map; import org.jooby.Env; import org.objectweb.asm.ClassReader; import org.objectweb.asm.ClassVisitor; import org.objectweb.asm.Label; import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; import org.objectweb.asm.Type; import com.google.common.base.Throwables; import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; import com.google.common.cache.LoadingCache; import com.google.common.io.Closeables; import com.google.common.io.Resources; import com.google.common.util.concurrent.UncheckedExecutionException; public class RouteMetadata implements ParameterNameProvider { private static final String[] NO_ARG = new String[0]; private final LoadingCache<Class<?>, Map<String, Object>> cache; public RouteMetadata(final Env env) { CacheLoader<Class<?>, Map<String, Object>> loader = CacheLoader.from(RouteMetadata::extractMetadata); cache = env.name().equals("dev") ? CacheBuilder.newBuilder().maximumSize(0).build(loader) : CacheBuilder.newBuilder().build(loader); } @Override public String[] names(final Executable exec) { Map<String, Object> md = md(exec); String key = paramsKey(exec); return (String[]) md.get(key); } public int startAt(final Executable exec) { Map<String, Object> md = md(exec); return (Integer) md.getOrDefault(startAtKey(exec), -1); } private Map<String, Object> md(final Executable exec) { try { return cache.getUnchecked(exec.getDeclaringClass()); } catch (UncheckedExecutionException ex) { throw Throwables.propagate(ex.getCause()); } } private static Map<String, Object> extractMetadata(final Class<?> owner) { InputStream stream = null; try { Map<String, Object> md = new HashMap<>(); stream = Resources.getResource(owner, classfile(owner)).openStream(); new ClassReader(stream).accept(visitor(md), 0); return md; } catch (Exception ex) { // won't happen, but... throw new IllegalStateException("Can't read class: " + owner.getName(), ex); } finally { Closeables.closeQuietly(stream); } } private static String classfile(final Class<?> owner) { StringBuilder sb = new StringBuilder(); Class<?> dc = owner.getDeclaringClass(); while (dc != null) { sb.insert(0, dc.getSimpleName()).append("$"); dc = dc.getDeclaringClass(); } sb.append(owner.getSimpleName()); sb.append(".class"); return sb.toString(); } private static ClassVisitor visitor(final Map<String, Object> md) { return new ClassVisitor(Opcodes.ASM5) { @Override public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) { boolean isPublic = ((access & Opcodes.ACC_PUBLIC) > 0) ? true : false; boolean isStatic = ((access & Opcodes.ACC_STATIC) > 0) ? true : false; if (!isPublic || isStatic) { // ignore return null; } final String seed = name + desc; Type[] args = Type.getArgumentTypes(desc); String[] names = args.length == 0 ? NO_ARG : new String[args.length]; md.put(paramsKey(seed), names); int minIdx = ((access & Opcodes.ACC_STATIC) > 0) ? 0 : 1; int maxIdx = Arrays.stream(args).mapToInt(Type::getSize).sum(); return new MethodVisitor(Opcodes.ASM5) { private int i = 0; private boolean skipLocalTable = false; @Override public void visitParameter(final String name, final int access) { skipLocalTable = true; // save current parameter names[i] = name; // move to next i += 1; } @Override public void visitLineNumber(final int line, final Label start) { // save line number md.putIfAbsent(startAtKey(seed), line); } @Override public void visitLocalVariable(final String name, final String desc, final String signature, final Label start, final Label end, final int index) { if (!skipLocalTable) { if (index >= minIdx && index <= maxIdx) { // save current parameter names[i] = name; // move to next i += 1; } } } }; } }; } private static String paramsKey(final Executable exec) { return paramsKey(key(exec)); } private static String paramsKey(final String key) { return key + ".params"; } private static String startAtKey(final Executable exec) { return startAtKey(key(exec)); } private static String startAtKey(final String key) { return key + ".startAt"; } @SuppressWarnings("rawtypes") private static String key(final Executable exec) { if (exec instanceof Method) { return exec.getName() + Type.getMethodDescriptor((Method) exec); } else { return "<init>" + Type.getConstructorDescriptor((Constructor) exec); } } }