https://github.com/zeldan/your-own-dependency-injection-framework
lightweight dependency injection framework example in java
https://github.com/zeldan/your-own-dependency-injection-framework
dependency-injection dependency-injection-framework java java-tutorial tutorial-code
Last synced: 3 months ago
JSON representation
lightweight dependency injection framework example in java
- Host: GitHub
- URL: https://github.com/zeldan/your-own-dependency-injection-framework
- Owner: zeldan
- License: apache-2.0
- Created: 2017-03-08T21:50:35.000Z (over 8 years ago)
- Default Branch: master
- Last Pushed: 2024-06-22T15:55:52.000Z (about 1 year ago)
- Last Synced: 2024-06-22T23:33:52.989Z (about 1 year ago)
- Topics: dependency-injection, dependency-injection-framework, java, java-tutorial, tutorial-code
- Language: Java
- Homepage:
- Size: 67.4 KB
- Stars: 23
- Watchers: 3
- Forks: 10
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# your-own-dependency-injection-framework
This is a small project that demonstrates how to build your own dependency injection framework.
It supports **constructor** and **field** injection.
- The framework itself can be found under the "com.di.framework" package.
- Sample applications are available under the tests.
### How to use
##### 1. Define how you want to map interfaces to their implementations.
```java
public class DependencyInjectionConfig extends AbstractModule {
@Override
public void configure() {
createMapping(GreetingService.class, WelcomeServiceImpl.class);
createMapping(Logger.class, QuietLoggerImpl.class);
}
}
```
##### 2. Add **@OwnInject** annotation to the constructor or fields.
```java
public class ConstructorInjectionClient {
private final GreetingService service;
private final Logger logger;
@OwnInject
public ConstructorInjectionClient(final GreetingService service, final Logger logger) {
this.service = service;
this.logger = logger;
}
}
```
OR
```java
public class FieldInjectionClient {
@OwnInject
private GreetingService service;
@OwnInject
private Logger logger;
}
```
##### 3. Use **OwnDi** to get your injected class.
```java
public class SampleAppToTryDependencyInjection {
public static void main(final String[] args) throws Exception {
final OwnDiFramework ownDi = OwnDi.getFramework(new DependencyInjectionConfig());
final ConstructorInjectionClient constructorInjectionClient = (ConstructorInjectionClient) ownDi.inject(ConstructorInjectionClient.class);
}
}
```
### How It Works
The two main classes are **AbstractModule** and **OwnDiFramework**.
* **AbstractModule** contains interfaces with their implementations (subclasses).
* **OwnDiFramework** performs the injection via Java reflection. It checks that the constructor or fields are annotated with the **@OwnInject** annotation.
### Running Tests
To execute tests, use the Maven Wrapper included in the project. Run the following command from the root directory of the project:
```sh
./mvnw test
```
This command will compile the project with Java 21 and run all the tests using JUnit.
If you encounter any issues or have any questions, please refer to the documentation or reach out for support.