001package ball.lang.reflect;
002/*-
003 * ##########################################################################
004 * Utilities
005 * $Id: DefaultInvocationHandler.java 5285 2020-02-05 04:23:21Z ball $
006 * $HeadURL: svn+ssh://svn.hcf.dev/var/spool/scm/repository.svn/ball-util/trunk/src/main/java/ball/lang/reflect/DefaultInvocationHandler.java $
007 * %%
008 * Copyright (C) 2008 - 2020 Allen D. Ball
009 * %%
010 * Licensed under the Apache License, Version 2.0 (the "License");
011 * you may not use this file except in compliance with the License.
012 * You may obtain a copy of the License at
013 *
014 *      http://www.apache.org/licenses/LICENSE-2.0
015 *
016 * Unless required by applicable law or agreed to in writing, software
017 * distributed under the License is distributed on an "AS IS" BASIS,
018 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
019 * See the License for the specific language governing permissions and
020 * limitations under the License.
021 * ##########################################################################
022 */
023import java.lang.invoke.MethodHandles;
024import java.lang.reflect.Constructor;
025import java.lang.reflect.InvocationHandler;
026import java.lang.reflect.Method;
027import java.lang.reflect.Proxy;
028import java.util.ArrayList;
029import java.util.Arrays;
030import java.util.HashMap;
031import java.util.LinkedHashSet;
032import java.util.List;
033import java.util.Objects;
034import java.util.Set;
035import java.util.stream.Collectors;
036import java.util.stream.Stream;
037import lombok.NoArgsConstructor;
038import lombok.ToString;
039
040import static org.apache.commons.lang3.ClassUtils.getAllInterfaces;
041import static org.apache.commons.lang3.reflect.MethodUtils.invokeMethod;
042
043/**
044 * Default {@link InvocationHandler} implementation.
045 * See {@link #invoke(Object,Method,Object[])}.
046 *
047 * @author {@link.uri mailto:ball@hcf.dev Allen D. Ball}
048 * @version $Revision: 5285 $
049 */
050@NoArgsConstructor @ToString
051public class DefaultInvocationHandler implements InvocationHandler {
052    private final HashMap<Class<?>,List<Class<?>>> cache = new HashMap<>();
053
054    /**
055     * See {@link Proxy#getProxyClass(ClassLoader,Class[])}.
056     *
057     * @param   interfaces      The interface {@link Class}es the
058     *                          {@link Proxy} {@link Class} will implement.
059     *
060     * @return  The {@link Proxy}.
061     */
062    public Class<?> getProxyClass(Class<?>... interfaces) throws IllegalArgumentException {
063        return Proxy.getProxyClass(getClass().getClassLoader(), interfaces);
064    }
065
066    /**
067     * See
068     * {@link Proxy#newProxyInstance(ClassLoader,Class[],InvocationHandler)}.
069     * Default implementation invokes {@link #getProxyClass(Class...)}.
070     *
071     * @param   interfaces      The interface {@link Class}es the
072     *                          {@link Proxy} {@link Class} will implement.
073     *
074     * @return  The {@link Proxy}.
075     */
076    public Object newProxyInstance(Class<?>... interfaces) throws IllegalArgumentException {
077        Object proxy = null;
078
079        try {
080            proxy =
081                getProxyClass(interfaces)
082                .getConstructor(InvocationHandler.class)
083                .newInstance(this);
084        } catch (IllegalArgumentException exception) {
085            throw exception;
086        } catch (RuntimeException exception) {
087            throw exception;
088        } catch (Exception exception) {
089            throw new IllegalStateException(exception);
090        }
091
092        return proxy;
093    }
094
095    /**
096     * {@inheritDoc}
097     *
098     * If the {@link Method#isDefault() method.isDefault()}, that
099     * {@link Method} will be invoked directly.  If the {@link Method} is
100     * declared in {@link Object}, it is applied to {@link.this}
101     * {@link InvocationHandler}.  Otherwise, the call will be dispatched to
102     * a declared {@link Method} on {@link.this} {@link InvocationHandler}
103     * with the same name and compatible parameter types (forcing access if
104     * necessary).
105     *
106     * @throws  Exception       If no compatible {@link Method} is found or
107     *                          the {@link Method} cannot be invoked.
108     */
109    @Override
110    public Object invoke(Object proxy,
111                         Method method, Object[] argv) throws Throwable {
112        Object result = null;
113        Class<?> declarer = method.getDeclaringClass();
114
115        if (method.isDefault()) {
116            Constructor<MethodHandles.Lookup> constructor =
117                MethodHandles.Lookup.class
118                .getDeclaredConstructor(Class.class);
119
120            constructor.setAccessible(true);
121
122            result =
123                constructor.newInstance(declarer)
124                .in(declarer)
125                .unreflectSpecial(method, declarer)
126                .bindTo(proxy)
127                .invokeWithArguments(argv);
128        } else if (declarer.equals(Object.class)) {
129            result = method.invoke(this, argv);
130        } else {
131            result =
132                invokeMethod(this, true,
133                             method.getName(),
134                             argv, method.getParameterTypes());
135        }
136
137        return result;
138    }
139
140    /**
141     * Method available to subclass implementations to get the implemented
142     * interfaces of the argument {@link Class types}.  The default
143     * implementation caches the results.
144     *
145     * @param   type            The {@link Class} to analyze.
146     * @param   types           Additional {@link Class}es to analyze.
147     *
148     * @return  The {@link List} of interface {@link Class}es.
149     */
150    protected List<Class<?>> getImplementedInterfacesOf(Class<?> type,
151                                                        Class<?>... types) {
152        Set<Class<?>> set =
153            Stream.concat(Stream.of(type), Arrays.stream(types))
154            .filter(Objects::nonNull)
155            .flatMap(t -> cache.computeIfAbsent(t, k -> compute(k)).stream())
156            .collect(Collectors.toCollection(LinkedHashSet::new));
157
158        return new ArrayList<>(set);
159    }
160
161    private List<Class<?>> compute(Class<?> type) {
162        Set<Class<?>> set =
163            Stream.concat(Stream.of(type), getAllInterfaces(type).stream())
164            .filter(Class::isInterface)
165            .collect(Collectors.toCollection(LinkedHashSet::new));
166
167        return new ArrayList<>(set);
168    }
169}