Spring（IOC控制反转、DI依赖注入、Bean、ApplicationContext、Spring相关API）

最新推荐文章于 2024-07-14 20:28:48 发布

OREO夹心

最新推荐文章于 2024-07-14 20:28:48 发布

阅读量138

点赞数

分类专栏： Spring 文章标签： spring

本文链接：https://blog.csdn.net/weixin_51443782/article/details/113132612

版权

Spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1、Spring概述

1.1spring概念

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

全站式开源框架：为每一层提供技术支持;

表示层（web）：struts2 springmvc；

业务逻辑层（service）：常用与service管理事务，记录日志，不仅仅在service层；

持久层（dao）：hibernate、mybatis；看到好的框架，将框架整合进来；

提供了展现层 SpringMVC和持久层 Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架

1. 2框架图

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qYX2We0o-1611630295576)(img\image-20210107083405888.png)]$

1.3spring jar包

四个核心：

beans：bean管理
Context：上下文（体现在xml配置） spring-context-support用于web
Expression Language：spring EL表达式
Core：spring框架基石核心支持

一个依赖：

logging:日志依赖

注意：beans、context 、core、expression均是spring官网下载的spring包中的，而logging是Oracle官网，commons组件中的一个

1.4、Spring特点

1.方便解耦，简化开发

通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

2.AOP**编程**的支持

通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

3.**声明式事务**的支持

在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

4.方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序。

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

Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。

6.降低Java EE API的使用难度

Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。

7.Java 源码是经典学习范例

Spring的源码设计精妙、结构清晰、匠心独运，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。

2. spring快速入门

2.1 Spring程序开发步骤

①导入 Spring 开发的基本包坐标

②编写 Dao 接口和实现类

③创建 Spring 核心配置文件

④在 Spring 配置文件中配置 UserDaoImpl

⑤使用 Spring 的 API 获得 Bean 实例

2.2 示例

①导入 Spring 开发的基本包坐标

<properties>    <spring-version>5.0.8.RELEASE</spring-version></properties>
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring-version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>${spring-version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring-version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${spring-version}</version>
    </dependency>
    <!-- spring核心包 end-->
</dependencies>

②编写实体类

maevn项目中java中创建com.yunhe.bean创建user实体类；

③创建 Spring 核心配置文件

maevn项目中类路径下（resources）创建applicationContext.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.xsd">
</beans>

④在 Spring 配置文件中配置 UserDaoImpl

<bean id="user" class="com.yunhe.bean.User" >   
    <property name="username" value="jack"/>    
    <property name="age" value="22"/>    
</bean>

⑤使用 Spring 的 API 获得 Bean 实例

public class Test01 {    
    public static void main(String[] args) { 
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml")
		User user = (User) ac.getBean("user");        
        System.out.println(user);                                       
  }
}

3、IOC和DI 概念

3.1 IOC控制反转

：inverse of control 控制反转，将实例创建的权利交给工厂(spring)；

控制反转即IoC (Inversion of Control)，它把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。所谓的“控制反转”概念就是对组件对象控制权的转移，从程序代码本身转移到了外部容器。

3.2 DI依赖注入

依赖注入（Dependency Injection）

依赖注入的基本原则是：应用组件不应该负责查找资源或者其他依赖的协作对象。配置对象的工作应该由IoC容器负责，“查找资源”的逻辑应该从应用组件的代码中抽取出来，交给IoC容器负责。

Dependency injection：依赖注入，一个对象A使用另一个对象的过程称为依赖。从Spring容器中获取A对象，使用Spring自动将A需要的B进行设置，此过程称为是注入。简单的说：就是spring在生成对象的同时，还可以将该对象所需要用到的对象进行赋值

<bean id="user" class="com.yunhe.bean.User">
<property name="username" value="jack"/>
<property name="age" value="22"/>
<property name="computer" ref="computer"/>
</bean>
<bean id="computer" class="com.yunhe.bean.Computer" >
    <property name="brand" value="联想"/>
    <property name="price" value="5000"/>
</bean>

4、Bean实例化三种方式

1）使用无参构造方法实例化

它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

    <bean id="user" class="com.yunhe.bean.User">
    <property name="username" value="jack"/>
    <property name="age" value="22"/>
    <property name="computer" ref="computer"/>
</bean>
<bean id="computer" class="com.yunhe.bean.Computer" >
    <property name="brand" value="联想"/>
    <property name="price" value="5000"/>
</bean>

2）工厂静态方法实例化

工厂的静态方法返回Bean实例

<bean id="user3" class="com.yunhe.factory.UserStaticFactory" factory-method="createUser"/>

public class UserStaticFactory {
    public static User createUser(){
        Computer computer=new Computer();
        computer.setBrand("小米");
        computer.setPrice(4000);
        User user3=new User("小红",18,computer);

        return user3;
    }
}

3）工厂实例方法实例化

工厂的非静态方法返回Bean实例

<bean id="userFactory" class="com.yunhe.factory.UserFactory"/>
    <bean id="user2" factory-bean="userFactory" factory-method="createUser"/>

public class UserFactory {
    public User createUser(){
        Computer computer=new Computer();
        computer.setBrand("华为");
        computer.setPrice(6000);
        User user2=new User("Tome",22,computer );
        return  user2;
    }
}

5、spring 配置文件

5.1 Bean生命周期配置

init-method：指定类中的初始化方法名称

destroy-method：指定类中销毁方法名称

<!--  生命周期测试 添加 init-method="init" destroy-method="destory"  -->
    <bean id="user" class="com.yunhe.bean.User" init-method="init" destroy-method="destory">
    <property name="username" value="jack"/>
    <property name="age" value="22"/>
    <property name="computer" ref="computer"/>
</bean>

5.2 Bean标签范围配置

scope:指对象的作用范围，取值如下：

取值范围	说明
singleton	默认值，单例的
prototype	多例的
request	WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
session	WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
global session	WEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当于 session

1）当scope的取值为singleton时

Bean的实例化个数：1个

Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例

Bean的生命周期：

对象创建：当应用加载，创建容器时，对象就被创建了

对象运行：只要容器在，对象一直活着

对象销毁：当应用卸载，销毁容器时，对象就被销毁了

2）当scope的取值为prototype时

Bean的实例化个数：多个

Bean的实例化时机：当调用getBean()方法时实例化Bean

对象创建：当使用对象时，创建新的对象实例

对象运行：只要对象在使用中，就一直活着

对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

5.3Bean标签基本配置

用于配置对象交由Spring 来创建。

默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

基本属性：

id：Bean实例在Spring容器中的唯一标识

class：Bean的全限定名称

6、spring相关API

6.1 ApplicationContext的继承体系

applicationContext：接口类型，代表应用上下文，可以通过其实例获得 Spring 容器中的 Bean 对象

6.2 ApplicationContext的实现类

1）ClassPathXmlApplicationContext

它是从类的根路径下加载配置文件推荐使用这种

2）FileSystemXmlApplicationContext

它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

3）AnnotationConfigApplicationContext

当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

6.3 getBean()方法使用

public class UserStandardFactory  implements FactoryBean<User> {
    public User getObject() throws Exception {
        User user4=new User();
        user4.setUsername("小明");
        user4.setAge(19);
        Computer computer=new Computer();
        computer.setBrand("华硕");
        computer.setPrice(6666);
        user4.setComputer(computer);
        return user4;
    }
    public Class<?> getObjectType() {
        return User.class;
    }
}

其中，当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。

当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错

getBean()方法使用

public class Test01 {    
    public static void main(String[] args) {       
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml")
		User user = (User) ac.getBean("user");       
        System.out.println(user);                                       
  }
}

6.4 三种获取ApplicationContext对象方法

	ApplicationContext ac1=new ClassPathXmlApplicationContext("applicationContext.xml")

//绝对路径
ApplicationContext ac2=new FileSystemXmlApplicationContext(“D:\workspace\code\spring0106\src\main\resources\applicationContext.xml”);
// 相对路径 ApplicationContext对象无close方法
FileSystemXmlApplicationContext ac3=new FileSystemXmlApplicationContext(Test01.class.getClassLoader().getResource("./applicationContext.xml").getPath());