【Spring编程】初识Spring-基础知识

Spring基础知识汇总

一、Spring简介

1、概述

Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用 Spring 框架来创建性能好、易于测试、可重用的代码。

Spring 是分层的 Java SE/EE full-stack 轻量级开源框架，以 IoC（Inverse of Control，控制反转）和 AOP（Aspect Oriented Programming，面向切面编程）为内核，使用基本的 JavaBean 完成以前只可能由 EJB 完成的工作，取代了 EJB 臃肿和低效的开发模式。

Spring 是一个轻量级的应用框架，具有很高的凝聚力和吸引力，其基础版本只有 2 MB 左右的大小。

Spring 框架的核心特性是可以用于开发任何 Java 应用程序，但是在 Java EE 平台上构建 web 应用程序是需要扩展的。 Spring 框架的目标是使 J2EE 开发变得更容易使用，通过启用基于 POJO 编程模型来促进良好的编程实践。

2、Spring框架的优点

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

二、Spring的体系结构

Spring 框架采用分层架构，根据不同的功能被划分成了多个模块，这些模块大体可分为 Data Access/Integration、Web、AOP、Aspects、Messaging、Instrumentation、Core Container 和 Test，如图 1 所示。

图 1 中包含了 Spring 框架的所有模块，这些模块可以满足一切企业级应用开发的需求，在开发过程中可以根据需求有选择性地使用所需要的模块。

1、Data Access/Integration（数据访问／集成）

数据访问/集成层包括 JDBC、ORM、OXM、JMS 和 Transactions 模块，具体介绍如下。

• JDBC 模块：提供了一个 JDBC 的抽象层，大幅度减少了在开发过程中对数据库操作的编码。
• ORM 模块：对流行的对象关系映射API，包括 JPA、JDO、Hibernate 和 iBatis 提供了的集成层。使用Spring-orm模块可以将这些O/R映射框架与Spring提供的所有其他功能结合使用,例如声明式事务管理功能。
• OXM 模块：提供了一个支持对象/XML映射的抽象层实现，如 JAXB、Castor、XMLBeans、JiBX 和
  XStream。
• JMS 模块：指 Java消息服务，包含的功能为生产和消费的信息。自Spring 4.1以后,提供了与Spring-messaging模块的集成。
• Transactions 事务模块：支持编程和声明式事务管理实现特殊接口类，并为所有的POJO (普通Java对象)类的编程和声明式事务管理。

2、Web 模块

Spring 的 Web 层包括 Web、Servlet、Struts 和 Portlet 组件，具体介绍如下。

• Web 模块：提供了基本的 Web 开发集成特性，例如多文件上传功能、使用的 Servlet 监听器的 IoC 容器初始化以及 Web应用上下文。
• Servlet模块：也称为Web-W模块,包含用于Web应用程序的Spring MVC和REST Web Services实现。Spring MVC框架提供了领域模型代码和Web表单之间的清晰分离,并与Spring Framework的所有其他功能集成,。包括 Spring 模型—视图—控制器（MVC）实现 Web 应用程序。
• Struts 模块：包含支持类内的 Spring 应用程序，集成了经典的 Struts Web 层。
• Portlet 模块：提供了在 Portlet 环境中使用 MVC实现，类似 Web-Servlet 模块的功能。

3、 Core Container（核心容器）

Spring 的核心容器是其他模块建立的基础，由 Beans 模块、Core 核心模块、Context 上下文模块和 Expression Language 表达式语言模块组成，具体介绍如下。

• Beans 模块：提供了 BeanFactory，是工厂模式的经典实现，Spring 将管理对象称为 Bean。
• Core 核心模块：提供了 Spring 框架的基本组成部分，包括 IoC 和 DI 功能。
• Context 上下文模块：建立在核心和Beans模块的基础之上，它是访问定义和配置任何对象的媒介。ApplicationContext 接口是上下文模块的焦点。
• Expression Language 模块：是运行时查询和操作对象图的强大的表达式语言。

4.、其他模块

Spring的其他模块还有 AOP、Aspects、Instrumentation 以及 Test 模块，具体介绍如下。

• AOP 模块：提供了面向切面编程实现，允许定义方法拦截器和切入点，将代码按照功能进行分离，以降低耦合性。
• Aspects 模块：提供与 AspectJ 的集成，是一个功能强大且成熟的面向切面编程（AOP）框架。
• Instrumentation 模块：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。
• Test 模块：支持 Spring 组件，支持使用JUnit或TestNG对Spring组件进行单元测试和集成测试。

三、Spring的核心容器

Spring的核心框架是其他模块建立的基础，由Spring-core、Spring-beans、Spring-context、Spring-context-support和Spring-expression（Spring表达式语言)等模块组成。

• Spring-core：提供了框架的基本组成部分，包括控制反转和注册依赖功能。
• Spring-beans：提供BeanFactory，是工厂模式的一个经典实现，Spring将管理对象称为Bean。
• Spring-context：提供一个框架式的对象访问方式，是访问定义和配置的任何对象的媒介。ApplicationContext接口是Context模块的焦点。
• Spring-context-support：支持整合第三方库到Spring的应用程序，特别是用于高速缓存和任务调度的支持。
• Spring-expression：提供了强大的表达式语言去支持运行时查询和操作对象图。这是对JSP2.1规范中规定的统一表达式语言(Unified EL)的扩展。该语言支持设置和获取属性值、属性分配、方法调用、访问数组、集合和索引器的内容、逻辑和算术运算、变量命名以及从Spring的1oC容器中以名称检索对象。它还支持列表投影、选择以及常见的列表聚合。

四、Spring的核心

核心就是管理资源组件及其依赖关系。包括IoC（Inversion of Control 控制反转）/ DI (Dependency Injection依赖注入)，Aop（Aspect Oriented Programming面向切面编程）。

1、Spring之IOC

依赖注入或控制反转的定文中，调用者不负责被调用者的实例创建工作，该工作由Spring框架中的容器米负责，它通过开发者的配置来判断实例类型，创建后再注入调用者。由于Spring容器负责被调用者实例，实例创建后又负责将该实例注入调用者，因此称为依赖注入。而被调用者的实例创建工作不两由调用者来创建而是由Spring来创建，控制权由应用代码转移到了外部容器，控制权发生了反转，因此称为控制反转。

2、IOC-控制反转

• IOC-Inversion of Control,即控制反转。它不是什么技术，而是一种设计思想。
• 传统的创建对象的方法是直接通过new 关键字，而spring 则是通过IOC 容器来创建对象，也就是说我们将创建对象的控制权交给了IOC
  容器。我们可以用一句话来概括IOC：IOC让程序员不在关注怎么去创建对象，而是关注与对象创建之后的操作，把对象的创建、初始化、销毁等工作交给spring容器来做。
• IOC概念:程序中开发者不需要人工的创建对象，而是把创建对象的权力或者工作转交给Spring容器(IOC容器) ，让Spring容器去创建并管理这些对象，以达到程序的高度解耦的目的!
• 耦合具有两面性（two-headed
  beast）。一方面，紧密耦合的代码难以测试、难以复用、难以理解，并且典型地表现出“打地鼠”式的bug特性（修复一个bug，将会出现一个或者更多新的bug）。另一方面，一定程度的耦合又是必须的——完全没有耦合的代码什么也做不了。为了完成有实际意义的功能，不同的类必须以适当的方式进行交互。总而言之，耦合是必须的，但应当被小心谨慎地管理。
• 从注入方法上看，IoC主要可以分为3种类型：①构造函数注入、②属性注入③接口注入。Spring支持构造函数注入和属性注入。

3、AOP

Aop（Aspect Oriented Programming面向切面编程）：我们知道OOP（面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分，如果在应用开发过程中，如果产生横切性问题，比如日志记录，权限验证，监控性能，异常处理等，这个时候AOP就上场了，AOP是通过预编译方式或者运行期动态代理实现的一种方式，AOP可以对业务逻辑的各个部分进行隔离，有效减少了系统间的重复代码，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

名称	说明
Joinpoint（连接点）	指那些被拦截到的点，在 Spring 中，可以被动态代理拦截目标类的方法。
Pointcut（切入点）	指要对哪些 Joinpoint 进行拦截，即被拦截的连接点。
Advice（通知）	指拦截到 Joinpoint 之后要做的事情，即对切入点增强的内容。
Target（目标）	指代理的目标对象。
Weaving（植入）	指把增强代码应用到目标上，生成代理对象的过程。
Proxy（代理）	指生成的代理对象。
Aspect（切面）	切入点和通知的结合。

五、Spring Bean的生命周期

Bean 生命周期的整个执行过程描述如下。

1）根据配置情况调用 Bean 构造方法或工厂方法实例化 Bean。

2）利用依赖注入完成 Bean 中所有属性值的配置注入。

3）如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。

4）如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。

5）如果 Bean 实现了 ApplicationContextAware 接口，则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用。

6）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的预初始化方法 postProcessBeforeInitialzation() 对 Bean 进行加工操作，此处非常重要，Spring 的 AOP 就是利用它实现的。

7）如果 Bean 实现了 InitializingBean 接口，则 Spring 将调用 afterPropertiesSet() 方法。

8）如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。

9）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()。此时，Bean 已经可以被应用系统使用了。

10）如果在 中指定了该 Bean 的作用范围为 scope=“singleton”，则将该 Bean 放入 Spring IoC 的缓存池中，将触发 Spring 对该 Bean 的生命周期管理；如果在 中指定了该 Bean 的作用范围为 scope=“prototype”，则将该 Bean 交给调用者，调用者管理该 Bean 的生命周期，Spring 不再管理该 Bean。

11）如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法将 Spring 中的 Bean 销毁；如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁。

Spring 为 Bean 提供了细致全面的生命周期过程，通过实现特定的接口或 的属性设置，都可以对 Bean 的生命周期过程产生影响。虽然可以随意配置 的属性，但是建议不要过多地使用 Bean 实现接口，因为这样会导致代码和 Spring 的聚合过于紧密。

六、Spring中Bean的作用域

作用域的种类

Spring 容器在初始化一个 Bean 的实例时，同时会指定该实例的作用域。Spring3 为 Bean 定义了五种作用域，具体如下。

1、singleton

单例模式，使用 singleton 定义的 Bean 在 Spring 容器中只有一个实例，这也是 Bean 默认的作用域。

< bean id=“person” class=“class=“com.swjd.bean.Person”” scope=“singleton”/>

2、prototype

原型模式，每次通过 Spring 容器获取 prototype 定义的 Bean 时，容器都将创建一个新的 Bean 实例。

< bean id=“person” class=“class=“com.swjd.bean.Person”” scope=“prototype”/>

3、request

在一次 HTTP 请求中，容器会返回该 Bean 的同一个实例。而对不同的 HTTP 请求，会返回不同的实例，该作用域仅在当前 HTTP Request 内有效。

4、session

在一次 HTTP Session 中，容器会返回该 Bean 的同一个实例。而对不同的 HTTP 请求，会返回不同的实例，该作用域仅在当前 HTTP Session 内有效。

5、global Session

在一个全局的 HTTP Session 中，容器会返回该 Bean 的同一个实例。该作用域仅在使用 portlet context 时有效。

七、Spring的配置

1、搭建项目

首先在新建好的Maven项目中找到pom.xml导入相应的依赖(< dependencies>内)

        
            org.springframework
            spring-context
            4.3.7.RELEASE
        
        
        
            org.springframework
            spring-core
            4.3.7.RELEASE
        
        
        
            org.springframework
            spring-beans
            4.3.7.RELEASE
        
        
            org.springframework
            spring-context-support
            4.3.7.RELEASE
        
        
        
            org.springframework
            spring-expression
            4.3.7.RELEASE
        

2、创建配置文件applicationContext.xml

①File（右击resources也可）—New—XML Configuration File—Spring Config(pom.xml中的依赖全下载好Spring Config才会显示)—applicationContext.xml

注意：配置文件官方推荐的命名为—applicationContext.xml，首字母不用大写
②输入applicationContext.xml后点击OK，最上方会出现一条黄色的线，点击Configure application context，在跳出的页面点击OK则真正创建成功

3、在Spring容器内创建对象

• 首先要创建一个实体类(Person)-----必须要有无参的构造方法

//创建实体类
public class Person {
    private int id;
    private String name;
    private String sex;

    public Person() {
        System.out.println("用无参构造方法创建");
    }

    public Person(int id, String name, String sex) {
        System.out.println();
        this.id = id;
        this.name = name;
        this.sex = sex;
    }

• 在applicationContext.xml创建对象

<!--Spring容器 管理创建对象-->
    <!--配置对象 id表示对象名 class表示对象从person类中创建(要写全路径)，name可以有多个，不同对象不可重复 -->
    <!--方式一:无参构造方法创建对象-->
    <bean id="p1" name="person" class="com.swjd.bean.Person">
    <!--DI注入 本质调用set的方法赋值-->
        <property name="id" value="957"></property>
        <property name="name" value="貂蝉"></property>
        <property name="sex" value="女"></property>
    </bean>

4、用Spring框架在测试类调用对象

public static void main(String[] args) {
       //以前的方式
       /*Person person=new Person();
       System.out.println(person);*/

       //用Spring容器(IOC控制反转)
       //1.启动并加载spring框架(可创建多个 名字不同就可)
       ClassPathXmlApplicationContext context=
               new ClassPathXmlApplicationContext("applicationContext.xml");
       //2.拿Person对象---测试单例
       //测试无参的构造方法创建对象
       Person person=context.getBean("p1",Person.class);
       System.out.println(person);
       person.setName("妲己");
       System.out.println(person);

八、Bean标签的属性

1、id属性

id：是bean对象的唯一标识(表示对象名)，不能添加特别字符，一个对象只能有一个id

2、class属性

class：指定bean对应类的全路径，表示对象从person类中创建。如：

<bean id="p1" class="com.swjd.bean.Person"></bean>

3、name属性

name：是bean对应对象的一个标识，一个对象只能有一个id，但是可以拥有很多name，不同实体对象的name亦不可重复。

若name值一样，则在测试类引用实体对象时程序无法识别你引用的到底是p1对象还是p2对象。

4、property属性

property：< bean>元素的子元素，用于调用 Bean 实例中的 Set 方法完成属性赋值，从而完成依赖注入。该元素的 name 属性指定 Bean 实例中的相应属性名

 < bean id="p1" name="person" class="com.swjd.bean.Person">
	< property name="id" value="957">< /property>
 < /bean>

5、scope属性

scope：执行bean对象创建模式和生命周期，表示创建的容器的作用域是单例模式还是多例模式（默认为单例模式）。

//单例模式，若更改值，改的便是同一实体
 scope="singleton"

//表示创建的对象是多例(每次使用对象的时候会额外创建一个新的)
 scope="prototype"

若更改值，实体不会受影响。

Scope="request"表示再一次请求范围内，Spring容器中的对象保持一个，公用同一个。
Scope="session"表示再一次会话范围内，Spring容器中的对象保持一个，公用同一个。
注意：后两个只能用在web项目里

6、lazy-init属性

• lazy-init：是否延时加载，默认值为false，表示对象的加载时机，只对单例模式有效。
• lazy-int=“default”：Spring容器启动，对象就立即创建！默认值！
• lazy-init=“true”：延迟创建！懒加载，使用对象的时候才创建对象！
• lazy-init=“false”：Spring框架一使用就加载！

7、Init-method属性

首先要在实体类中添加初始化的方法

//初始化
    public void init(){
        System.out.println("对象创建完，就调用");
    }

Init-method：对象初始化方法，表示对象创建完成后调用的方法。

//使用
init-method="init"

8、Destroy-method属性

首先要在实体类中添加销毁的方法

//销毁
    public void destroy(){
        System.out.println("已销毁");
    }

Destroy-method：对象销毁方法，对象销毁后调用的方法。

//使用
 destroy-method="destroy"

9、constructor-arg属性

constructor-arg：< bean>元素的子元素，可以使用此元素传入构造参数进行实例化。该元素的 index 属性指定构造参数的序号（从 0 开始），type 属性指定构造参数的类型

 <bean id="p1" name="person" class="com.swjd.bean.Person">
	<constructor-arg index="0" type="int" value="34522"/>
    <constructor-arg index="1" type="java.lang.String" value="妲己"/>
 </bean>

10、ref属性

ref：< property> 和 < constructor-arg> 等元素的子元索，该元素中的 bean 属性用于指定对 Bean 工厂中某个 Bean 实例的引用

 <bean id="p1" name="person" class="com.swjd.bean.Person">
	<constructor-arg index="2" type="int" value="3"/>
    <!--引用注入对象二-->
    <constructor-arg index="3" type="com.swjd.bean.Dog" ref="d2"/>
</bean>

11、value属性

value：< property> 和 < constractor-arg> 等元素的子元素，用于直接指定一个常量值

12、list属性

list：用于封装 List 或数组类型的依赖注入

13、set属性

set：用于封装 Set 类型属性的依赖注入

14、map属性

map：用于封装 Map 类型属性的依赖注入

15、entry属性

entry： 元素的子元素，用于设置一个键值对。其 key 属性指定字符串类型的键值，ref 或 value 子元素指定其值

九、DI-依赖注入

注意：DI依赖注入，要保留实体类中get/set方法和空的构造方法。

十、SpringDI-基本依赖注入的方式

1、调用set方式注入

	<bean id="m1" class="com.swjd.bean.Man">
        <!--方式一:调用set方法注入-->
        <property name="id" value="34521"/>
        <property name="name" value="李白"/>
        <property name="age" value="2"/>
      </bean>

2、通过带参的构造方法注入

	<bean id="m2" class="com.swjd.bean.Man">
        <!--方式二:调用带参的构造方法注入-->
        <constructor-arg index="0" type="int" value="34522"/>
        <constructor-arg index="1" type="java.lang.String" value="妲己"/>
        <constructor-arg index="2" type="int" value="3"/>
 	</bean>

3、P命名空间注入

 <!--方式三:P命名空间注入(本质依旧是set注入)-->
    <bean id="m3" class="com.swjd.bean.Man"
          p:id="34523" p:name="八戒" p:age="1">
     </bean>

4、Spel表达式注入

	<bean id="m4" class="com.swjd.bean.Man">
        <!--方式四:Spel表达式注入-->
        <property name="id" value="#{m1.id}"/>
        <property name="name" value="#{m2.name}"/>
        <property name="age" value="#{m3.age}"/>
    </bean>

十一、创建Spring对象的方法

1、无参数的构造方法

<!--方式一:无参构造方法创建对象-->
    <bean id="p1" name="person" class="com.swjd.bean.Person">
        <!--DI注入 本质调用set的方法赋值-->
        <property name="id" value="957"></property>
        <property name="name" value="貂蝉"></property>
        <property name="sex" value="女"></property>
    </bean>

2、有参数的构造方法

<!--方式二:有参构造方法创建对象-->
    <bean id="p3" class="com.swjd.bean.Person">
        <constructor-arg index="0" type="int" value="9528"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" value="德玛西亚"></constructor-arg>
        <constructor-arg index="2" type="java.lang.String" value="男"></constructor-arg>
    </bean>

3、静态工厂创建对象

//静态工厂
public class PersonFactory {
    //创建person的静态方法
    public static Person createPerson(){
        System.out.println("通过静态工厂创建对象");
        return new Person(914,"红灰太狼","男");
    }
}

<!--方式三:用静态工厂创建对象-->
    <bean id="p4" class="com.swjd.beanFactory.PersonFactory" factory-method="createPerson"></bean>

4、非静态工厂创建对象

//非静态工厂
public class NoStaticPersonFactory {
    //创建person的非静态方法
    public  Person createPerson(){
        System.out.println("通过非静态工厂创建对象");
        return new Person(914,"红灰小狼","男");
    }
}

<!--方式四:用非静态工厂创建对象 不可直接拿对象-->
    <bean id="noStaticFactory" class="com.swjd.beanFactory.NoStaticPersonFactory"></bean>
    <bean id="p5" factory-bean="noStaticFactory" factory-method="createPerson"></bean>

十二、复杂类型注入的方法

例：人要养一条狗，建一个狗的实体类，然后在Man实体类中封装一个狗的对象，get/set方法toString都要有，接下来开始四种不同依赖注入对象

1、注入对象

2、注入数组

实体类：

public class Student {
    private String name;
    private String[] hobbies; //爱好
    private List<String> subject; //科目
    private Map<String,Object> map;

    public Student() {
    }

<!--复杂类型的注入-->
    <bean id="s1" class="com.swjd.bean.Student">
        <property name="name" value="小许鸭"/>
        <!--注入数组-->
        <property name="hobbies">
            <array>
                <value>喜欢你</value>
                <value>喜欢我</value>
                <value>喜欢大家</value>
            </array>
        </property>
      </bean>

3、注入集合list、set

	<bean id="s1" class="com.swjd.bean.Student">
	<!--注入集合 list、set相同-->
        <property name="subject">
            <list>
                <value>MyBatis</value>
                <value>Spring</value>
                <value>Oracle</value>
            </list>
        </property>
      </bean>

4、注入map

<bean id="s1" class="com.swjd.bean.Student">
	<!--注入Map-->
        <property name="map">
            <map>
                <entry key="CN">
                    <value>中国</value>
                </entry>
                <entry key="HG">
                    <value>韩国</value>
                </entry>
                <entry key="RU">
                    <value>俄罗斯</value>
                </entry>
            </map>
        </property>
      </bean>