Spring框架学习总结第三天

最新推荐文章于 2023-07-28 08:01:36 发布

Query*

最新推荐文章于 2023-07-28 08:01:36 发布

阅读量178

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/qq_46601365/article/details/117424367

版权

java 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

Spring框架学习总结第三天

AOP的相关概念[理解]

AOP概述

什么是AOP

AOP：全称是 Aspect Oriented Programming 即：面向切面编程。

在这里插入图片描述

简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

AOP的作用及优势

作用：

在程序运行期间，不修改源码对已有方法进行增强。

优势：

减少重复代码

提高开发效率

维护方便

AOP的实现方式

使用动态代理技术

AOP的具体应用

案例中问题

这是我们昨天课程中做的增删改查例子。下面是客户的业务层实现类。我们能看出什么问题吗?

package com.itheima.service.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;

import java.util.List;

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public List<Account> findAllAccount() {
        return accountDao.findAllAccount();
    }

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }

    @Override
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    @Override
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    @Override
    public void deleteAccount(Integer acccountId) {
        accountDao.deleteAccount(acccountId);
    }
    
}

问题就是

事务被自动控制了。换言之，我们使用了 connection 对象的 setAutoCommit(true)

此方式控制事务，如果我们每次都执行一条 sql 语句，没有问题，但是如果业务方法一次要执行多条 sql语句，这种方式就无法实现功能了。

请看下面的示例：我们在业务层中多加入一个方法。

业务层接口
    
/**
 * 转账
 * @param sourceName    转出账户名称
 * @param targetName    转入账户名称
 * @param money         转账金额
 */
void transfer(String sourceName, String targetName, Float money);

业务层实现类
@Override
public void transfer(String sourceName, String targetName, Float money) {
    //2.1根据名称查询转出账户
    Account source = accountDao.findAccountByName(sourceName);
    //2.2根据名称查询转入账户
    Account target = accountDao.findAccountByName(targetName);
    //2.3转出账户减钱
    source.setMoney(source.getMoney() - money);
    //2.4转入账户加钱
    target.setMoney(target.getMoney() + money);
    //2.5更新转出账户
    accountDao.updateAccount(source);

    //手动制造异常
    //int i = 1/0;

    //2.6更新转入账户
    accountDao.updateAccount(target);
}

当我们执行时，由于执行有异常，转账失败。但是因为我们是每次执行持久层方法都是独立事务，导致无法实现事务控制（不符合事务的一致性）

问题的解决

分析

在这里插入图片描述

该方法中每一个连接都是一个单独的事务，单个线程访问该方法，会出现多个事务的情况，出现异常，则后续事务无法提交，故我们需要将这些连接整合成一个事务，使用ThreadLocal对象把Connection和当前线程绑定，从而使一个线程中只有一个能控制事务的对象。

解决办法

让业务层来控制事务的提交和回滚。

改造后的业务层实现类

注：此处没有使用spring的IoC

package com.itheima.service.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import com.itheima.utils.TransactionManager;

import java.util.List;

/**
 * 账户的业务层实现类
 *
 * 事务控制应该都是在业务层
 */
public class AccountServiceImpl_OLD implements IAccountService{

    private IAccountDao accountDao;
    private TransactionManager txManager;

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public List<Account> findAllAccount() {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            List<Account> accounts = accountDao.findAllAccount();
            //3.提交事务
            txManager.commit();
            //4.返回结果
            return accounts;
        } catch (Exception e) {
            //5.回滚操作
            txManager.rollback();
            throw new RuntimeException(e);
        } finally {
            //6.释放连接
            txManager.release();
        }
    }

    public Account findAccountById(Integer accountId) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            Account account = accountDao.findAccountById(accountId);
            //3.提交事务
            txManager.commit();
            //4.返回结果
            return account;
        } catch (Exception e) {
            //5.回滚操作
            txManager.rollback();
            throw new RuntimeException(e);
        } finally {
            //6.释放连接
            txManager.release();
        }
    }

    public void saveAccount(Account account) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.saveAccount(account);
            //3.提交事务
            txManager.commit();
        } catch (Exception e) {
            //4.回滚操作
            txManager.rollback();
        } finally {
            //5.释放连接
            txManager.release();
        }
    }

    public void updateAccount(Account account) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.updateAccount(account);
            //3.提交事务
            txManager.commit();
        } catch (Exception e) {
            //4.回滚操作
            txManager.rollback();
        } finally {
            //5.释放连接
            txManager.release();
        }
    }

    public void deleteAccount(Integer accountId) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.deleteAccount(accountId);
            //3.提交事务
            txManager.commit();
        } catch (Exception e) {
            //4.回滚操作
            txManager.rollback();
        } finally {
            //5.释放连接
            txManager.release();
        }
    }

    public void transfer(String sourceName, String targetName, Float money) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney() - money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney() + money);
            //2.5更新转出账户
            accountDao.updateAccount(source);

            //手动制造异常
            //int i = 1/0;

            //2.6更新转入账户
            accountDao.updateAccount(target);
            //3.提交事务
            txManager.commit();
        } catch (Exception e) {
            //4.回滚操作
            txManager.rollback();
            e.printStackTrace();
        } finally {
            //5.释放连接
            txManager.release();
        }

    }
}

连接工具类

package com.itheima.utils;

import javax.sql.DataSource;
import java.sql.Connection;

/**
 * 连接工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定
 */
public class ConnectionUtils {

    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    /**
     * 获取当前线程上的连接，保证该线程获得的连接为同一个
     * @return
     */
    public Connection getThreadConnection() {
        //1.先从ThreadLocal上获取
        Connection conn = tl.get();
        try{
            //2.判断当前线程上是否有链接
            if (conn == null) {
                //3.从数据源中获取一个连接，并且存入ThreadLocal中，数据源不能new，只能等spring注入
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            //4.返回当前线程上的连接
            return conn;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 在线程用完后，把线程和连接解绑（java工程不涉及这个问题，但web工程涉及）
     */
    public void removeConnection() {
        tl.remove();
    }
}

和事务管理相关的工具类

package com.itheima.utils;

import java.sql.SQLException;

/**
 * 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放事务
 */
public class TransactionManager {

    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    /**
     * 开启事务
     */
    public void beginTransaction() {
        try {
            //System.out.println(connectionUtils.getThreadConnection()); //事务使得获取的连接Connection对象是同一个
            connectionUtils.getThreadConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 提交事务
     */
    public void commit() {
        try {
            //System.out.println(connectionUtils.getThreadConnection());
            connectionUtils.getThreadConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 回滚事务
     */
    public void rollback() {
        try {
            //System.out.println(connectionUtils.getThreadConnection());
            connectionUtils.getThreadConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 释放连接
     */
    public void release() {
        try {
            //System.out.println(connectionUtils.getThreadConnection());
            connectionUtils.getThreadConnection().close(); //还回连接池中
            connectionUtils.removeConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

其他类的代码

项目jar包

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

    <!--提供QueryRunner类执行sql语句-->
    <dependency>
        <groupId>commons-dbutils</groupId>
        <artifactId>commons-dbutils</artifactId>
        <version>1.4</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.11</version>
    </dependency>

    <dependency>
        <groupId>c3p0</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.1.2</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

dao

package com.itheima.dao;

import com.itheima.domain.Account;
import java.util.List;

/**
 * 账户的持久层接口
 */
public interface IAccountDao {

    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();

    /**
     * 查询一个
     * @return
     */
    Account findAccountById(Integer accountId);

    /**
     * 保存
     * @param account
     */
    void saveAccount(Account account);

    /**
     * 更新
     * @param account
     */
    void updateAccount(Account account);

    /**
     * 删除
     * @param accountId
     */
    void deleteAccount(Integer accountId);

    /**
     * 根据名称查询账户
     * @param accountName
     * @return    如果有唯一的一个结果就返回，如果没有结果就返回null
     *            如果结果集超过一个就抛异常
     */
    Account findAccountByName(String accountName);
}

daoImpl

package com.itheima.dao.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.utils.ConnectionUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.util.List;

/**
 * 账户的持久层实现类
 */
public class AccountDaoImpl implements IAccountDao {

    private QueryRunner runner;
    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }

    public List<Account> findAllAccount() {
        try{
            return runner.query(connectionUtils.getThreadConnection(),"select * from account",new BeanListHandler<Account>(Account.class));
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public Account findAccountById(Integer accountId) {
        try{
            return runner.query(connectionUtils.getThreadConnection(),"select * from account where id = ? ",new BeanHandler<Account>(Account.class),accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void saveAccount(Account account) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"insert into account(name,money)values(?,?)",account.getName(),account.getMoney());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void updateAccount(Account account) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void deleteAccount(Integer accountId) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"delete from account where id=?",accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public Account findAccountByName(String accountName) {
        try{
            List<Account> accounts = runner.query(connectionUtils.getThreadConnection(),"select * from account where name = ? ", new BeanListHandler<Account>(Account.class), accountName);
            if (accounts == null || accounts.size() == 0) {
                return null;
            }
            if (accounts.size() > 1) {
                throw new RuntimeException("结果集不唯一，数据有问题");
            }
            return accounts.get(0);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

pojo

package com.itheima.domain;

import java.io.Serializable;

/**
 * 账户的实体类
 */
public class Account implements Serializable {

    private Integer id;
    private String name;
    private Float money;
    
}

service

package com.itheima.service;

import com.itheima.domain.Account;

import java.util.List;

/**
 * 账户的业务层接口
 */
public interface IAccountService {

    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();

    /**
     * 查询一个
     * @return
     */
    Account findAccountById(Integer accountId);

    /**
     * 保存
     * @param account
     */
    void saveAccount(Account account);

    /**
     * 更新
     * @param account
     */
    void updateAccount(Account account);

    /**
     * 删除
     * @param accountId
     */
    void deleteAccount(Integer accountId);

    /**
     * 转账
     * @param sourceName    转出账户名称
     * @param targetName    转入账户名称
     * @param money         转账金额
     */
    void transfer(String sourceName, String targetName, Float money);

    //void test(); //他只是连接点，不是切入点，因为没有被增强
}

bean.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">

    <!-- 配置Service -->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl_OLD">
        <!--注入dao set方法注入-->
        <property name="accountDao" ref="accountDao"></property>
        <!--注入事务管理器-->
        <property name="txManager" ref="txManager"></property>
    </bean>

    <!--配置Dao对象-->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
        <!--注入QueryRunner -->
        <property name="runner" ref="runner"></property>
        <!--注入ConnectionUtils-->
        <property name="connectionUtils" ref="connectionUtils"></property>
     </bean>

    <!--配置QueryRunner scope="prototype"配置QueryRunner对象为多例对象，保证多线程安全问题-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入数据源 不需要了，直接从util类里注入
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
        -->
    </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://localhost:3306/eesy?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;serverTimezone=GMT%2B8"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!--配置Connection的工具类 ConnectionUtils-->
    <bean id="connectionUtils" class="com.itheima.utils.ConnectionUtils">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--配置事务管理器-->
    <bean id="txManager" class="com.itheima.utils.TransactionManager">
        <!--注入ConnectionUtils-->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>

</beans>

test

package com.itheima.test;

import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

/**
 * 使用Junit单元测试，测试我们的配置
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {

    @Autowired
    @Qualifier("accountService")
    private IAccountService as;

    @Test
    public void testTransfer() {
        as.transfer("aaa","bbb",100F);
    }

}

新的问题

上一小节的代码，通过对业务层改造，已经可以实现事务控制了，但是由于我们添加了事务控制，也产生了一个新的问题：

业务层方法变得臃肿了，里面充斥着很多重复代码。并且业务层方法和事务控制方法耦合了，即方法之间的依赖很强

试想一下，如果我们此时提交，回滚，释放资源中任何一个方法名变更，都需要修改业务层的代码，况且这还只是一个业务层实现类，而实际的项目中这种业务层实现类可能有十几个甚至几十个。

思考：

这个问题能不能解决呢？

答案是肯定的，使用下一小节中提到的技术。

动态代理

动态代理的特点

字节码随用随创建，随用随加载。

它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。

装饰者模式就是静态代理的一种体现。

动态代理的作用

不修改源码的基础上对方法增强。

动态代理常用的有两种方式

基于接口的动态代理

提供者：JDK 官方的 Proxy 类。

要求：被代理类最少实现一个接口。

基于子类的动态代理

提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。

要求：被代理类不能用 final 修饰的类（最终类）。

使用JDK官方的Proxy类创建代理对象

此处我们使用的是一个生产者和消费者的例子：

对生产厂家要求的接口

package com.itheima.proxy;

public interface IProducer {
    /**
     * 销售
     * @param money
     */
    public void saleProduct(float money);


    /**
     * 售后
     * @param money
     */
    public void afterService(float money);
}

一个生产者

package com.itheima.proxy;

public class Producer implements IProducer{
    /**
     * 销售
     * @param money
     */
    public void saleProduct(float money) {
        System.out.println("销售产品，并拿到钱：" + money);
    }

    /**
     * 售后
     * @param money
     */
    public void afterService(float money) {
        System.out.println("提供售后服务，并拿到钱：" + money);
    }
}

模拟一个消费者

package com.itheima.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Client {

    public static void main(String[] args) {
        //匿名内部类访问外部成员变量时，外部成员变量要求是最终的
        final Producer producer = new Producer();

        /**
         * 动态代理：
         *    特点：字节码随用随创建，随用随加载
         *    作用：不修改源码的基础上对方法增强
         *    分类：
         *        基于接口的动态代理
         *        基于子类的动态代理
         *    基于接口的动态代理：
         *        涉及的类：Proxy
         *        提供者：JDK官方
         *    如何创建代理对象：
         *        使用Proxy类中的newProxyInstance方法
         *    创建代理对象的要求：
         *        被代理类最少实现一个接口，如果没有则不能使用
         *    newProxyInstance方法的参数：
         *        ClassLoader：类加载器
         *             它是用于加载代理对象字节码的，和被代理对象使用相同的类加载器，固定写法
         *        Class[]：字节码数组
         *             它是用于让代理对象和被代理对象有相同方法
         *        InvocationHandler：用于提供增强的代码
         *             它是让我们写如何代理，我们一般都是写一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的
         *             此接口的实现类都是谁用谁写
         */
        IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 作用：执行被代理对象的任何接口方法都会经过该方法
                     * 方法参数的含义
                     * @param proxy     代理对象的引用 可以用他在方法中获取代理对象，一般不用
                     * @param method    当前执行的方法
                     * @param args      当前执行方法所需的参数
                     * @return          和被代理对象方法有相同的返回值
                     * @throws Throwable
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //return method.invoke(producer,args); //代理对象什么也没干，没有增强

                        //提供增强的代码
                        Object returnValue = null;
                        //1.获取方法执行的参数
                        Float money = (Float)args[0];
                        //2.判断当前方法是不是销售
                        if ("saleProduct".equals(method.getName())) {
                            returnValue = method.invoke(producer,money*0.8F);
                        }
                        return returnValue;
                    }
                });
        proxyProducer.saleProduct(10000F);
    }
}

运行结果

在这里插入图片描述

使用CGLib的Enhancer类创建代理对象

需要的jar包

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.1_3</version>
</dependency>

一个生产者

package com.itheima.cglib;

import com.itheima.proxy.IProducer;

public class Producer {
    /**
     * 销售
     * @param money
     */
    public void saleProduct(float money) {
        System.out.println("销售产品，并拿到钱：" + money);
    }

    /**
     * 售后
     * @param money
     */
    public void afterService(float money) {
        System.out.println("提供售后服务，并拿到钱：" + money);
    }
}

模拟一个消费者

package com.itheima.cglib;

import com.itheima.proxy.Producer;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class Client {

    public static void main(String[] args) {
        //匿名内部类访问外部成员变量时，外部成员变量要求是最终的
        final Producer producer = new Producer();

        /**
         * 动态代理：
         *    特点：字节码随用随创建，随用随加载
         *    作用：不修改源码的基础上对方法增强
         *    分类：
         *        基于接口的动态代理
         *        基于子类的动态代理
         *    基于子类的动态代理：
         *        涉及的类：Enhance
         *        提供者：第三方cglib库
         *    如何创建代理对象：
         *        使用Enhance类中的create方法
         *    创建代理对象的要求：
         *        被代理类不能是最终类
         *    create方法的参数：
         *        Class：字节码
         *             它是用于指定被代理对象的字节码
         *        Callback：用于提供增强的代码
         *             它是让我们写如何代理，我们一般都是写一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的
         *             此接口的实现类都是谁用谁写
         *             我们一般写的都是该接口（Callback）的子接口实现类：MethodInterceptor
         */
        Producer cglibProduce = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
            /**
             * 执行被代理对象的任何方法都会经过该方法
             * @param proxy
             * @param method
             * @param args
             * 以上三个参数和基于接口的动态代理中invoke方法参数是一样的
             * @param methodProxy   当前执行方法的代理对象
             * @return   和被代理对象执行的方法的返回值一样
             * @throws Throwable
             */
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                //提供增强的代码
                Object returnValue = null;
                //1.获取方法执行的参数
                Float money = (Float)args[0];
                //2.判断当前方法是不是销售
                if ("saleProduct".equals(method.getName())) {
                    returnValue = method.invoke(producer,money*0.8F);
                }
                return returnValue;
            }
        });
        cglibProduce.saleProduct(12000F);
    }
}

运行结果

在这里插入图片描述

解决案例中的问题

用于创建Service的代理对象的工厂

package com.itheima.factory;

import com.itheima.service.IAccountService;
import com.itheima.utils.TransactionManager;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class BeanFactory {

    private IAccountService accountService;
    private TransactionManager txManager;

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }

    public final void setAccountService(IAccountService accountService) {
        this.accountService = accountService;
    }

    /**
     * 获取Service代理对象
     * @return
     */
    public IAccountService getAccountService() {
        return (IAccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 添加事务的支持
                     * @param proxy
                     * @param method
                     * @param args
                     * @return
                     * @throws Throwable
                     */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if ("test".equals(method.getName())) {
                    return method.invoke(accountService,args);
                }
                Object rtValue = null;
                try {
                    //1.开启事务
                    txManager.beginTransaction();
                    //2.执行操作
                    rtValue = method.invoke(accountService, args);
                    //3.提交事务
                    txManager.commit();
                    //4.返回结果
                    return rtValue;
                } catch (Exception e) {
                    //5.回滚操作
                    txManager.rollback();
                    throw new RuntimeException(e);
                } finally {
                    //6.释放连接
                    txManager.release();
                }
            }
        });
    }
}

业务层实现类

package com.itheima.service.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import com.itheima.utils.TransactionManager;

import java.util.List;

/**
 * 账户的业务层实现类
 *
 * 事务控制应该都是在业务层
 */
public class AccountServiceImpl implements IAccountService{

    private IAccountDao accountDao;
    /*private TransactionManager txManager;

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    } 创建了代理对象，就不需要这个了*/

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public List<Account> findAllAccount() {
        return accountDao.findAllAccount();
    }

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }

    @Override
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    @Override
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    @Override
    public void deleteAccount(Integer accountId) {
        accountDao.deleteAccount(accountId);
    }

    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer......");
        //2.1根据名称查询转出账户
        Account source = accountDao.findAccountByName(sourceName);
        //2.2根据名称查询转入账户
        Account target = accountDao.findAccountByName(targetName);
        //2.3转出账户减钱
        source.setMoney(source.getMoney() - money);
        //2.4转入账户加钱
        target.setMoney(target.getMoney() + money);
        //2.5更新转出账户
        accountDao.updateAccount(source);

        //手动制造异常
        //int i = 1/0;

        //2.6更新转入账户
        accountDao.updateAccount(target);
    }
}

在bean.xml中添加及修改的代码

<!--配置代理的service-->

<bean id="proxyAccountService" factory-bean="beanFactory" factory-method="getAccountService"></bean>

<!--配置beanFactory-->
<bean id="beanFactory" class="com.itheima.factory.BeanFactory">
    <!--注入service-->
    <property name="accountService" ref="accountService"></property>
    <!--注入事务管理器-->
    <property name="txManager" ref="txManager"></property>
</bean>

<!-- 配置Service -->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
    <!--注入dao set方法注入-->
    <property name="accountDao" ref="accountDao"></property>
    <!--注入事务管理器
    <property name="txManager" ref="txManager"></property>
    -->
</bean>

测试类

package com.itheima.test;

import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

/**
 * 使用Junit单元测试，测试我们的配置
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {

    @Autowired
    @Qualifier("proxyAccountService")
    private IAccountService as;

    @Test
    public void testTransfer() {
        as.transfer("aaa","bbb",100F);
    }

}

Spring中的AOP[掌握]

Spring中AOP的细节

说明

我们学习 spring 的 aop，就是通过配置的方式，实现上一章节的功能。

AOP相关术语

Joinpoint(连接点)

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

Pointcut(切入点)

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

Advice(通知/增强)

所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。

通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

Introduction(引介)

引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。

Target(目标对象)

代理的目标对象。

Weaving(织入)

是指把增强应用到目标对象来创建新的代理对象的过程。

spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

Proxy(代理)

一个类被 AOP 织入增强后，就产生一个结果代理类。

Aspect(切面)

是切入点和通知（引介）的结合。

学习spring中的AOP要明确的事

a、开发阶段（我们做的）

编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。

把公用代码抽取出来，制作成通知。（开发阶段最后再做）：AOP 编程人员来做。

在配置文件中，声明切入点与通知间的关系，即切面。：AOP 编程人员来做。

b、运行阶段（Spring框架完成的）

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

关于代理的选择

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

基于XML的AOP配置

示例：

在执行增删改时，记录日志。并且把 spring 的 ioc 也一起应用进来。

导入jar包

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

    <!--后面为了解析切入点表达式-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.7</version>
    </dependency>
</dependencies>

业务层接口

package com.itheima.service;

/**
 * 账户的业务层接口
 */
public interface IAccountService {
    /**
     * 模拟保存账户
     */
    void saveAccount();

    /**
     * 模拟更新账户
     */
    void updateAccount(int i);

    /**
     * 删除账户
     * @return
     */
    int deleteAccount();
}

业务层接口实现类

package com.itheima.service.impl;

import com.itheima.service.IAccountService;

public class AccountServiceImpl implements IAccountService {
    public void saveAccount() {
        System.out.println("执行了保存");
    }

    public void updateAccount(int i) {
        System.out.println("执行了更新" + i);
    }

    public int deleteAccount() {
        System.out.println("执行了删除");
        return 0;
    }
}

记录日志的工具类

package com.itheima.utils;

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {
    /**
     * 用于打印日志，计划让其在切入点方法执行之前执行（切入点方法就是业务层方法）
     */
    public void printLog() {
        System.out.println("Logger类中的printLog方法开始记录日志了。。。");
    }
}

spring中基于XML的AOP配置步骤

1、把通知Bean也交给spring来管理

<!--配置spring的IOC，把service对象配置进来-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

<!--配置Logger类-->
<bean id="logger" class="com.itheima.utils.Logger"></bean>

2、使用aop:config标签表明开始AOP的配置

aop:config

作用：用于声明开始 aop 的配置

<aop:config>
<!-- 配置的代码都写在此处 -->
</aop:config>

3、使用aop:aspect标签表明配置切面

aop:aspect

作用：用于配置切面。

属性：

id：给切面提供一个唯一标识。

ref：引用配置好的通知类 bean 的 id。

<aop:aspect id="logAdvice" ref="logger">
    <!--配置通知的类型，并且建立通知方法和切入点方法的关联-->          
</aop:aspect>

4、在aop:aspect标签的内部使用对应标签来配置通知的类型

我们现在示例是让printLog方法在切入点方法执行之前执行，所以是前置通知。

配置文件bean.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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">

    <!--配置spring的IOC，把service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

    <!--配置Logger类-->
    <bean id="logger" class="com.itheima.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置通知的类型，并且建立通知方法和切入点方法的关联-->
            <aop:before method="printLog" pointcut="execution(* com.itheima.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

测试AOP的配置

package com.itheima.test;

import com.itheima.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AOPTest {

    public static void main(String[] args) {
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        //3.执行方法
        as.saveAccount();
        as.updateAccount(1);
        as.deleteAccount();
    }
}

四种常用的通知类型

aop:before

作用：

用于配置前置通知。指定增强的方法在切入点方法之前执行

属性：

method：用于指定通知类中的增强方法名称

poinitcut：用于指定切入点表达式，表达式的含义指的是对业务层中哪些方法增强

ponitcut-ref：用于指定切入点的表达式的引用

执行时间点：

切入点方法执行之前执行

aop:after-returning

作用：

用于配置后置通知

属性：

method：指定通知中方法的名称

pointcut：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

执行时间点：

切入点方法正常执行之后。它和异常通知只能有一个执行

aop:after-throwing

作用：

用于配置异常通知

属性：

method：指定通知中方法的名称

pointcut：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

执行时间点：

切入点方法执行产生异常后执行。它和后置通知只能执行一个

aop:after

作用：

用于配置最终通知

属性：

method：指定通知中方法的名称

pointcut：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

执行时间点：

无论切入点方法执行时是否有异常，它都会在其后面执行

测试

修改记录日志的工具类

package com.itheima.utils;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {
    /**
     * 前置通知
     */
    public void beforePrintLog() {
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }

    /**
     * 后置通知
     */
    public void afterReturningPrintLog() {
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
    }

    /**
     * 异常通知
     */
    public void afterThrowingPrintLog() {
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }

    /**
     * 最终通知
     */
    public void afterPrintLog() {
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }
    
}

修改配置文件bean.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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">

    <!--配置spring的IOC，把service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

    <!--配置Logger类-->
    <bean id="logger" class="com.itheima.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"/>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置前置通知：在切入点方法执行之前执行-->
            <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>
            
            <!--配置后置通知：在切入点方法正常执行之后执行 它和异常通知永远只能执行一个-->
            <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>
            
            <!--配置异常通知：在切入点方法执行产生异常之后执行 它和后置通知永远只能执行一个-->
            <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>
            
            <!--配置最终通知：无论切入点方法是否正常执行它都会在其后面执行-->
            <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

修改测试类

package com.itheima.test;

import com.itheima.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 测试AOP的配置
 */
public class AOPTest {

    public static void main(String[] args) {
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        //3.执行方法
        as.saveAccount();
    }
}

运行结果

在这里插入图片描述

切入点表达式

切入点表达式的写法

关键字：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.*.*(..)

切入点表达式的配置

1、在各个通知的pointcut属性中直接定义切入点表达式，例如

<!--配置AOP-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置通知的类型，并且建立通知方法和切入点方法的关联-->
            <aop:before method="printLog" pointcut="execution(* com.itheima.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>

2、使用aop:pointcut标签定义切入点表达式，再使用各个通知的pointcut-ref属性引用切入点表达式，例如

作用：

用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。

属性：

expression：用于定义切入点表达式。

id：用于给切入点表达式提供一个唯一标识

注意：

使用aop:pointcut标签定义切入点表达式写在aop:aspect标签内部只能当前切面使用，它还可以写在aop:aspect标签外面，此时就变成了所有切面可用。写在aop:aspect标签时必须是aop:aspect标签前面，因为有约束。

<aop:config>
    <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"/>
    <!--配置切面-->
    <aop:aspect id="logAdvice" ref="logger">
        <!--配置前置通知：在切入点方法执行之前执行-->
        <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>
    </aop:aspect>
</aop:config>

环绕通知

aop:around

作用：

用于配置环绕通知，它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式

属性：

method：指定通知中方法的名称。

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

说明：

它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。

注意：

通常情况下，环绕通知都是独立使用的

测试

只需要修改记录日志的工具类和配置文件bean.xml即可

修改记录日志的工具类

package com.itheima.utils;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {
    public void aroundPrintLog() {
		System.out.println("环绕通知Logger类中的aroundPrintLog方法开始记录日志了");     
    }
}

修改配置文件bean.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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">

    <!--配置spring的IOC，把service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

    <!--配置Logger类-->
    <bean id="logger" class="com.itheima.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"/>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置环绕通知 详细的注释请看Logger类中-->
            <aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

运行结果

在这里插入图片描述

问题

当我们配置了环绕通知后，切入点方法没有执行，而通知方法执行了

问题解决

分析

通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有

在这里插入图片描述

解决

Spring框架为我们提供了一个接口，ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。

修改记录日志的工具类

package com.itheima.utils;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {
    /**
     * 环绕通知
     */
    public Object aroundPrintLog(ProceedingJoinPoint pjp) {
        Object rtValue = null;
        try {
            Object[] args = pjp.getArgs(); //得到方法执行所需的参数
            System.out.println("环绕通知Logger类中的aroundPrintLog方法开始记录日志了。。。前置");
            rtValue = pjp.proceed(args); //明确调用业务层方法（切入点方法）
            System.out.println("环绕通知Logger类中的aroundPrintLog方法开始记录日志了。。。后置");
            return rtValue;
        } catch (Throwable throwable) { //异常必须是Throwable，exception不行
            System.out.println("环绕通知Logger类中的aroundPrintLog方法开始记录日志了。。。异常");
            throw new RuntimeException(throwable);
        } finally {
            System.out.println("环绕通知Logger类中的aroundPrintLog方法开始记录日志了。。。最终");
        }
    }
}

运行结果

在这里插入图片描述

基于注解的AOP配置

导入jar包

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

    <!--后面为了解析切入点表达式-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.7</version>
    </dependency>

    <!--导入spring整合junit的jar包（坐标）-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

业务层接口

package com.itheima.service;

/**
 * 账户的业务层接口
 */
public interface IAccountService {
    /**
     * 模拟保存账户
     */
    void saveAccount();

    /**
     * 模拟更新账户
     */
    void updateAccount(int i);

    /**
     * 删除账户
     * @return
     */
    int deleteAccount();
}

业务层接口实现类

package com.itheima.service.impl;

import com.itheima.service.IAccountService;
import org.springframework.stereotype.Service;

/**
 * 账户的业务层实现类
 */
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
    public void saveAccount() {
        System.out.println("执行了保存");
        //int i = 1/0;
    }

    public void updateAccount(int i) {
        System.out.println("执行了更新" + i);
    }

    public int deleteAccount() {
        System.out.println("执行了删除");
        return 0;
    }
}

配置文件bean.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       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">

    <!--配置spring创建容器时要扫描的包-->
    <context:component-scan base-package="com.itheima"></context:component-scan>

    <!--配置spring开启注解AOP的支持  可以使用EnableAspectJAutoProxy替换-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
</beans>

不使用XML的配置方式

@EnableAspectJAutoProxy

作用：

开启注解AOP的支持

@Configuration
@ComponentScan(basePackages="com.itheima")
@EnableAspectJAutoProxy
public class SpringConfiguration {
}

记录日志的工具类(四种通知)

@Aspect

作用：

把当前类声明为切面类。

@Before

作用：

把当前方法看成是前置通知。

属性：

value：用于指定切入点表达式，还可以指定切入点表达式的引用。

@AfterReturning

作用：

把当前方法看成是后置通知。

属性：

value：用于指定切入点表达式，还可以指定切入点表达式的引用

@AfterThrowing

作用：

把当前方法看成是异常通知。

属性：

value：用于指定切入点表达式，还可以指定切入点表达式的引用

@After

作用：

把当前方法看成是最终通知。

属性：

value：用于指定切入点表达式，还可以指定切入点表达式的引用

package com.itheima.utils;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
@Component("logger")
//@EnableAspectJAutoProxy //开启注解AOP的支持的注解也可以加在这里
@Aspect //表示当前类是一个切面类
public class Logger {

    @Pointcut("execution(* com.itheima.service.impl.*.*(..))")
    private void pt1() {}

    /**
     * 前置通知
     */
    @Before("pt1()")
    public void beforePrintLog() {
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }

    /**
     * 后置通知
     */
    @AfterReturning("pt1()")
    public void afterReturningPrintLog() {
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
    }

    /**
     * 异常通知
     */
    @AfterThrowing("pt1()")
    public void afterThrowingPrintLog() {
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }

    /**
     * 最终通知
     */
    @After("pt1()")
    public void afterPrintLog() {
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }

}

记录日志的工具类(环绕通知)

@Around

作用：

把当前方法看成是环绕通知。

属性：

value：用于指定切入点表达式，还可以指定切入点表达式的引用。

package com.itheima.utils;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
@Component("logger")
@EnableAspectJAutoProxy
@Aspect //表示当前类是一个切面类
public class Logger {

    @Pointcut("execution(* com.itheima.service.impl.*.*(..))")
    private void pt1() {}

    /**
     * 环绕通知
     */
    @Around("pt1()")
    public Object aroundPrintLog(ProceedingJoinPoint pjp) {
        Object rtValue = null;
        try {
            Object[] args = pjp.getArgs(); //得到方法执行所需的参数
            System.out.println("环绕通知Logger类中的aroundPrintLog方法开始记录日志了。。。前置");
            rtValue = pjp.proceed(args); //明确调用业务层方法（切入点方法）
            System.out.println("环绕通知Logger类中的aroundPrintLog方法开始记录日志了。。。后置");
            return rtValue;
        } catch (Throwable throwable) { //异常必须是Throwable，exception不行
            System.out.println("环绕通知Logger类中的aroundPrintLog方法开始记录日志了。。。异常");
            throw new RuntimeException(throwable);
        } finally {
            System.out.println("环绕通知Logger类中的aroundPrintLog方法开始记录日志了。。。最终");
        }
    }
}

切入点表达式注解配置

@Pointcut

作用：

指定切入点表达式

属性：

value：指定表达式的内容

测试AOP的配置(XML)

package com.itheima.test;

import com.itheima.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 测试AOP的配置
 */
public class AOPTest {

    public static void main(String[] args) {
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        //3.执行方法
        as.saveAccount();
    }

}

测试AOP的配置(无XML)

package com.itheima.test;

import com.itheima.service.IAccountService;
import com.itheima.service.configuration.SpringConfiguration;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @ClassName: AOPTestAnno
 * @Description:
 * @Author: keke
 * @Date: 2021/5/31
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class AOPTestAnno {

    @Autowired
    private IAccountService accountService;

    @Test
    public void testLogger(){
        accountService.saveAccount();
    }
}

测试结果(四种通知)

在这里插入图片描述

注意：spring在基于注解的通知配置上，最终通知都会先于后置通知/异常通知，开发时需要注意，环绕通知不会

测试结果(环绕通知)

在这里插入图片描述

练习

可以将之前对账户的增删改查项目的事务管理用spring的AOP进行实现，在这里就不演示了，欢迎评论一起学习！

Query*

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring框架学习总结第三天

Spring框架学习总结第三天AOP的相关概念[理解]AOP概述什么是AOPAOP：全称是 Aspect Oriented Programming 即：面向切面编程。简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。AOP的作用及优势作用：在程序运行期间，不修改源码对已有方法进行增强。优势：减少重复代码提高开发效率维护方便AOP的实现方式使用动态代理技术AOP的具体应用案例中问题这是我们昨天课
复制链接

扫一扫

专栏目录