标签：情况   环境配置   安装步骤   window   需要   命名   使用   依赖包   name   

IOC与DI的理解及使用

控制反转IOC（Inversion of Control）是一种设计思想，DI（依赖注入）是实现IOC的一种方法。在没有IOC的程序中，我们使用面向对象编程，对象的创建于对象间的依赖完全硬编码在程序中，对象的创建有程序自己控制；控制反转后将对象的创建转移给第三方；

控制反转是一种通过描述XML（或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入（Dependency Injection，DI）

IOC演示：

1. UserDao接口

   public interface UserDao {
       void getUser();
   }
   

2. UserDaoImpl实现类

   public class UserDaoImpl implements UserDao{
       public void getUser() {
           System.out.println("默认获取用户");
       }
   }
   

3. UserService业务接口

   public interface UserService {
       void getUser();
   
       void setUserDao(UserDao userDao);
   }
   

4. UserServiceImpl业务实现类

   public class UserServiceImpl implements UserService {
   
       private UserDao userDao ;
   
       //利用set进行动态实现值的注入
       public void setUserDao(UserDao userDao){
           this.userDao = userDao;
       }
   
       public void getUser() {
           userDao.getUser();
       }
   }
   

这里使用一个Set方法实现

      private UserDao userDao ;
  
      //利用set进行动态实现值的注入
      public void setUserDao(UserDao userDao){
          this.userDao = userDao;
      }
  
      //代替了原先主动在该类中穿创建对象:
      //userDao = new UserDao();

• 之前，程序是主动创建对象，控制权在开发者手上！
• 使用set注入后，程序不再具有主动性，而是变成了被动的接收对象！
• 这种对象的控制权的转变思想就是IOC（控制反转）

这种思想，从本质上解决了问题，程序员不用再去管理对象的创建了，系统的耦合性大大降低，可以更加专注在业务的实现上。这就是IOC的原型。

1、第一个spring

Spring的核心就是基于IOC容器，将对象的创建以及依赖的注入全部交由Spring容器来完成。

首先基于如上接口和业务创建两个接口实现类：

public class UserDaoMysqlImpl implements UserDao{
    public void getUser() {
        System.out.println("mysql获取用户");
    }
}

public class UserOracleImpl implements UserDao{
    public void getUser() {
        System.out.println("oracle获取用户");
    }
}

创建applicationContext.xml文件

基于XML的配置元数据的基本结构：

测试：

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象ApplicationContext
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
		
        //对象已经在Spring中管理了，使用时直接根据bean id取即可
        UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean("userServiceImpl");
        serviceImpl.getUser();

    }
}

现在，我们彻底不用在程序中去改动了，要实现不同的操作，只需要在XML中进行修改；

这个过程就叫控制反转：

• 控制：谁来控制对象的创建，传统的应用程序是由程序本身控制创建的，使用Spring后，对象由Spring来创建；
• 反转：程序本身不创建对象，而变成被动的接受对象；
• 依赖注入：就是利用set、构造方法等进行属性的注入；
  • 依赖：bean对象的创建依赖于容器！
  • 注入：bean对象中的所有属性，由容器来注入！

IOC是一种编程思想，由主动的编程变为被动的接收。

总结为一句话：对象由Spring来创建，管理，装配。

2、IOC创建对象的方法

1. 默认使用无参构造创建对象

2. 自定义使用有参构造创建对象

   1. 下标赋值

   2. 参数名赋值

   3. 根据类型赋值（有同类型参数时则会有问题）

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了。

3、DI(依赖注入)

IOC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。

DI的实现原理是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，Spring就是通过反射来实现注入的。

理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

• 谁依赖于谁：是应用程序依赖于IoC容器；

• 为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源；

• 谁注入谁：是IOC容器注入应用程序依赖的某个对象；

• 注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。

1、构造器注入

1. 默认使用无参构造创建对象

2. 自定义使用有参构造创建对象：

   1. 下标赋值
   2. 参数名赋值
   3. 根据类型赋值（有同类型参数时则会有问题）

*2、set方式注入

【环境搭建】

1. 复杂类型

   public class Address {
       private String address;
   
       public String getAddress() {
           return address;
       }
   
       public void setAddress(String address) {
           this.address = address;
       }
   
       @Override
       public String toString() {
           return "Address{" +
                   "address=‘" + address + ‘\‘‘ +
                   ‘}‘;
       }
   }
   

2. 测试对象

   @Data
   public class Student {
       private String name;
       private Address address;
       private String[] books;
       private List hobbies;
       private Map card;
       private Set games;
       private String wife;    //null
       private Properties info;
   }
   

3. beans.xml

   	西游记三国演义红楼梦水浒传唱歌打游戏LOLCS男18

4. 测试类

   public class MyTest2 {
       public static void main(String[] args) {
           ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
           Student student = (Student) context.getBean("student");
           System.out.println();
       }
   }
   

• 测试结果

  Student{
  	name=‘ps‘, 
  	address=Address{address=‘address‘},
      books=[西游记, 三国演义, 红楼梦, 水浒传], 
      hobbies=[唱歌, 打游戏],
      card={学生证=147596654, 身份证=33216541236542512},
      games=[LOL, CS],
      wife=‘null‘, 
      info={性别=男, 年龄=18}
  }
  

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了。

3、拓展

可以使用p命名空间和c命名空间进行注入：

p命名（properties）

c命名（constructor）

注意：p命名和c命名空间不能直接使用，需要导入xml约束

xmlns:p="http://www.springframework.org/schema/p" 
xmlns:c="http://www.springframework.org/schema/c"

4、bean的作用域

1. 单例模式（Spring默认机制）

   bean的一个共享实例，并且所有对具有ID或与该bean定义相匹配的ID的bean的请求都会导致该特定的bean实例由Spring容器返回

2. 原型模式：

   每次对特定bean提出请求时，bean部署的非单一原型范围都会创建一个新的bean实例

3. 其余的request、session、application等只能在web开发中使用，对应的就是这三类作用域。

python虚拟环境配置

标签：情况   环境配置   安装步骤   window   需要   命名   使用   依赖包   name   

原文地址：https://www.cnblogs.com/crystal1126/p/13469170.html