spring超全面详解

spring概述

Spring 是于2003年兴起的一款轻量级的,非侵入式的IOC和AOP的一站式的java开发框架
  为简化企业级应用开发而生.

1.轻量级:   就是指spring核心功能的jar包不大

2.非侵入式:  我们的业务代码不需要继承或实现spring中任何的类或接口

3.IOC:   控制反转    就是把创建对象的权利反转给spring框架

4.AOP:  面向切面编程    它是一种编程思想，是面向对象编程（OOP) 的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面

5.一站式框架:   Spring 本身也提供了数据访问功能和 web 功能,以及可以很好的管理其他框架

Spring 体系结构

Core Container(核心容器):

Beans:     管理 Beans

Core:       Spring 的核心,提供IOC容器的对象的创建并处理依赖对象关系

Context:  配置文件  就是Bean的关系的集合,也叫做IOC容器,调用了大部分spring-core中的方法

ExpressionLanguage: SpEL 表达式

AOP:    切面编程   使 Spring框架管理对象支持AOP，同时这个模块也提供了事务管理

ORM:   提供了对现有的ORM框架的支持，例如Hibernate，JDO，Mybatis等。

DAO:    提供了对数据访问对象（Data Access Object，DAO）模式和JDBC的支持，把实现业务逻辑和数据库访问的代码实现分离等。

Data Access(数据库整合): JDBC, ORM, OXM, JMS, Transaction

springWeb(MVC Web 开发):  是 spring 框架的一个模块，springWeb 和 spring 无需通过中间整合层进行整合,   是一个基于 mvc 的 web 框架,方便前后端数据的传输,    拥有控制器，接收外部求，解析参数传给服务层

spring搭建和测试

spring项目的搭建就是在Maven项目的基础上添加一些依赖并且进行一些配置

1.Maven 导入 spring 核心基础 jar

<!-- spring-context -->

< dependency >

< groupId >org.springframework</ groupId >

< artifactId >spring-context</ artifactId >

< version >5.2.2.RELEASE</ version >

</ dependency >

2. 编写 spring 配置文件

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

< bean id ="admin" class ="com.ffyc.spring.bean.Admin" > </ bean >

</ beans >

3. 编写一个 Admin 实体类

public class Admin {
    private int id;
    private String account;

    public Admin() {
        System.out.println("无参构造方法");
    }

    public Admin(int id, String account) {
        this.id = id;
        this.account = account;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    @Override
    public String toString() {
        return "Admin{" +
                "id=" + id +
                ", account='" + account + '\'' +
                '}';
    }
}

4.测试

 //读取spring配置文件,并对文件中配置的对象进行创建
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
                                       Admin admin = app.getBean("admin", Admin.class);
        System.out.println(admin);

IOC(控制反转)

概述:  它是一种 设计思想 ，就是 将原本在程序中手动创建对象的控制权，交由 Spring 框架来

管理。 IOC 容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个生命周期都是由容器来控制。我们需要使用的对象都由 ioc 容器进行管 理，不需要我们再去手动通过 new 的方式去创建对象，由 ioc 容器直接帮我们组装好，当我们需要使用的时候直接从 ioc 容器中直接获取就可以了。

正控： 若要使用某个对象，需要 自己去负责对象的创建

反控： 若要使用某个对象，只需要 从 Spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把 创建对象的控制权反转给了 Spring 框架.

底层实现方式: 解析 xml/扫描注解标签 + 工厂模式 + 反射机制

spring中bean的管理

1.基于 xml 配置方式依赖注入

在spring创建对象(控制反转)时,还需要为我们的对象属性进行初始化赋值,这个过程称为依赖注入

(1)get,  set  方式注入

 <bean id="admin" name="admin2" class="com.ffyc.ssm.model.Admin" scope="prototype">
           <property name="id" value="10"></property>
           <property name="account" value="admin"></property>
         
 </bean>     
	

(2)构造方法注入

  <bean id="admin" name="admin1" class="com.ffyc.ssm.model.Admin" scope="prototype">
            <constructor-arg name="id" value="100"></constructor-arg>
            <constructor-arg name="account" value="admins"></constructor-arg>
  </bean>

bean 配置需要 spring 管理的类,也叫做spring管理的类叫做bean对象

id 生成的对象名

class 全类名

name 对象别名,可以为多个

scope(bean的作用域): singleton(默认值):在 Spring 中只存在一个 bean 实例, 单例模式.  在spring启动时就会创建

prototype:原型 getBean()的时候都会 new Bean()

2.注解方式实现依赖注入

(1)注解需要的 jar 包,  注解功能封装在 AOP 包中，导入 Spring aop jar 包即可

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

(2)在spring中开启注解扫描

<context:component-scan base-package="包名"> </context:component-scan>

(3)利用注解方式创建对象

@Component(value=“admin”)也就是相当于 <bean id=“admin” class=“”></bean>

@Service

@Repository

以上注解都可以实现创建对象功能，只是为了后续扩展功能，在不同的层使用不同的注解标记

@Scope(value=“prototype”) 原型         @Scope(value=“ singleton ”) 单例

3.注解方式注入属性

(1)@Autowired

@Autowired 是 Spring 提供的注解,有两种方式进行注入

byType 自动注入

该注解默认使用按类型自动装配 Bean 的方式。

byName 自动注入

如果我们想使用按照名称（byName）来装配，可以结合@Qualifier 注解一起使用。

需要在引用属性上联合使用注解@Autowired 与@Qualifier。@Qualifier 的value 属性用于指定要匹配的 Bean 的 id 值。

  @Autowired 
    @Qualifier(value = "adminDao")
    AdminDao adminDao;

(2)@Resource 自动注入

S pring 提供了对 jdk 中@Resource 注解的支持。

@Resource 注解既可以按名称匹配 Bean，也可以按类型匹配 Bean。默认按照 ByType 自动注入

byName 注入引用类型属性

@Resource 注解指定其 name 属性，则 name 的值即为按照名称进行匹配的 Bean 的 id。

 @Resource(name = "adminDao")
    AdminDao adminDao;

4.注解与 XML 的对比

注解优点： 方便,直观,高效（代码少，没有配置文件的书写那么复杂）

注解缺点： 以硬编码的方式写入到 Java 代码中，修改是需要重新编译代码的。

xml 优点是： 配置和代码是分离的,在 xml 中做修改，无需编译代码，只需重启服务器即可将新的配置加载。

xml 的缺点是： 编写麻烦，效率低，大型项目过于复杂。

Spring JDBC

Spring 是个一站式框架：Spring 自身也提供了控制层的 SpringMVC 和 持久层的 Spring JdbcTemplate。

搭建步骤:

1.下载 Spring JdbcTemplate 的 jar 包

<!-- spring-jdbc -->

< dependency >

< groupId >org.springframework</ groupId >

< artifactId >spring-jdbc</ artifactId >

< version >5.2.2.RELEASE</ version >

</ dependency >

2.导入阿里巴巴提供的数据源管理组件  druid(德鲁伊)    

常用的数据库连接池组件:dbcp c3p0 数据源组件,封装了连接数据库,还有数据库连接池功能

<!-- 阿里数据源 -->

< dependency >

< groupId >com.alibaba</ groupId >

< artifactId >druid</ artifactId >

< version >1.1.10</ version >

</ dependency >

3.导入属性文件(config.properties)

classDriverName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/ssmdb?serverTimezone=Asia/Shanghai
uname=root
pwd=root

<context:property-placeholder location="config.properties"/>

4.管理数据源对象

spring 管理与数据库链接 (数据源)

 

<bean id="dataSource"class="com.alibaba.druid.pool.DruidDataSource">
<propertyname="driverClassName" value="${driverClassName}"></property>
<property name="url" value="${url}"></property>
<property name="username" value="${uname}"></property>
<property name="password" value="${pwd}"></property>
<property name="initialSize" value="10"></property>
<property name="minIdle" value="5"></property>
<property name="maxActive" value="20"></property>
</bean>

5.创建spring封装的jdbc

 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入数据源的对象-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

6.在类中获得 JdbcTemplate 对象，直接使用。

AOP(面向切面编程)

前言:     开发好一个版本后,后期如果需要添加新的功能,就需要修改原来的代码,加入调用新功能的代码.  这样开发就很麻烦,会存在大量的冗余代码.

概述:  AOP为Aspect Oriented Programming的缩写 面向切面编程,  它是 OOP 的延续，可以对业务逻辑和非业务逻辑进行隔离，从而使得各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 AOP、OOP 是面向不同领域的两种设计思想。OOP （面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分。 而 AOP 则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。

也就是将程序中的一些非业务代码进行提取,在不需要修改原来代码的情况下,为程序添加额外的功能.
非业务代码:  (验证权限,打印日志,提交事务,统一异常处理)

核心原理： 使用动态代理的方式在执行方法前后或者出现异常的时候做加入相关的逻辑.

使用案例: 事务处理：开启事务，关闭事务，出现异常后回滚事务

                权限判断：在执行方法前，判断是否具有权限

                日志：在执行前进行日志处理

 AOP 的基本概念

连接点（Joinpoint）： 类中可以被增强的方法，这个方法就被称为连接点

切入点（pointcut）： 类中有很多方法可以被增强，但实际中只有 add 和 update被增强了，那么 add 和 update 方法就被称为切入点（实际实现的连接点）

通知(Advice): 通知是指一个切面在特定的连接点要做的事情(增强的功能)。通知分为方法执行前通知，方法执行后通知，环绕通知等.

切面(Aspect): 把通知添加到切入点的整个过程称为切面.

目标(Target): 代理的目标对象(连接点,切入点所在类)

代理(Proxy): 向目标对象应用通知时创建的代理对象

springAOP 实现

AspectJ 是一个基于 Java 语言的 AOP 框架，它提供了强大的 AOP 功能,且其实现方式更为简捷，使用更为方便， 而且还支持注解式开发。所以，Spring 又将 AspectJ 的对于 AOP 的实现也引入到了自己的框架中。

首先下载 AOP 相关 jar

< dependency >

< groupId >org.springframework</ groupId >

< artifactId >spring-aspects</ artifactId >

< version >5.2.2.RELEASE</ version >

</ dependency >

1.基于 aspectj 的 xml 配置方式实现

AspectJ 中常用的通知有五种类型：

前置通知,后置通知,环绕通知,异常通知,最终通知

< bean id ="aopdemo" class ="com.ff.spring.aop.AopDemo" ></ bean >

< aop :config >

<!-- 配置切入点 -->

< aop :pointcut expression ="execution(*com.ff.spring.service.UserService.adduser(..))" id ="adduser" />

< aop :pointcut expression ="execution(*com.ff.spring.service.UserService.*(..))" id ="allmethod" />

<!-- 配置通知和切入点 -->

< aop :aspect ref ="aopdemo" >

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

< aop :after method ="savelog" pointcut-ref ="adduser" />

< aop :around method ="aroundAdvice" pointcut-ref ="adduser" />

< aop :after-throwing method ="exceptionAdvice" pointcut-ref ="allmethod"  throwing ="e" />

</ aop :aspect >

</ aop :config >

2.基于注解方式的实现

启动 AspectJ 支持:<aop:aspectj-autoproxy /> <!--自动代理-->

环绕通知可以包括前面的所有与通知

Spring 事物管理

概述:   事物可以看做是由对数据库若干操作组成的一个单元。

我们在开发企业应用时，对于业务人员的一个操作实际是对数据读写的多步操作的结合。由于数据操作在顺序执行的过程中，任何一步操作都有可能发生异常， 异常会导致后续操作无法完成，此时由于业务逻辑并未正确的完成，之前成功操作数据的并不可靠，需要在这种情况下进行回退。

事务的作用就是为了保证用户的每一个操作都是可靠的，事务中的每一步操作都必须成功执行，只要有发生异常就回退到事务开始未进行操作的状态,这些操作要么都完成，要么都取消，从而保证数据满足一致性的要求

Spring 中的事务管理分为两种形式,一种是编程式事务,一种是声明式事务.

编 程 式 事 务 在 项 目 中 很 少 使 用 , 这 种 方 式 需 要 注 入 一 个 事 务 管 理 对 TransactionTemplate ,然后在我们代码中需要提交事务或回滚事务时自己写代码实现.

声明式事务 管理建立在 AOP 基础上，本质是对方法前后进行拦截，所以声明式事务是方法级别的。

Spring 声明式事物管理方式有两种：

基于 xml 配置

基于注解实现

基于注解实现

1.配置事物管理器

<!-- 配置 spring 事务管理类, 并注入数据源 -->

< bean id ="transactionManager"

class ="org.springframework.jdbc.datasource.DataSourceTransactionManager" >

< property name ="dataSource" ref ="dataSource" ></ property >

</ bean >

2.开启注解事务管理 

< tx :annotation-driven transaction-manager ="transactionManager" />

3.在 service 中控制事务

@Service(value="adminDao")

@Transactional

@Transactional的用法

        一般把    @Transactional标签添加在service中,
        @Transactional可以添加在service层中类上,类中所有的方法都会添加事务管理功
        @Transactional如果只添加在某个方法上,那么表示此方法在事务管理中进行

@Transactional在以下6种情况下会失效.
         1.修饰一个非public的方法,底层权限只针对public修饰的方法
         2.方法中的异常被catch捕获处理了
         3.默认情况下出现编译期异常,事务不生效
            默认情况下只对运行期异常进行捕获@Transactional(rollbackFor = RuntimeException.class)
            我们可以把其修改为@Transactional(rollbackFor = Exception.class),这样就可以处理任意的异常
         4.@Transactional事务传播行为设置错误
         5.数据库引擎不支持事务, 数据库引擎是mysql底层具体的一种数据处理实现的机制
             常用的两个引擎: innodb(支持事务功能),myisam(不支持事务)
         6.在一个非事务方法中使用this(原始的对象==自己new出来的对象)     

Spring 事务传播行为

概述: 既然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。 事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。事务传播行为是 Spring 框架独有的事务增强特性，他不属于的事务实际提供方数据库行为

Spring 定义了七种传播行为：

PROPAGATION_REQUIRED       如果当前没有事务，就新建一个事务，如果已经存在一个事务中， 加入到这个事务中。这是最常见的选择。

PROPAGATION_SUPPORTS       支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY      使用当前的事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW       新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER        以非事务方式执行，如果当前存在事务，则抛出异常。

PROPAGATION_NESTED        如果当前存在事务，则在嵌套事务内执行。如果当前没有事务， 则执行与 PROPAGATION_REQUIRED 类似的操作。

Spring 集成 Mybatis

Spring 集成 Mybatis 其核心是将 SqlSessionFactory 交由 Spring 管理，并由

Spring 管理对 dao 接口的代理实现

1. 导入 mybatis jar 包

Spring 结合 mybatis 插件包

< dependency >

< groupId >org.mybatis</ groupId >

< artifactId >mybatis-spring</ artifactId >

< version >1.3.1</ version >

</ dependency >

2.配置 sqlSessionFactory

< bean id ="sqlSessionFactory" class ="org.mybatis.spring.SqlSessionFactoryBean" >

< property name ="dataSource" ref ="dataSource" ></ property >

< property name ="configLocation" value ="mybatis-config.xml" ></ property >

< property name ="mapperLocations" value ="com/ff/*Mapper.xml" >

</ property >

</ bean >

3.指定生成接口代理

< bean id ="mapperFactory" class ="org.mybatis.spring.mapper.MapperScannerConfigurer" >

< property name ="basePackage" value ="com.ff.ssm.dao" ></ property >

< property name ="sqlSessionFactoryBeanName" value ="sqlSessionFactory" >

</ property >

</ bean >

4.在 service 中注入 Dao 代理接口，此接口有 Spring 代理实现

@Resource
LoginDao loginDao;