JAVA IOC
Certainly! Here's a more detailed example that combines various ways to use and configure IoC using Spring:
1. XML Configuration:
```xml
<!-- beans.xml -->
<beans>
<bean id="messageService" class="com.example.MessageService"/>
<bean id="notificationService" class="com.example.NotificationService">
<property name="messageService" ref="messageService"/>
</bean>
</beans>
```
In this example, we define two beans, `messageService` and `notificationService`, in an XML configuration file. The
`messageService` bean of class `com.example.MessageService` is created and injected into the `notificationService`
bean using the `ref` attribute.
2. Annotation-based Configuration:
```java
@Component
public class MessageService {
public void sendMessage(String message) {
System.out.println("Sending message: " + message);
}
}
```
```java
@Component
public class NotificationService {
private final MessageService messageService;
@Autowired
public NotificationService(MessageService messageService) {
this.messageService = messageService;
}
public void sendNotification(String message) {
messageService.sendMessage(message);
}
}
```
In this example, the `@Component` annotation is used to mark the `MessageService` and `NotificationService`
classes as Spring-managed beans. The `NotificationService` class has a dependency on the `MessageService`
interface, which is automatically injected using the `@Autowired` annotation.
3. Java-based Configuration:
```java
@Configuration
public class AppConfig {
@Bean
public MessageService messageService() {
return new MessageService();
}
@Bean
public NotificationService notificationService() {
return new NotificationService(messageService());
}
}
```
In this example, we define bean definitions using Java-based configuration. The `messageService` bean is created
and injected into the `notificationService` bean using the `messageService()` method.
4. Component Scanning:
```java
@Component
public class MessageService {
public void sendMessage(String message) {
System.out.println("Sending message: " + message);
}
}
```
```java
@Component
public class NotificationService {
private final MessageService messageService;
@Autowired
public NotificationService(MessageService messageService) {
this.messageService = messageService;
}
public void sendNotification(String message) {
messageService.sendMessage(message);
}
}
```
In this example, the `@Component` annotation is used to mark the `MessageService` and `NotificationService`
classes as Spring-managed beans. During component scanning, Spring will automatically detect and create instances
of these classes.
5. XML and Annotation Combination:
```xml
<!-- beans.xml -->
<beans>
<context:component-scan base-package="com.example"/>
</beans>
```
In this example, the XML configuration file specifies component scanning using the `context:component-scan`
element. It tells Spring to scan the `com.example` package for annotated beans.
6. Java-based and Annotation Combination:
```java
@Configuration
@ComponentScan("com.example")
public class AppConfig {
// Bean definitions and other configurations
}
```
In this example, the `@Configuration` annotation is used to mark the class as a configuration class. The
`@ComponentScan` annotation is used to specify the package to scan for annotated beans.
To run the application, you can create
a main class that loads the Spring application context:
```java
import org.springframework.context.ApplicationContext;
import
org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new
AnnotationConfigApplicationContext(AppConfig.class);
NotificationService notificationService =
context.getBean(NotificationService.class);
notificationService.sendNotification("Hello, Spring!");
}
}
```
In this example, we load the Spring application context using the `AnnotationConfigApplicationContext` class and
pass the `AppConfig` class as an argument. We then retrieve the `NotificationService` bean from the context and call
the `sendNotification()` method.
When you run the application, it will print "Sending message: Hello, Spring!" as the output, demonstrating the
successful wiring and invocation of the beans.
Please note that for the examples to work, you'll need to have the necessary dependencies in your Maven project,
such as `spring-context`, `spring-beans`, and `spring-core`.