Spring总结篇

---

Spring框架总结并与MyBatis整合

---

什么是Spring？

Spring是一个开源框架，它是为了解决企业应用开发的复杂性而创建的。它的的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的J一站式)轻量级开源框架。

为什么spring是一站式轻量级框架？

①spring是非侵入式编程，spring的实现不需要继承类也不需要实现接口

②它支持Java的三层开发（即数据库层、表现层、业务逻辑层）

Spring框架的整体架构

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

•Spring Core(核心容器)：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
•Spring Context(Spring上下文)：pring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
•Spring AOP(面向切边编程)：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
•Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
•Spring ORM：Spring 框架插入了若干个 ORM (对象关系映射)框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
•Spring Web：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
•Spring MVC：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

spring的安装、配置？

​ 1、进入spring的官方网址，下载最新spring jar包。：http://spring.io/ 进入projects
这个就是各个spring版本的下载地址： http://repo.spring.io/release/org/springframework/spring 而且很清楚的告诉你下载哪个文件

​ 2、在项目的lib中引用需要的jar，项目就可以使用spring了

Spring框架搭建步骤：

①导入jar包

<!-- spring开发依赖的jar  star-->
    <!-- spring-core -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring-version}</version>
    </dependency>
    <!-- spring-context -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring-version}</version>
    </dependency>
    <!-- spring-beans -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring-version}</version>
    </dependency>
    <!-- spring-expression -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>5.1.8.RELEASE</version>
    </dependency>
    <!-- commons-logging -->
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.2</version>
    </dependency>
    <!-- log4j -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
    <!-- spring开发依赖的jar  end-->
     <!-- spring-aop start -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.1.8.RELEASE</version>
    </dependency>
    <!-- aopalliance -->
    <dependency>
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>
      <version>1.0</version>
    </dependency>
    <!-- aspectjweaver -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.4</version>
    </dependency>
    <!-- spring-aop end -->
     <!-- mysql -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.16</version>
    </dependency>
    <!-- mybatis -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>

    <!-- 数据源 start-->
    <!-- commons-dbcp2 -->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-dbcp2</artifactId>
      <version>2.6.0</version>
    </dependency>
    <!-- commons-pool2 -->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-pool2</artifactId>
      <version>2.6.0</version>
    </dependency>
    <!-- 数据源 end-->

②配置spring-config.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-beans.aop
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean>
    ...
    </bean>
    <aop>
    ...
    </aop>
</beans>

③编写实体类及三层业务逻辑代码

④测试

//通过ClassPathXmlApplicationContext实例化Spring上下文
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
//通过ApplicationContext的getBean（）方法，根据id来获取Bean的实例
HelloSpring helloSpring=（HelloSpring）context.getBean（"helloSpring"）;
//执行print（）方法
helloSpring.print();

Spring的核心技术—IOC、AOP

1、IOC容器
•定义：IOC:(Inversion of control)控制反转又称依赖注入，是面向对象编程中的一种设计理念，用来降低程序代码之间的耦合度
控制器中的javaBean 对象有指定的配置文件映射生成，可以配置javaBean的依赖关系需要的对象有ioc提供。
•方式：

①set方法注入

 <bean id="player"  class="com.xdl.bean.Player">

       <property  name="name"  value="shenge"/>

       <property  name="age"  value="18"/>

     </bean>

②接口注入

  <bean  id=""  class=""  autowire="no/byName/byType/constructor/autodetect"></bean>

                no  默认值    byName  根据属性的名字   byType   根据类型去查找

                 constructor   优先按照构造方法参数的名字去查找，如果找不到，

③构造方法注入

<bean id="player"  class="com.xdl.bean.Player">

                    <constructor-arg  index="0"  value="chen"/>

                     <constructor-arg  index="1"   value="18"/>

               </bean>

•作用：Spring中IOC 最大的好处是便于替换对象，只要用 JavaBean 属性和配置文件加入依赖性（协作对象），
然后可以很容易地在需要时替换具有类似接口的协作对象。

2、AOP（面向切面编程）

•定义：将程序中的交叉业务逻辑提取出来，称之为切面。将这些切面动态织入到目标对象，然后生成一个代理对象的过程。

•核心概念：

①Aspect（切面）

切面，是对交叉业务逻辑的统称。

②Joinpoint（连接点）

连接点，指切面可以织入到目标对象的位置（方法，属性等）。

③Advice（通知）

通知，指切面的具体实现。

④Pointcut（切入点）

切入点，指通知应用到哪些类的哪些方法或属性之上的规则。

⑤Introduction（引入）

引入，指动态地给一个对象增加方法或属性的一种特殊的通知。

⑥Weaving（织入）

织入，指将通知插入到目标对象，将通知应用到连接点形成切入点的过程。

⑦Target（目标对象）

目标对象，指需要织入切面的对象（被代理对象，被通知的对象，被增强的类对象）。

⑧Proxy（代理对象）

代理对象，指切面织入目标对象之后形成的对象。

Spring的增强处理类型

①前置增强
顾名思义就是在目标方法执行前织入增强。BeforeAdvice表示前置增强。属于Spring提供的增强所以属于方法级增强。MethodBeforeAdvice为目前可用前置增强。

②后置增强
顾名思义就是在目标方法执行后织入增强。AfterReturningAdvice表示后置增强。属于Spring提供的增强所以属于方法级增强。

③环绕赠强
MethodInterceptor是前置增强和后置增强的综合，在目标方法执行前后都织入增强。可以用该增强替换前置增强和后置增强

④异常抛出增强
ThrowsAdvice表示在目标方法抛出异常时实施增强

Spring的注解

注解	解释
@Controller	一般应用在controller控制层
@Service	应用在service层（业务逻辑层）
@Repository	应用在dao层（数据访问层）
@Component	表示一个带注释的类是一个“组件”，成为Spring管理的Bean。当使用基于注解的配置和类路径扫描时，这些类被视为自动检测的候选对象。同时@Component还是一个元注解。
@Resource	相当于@Autowired+@Qualifier
@Autowired	Spring提供的工具（由Spring的依赖注入工具自动注入。）

Spring与MyBatis的整合：

1、步骤：

①下载并在项目中导入jar包

  <!-- mybatis-spring整合 start-->
    <!-- mybatis-spring -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.1</version>
    </dependency>
    <!-- spring-jdbc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.1.8.RELEASE</version>
    </dependency>
    <!-- spring-tx -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.1.8.RELEASE</version>
    </dependency>
    <!-- mybatis-spring整合 end-->

②建立开发目录结构，创建实体类

③创建数据访问接口

④配置SQL映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<mapper namespace="xx.xMapper">
    <select id="" resultMap="" parameterType="">
    select *from biaoMing
    </select>
</mapper>

⑤配置MyBatis配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--类型别名-->
    <typeAliases>
    <package name="xx.pojo"/>
    </typeAliases>
</configuration>

⑥编写业务逻辑代码

⑦测试

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.Service;

public class Test{
       @org.junit.Test
        public  void testRole(){
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            XService xService = (Service)context.getBean("Service");
        }


}

spring的事务管理

1.定义：Spring 的事务管理：它保证了一系列操作可以作为一个工作单元，所有的操作被执行的机制。
执行后只有两种结果，要么全部成功，要么全部失败。
防止出现脏数据，防止数据库数据出现问题。
2.Spring提供的事务管理可以分为两类：编程式的和声明式的。
编程式事务，比较灵活，但是代码量大，存在重复的代码比较多；
声明式则比编程式更灵活；在使用Spring的声明式事务时不需要编写任何代码,它通过AOP实现事务管理。
3.spring是怎么实现事务管理:在配置文件中声明事务管理器，然后配置事务属性，定义事务切入点，最后通过AOP实现事务管理；
4.事务有七种传播性，四种隔离级别;

演示案例：https://pan.baidu.com/s/1Cwq0JfKK1x_PdUSbyxZERQ