spring

Posted 小企鹅推雪球!

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了spring相关的知识，希望对你有一定的参考价值。

文章目录

Spring-IOC容器详解

第一：什么是IOC？

  1. Spring 容器是 Spring 框架的核心
  2. IOC是控制反转，减低代码之间的耦合度，将对象的创建和对象之间的调用的过程，交给Spring进行管理
  3. spring容器使用依赖注入（DI）来管理组成一个应用程序的组件，这些对象被称为Spring Beans
  4. 通过配置元数据文件，容器直到哪些对象进行实例化配置和组装，
  5. 配置元数据可以通过xml，Java注释活Java代码表示

第二：IOC容器是具有依赖注入功能的容器

  1. IOC容器可以创建对象，IOC容器负责实例化，定位，配置应用程序中的对象以及建立这些对象间的依赖
  2. 一般一个new实例，控制权由程序员控制，而控制反转是指new实例工作不由程序员来做，而是交给Spring容器来做，
  3. 在Spring中BeanFactory是IOC容器的实际代表者

Spring容器类型

  1. Spring提供了两种类型的容器
    1. Spring BeanFactory 容器它是最简单的容器，给 DI 提供了基本的支持，
    2. Spring ApplicationContext 容器该容器添加了更多的企业特定的功能，例如从一个属性文件中解析文本信息的能力，发布应用程序事件给感兴趣的事件监听器的能力。
  2. ApplicationContext 容器包括 BeanFactory 容器的所有功能，所以通常不建议使用BeanFactory。
  3. BeanFactory 仍然可以用于轻量级的应用程序，如移动设备或基于 applet 的应用程序，其中它的数据量和速度是显著。

Spring BeanFactory容器

  1. Spring BeanFactory容器是最简单的容器，主要的功能是为依赖注入（DI）提供这支持
  2. 在 Spring 中，有大量对 BeanFactory 接口的实现。其中，最常被使用的是 XmlBeanFactory 类。这个容器从一个 XML 文件中读取配置元数据，由这些元数据来生成一个被配置化的系统或者应用。

Spring应用程序示例

  1. 创建SpringExample工程闭关在src文件夹下创建名为 com.tutorialspoint 文件夹
  2. 选择 Add External JARs 选项，导入 Spring 的库文件，
  3. 在 com.tutorialspoint 文件夹下创建 HelloWorld.java 和 MainApp.java 两个类文件。
  4. 在 src 文件夹下创建 Bean 的配置文件 Beans.xml

HelloWorld.java

package com.tutorialspoint;
public class HelloWorld {
   private String message;
   public void setMessage(String message){
    this.message  = message;
   }
   public void getMessage(){
    System.out.println("Your Message : " + message);
   }
}

MainApp.java

package com.tutorialspoint;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
public class MainApp {
   public static void main(String[] args) {
      XmlBeanFactory factory = new XmlBeanFactory
                             (new ClassPathResource("Beans.xml"));
      HelloWorld obj = (HelloWorld) factory.getBean("helloWorld");
      obj.getMessage();
   }
}
  1. 利用框架提供的 XmlBeanFactory() API 去生成工厂 bean 以及利用 ClassPathResource() API 去加载在路径 CLASSPATH 下可用的 bean 配置文件
  2. XmlBeanFactory（）API负责创建并初始化所有的对象，即在配置文件bean配置
  3. 利用成的 bean 工厂对象的 getBean() 方法得到所需要的 bean。 通过配置文件中的 bean ID 来返回一个真正的对象，该对象最后可以用于实际的对象。一旦得到这个对象，你就可以利用这个对象来调用任何方法。

Beans.xml文件

<?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
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id="helloWorld" class="com.tutorialspoint.HelloWorld">
       <property name="message" value="Hello World!"/>
   </bean>

</beans>

Spring Bean的定义

  1. 在Spring IOC容器中，bean 是一个被实例化，组装，并通过 Spring IoC 容器所管理的对象
  2. Bean对象是用容器提供的配置元数据创建的
  3. bean定义包含配置元数据的信息
    1. class属性：指定用来创建bean的bean类
    2. name属性：指定唯一标识bean的标识符，在基于XML的配置元数据中，可以使用id或name属性指定bean标识符
    3. scope属性指定由特定的 bean 定义创建的对象的作用域
    4. constructor-arg 和 properties：用来注入依赖关系的

Spring配置元数据

  1. Spring IoC 容器完全由实际编写的配置元数据的格式解耦。
  2. 基于 XML 的配置文件
  3. 配置文件中有不同的 bean 定义，包括延迟初始化，初始化方法和销毁方法的：
<?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
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- A simple bean definition -->
   <bean id="..." class="...">
       <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- A bean definition with lazy init set on -->
   <bean id="..." class="..." lazy-init="true">
       <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- A bean definition with initialization method -->
   <bean id="..." class="..." init-method="...">
       <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- A bean definition with destruction method -->
   <bean id="..." class="..." destroy-method="...">
       <!-- collaborators and configuration for this bean go here -->
   </bean>

   <!-- more bean definitions go here -->

</beans>
  1. ①xmlns=“http://www.springframework.org/schema/beans”，默认命名空间：它没有空间名，用于Spring Bean的定义；
  2. ②xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”，xsi命名空间：这个命名空间用于为每个文档中命名空间指定相应的Schema样式文件，是标准组织定义的标准命名空间。

第二：IOC底层原理

  1. XML解析，工厂模式和反射
  2. IOC解耦的步骤

    1. 第一步：创建XML配置文件，配置创建对象

    2. 第二步：有service 类和dao类，创建工厂类

IOC接口

  1. IOC思想基于IOC容器完成，IOC容器底层是对象工厂
  2. Spring提供了IOC容器实现的两种方式：
    1. BeanFactory:IOC容器最基本的实现方式，是Spring内部的使用接口，在开发中一般不使用
    2. ApplicationContext:：BeanFactory接口的子接口，在开发中使用，功能更强大
    3. BeanFactory特点:在加载配置文件的时候，不会创建对象，在获取对象（使用对象时）才会创建对象
    4. ApplicationContext特点：在加载配置文件的时候就会将配置文件中对象进行创建
  3. ApplicationContext接口的主要实现类：
    1. File需要写配置文件的盘符路径
    2. Class表示配置文件的当前目录下的配置的路径（不用写全）

IOC操作-Bean管理

  1. 什么是Bean管理：指两个操作
    1. 第一Spring创建对象
    2. 第二Spring注入属性
  2. Bean管理操作的两种实现方式
    1. 基于xml配置文件实现Bean管理
      1. 基于xml方式创建对象

        1. 在spring配置文件中，使用bean标签，标签里添加对应属性，可以实现对象创建
        2. 在bean标签中的常用属性
        1. id属性，表示当前对象的唯一标识
        2. class属性：标识类的全路径，即包类的路径
        3. 创建对象的时候会默认执行无参数构造方法完成对象创建
      2. 基于xml方式注入属性
        1. DI：是依赖注入，就是注入属性（set方法注入，有参构造参数注入）

          1. 第一种注入方式;使用set方法进行注入

            /**
* 演示使用 set 方法进行注入属性
*/
public class Book {
 //创建属性
 private String bname;
 private String bauthor;
 //创建属性对应的 set 方法
 public void setBname(String bname) {
 this.bname = bname;
 }
 public void setBauthor(String bauthor) {
 this.bauthor = bauthor;
 }
}

          2. 在spring配置文件配置对象创建，配置属性注入

            <!--2 set 方法注入属性-->
<bean id="book" class="com.atguigu.spring5.Book">
 <!--使用 property 完成属性注入
 name：类里面属性名称
 value：向属性注入的值
 -->
 <property name="bname" value="易筋经"></property>
 <property name="bauthor" value="达摩老祖"></property>
</bean>

注入案例

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--1 配置User对象创建-->
    <!--<bean id="user" class="com.atguigu.spring5.User"></bean>-->

    <!--2 set方法注入属性-->
    <bean id="book" class="com.atguigu.spring5.Book">
        <!--使用property完成属性注入
            name：类里面属性名称
            value：向属性注入的值
        -->
        <property name="bname" value="易筋经"></property>
        <property name="bauthor" value="达摩老祖"></property>
        <!--null值-->
        <!--<property name="address">
            <null/>
        </property>-->

        <!--属性值包含特殊符号
            1 把<>进行转义 &lt; &gt;
            2 把带特殊符号内容写到CDATA
        -->
        <property name="address">
            <value><![CDATA[<<南京>>]]></value>
        </property>
    </bean>

    <!--3 有参数构造注入属性-->
    <!--<bean id="orders" class="com.atguigu.spring5.Orders">
        <constructor-arg name="oname" value="电脑"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>-->

    <!--2 set方法注入属性-->
    <!--<bean id="book" class="com.atguigu.spring5.Book" p:bname="九阳神功" p:bauthor="无名氏">
    </bean>-->
</beans>

package com.ryx.spring5;

/**
 * 使用有参数构造注入
 */
public class Orders {
    //属性
    private String oname="";
    private String address;
    //有参数构造
    public Orders(String oname,String address) {
        this.oname = oname;
        this.address = address;
    }

    public void ordersTest() {
        System.out.println(oname+"::"+address);
    }
}

以上是关于spring的主要内容，如果未能解决你的问题，请参考以下文章

Spring boot：thymeleaf 没有正确渲染片段

What's the difference between @Component, @Repository & @Service annotations in Spring?(代码片段

spring练习，在Eclipse搭建的Spring开发环境中，使用set注入方式，实现对象的依赖关系，通过ClassPathXmlApplicationContext实体类获取Bean对象(代码片段

Spring Rest 文档。片段生成时 UTF-8 中间字节无效 [重复]

解决spring-boot启动中碰到的问题：Cannot determine embedded database driver class for database type NONE(转)(代码片段

一张图帮你记忆，Spring Boot 应用在启动阶段执行代码的几种方式