Spring-1-概述、IoC、bean对象、DI

最新推荐文章于 2022-05-13 14:45:59 发布

LiuYP_1024

最新推荐文章于 2022-05-13 14:45:59 发布

阅读量171

点赞数

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

本文链接：https://blog.csdn.net/beyong_78439/article/details/104138661

版权

Spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

# 内容
    1. Spring的概述
        * 概念
        * 优点
        * 两大核心
        * 体系结构
    2. IoC：控制反转
    3. bean对象
        * 创建bean对象的四种方式
        * bean的作用范围
        * bean的生命周期
        * BeanFactory和 ApplicationContext 的区别
        * ApplicationContext 接口的实现类
    4. DI：依赖注入
        * 概念、作用
        * 依赖注入的三种方式（构造器、set方法）

## Spring概述
    1. 概念：
        Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 、持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

    2. 优点
        1. 方便解耦，简化开发
            Spring就是一个大工厂，可以将所有对象创建和依赖的关系维护，交给Spring管理。
        2. AOP编程的支持
            Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。
        3. 声明式事务的支持
            只需要通过配置就可以完成对事务的管理，而无需手动编程。
        4. 方便程序的测试
            Spring对Junit4支持，可以通过注解方便的测试Spring程序。
        5. 方便集成各种优秀框架
            Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架的直接支持（如：Struts、Hibernate、MyBatis等）。
        6. 降低JavaEE API的使用难度
            Spring对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低。

    3. 两大核心
        * IOC：Inverse Of Control控制反转
        * AOP：Aspect Oriented Programming面向切面编程

    4. Spring体系结构
        Spring框架至今已集成了20多个模块，这些模块分布在以下模块中：
        * 核心容器（Core Container）：Beans,Core,Context,Expression
        * 数据访问/集成（Data Access/Integration）层
        * Web层：WebSocket、Servlet、Web、Portlet
        * AOP（Aspect Oriented Programming）模块
        * 植入（Instrumentation）模块
        * 消息传输（Messaging）
        * 测试（Test）模块

    5. 核心容器：Core Container
        Spring的核心容器是其他模块建立的基础，有Spring-core、Spring-beans、Spring-context、Spring-context-support和Spring-expression（String表达式语言）等模块组成。
        * Spring-core模块：提供了框架的基本组成部分，包括控制反转（Inversion of Control，IOC）和依赖注入（Dependency Injection，DI）功能。
        * Spring-beans模块：提供了BeanFactory，是工厂模式的一个经典实现，Spring将管理对象称为Bean。
        * Spring-context模块：建立在Core和Beans模块的基础之上，提供一个框架式的对象访问方式，是访问定义和配置的任何对象的媒介。ApplicationContext接口是Context模块的焦点。
        * Spring-context-support模块：支持整合第三方库到Spring应用程序上下文，特别是用于高速缓存（EhCache、JCache）和任务调度（CommonJ、Quartz）的支持。
        * Spring-expression模块：提供了强大的表达式语言去支持运行时查询和操作对象图。这是对JSP2.1规范中规定的统一表达式语言（Unified EL）的扩展。该语言支持设置和获取属性值、属性分配、方法调用、访问数组、集合和索引器的内容、逻辑和算术运算、变量命名以及从Spring的IOC容器中以名称检索对象。它还支持列表投影、选择以及常用的列表聚合。

    6. AOP和Instrumentation
        * Spring-aop模块：提供了一个符合AOP要求的面向切面的编程实现，允许定义方法拦截器和切入点，将代码按照功能进行分离，以便干净地解耦。
        * Spring-aspects模块：提供了与AspectJ的集成功能，AspectJ是一个功能强大且成熟的AOP框架。
        *　Spring-instrument模块：提供了类植入（Instrumentation）支持和类加载器的实现，可以在特定的应用服务器中使用。

    7. 消息

    8. 数据访问/集成
        数据访问/集成层由JDBC、ORM、OXM、JMS和事务模块组成。
        * Spring-jdbc模块：提供了一个JDBC的抽象层，消除了烦琐的JDBC编码和数据库厂商特有的错误代码解析。
        * Spring-orm模块：为流行的对象关系映射（Object-Relational Mapping）API提供集成层，包括JPA和Hibernate。使用Spring-orm模块可以将这些O/R映射框架与Spring提供的所有其他功能结合使用，例如声明式事务管理功能。
        * Spring-oxm模块：提供了一个支持对象/XML映射的抽象层实现，例如JAXB、Castor、JiBX和XStream。
        * Spring-jms模块（Java Messaging Service）：指Java消息传递服务，包含用于生产和使用消息的功能。自Spring4.1以后，提供了与Spring-messaging模块的集成。
        * Spring-tx模块（事务模块）：支持用于实现特殊接口和所有POJO（普通Java对象）类的编程和声明式事务管理。

    9. WEB
        Web层由Spring-web、Spring-webmvc、Spring-websocket和Portlet模块组成。
        * Spring-web模块：提供了基本的Web开发集成功能，例如多文件上传功能、使用Servlet监听器初始化一个IOC容器以及Web应用上下文。
        * Spring-webmvc模块：也称为Web-Servlet模块，包含用于web应用程序的Spring MVC和REST Web Services实现。Spring MVC框架提供了领域模型代码和Web表单之间的清晰分离，并与Spring * Framework的所有其他功能集成。
        * Spring-websocket模块：Spring4.0以后新增的模块，它提供了WebSocket和SocketJS的实现。
        * Portlet模块：类似于Servlet模块的功能，提供了Portlet环境下的MVC实现。

    10. 测试
        Spring-test模块支持使用JUnit或TestNG对Spring组件进行单元测试和集成测试。

## IoC控制反转
    1. IoC概念
        * 控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。
        * 通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

    2. 作用：削减计算机程序的耦合(解除我们代码中的依赖关系)

    3. 配置文件导入约束：

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

## bean对象
    1. 创建bean的三种XML方式和注解方式
        1. XML方式使用默认构造函数创建。
           * 在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
           * 采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。

 <bean id="accountService" class="com.lyp.service.impl.AccountServiceImpl"></bean>

2. XML方式使用工厂中的普通方法创建对象（使用某个类中的普通方法创建对象，并存入spring容器）

<bean id="instanceFactory" class="com.lyp.factory.InstanceFactory"></bean>
<bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>

3. XML方式使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)

<bean id="accountService" class="com.lyp.factory.StaticFactory" factory-method="getAccountService"></bean>

4. 使用注解创建（作用就和在XML配置文件中编写一个<bean>标签实现的功能一样）
第一步：先将bean.xml中的beans中插入<context:component-scan>标签
作用：告知spring在创建容器时要扫描的包，配置所需要的标签不是在beans的约束中，而是一个名称为context名称空间和约束中

                <?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:context="http://www.springframework.org/schema/context"
                       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context.xsd">
                
                <!-- 告知spring在创建容器时要扫描的包 -->
                    <context:component-scan base-package="com.lyp"></context:component-scan>
                </beans>

第二步：在对应的类上面加入注解
                * @Component:
                    作用：用于把当前类对象存入spring容器中
                    属性：
                        value：用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。
                * @Controller：一般用在表现层
                * @Service：一般用在业务层
                * @Repository：一般用在持久层
注：以上三个注解他们的作用和属性与Component是一模一样。他们是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰

    2. bean的作用范围
        作用：用于指定bean的作用范围
        1. 在bean标签中的scope属性设置：
            取值：常用的就是单例的和多例的
                singleton：单例的（默认值）
                prototype：多例的
                request：作用于web应用的请求范围
                session：作用于web应用的会话范围
                global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session
        2. 使用注解配置
            @Scope("value")
            属性：value属性取值为 singleton（单例）；prototype（多例）

    3. bean的生命周期
        * 单例对象：单例对象的生命周期和容器相同
            出生：当容器创建时对象出生
            活着：只要容器还在，对象一直活着
            死亡：容器销毁，对象消亡
        * 多例对象
            出生：当我们使用对象时spring框架为我们创建
            活着：对象只要是在使用过程中就一直活着。
            死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收

    4. BeanFactory和 ApplicationContext 的区别
        * 层次不同：
            BeanFactory是Spring容器中的顶层接口，而ApplicationContext 是它的子接口。
        * 创建对象的时间点不同：
            ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。
            BeanFactory：什么使用什么时候创建对象

    5. ApplicationContext 接口的实现类
        * ClassPathXmlApplicationContext：
            它是从类的根路径下加载配置文件，推荐使用这种
        * FileSystemXmlApplicationContext：
            它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
        * AnnotationConfigApplicationContext:
            当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解

        获取容器：

 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

## 依赖注入：DI
    1. 概念：
        依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。
        我们的程序在编写时，通过控制反转，把对象的创建交给了spring，但是代码中不可能出现没有依赖的情况。 ioc解耦只是降低他们的依赖关系，但不会消除。
        依赖关系的管理，都交给spring来维护，在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明。
        例如：我们的业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用spring之后，就让spring来维护了。

    2. 作用：
        * 降低程序间的耦合（依赖关系）

    3. 三类依赖注入的数据：
        * 基本类型和String
        * 其他bean类型（在配置文件或者注解配置过的bean）
        * 复杂类型：array/set/map/list/properties，结构相同，标签可以互换
            用于给List结构集合注入的标签：list或array或set
            用于个Map结构集合注入的标签:map或props

    4. 三类依赖注入的方法：
        * 构造函数注入
        * set方法注入（更常用）
        * 注解注入

    5. 构造函数注入
        * 要求：该类里面有包含对应参数的构造方法
        * 使用的标签:constructor-arg
        * 标签出现的位置：bean标签的内部
        * 标签中的属性
            type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
            index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
            name：用于指定给构造函数中指定名称的参数赋值，常用的
            value：用于提供基本类型和String类型的数据
            ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
        * 优势：
            在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
        * 弊端：
            改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。

        <bean id="accountService" class="com.lyp.service.impl.AccountServiceImpl">
            <constructor-arg name="name" value="泰斯特"></constructor-arg>
            <constructor-arg name="age" value="18"></constructor-arg>
            <constructor-arg name="birthday" ref="now"></constructor-arg><!-- 指定其他的bean类型数据 -->
        </bean>
        <!-- 配置一个日期对象 -->
        <bean id="now" class="java.util.Date"></bean>

6. set方法注入（更常用）
        * 要求：该类里面有对应参数的注入成员的set方法
        * 使用的标签：property
        * 出现的位置：bean标签的内部
        * 标签的属性
            name：用于指定注入时所调用的set方法名称
            value：用于提供基本类型和String类型的数据
            ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
        * 优势：
            创建对象时没有明确的限制，可以直接使用默认构造函数
        * 弊端：
            如果有某个成员必须有值，则获取对象是有可能set方法没有执行。

        * 简单类型注入示例

            <bean id="accountService2" class="com.lyp.service.impl.AccountServiceImpl2">
                <property name="name" value="TEST" ></property>
                <property name="age" value="21"></property>
                <property name="birthday" ref="now"></property><!-- 指定其他的bean类型数据 -->
            </bean>
            <!-- 配置一个日期对象 -->
            <bean id="now" class="java.util.Date"></bean>

* 复杂类型(集合属性)注入示例

            <bean id="accountService3" class="com.lyp.service.impl.AccountServiceImpl3">
                <property name="myStrs"><!--数组:String[] myStrs-->
                    <set>
                        <value>AAA</value>
                        <value>BBB</value>
                        <value>CCC</value>
                    </set>
                </property>
        
                <property name="myList"><!--list:List<String> myList-->
                    <array>
                        <value>AAA</value>
                        <value>BBB</value>
                        <value>CCC</value>
                    </array>
                </property>
        
                <property name="mySet"><!--set:Set<String> mySet-->
                    <list>
                        <value>AAA</value>
                        <value>BBB</value>
                        <value>CCC</value>
                    </list>
                </property>
        
                <property name="myMap"><!--map:Map<String> myMap-->
                    <props>
                        <prop key="testC">ccc</prop>
                        <prop key="testD">ddd</prop>
                    </props>
                </property>
        
                <property name="myProps"><!--properties:Properties myProps-->
                    <map>
                        <entry key="testA" value="aaa"></entry>
                        <entry key="testB">
                            <value>BBB</value>
                        </entry>
                    </map>
                </property>
            </bean>

LiuYP_1024

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring-1-概述、IoC、bean对象、DI

# 内容1.Spring的概述* 概念* 优点* 两大核心* 体系结构2.IoC：控制反转3.bean对象* 创建bean对象的四种方式* bean的作用范围* bean的生命周期* BeanFactory和 Appli...
复制链接

扫一扫

专栏目录