A fast and very lightweight dependency injection library for Java 8+

<h2>Basic Usage</h2>
So now we know what the <code>@Inject</code> does:
<ul>
<li>In a field: declares that the field is a dependency that must be set</li>
<li>In constructors and methods: declares that the parameters are dependencies that must be provided</li>
</ul>
<h3>Declaration</h3>
Using the <code>@Inject</code> annotation we can declare dependencies, e.g.
<pre><code class="hljs language-java">public class ItemDao {
 
 @Inject private Database database;
 @Inject private Configuration configuration;
 
 // ...
 
}
</code></pre>
However, the declaration does nothing, we must process it
<h3>Processing</h3>
When you declare a dependency on some class, like <code>@Inject private Database database</code>,
the dependency is processed when the class is processed, so it is not necessary to manually
process them all.
As we said, the dependencies of an object will be processed together with it, but, we need to
manually process an initial object, the entry point
To do this, we must create an <code>Injector</code> and optionally configure it (we will explain this later)
<pre><code class="hljs language-java">public class Main {
 
 @Inject private Server server;
 
 public void start() {
 server.start();
 }
 
 public static void main(String[] args) {
 Injector injector = Injector.create();
 // here we manually tell the injector to instantiate
 // our Main class that declares a dependency on the
 // Server class, our Injector is smart and will instantiate
 // and set it too
 Main main = injector.getInstance(Main.class);
 main.start();
 
 // We can alternatively do:
 Main main = new Main();
 injector.injectMembers(main);
 main.start();
 // however, the Injector does not know about the Main
 // constructor, and it will not process it so injections
 // there will not work. It will just inject fields and methods
 }
 
}
</code></pre>
In this case, the injector will instantiate both <code>Main</code> and <code>Server</code>
using the default constructor, but what if we need more? what if Server
is an interface? how do we bind the interface to an implementation?
See <a href="/docs/inject/config/injector-configuration">Injector Configuration</a>

Basic Usage

<h2>Dependency Injection</h2>
Dependency injection (<a href="https://en.wikipedia.org/wiki/Dependency_injection">Wikipedia</a>) is an
OOP design pattern where classes declare their dependencies as arguments instead of directly
creating them.
This pattern lets us easily create flexible and testable objects, following the
<a href="https://en.wikipedia.org/wiki/Liskov_substitution_principle">Liskov Substitution Principle</a>
<h3>Without Dependency Injection</h3>
Here is an example where we do not use dependency injection:
<pre><code class="hljs language-java">public class UserDao {
 
 private final Database database = new SQLiteDatabase("/myfile.dat");
 
 // ...
 
}
</code></pre>
In this example, you can't replace the database implementation or file path, which
makes it hard to test and re-use
<h3>With Dependency Injection</h3>
Here is an example where we do use dependency injection:
<pre><code class="hljs language-java">public class UserDao {
 
 private final Database database;
 
 public UserDao(Database database) {
 this.database = database;
 }
 
 // ...
 
}
</code></pre>
In this example, we can set any database implementation, so it is testable
and re-usable
<h3>With unnamed/inject</h3>
Here is an example that uses dependency injection with <code>unnamed/inject</code>
<pre><code class="hljs language-java">import team.unnamed.inject.Inject;

public class UserDao {
 
 @Inject private Database database;
 
}
</code></pre>
In this example, we just declare a dependency using the <code>@Inject</code> annotation
instead of as an argument in a constructor. However, the <code>@Inject</code> annotation is
not magic and this will not work using <code>new UserDao()</code> since the object is
not processed.

Dependency Injection

<h2>Getting Started</h2>
Welcome to the <code>inject</code> documentation
<code>unnamed/inject</code> is a zero-dependency, lightweight and fast runtime dependency
injection library for Java 8+
<h3>Features</h3>
<ul>
<li>Known and easy to use DSL (domain specific language) to configure bindings</li>
<li>Potentially increase your programming productivity, you don't have to worry
about manually injecting dependencies</li>
<li>Out of the box support for features like multibinding and assisted inject</li>
</ul>

Getting Started

<h2>Installation</h2>
You can add <code>inject</code> to your project using <a href="https://gradle.org/">Gradle</a> (recommended),
<a href="https://maven.apache.org/">Maven</a> or manually downloading the JAR files from
<a href="https://github.com/unnamed/inject/releases">GitHub Releases</a>.
Also note that <code>inject</code> is available from the <a href="https://search.maven.org/artifact/team.unnamed/inject">Maven Central Repository</a>
so you can use it in your project without adding any repository!
<h3>Gradle</h3>
Add the dependency
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:inject:2.0.1")
}
</code></pre>
<h3>Maven</h3>
Add the dependency
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>inject&#x3C;/artifactId>
 &#x3C;version>2.0.1&#x3C;/version>
&#x3C;/dependency>
</code></pre>

Installation

<h2>Dependency Injection</h2>
Dependency injection (<a href="https://en.wikipedia.org/wiki/Dependency_injection">Wikipedia</a>) is an
OOP design pattern where classes declare their dependencies as arguments instead of directly
creating them.
This pattern lets us easily create flexible and testable objects, following the
<a href="https://en.wikipedia.org/wiki/Liskov_substitution_principle">Liskov Substitution Principle</a>
<h3>Without Dependency Injection</h3>
Here is an example where we do not use dependency injection:
<pre><code class="hljs language-java">public class UserDao {
 
 private final Database database = new SQLiteDatabase("/myfile.dat");
 
 // ...
 
}
</code></pre>
In this example, you can't replace the database implementation or file path, which
makes it hard to test and re-use
<h3>With Dependency Injection</h3>
Here is an example where we do use dependency injection:
<pre><code class="hljs language-java">public class UserDao {
 
 private final Database database;
 
 public FileReader(Database database) {
 this.database = database;
 }
 
 // ...
 
}
</code></pre>
In this example, we can set any database implementation, so it is testable
and re-usable
<h3>With unnamed/inject</h3>
Here is an example that uses dependency injection with <code>unnamed/inject</code>
<pre><code class="hljs language-java">import team.unnamed.inject.Inject;

public class UserDao {
 
 @Inject private Database database;
 
}
</code></pre>
In this example, we just declare a dependency using the <code>@Inject</code> annotation
instead of as an argument in a constructor. However, the <code>@Inject</code> annotation is
not magic and this will not work using <code>new UserDao()</code> since the object is
not processed.

<h2>Installation</h2>
You can add <code>inject</code> to your project using <a href="https://gradle.org/">Gradle</a> (recommended),
<a href="https://maven.apache.org/">Maven</a> or manually downloading the JAR files
<h3>Gradle</h3>
Add our repository
<pre><code class="hljs language-kotlin">repositories {
 maven("https://repo.unnamed.team/repository/unnamed-public/")
}
</code></pre>
Add the dependency
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:inject:2.0.0")
}
</code></pre>
<h3>Maven</h3>
Add our repository
<pre><code class="hljs language-xml">&#x3C;repository>
 &#x3C;id>unnamed-public&#x3C;/id>
 &#x3C;url>https://repo.unnamed.team/repository/unnamed-public/&#x3C;/url>
&#x3C;/repository>
</code></pre>
Add the dependency
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>inject&#x3C;/artifactId>
 &#x3C;version>2.0.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>