Java tutorial
/* * Grapht, an open source dependency injector. * Copyright 2014-2015 various contributors (see CONTRIBUTORS.txt) * Copyright 2010-2014 Regents of the University of Minnesota * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., 51 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ package org.grouplens.grapht.reflect.internal; import org.apache.commons.lang3.builder.EqualsBuilder; import org.apache.commons.lang3.builder.HashCodeBuilder; import org.grouplens.grapht.reflect.Desires; import org.grouplens.grapht.reflect.InjectionPoint; import org.grouplens.grapht.util.ClassProxy; import org.grouplens.grapht.util.Preconditions; import javax.annotation.Nonnull; import javax.annotation.Nullable; import java.io.InvalidObjectException; import java.io.ObjectInputStream; import java.io.ObjectStreamException; import java.io.Serializable; import java.lang.annotation.Annotation; import java.lang.reflect.Member; import java.util.Collection; import java.util.Collections; /** * Synthetic injection point used for {@link Desires#create(java.lang.annotation.Annotation, Class, boolean)}. * * @author <a href="http://grouplens.org">GroupLens Research</a> */ public final class SimpleInjectionPoint implements InjectionPoint, Serializable { private static final long serialVersionUID = -1L; // fields marked as transient since direct serialization is disabled private final transient Annotation qualifier; private final transient Class<?> type; private final transient boolean nullable; public SimpleInjectionPoint(@Nullable Annotation qualifier, Class<?> type, boolean nullable) { Preconditions.notNull("type", type); if (qualifier != null) { Preconditions.isQualifier(qualifier.annotationType()); } this.qualifier = qualifier; this.type = type; this.nullable = nullable; } @Override public Class<?> getErasedType() { return type; } @Override public Member getMember() { return null; } @Override public boolean isNullable() { return nullable; } @Override public Class<?> getType() { return type; } @Nullable @Override public Annotation getQualifier() { return qualifier; } @Nullable @Override public <A extends Annotation> A getAttribute(Class<A> atype) { return null; } @Nonnull @Override public Collection<Annotation> getAttributes() { return Collections.emptyList(); } @Override public int hashCode() { return new HashCodeBuilder().append(type).append(qualifier).toHashCode(); } @Override public boolean equals(Object o) { if (!(o instanceof SimpleInjectionPoint)) { return false; } SimpleInjectionPoint p = (SimpleInjectionPoint) o; EqualsBuilder eqb = new EqualsBuilder(); return eqb.append(type, p.type).append(qualifier, p.qualifier).append(nullable, p.nullable).isEquals(); } @Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("synthetic "); if (qualifier != null) { sb.append(qualifier).append(" "); } return sb.append(type.getName()).toString(); } private Object writeReplace() { return new SerialProxy(type, nullable, qualifier); } private void readObject(ObjectInputStream stream) throws InvalidObjectException { throw new InvalidObjectException("Serialization proxy required"); } /** * Serialization proxy for the Serialization Proxy Pattern. */ private static class SerialProxy implements Serializable { private static final long serialVersionUID = 1L; private ClassProxy type; private boolean nullable; @Nullable @SuppressWarnings("squid:S1948") // serializable - annotations are serializable private Annotation qualifier; private SerialProxy(Class<?> t, boolean isNullable, @Nullable Annotation qual) { type = ClassProxy.of(t); nullable = isNullable; qualifier = qual; } public Object readResolve() throws ObjectStreamException { try { return Desires.createInjectionPoint(qualifier, type.resolve(), nullable); } catch (ClassNotFoundException e) { InvalidObjectException ex = new InvalidObjectException( "cannot resolve class " + type.getClassName()); ex.initCause(e); throw ex; } } } }