> For the complete documentation index, see [llms.txt](https://ddozzi.gitbook.io/mixin-tutorial/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://ddozzi.gitbook.io/mixin-tutorial/how-to-make-a-mixin-client/5-or-injections.md).

# 5 | Injections

How to use and apply the @Inject annotation to your code. Also tells you how to read and write all the parameters housed inside the annotation.

### What is Inject?

The `@Inject` annotation injects code into a specified target method.

Parameters, in order:

* All target method parameters
* `CallbackInfo` (for `void` return type on target) or `CallbackInfoReturnable<R>`

Return type: `void`

Consider the following code:&#x20;

```java
 public void target() {
      Dummy.getInstance().dummy("foo");
 }
```

If we were to inject into it, we would use something like this:

```java
@Inject(method = "target()V", at = @At(value = "INVOKE", target = "Lnet/example/Dummy;dummy(Ljava/lang/String;)V"))
private void mixin(CallbackInfo ci) {
    injectedCode();
}
```

It might be a little hard to understand at first, so lets break it down.

```java
@Inject(
    method = "target()V",
    at = @At(value = "INVOKE", target = "Lnet/example/Dummy;dummy(Ljava/lang/String;)V")
)
```

The first parameter is `method` , it tells the mixin what method we're going to modify

Now for the `@At` statement:

* `value = "INVOKE"`&#x20;
  * This tells the mixin that we're looking for the invocation of the method.
* `target = "Lnet/example/Dummy;dummy()V")`
  * This tells the mixin where the method we're modifying is located

Now, lets break down the syntax of `"Lnet/example/Dummy;dummy()V"`&#x20;

The `L` represents a class name, so `Lnet/example/Dummy;` is the path to the class where the method `dummy` , is located.

The `dummy` represents the method name inside the `Dummy` class.

Inside the brackets, we see another class `(Ljava/lang/String;)`, this is the path to the `String` class, as `String` is actually a class, just one in the standard library, which doesn't need to be imported, everything inside these brackets are the parameters for `dummy`

Just after the brackets there is a `V`, which simply means `void` specifying that the `println` function doesn't return any value

The table below shows the different characters with their different meanings.

| *FieldType* term | Type       | Interpretation                                                                    |
| ---------------- | ---------- | --------------------------------------------------------------------------------- |
| B                | byte       | signed byte                                                                       |
| C                | char       | Unicode character code point in the Basic Multilingual Plane, encoded with UTF-16 |
| D                | double     | double-precision floating-point value                                             |
| F                | float      | single-precision floating-point value                                             |
| I                | int        | integer                                                                           |
| J                | long       | long integer                                                                      |
| L                | ClassName; | reference an instance of class ClassName                                          |
| S                | short      | signed short                                                                      |
| Z                | boolean    | true or false                                                                     |
| \[               | reference  | one array dimension                                                               |

[Read more](https://docs.oracle.com/javase/specs/jvms/se14/html/jvms-4.html#jvms-4.3.2)

### Inject, cancelable

Consider the following code:

```java
 public void target() {
      Dummy.getInstance().dummy("foo");
 }
```

Example mixin:

```java
@Inject(
    method = "target()V", 
    at = @At(value = "INVOKE", 
    target = "Lnet/example/Dummy;dummy(Ljava/lang/String;)V"), 
    cancellable = true
)
private void mixin(CallbackInfo ci) {
    if (condition) {
        ci.cancel();
    }
}
```

Lets dissect this; First, we start off with defining our method, in this case, it's `target()` then we define the `@At` statement, which houses our `value` and our `target`.

Oh, but what's that? It's the `cancellable` statement!&#x20;

The `cancellable` statement, can only be used at `TAIL` or `RETURN` . It's job is to inject code into a target method, and if `ci.cancel` is called, it returns after the mixin is done executing.

So, if we were to apply our mixin to our `target()` function, we would have a result similar, if not exactly like this:

```java
 public void target() {
      Dummy.getInstance().dummy();
      {
          boolean canceled = false;
          if (condition) {
              canceled = true;
          }
          if (canceled) return;
     }
  }
```

{% hint style="success" %}
Congrats! Now you hold the power of injecting code to your heart's content!
{% endhint %}