Spring学习总结

Spring学习笔记

创建时间：	2019/1/14 星期一 14:20
更新时间：	2019/1/16 星期三 13:29
作者：	1098360241@qq.com

1.Spring的特点

（1）轻量级：Spring 是非侵入性的 - 基于 Spring 开发的应用中的对象可以不依赖于 Spring 的 API 依赖注入。

（2）(DI --- dependency injection、IOC)。

（3）面向切面编程(AOP --- aspect oriented programming) 。

（4）容器： Spring 是一个容器, 因为它包含并且管理应用对象的生命周期。 

（5）框架 ：Spring 实现了使用简单的组件配置组合成一个复杂的应用，在 Spring 中可以使用 XML 和 Java 注解组合这些对象 。

（6）一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库 （实际上 Spring 自身也提供了展现层的 SpringMVC 和 持久层的 Spring JDBC）。

2.Spring的功能

（1）Spring 容器提供了IOC机制，可以创建对象以及管理对象之间的调用关系，避免了硬编码造成的程序耦合。

（2）Spring 提供了AOP（面向切面编程方式）功能，可以实现很多特定功能声明式事务控制处理。

（3）Spring对JDBC进行了轻量级的封装，可以更加灵活的去操作数据库 。

（4）Spring提供了MVC设计模式的解决方案 

（5）Spring提供了文件上传、定时器等常用工具类 。

（6）Spring提供了对于其他优秀框架的支持（如：Struts、Hibernate、MyBatis、Quartz等）。

3.Spring体系结构 

    

 1.core container

    a.beans与core 它们提供spring框架最基本功能，包含ioc与di。

    b.context 上下文对象，基于beans与cores。

    c.spel它是spring提供的一个表达式语言。

 2.Data access/integration

    d.数据访问。

    e.集成。

 3.Web

    f.Spring本身提供spring mvc。

    g.也可以与其它的web层进行集成。

 4.AOP

    h.AOP大部分情况下是使用动态代理来实现的。

 5.Test

    i.使用spring可以方便的进行测试。

Spring的jar包下载

Spring的官网：spring.io

本次学习使用的是spring4.2.4

 

在spring3.0.2版本后，不在提供依赖jar包

 

其中：docs 存在API和规范文档

          libs 开发jar包

          schema 开发过程中需要的xml的schema约束

4.总结spring使用步骤

    1.在applicationContext.xml文件中配置bean

    2.创建一个AppliCationContext对象

    ApplicationContext它是BeanFactory的一个子接口，我们在使用时使用的是AppliCationContext的实现类ClassPathXmlApplicationContext

   

    可以通过getBean(配置文件中id名称)来获取指定的对象。

 

5.Bean获取与实例化

ApplicationContext与BeanFactory关系

ApplicationContext它是扩展BeanFactory接口。

BeanFactory它采取延迟加载的方案，只有真正在getBean时才会实例化Bean

 

在开发中我们一般使用的是ApplicationContext,真正使用的是其实现类,

FileSystemXmlAppliCationContext 根据文件路径获取

ClassPathXmlApplicationContext  根据类路径获取

AppliCationContext它会在配置文件加载时，就会初始化Bean,并且ApplicationContext它提供不同的应用层的Context实现。例如在web开发中可以使用WebApplicationContext.

 

Bean的实例化方式

1.无参数构造

对于这种方式，注意Bean类中必须提供无参数构造。

 

2.静态工厂方法

需要创建一个工厂类，在工厂类中提供一个static返回bean对象的方法就可以。

 

3.实例工厂方法

需要创建一个工厂类，在工厂类中提供一个非static的创建bean对象的方法，在配置文件中需要将工厂配置，还需要配置bean

每一个类实现了Bean的规范才可以由Spring来接管，那么Bean的规范是什么呢？

• 必须是个公有(public)类
• 有无参构造函数
• 用公共方法暴露内部成员属性(getter,setter)

实现这样规范的类，被称为Java Bean。即是一种可重用的组件。

Spring框架，通过以下方式，决定如何初始化容器：

方式一：Spring通过扫描指定包中的类，通过类上的注解，决定容器中，是否初例化该对象

方式二：XML添加

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

<property name="user" value="${jdbc.user}"></property>

</bean>

//如上bean标签的作用，就是实例化对象，上述等价如下java代码

ComboPooledDataSource dataSource = new ComboPooledDataSource();

dataSouce.user = ${jdbc.user}

 

Bean的作用域

在bean声明时它有一个scope属性，它是用于描述bean的作用域。

可取值有:

    singleton:单例 代表在spring ioc容器中只有一个Bean实例 (默认的scope)

    prototype多例 每一次从spring容器中获取时，都会返回一个新的实例

    request 用在web开发中，将bean对象request.setAttribute()存储到request域中

    session 用在web开发中，将bean对象session.setAttribute()存储到session域中

在开发中常用的值是singleton与prototype

 

Bean的生命周期

1.instantiate bean对象实例化

2.populate properties 封装属性

3.如果Bean实现BeanNameAware执行setBeanName

4.如果Bean实现BeanFactoryAwar或ApplicationContextAwar设置工厂setBeanFactory或上下文对象setApplicationContext

5.如果存在类实现BeanPostProcessor(后处理Bean),执行postProcessBeforeInitialization

6.如果Bean实现InitializingBean执行afterPropertiesSet

7.调用自定义的init-method方法

8.如果存在类实现BeanPostProcessor(处理Bean),执行postProcessAfterInitialization

9.执行业务处理

10.如果Bean实现DisposableBean执行destroy

11.调用自定义的destroy-method

 

对于bean的生命周期方法:

    第三步与第四步是让Bean了解spring容器。

    第五步与第八步 可以针对指定的Bean进行功能增强，这时一般会使用动态代理.

    第六步与第十步:通过实现指定的接口来完成init与destroy操作

    但是在开发中一般不使用第6步与第10步，原因是我们可以使用第7步与第11步来完成。

    第7步与第11步的初始化与销毁操作它无耦合，推荐使用的。但是必须在配置文件中指定初始化与销毁的方法

  

总结:

    对于bean的生命周期，我们需要关注的主要有两个方法:

        1.增强bean的功能可以使用后处理Bean, BeanPostProcessor

        2.如果需要初始化或销毁操作我们可以使用init-method  destroy-method

        注意:destroy-method只对scope=singleton有效果。

6.DI（Dependency Injection，依赖注入）/IoC (Inversion of Control)控制反转

IoC (Inversion of Control)，控制反转，用白话来讲，就是由容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。

相对IoC而言“依赖注入DI (Dependency Injection)”的确更加准确的描述了这种古老而又时兴的设计理念。从名字上理解，所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，形象的来说，即由容器动态的将某种依赖关系注入到组件之中。

注意：依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同，依赖注入是从应用程序的角度在描述，应用程序依赖容器创建并注入它所需要的外部资源，控制反转从容器的角度在描述，容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源。

1） 应用程序依赖 spring 注入所需要的对象

2） setter 注入：在配置文件中将接口的实现配置为 bean 在应用程序中注入

bean

例如：

在配置文件中

<bean name=”dao” class=”daoImpl”>

<property name=”cc” ref=”cc”>

</bean>

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3） 构造器注入

<constructor-arg>

4） ref 表示参照其它的 bean

在参照的过程中一定要注意死循环

5） 自动装配-----------〉no

自动装配根据名字来匹配相应的 bean 尽量不要去自动装配

6） lookup 注入

7）singleton：单例模式是整个的 jvm 中只有一个实例，spring 的 singleton 是指在 spring 的容器中只有一个实例，一个生命周期中只有一个实例

8）DI依赖注入 的优点：

1.程序被动等待，强化面向接口编成

2.切断了对象或组件之间的联系，使程序的结构更加松散，运行和维护更加简单

7.AOP（Aspect Oriented Programming，面向切面编程）

      1.含义：在面向对象编程（oop）思想中，我们将事物纵向抽成一个个的对象。而在面向切面编程中，我们将一个个的对象某些类似的方面横向抽成一个切面，对这个切面进行一些如权限控制、事物管理，记录日志等公用操作处理的过程就是面向切面编程的思想。AOP 底层是动态代理，如果是接口采用 JDK 动态代理，如果是类采用CGLIB 方式实现动态代理。在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应用, 并且不必修改受影响的类. 这样一来，横切关注点就被模块化到特殊的对象(切面)里。

    2.AOP的优点：每个事物逻辑位于一个位置, 代码不分散, 便于维护和升级；业务模块更简洁, 只包含核心业务代码。

    3.AOP的实现原理

        AOP依赖于动态代理模式的实现。其中重要的组成部分包括：连接点（Joinpoint）、通知（Advice）、切入点（Pointcut）、引入（Introduction）、目标对象（Target Object）、AOP 代理（AOP Proxy）和织入（Weaving）；AspectJ：Java 社区里最完整最流行的 AOP 框架，提供了几种常见的通知类型参考：前置通知（Before advice）、返回后通知（After returning advice）、抛出异常后通知（After throwing advice）、后通知（After (finally) advice）、环绕通知（Around Advice）。环绕通知的功能最为强大，它可以实现其他所有类型通知的功能，还能够决定连接点方法的执行方式、是否执行、是否伪造返回值、是否伪造参数等，Spring中可以使用Schema风格的XML配置和AspectJ方式配置两个风格对AOP进行配置，功能类似。

4.利用XML配置装配AOP

利用XML配置进行AOP组件的声明装配：

注意：当使用 XML 声明切面时, 需要在 <beans> 根元素中导入 aop Schema。 

          在 Bean 配置文件中, 所有的 Spring AOP 配置都必须定义在 <aop:config> 元素内部，对于每个切面而言, 都要创建一个 <aop:aspect> 元素来为具体的切面实现引用后端 Bean 实例。

          一个application context可以包含多个 <aop:config>， 一个 <aop:config> 可以包含pointcut，advisor和aspect元素（注意它们必须按照这样的顺序进行声明）。

          切面 Bean 必须有一个标示符, 供 <aop:aspect> 元素引用。

AOP命名空间及Schema示例

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

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

       xmlns:jpa="http://www.springframework.org/schema/data/jpa"

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

       xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans.xsd

              http://www.springframework.org/schema/data/jpa  http://www.springframework.org/schema/data/jpa/spring-jpa.xsd

              http://www.springframework.org/schema/tx  http://www.springframework.org/schema/tx/spring-tx.xsd

              http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd

               http://www.springframework.org/schema/aop  http://www.springframework.org/schema/aop/spring-aop.xsd" >

切点切面的配置，利用Spring的AOP来重新实现代理模式的应用示例。示例：FBI监视嫌疑人的qq聊天，Msn情况。

定义切点和切面类并将其加入Spring容器：

Man.java类

public class Man {

 

       private String name;

       public String getName() {

              return name;

       }

       public void setName(String name) {

              this.name = name;

       }

}

 

FBI.java类

 

public class Man {

       private String name;

       public String getName() {

              return name;

       }

       public void setName(String name) {

              this.name = name;

       }

       

       public void qq() {

              

              System.out.println("我在聊qq");

              

       }

       

       public void msn() {

              

              System.out.println("我在聊msn");

              

       }

}

加入Spring容器

 

<bean id="man" class="com.sitech.springAop.Man" p:name="XiaoMing">

<bean id="fbi" class="com.sitech.springAop.FBI">

 

配置切入点并进行织入装配

 

<aop:config>

    <aop:pointcut id="manPointcut" expressions="execution(*com.sitech.springAop.Man.*(..))" />

    <aop:aspect  id="beroreExample" ref="fbi">

        <aop:before pointcut-ref="manPointcut" method="before" />

    </aop:aspect>

</aop:config>

 

1.配置切入点，expression指明切入点表达式，表明切入的目标连接点

2.声明通知（before说明声明的是前置通知），说明绑定的切入点和通知方法

注意：aop:config是AOP配置的根标签，所有的AOP配置都在它的内部

 

测试程序

 

public class AopTest {

       

       public static void main(String[] args) {

              

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

              Man man = context.getBean("man",Man.class);

              man.qq();

              man.msn();

       }

}

 

从上例可以看到，Spring中使用切入点表达式来明确切点和切面增强的装配关系，Spring AOP 支持在切入点表达式中使用如下的格式：

 

方法	说明
execution	匹配方法执行的连接点，这是将会用到的Spring的最主要的切入点指定者
within	限定匹配特定类型的连接点（在匹配的类型中定义的方法的执行）
this	限定实现特定接口的代理对象连接点
target	限定实现特定接口的目标对象（非代理对象）连接点
args	限定匹配特定的连接点，其中参数是指定类型的实例
@target	限定匹配特定的连接点，其中实际执行的对象本身（属性变量上）已经有指定类型的注解
@args	限定匹配特定的连接点，其中实际传入参数的运行时类型有指定类型的注解
@within	限定匹配特定的连接点，其中连接点所在类型已指定注解
@annotation	限定匹配特定的连接点，其中连接点的主题有某种给定的注解
bean	按bean的id匹配，匹配的bean中全部方法作连接点，可以使用Bean的id或name进行匹配，并且可使用通配符“*”

 

在切入点表达式中描述类型、方法时可以使用通配符进行多目标匹配： 

 

通配符	说明
*	匹配任何数量字符
..	匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数
+	匹配指定类型的子类型；仅能作为后缀放在类型模式后边

示例：

表达式	匹配
java.lang.String	匹配String类型
java.*.String	匹配java包下的任何直接子包下的String类型如java.lang.String，但不匹配java.lang.ss.String
java..*	匹配java包及任何子包下的任何类型; 如java.lang.String、java.lang.annotation.Annotation
java.lang.*ing	匹配任何java.lang包下的以ing结尾的类型
java.lang.Number+	匹配java.lang.Number的子类型；  如匹配java.lang.Integer，也匹配java.math.BigInteger

（1）具体的切入点匹配表达式类型：匹配类型部分使用如下方式匹配（？表示可选）：

方式：注解？ 类的全限定名字  

注意：注解：可选，类型上持有的注解，如@Deprecated；

     类的全限定名：必填，可以是任何类全限定

（2）匹配方法部分使用如下方式匹配：      

方式：注解？ 修饰符? 返回值类型 类型声明?方法名(参数列表) 异常列表？ 

注意：注解： 可选，方法上持有的注解，如@Deprecated 修饰符： 可选，如public、protected 

     返回值类型： 必填，可以是任何类型模式；“*”表示所有类型     

     类型声明： 可选，可以是任何类型模式 方法名： 必填，可以使用“*”进行模式匹配 

     参数列表（以,分割）：“()”表示方法没有任何参数；“(..)”表示匹配接受任意个参数的方法，“(..,java.lang.String)”表示匹配接受java.lang.String类型的参数结束，且其前边可以接受有任意个参数的方法；

                        “(java.lang.String,..)” 表示匹配接受java.lang.String类型的参数开始，且其后边可以接受任意个参数的方法；

                        “(*,java.lang.String)” 表示匹配接受java.lang.String类型的参数结束，且其前边接受有一个任意类型参数的方法 

     异常列表： 可选，以“throws 异常全限定名列表”声明，异常全限定名列表如有多个以“，”分割，如throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException 

 

 

转载于:https://www.cnblogs.com/zylong1220/p/10276530.html