woggioni/wdi
1
0
Fork 0
Code Actions Packages Releases Activity

initial commit

Browse Source
This commit is contained in:
Walter Oggioni
2021-04-07 21:40:57 +02:00
commit 3312341b17
21 changed files with 1138 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
.gitattributes vendored Normal file
View File

@@ -0,0 +1,6 @@
#
# https://help.github.com/articles/dealing-with-line-endings/
#
# These are explicitly windows files and should use crlf
*.bat text eol=crlf

5
.gitignore vendored Normal file
View File

@@ -0,0 +1,5 @@
# Ignore Gradle project-specific cache directory
.gradle
# Ignore Gradle build output directory
build

38
build.gradle Normal file
View File

@@ -0,0 +1,38 @@
plugins {
id 'java-library'
}
group = "net.woggioni"
repositories {
mavenLocal()
mavenCentral()
jcenter()
}
dependencies {
compileOnly group: "org.projectlombok", name: "lombok", version: lombokVersion
annotationProcessor group: "org.projectlombok", name: "lombok", version: lombokVersion
implementation group: 'net.woggioni', name: 'jwo', version: jwoVersion
testCompileOnly group: "org.projectlombok", name: "lombok", version: lombokVersion
testAnnotationProcessor group: "org.projectlombok", name: "lombok", version: lombokVersion
testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: junitJupiterVersion
testRuntimeOnly group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: junitJupiterVersion
}
java {
modularity.inferModulePath = true
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
}
compileTestJava {
options.compilerArgs << '-parameters'
}
test {
useJUnitPlatform()
}

4
gradle.properties Normal file
View File

@@ -0,0 +1,4 @@
jwoVersion=1.0
junitJupiterVersion=5.7.0
lombokVersion=1.18.16
slf4jVersion=1.7.30

BIN
gradle/wrapper/gradle-wrapper.jar vendored Normal file
View File

Binary file not shown.

5
gradle/wrapper/gradle-wrapper.properties vendored Normal file
View File

@@ -0,0 +1,5 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.1-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

185
gradlew vendored Executable file
View File

@@ -0,0 +1,185 @@
#!/usr/bin/env sh
#
# Copyright 2015 the original author or authors.
#
# Licensed 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
#
# https://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.
#
##############################################################################
##
## Gradle start up script for UN*X
##
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG=`dirname "$PRG"`"/$link"
fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >/dev/null
APP_HOME="`pwd -P`"
cd "$SAVED" >/dev/null
APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
warn () {
echo "$*"
}
die () {
echo
echo "$*"
echo
exit 1
}
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "`uname`" in
CYGWIN* )
cygwin=true
;;
Darwin* )
darwin=true
;;
MINGW* )
msys=true
;;
NONSTOP* )
nonstop=true
;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java"
else
JAVACMD="$JAVA_HOME/bin/java"
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD="java"
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
MAX_FD_LIMIT=`ulimit -H -n`
if [ $? -eq 0 ] ; then
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
MAX_FD="$MAX_FD_LIMIT"
fi
ulimit -n $MAX_FD
if [ $? -ne 0 ] ; then
warn "Could not set maximum file descriptor limit: $MAX_FD"
fi
else
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
fi
fi
# For Darwin, add options to specify how the application appears in the dock
if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi
# For Cygwin or MSYS, switch paths to Windows format before running java
if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
JAVACMD=`cygpath --unix "$JAVACMD"`
# We build the pattern for arguments to be converted via cygpath
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
SEP=""
for dir in $ROOTDIRSRAW ; do
ROOTDIRS="$ROOTDIRS$SEP$dir"
SEP="|"
done
OURCYGPATTERN="(^($ROOTDIRS))"
# Add a user-defined pattern to the cygpath arguments
if [ "$GRADLE_CYGPATTERN" != "" ] ; then
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
fi
# Now convert the arguments - kludge to limit ourselves to /bin/sh
i=0
for arg in "$@" ; do
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
else
eval `echo args$i`="\"$arg\""
fi
i=`expr $i + 1`
done
case $i in
0) set -- ;;
1) set -- "$args0" ;;
2) set -- "$args0" "$args1" ;;
3) set -- "$args0" "$args1" "$args2" ;;
4) set -- "$args0" "$args1" "$args2" "$args3" ;;
5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
esac
fi
# Escape application args
save () {
for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
echo " "
}
APP_ARGS=`save "$@"`
# Collect all arguments for the java command, following the shell quoting and substitution rules
eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
exec "$JAVACMD" "$@"

89
gradlew.bat vendored Normal file
View File

@@ -0,0 +1,89 @@
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto execute
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto execute
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega

1
settings.gradle Normal file
View File

@@ -0,0 +1 @@
rootProject.name = 'wdi'

18
src/main/java/net/woggioni/wdi/api/Bean.java Normal file
View File

@@ -0,0 +1,18 @@
package net.woggioni.wdi.api;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface Bean {
enum Scope {
Singleton, Prototype
}
String name() default "";
Scope scope() default Scope.Singleton;
}

13
src/main/java/net/woggioni/wdi/api/BeanClasses.java Normal file
View File

@@ -0,0 +1,13 @@
package net.woggioni.wdi.api;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface BeanClasses {
Class<?>[] value() default {};
}

11
src/main/java/net/woggioni/wdi/api/BeanConfigurationException.java Normal file
View File

@@ -0,0 +1,11 @@
package net.woggioni.wdi.api;
public class BeanConfigurationException extends RuntimeException {
public BeanConfigurationException(String msg) {
super(msg);
}
public BeanConfigurationException(String msg, Throwable cause) {
super(msg, cause);
}
}

244
src/main/java/net/woggioni/wdi/api/BeanContainer.java Normal file
View File

@@ -0,0 +1,244 @@
package net.woggioni.wdi.api;
import lombok.AccessLevel;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import net.woggioni.jwo.CollectionUtils;
import net.woggioni.jwo.JWO;
import net.woggioni.jwo.tuple.Tuple2;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.util.*;
import java.util.function.BiConsumer;
@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
public class BeanContainer {
private final Map<Executable, Object> singletonCache;
private final NavigableMap<BeanSpec, Executable> bom;
@RequiredArgsConstructor
private static class ConstructorList {
final Iterable<Map.Entry<BeanSpec, Executable>> allBeans;
final Iterable<Class<? extends BeanFactory>> beanFactories;
}
@SneakyThrows
public static BeanContainer with(Class<? extends BeanFactory> beanFactoryClass) {
try {
return with(beanFactoryClass.getConstructor().newInstance());
} catch (NoSuchMethodException | IllegalAccessException ex) {
throw JWO.newThrowable(BeanConfigurationException.class,
"Bean factory class '%s' is required to have a public zero arguments constructor", beanFactoryClass.getName());
}
}
public static BeanContainer with(BeanFactory root) {
Map<Executable, Object> singletonCache = new HashMap<>();
NavigableMap<BeanSpec, Executable> bom = new TreeMap<>(BeanSpec.specComparator);
List<BeanFactory> stack = new ArrayList<>();
stack.add(root);
while(!stack.isEmpty()) {
ConstructorList constructorList = computeBom(JWO.pop(stack));
for(Map.Entry<BeanSpec, Executable> entry : constructorList.allBeans) {
bom.putIfAbsent(entry.getKey(), entry.getValue());
}
for(Class<? extends BeanFactory> beanFactoryClass : constructorList.beanFactories) {
BeanFactory beanFactory = getBean(singletonCache, bom, beanFactoryClass, null, BeanSpec.emptyQualifier);
stack.add(beanFactory);
}
}
return new BeanContainer(singletonCache, Collections.unmodifiableNavigableMap(bom));
}
@SneakyThrows
private static ConstructorList computeBom(BeanFactory beanFactory) {
Class<? extends BeanFactory> beanFactoryClass = beanFactory.getClass();
List<Map.Entry<BeanSpec, Executable>> allBeans = new ArrayList<>();
List<Class<? extends BeanFactory>> beanFactories = new ArrayList<>();
BiConsumer<BeanSpec, Executable> add2ResultList = (BeanSpec beanSpec, Executable executable) -> {
Map.Entry<BeanSpec, Executable> entry = new AbstractMap.SimpleEntry<>(beanSpec, executable);
allBeans.add(entry);
Class<?> cls = beanSpec.getCls();
if(BeanFactory.class.isAssignableFrom(cls) && cls != beanFactoryClass) {
beanFactories.add((Class<? extends BeanFactory>) beanSpec.getCls());
}
Iterator<Class<?>> it = new ParentIterator(cls);
while(it.hasNext()) {
Class<?> superClass = it.next();
entry = new AbstractMap.SimpleEntry<>(
new BeanSpec(superClass, beanSpec.getName(), beanSpec.getQualifiers()), executable);
allBeans.add(entry);
}
};
for(Method method : beanFactoryClass.getMethods()) {
Bean bean = method.getAnnotation(Bean.class);
if(bean != null) {
String name = bean.name();
if(name.isEmpty()) name = JWO.decapitalize(method.getName());
add2ResultList.accept(new BeanSpec(method.getReturnType(), name, extractQualifiers(method)), method);
}
}
List<Class<?>> classes = new ArrayList<>();
classes.add(beanFactoryClass);
for(Class<?> cls : beanFactory.getClasses()) classes.add(cls);
BeanClasses beanClasses = beanFactoryClass.getAnnotation(BeanClasses.class);
if(beanClasses != null) {
for(Class<?> cls : beanClasses.value()) classes.add(cls);
}
Import imports = beanFactoryClass.getAnnotation(Import.class);
if(imports != null) {
for(Class<?> cls : imports.value()) classes.add(cls);
}
for(Class<?> cls : classes) {
Constructor<?>[] constructors = cls.getConstructors();
if(constructors.length == 1) {
BeanSpec spec = new BeanSpec(
cls,
JWO.decapitalize(cls.getSimpleName()),
extractQualifiers(constructors[0])
);
add2ResultList.accept(spec, constructors[0]);
} else {
List<Constructor<?>> annotatedConstructors = new ArrayList<>();
for(Constructor<?> constructor : constructors) {
if(constructor.getAnnotation(Bean.class) != null)
annotatedConstructors.add(constructor);
}
if(annotatedConstructors.isEmpty()) {
throw JWO.newThrowable(BeanConfigurationException.class, "Class '%s' has multiple constructors," +
" but none of them is annotated with %s", cls.getName(), Bean.class.getName());
} else {
for(Constructor<?> annotatedConstructor : annotatedConstructors) {
String name = annotatedConstructor.getAnnotation(Bean.class).name();
if(name.isEmpty()) name = JWO.decapitalize(annotatedConstructor.getName());
BeanSpec spec = new BeanSpec(cls, name, extractQualifiers(annotatedConstructor));
add2ResultList.accept(spec, annotatedConstructor);
}
}
}
}
return new ConstructorList(allBeans, beanFactories);
}
private static NavigableSet<Annotation> extractQualifiers(AnnotatedElement annotatedElement) {
NavigableSet<Annotation> result = new TreeSet<>(BeanSpec.annotationComparator);
for(Annotation methodAnnotation : annotatedElement.getAnnotations()) {
for(Annotation annotationAnnotation : methodAnnotation.annotationType().getAnnotations()) {
if(annotationAnnotation instanceof Qualifier) {
result.add(methodAnnotation);
break;
}
}
}
return Collections.unmodifiableNavigableSet(result);
}
private static Tuple2<BeanSpec, Boolean> analyzeInjectionPoint(Parameter parameter) {
String name;
boolean strictName;
{
String beanName = Optional.ofNullable(parameter.getAnnotation(Bean.class)).map(Bean::name).orElse("");
if(!beanName.isEmpty()) {
name = beanName;
strictName = true;
} else {
if(parameter.isNamePresent()) {
name = parameter.getName();
} else {
name = "";
}
strictName = false;
}
}
return new Tuple2<>(new BeanSpec(parameter.getType(), name, extractQualifiers(parameter)), strictName);
}
@SneakyThrows
private static Object getBean(
Map<Executable, Object> singletonCache,
NavigableMap<BeanSpec, Executable> bom,
BeanSpec spec, boolean strictName) {
List<Map.Entry<BeanSpec, Executable>> candidatesFactoryMethods = new ArrayList<>();
if(bom.containsKey(spec)) candidatesFactoryMethods.add(bom.floorEntry(spec));
else {
BeanSpec head = new BeanSpec(spec.getCls(), "", BeanSpec.emptyQualifier);
for (Map.Entry<BeanSpec, Executable> entry : bom.tailMap(head, true).entrySet()) {
BeanSpec key = entry.getKey();
if (key.getCls() == spec.getCls()) {
key.getQualifiers().containsAll(spec.getQualifiers());
if ((!strictName || Objects.equals(key.getName(), spec.getName())) &&
key.getQualifiers().containsAll(spec.getQualifiers())) {
candidatesFactoryMethods.add(entry);
}
} else break;
}
}
Executable executable;
if(candidatesFactoryMethods.isEmpty())
throw JWO.newThrowable(BeanConfigurationException.class, "No bean found for %s", spec);
else if(candidatesFactoryMethods.size() > 1) {
if(!strictName) {
executable = candidatesFactoryMethods.get(0).getValue();
for(Map.Entry<BeanSpec, Executable> entry : candidatesFactoryMethods) {
if(Objects.equals(entry.getKey().getName(), spec.getName())) {
executable = entry.getValue();
break;
}
}
} else throw JWO.newThrowable(BeanConfigurationException.class, "Multiple candidates found matching %s", spec);
} else {
executable = candidatesFactoryMethods.get(0).getValue();
}
Object result = singletonCache.get(executable);
if(result == null) {
List<Object> executableParameters = new ArrayList<>();
for(Parameter parameter : executable.getParameters()) {
Tuple2<BeanSpec, Boolean> tuple = analyzeInjectionPoint(parameter);
executableParameters.add(getBean(singletonCache, bom, tuple._1, tuple._2));
}
if(executable instanceof Constructor) {
result = ((Constructor<?>) executable).newInstance(executableParameters.toArray());
} else if(executable instanceof Method) {
if(Modifier.isStatic(executable.getModifiers())) {
result = ((Method) executable).invoke(null, executableParameters.toArray());
} else {
Object instance = getBean(singletonCache, bom,
new BeanSpec(
executable.getDeclaringClass(),
"",
BeanSpec.emptyQualifier), false);
result = ((Method) executable).invoke(instance, executableParameters.toArray());
}
}
else throw new IllegalStateException();
singletonCache.put(executable, result);
}
return result;
}
private static <T> T getBean(Map<Executable, Object> singletonCache,
NavigableMap<BeanSpec, Executable> bom,
Class<T> cls,
String name,
NavigableSet<Annotation> qualifiers) {
return (T) getBean(singletonCache, bom, new BeanSpec(cls, name == null ? "" : name, qualifiers), name != null);
}
public <T> T getBean(Class<T> cls, String name, Annotation ...qualifiers) {
return (T) getBean(singletonCache, bom,
new BeanSpec(cls, name == null ? "" : name,
Arrays.stream(qualifiers).collect(CollectionUtils.toUnmodifiableTreeSet(BeanSpec.annotationComparator))),
name != null);
}
public <T> T getBean(Class<T> cls) {
return getBean(cls, null);
}
}

9
src/main/java/net/woggioni/wdi/api/BeanFactory.java Normal file
View File

@@ -0,0 +1,9 @@
package net.woggioni.wdi.api;
import java.util.Collections;
public interface BeanFactory {
default Iterable<Class<?>> getClasses() {
return Collections.emptyList();
}
}

52
src/main/java/net/woggioni/wdi/api/BeanSpec.java Normal file
View File

@@ -0,0 +1,52 @@
package net.woggioni.wdi.api;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import net.woggioni.jwo.collection.LexicographicIterableComparator;
import java.lang.annotation.Annotation;
import java.util.Collections;
import java.util.Comparator;
import java.util.NavigableSet;
import java.util.Objects;
import java.util.stream.Collectors;
@RequiredArgsConstructor
class BeanSpec {
@Getter
private final Class<?> cls;
@Getter
private final String name;
@Getter
private final NavigableSet<Annotation> qualifiers;
@Override
public String toString() {
return String.format("{class: %s, name: '%s', qualifiers: [%s]}",
cls.getName(), name,
qualifiers.stream()
.map(Annotation::getClass)
.map(Class::getName)
.collect(Collectors.joining(", ")));
}
public static Comparator<Annotation> annotationComparator =
Comparator.<Annotation, String>comparing(it -> it.getClass().getName())
.thenComparing(Annotation::hashCode)
.thenComparing((ann1, ann2) -> {
if(Objects.equals(ann1, ann2)) return 0;
else {
return Integer.compare(System.identityHashCode(ann1), System.identityHashCode(ann2));
}
});
public static Comparator<Class<?>> classComparator = Comparator.comparing(Class::getName);
public static Comparator<BeanSpec> specComparator = Comparator.comparing(BeanSpec::getCls, classComparator)
.thenComparing(BeanSpec::getQualifiers,
new LexicographicIterableComparator<>(annotationComparator))
.thenComparing(BeanSpec::getName);
public static NavigableSet<Annotation> emptyQualifier = Collections.emptyNavigableSet();
}

13
src/main/java/net/woggioni/wdi/api/Import.java Normal file
View File

@@ -0,0 +1,13 @@
package net.woggioni.wdi.api;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Import {
Class<? extends BeanFactory>[] value() default {};
}

62
src/main/java/net/woggioni/wdi/api/ParentIterator.java Normal file
View File

@@ -0,0 +1,62 @@
package net.woggioni.wdi.api;
import net.woggioni.jwo.JWO;
import java.util.*;
class ParentIterator implements Iterator<Class<?>> {
static Class<?>[] superClasses(Class<?> cls) {
Class<?>[] interfaces = cls.getInterfaces();
Class<?>[] result;
int i = 0;
Class<?> superclass = cls.getSuperclass();
if(superclass != null) {
result = new Class<?>[interfaces.length + 1];
result[i++] = superclass;
} else {
result = new Class<?>[interfaces.length ];
}
System.arraycopy(interfaces, 0, result, i, interfaces.length);
return result;
}
private final List<Iterator<Class<?>>> stack;
private final Set<Class<?>> resultCache;
private Class<?> nextValue;
ParentIterator(Class<?> cls) {
stack = new ArrayList<>();
stack.add(JWO.iterator(superClasses(cls)));
resultCache = new HashSet<>();
nextValue = computeNext();
}
private Class<?> computeNext() {
while(!stack.isEmpty()) {
Iterator<Class<?>> last = JWO.tail(stack);
if (last.hasNext()) {
Class<?> next = last.next();
if(resultCache.add(next)) {
stack.add(JWO.iterator(superClasses(next)));
return next;
}
} else {
JWO.pop(stack);
}
}
return null;
}
@Override
public boolean hasNext() {
return nextValue != null;
}
@Override
public Class<?> next() {
Class<?> result = nextValue;
nextValue = computeNext();
return result;
}
}

12
src/main/java/net/woggioni/wdi/api/Qualifier.java Normal file
View File

@@ -0,0 +1,12 @@
package net.woggioni.wdi.api;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Qualifier {
}

11
src/main/java/net/woggioni/wdi/api/Startup.java Normal file
View File

@@ -0,0 +1,11 @@
package net.woggioni.wdi.api;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Startup {
}

330
src/test/java/net/woggioni/wdi/api/BeanContainerTest.java Normal file
View File

@@ -0,0 +1,330 @@
package net.woggioni.wdi.api;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.Arrays;
import java.util.List;
public class BeanContainerTest {
public static class Test1 {
@RequiredArgsConstructor
public static class Foo {
public final String s;
}
public static class Configuration implements BeanFactory {
@Override
public List<Class<?>> getClasses() {
return Arrays.asList(Foo.class);
}
@Bean
public String bar() {
return "bar";
}
}
@Test
public void test() {
BeanContainer container = BeanContainer.with(Configuration.class);
Foo foo = container.getBean(Foo.class);
System.out.println(foo.s);
}
}
public static class Test2 {
public static class Foo {}
@RequiredArgsConstructor
public static class Bar {
public final Foo foo;
}
public static class Configuration implements BeanFactory {
@Override
public List<Class<?>> getClasses() {
return Arrays.asList(Foo.class);
}
@Bean
public Bar bar(Foo foo) {
return new Bar(foo);
}
}
@Test
public void test() {
BeanContainer container = BeanContainer.with(Configuration.class);
Foo foo = container.getBean(Foo.class);
Bar bar = container.getBean(Bar.class);
Assertions.assertSame(foo, bar.foo);
}
}
public static class Test3 {
public static class Foo {}
@RequiredArgsConstructor
public static class Bar {
public final Foo foo;
}
@BeanClasses(Foo.class)
public static class Configuration implements BeanFactory {
@Bean
public Bar bar(Foo foo) {
return new Bar(foo);
}
}
@Test
public void test() {
BeanContainer container = BeanContainer.with(Configuration.class);
Foo foo = container.getBean(Foo.class);
Bar bar = container.getBean(Bar.class);
Assertions.assertSame(foo, bar.foo);
}
}
public static class Test4 {
public static class Foo {}
@RequiredArgsConstructor
public static class Bar {
public final Foo foo;
}
@Import(AnotherConfiguration.class)
public static class Configuration implements BeanFactory {
@Bean
public Bar bar(Foo foo) {
return new Bar(foo);
}
}
@BeanClasses(Foo.class)
public static class AnotherConfiguration implements BeanFactory { }
@Test
public void test() {
BeanContainer container = BeanContainer.with(Configuration.class);
Foo foo = container.getBean(Foo.class);
Bar bar = container.getBean(Bar.class);
Assertions.assertSame(foo, bar.foo);
}
}
public static class Test5 {
@RequiredArgsConstructor
public static class Person {
final String name;
final String surname;
final int age;
}
@RequiredArgsConstructor
public static class People {
final Person bob;
final Person john;
}
public static class People2 {
public People2(@Bean(name = "bob") Person p1, @Bean(name = "john") Person p2) {
this.bob = p1;
this.john = p2;
}
final Person bob;
final Person john;
}
public static class People3 {
public People3(Person bob, Person john) {
this.bob = bob;
this.john = john;
}
final Person bob;
final Person john;
}
@BeanClasses({People.class, People2.class, People3.class})
public static class Configuration implements BeanFactory {
@Bean
public Person bob() {
return new Person("Bob", "Kennedy", 42);
}
@Bean
public Person john() {
return new Person("John", "Kennedy", 46);
}
}
@Test
public void test() {
BeanContainer container = BeanContainer.with(Configuration.class);
Person bob = container.getBean(Person.class, "bob");
Person john = container.getBean(Person.class, "john");
Assertions.assertEquals("Bob", bob.name);
Assertions.assertEquals("John", john.name);
People people = container.getBean(People.class);
Assertions.assertSame(people.bob, bob);
Assertions.assertSame(people.john, john);
People2 people2 = container.getBean(People2.class);
Assertions.assertSame(people2.bob, bob);
Assertions.assertSame(people2.john, john);
People3 people3 = container.getBean(People3.class);
Assertions.assertSame(people3.bob, bob);
Assertions.assertSame(people3.john, john);
}
}
public static class Test6 {
@Qualifier
@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Bob {}
@Qualifier
@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface John {}
@RequiredArgsConstructor
public static class Person {
final String name;
final String surname;
final int age;
}
public static class People {
public People(@Bob Person p1, @John Person p2) {
this.bob = p1;
this.john = p2;
}
final Person bob;
final Person john;
}
@BeanClasses(People.class)
public static class Configuration implements BeanFactory {
@Bean
@Bob
public Person bob() {
return new Person("Bob", "Kennedy", 42);
}
@John
@Bean
public Person john() {
return new Person("John", "Kennedy", 46);
}
}
@Test
@Bob
@John
@SneakyThrows
public void test() {
BeanContainer container = BeanContainer.with(Configuration.class);
Bob b = Configuration.class.getMethod("bob").getAnnotation(Bob.class);
Person bob = container.getBean(Person.class, null, b);
John j = Configuration.class.getMethod("john").getAnnotation(John.class);
Person john = container.getBean(Person.class, null, j);
Assertions.assertEquals("Bob", bob.name);
Assertions.assertEquals("John", john.name);
People people = container.getBean(People.class);
Assertions.assertSame(people.bob, bob);
Assertions.assertSame(people.john, john);
}
}
public static class Test7 {
@Qualifier
@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Named {
String name() default "";
}
@RequiredArgsConstructor
public static class Person {
final String name;
final String surname;
final int age;
}
public static class People {
public People(@Named(name = "bob") Person p1, @Named(name = "john") Person p2) {
this.bob = p1;
this.john = p2;
}
final Person bob;
final Person john;
}
@BeanClasses({People.class})
public static class Configuration implements BeanFactory {
@Bean
@Named(name = "bob")
public Person bob() {
return new Person("Bob", "Kennedy", 42);
}
@Bean
@Named(name = "john")
public Person john() {
return new Person("John", "Kennedy", 46);
}
}
@Test
@SneakyThrows
public void test() {
BeanContainer container = BeanContainer.with(Configuration.class);
Named b = Configuration.class.getMethod("bob").getAnnotation(Named.class);
Named j = Configuration.class.getMethod("john").getAnnotation(Named.class);
Person bob = container.getBean(Person.class, null, b);
Person john = container.getBean(Person.class, null, j);
Assertions.assertEquals("Bob", bob.name);
Assertions.assertEquals("John", john.name);
People people = container.getBean(People.class);
Assertions.assertSame(people.bob, bob);
Assertions.assertSame(people.john, john);
}
}
}

30
src/test/java/net/woggioni/wdi/api/ParentIteratorTest.java Normal file
View File

@@ -0,0 +1,30 @@
package net.woggioni.wdi.api;
import net.woggioni.jwo.CollectionUtils;
import net.woggioni.jwo.JWO;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class ParentIteratorTest {
@Test
public void test() {
List<Class<?>> expectedClasses = CollectionUtils.immutableList(
java.util.AbstractList.class,
java.util.AbstractCollection.class,
Object.class,
java.util.Collection.class,
java.lang.Iterable.class,
java.util.List.class,
java.util.RandomAccess.class,
java.lang.Cloneable.class,
java.io.Serializable.class
);
Assertions.assertEquals(expectedClasses,
JWO.iterator2Stream(new ParentIterator(ArrayList.class)).collect(Collectors.toList()));
}
}