Spring AOP 学习总结

最新推荐文章于 2023-08-28 15:28:40 发布

张薄薄

最新推荐文章于 2023-08-28 15:28:40 发布

阅读量131

点赞数

1、cglib动态代理

由于静态代理需要实现目标对象的相同接口，那么可能会导致代理类会非常非常多，不好维护，因此出现了动态代理。动态代理也有个约束，目标对象一定是要有接口的，没有接口就不能实现动态代理，因此出现了cglib代理。cglib代理也叫子类代理，从内存中构建出一个子类来扩展目标对象的功能！cglib是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。

2、编写cglib

需要引入cglib–jar文件，但是spring的核心包中已经包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。
引入功能包后，就可以在内存中动态构建子类
代理的类不能为final，否则报错【在内存中构建子类来做扩展，当然不能为final，有final就不能继承了】
目标对象的方法如果为final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法。

//需要实现MethodInterceptor接口
public class ProxyFactory implements MethodInterceptor{
    // 维护目标对象
    private Object target;
    public ProxyFactory(Object target){
        this.target = target;
    }
    // 给目标对象创建代理对象
    public Object getProxyInstance(){
        //1. 工具类
        Enhancer en = new Enhancer();
        //2. 设置父类
        en.setSuperclass(target.getClass());
        //3. 设置回调函数
        en.setCallback(this);
        //4. 创建子类(代理对象)
        return en.create();
    }
    @Override
    public Object intercept(Object obj, Method method, Object[] args,
            MethodProxy proxy) throws Throwable {  
        System.out.println("开始事务.....");        
        // 执行目标对象的方法
        Object returnValue = method.invoke(target, args);        
        System.out.println("提交事务.....");
        return returnValue;
    }
}

//测试
public class App {
    public static void main(String[] args) {
        UserDao userDao = new UserDao();
        UserDao factory = (UserDao) new ProxyFactory(userDao).getProxyInstance();
        factory.save();
    }
}

3、手动实现AOP编程

1、先引入aop相关jar文件：spring-aop-3.2.5.RELEASE.jar、aopalliance.jar、aspectjweaver.jar、aspectjrt.jar
2、bean.xml中引入aop名称空间：
xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

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

3、配置文件中开启AOP注解方式

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

    <context:component-scan base-package="aa"/>
    <!-- 开启aop注解方式 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

4、切面类（动态代理又接口的类）

@Component
@Aspect//指定为切面类
public class AOP {
    //里面的值为切入点表达式
    @Before("execution(* aa.*.*(..))")
    public void begin() {
        System.out.println("开始事务");
    }
    @After("execution(* aa.*.*(..))")
    public void close() {
        System.out.println("关闭事务");
    }
}

//UserDao实现了IUser接口
@Component
public class UserDao implements IUser {
    @Override
    public void save() {
        System.out.println("DB:保存用户");
    }
}

//IUser接口
public interface IUser {
    void save();
}

//测试
public class App {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml");
        //这里得到的是代理对象....
        IUser iUser = (IUser) ac.getBean("userDao");
        System.out.println(iUser.getClass());
        iUser.save();      
    }
}

5、切面类（动态代理无接口）

//OrderDao没有实现接口
@Component
public class OrderDao {
    public void save() {
        System.out.println("我已经进货了！！！");        
    }
}

//测试
public class App {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml");
        OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
        System.out.println(orderDao.getClass());
        orderDao.save();
    }
}

6、优化和AOP注解API

API：

@Aspect 指定一个类为切面类
@Pointcut("execution( cn.itcast.e_aop_anno..*(..))") 指定切入点表达式
@Before("pointCut_()") 前置通知: 目标方法之前执行
@After("pointCut_()") 后置通知：目标方法之后执行（始终执行）
@AfterReturning("pointCut_()") 返回后通知：执行方法结束前执行(异常不执行)
@AfterThrowing("pointCut_()") 异常通知: 出现异常时候执行
@Around("pointCut_()") 环绕通知：环绕目标方法执行

 // 前置通知 : 在执行目标方法之前执行
    @Before("pointCut_()")
    public void begin(){
        System.out.println("开始事务/异常");
    }
    
    // 后置/最终通知：在执行目标方法之后执行  【无论是否出现异常最终都会执行】
    @After("pointCut_()")
    public void after(){
        System.out.println("提交事务/关闭");
    }
    
    // 返回后通知： 在调用目标方法结束后执行 【出现异常不执行】
    @AfterReturning("pointCut_()")
    public void afterReturning() {
        System.out.println("afterReturning()");
    }
    
    // 异常通知： 当目标方法执行异常时候执行此关注点代码
    @AfterThrowing("pointCut_()")
    public void afterThrowing(){
        System.out.println("afterThrowing()");
    }
    
    // 环绕通知：环绕目标方式执行
    @Around("pointCut_()")
    public void around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("环绕前....");
        pjp.proceed();  // 执行目标方法
        System.out.println("环绕后....");
    }

7、优化

每次写Before、After等，都要重写一次切入点表达式，这样就不优雅了。于是乎，我们要使用@Pointcut这个注解，来指定切入点表达式，在用到的地方中，直接引用就行了！

@Component
@Aspect//指定为切面类
public class AOP {
    // 指定切入点表达式，拦截哪个类的哪些方法
    @Pointcut("execution(* aa.*.*(..))")
    public void pt() {

    }
    @Before("pt()")
    public void begin() {
        System.out.println("开始事务");
    }
    @After("pt()")
    public void close() {
        System.out.println("关闭事务");
    }
}

8、XML实现AOP：把所有注解都注释掉

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

    <!--对象实例-->
    <bean id="userDao" class="aa.UserDao"/>
    <bean id="orderDao" class="aa.OrderDao"/>
    <!--切面类-->
    <bean id="aop" class="aa.AOP"/>
    <!--AOP配置-->
    <aop:config >
        <!--定义切入表达式，拦截哪些方法-->
        <aop:pointcut id="pointCut" expression="execution(* aa.*.*(..))"/>
        <!--指定切面类是哪个-->
        <aop:aspect ref="aop">
            <!--指定来拦截的时候执行切面类的哪些方法-->
            <aop:before method="begin" pointcut-ref="pointCut"/>
            <aop:after method="close" pointcut-ref="pointCut"/>
        </aop:aspect>
    </aop:config>  
</beans>

测试XML注解

public class App {
    @Test
    public  void test1() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml");
        OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
        System.out.println(orderDao.getClass());
        orderDao.save();
    }

    @Test
    public  void test2() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml");
        IUser userDao = (IUser) ac.getBean("userDao");
        System.out.println(userDao.getClass());
        userDao.save();
    }
}

张薄薄

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring AOP 学习总结

1、cglib动态代理由于静态代理需要实现目标对象的相同接口，那么可能会导致代理类会非常非常多，不好维护，因此出现了动态代理。动态代理也有个约束，目标对象一定是要有接口的，没有接口就不能实现动态代理，因此出现了cglib代理。cglib代理也叫子类代理，从内存中构建出一个子类来扩展目标对象的功能！cglib是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它...
复制链接

扫一扫