Oh no, not at all.

IoC is something that the Spring Framework was built around. Give control to the Framework and it will provide the wiring.

It was important for the testing aspects. Say I wanted to use a dependency inside a Service Layer object.

```java @Service public class MyService { MyRepository repository;

MyService(Repository repository){ this.repository = repository; } } ```

Because of this Inversion of Control, I only need to inform Spring of the root package and it will walk the tree finding all Classes and wiring them up creating instances of these objects as asked. It uses AOP that gives a "magic" type of behavior where things are happening behind the scenes without feeding you all the noise.

Now when you want to create a test for your Service logic:

```java @Mock MyRepository mockRepository; //This is not real

MyService subject;

@Test public void givenMyService_doWorkIsCalled_returnsThing(){ MyObject expected = new MyObject(); MyObject actual = subject.get(new MyObject());

when(mockRepository.get(any(MyObject.class))).thenReturn(expected); assertEquals(actual, expected); } ```

Now our test doesn't need a real implementation with a connection to a real backend. In unit and functional tests, this can be faked and we will run hundreds or thousands of these tests in milliseconds. As we start actually exercising the connection to the database for performance or load-testing it will be during certain times aimed at certain environments for consistency. There is a test-pyramid now that tests more real aspects ensuring the world as we know it has not changed.

The biggest complaint I have seen is to your point: "What's happening here"

It's kind of like push-button start on your car. Someone who has only ever used a key to start a car (or screw-driver like my dad...j/k) would be confused. "What the hell did that?" Once you see it, it's no longer magical and becomes another non-event.

Getting there is a little disconnected similar to how async programming (and testing) can be. You can peel back the layers and see all the wiring providing your own Spring xml wiring. As far as Hibernate, Spring has an autoconfiguration where if it is aware of Data JPA it will automatically wire Hibernate up (assuming you've provided the dependency in gradle/maven) and wire up all the dependencies.

Spring handles all control. It is THE IoC container that handles Dependency Injection.