爆肝15000字！Spring框架基础详解！

        因为开学要做项目的原因，花了整整一天的事件来复习spring的知识，并且对Spring中常用的东西进行总结，红字部分是相对重要的，大家可以多注意！如果本文有写的不对或者不明确的地方还希望大家可以在评论中指出。

目录

(1)Spring是什么，Spring可以干什么？

  （2）程序间的耦合

2.1什么是程序间的耦合？

 2.2什么是工厂模式，使用工厂模式解耦。

2.3控制反转

 3.基于xml的配置步骤。

3.1BeanFactory 和 ApplicationContext 的区别

3.2配置文件中bean标签的解释

3.3.bean的作用范围和生命周期

3.4 Spring的依赖注入

3.4.1什么是Spring的依赖注入

3.4.2 什么样的数据可以进行依赖注入，注入的方式？

 3.4.3构造函数来注入数据

  3.4.3set方法来注入数据

 3.4.4使用注解的方式来注入数据

3.4.5关于Spring注解和xml的选择问题

（4）AOP概述

 4.1什么是AOP？AOP的作用，优势？AOP的实现方式？

4.2Spring中AOP的细节

4.2.1需要明确

4.2.2AOP基于xml配置步骤

4.3.3基于注解的AOP配置

（5）Spring中的事务控制

5.1需要明确

5.2Spring中的事务控制的API的介绍

PlatformTransactionManager

TransactionDefinition

5.3事务的隔离级别 

5.4事务的传播行为 

 5.5基于注解的声明式事务配置方式

---

(1)Spring是什么，Spring可以干什么？

Spring是分层的javase/javaee应用的全栈轻量级开源框架，以IOC和AOP为内核，提供了SpringMVC和持久层SpringJDBC以及业务层等众多的企业级别应用技术，最主要可以整合其他的第三方框架的类库。

（1）方便解耦，简化程序的开发和维护。

Spring的Ioc容器，可以讲将对象之间的依赖关系交给Spring管理，避免因为编码造成的程序耦合太高，使得维护变得艰难

（2）AOP编程的支持

可以进行面向切面编程，许多用面向对象的功能AOP可以轻松应对。

（3）声明式事务的支持

可以进行更加灵活的事务管理。

  （2）程序间的耦合

2.1什么是程序间的耦合？

程序间的耦合性也叫做程序间的耦合度，就是模块之间关联程度的衡量，也就是模块间的依赖关系，包括控制，调用，数据传输，模块之间的耦合度越高，独立性越差，耦合度越高，维护成本越高，我们软件设计人员应该使类和构件之间的耦合度最小。

public class AccountServiceImpl implements IAccountService {
private IAccountDao accountDao = new AccountDaoImpl();
}

业务层调用持久层， 并且此时业务层在依赖持久层的接口和实现类。这种的依赖关系太强，在我们的程序中应该避免

public class JdbcDemo1 {

public static void main(String[] args) throws Exception {
//DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.jdbc.Driver");
}
}

我们早期使用JDBC的时候有使用Drivermanager的register方法，为了降低耦合度，所以我们在使用反射创建对象，即使是这种方式，也是直接将数据源的信息在源代码中写，我们如果修改数据源信息就要修改源码这样操作肯定是不友好的。所以我们需要设置一个数据源文件，在使用JDBC对业务层操作的时候，只需要加载配置文件，修改数据源信息的时候，也只需要修改配置文件，这样做就十分友好了！

 2.2什么是工厂模式，使用工厂模式解耦。

工程模式就是使用工厂来创建多个对象，在人们需要的时候直接拿来用就行了。

所以在实际开发的时候我们可以让工厂类读取配置文件，将这些对象创建并且存起来，再接下来使用的时候直接拿来就好。

2.3控制反转

1.上面讲述的问题，存到哪里去，应该是容器，就有map和list来选择，因为有查找的寻求，我们可以通过key：value来查找，所以使用的是map来存储，接下来用两张图来解释原来用关键子new来创建对象和使用工厂模式解耦的图示。

 

控制反转，缩写为IoC，把创建对象的权力交给框架而并非编码实现，是Spring框架的主要特征，它包括依赖注入和依赖查找。

 3.基于xml的配置步骤。

1.用maven导入spring坐标

2.在类的跟目录下创建一个非中文名的xml配置文件，同时给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">


<!-- bean 标签：用于配置让 spring 创建对象，并且存入 ioc 容器之中
 id 属性：对象的唯一标识。
 class 属性：指定要创建对象的全限定类名
-->


<!-- 配置 service --> 
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
</bean>
<!-- 配置 dao -->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>

</beans>

3. main方法读取配置文件

public class Client {
/**
 * 使用 main 方法获取容器测试执行
*/
public static void main(String[] args) {

//1.使用 ApplicationContext 接口，就是在获取 spring 容器
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

//2.根据 bean 的 id 获取对象，从Spring的Ioc容器中取出对象
IAccountService aService = (IAccountService) ac.getBean("accountService");

System.out.println(aService);
IAccountDao aDao = (IAccountDao) ac.getBean("accountDao");
System.out.println(aDao);
}
}

3.1BeanFactory 和 ApplicationContext 的区别

BeanFactory 才是 Spring 容器中的顶层接口。 ApplicationContext 是它的子接口。 BeanFactory 和 ApplicationContext 的区别：

创建对象的时间点不一样。

ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。

BeanFactory：什么使用什么时候创建对象。

3.2配置文件中bean标签的解释

作用：声明bean标签中的对象有交给SpringIoc来管理的

默认情况下调用类中的无参构造函数，没有无参构造函数会抛出异常

属性：id给对象在容器中提供一个唯一标识，用于方便获取对象。

        class指定类的全限定类名。用于反射创建对象，默认情况调用无参构造函数

        * singleton:默认值，单例的。

        * prototype :多例的.

        * request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.

        *session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.

        * global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么 globalSession 相当于 session.

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

3.3.bean的作用范围和生命周期

单例对象：scope = "singleton"

        对象出生：当应用加载，创建容器的时候，对象被创建。

        对象活着：只要容器在对象一直存在。

        对象死亡：应用卸载，销毁容器的时候，对象就被销毁了。

多例对象：scope = "prototype"

        对象出生：当使用对象的时候，创建新的对象实例。

        对象活着：只要对象在使用中对象就一直活着。

        对象死亡：和Spring容器没有关系，只是对象长时间不用了，就被java中的垃圾回收机制回收了。

3.4 Spring的依赖注入

3.4.1什么是Spring的依赖注入

依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。

我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。

ioc 解耦只是降低他们的依赖关系，但不会消除。

例如：我们的业务层仍会调用持久层的方法。 那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。 意思就是就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

3.4.2 什么样的数据可以进行依赖注入，注入的方式？

基本数据类型和String类

其他bean类，但是必须在配置文件中声明或者注解配置过的类

复杂类型，集合类型

注入的方式也有三种

（1）使用构造函数来注入

（2）使用set方法来提供

（3）使用注解来提供（一般都是使用注解来注入，在后面会讲到）

 3.4.3构造函数来注入数据

我们创建了三种不同类型的数据。

public class AccountServiceImpl implements IAccountService {
private String name;
private Integer age;
private Date birthday;
public AccountServiceImpl(String name, Integer age, Date birthday) {
this.name = name;
this.age = age;
this.birthday = birthday;
}
@Override
public void saveAccount() {
System.out.println(name+","+age+","+birthday);
}
}

 class要给全限定类名，

name就是在构造函数中的名称，

value大家懂的都懂把,

ref引用Spring容器中的对象。

但是有一个问腿在创建日期对象的时候并不能直接new一个日期，所以我们将Date类也交给Spring管理，然后再ref中引用Date的唯一标识就行了，

<bean id="accountService" class="com.itheima.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 id="now" class="java.util.Date"></bean>

  3.4.3set方法来注入数据

使用set方法来注入数据意思就是肯定要实现set方法啊要不然拿什么注入？？？

public class AccountServiceImpl implements IAccountService {
private String name;
private Integer age;
private Date birthday;
public void setName(String name) {
this.name = name;
}
public void setAge(Integer age) {
this.age = age;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Override
public void saveAccount() {
System.out.println(name+","+age+","+birthday);
}
}

 name：要注意，name是set后面跟的名字，并不是成员变量中的变量名！

剩下的和上面内容一样了

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<property name="name" value="test"></property>
<property name="age" value="21"></property>
<property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>

 3.4.4使用注解的方式来注入数据

1.使用注解的方式来注入数据，必须要配置注解扫描。

         ComponentScan
        作用:用于通过注解指定spring在创建容器时要扫描的包属性:
        value: 它和basePackages的作用是一样的，都是用于指定创建容器时要扫描的包我们使用此注解就等同于在xml中配置了:

<context:component-scan base-package="需要扫描的包的全限定类名"></context:component-scan>

2.修改xml配置文件约束context要加进来，context是允许Spring对注解的支持

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
 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
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd">

3.使用注解来配置管理的资源

下面来介绍几种注解：

        @Controller @Service @Repository这三种注解都是将类交给Spring管理他们的作用和属性是一样的，只不过他们提供了更加明确的语义化。

        @Controller：一般用于表现层的注解

        @Service：一般用于业务层的注解

        @Repository：一般用于持久层的注解

        @Component：泛指各种组件，就是说当我们的类不属于各种归类的时候（不属于@Controller、@Services等的时候），我们就可以使用@Component来标注这个类。

注意：当注解中有且只有一个属性要赋值的话，并且名称是value时候，value可以不写

        @Autowired：自动按照类型注入，使用注解完成对数据注入的时候，set方法可以省略。

        @Qualifier：在自动按照类型注入的基础上，再按照bean的id注入，给字段注入的时候需要和@Autowired一起使用，但是给方法注入的时候可以一起使用。

        @Vaule：哈哈哈这个不用说了，大家懂的都懂，不懂remake。

3.4.5关于Spring注解和xml的选择问题

我们讲述了Spring注解和xml的配置，所以我们要如何选择注解和xml来管理我们的类呢？首先Spring的管理是尤其简单的，配置也简单，但是是直接修改源码不太友好。但是xml一旦配置好了就无需再修改源码，但是如果有很多类需要注入那么配置xml的配置也会变得麻烦。

（4）AOP概述

 4.1什么是AOP？AOP的作用，优势？AOP的实现方式？

        AOP意思就是面向切面编程，通过预编译方式和动态代理实现程序功能的统一维护的技术，AOP是OOP的延续，是Spring框架中的一个重要内容，是函数式编程的衍生泛型，利用AOP可以对业务逻辑各个部分进行隔离，从而使得业务逻辑各部分之间耦合度的降低，提高程序的重用性，提高开发的效率。

        也就是把程序中重复的代码进行抽取，在需要执行的时候，采用动态代理的技术，在不修改源码的基础上，对已有方法进行增强。

4.2Spring中AOP的细节

Joinpoint(连接点): 所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的 连接点。

Pointcut(切入点): 所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。

4.2.1需要明确

(a)开发阶段：程序员需要做的：编写业务核心逻辑，把公共代码进行抽取制作成通知，在配置文件中声明切入点和通知间的关系

(b)运行阶段：Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对 象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

4.2.2AOP基于xml配置步骤

1.把通知类用bean标签包裹

2.用aop：config标签来声明aop的配置

3.在aop：config标签内部来配置切面

4.使用aop：pointcut来配置切入点表达式，用于指定对哪些类的哪些方法进行增强。

expression属性：用于定义切入点表达式。execution(切入点表达式)

该部分内容需要写在配置切面之前！！！

该部分内容需要写在配置切面之前！！！

该部分内容需要写在配置切面之前！！！

有同学会问切入点表达式怎么写？

                关键字：execution(表达式)
                表达式：
                    访问修饰符  返回值  包名.包名.包名...类名.方法名(参数列表)
                标准的表达式写法：
                    public void com.itheima.service.impl.AccountServiceImpl.saveAccount()
                访问修饰符可以省略
                    void com.itheima.service.impl.AccountServiceImpl.saveAccount()
                返回值可以使用通配符，表示任意返回值
                    * com.itheima.service.impl.AccountServiceImpl.saveAccount()
                包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
                    * *.*.*.*.AccountServiceImpl.saveAccount())
                包名可以使用..表示当前包及其子包
                    * *..AccountServiceImpl.saveAccount()
                类名和方法名都可以使用*来实现通配
                    * *..*.*()
                参数列表：
                    可以直接写数据类型：
                        基本类型直接写名称           int
                        引用类型写包名.类名的方式   java.lang.String
                    可以使用通配符表示任意类型，但是必须有参数
                    可以使用..表示有无参数均可，有参数可以是任意类型
                全通配写法：
                    * *..*.*(..)

                实际开发中切入点表达式的通常写法：
                    切到业务层实现类下的所有方法
                        * com.itheima.service.impl.*.*(..)

5.使用aop：xxx来配通知的类型

先来讲述四种通知类型：

        1.前置通知：在执行业务层代码之前执行。

        2.后置通知：在执行业务层代码之后执行。

        3.异常通知：发生异常在catch中执行异常通知。

        4.最终通知：人如其名，也就是在业务层代码最后执行。

        5.环绕通知：是Spring中可以手动控制控制代码增强的方式。

注意：异常通知和后置通知两者只能执行一个。

接下来介绍他们的标签：

        aop:before  前置通知        开启事务

        aop:after-returning        后置通知            提交事务    

        aop:after-throwing        异常通知                回滚事务

        aop:after        最终通知        释放资源

        aop:after        环绕通知

* 环绕通知实际上就是将方法写在哪一块就是对应的xx通知，比如方法写在执行业务层方法之前，那么就是前置通知，写在业务层代码之后就是后置通知。。。 

public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值
Object rtValue = null;
try {
//获取方法执行所需的参数
Object[] args = pjp.getArgs();
//前置通知：开启事务
beginTransaction();
//执行方法
rtValue = pjp.proceed(args);
//后置通知：提交事务
commit();
}catch(Throwable e) {
//异常通知：回滚事务
rollback();
e.printStackTrace();
}finally {
//最终通知：释放资源
release();
}
return rtValue;
}

4.3.3基于注解的AOP配置

1.在maven中导入Spring的坐标

2.导入xml中支持AOP和注解的约束。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
 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
 http://www.springframework.org/schema/aop
 http://www.springframework.org/schema/aop/spring-aop.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 配置数据库操作对象 -->
<bean id="dbAssit" class="com.itheima.dbassit.DBAssit">
<property name="dataSource" ref="dataSource"></property>
<!-- 指定 connection 和线程绑定 -->
<property name="useCurrentConnection" value="true"></property>
</bean>
<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property>
<property name="user" value="root"></property>
<property name="password" value="1234"></property>
</bean>
</beans>

3.在配置文件中开启要扫描的包

<context:component-scan base-package="需要扫描的包"></context:component-scan>

4.第四步将资源交给注解管理

 3.4.4使用注解的方式来注入数据

5.在通知类上声明这个类是一个切面使用@Aspect。

6.在增强的方法上使用注解来配置通知。

下面来介绍四个关于通知类型的注解：

        @Before （“execution（切入点表达式）”）       声明把当前方法看为前置通知

        @AfterReturning  （“execution（切入点表达式）”）         声明把当前方法看为后置通知.

        @AfterThrowing    （“execution（切入点表达式）”）       声明把当前方法看为异常通知

        @After  （“execution（切入点表达式）”）          声明把当前方法看为最终通知

7.在Spring配置文件中开启Spring对注解AOP的支持

<aop:aspectj-autoproxy/>

注意：Spring基于注解配置的四种通知类型有一个bug，就是在使用注解配置事务通知的时候，在不使用环绕通知的前提下，spring的事务通知是有顺序问题的！！！所以我们一般来说并不推荐使用这四种注解来配置AOP会造成一些问题，所以就有了环绕通知注解的配置。

8.Around（“execution（切入点表达式）”）   把当前方法看为环绕通知

        在使用环绕通知的时候和用xml配置文件配置的时候一样，都是如果是前置通知就写在业务层方法之前，是后置通知就写在业务层方法之后。。。

        问题引入：在配置注解的时候使用切入点表达式，那岂不是每一个注解上都得写上同样的切入点表达式？造成了我们代码的臃肿。

        解决办法：使用@Pointcut（“execution（切入点表达式）”）注解声明一个方法，然后只需要在后面需要切入点表达式的时候在本该使用切入点表达式的地方换做对该方法名的引用就行了。

 注意：在引用的时候不要少了方法名后面的括号！！！

 注意：在引用的时候不要少了方法名后面的括号！！！

 注意：在引用的时候不要少了方法名后面的括号！！！

（5）Spring中的事务控制

5.1需要明确

1.javaee体系进行分层开发，事务处理位于业务层，Spring为我们提供了分层设计业务层的事务处理解决方案。

2.Spring框架为我们提供一组事务控制的接口，这组接口是在 spring-tx-5.0.2.RELEASE.jar 中。

3.Spring中的事务控制都是基于AOP的，可以使用编程和配置的方法实现，我们学习的重点是使用配置的方法来实现，

5.2Spring中的事务控制的API的介绍

PlatformTransactionManager

此接口是Spring的事务管理器，提供了我们常用的操作事务的方法，

TransactionDefinition

它是事务的定义信息的对象，方法如下

5.3事务的隔离级别 

5.4事务的传播行为 

 5.5基于注解的声明式事务配置方式

1.将坐标导入到maven的pom中

2.创建Spring的配置文件导入约束，并且配置扫描的包。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:context="http://www.springframework.org/schema/context"
 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
 http://www.springframework.org/schema/aop
 http://www.springframework.org/schema/aop/spring-aop.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">
<!-- 配置 spring 创建容器时要扫描的包 -->
<context:component-scan base-package="com.itheima"></context:component-scan>

<!-- 配置 JdbcTemplate-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 配置 spring 提供的内置数据源 -->
<bean id="dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName"value="com.mysql.jdbc.Driver"></property>
    <property name="url"value="jdbc:mysql://localhost:3306/spring_day02"></property>
    <property name="username" value="root"></property>
    <property name="password" value="1234"></property>
</bean>
</beans>

3.将业务层接口和实现类让Spring管理

@Service("accountService")
public class AccountServiceImpl implements IAccountService {
@Autowired
private IAccountDao accountDao;
//其余代码和基于 XML 的配置相同
}

4.将dao接口和实现类都让Spring管理

@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
//其余代码和基于 XML 的配置相同
}

5.配置事务管理器并且注入数据源

<!-- 配置事务管理器 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>

6.在业务层使用@Transactional 注解

@Service("accountService")
@Transactional(readOnly=true,propagation=Propagation.SUPPORTS)
public class AccountServiceImpl implements IAccountService {
@Autowired
private IAccountDao accountDao;

该注解的属性和 xml 中的属性含义一致。该注解可以出现在接口上，类上和方法上。

出现接口上，表示该接口的所有实现类都有事务支持。

出现在类上，表示类中所有方法有事务支持 出现在方法上，表示方法有事务支持。

以上三个位置的优先级：方法>类>接口

7.在配置文件中开启Spring对注解事务的支持

<!-- 开启 spring 对注解事务的支持 -->
<tx:annotation-driven transaction-manager="transactionManager"/>