Spring学习三-Spring 的 AOP和基于XML以及注解的 AOP 配置

其他 2020-04-25 10:42:22 阅读次数: 0

Spring学习三-AOP学习

1、实现转账功能，引入事务

1.1、实现转账功能

public void transfer(String sourceName, String targetName, BigDecimal money) {
  User sourceUser = userDao.getUserByName(sourceName);
  User targetUser = userDao.getUserByName(targetName);
  sourceUser.setMoney(sourceUser.getMoney().subtract(money));
  userDao.updateUser(sourceUser);
	
  // 故意使其发生异常
  int a = 1/0;
  targetUser.setMoney(targetUser.getMoney().add(money));
  userDao.updateUser(targetUser);
}

故意使其发生异常，这样导致 userDao.updateUser(sourceUser); 执行完成，userDao.updateUser(targetUser);执行未完成，导致转账过程中出现错误。

1.2、解决转账出现问题

  • 添加事务，事务进行控制
  • 保证当前数据库的操作是同一次连接

1.2.1、ConnectionUtils

public class ConnectionUtils {

    private ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();

    public void setThreadLocal(ThreadLocal<Connection> threadLocal) {
        this.threadLocal = threadLocal;
    }

    private DataSource dataSource;

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

    public Connection getThreadConnection() {
        Connection connection = threadLocal.get();

        if (connection == null) {
            try {
                connection = dataSource.getConnection();
                threadLocal.set(connection);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return connection;
    }

    public void removeConnection(){
        threadLocal.remove();
    }
}

1.2.2、TransationManager

提供和事务相关的工具类，包含了开启事务，提交事务，回滚事务，释放连接

public class TransationManager {

    private ConnectionUtils connectionUtils;

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

    public void beginTransation(){
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void commitTransation(){
        try {
            connectionUtils.getThreadConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void rollbackTransation(){
        try {
            connectionUtils.getThreadConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void releaseTransation(){
        try {
            connectionUtils.getThreadConnection().close();
            connectionUtils.removeConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

1.2.3、UserDao

package com.wmding.spring.dao;

import com.wmding.spring.bean.User;
import com.wmding.spring.utils.ConnectionUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.sql.SQLException;
import java.util.List;

public class UserDao {

    private QueryRunner runner;

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

    private ConnectionUtils connectionUtils;

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

    public int saveUser(User user) {
        try {
            return runner.update(connectionUtils.getThreadConnection(),"insert into user(name,age,money) values(?,?,?)", user.getName(), user.getAge(), user.getMoney());
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return -1;
    }

    public List<User> list() {
        try {
            return runner.query(connectionUtils.getThreadConnection(),"select * from user", new BeanListHandler<User>(User.class));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    public int deleteUser(Integer userId) {
        try {
            return runner.update(connectionUtils.getThreadConnection(),"delete from user where id=?", userId);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return -1;
    }

    public User getUserById(Integer id) {
        try {
            return runner.query(connectionUtils.getThreadConnection(),"select * from user where id = ?", new BeanHandler<User>(User.class), id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    public void updateUser(User user) {
        try {
            runner.update(connectionUtils.getThreadConnection(),"update user set name = ?,age = ?,money = ? where id = ?", user.getName(), user.getAge(), user.getMoney(), user.getId());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


    public User getUserByName(String name) {
        try {
            List<User> query = runner.query(connectionUtils.getThreadConnection(),"select * from user where name = ?", new BeanListHandler<User>(User.class), name);
            if (query == null || query.size() == 0) {
                return null;
            } else if (query.size() > 1) {
                throw new RuntimeException("数据出错了");
            } else {
                return query.get(0);
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }

        return null;
    }
}

1.2.4、UserServiceImpl

业务实现中增加事务控制

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    private TransationManager transationManager;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void setTransationManager(TransationManager transationManager) {
        this.transationManager = transationManager;
    }

    public void transfer(String sourceName, String targetName, BigDecimal money) {
        try {
          	// 开启事务
            transationManager.beginTransation();
            User sourceUser = userDao.getUserByName(sourceName);
            User targetUser = userDao.getUserByName(targetName);

            sourceUser.setMoney(sourceUser.getMoney().subtract(money));
            userDao.updateUser(sourceUser);

            int a = 1/0;
            targetUser.setMoney(targetUser.getMoney().add(money));
            userDao.updateUser(targetUser);
          	// 提交事务（业务完成）
            transationManager.commitTransation();
        }catch (Exception e){
          	// 回滚事务
            transationManager.rollbackTransation();
            throw new RuntimeException(e);
        }finally {
          	// 释放连接
            transationManager.releaseTransation();
        }

    }
}

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:p="http://www.springframework.org/schema/p" 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/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="connectionUtils" class="com.wmding.spring.utils.ConnectionUtils">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <bean id="transationManager" class="com.wmding.spring.utils.TransationManager">
        <property name="connectionUtils" ref="connectionUtils"/>
    </bean>

    <bean id="userService" class="com.wmding.spring.serivce.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
        <property name="transationManager" ref="transationManager"></property>
    </bean>

    <bean id="userDao" class="com.wmding.spring.dao.UserDao">
        <property name="runner" ref="runner"/>
        <property name="connectionUtils" ref="connectionUtils"/>
    </bean>

    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
    </bean>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl"
                  value="jdbc:mysql://localhost:3306/spring?useUnicode=true&amp;characterEncoding=utf8&amp;autoReconnect=true&amp;useSSL=false&amp;serverTimezone=UTC"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>

</beans>

问题虽然得到了解决，但是这样导致代码的耦合度比较高：

  • UserServiceImpl 中引入了TransationManager；如果有多个方法时，都需要使用 transationManager.beginTransation(); 的方法进行添加。

1.3、使用动态代理实现业务控制

1.3.1、UserServiceImpl 中不再引入TransationManager来控制事务

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public int saveUser(User user) {
        return userDao.saveUser(user);
    }

    public List<User> list() {
        return userDao.list();
    }

    public int deleteUser(Integer userId) {
        return userDao.deleteUser(userId);
    }

    public User getUserById(Integer id) {
        return userDao.getUserById(id);
    }

    public User getUserByName(String name) {
        return userDao.getUserByName(name);
    }

    public void updateUser(User user) {
        userDao.updateUser(user);
    }

    public void transfer(String sourceName, String targetName, BigDecimal money) {
            User sourceUser = userDao.getUserByName(sourceName);
            User targetUser = userDao.getUserByName(targetName);
            sourceUser.setMoney(sourceUser.getMoney().subtract(money));
            userDao.updateUser(sourceUser);

            int a = 1/0;
            targetUser.setMoney(targetUser.getMoney().add(money));
            userDao.updateUser(targetUser);
    }
}

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

public class BeanFactory {

    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    private TransationManager transationManager;

    public void setTransationManager(TransationManager transationManager) {
        this.transationManager = transationManager;
    }

    /**
     * 获取代理对象
     *
     * @return
     */
    public UserService getUserService() {

        return (UserService) Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader(), UserServiceImpl.class.getInterfaces(),
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) {

                        Object rtValue;
                        try {
                            // 开启事务
                            transationManager.beginTransation();

                            // 执行操作
                            rtValue = method.invoke(userService, args);

                            // 提交事务
                            transationManager.commitTransation();

                            return rtValue;
                        } catch (Exception e) {
                            // 事务回滚
                            transationManager.rollbackTransation();
                            throw new RuntimeException(e);
                        } finally {
                            // 事务关闭，断开连接
                            transationManager.releaseTransation();
                        }

                    }
                });
    }
}

在该类中，使用动态代理来添加事务控制。省去之前在 UserServiceImpl 的每个方法中进行事务控制。

1.3.3、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:p="http://www.springframework.org/schema/p" 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/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="connectionUtils" class="com.wmding.spring.utils.ConnectionUtils">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <bean id="transationManager" class="com.wmding.spring.utils.TransationManager">
        <property name="connectionUtils" ref="connectionUtils"/>
    </bean>

    <bean id="userService" class="com.wmding.spring.serivce.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

    <bean id="userDao" class="com.wmding.spring.dao.UserDao">
        <property name="runner" ref="runner"/>
        <property name="connectionUtils" ref="connectionUtils"/>
    </bean>

    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
    </bean>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl"
                  value="jdbc:mysql://localhost:3306/spring?useUnicode=true&amp;characterEncoding=utf8&amp;autoReconnect=true&amp;useSSL=false&amp;serverTimezone=UTC"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <bean id="beanFactory" class="com.wmding.spring.BeanFactory">
        <property name="transationManager" ref="transationManager"/>
        <property name="userService" ref="userService"/>
    </bean>

    <bean id="userServiceProxy" factory-bean="beanFactory" factory-method="getUserService"/>

</beans>

1.3.4、测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class UserTest {
    /**
     * 使用userService的代理
     */
    @Autowired
    @Qualifier("userServiceProxy")
    private UserService userService;

    @Test
    public void transfer() {
        userService.transfer("aaa", "bbb", new BigDecimal(100));
    }
}

2、AOP

2.1、AOP的基本概念

AOP ：Aspect oriented Programming（面向切面编程）

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

优势：减少重复代码、提供开发效率、方便维护

实现原理：动态代理

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

  • 基于接口的
    • 提供者：JDK 提供的 Proxy 类
    • 要求：被代理类最少实现一个接口
  • 基于子类的动态代理
    • 提供者：第三方jar。CGLib
    • 要求：被代理类不能用 final 修饰的类（即不能是最终类）

3、Spring 中的 AOP

3.1、Spring中配置 AOP

3.1.1、pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wmding.spring</groupId>
    <artifactId>spring-demo-aop01</artifactId>
    <version>1.0-SNAPSHOT</version>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>RELEASE</version>
        </dependency>

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

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

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
    </dependencies>

</project>

3.1.2、Logger

public class Logger {

    public void beforePrintLog(){
        System.out.println("前置通知打印日志");
    }

    public void afterRunningPrintLog(){
        System.out.println("后置通知打印日志");
    }

    public void afterThrowingPrintLog(){
        System.out.println("异常通知打印日志");
    }

    public void afterPrintLog(){
        System.out.println("最终通知打印日志");
    }

}

3.1.3、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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       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/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="logger" class="com.wmding.spring.log.Logger"/>
    <bean id="userService" class="com.wmding.spring.serivce.impl.UserServiceImpl"/>


    <!-- 配置切面 -->
    <aop:config>
        <aop:pointcut id="pt1" expression="execution(* com.wmding.spring.serivce.impl.*.*(..))"/>
        <aop:aspect id="logAspect" ref="logger">
            <aop:before method="beforePrintLog" pointcut-ref="pt1"/>
            <aop:after-returning method="afterRunningPrintLog" pointcut-ref="pt1"/>
            <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"/>
            <aop:after method="afterPrintLog" pointcut-ref="pt1"/>
        </aop:aspect>
    </aop:config>
</beans>

3.1.4、UserServiceImpl

public class UserServiceImpl implements UserService {

    public void test() {
        System.out.println("UserServiceImpl 中 text 方法被执行了");
    }
}

3.1.5、测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class LoggerTest {
    
    @Autowired
    private UserService userService;

    @Test
    public void saveUser() {
        userService.test();
    }
}

3.2、使用在配置文件中配置环绕通知

<?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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       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/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="logger" class="com.wmding.spring.log.Logger"/>
    <bean id="userService" class="com.wmding.spring.serivce.impl.UserServiceImpl"/>


    <!-- 配置切面 -->
    <aop:config>
        <aop:pointcut id="pt1" expression="execution(* com.wmding.spring.serivce.impl.*.*(..))"/>
        <aop:aspect id="logAspect" ref="logger">
<!--            <aop:before method="beforePrintLog" pointcut-ref="pt1"/>-->
<!--            <aop:after-returning method="afterRunningPrintLog" pointcut-ref="pt1"/>-->
<!--            <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"/>-->
<!--            <aop:after method="afterPrintLog" pointcut-ref="pt1"/>-->
            <aop:around method="aroundPrintLog" pointcut-ref="pt1"/>
        </aop:aspect>
    </aop:config>
</beans>

Spring 提供了一接口 ProceedingJoinPoint，在接口的 proceed() 方法就相当于明确调用切入点方法。

该接口可以作为环绕通知的方法参数，在程序执行时，Spring 会为我们提供该接口的实现类供我们使用。

public class Logger {
    /**
     * 环绕通知
     */
    public Object aroundPrintLog(ProceedingJoinPoint proceedingJoinPoint) {

        Object[] args = proceedingJoinPoint.getArgs();
        Object proceed = null;
        try {
            System.out.println("前置通知打印日志");
            proceed = proceedingJoinPoint.proceed(args);
            System.out.println("后置通知打印日志");
            return proceed;
        } catch (Throwable throwable) {
            System.out.println("异常通知打印日志");
            throw new RuntimeException(throwable);
        }finally {
            System.out.println("最终通知打印日志");
        }
    }
}

3.3 基于注解的AOP

3.3.1、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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       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/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

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

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

3.3.2 使用注解进行配置

@Component("log")
@Aspect
public class Logger {

    @Pointcut("execution(* com.wmding.spring.serivce.impl.*.*(..))")
    public void p1(){}

    @Before("p1()")
    public void beforePrintLog() {
        System.out.println("前置通知打印日志");
    }

    @AfterReturning("p1()")
    public void afterRunningPrintLog() {
        System.out.println("后置通知打印日志");
    }

    @AfterThrowing("p1()")
    public void afterThrowingPrintLog() {
        System.out.println("异常通知打印日志");
    }

    @After("p1()")
    public void afterPrintLog() {
        System.out.println("最终通知打印日志");
    }

    /**
     * 环绕通知
     */
    public Object aroundPrintLog(ProceedingJoinPoint proceedingJoinPoint) {

        Object[] args = proceedingJoinPoint.getArgs();
        Object proceed = null;
        try {
            System.out.println("前置通知打印日志");
            proceed = proceedingJoinPoint.proceed(args);
            System.out.println("后置通知打印日志");
            return proceed;
        } catch (Throwable throwable) {
            System.out.println("异常通知打印日志");
            throw new RuntimeException(throwable);
        }finally {
            System.out.println("最终通知打印日志");
        }
    }
}
wmd看海
发布了57 篇原创文章 · 获赞 3 · 访问量 1万+
私信 关注

猜你喜欢

转载自blog.csdn.net/wmdkanh/article/details/105719065
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
Java基础复习_day13_Collection集合
2018.11.16 c语言学习经验
且看Java内置四大核心函数式接口
小程序云开发中数据库的数据分段和显示图片
python的函数
Web-JS进阶
【干货】C++常用代码积累笔记大全
Spring的ioc操作 与 IOC底层原理
构建之法20191121-11 Scrum立会报告+燃尽图 07
Spring boot之Hello World访问404
每日归档
更多
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022