第83天学习打卡（Spring IOC理论推导 HelloSpring IOC创建对象的方式 Spring配置 DI依赖注入）Bean的自动装配

2021-06-06 15:03

阅读：702

标签：一句话而且 stat type doc 是你自动 setname 杂类

2.IOC理论推导

1.UserDao接口

2.UserDaoImpl实现类

3.UserService业务接口

4.UserServiceImpl实现类

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码！如果程序代码量十分大，修改一次的成本代价十分昂贵。

我们使用一个Set接口实现

 package com.kuang.service;
 ?
 import com.kuang.dao.UserDao;
 public class UserServiceImpl implements UserService{
     private UserDao userDao;
 ?
     //利用set进行动态实现值的注入
     public void setUserDao(UserDao userDao) {
         this.userDao = userDao;
     }
 ?
     @Override
     public void getUser() {
         userDao.getUser();
 ?
     }
 }
 ?

测试：

 import com.kuang.dao.UserDaoMysqlImpl;
 import com.kuang.dao.UserDaoOracleImpl;
 import com.kuang.dao.UserDaoSqlserverImpl;
 import com.kuang.service.UserServiceImpl;
 ?
 public class MyTest {
     public static void main(String[] args) {
         //用户实际调用 的是业务层，dao层他们不需要接触
         UserServiceImpl userService = new UserServiceImpl();
 ?
         ((UserServiceImpl)userService).setUserDao(new UserDaoSqlserverImpl());
         userService.getUser();
     }
 }
 ?

之前，程序是主动创建对象！控制权在程序员手上！
使用了set注入之后，程序不再具有主动性，而是变成了被动的接受对象！

这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建了。

系统的耦合性大大降低，可以更加专注的在业务的实现上！这是IOC的原型！

IOC本质：

控制反转IOC(Inversion of Control),是一种设计思想，DI（依赖注入）是实现IOC的一种方法，也有人认为DI只是Ioc的另一种说法。没有Ioc的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，所谓控制反转就是获得依赖对象的方式反转！

技术图片

IOC是Spring框架的核心内容，使用多种方式完美的实现了IOC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IOC.

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从IOC容器中取出需要的对象。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

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

3. HelloSpring

beans框架的官网地址：

https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#spring-core

beans.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">
 
 bean id="hello" class="com.kuang.pojo.Hello">
     property name="str" value="Spring"/>
 bean>
 beans>

Hello 对象是谁创建的？

hello对象是由Spring创建的
Hello对象的属性是怎么设置的？

hello对象的属性是由Spring容器设置的。

这个过程就叫做控制反转：

控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。

反转：程序本身不创建对象，而变成被动的接受对象。

依赖注入：就是利用set方法来进行注入的。

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

可以通过new ClassPathXmlApplicationContext去浏览一下底层源码。

我们彻底不用在程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的ioc,一句话搞定：对象由Spring来创建，管理，装配！

beans.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">
 ?
     bean id="mysqlImpl" class="com.kuang.dao.UserDaoMysqlImpl"/>
     bean id="oracleImpl" class="com.kuang.dao.UserDaoOracleImpl"/>
 ?
     bean id="UserServiceImpl" class="com.kuang.service.UserServiceImpl">
         property name="userDao" ref="oracleImpl"/>
     bean>
 ?
 ?
 beans>

测试：

 import com.kuang.service.UserServiceImpl;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 ?
 public class MyTest {
     public static void main(String[] args) {
         //获取ApplicationContext; 拿到spring 的容器
      ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
 ?
      //容器在手，天下我有  ，需要什么，就直接get什么！
         UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl");
         userServiceImpl.getUser();
 ?
     }
 }
 ?

4.IOC创建对象的方式

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

 package com.kuang.pojo;
 ?
 public class User {
     private String name;
 ?
     public User(){
         System.out.println("User的无参构造！");
     }
 ?
     public String getName() {
         return name;
     }
 ?
     public void setName(String name) {
         this.name = name;
     }
     public void show(){
         System.out.println("name=" + name);
     }
 }
 ?

beans.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">
     bean id="user" class="com.kuang.pojo.User">
         property name="name" value="秦疆"/>
     bean>
 ?
 ?
 ?
 beans>

测试：

 import com.kuang.pojo.User;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 ?
 public class MyTest {
     public static void main(String[] args){
         //拿到容器
     ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
         User user = (User) context.getBean("user");
         user.show();
 ?
     }
 }
 ?

2.假设我们要使用有参构造创建对象。

1.下标赋值：

 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">
     bean id="user" class="com.kuang.pojo.User">
      constructor-arg index="0" value="狂神说Java"/>
     bean>
 ?
 ?
 ?
 beans>

2.类型

 
 bean id="user" class="com.kuang.pojo.User">
         constructor-arg type="java.lang.String" value="qinjiang"/>
     bean>

3.参数名

     bean id="user" class="com.kuang.pojo.User">
         constructor-arg name="name" value="秦疆"/>
     bean>
 ?

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

5.Spring配置(xml中不要写中文注释不要写会出错)

5.1别名

 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">
 ?
     bean id="user" class="com.kuang.pojo.User">
         constructor-arg name="name" value="秦疆"/>
     bean>
 bean id="userT" class="com.kuang.pojo.UserT">
 ?
 bean>
     
     alias name="user" alias="doudou"/>
 ?
 ?
 ?
 beans>

测试：

 import com.kuang.pojo.User;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 ?
 public class MyTest {
     public static void main(String[] args){
         //拿到容器
     ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
         User user = (User) context.getBean("doudou");
         user.show();
 ?
 ?
     }
 }
 ?

5.2 Bean的配置

 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">
 ?
     bean id="user" class="com.kuang.pojo.User">
         constructor-arg name="name" value="秦疆"/>
     bean>
 
     bean id="userT" class="com.kuang.pojo.UserT" name="user2 u2,u3;u4">
         property name="name" value="西部开源"/>
 ?
     bean>
 ?
 ?
 ?
 ?
 ?
 beans>

 import com.kuang.pojo.User;
 import com.kuang.pojo.UserT;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 ?
 public class MyTest {
     public static void main(String[] args){
         //拿到容器
     ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
         UserT user = (UserT) context.getBean("u4");
         user.show();
 ?
 ?
     }
 }
 ?

5.3 import

这个import,一般用于团队开发使用，他可以将多个配置文件，导入合并为一个

假设，现在项目中有多个人开发，这三个人负责不同的类的开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！

张三
李四
王五
applicationContext.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">
     import resource="beans.xml"/>
     import resource="beans2.xml"/>
     import resource="beans3.xml"/>
 ?
 beans>

使用的时候，直接使用总的配置就可以了

6.DI依赖注入

6.1构造器注入（前面已讲）

6.2Set方式注入【重点】

依赖注入：Set注入！
- 依赖：bean对象的创建依赖于容器
- 注入：bean对象中的所有属性，由容器注入！

【环境搭建】

1.复杂类型

 package com.kuang.pojo;
 ?
 public class Address {
     private String address;
 ?
     public String getAddress() {
         return address;
     }
 ?
     public void setAddress(String address) {
         this.address = address;
     }
 }
 ?

2.真实测试对象

 package com.kuang.pojo;
 ?
 import java.util.*;
 ?
 public class Student {
     private String name;
     private Address address;
     private String[] books;
     private ListString> hobbies;
     private MapString,String> card;
     private SetString> games;
     private String wife;
     private Properties info;
 ?
     public String getName() {
         return name;
     }
 ?
     public void setName(String name) {
         this.name = name;
     }
 ?
     public Address getAddress() {
         return address;
     }
 ?
     public void setAddress(Address address) {
         this.address = address;
     }
 ?
     public String[] getBooks() {
         return books;
     }
 ?
     public void setBooks(String[] books) {
         this.books = books;
     }
 ?
     public ListString> getHobbies() {
         return hobbies;
     }
 ?
     public void setHobbies(ListString> hobbies) {
         this.hobbies = hobbies;
     }
 ?
     public MapString, String> getCard() {
         return card;
     }
 ?
     public void setCard(MapString, String> card) {
         this.card = card;
     }
 ?
     public SetString> getGames() {
         return games;
     }
 ?
     public void setGames(SetString> games) {
         this.games = games;
     }
 ?
     public String getWife() {
         return wife;
     }
 ?
     public void setWife(String wife) {
         this.wife = wife;
     }

上一篇：SpringBoot -- @RestControllerAdvice 注解

下一篇：SpringBoot解决跨域的三种方式

文章来自：搜素材网的编程语言模块，转载请注明文章出处。
文章标题：第83天学习打卡（Spring IOC理论推导 HelloSpring IOC创建对象的方式 Spring配置 DI依赖注入）Bean的自动装配
文章链接：http://soscw.com/essay/91327.html

亲，登录后才可以留言！

第83天学习打卡（Spring IOC理论推导 HelloSpring IOC创建对象的方式 Spring配置 DI依赖注入）Bean的自动装配

2.IOC理论推导

3. HelloSpring

4.IOC创建对象的方式

5.Spring配置(xml中不要写中文注释不要写会出错)

5.1别名

5.2 Bean的配置

5.3 import

6.DI依赖注入

6.1构造器注入（前面已讲）

6.2Set方式注入【重点】

评论

热门文章

推荐文章

最新文章

置顶文章

第83天学习打卡（Spring IOC理论推导 HelloSpring IOC创建对象的方式 Spring配置 DI依赖注入）Bean的自动装配

2.IOC理论推导

3. HelloSpring

4.IOC创建对象的方式

5.Spring配置(xml中不要写中文注释 不要写 会出错)

5.1别名

5.2 Bean的配置

5.3 import

6.DI依赖注入

6.1构造器注入（前面已讲）

6.2Set方式注入【重点】

评论

热门文章

推荐文章

最新文章

置顶文章

5.Spring配置(xml中不要写中文注释不要写会出错)