Spring框架知识要点总结

spring框架

1、JavaEE开发的三层架构：

①web层：springmvc框架

②dao层：mybatis框架

③service

spring框架不属于任何一层，但是存在于每一层。

2、spring是什么？

Spring是分层的JavaEE/SE应用，全栈轻量级开源框架，以IOC和AOP为内核。

提供了展现层springmvc和持久层spring JDBCTemplate以及业务层事务管理等重多的企业级应用技术，还整合了开源世界重多注明的第三方框架和类库，逐渐成为使用最多的JavaEE企业级开源框架。

3、spring的优势

①方便解耦，简化开发：通过spring提供的IOC容器，可以将对象间的依赖关系交由spring进行控制，避免硬编码锁造成的过度耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

②AOP编程的支持：通过spring的AOP功能，方便进行面向切面编程，许多不容易用传统OOP实现的功能可以通过AOP轻松实现。

③声明式事务的支持：可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务管理，提高开发效率和质量。

④方便程序的测试：可以使用非容器依赖的编程方式进行几乎所有的测试工作，测试工作不再是昂贵的操作，而是随手可做的事情。

⑤方便继承各种优秀的框架：spring对各种优秀的框架（Struts、hibernate、hessian、quartz等）的支持。

⑥降低javaEE API的使用难度：spring对javaEE API（如JDBC、JavaMail、远程调用等）进行了薄薄的封装，使这些API的使用难度大为降低。

⑦Java的源码设计精妙、结构清晰、匠心独用、处处体现着大师对Java设计模式的灵活运用以及对Java技术的高深造诣。它的源码无疑是Java技术的最佳实现的范例。

4、spring程序开发步骤：

①导入spring开发的基本的坐标

②编写Dao接口和实现类（创建bean）

③创建spring核心配置文件

④在spring配置文件中配置UserDaoImpl

⑤使用spring的API获得Bean实例

5、spring的配置文件

1、bean标签的基本配置：用于配置对象交由spring来创建；默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

基本属性：

• id：bean实例在spring容器中的唯一标识（不允许重复）
• class：bean的全限定名称

2、bean标签的范围配置：

scope：指对象的作用范围取值如下：

• singleton：默认值，单例的

  • 当scope的属性为singleton时：

    • bean的实例化个数：1个
    • bean的实例化时机：当spring核心文件被加载时，实例化配置的bean实例。

  bean的生命周期：

  • 对象创建：当应用加载，创建容器时，对象就被创建了

  • 对象运行：只要容器在，对象一直活着

  • 对象销毁：当应用卸载，销毁容器时，对象就被销毁了。

• prototype：多例的

  • 当scope的属性为prototype时：

    • bean的实例化个数：多个
    • bean的实例化时机：当调用getBean()方法时实例化bean

    bean的生命周期：

    • 对象的创建：当使用对象时，创建新的对象实例
    • 对象的运行：只要对象在使用中，就一直活着。
    • 对象销毁：当对象长时间不用时，被Java的垃圾回收器回收了。

3、bean的生命周期配置：

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

4、bean的实例化三种方式：

• 无参构造方法实例化（重点）
• 工厂静态方法实例化（了解）
• 工厂实例方法实例化（了解）

5、bean的依赖注入概念：它是spring框架核心IOC的具体实现。

• 编写程序时，通过控制反转，把对象的创建权交给spring，但是代码中不可能出现没有依赖的情况。IOC解耦只是降低它们的依赖关系，但是不会消除。
• 那这种业务层和持久层的依赖关系，在使用spring之后，就让spring来维护了。简单来说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

6、bean的依赖注入方式：

• 构造方法注入：配置文件添加 constructor-arg 子标签

  • <bean id="userService" class="com.itheima.service.Impl.UserServiceImpl">
    	<constructor-arg name="userDao" ref="userDao">constructor-arg>
    bean>
    

• set方法注入：

  • P命名空间注入本质也是set方法注入，但是比起上述的set方法注入更加方便，主要体现在配置文件中，如下：首先，需要引入P命名空间,然后再修改注入方式：

    • xmlns:p="http://www.springframework.org/schema/p"
      

7、bean的依赖注入的数据类型：除了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入。

• 注入数据的三种数据类型

  • 引用数据类型

  • 普通数据类型

    • <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
              <property name="username" value="张三">property>
              <property name="age" value="88">property>
      bean>
      

  • 集合数据类型

    • <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
              <property name="strList">
                  <list>
                      <value>aaavalue>
                  list>
              property>
              <property name="userMap">
                  <map>
                      <entry key="u1" value-ref="user1">entry>
                  map>
              property>
              <property name="properties">
                  <props>
                      <prop key="p1">pprop>
                  props>
              property>
          bean>
      

8、引入其他配置文件（分模块开发）

• 实际开发中，spring的配置内容非常多，就是导致spring配置很繁杂且体积很大，所以可以将部分配置拆解到其他配置文件中，而在spring主配置文件中通过import标签进行加载：

  <import resource="applicationContext-xxx.xml"/>
  

9、spring的重点配置：

<bean>标签
    id属性：在容器中bean实例的唯一标识，不允许重复
	class属性：要实例化的bean的全限定名
    scope属性：bean的作用范围，常用的是singletion（默认）和prototype
    <property>标签：属性注入
        name属性：属性名称
        value属性：注入的普通属性值
        ref属性：注入的对象引用值
        <list>标签
        <map>标签
        <properties>标签
        <constructor-arg>标签
    property>
bean>
<import>标签：导入其他的spring配置文件

6、spring相关的API

1、ApplicationContext的实现类

• ClassPathXmlApplicationContext

  它是从类的根路径下加载配置文件（推荐使用）

• FileSystemXmlApplicationContext

  它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

• AnnotationConfigApplicationContext

  当使用注解配置容器对象时，需要使用此类来创建spring容器。它用来读取注解。

2、spring的重点API

• 创建应用上下文对象的三种方式和getBean的两种使用方式使用：

ApplicationContext app = new ClasspathXmlApplicationContext("xml文件");
app.getBean("id");
app.getBean(class);

7、spring配置数据源

1、数据源（连接池）的作用

• 数据源(连接池)是为提高程序性能而出现的
• 事先实例化数据源，初始化部分连接资源
• 使用链接资源时，从数据源中获取
• 使用完毕之后将链接资源归还给数据源

常见的数据源(连接池)：DBCP、C3P0、BoneCP、Druid等

2、数据源的开发步骤

• 导入数据源坐标和数据库驱动坐标

• 创建数据源对象

• 设置数据源的基本连接参数（驱动、数据库地址、用户名、用户密码）

• 使用数据源获取连接资源和归还连接资源

  • 手动创建c3p0数据源

    //创建数据源对象
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    //设置数据源的基本连接参数
    dataSource.setDriverClass("com.mysql.jdbc.Driver");
    dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
    dataSource.setUser("root");
    dataSource.setPassword("root");
    //使用数据源对象获取链接资源对象
    Connection connection = dataSource.getConnection();
    

  • 手动创建druid数据源

    //获取数据源对象
    DruidDataSource dataSource = new DruidDataSource();
    //设置基本的连接参数
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/test");
    dataSource.setUsername("root");
    dataSource.setPassword("root");
    //使用数据源对象获取链接资源对象
    DruidPooledConnection connection = dataSource.getConnection();
    

  • 提取jdbc.properties配置文件

    jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/test
    jdbc.username=root
    jdbc.password=root
    

  • 读取jdbc.properties配置文件创建连接池

    //加载类路径下的jdbc.properties
    ResourceBundle rb = ResourceBundle.getBundle("jdbc");
    String driver = rb.getString("jdbc.driver");
    String url = rb.getString("jdbc.url");
    String username = rb.getString("jdbc.username");
    String password = rb.getString("jdbc.password");
    //创建数据源对象
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setDriverClass(driver);
    dataSource.setJdbcUrl(url);
    dataSource.setUser(username);
    dataSource.setPassword(password);
    //使用数据源获取链接资源
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    

3、spring配置数据源

可以将dataSource的创建权交给spring容器去完成

dataSource有无参构造，而spring默认就是通过无参构造方法实例化对象的

dataSource要想使用，需要通过set方法设置数据库链接信息，而spring可以通过set方法进行字符串注入

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
    <property name="user" value="root"/>
    <property name="password" value="root"/>
bean>

测试从容器当中获取数据源

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
DataSource dataSource = app.getBean(DataSource.class);
Connection connection = dataSource.getConnection();
System.out.println(connection);
connection.close();

4、抽取jdbc配置文件

• applicationContext加载jdbc.properties配置文件获得连接信息。

  • 首先，需要引入context命名空间和约束路径

  命名空间：

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

  约束路径：

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

• 知识要点：

  • spring容器加载properties配置文件

  <context:property-placeholder location="xx.properties"/>
  <property name="" value="${key}"/>
  

8、spring注解开发

1、spring原始注解

• spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml文件可以简化配置，提高开发效率。

• spring原始注解主要是替代的配置

  注解	说明
  @Component	使用在类上，用于实例化bean
  @Controller	使用在web层的类上，用于实例化bean
  @Service	使用在service层的类上，用于实例化bean
  @repository	使用在dao层的类上，用于数理化bean
  @Autowired	使用在字段上，用于根据类型依赖注入
  @Qualifier	结合@Autowired一起使用，用于根据名称进行依赖注入
  @Resource	相当于@Autowired＋@Qualifier，按照名称进行依赖注入
  @Value	注入普通属性
  @Scope	标注bean的作用范围
  @PostConstruct	使用在方法上，标注该方法是bean的初始化方法
  @PreDestory	使用在方法上，标注该方法是在bean的销毁方法

  注意：使用注解开发时，需要在applicationContext.xml配置文件中配置组件扫描，作用是指定哪个包及其子包下的bean需要进行扫描以便识别使用注解配置的类、字段和方法。

  
  <context:component-scan base-package="com.itheima"/>
  

2、spring新注解

• 使用上面的注解还能全部代替xml配置文件，还需要使用注解代替的配置如下：

  • 非自定义的bean的配置：

  • 加载properties文件的配置：context:property-placeolder

  • 组件扫描的配置：context:component-scan

  • 引入其他文件：

    注解	说明
    @Configuration	用于指定当前类是一个spring的核心配置类，当创建容器时会从该类上加载注解
    @ComponentScan	用于指定spring在初始化容器时要扫描的包。作用和在spring的xml配置文件中的一样
    @Bean	使用在方法上，标注该方法返回值存储到spring容器中
    @PropertySource	用于加载.properties文件中的配置
    @Import	用于导入其他配置类

9、Spring整合Junit

1、原始Junit测试spring的问题

• 在测试类中，每个测试方法都可以有以下两行代码：

  ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
  IAccountService as = ac.getBean("accountService",IAccountService.class);
  

  这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删掉。

• 上述问题解决思路

  让SpringJunit负责创建spring容器，但是需要将配置文件的名称告诉它

  将需要进行测试的bean直接在测试类中进行注入

• spring集成Junit步骤：

  ①导入spring集成Junit的坐标

  ②使用@Runwith注解替换原来的运行器

  ③使用@ContextConfiguration指定配置文件或配置类

  ④使用@Autowired注入需要测试的对象

  ⑤创建测试方法进行测试

10、spring的AOP

1、什么是AOP？

AOP为Aspect Oriented Programming的缩写，意思是面向切面编程，是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

AOP是OOP的延续，是软件开发中的一个热点，也是spring框架中的一个重要内容，是函数式编程的一种衍生泛型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各个部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2、AOP的作用和优势

• 作用：在程序运行期间，在不修改源码的情况下对方法进行功能性增强。
• 优势：减少重复代码，提高开发效率，并且便于维护

3、AOP的底层实现

• 实际上，AOP的底层是通过spring提供的动态代理技术实现的。在运行期间，spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，再去调用目标对象的方法，从而完成功能的增强。

4、AOP的动态代理技术

常用的动态代理技术：

• JDK代理：基于接口的动态代理技术
• cglib代理：基于父类的动态代理技术

5、JDK的动态代理

①目标接口

public interface TargetInterface {
     
    public void method();
}

②目标类

public class Target implements TargetInterface {
     
    @Override
    public void method() {
     
        System.out.println("Target running....");
    }
}

③动态代理代码

//创建目标对象
final Target target = new Target();
//增强对象
final Advice advice = new Advice();
//返回值就是动态生成的代理对象
TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
	//目标对象类加载器
	target.getClass().getClassLoader(),
	//目标对象相同的接口字节码对象数组
	target.getClass().getInterfaces(),
	new InvocationHandler() {
     
	//调用代理对象的任何方法，实质执行的都是invoke方法
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     
		advice.before();//前置增强
		Object invoke = method.invoke(target, args);//执行目标法
		advice.afterReturning();//后置增强
		return invoke;
	}
});

④调用代理对象的方法测试

//调用代理对象的方法
proxy.save();

6、cglib的动态代理

①目标类

public class Target {
     
    public void method() {
     
        System.out.println("Target running....");
    }
}

②动态代理代码

Target target = new Target(); //创建目标对象
Enhancer enhancer = new Enhancer();   //创建增强器
enhancer.setSuperclass(Target.class); //设置父类
enhancer.setCallback(new MethodInterceptor() {
      //设置回调
    @Override
    public Object intercept(Object o, Method method, Object[] objects, 
    MethodProxy methodProxy) throws Throwable {
     
        System.out.println("前置代码增强....");
        Object invoke = method.invoke(target, objects);
        System.out.println("后置代码增强....");
        return invoke;
    }
});
Target proxy = (Target) enhancer.create(); //创建代理对象

③调用代理对象的测试方法

//测试,当调用接口的任何方法时，代理对象的代码都无序修改
proxy.method();

7、AOP的相关概念

1、spring的AOP实现底层就是随上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

2、AOP的相关术语

• Target（目标对象）：代理的目标对象，要被增强的对象
• Proxy（代理）：一个类被AOP织入增强后，就产生了一个结果代理类
• Joinpoint（连接点）：所谓的连接点是指那些被拦截到的点。在spring中，这些点指的是方法，因为spring只支持方法类型的连接点。（可以被增强的方法叫做连接点）
• Pointcut（切入点）：所谓的切入点是指我们要对哪些Joinpoint进行拦截的定义（被增强的连接点叫做切入点）
• Advice（通知/增强）：所谓的通知是指拦截到joinpoint之后所要做的事情就是通知/增强
• Aspect（切面）：是切入点和通知的结合
• Weaving（织入）：就是将切点和增强结合的过程

8、AOP开发的明确事项

1、需要编写的内容：

• 编写核心业务代码（目标类的目标方法）
• 编写切面类，切面类中有通知（增强功能方法）
• 在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合

2、AOP技术实现的内容

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

3、AOP底层使用哪种代理方式？

• 在spring中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

9、知识要点

• AOP：面向切面编程
• AOP底层实现：基于JDK的动态代理和基于cglib的动态代理
• AOP的重点概念：
  • pointcut（切入点）：被增强的方法
  • Advice（通知/增强）：封装增强业务逻辑的方法
  • Aspect（切面）：切点+通知
  • Weaving（织入）：将切点与通知结合的过程
• 开发明确事项：
  • 谁是切点（切点表达式配置）
  • 谁是通知（切面类中的增强方法）
  • 将切点和通知进行织入配置

11、基于XML的AOP开发

1、快速入门

①导入AOP相关坐标

<dependency>
  <groupId>org.springframeworkgroupId>
  <artifactId>spring-contextartifactId>
  <version>5.0.5.RELEASEversion>
dependency>

<dependency>
  <groupId>org.aspectjgroupId>
  <artifactId>aspectjweaverartifactId>
  <version>1.8.13version>
dependency>

②创建目标类接口和目标类（内部有切点）

public interface TargetInterface {
     
    public void method();
}

public class Target implements TargetInterface {
     
    @Override
    public void method() {
     
        System.out.println("Target running....");
    }
}

③创建切面类（内部有增强方法）

public class MyAspect {
     
    //前置增强方法
    public void before(){
     
        System.out.println("前置代码增强.....");
    }
}

④将目标类和切面类的对象创建权交给spring

<bean id="target" class="com.itheima.aop.Target">bean>

<bean id="myAspect" class="com.itheima.aop.MyAspect">bean>

⑤在applicationContext.xml中配置织入关系（告诉spring框架，哪些方法(切点)需要进行哪些增强）

<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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        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
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

在applicationContext.xml中配置织入关系：

<aop:config>
    
    <aop:aspect ref="myAspect">
        
        <aop:before method="before" pointcut="execution(public void com.itheima.aop.Target.method())">aop:before>
    aop:aspect>
aop:config>

⑥测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
     
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
     
        target.method();
    }
}

2、XML配置AOP详解

①切点表达式：

表达语法：

excution([修饰符] 返回值类型 包名.类名.方法名(参数))

• 访问修饰符可以省略
• 返回值类型、包名、类名、方法名可以使用星号*代表任意
• 包名 与类名之间一个点.代表当前包下的类，两个点…表示当前包及其子包下的类
• 参数列表可以使用两个点…表示任意个数，任意类型的参数列表

②通知的类型

通知的配置语法：

<aop:通知类型 method=“切面类中的方法名” pointcut=“切点表达式”>aop:通知类型>

通知类型：

名称	标签	说明
前置通知		用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知		用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知		用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知		用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知		用于配置最终通知。无论赠强的方法执行是否有异常都会执行

③切点表达式的抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用pointcut-ref属性代替pointcut属性来引用抽取后的切点表达式。

<aop:config>
    
    <aop:aspect ref="myAspect">
        <aop:pointcut id="myPointcut" expression="execution(* com.itheima.aop.*.*(..))"/>
        <aop:before method="before" pointcut-ref="myPointcut">aop:before>
    aop:aspect>
aop:config>

3、知识要点

• AOP的织入配置

  
  <aop:config>
  	
      <aop:aspect ref="切面类">
  		
   		aop:around>
   	aop:aspect>
  aop:config>
  

• 通知的类型：前置通知、后置通知、环绕通知、异常抛出通知、最终通知

• 切点表达式的写法：

  execution([修饰符] 返回值类型 包名.类名.方法名(参数))
  

12、基于注解的AOP开发

1、快速入门

• 基于注解的AOP开发步骤：
  • 创建目标接口和目标类（内部有切点）
  • 创建切面类（内部有增强方法）
  • 将目标类和切面类的对象的创建权交给spring
  • 在切面类中使用注解配置织入关系
  • 在配置文件中开启组件扫描和AOP的自动代理
  • 测试

①创建目标接口和目标类（内部有切点）

public interface TargetInterface {
     
    public void method();
}

public class Target implements TargetInterface {
     
    @Override
    public void method() {
     
        System.out.println("Target running....");
    }
}

②创建切面类（内部有增强方法）

public class MyAspect {
     
    //前置增强方法
    public void before(){
     
        System.out.println("前置代码增强.....");
    }
}

③将目标类和切面类的对象创建权交给spring

@Component("target")
public class Target implements TargetInterface {
     
    @Override
    public void method() {
     
        System.out.println("Target running....");
    }
}
@Component("myAspect")
public class MyAspect {
     
    public void before(){
     
        System.out.println("前置代码增强.....");
    }
}

④在切面类中使用注解配置织入关系

@Component("myAspect")
@Aspect
public class MyAspect {
     
    @Before("execution(* com.itheima.aop.*.*(..))")
    public void before(){
     
        System.out.println("前置代码增强.....");
    }
}

⑤在配置文件中开启组件扫描和AOP的自动代理

<context:component-scan base-package="com.itheima.aop"/>


<aop:aspectj-autoproxy>aop:aspectj-autoproxy>

⑥测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
     
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
     
        target.method();
    }
}

2、注解配置AOP详解

①注解通知的类型

通知的配置语法：@通知注解(“切点表达式”)

名称	注解	说明
前置通知	@Before	用于配置前置通知，指定增强的方法在切入点方法之前执行
后置通知	@AfterReturning	用于配置后置通知，指定增强的方法在切入点方法之后执行
环绕通知	@Around	用于配置管绕通知，指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	@AfterThrowing	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	@After	用于配置最终通知，无论增强方式执行是否有异常都会执行

②切点表达式的抽取

同xml配置aop一样，我们可以将切点表达式抽取。抽取方式是在切面内定义方法，在该方法上使用@Pointcut注解定义切点表达式，然后在增强注解中进行引用，具体如下：

@Component("myAspect")
@Aspect
public class MyAspect {
     
    @Before("MyAspect.myPoint()")
    public void before(){
     
        System.out.println("前置代码增强.....");
    }
    @Pointcut("execution(* com.itheima.aop.*.*(..))")
    public void myPoint(){
     }
}

③知识要点

• 注解aop开发步骤
• 通知注解类型

13、spring JdbcTemplate基本使用

1、JdbcTemplate概述

• 它是spring框架中提供的一个对象，是对原始繁琐的JdbcAPI对象的简单封装，spring框架为我们提供了很多的操作模板类。例如：操作关系型数据库的JdbcTemplate和HibernateTemplate，操作nosql数据库的RedisTemplate，操作消息队列的JmsTemplate等等。

2、JdbcTemplate开发步骤

• ①导入spring-jdbc和spring-tx坐标

  
  <dependency>
  	<groupId>org.springframeworkgroupId>
  	<artifactId>spring-jdbcartifactId>
  	<version>5.0.5.RELEASEversion>
  dependency>
  
  <dependency>
  	<groupId>org.springframeworkgroupId>
  	<artifactId>spring-txartifactId>
  	<version>5.0.5.RELEASEversion>
  dependency>
  
  

• ②创建数据库表和实体

• ③创建JdbcTemplate对象

• ④执行数据库操作

3、spring产生JdbcTemplate对象

我们可以将JdbcTemplate的创建权交给spring，将数据源Datasource的创建权也交给spring，在spring容器内部将数据源DataSoutce注入到JdbcTemplate模板对象中，配置如下：

    
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    bean>
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource">property>
    bean>

4、知识要点

①导入spring-jdbc和spring-tx坐标

②创建数据库表和实体

③创建JdbcTemplate对象

④执行数据库操作

• 更新操作：
  • jdbcTemplate.update(sal,params)
• 查询操作
  • jdbcTemplate.query(sql,mapper,params)
  • jdbcTemplate.queryForObject(sql,mapper,params)

14、spring的声明式事务控制

1、编程式事务控制相关对象

1.1PlatformTransactionManager（平台事务管理器）

• PlatformTransactionManager接口是spring的事务管理器，它里面提供了我们常用的操作事务的方法。

  方法	说明
  TransactionStatus getTransaction(TransactionDefination defination)	获取事务的状态信息
  void commit(TransactionStatus status)	提交事务
  void rollback(TransactionStatus ststus)	回滚事务

  注意：
  PlatformTransactionManager 是接口类型，不同的 Dao 层技术则有不同的实现类，例如：Dao 层技术是jdbc 或 mybatis 时：org.springframework.jdbc.datasource.DataSourceTransactionManager
  Dao 层技术是hibernate时：org.springframework.orm.hibernate5.HibernateTransactionManager

1.2TransactionDefinition（事务的定义对象）

• TransactionDefinition是事务的定义信息对象，里面有如下方法：

  方法	说明
  int getIsolationLevel()	获得事务的隔离级别
  int getPropogationBehavior()	获得事务的传播行为
  int getTimeout()	获得超时时间
  boolean isReadOnly()	是否只读

• 事务的隔离级别：设置事务的隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读和虚读。

  • ISOLATION_DEFAULT
  • ISOLATION_READ_UNCOMMITTED（读未提交）
  • ISOLATION_READ_COMMITTED（读已提交）
  • ISOLATION_REPEATABLE_READ（可重复读 /MySQL数据库默认隔离级别）
  • ISOLATION_SERIALIZABLE（串行化）

• 事务的传播行为

  • REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）
  • SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）
  • MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常
  • REQUERS_NEW：新建事务，如果当前在事务中，把当前事务挂起。
  • NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
  • NEVER：以非事务方式运行，如果当前存在事务，抛出异常
  • NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行REQUIRED 类似的操作
  • 超时时间：默认值是-1，没有超时限制。如果有，以秒为单位进行设置
  • 是否只读：建议查询时设置为只读

1.3TransactionStatus（事务的状态对象）

• TransactionStatus接口提供的是事务具体的运行状态，方法介绍如下：

  方法	说明
  boolean hsaSavepoint()	是否储存回滚点
  boolean isCompleted	事务是否完成
  boolean isNewTransaction	是否是新事务
  boolean isRollbackOnly	事务是否回滚

1.4知识要点：

编程式事务控制的三大对象

• PlatformTransactionManager（平台事务管理器）
• TransactionDefinition（事务的定义对象）
• TransactionStatus（事务的状态对象）

15、基于XML的声明式事务控制

1、什么是声明式事务控制

• spring的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明，就是指在配置文件中声明，用在spring配置文件中声明式的处理事务来代替代码式的处理事务。

• 声明式事务处理的作用优点

  • 事务管理不侵入开发的组件。具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此。因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也只需要在定义文件中重新配置即可。
  • 在不需要事务管理的时候，只要在设定文件上修改一下，即可移除事务管理服务，无需改变代码重新编译，这样维护起来极其方便。

  注意：spring声明式事务控制底层就是AOP。

2、声明式事务控制的实现

1、声明式事务控制明确事项：

• 谁是切点？（就是业务方法）
• 谁是通知？（事务控制）
• 配置切面？

2、声明式事务控制的实现

①引入P命名空间

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
">

②配置事务增强

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource">property>
bean>


<tx:advice id="txAdvice" transaction-manager="transactionManager">				<tx:attributes>
		<tx:method name="*"/>
	tx:attributes>
tx:advice>

③配置事务的aop织入

<aop:config>
	<aop:pointcut id="myPointcut" expression="execution(* com.itheima.service.impl.*.*(..))"/>
	<aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut">				aop:advisor>
aop:config>

④测试

3、切点方法的事务参数的配置

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    
    <tx:attributes>
        <tx:method name="*"/>
    tx:attributes>
tx:advice>

其中，代表切点方法的事务参数的配置，例如：

<tx:method name="transfer"
           isolation="REPEATABLE_READ"
           propagation="REQUIRED"
           timeout="-1"
           read-only="false"/>

• name:切点方法名称
• isolation:事务的隔离级别（REPEATABLE_READ）
• propagation：事务的传播行为（REQUIRED）
• timeout:超时时间
• read-only:是否只读

3、知识要点

声明式事务控制的配置要点：

• 平台事务管理器
• 事务通知的配置
• 事务aop织入的配置

16、基于注解的声明式事务控制

1、使用注解配置声明式事务控制

①编写AccountDao

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {
     

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void out(String outMan, double money) {
     
        jdbcTemplate.update("update account set money=money-? where name =?", money, outMan);
    }

    public void in(String inMan, double money) {
     
        jdbcTemplate.update("update account set money= money+? where name =?", money, inMan);
    }
}

②编写AccountService

@Service("accountService")
public class AccountServiceImpl implements AccountService {
     
    @Autowired
    private AccountDao accountDao;

    @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRED)
    public void transfer(String outMan, String inMan, double money) {
     
        accountDao.out(outMan, money);
        int i = 1 / 0;
        accountDao.in(inMan, money);
    }
}

③编写applicationContext.xml配置文件

	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource">property>
    bean>
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource">property>
    bean>
 
    <context:component-scan base-package="com.itheima">context:component-scan>
    
    <tx:annotation-driven transaction-manager="transactionManager">tx:annotation-driven>

2、注解配置声明式事务控制解析

①使用@Transactional在需要进行事务控制的类或者是方法上修饰，注解可以用的属性同xml配置方法，例如隔离级别、传播行为等；

②注解使用在类上，那么该类下的所有方法都使用同一套注解参数配置；

③使用在方法上，不同的方法可以采用不同的事务参数配置；

④xml配置文件中要配置开启事务的注解驱动

3、知识要点

注解声明式事务控制的配置要点：

• 平台事务管理器配置（xml方式）
• 事务通知的配置（@Transactional注解配置）
• 事务注解驱动的配置