Spring概括：控制反转与依赖注入

Posted 2021-10-28 名字真的很急用

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring概括：控制反转与依赖注入相关的知识，希望对你有一定的参考价值。

Spring

一：Spring概述

什么是Spring？
1. 分层设计（持久层mybatis、业务层、控制层）
2. Java SE/Java EE应用full-stack（全栈式）轻量级 开源的框架
  1. 轻量级：
    - 服务
    - 资源
    - 耦合度
3. 两大核心
  - IOC ：控制反转（创建对象角度：new；Spring容器）
  - AOP:面向切面编程（在我们不改变源代码的情况下，对业务进行更改）
    - ```
    public void  say(){   sout(123);sout(456) }
```

2:Sprig框架的发展史

1997：IBM EJB
2002年的，EJB
2006年：EJB 3.0
2017年：spring 5

3：Spring优势

方便解耦，简化开发（IOC）
- spring容器，它可以对所有对象的创建和销毁提供维护，实现了解耦
  1. 耦合度：对象之间的一种关系。所以要合理的使用耦合度（Spring_IOC）

2.AOP编程的支持

了解：面向切面编程

3.声明式事务的支持（数据库）

通过配置（xml）来完成事务的支持，不再需要手动的编写代码

4.方便调试，能够使用Juit测试单元

5.方便集成各种优秀的框架

spring框架，不仅仅生产技术，搬运集成其他的技术
依赖
- 也是一种关系（类和类）；maven体系，整个项目依赖了一些jar。某些类在依赖

4:Spring体系结构

二：IOC :控制反转 -----》解耦

解耦的原则

编译时期不依赖，运行时依赖

  //第一种方式
        DriverManager.registerDriver(new com.mysql.jdbc.Driver());
        //第二种方式:反射
        Class.forName("com.mysql.jdbc.Driver");

自定义IOC
- 实现services层和dao层进行解耦（反射）
- 步骤分析
  1. 创建Java项目，导入自定义的相关IOC坐标
  2. 编写Dao层和它的实现类
  3. 编写Servces层和实现类
  4. 编写测试代码

三：Spring框架入门案例

实现services层和dao层进行解耦
- 第一步：创建项目，导入依赖（Spring）
- 第二步：定义xml（解决硬编码）
- 第三步：容器中取相关对象
- 第四步:测试代码

四：SpringAPI

BeanFactory

IOC容器的核心接口，它定义了ico的基本功能（解析，ioc）

XmlBeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        Object u = xmlBeanFactory.getBean("u"); //getbean :创建的实例

ApplicationContext
- 代表应用上下问对象（spring项目），可以获取spring容器中的对象：容器启动的时候
  - ```
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
```

常用类

ClassPathXmlApplicationContext ：当前项目中 推荐使用
FileSystemXmlApplicationContext：随意的方法

常用方法

getBean(String name):根据id获取ioc容器中的对象
getBean(String  name,Class<T> class_ ) :根据id和运行时状态

五：Spring配置文件

bean标签

id:Bean在spring容器中的唯一标识
class：全限定路径名
* 默认情况调用的式类中的无参构造方法，如果没有无参构造，则会创建失败

bean标签的范围配置

<bean id="c1" class="com.domain.Car" scope="prototype"></bean>
prototype:多例
singleton：单例

bean的声明周期配置

 <bean id="c2" class="com.domain.Car"  init-method="init" destroy-method="destory"></bean>
init:对象创建的时候
detroy:对象销毁的时候

六：bean的实例化

无参构造方法

<bean id="c1" class="com.domain.Car" scope="prototype"></bean>

工厂方式

package com.Utils;

import com.dao.User02;

public class BeanFactory {

    private static User02 user02;

    static {

        user02 = new User02();

    }

    public static User02  getUser02(){
        return  user02;
    }
    //一步到位
//    public static User02 createBean(){
//        return new User02();
//    }
}

静态

 <bean id="c3" class="com.utils.StaticCarFactory" factory-method="getCar">
  
      </bean>

package com.Utils;

import com.dao.User02;

public class InstranceFactory {
    private User02 user02;

    public InstranceFactory(){
        user02 = new User02();
    }

    public User02 getUser02(){
        return  user02;
    }

    /*
    public class InstranceFactory(){
     System.out.println("正在创建中")
    }
    public User02 createBean(){
     return new User02;
    }
     */

}

实例

  <bean id="if" class="com.utils.InstanceCarFactory"></bean>
      <bean id="c4" class="com.domain.Car" factory-bean="if" factory-method="getCar"></bean>

静态工厂：只需要一个bean；实例化工厂至少需要两个bean

依赖注入：
- 它也是Spring框架的IOC的具体体现
  - 在我们编写代码的时候，创建对象的权力交给Spring（IOC），代码中不可能出现没有依赖的情况。
    
    IOC只能降低他们的依赖关系，但不能消除；Serveices —》Dao
  - 那这种类似业务层和数据持久层的依赖关系。在使用Spring以后，就让Spring来维护了。依赖注入

依赖注入分类

构造方法

<bean id="um" class="com.mapper.imp.UserMapperImp">
      <!-- <constructor-arg value="孙悟空"></constructor-arg>
       <constructor-arg value="15"></constructor-arg>-->
      <!-- <constructor-arg index="0" value="12"></constructor-arg>
       <constructor-arg index="1" value="苏"></constructor-arg>-->
       <constructor-arg name="name" value="wuuw"></constructor-arg>
        <constructor-arg name="age" value="11"></constructor-arg>
   </bean>

set方法

<bean class="com.domain.User" id="user"></bean>
    <!--set实现注入-->
    <bean id="um2" class="com.mapper.imp.UserMapperImp">
        <property name="name" value="小猪猪"></property>
        <property name="age" value="23"></property>
        <property name="u" ref="user"></property>
    </bean>

p空间命名法

引入p约束

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

 <bean id="um3" class="com.mapper.imp.UserMapperImp" p:u-ref="user"></bean>

依赖注入：（基本类型/以用类型）

数组、List集合、map集合、自定义

环境搭建

导入依赖

<dependencies>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-context</artifactId>
           <version>5.2.17.RELEASE</version>
       </dependency>

       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.12</version>
          
       </dependency>
   </dependencies

配置文件

<?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">


</beans>

实验相关类

package com;

public class Book {
}
-------------------------------
package com;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

public class User {
    private  String name;
    private  int age;
    private List<String> lists;
    private  List<Book>  books;
    private  String[]  arr;
    private  Book[] arrbook;
    private Map<String,String> maps;
    private  Map<String,Book> map_books;

    public User() {
    }

    public User(String name, int age, List<String> lists, List<Book> books, String[] arr, Book[] arrbook, Map<String, String> maps, Map<String, Book> map_books) {
        this.name = name;
        this.age = age;
        this.lists = lists;
        this.books = books;
        this.arr = arr;
        this.arrbook = arrbook;
        this.maps = maps;
        this.map_books = map_books;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public List<String> getLists() {
        return lists;
    }

    public void setLists(List<String> lists) {
        this.lists = lists;
    }

    public List<Book> getBooks() {
        return books;
    }

    public void setBooks(List<Book> books) {
        this.books = books;
    }

    public String[] getArr() {
        return arr;
    }

    public void setArr(String[] arr) {
        this.arr = arr;
    }

    public Book[] getArrbook() {
        return arrbook;
    }

    public void setArrbook(Book[] arrbook) {
        this.arrbook = arrbook;
    }

    public Map<String, String> getMaps() {
        return maps;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public Map<String, Book> getMap_books() {
        return map_books;
    }

    public void setMap_books(Map<String, Book> map_books) {
        this.map_books = map_books;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\\'' +
                ", age=" + age +
                ", lists=" + lists +
                ", books=" + books +
                ", arr=" + Arrays.toString(arr) +
                ", arrbook=" + Arrays.toString(arrbook) +
                ", maps=" + maps +
                ", map_books=" + map_books +
                '}';
    }
}

数组类型

<?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="book" class="com.Book">
        <property name="page" value="10"></property>
   </bean>
     <bean id="u1" class="com.User">
          <property name="age" value="12"></property>
          <property name="name" value="武松"></property>
          <!--数组-->
          <property name="arr">
               <array>
                    <value>a</value>
                    <value>b</value>

               </array>
          </property>
          <property name="arrbook">
              <array>
                   <ref bean="book"></ref>
              </array>
          </property>
     </bean>
</beans>

测试代码

 @org.junit.Test
    public  void method01(){

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        System.out.println(context.getBean("u1",User.class));
    }

List集合和数组一样

Map和properties集合

<!--        list集合-->
        <property name="lists">
            <list>
                <value>aaa</value>
                <value>bbb</value>
            </list>
        </property>
        <property name="books">
            <list&以上是关于Spring概括：控制反转与依赖注入的主要内容，如果未能解决你的问题，请参考以下文章 
 Spring概括：控制反转与依赖注入
 深层理解Spring 控制反转和依赖注入，这一篇文够了
 spring学习总结一----控制反转与依赖注入
 spring依赖注入，和控制反转。用自己的话说是怎么说的。最好能够用代码来解释
 “依赖注入”，“控制反转”是指啥？
 Spring控制反转与依赖注入(IOCDI)