• Spring:IOC与AOP

    目录

    一、Spring简介

    1、Spring

    2.spring优势

    二、IOC

    1.概念和原理

     2.自定义IOC容器

    1.需求

    2.实现

    3.Spring相关的API

    3.1 图解​编辑

     3.2.BeanFactory 接口

    4、Spring相关配置文件和操作

    4.1 Bean标签基本配置

    4.2 Bean标签配置范围

    4.3 Bean生命周期配置

    4.4 Bean实例化三种方式

    4.5 无参构造方法实例化

    4.6 工厂静态方法实例化

    4.7 工厂普通方法实例化

    4.8 Bean依赖注入概述

    4.9 有参构造方法注入（一个是userdao  另一个时 str   配置如下）

    4.10 set方法注入

    4.11 命名空间注入

    4.12 set 普通数据类型的注入

    4.13 集合 数组 map properties 的注入

    4.14  配置文件模块化

    4.15 知识小结

    5 Dbutils整合

    5.1 xml的形式

    5.2 注解的形式 （无配置文件）

    6 Spring整合Junit  代码 和5 的一样

    6.1 为什么用 Spring测试

    6.2 依赖

    6.3 测试

    三、AOP

    1 AOP概念

    2  AOP底层原理（JDK动态代理和CGLIB动态代理）

    核心配置文件    jdbc.properties 同上

    数据库连接工具类 和 事务工具类

    事务工具类

     2.1 JDK动态代理

    2.2 CGLIB动态代理

    测试  转账中间添加了int i=5/0  事务捕捉到异常 数据库未发生改变

    service实现层代码

    dao实现层代码

    3.AOP术语

    4 编写通知类 配置核心文件（两种方法 一种是直接写poingtcut  另一种 是先定义 再用pointcut-ref引入 ）

    5 .AOP 自动代理

    6 注解配置AOP详解

    6.1 切点表达式

    6.2通知类型

    6.3 纯注解配置

    6.4 AOP优化转账案例

    6.5注解配置实现

    6.6 注意点

    一、Spring简介

    1、Spring

    Spring是分层的 Java SE/EE应用 full-stack(全栈式) 轻量级开源框架。

    提供了表现层 SpringMVC和持久层 Spring JDBC Template以及 业务层 事务管理等众多的企业级应用
    技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框
    架。
    两大核心：以 IOC（Inverse Of Control：控制反转 将创建对象过程交给Spring进行管理）和 AOP（Aspect OrientedProgramming：面向切面编程）为内核。

    2.spring优势

    1）方便解耦，简化开发
        Spring就是一个容器，可以将所有对象创建和关系维护交给Spring管理
        什么是耦合度？
            对象之间的关系，通常说当一个模块(对象)更改时也需要更改其他模块(对象)，这就是耦合，
            耦合度过高会使代码的维护成本增加。要尽量解耦
    2）AOP编程的支持
        Spring提供面向切面编程，方便实现程序进行权限拦截，运行监控等功能。
    3）声明式事务的支持
        通过配置完成事务的管理，无需手动编程
    4）方便测试，降低JavaEE API的使用
        Spring对Junit4支持，可以使用注解测试
    5）方便集成各种优秀框架
        不排除各种优秀的开源框架，内部提供了对各种优秀框架的直接支持

    二、IOC

    1.概念和原理

    1、什么是 IOC （Inverse Of Control）
    （1）控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理（比如对象的创建和销毁）
    控制：在java中指的是对象的控制权限（创建、销毁）
    反转：指的是对象控制权由原来 由开发者在类中手动控制 反转到 由Spring容器控制
    （2）使用 IOC 目的：为了耦合度降低
    （3）做入门案例就是 IOC 实现
    2、IOC 底层原理
    （1）xml 解析、工厂模式、反射
    3、画图讲解 IOC 底层原理

     2.自定义IOC容器

    1.需求

    1. 创建java项目，导入自定义IOC相关坐标
    2. 编写Dao接口和实现类
    3. 编写Service接口和实现类
    4. 编写测试代码

    2.实现

    依赖

    1.   <dependencies>
    2.         <dependency>
    3.             <groupId>dom4j</groupId>
    4.             <artifactId>dom4j</artifactId>
    5.             <version>1.6.1</version>
    6.         </dependency>
    7.         <dependency>
    8.             <groupId>jaxen</groupId>
    9.             <artifactId>jaxen</artifactId>
    10.             <version>1.1.6</version>
    11.         </dependency>
    12.         <dependency>
    13.             <groupId>junit</groupId>
    14.             <artifactId>junit</artifactId>
    15.             <version>4.12</version>
    16.         </dependency>
    17.     </dependencies>

    编写Dao接口和实现类

    public interface UserDao {
    public void save();
}
    public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("保存成功");
    }
}

    Service接口和实现类

    public interface UserService {
    public  void save();
}
    public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public void save()  {
        userDao = (UserDao) BeanFactory.getBean("userDao");
        userDao.save();
    }

}

    beans.xml 文件

    <beans>
<!--    bean 表示一个需要创建的对象
        id: 表示该对象的名字
        class：表示该对象的类型
-->


    <bean id="userDao" class="com.qiku.dao.UserDaoImpl"></bean>

</beans>
    BeanFactory 工厂类 
    1. package com.qiku.utils;
    2.  
    3. /**
    4.  * 2022/6/23 15:05
    5.  *
    6.  * @author yrc
    7.  * @version MySpring
    8.  */
    9.  
    10.  
    11. import org.dom4j.Document;
    12. import org.dom4j.Element;
    13. import org.dom4j.io.SAXReader;
    14. import java.io.InputStream;
    15. import java.util.HashMap;
    16. import java.util.List;
    17. import java.util.Map;
    18.  
    19. /**
    20.  * 根据配置文件中的信息 创建对象
    21.  * 并将所有的对象存入一个容器之中
    22.  */
    23. public class BeanFactory {
    24. //声明一个 map 充当 容器作用 ，用于包存所有的对象
    25. public  static Map<String ,Object> ioc=new HashMap<>();
    26.  
    27. //程序启动时 自动初始化对象
    28.     static {
    29.  
    30.     try {
    31.         //1 读取配置文件
    32.         InputStream resource =
    33.                 BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
    34.         //2 解析xml
    35.         SAXReader saxReader = new SAXReader();
    36.         //2.1 通过saxReader 将resource装换为document
    37.         Document document = saxReader.read(resource);
    38.         //3 编写xPath表达式
    39.         String xPath="//bean";
    40.         //4 获取所有的bean标签
    41.         List<Element> nodes = document.selectNodes(xPath);
    42.         System.out.println(nodes);
    43.         //5 遍历 并创建对象 设置到map中
    44.         for (Element e:nodes){
    45.             String id = e.attributeValue("id");
    46.             String className = e.attributeValue("class");
    47.             System.out.println("id= "+id);
    48.             System.out.println("id= "+className);
    49.             Object obj = Class.forName(className).newInstance();
    50.             //将 id 和obj存入ioc容器
    51.             ioc.put(id,obj);
    52.         }
    53.     } catch (Exception e) {
    54.         e.printStackTrace();
    55.     }
    56. }
    57.  
    58. //提供获取对象的方法
    59.    public static Object getBean(String beanId){
    60.         return ioc.get(beanId);
    61.    }
    62.  
    63.  
    64.  
    65.  
    66. }

    测试类 以及结果

     总结：

    * 其实升级后的BeanFactory就是一个简单的Spring的IOC容器所具备的功能。

    * 之前我们需要一个userDao实例，需要开发者自己手动创建 new UserDao();

    * 现在我们需要一个userdao实例，直接从spring的IOC容器获得，对象的创建权交给了spring控制

    * 最终目标：代码解耦合 解耦合并不是没有关系了 只是耦合度降低了

    3.Spring相关的API

    3.1 图解

     3.2.BeanFactory 接口

    1、IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂
    2、Spring 提供 IOC 容器实现两种方式：（两个接口）
    （1）BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用
    特点：在第一次调用getBean()方法时，创建指定对象的实例（用的时候去创建）

    BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

    加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象
    （2）ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能一 般由开发人
    员进行使用 （ 类加载的时候去创建 ）
    特点：在spring容器启动时，加载并创建所有对象的实例
    加载配置文件时候就会把在配置文件对象进行创建
    3、ApplicationContext 接口有实现类

    1. ClassPathXmlApplicationContext
        它是从类的根路径下加载配置文件 推荐使用这种。
    2. FileSystemXmlApplicationContext
        它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
    3. AnnotationConfigApplicationContext
        当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
        ApplicationContext app =new ClassPathXmlApplicationContext("applicationContext.xml");

    4、Spring相关配置文件和操作

    4.1 Bean标签基本配置

    <bean id="" class=""></bean>

    * 用于配置对象交由Spring来创建。


    * 基本属性：
        id：Bean实例在Spring容器中的唯一标识
        class：Bean的全限定名（全路径）

    name: 不常用
    * 默认情况下它调用的是类中的 无参构造函数，如果没有无参构造函数则不能创建成功。

    4.2 Bean标签配置范围

    <bean id="" class="" scope=""></bean>

    4.3 Bean生命周期配置

    <bean id="" class="" scope="" init-method="" destroy-method=""></bean>

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

    4.4 Bean实例化三种方式

        无参构造方法实例化
        工厂静态方法实例化
        工厂普通方法实例化

    4.5 无参构造方法实例化

    它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

    <bean id="userDao" class="com.qiku.dao.impl.UserDaoImpl"/>

    4.6 工厂静态方法实例化

    应用场景
    依赖的jar包中有个A类，A类中有个静态方法m1，m1方法的返回值是一个B对象。如果我们频繁使用B对象，此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类中的m1方法，直接从IOC容器获得。

    public class StaticFactoryBean {
        public static UserDao createUserDao(){
            return new UserDaoImpl();
        }
    }

    <bean id="userDao" class="com.qiku.factory.StaticFactoryBean" factory-method="createUserDao" />

    4.7 工厂普通方法实例化

    应用场景
    依赖的jar包中有个A类，A类中有个普通方法m1，m1方法的返回值是一个B对象。如果我们频繁使用B对象，此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类中的m1方法，直接从IOC容器获得。

    public class DynamicFactoryBean {
        public UserDao createUserDao(){
            return new UserDaoImpl();
        }
    }

    1. <bean id="dynamicFactoryBean" class="com.qiku.factory.DynamicFactoryBean"/>
    2. <bean id="userDao" factory-bean="dynamicFactoryBean" factory-method="createUserDao"/>

    4.8 Bean依赖注入概述

    依赖注入 DI（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。

    在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。

    那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是通过框架把持久层对象传入业务层，而不用我们自己去获取。

    4.9 有参构造方法注入（一个是userdao  另一个时 str   配置如下）

    1.     public UserServiceImpl(UserDao userDao,String str) {
    2.         System.out.println("有参构造器执行了 ");
    3.         this.userDao = userDao;
    4.  
    5.     }
    1. <!--  配置userDao 将其交给Spring 的容器管理&ndash;&gt;-->
    2.     <bean id="userDao" class="com.qiku.dao.impl.UserDaoImpl"></bean>
    3.  
    4.  
    5. <!--    配置UserService-->
    6.     <bean id="userService" class="com.qiku.service.impl.UserServiceImpl">
    7.         <!-- （1）   使用有参构造器的 方式注入 index下标0 代表第一个参数
    8.               1 则代表 第二个参数 type 为参数类型 ref 为引用数据类型 指的是上面 的 id userDao-->
    9. <!--        <constructor-arg index="0" type="com.qiku.dao.UserDao" ref="userDao"/>-->
    10. <!--        第(2)种方法 name表示参数中的名字  代表之前的 index=0-->
    11.         <constructor-arg name="userDao" type="com.qiku.dao.UserDao" ref="userDao"></constructor-arg>
    12.         <constructor-arg name="str" type="java.lang.String" value="123"></constructor-arg>
    13.    </bean>

    4.10 set方法注入

    1.    public void setUserDao(UserDao userDao) {
    2.         System.out.println("set方法执行了");
    3.         this.userDao = userDao;
    4.     }

    配置spring容器利用set方法注入

    1. <bean id="userDao" class="com.qiku.dao.impl.UserDaoImpl"></bean>
    2. <bean id="userService2" class="com.qiku.service.impl.UserServiceImpl">
    3.  <property name="userDao" ref="userDao"/>
    4. </bean>

    4.11 命名空间注入

    xmlns:p="http://www.springframework.org/schema/p"
    1.   <!--        p命名空间 注入-->
    2. <bean id="userDao" class="com.qiku.dao.impl.UserDaoImpl"></bean>
    3.     <bean id="userService3" class="com.qiku.service.impl.UserServiceImpl"
    4.           p:userDao-ref="userDao">
    5.     </bean>

    4.12 set 普通数据类型的注入

    1. public class User { 
    2. 	private String username; 
    3. 	private String age; 
    4. 	public void setUsername(String username) { 
    5. 		this.username = username; 
    6. 	}
    7. 	public void setAge(String age) { 
    8. 		this.age = age; 
    9. 	} 
    10. }
    1.     <bean id="user4" class="com.qiku.pojo.User">
    2.  
    3.         <constructor-arg name="name" value="马孟德"></constructor-arg>
    4.         <constructor-arg name="age"  value="35"></constructor-arg>
    5.  
    6. <!--        <property name="name" value="马孟德"></property>-->
    7. <!--        <property name="age" value="35"></property>-->
    8.     </bean>

    4.13 集合 数组 map properties 的注入

    User类  还有set 方法

    1.     private List<Object> list;
    2.     private Object[] arrays;
    3.     private Map<String,Integer> map;
    4.    private Properties properties;

    配置文件

    1. <!--    注入集合类型-->
    2.     <bean id="user5" class="com.qiku.pojo.User">
    3.         <property name="list" >
    4.             <list>
    5.                 <value>chaolihai</value>
    6.                 <value>bucuoou</value>
    7.                 <value>zhadsafds</value>
    8.                 <ref bean="userDao"></ref>
    9.             </list>
    10.         </property>
    11.      </bean>
    12. <!--    注入数组类型-->
    13.     <bean id="user6" class="com.qiku.pojo.User">
    14.         <property name="arrays" >
    15.             <array>
    16.                 <value>chaolihai</value>
    17.                 <value>bucuoou</value>
    18.                 <value>zhadsafds</value>
    19.                 <ref bean="userDao"></ref>
    20.             </array>
    21.         </property>
    22.     </bean>
    23. <!--    注入map类型-->
    24.     <bean id="user7" class="com.qiku.pojo.User">
    25.         <property name="map" >
    26.             <map>
    27.                <entry key="嗨嗨嗨" value="8"></entry>
    28.                 <entry key="clearlove" value="7"></entry>
    29.                 <entry key="老阴逼" value="6"></entry>
    30.             </map>
    31.         </property>
    32.     </bean>
    33.  
    34. <!--    注入Properties类型数据-->
    35.     <bean id="user8" class="com.qiku.pojo.User" scope="prototype">
    36.         <property name="properties">
    37.          <props>
    38.              <prop key="driver">com.mysql.jdbc.Driver</prop>
    39.              <prop key="url">jdbc:mysql://localhost:3306/mydb</prop>
    40.              <prop key="username">root</prop>
    41.              <prop key="password">root</prop>
    42.          </props>
    43.         </property>
    44.     </bean>

    测试

    1.   //集合注入
    2.     @Test
    3.     public void test10() {
    4.  
    5.         ClassPathXmlApplicationContext context =
    6.                 new ClassPathXmlApplicationContext("applicationContext.xml");
    7.         User user = context.getBean("user5", User.class);
    8.         System.out.println(user.getList());
    9.         context.close();
    10.     }
    11.    
    12.     @Test
    13.     public void test11() {
    14.  
    15.         ClassPathXmlApplicationContext context =
    16.                 new ClassPathXmlApplicationContext("applicationContext.xml");
    17.         User user = context.getBean("user6", User.class);
    18.         System.out.println(user.getArrays());
    19.         context.close();
    20.     }
    21.     //集合注入
    22.     @Test
    23.     public void test12() {
    24.  
    25.         ClassPathXmlApplicationContext context =
    26.                 new ClassPathXmlApplicationContext("applicationContext.xml");
    27.         User user = context.getBean("user7", User.class);
    28.         System.out.println(user.getMap());
    29.         context.close();
    30.     }
    31.     @Test
    32.     public void test13() {
    33.  
    34.         ClassPathXmlApplicationContext context =
    35.                 new ClassPathXmlApplicationContext("applicationContext.xml");
    36.         User user = context.getBean("user8", User.class);
    37.         System.out.println(user.getProperties());
    38.         context.close();
    39.     }

    4.14  配置文件模块化

    实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分
    配置拆解到其他配置文件中，也就是所谓的配置文件模块化。

    1）并列的多个配置文件

    ApplicationContext act = new ClassPathXmlApplicationContext("beans1.xml","beans2.xml","...");

    2）主从配置文件

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

    4.15 知识小结

    <bean>标签：创建对象并放到spring的IOC容器
        id属性:在容器中Bean实例的唯一标识，不允许重复
        class属性:要实例化的Bean的全限定名
        scope属性:Bean的作用范围，常用是Singleton(默认)和prototype

    <constructor-arg>标签：属性注入
        name属性：属性名称
        value属性：注入的普通属性值
        ref属性：注入的对象引用值

    <property>标签：属性注入
        name属性：属性名称
        value属性：注入的普通属性值
        ref属性：注入的对象引用值
        <list>
        <set>
        <array>
        <map>
        <props>
        
    <import>标签:导入其他的Spring的分文件

    属性中包含尖括号

    属性设置空值

    5 Dbutils整合

    5.1 xml的形式

    5.1.1 核心配置文件

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:context="http://www.springframework.org/schema/context"
    4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    5.        xsi:schemaLocation="
    6.        http://www.springframework.org/schema/beans
    7. 	   http://www.springframework.org/schema/beans/spring-beans.xsd
    9.        http://www.springframework.org/schema/context
    10. 	   http://www.springframework.org/schema/context/spring-context.xsd"
    11.        >
    12.  
    13. <!--   spring 加载外部文件-->
    14.     <context:property-placeholder location="classpath:jdbc.properties"/>
    15. <!--    将数据库连接池交给IOC容器-->
    16.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    17.         <property name="driverClassName" value="${jdbc.driver}"></property>
    18.         <property name="url" value="${jdbc.url}"></property>
    19.         <property name="username" value="${jdbc.username}"></property>
    20.         <property name="password" value="${jdbc.password}"></property>
    21.     </bean>
    22.  
    23.  
    24.     <!--    将QueryRunner 交给IOC 容器-->
    25. <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
    26.     <!--利用有参构造器的方式将 datasource注入 -->
    27.     <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    28. </bean>
    29.  
    30. <!--    将AccountDao 交给IOC-->
    31. <bean id="accountDao" class="com.qiku.dao.impl.AccountDaoImpl">
    32.     <property name="qr" ref="queryRunner"></property>
    33. </bean>
    34.  
    35.     <!--把AccountService交给IOC容器-->
    36.     <bean id="accountService" class="com.qiku.service.impl.AccountServiceImpl">
    37.         <property name="accountDao" ref="accountDao"></property>
    38.     </bean>
    39.  
    40.  
    41.  
    42. </beans>

    5.1.2 jdbc配置文件

    1. jdbc.driver=com.mysql.jdbc.Driver
    2. jdbc.url=jdbc:mysql://localhost:3306/spring_db?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false
    3. jdbc.username=root
    4. jdbc.password=root

    5.1.3 set方法

    queryrunner在Dao层 set注入spring容器

    5.2 注解的形式 （无配置文件）

    jdbc 配置文件同5.1.2

    5.2.1 数据库配置类

    1. package com.qiku.config;
    2. /* 数据源配置
    4. * */
    5.  
    6. import com.alibaba.druid.pool.DruidDataSource;
    7. import org.springframework.beans.factory.annotation.Value;
    8. import org.springframework.context.annotation.Bean;
    9. import org.springframework.context.annotation.PropertySource;
    10.  
    11. import javax.sql.DataSource;
    12.  
    13.  
    14. @PropertySource("classpath:jdbc.properties")
    15. public class DataSourceConfig {
    16.     //使用EL表达式 读取配置文件中的值 给属性赋值
    17.     @Value("${jdbc.driver}")
    18.     private String driver;
    19.     @Value("${jdbc.url}")
    20.     private String url;
    21.     @Value("${jdbc.username}")
    22.     private String username;
    23.     @Value("${jdbc.password}")
    24.     private String password;
    25.  
    26.  
    27.     @Bean
    28.     public DataSource getDataSource(){
    29.         DruidDataSource dataSource = new DruidDataSource();
    30.         dataSource.setDriverClassName(driver);
    31.         dataSource.setUrl(url);
    32.         dataSource.setUsername(username);
    33.         dataSource.setPassword(password);
    34.         return  dataSource;
    35.     }
    36.  
    37.  
    38. }

    5.2.2 Spring 核心配置类

    1. package com.qiku.config;
    2.  
    3. import org.apache.commons.dbutils.QueryRunner;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.context.annotation.Bean;
    6. import org.springframework.context.annotation.ComponentScan;
    7. import org.springframework.context.annotation.Configuration;
    8. import org.springframework.context.annotation.Import;
    9.  
    10. import javax.sql.DataSource;
    11.  
    12. /**@Configuration 写在类上面
    13.  * 表示该类是一个配置类
    14.  * @ComponentScan 用于开启注解扫描
    15.  *
    16.  * @Import(DataSourceConfig.class)
    17.  * 引入其他配置类
    18.  */
    19. @Configuration
    20. @ComponentScan("com.qiku")
    21. @Import(DataSourceConfig.class)
    22. public class SpringConfig {
    23. //   @Bean 写在方法上 用于将第三方的类 交给IOC容器
    24.     //默认的beanId同样是雷鸣的首字母小写 体现为方法的返回值类型
    25.     @Bean("queryRunner")
    26.     public QueryRunner getQueryRunner(
    27.             @Autowired DataSource dataSource) {
    28.         return new QueryRunner(dataSource);
    29.     }
    30.     
    31.  
    32. }

    5.2.3 DAO层实现类

    1. package com.qiku.dao.impl;
    2.  
    3. import com.qiku.dao.AccountDao;
    4. import com.qiku.pojo.Account;
    5. import org.apache.commons.dbutils.QueryRunner;
    6. import org.apache.commons.dbutils.handlers.BeanHandler;
    7. import org.apache.commons.dbutils.handlers.BeanListHandler;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.stereotype.Repository;
    10.  
    11. import java.sql.SQLException;
    12. import java.util.List;
    13.  
    14. /**
    15.  * 2022/6/24 15:22
    16.  *
    17.  * @author yrc
    18.  * @version spring02_quickStart
    19.  */
    20. @Repository
    21. public class AccountDaoImpl implements AccountDao {
    22.  
    23.     @Autowired
    24.     private QueryRunner qr;
    25.  
    26.     //set 方法  spring注入
    27.     public void setQr(QueryRunner qr) {
    28.         this.qr = qr;
    29.     }
    30.  
    31.     @Override
    32.     public void save(Account account) throws SQLException {
    33.         String sql = "insert into account(name,money) " +
    34.                 "values(?,?)";
    35.         int update = qr.update(sql, account.getName(), account.getMoney());
    36.     }
    37.  
    38.     @Override
    39.     public void update(Account account) throws SQLException {
    40.         String sql="update account set name=? ,money=? where id=?";
    41.         int update = qr.update(sql, account.getName(), account.getMoney(), account.getId());
    42.  
    43.     }
    44.  
    45.     @Override
    46.     public void delete(Integer id) throws SQLException {
    47.         String sql="delete from account where id=?";
    48.         qr.update(sql,id);
    49.  
    50.     }
    51.  
    52.     @Override
    53.     public List<Account> findAll() throws SQLException {
    54.         String sql="select * from account";
    55.         List<Account> query = qr.query(sql, new BeanListHandler<Account>(Account.class));
    56.         return  query;
    57.     }
    58.  
    59.     @Override
    60.     public Account findById(Integer id) throws SQLException {
    61.         String sql="select * from account where id =?";
    62.         Account query = qr.query(sql, new BeanHandler<Account>(Account.class),id);
    63.         return  query;
    64.  
    65.     }
    66. }

    5.2.4 Service层实现类

    1. package com.qiku.service.impl;
    2.  
    3. import com.qiku.dao.AccountDao;
    4. import com.qiku.pojo.Account;
    5. import com.qiku.service.AccountService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Service;
    8.  
    9. import java.sql.SQLException;
    10. import java.util.List;
    11.  
    12. /**
    13.  * 2022/6/24 15:49
    14.  *
    15.  * @author yrc
    16.  * @version spring02_quickStart
    17.  */
    18. @Service
    19. public class AccountServiceImpl implements AccountService {
    20.     @Autowired
    21.     private AccountDao accountDao;
    22.  
    23.     public void setAccountDao(AccountDao accountDao) {
    24.         this.accountDao = accountDao;
    25.     }
    26.     @Override
    27.     public void save(Account account) throws SQLException {
    28.       accountDao.save(account);
    29.     }
    30.  
    31.     @Override
    32.     public void update(Account account) throws SQLException {
    33.   accountDao.update(account);
    34.     }
    35.  
    36.     @Override
    37.     public void delete(Integer id) throws SQLException {
    38.   accountDao.delete(id);
    39.     }
    40.  
    41.     @Override
    42.     public List<Account> findAll() throws SQLException {
    43.         List<Account> all = accountDao.findAll();
    44.         return all;
    45.     }
    46.  
    47.     @Override
    48.     public Account findById(Integer id) throws SQLException {
    49.         Account account = accountDao.findById(id);
    50.  
    51.         return  account;
    52.     }
    53.  
    54. }

    5.2.5 测试类

    1. package com.qiku.test;
    2.  
    3. import com.qiku.config.SpringConfig;
    4. import com.qiku.pojo.Account;
    5. import com.qiku.service.AccountService;
    6. import org.junit.Test;
    7. import org.springframework.context.ApplicationContext;
    8. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    9. import org.springframework.context.support.ClassPathXmlApplicationContext;
    10.  
    11. import java.sql.SQLException;
    12. import java.util.List;
    13.  
    14. /**
    15.  * 2022/6/24 16:37
    16.  *
    17.  * @author yrc
    18.  * @version spring02_quickStart
    19.  */
    20. public class AccountServiceTest {
    21.     //加载配置类
    22.  
    23.     ApplicationContext context =
    24.             new AnnotationConfigApplicationContext(SpringConfig.class);
    25.  
    26. // 没有配置文件了
    27. //    private ClassPathXmlApplicationContext context
    28. //            =new ClassPathXmlApplicationContext("applicationContext.xml");
    29.     //从IOC中获取accountService对象
    30.     private AccountService accountService= context.getBean("accountServiceImpl",AccountService.class);
    31. //    测试报保存信息
    32.     @Test
    33.     public void testSave() throws SQLException {
    34.         Account account=new Account();
    35.         account.setName("lucy");
    36.         account.setMoney(9999.99);
    37.         accountService.save(account);
    38.     }
    39.     @Test
    40.     public void testUpdate() throws SQLException {
    41.         Account account=new Account();
    42.         account.setId(3);
    43.         account.setName("机甲战士");
    44.         account.setMoney(9999.99);
    45.         accountService.update(account);
    46.     }
    47.     @Test
    48.     public void testFindAll() throws SQLException {
    49.         Account account=new Account();
    50.  
    51.         List<Account> all = accountService.findAll();
    52.         System.out.println(all);
    53.     }
    54.     @Test
    55.     public void testFindById() throws SQLException {
    56.         Account account=new Account();
    57. account.setId(1);
    58.         Account byId = accountService.findById(account.getId());
    59.         System.out.println(byId);
    60.     }
    61.     @Test
    62.     public void testDelete() throws SQLException {
    63.         Account account=new Account();
    64.  
    65.        accountService.delete(4);
    66.  
    67.     }
    68. }

    5.2.6 数据库

    6 Spring整合Junit  代码 和5 的一样

    6.1 为什么用 Spring测试

    6.2 依赖

    1. <!--此处需要注意的是，spring5 及以上版本要求 junit 的版本必须是 4.12 及以上--> 
    2. <dependency> 
    3. 	<groupId>org.springframework</groupId> 
    4. 	<artifactId>spring-test</artifactId> 
    5. 	<version>5.1.5.RELEASE</version> 
    6. </dependency> 
    7. <dependency> 
    8. 	<groupId>junit</groupId> 
    9. 	<artifactId>junit</artifactId> 
    10. 	<version>4.12</version> 
    11. 	<scope>test</scope> 
    12. </dependency>

    6.3 测试

    1. @RunWith(SpringJUnit4ClassRunner.class)
    2. @ContextConfiguration(classes = {SpringConfig.class})
    3. public class SpringAndJunitTest {
    4.     @Autowired
    5.     private AccountService accountService;
    6.  
    7.     @Test
    8.     public void testFindALL() throws SQLException {
    9.         List<Account> all = accountService.findAll();
    10.         System.out.println(all);
    11.  
    12.     }
    13.  
    14.     @Autowired
    15.     private DataSource dataSource;
    16.     @Test
    17.     public void test02(){
    18.         System.out.println(dataSource);
    19.     }
    20. }

    三、AOP

    1 AOP概念

    （1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得
    业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
    （2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能

    2  AOP底层原理（JDK动态代理和CGLIB动态代理）

    我们可以将业务代码和事务代码进行拆分，通过动态代理的方式，对业务方法进行事务的增强。这样就不会对业务层产生影响，解决了耦合性的问题啦！

    常用的动态代理技术
    JDK 代理 : 基于接口的动态代理技术·：利用拦截器（必须实现invocationHandler）加上反射机制生成一个代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理，从而实现方法增强

    CGLIB代理：基于父类的动态代理技术：动态生成一个要代理的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截技术拦截所有的父类方法的调用，顺势织入横切逻辑，对方法进行增强

    核心配置文件    jdbc.properties 同上

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:context="http://www.springframework.org/schema/context"
    4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    5.        xsi:schemaLocation="
    6.        http://www.springframework.org/schema/beans
    7. 	   http://www.springframework.org/schema/beans/spring-beans.xsd
    9.        http://www.springframework.org/schema/context
    10. 	   http://www.springframework.org/schema/context/spring-context.xsd"
    11.        >
    12. <context:component-scan base-package="com.qiku"></context:component-scan>
    13. <!--   spring 加载外部文件-->
    14.     <context:property-placeholder location="classpath:jdbc.properties"/>
    15. <!--&lt;!&ndash;    将数据库连接池交给IOC容器&ndash;&gt;-->
    16.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    17.         <property name="driverClassName" value="${jdbc.driver}"></property>
    18.         <property name="url" value="${jdbc.url}"></property>
    19.         <property name="username" value="${jdbc.username}"></property>
    20.         <property name="password" value="${jdbc.password}"></property>
    21.     </bean>
    22.  
    23.  
    24.  
    25.     <!--    将QueryRunner 交给IOC 容器-->
    26. <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
    27.     <!--利用有参构造器的方式将 datasource注入 -->
    28.     <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    29. </bean>
    30.  
    31. </beans>

    数据库连接工具类 和 事务工具类

    1. package com.qiku.utils;
    2.  
    3.  
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.stereotype.Component;
    6.  
    7. import javax.sql.DataSource;
    8. import java.sql.Connection;
    9. import java.sql.SQLException;
    10.  
    11. /**
    12.  * 由于之前的 in out 操作都是独立的食物 并且独立的连接
    13.  * 解决方法：
    14.  * 将获取连接的方式统一管理  以及同一个事务中尽心操作
    15.  *
    16.  * 链接工具类： 从数据源中获取一个链接 并实现线程的绑定
    17.  *
    18.  *
    19.  */
    20. @Component
    21. public class ConnectionUtils {
    22. //    创建本地线程 绑定的是数据库连接
    23.     private ThreadLocal<Connection> threadLocal=new ThreadLocal<>();
    24.  
    25. //    从IOC容器中 获取数据源对象
    26.     @Autowired
    27.     private DataSource dataSource;
    28.  
    29.     //获取当前线程上的连接
    30.     public Connection getThreadConnection() {
    31.         //1 先从threadlocal里面获取 当前连接
    32.         Connection connection = threadLocal.get();
    33.         //判断connection 是否为null
    34.         if (connection == null) {
    35.  
    36.             try { //则说明是第一次获取  则从数据源中 获取连接 并与线程绑定
    37.                 connection = dataSource.getConnection();
    38.                 threadLocal.set(connection);
    39.             } catch (SQLException e) {
    40.                 e.printStackTrace();
    41.             }
    42.         }
    43.         return  connection;
    44.     }
    45.  
    46.     //解除绑定
    47.     public  void removeThreadConnection(){
    48.  
    49.         threadLocal.remove();
    50.     }
    51. }
    52.  
    53.  
    54.

    事务工具类

    1. package com.qiku.utils;
    2.  
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.stereotype.Component;
    5.  
    6. import java.sql.SQLException;
    7.  
    8. /*
    9. * 事务管理器 ：开启事务  提交事务  回滚事务  释放资源
    10. * */
    11. @Component
    12. public class TransactionManager {
    13.  
    14.     @Autowired
    15.     private ConnectionUtils connectionUtils;
    16.  
    17.     //开启事务
    18.     public void beginTransaction(){
    19.         try {
    20.             //开启事务 并关闭自动提交
    21.             connectionUtils.getThreadConnection().setAutoCommit(false);
    22.         } catch (SQLException e) {
    23.             e.printStackTrace();
    24.         }
    25.     }
    26.     public void commit(){
    27.         try {
    28.             //提交事务
    29.             connectionUtils.getThreadConnection().commit();
    30.         } catch (SQLException e) {
    31.             e.printStackTrace();
    32.         }
    33.     }
    34.     public void rollback(){
    35.         try {
    36.             //事务回滚
    37.             connectionUtils.getThreadConnection().rollback();
    38.         } catch (SQLException e) {
    39.             e.printStackTrace();
    40.         }
    41.     }
    42.     public void release(){
    43.         try {
    44.             //改回自动提交
    45.             connectionUtils.getThreadConnection().setAutoCommit(true);
    46.             //归还连接池
    47.             connectionUtils.getThreadConnection().close();
    48.             //解除与线程的绑定
    49.             connectionUtils.removeThreadConnection();
    50.         } catch (SQLException e) {
    51.             e.printStackTrace();
    52.         }
    53.     }
    54. }

     2.1 JDK动态代理

    2.1.1 工厂动态代理类

    1. package com.qiku.proxy;
    2.  
    3. import com.qiku.service.AccountService;
    4. import com.qiku.utils.TransactionManager;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.stereotype.Component;
    7.  
    8. import java.lang.reflect.InvocationHandler;
    9. import java.lang.reflect.Method;
    10. import java.lang.reflect.Proxy;
    11. import java.util.Arrays;
    12.  
    13. @Component
    14. public class JdkProxyFactory {
    15.     /*
    16.     * 动态代理类*/
    17.     //要代理的目标对象
    18.     @Autowired
    19.     private AccountService accountService;
    20.     //事务管理器
    21.     @Autowired
    22.     private TransactionManager transactionManager;
    23.  
    24.     //创建AccountService 的代理对象
    25.     public AccountService getAccountServiceProxy(){
    26.         AccountService accountServiceProxy =null;
    27.         accountServiceProxy = (AccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
    28.                 accountService.getClass().getInterfaces(),
    29.                 new InvocationHandler() {
    30.                     @Override
    31. //                                       代理对象    拦截到的的方法transfer()  拦截到的方法的参数
    32.                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    33.                         Object result=null;
    34.                         try{
    35. //                            开启事务
    36.                             transactionManager.beginTransaction();
    37.                             //执行业务处理
    38.                             result= method.invoke(accountService,args);
    39.                             //提交事务
    40.                             transactionManager.commit();
    41.                         }catch (Exception e){
    42.                             e.printStackTrace();
    43.                             transactionManager.rollback(); //回滚事务
    44.                         }finally {
    45.                             transactionManager.release();//释放资源
    46.                         }
    47.                         return result;
    48.                     }
    49.                 }
    50.         );
    51.         return accountServiceProxy;
    52.     }
    53.  
    54. }

    2.2 CGLIB动态代理

    2.2.1 工厂动态代理类 
    1. package com.qiku.proxy;
    2.  
    3. import com.qiku.service.AccountService;
    4. import com.qiku.utils.TransactionManager;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.cglib.proxy.Enhancer;
    7. import org.springframework.cglib.proxy.MethodInterceptor;
    8. import org.springframework.cglib.proxy.MethodProxy;
    9. import org.springframework.stereotype.Component;
    10.  
    11. import java.lang.reflect.InvocationTargetException;
    12. import java.lang.reflect.Method;
    13. import java.util.Arrays;
    14.  
    15. @Component
    16. public class CGLIBProxyFactory {
    17.  
    18.     @Autowired
    19.     private AccountService accountService;
    20.     @Autowired
    21.     private TransactionManager transactionManager;
    22.  
    23.     public AccountService getAccountServiceProxy(){
    24.         AccountService accountServiceProxy =null;
    25.         /**
    26.          * 参数一 ：目标对象的字节码文件
    27.          * 参数二 ： 动作类 实现增强功能
    28.         *
    29.         * */
    30.         accountServiceProxy= (AccountService) Enhancer.create(AccountService.class,
    31.                 new MethodInterceptor() {
    32.                     @Override
    33.                     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    34.                         Object result=null;
    35.  
    36.                         try {
    37.                             transactionManager.beginTransaction();
    38.                             result=method.invoke(accountService,objects);
    39.                             transactionManager.commit();
    40.                         } catch (Exception e) {
    41.                             e.printStackTrace();
    42.                             transactionManager.rollback();
    43.                         } finally {
    44.                             transactionManager.release();
    45.                         }
    46.                         return result;
    47.                     }
    48.                 });
    49.         return  accountServiceProxy;
    50.  
    51.     }
    52. }

    测试  转账中间添加了int i=5/0  事务捕捉到异常 数据库未发生改变

    service实现层代码

    1. @Service
    2. public class AccountServiceImpl implements AccountService {
    3.     @Autowired
    4.     private AccountDao accountDao;
    5.  
    6.     @Override
    7.     public void transfer(String outName, String innerName, Double money) {
    8. //支出
    9.             accountDao.out(outName,money);
    10.             int i=5/0;
    11. //        收入
    12.             accountDao.in(innerName,money);
    13.  
    14.  
    15.     }
    16. }

    dao实现层代码

    1. @Repository //注册到IOC容器
    2. public class AccountDaoImpl implements AccountDao {
    3.     //dao层保证同一个链接
    4.     @Autowired
    5.     private QueryRunner queryRunner;
    6.     @Autowired
    7.     private ConnectionUtils connectionUtils;
    8.  
    9.     @Override
    10.     public void out(String outerName, double money) {
    11.  
    12.         try {   String sql ="UPDATE account SET money=money-? WHERE name=?";
    13.             queryRunner.update(connectionUtils.getThreadConnection(),sql,money,outerName);
    14.         } catch (SQLException e) {
    15.             e.printStackTrace();
    16.         }
    17.     }
    18.     @Override
    19.     public void in(String innerName, double money) {
    20.  
    21.         try {   String sql ="UPDATE account SET money=money+? WHERE name=?";
    22.             queryRunner.update(connectionUtils.getThreadConnection(),sql,money,innerName);
    23.         } catch (SQLException e) {
    24.             e.printStackTrace();
    25.         }
    26.     }
    27.  
    28. }

    3.AOP术语

    3.1 Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。
    在正式讲解 AOP 的操作之前，我们必须理解 AOP 的相关术语，常用的术语如下：

    * Target（目标对象）：代理的目标对象
    * Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类
    * Joinpoint（连接点）：所谓连接点是指那些可以被拦截到的点，也就是可以被增强的方法。在spring中,这些点指的是方法，因为 spring只支持方法类型的连接点
    * Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。真正增强的方法

    （1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
    （2）语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) ) 
    举例 1：对 com.qiku.dao.BookDao 类里面的 add 进行增强
    execution(*com.qiku.dao.BookDao.add(.. ))
    举例 2：对 com.qiku.dao.BookDao 类里面的所有的方法进行增强
    execution( *com.qiku.dao.BookDao.* ( .. ))
    举例 3：对 com.qiku.dao 包里面所有类，类

    * Advice（通知/增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知 分类：前置通知、后置通知、异常通知、最终通知、环绕通知

    当前四个通知组合在一起时，执行顺序如下：
    @Before -> @After -> @AfterReturning（如果有异常：@AfterThrowing）


    * Aspect（切面）：是切入点和通知（引介）的结合
    * Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织 入，而AspectJ采用编译期织入和类装载期织入

    4 编写通知类 配置核心文件（两种方法 一种是直接写poingtcut  另一种 是先定义 再用pointcut-ref引入 ）

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:aop="http://www.springframework.org/schema/aop"
    4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    5.        xsi:schemaLocation="
    6.        http://www.springframework.org/schema/beans
    7.        http://www.springframework.org/schema/beans/spring-beans.xsd
    9.   http://www.springframework.org/schema/aop
    10.        http://www.springframework.org/schema/aop/spring-aop.xsd">
    11.  
    12. <!--    将目标对象 交给 IOC容器-->
    13.     <bean id="accountService" class="com.qiku.service.impl.AccountServiceImpl"></bean>
    14.     <bean id="userService" class="com.qiku.service.impl.UserServiceImpl"></bean>
    15.  
    16. <!--    将通知类 交给 IOC容器-->
    17.     <bean id="myAdvice" class="com.qiku.advic.MyAdvice"></bean>
    18.  
    19. <!--    配置植入关系  以及切面    方法一-->
    20.     <aop:config>
    21. <!--        引入通知类 即切面 myAdvice-->
    22.         <aop:aspect ref="myAdvice">
    23. <!--            配置目标类的transfer  方法执行是 使用前置 通知-->
    24. <!--            pointcut="execution(* com.qiku.service.impl.AccountServiceImpl.*(..))"/>-->
    25.             <aop:before method="before"
    26.  
    27.                      pointcut="execution(* com.qiku.service..*.*(..))"/>
    28.         </aop:aspect>
    29.     </aop:config>
    30. <!--    方法二-->
    31.     <aop:config>
    32. <!--        * com.qiku.service..*.*(..)   表示  service下的所有类的所有类型的方法-->
    33.         <aop:pointcut id="myPointcut" expression="execution(* com.qiku.service..*.*(..))"/>
    34.         <aop:aspect ref="myAdvice">
    35.  
    36. <!--            前置通知-->
    37.             <aop:before method="before" pointcut-ref="myPointcut"/>
    38.  
    39. <!--            后置通知-->
    40.             <aop:after-returning method="afgterReturning" pointcut-ref="myPointcut"/>
    41.  
    42. <!--            异常通知  发生异常  后置通知不执行-->
    43.             <aop:after-throwing method="afterThrowing" pointcut-ref="myPointcut"/>
    44.             <!--            最终通知  无论是否发生异常 都会执行-->
    45.             <aop:after method="after" pointcut-ref="myPointcut"/>
    46.             <!--            环绕通知 -->
    47.             <aop:around method="around" pointcut-ref="myPointcut"/>
    48.         </aop:aspect>
    49.     </aop:config>
    50.  
    51. </beans>

    5 .AOP 自动代理

    1. <!--aop的自动代理--> 
    2. <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    6 注解配置AOP详解

    6.1 切点表达式

    切点表达式的抽取

    1. @Component
    2. @Aspect
    3. public class MyAdvice {
    4.     @Pointcut("execution(* com.qiku..*.*(..))")
    5.     public void myPoint(){}
    6.  
    7.     @Before("MyAdvice.myPoint()")
    8.     public void before() {
    9.         System.out.println("前置通知...");
    10.     }
    11. }

       

    6.2通知类型

    通知的配置语法：@通知注解(“切点表达式")
    名称    标签    说明
    前置通知    @Before    用于配置前置通知。指定增强的方法在切入点方法之前执行
    后置通知    @AfterReturning    用于配置后置通知。指定增强的方法在切入点方法之后执行
    异常通知    @AfterThrowing    用于配置异常通知。指定增强的方法出现异常后执行
    最终通知    @After    用于配置最终通知。无论切入点方法执行时是否有异常，都会执行
    环绕通知    @Around    用于配置环绕通知。开发者可以手动控制增强代码在什么时候执行

    注意：

    当前四个通知组合在一起时，执行顺序如下：
    @Before -> @After -> @AfterReturning（如果有异常：@AfterThrowing）

    6.3 纯注解配置

    1. @Configuration
    2. @ComponentScan("com.qiku")  //容器里面注解扫描
    3. @EnableAspectJAutoProxy //替代 <aop:aspectj-autoproxy />
    4. public class SpringConfig {
    5.  
    6. }

    6 .4 AOP优化转账案例

    依然使用前面的转账案例，将两个代理工厂对象直接删除！改为spring的aop思想来实现
    xml配置实现

    1）配置文件

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.     xmlns:aop="http://www.springframework.org/schema/aop"
    5.     xmlns:context="http://www.springframework.org/schema/context"
    6.     xsi:schemaLocation=" http://www.springframework.org/schema/beans
    7.         http://www.springframework.org/schema/beans/spring-beans.xsd
    8.         http://www.springframework.org/schema/aop
    9.         http://www.springframework.org/schema/aop/spring-aop.xsd
    10.         http://www.springframework.org/schema/context
    11.         http://www.springframework.org/schema/context/spring-context.xsd">
    12.  
    13.     <!--开启组件扫描-->
    14.     <context:component-scan base-package="com.qiku"/>
    15.     <!--加载jdbc配置文件-->
    16.     <context:property-placeholder location="classpath:jdbc.properties"/>
    17.     <!--把数据库连接池交给IOC容器-->
    18.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    19.         <property name="driverClassName" value="${jdbc.driver}"></property>
    20.         <property name="url" value="${jdbc.url}"></property>
    21.         <property name="username" value="${jdbc.username}"></property>
    22.         <property name="password" value="${jdbc.password}"></property>
    23.     </bean>
    24.     <!--把QueryRunner交给IOC容器-->
    25.     <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
    26.         <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    27.     </bean>
    28.     <!--AOP配置-->
    29.     <aop:config>
    30.         <!--切点表达式-->
    31.         <aop:pointcut id="myPointcut" expression="execution(* com.qiku.service..*.*(..))"/>
    32.         <!-- 切面配置 -->
    33.         <aop:aspect ref="transactionManager">
    34.             <aop:before method="beginTransaction" pointcut-ref="myPointcut"/>
    35.             <aop:after-returning method="commit" pointcut-ref="myPointcut"/>
    36.             <aop:after-throwing method="rollback" pointcut-ref="myPointcut"/>
    37.             <aop:after method="release" pointcut-ref="myPointcut"/>
    38.         </aop:aspect>
    39.     </aop:config>
    40. </beans>

    2）事务管理器（通知）

    1. // 事务管理器工具类，包括：开启事务、提交事务、回滚事务、释放资源
    2. @Component
    3. public class TransactionManager {
    4.     @Autowired
    5.     ConnectionUtils connectionUtils;
    6.     public void begin(){
    7.         try {
    8.             connectionUtils.getThreadConnection().setAutoCommit(false);
    9.         } catch (SQLException e) {
    10.             e.printStackTrace();
    11.         }
    12.     }
    13.  
    14.     public void commit(){
    15.         try {
    16.             connectionUtils.getThreadConnection().commit();
    17.         } catch (SQLException e) {
    18.             e.printStackTrace();
    19.         }
    20.     }
    21.     
    22.     public void rollback(){
    23.         try {
    24.             connectionUtils.getThreadConnection().rollback();
    25.         } catch (SQLException e) {
    26.             e.printStackTrace();
    27.         }
    28.     }
    29.  
    30.     public void release(){
    31.         try {
    32.             connectionUtils.getThreadConnection().setAutoCommit(true);
    33.             connectionUtils.getThreadConnection().close();
    34.             connectionUtils.removeThreadConnection();
    35.         } catch (SQLException e) {
    36.             e.printStackTrace();
    37.         }
    38.     }
    39. }

    6.5注解配置实现

    1）配置文件

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.     xmlns:aop="http://www.springframework.org/schema/aop"
    5.     xmlns:context="http://www.springframework.org/schema/context"
    6.     xsi:schemaLocation=" http://www.springframework.org/schema/beans
    7.         http://www.springframework.org/schema/beans/spring-beans.xsd
    8.         http://www.springframework.org/schema/aop
    9.         http://www.springframework.org/schema/aop/spring-aop.xsd
    10.         http://www.springframework.org/schema/context
    11.         http://www.springframework.org/schema/context/spring-context.xsd">
    12.  
    13.     <!--开启组件扫描-->
    14.     <context:component-scan base-package="com.qiku"/>
    15.     <!--开启AOP注解支持-->
    16.     <aop:aspectj-autoproxy/>
    17.     <!--加载jdbc配置文件-->
    18.     <context:property-placeholder location="classpath:jdbc.properties"/>
    19.     <!--把数据库连接池交给IOC容器-->
    20.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    21.         <property name="driverClassName" value="${jdbc.driver}"></property>
    22.         <property name="url" value="${jdbc.url}"></property>
    23.         <property name="username" value="${jdbc.username}"></property>
    24.         <property name="password" value="${jdbc.password}"></property>
    25.     </bean>
    26.  
    27.     <!--把QueryRunner交给IOC容器-->
    28.     <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
    29.         <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    30.     </bean>
    31. </beans>

      

    2）事务管理器（通知）
     

    1. @Component
    2. @Aspect
    3. public class TransactionManager {
    4.     @Autowired
    5.     ConnectionUtils connectionUtils;
    6.  
    7.     @Around("execution(* com.hyq.serivce..*.*(..))")
    8.     public Object around(ProceedingJoinPoint pjp) {
    9.         Object object = null;
    10.         try {
    11.             // 开启事务
    12.             connectionUtils.getThreadConnection().setAutoCommit(false);
    13.             // 业务逻辑
    14.             pjp.proceed();
    15.             // 提交事务
    16.             connectionUtils.getThreadConnection().commit();
    17.         } catch (Throwable throwable) {
    18.             throwable.printStackTrace();
    19.             // 回滚事务
    20.             try {
    21.                 connectionUtils.getThreadConnection().rollback();
    22.             } catch (SQLException e) {
    23.                 e.printStackTrace();
    24.             }
    25.         } finally {
    26.             try {
    27.                 connectionUtils.getThreadConnection().setAutoCommit(true);
    28.                 connectionUtils.getThreadConnection().close();
    29.                 connectionUtils.removeThreadConnection();
    30.             } catch (SQLException e) {
    31.                 e.printStackTrace();
    32.             }
    33.         }
    34.         return object;
    35.     }
    36. }

    6.6 注意点

    1 在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高
  • 相关阅读:
    OpenJDK 19 的 5 个最关键和最具创新性的补充
    nodejs+vue健身房课程预约评分系统
    国内有好用的RPA浏览器吗？RPA浏览器的作用是什么？
    智云通CRM：让客户需要你，比你去寻找客户更重要？
    全连接神经网络学习MNIST实现手写数字识别
    如何在游戏中实现一场下雨效果
    关于proxmox，给Zstack的公开建议
    项目开始前要明确的几个注意事项
    Mybatis系列之 parameterMap 弃用了
    [HITCON CTF 2022] Superprime，rev Meow_way，BabySSS格基约减法，Secret共模攻击模未知
  • 原文地址：https://blog.csdn.net/weixin_45172902/article/details/125528637