ioc反转的是对象的控制权。传统开发中对象自己管理依赖，而ioc将对象创建和依赖管理交给外部容器，从而实现控制权的反转。ioc是一种设计原则，di是其具体实现方式，通过构造器、setter或接口注入依赖。java中依赖注入主要有三种方式：1.构造器注入，通过构造函数传递依赖，优点是依赖明确且不可变；2.setter注入，通过setter方法设置依赖，灵活性高但依赖关系可能不明确；3.接口注入，通过接口定义注入方法，解耦性好但实现复杂。ioc容器的核心原理是反射与配置，容器读取配置信息，利用反射创建bean并注入依赖，扮演“对象工厂”的角色。ioc解决了降低耦合度、提高可测试性、可维护性和可重用性等问题。ioc与aop是互补技术，ioc处理依赖关系，aop处理横切关注点，二者结合可构建更灵活的系统。
IoC（Inversion of Control，控制反转）是一种设计思想，简单来说就是将对象的控制权从自身转移到外部容器。依赖注入（Dependency Injection，DI）是实现IoC的一种方式，通过构造器、setter方法或接口将依赖关系注入到对象中。
IoC的核心在于“反转”，反转的是什么？是控制权。传统开发中，对象自己负责创建和管理依赖对象。IoC容器则接管了这个职责，它负责创建对象，并注入对象所需的依赖。
IoC和DI的区别？
IoC是一种原则，一种设计模式，而DI是实现IoC的具体手段。可以把IoC看作是目标，DI是达成目标的工具。所有的DI模式都实现了IoC，但并非所有的IoC实现方式都是DI。例如，服务定位器（Service Locator）也是一种IoC的实现方式，但它并不属于DI。
立即学习“Java免费学习笔记（深入）”；
如何用Java实现依赖注入？
Java中实现依赖注入主要有三种方式：
-
构造器注入（Constructor Injection）： 通过构造函数传递依赖对象。
public class UserService { private UserRepository userRepository; public UserService(UserRepository userRepository) { this.userRepository = userRepository; } public void createUser(String username, String password) { userRepository.save(new User(username, password)); } }这种方式的优点是依赖关系明确，对象创建后依赖不可变。
-
Setter方法注入（Setter Injection）： 通过setter方法设置依赖对象。
public class UserService { private UserRepository userRepository; public void setUserRepository(UserRepository userRepository) { this.userRepository = userRepository; } public void createUser(String username, String password) { userRepository.save(new User(username, password)); } }Setter注入的优点是灵活性高，可以选择性地注入依赖。缺点是依赖关系可能不明确，对象创建后依赖可能被修改。
-
接口注入（Interface Injection）： 通过接口定义注入方法。
public interface UserRepositoryAware { void setUserRepository(UserRepository userRepository); } public class UserService implements UserRepositoryAware { private UserRepository userRepository; @Override public void setUserRepository(UserRepository userRepository) { this.userRepository = userRepository; } public void createUser(String username, String password) { userRepository.save(new User(username, password)); } }接口注入的优点是解耦性好，但实现起来相对复杂，实际应用较少。
IoC容器的原理是什么？
IoC容器的核心原理是反射和配置。容器通过读取配置文件（XML、注解等）或扫描类路径，获取所有需要管理的Bean的信息。然后，利用反射机制创建Bean的实例，并根据配置信息注入依赖。
简而言之，容器扮演了“对象工厂”的角色，负责对象的创建、组装和管理。
举个例子，Spring IoC容器的启动过程大致如下：
- 读取配置： Spring容器读取XML配置文件或扫描注解，获取Bean的定义信息。
- BeanDefinition解析： 将配置信息解析成BeanDefinition对象，BeanDefinition包含了Bean的类型、作用域、依赖关系等信息。
- Bean实例化： 根据BeanDefinition创建Bean的实例。如果是单例Bean，则在容器启动时创建；如果是原型Bean，则在每次请求时创建。
- 依赖注入： 将Bean的依赖对象注入到Bean实例中。Spring支持构造器注入、Setter注入和字段注入。
-
Bean初始化： 执行Bean的初始化方法，例如实现
InitializingBean接口的afterPropertiesSet()方法或使用@PostConstruct注解的方法。 - Bean使用： 应用程序从容器中获取Bean的实例，并使用Bean提供的服务。
IoC解决了哪些问题？
IoC主要解决了以下几个问题：
- 降低耦合度： IoC容器管理对象之间的依赖关系，减少了对象之间的直接依赖，从而降低了系统的耦合度。
- 提高可测试性： 由于对象之间的依赖关系由容器管理，因此可以很容易地替换依赖对象，方便进行单元测试。
- 提高可维护性： IoC容器统一管理对象的创建和依赖注入，使得代码更加清晰易懂，易于维护。
- 提高可重用性： IoC容器可以将对象配置成不同的作用域（例如单例、原型），从而提高对象的可重用性。
为什么需要IoC容器？手写一个简单的IoC容器
没有IoC容器，我们就需要在代码中手动管理对象的生命周期和依赖关系，这会导致代码冗余、耦合度高、难以测试。
手写一个简单的IoC容器，可以帮助我们更好地理解IoC的原理。以下是一个简单的Java IoC容器的实现：
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class SimpleIoCContainer {
private Map beans = new HashMap<>();
public void registerBean(String beanName, Class beanClass) throws Exception {
Constructor constructor = beanClass.getConstructor();
Object bean = constructor.newInstance();
Field[] fields = beanClass.getDeclaredFields();
for (Field field : fields) {
if (field.isAnnotationPresent(Autowired.class)) {
field.setAccessible(true);
String dependencyBeanName = field.getType().getSimpleName().toLowerCase();
Object dependencyBean = getBean(dependencyBeanName);
if (dependencyBean == null) {
throw new IllegalArgumentException("找不到依赖的Bean: " + dependencyBeanName);
}
field.set(bean, dependencyBean);
}
}
beans.put(beanName, bean);
}
public Object getBean(String beanName) {
return beans.get(beanName);
}
public static void main(String[] args) throws Exception {
SimpleIoCContainer container = new SimpleIoCContainer();
container.registerBean("userRepository", UserRepository.class);
container.registerBean("userService", UserService.class);
UserService userService = (UserService) container.getBean("userService");
userService.createUser("testUser", "password");
}
}
@interface Autowired {}
class UserRepository {
public void save(User user) {
System.out.println("保存用户: " + user.getUsername());
}
}
class UserService {
@Autowired
private UserRepository userRepository;
public void createUser(String username, String password) {
userRepository.save(new User(username, password));
}
}
class User {
private String username;
private String password;
public User(String username, String password) {
this.username = username;
this.password = password;
}
public String getUsername() {
return username;
}
} 这个简单的IoC容器实现了Bean的注册和依赖注入。它使用了反射机制来创建Bean的实例，并使用自定义的@Autowired注解来标记需要注入的依赖。
注意： 这只是一个非常简单的IoC容器的实现，实际的IoC容器要复杂得多，例如Spring IoC容器。
IoC和AOP有什么关系？
IoC和AOP是两种不同的设计思想，但它们可以一起使用，以提高系统的模块化和可维护性。
- IoC关注的是对象之间的依赖关系， 负责对象的创建和依赖注入。
- AOP关注的是横切关注点， 例如日志、安全、事务等，可以将这些关注点从业务逻辑中分离出来，以提高代码的复用性和可维护性。
IoC容器可以与AOP框架集成，例如Spring AOP，从而实现更加强大的功能。例如，可以使用AOP来对Bean的方法进行拦截，并在方法执行前后执行一些额外的操作，例如记录日志或进行权限验证。
总之，IoC和AOP是两种互补的技术，它们可以一起使用，以构建更加灵活、可维护的系统。
