java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Spring IOC推导与DI构造器注入

Spring IOC推导与DI构造器注入超详细讲解

作者：绿仔牛奶_

这篇文章主要介绍了Spring IOC推导与DI构造器注入，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习吧

了解准备

什么是Spring？

Spring是一款轻量级的控制反转（IOC）和面向切面编程（AOP）的非入侵式开源框架

Spring框架主要由七部分组成，分别是 Spring Core、 Spring AOP、 Spring ORM、 Spring DAO、Spring Context、 Spring Web和 Spring Web MVC

Spring三大核心：IOC控制反转、DI依赖注入、AOP面向切面编程

Spring整合了现有的技术框架，使这些技术更加易于使用

Spring官网：https://spring.io/

下载地址：https://repo.spring.io/ui/native/release/org/springframework/spring

GitHub地址：https://github.com/spring-projects/spring-framework

maven依赖：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.3.18</version>
</dependency>

整合MyBatis时导入

<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.23</version>
</dependency>

IOC思想

引入IOC

准备Dao层接口和一堆实现类

public interface UserDao {
    void getUser();
}
public class UserDaoImpl implements UserDao{
    public void getUser() {
        System.out.println("UserDao获取User成功！");
    }
}
public class UserDaoMySqlImpl implements UserDao{
    public void getUser() {
        System.out.println("UserDaoMySqlImpl获取User成功！");
    }
}
public class UserDaoOracleImpl implements UserDao{
    public void getUser() {
        System.out.println("UserDaoOracleImpl获取User成功！");
    }
}

准备业务层

public interface UserService {
    void getUser();
}
public class UserServiceImpl implements UserService{
  private UserDao userDao = new UserDaoImpl;
  public void getUser() {
    userDao.getUser();
  }
}

测试不同UserDao实现类的getUser方法

public class MyTest {
  @Test
  public void testGetUser(){
    UserServiceImpl service = new UserServiceImpl();
    service.getUser();
  }
}

可以发现，当需要调用不同UserDao实现类时，每次都需要区service中修改UserDao实例的指向

private UserDao userDao = new UserDaoImpl;
private UserDao userDao = new UserDaoOracleImpl;
private UserDao userDao = new UserDaoMySqlImpl;

这样设计的耦合性极高，对程序执行的控制权始终在开发人员手中，当用户提出不同需求就需要我们不断去修改UserDao实例的指向。如果代码数量大，那么需要修改的就不止一处，下面在service中注入set方法来动态的获取不同的UserDao实例指向

service：

public class UserServiceImpl implements UserService{
  private UserDao userDao;
  // 注入set方法  解耦
  public void setUserDao(UserDao userDao){
    this.userDao = userDao;
  }
  public void getUser() {
    userDao.getUser();
  }
}

Test：

public class MyTest {
  @Test
  public void testGetUser(){
    UserServiceImpl service = new UserServiceImpl();
    service.setUserDao(new UserDaoOracleImpl());
    service.getUser();
  }
}

上述示例，就可以动态的去选择执行用户指定的方法。此处的Test可以看作是一个servlet，它获取到用户的请求之后解析出对应执行的方法，再通过service去调用执行，耦合性就降低许多即用户需求和程序之间的耦合性降低，程序执行的控制权交给用户。以此完成控制反转IOC

IOC本质

IOC的本质就是一种控制反转的设计思想，它不完全等同于DI，DI(依赖注入)可以理解为实现IOC的一种方式。

那我的理解其实是，不能说控制权交给了用户，只是我们通过程序编写可以实现对用户需求的解析。解析出用户的需求对应程序中所要执行的方法即可。不能理解为控制权，只能说用户具有了主动权，并且在代码层面我们提高了程序的动态特性。

所谓控制反转，就是说获取对象的不再由程序的硬编码决定，而是反转到了用户手中。首先程序会解析出用户需求，再动态的获取相应对象

XML配置Spring

以上述UserDao示例配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans                         https://www.springframework.org/schema/beans/spring-beans.xsd">
  <!-- 将每一个UserDao的实现类映射到Spring容器中的bean -->
  <bean id="mysqlImpl" class="com.mountain.dao.MySqlImpl"/>
  <bean id="oracleImpl" class="com.mountain.dao.OracleImpl"/>
  <bean id="userService" class="com.mountain.service.UserServiceImpl">
    <property name="userDao" ref="mysqlImpl"/>
  </bean>
</beans>

测试；

@Test
public void testGetUser(){
  // 获取spring上下文对象
  ApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml");
  UserServiceImpl service = (UserServiceImpl) context.getBean("userService");
  System.out.println(service.getUser());
}

可以看到，创建对象不需要再利用new关键字硬编码，而是完全交给Spring容器进行创建，我们在xml配置中将每一个UserDao的实现类映射到Bean，最后测试利用Spring上下文对象来获取映射好的bean实例

配置细节：

IOC体现：

IOC创建对象方式

默认创建对象方式：

// 无参构造
public User() {
  System.out.println("默认使用无参构造");
}
// 测试
ApplicationContext context = new ClassPathXmlApplicationContext("application-Context.xml");
User user = (User) context.getBean("User");

最终打印：默认使用无参构造，所以在不进行任何其他配置的情况下，Spring默认创建bean依然走无参构造器

public User(String name) {}
<bean id="User" class="com.yuqu.pojo.User">
  <property name="name" value="情人节"/>
</bean>

如果我们只显式了有参构造，那么无参构造被覆盖之后将会导致application-Context.xml文件配置的bean编译直接报错

使用含参构造时

方式一：

<!--  方式一：index代表构造器参数索引  -->
<bean id="User" class="com.yuqu.pojo.User">
  <constructor-arg index="0" value="情人节"/>
</bean>

方式二：

<!--  方式二：type代表参数类型  基本数据类型用  弊端较大  -->
<bean id="User" class="com.yuqu.pojo.User">
 <constructor-arg type="java.lang.String" value="圣诞节"/>
</bean>

但是假设多个参数都是java.lang.String那么方式二就是不可取的

方式三：

<!--  方式三：直接通过参数名设置  -->
<bean id="User" class="com.yuqu.pojo.User">
  <constructor-arg name="name" value="国庆节"/>
</bean>

到此这篇关于Spring IOC推导与DI构造器注入超详细讲解的文章就介绍到这了,更多相关Spring IOC推导与DI构造器注入内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文