Spring入门（二）之AOP实现原理

作者: 穿梭在围城 | 来源:发表于2018-12-03 18:01 被阅读0次

Spring入门之AOP实现原理

一、什么是AOP？

Aspect Oriented Programming(AOP)，面向切面编程，是一个比较热门的话题。AOP主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。比如我们最常见的就是日志记录了，举个例子，我们现在提供一个查询学生信息的服务，但是我们希望记录有谁进行了这个查询。如果按照传统的OOP的实现的话，那我们实现了一个查询学生信息的服务接口(StudentInfoService)和其实现
类
（StudentInfoServiceImpl.java），同时为了要进行记录的话，那我们在实现类(StudentInfoServiceImpl.java)中要添加其实现记录的过程。这样的话，假如我们要实现的服务有多个呢？那就要在每个实现的类都添加这些记录过程。这样做的话就会有点繁琐，而且每个实现类都与记录服务日志的行为紧耦合，违反了面向对象的规则。那么怎样才能把记录服务的行为与业务处理过程中分离出来呢？看起来好像就是查询学生的服务自己在进行，但却是背后日志记录对这些行为进行记录，并且查询学生的服务不知道存在这些记录过程，这就是我们要讨论AOP的目的所在。AOP的编程，好像就是把我们在某个方面的功能提出来与一批对象进行隔离，这样与一批对象之间降低了耦合性，可以就某个功能进行编程。

image.png

二、Spring使用的代理技术

动态代理（对可以实现的接口进行代理）
CGLIB代理（对所有可以继承的类进行代理）

什么是代理技术呢？（分为两种静态代理，动态代理）

静态代理

package cn.zw.proxy;
/**
 * 
 * @ClassName:  Dao   
 * @Description:TODO(Dao层的接口定义)   
 * @date:   2018年12月2日 下午8:52:09   
 */
public interface Dao {
    void save();
    void delete();
    void update();
    void select();
}

package cn.zw.proxy;
/**
 * 
 * @ClassName:  DaoImpl   
 * @Description:TODO(Dao的实现类用于CRUD操作)   
 * @date:   2018年12月2日 下午8:54:16   
 */
public class DaoImpl implements Dao {

    @Override
    public void save() {
        System.out.println("新增操作");
    }

    @Override
    public void delete() {
        System.out.println("删除操作");
    }

    @Override
    public void update() {
        System.out.println("修改操作");
    }

    @Override
    public void select() {
        System.out.println("查询操作");
    }

}

package cn.zw.proxy;
/**
 * 
 * @ClassName:  DaoWraper   
 * @Description:TODO(增强DaoImpl类)   
 * @date:   2018年12月2日 下午8:55:46   
 */
public class DaoWraper implements Dao {
    
    private DaoImpl daoImpl = new DaoImpl();
    
    @Override
    public void save() {
        System.out.println("新增操作增强1");
        daoImpl.save();
        System.out.println("新增操作增强2");
    }

    @Override
    public void delete() {
        System.out.println("删除操作增强1");
        daoImpl.delete();
        System.out.println("删除操作增强2");
    }

    @Override
    public void update() {
        System.out.println("修改操作增强1");
        daoImpl.update();
        System.out.println("修改操作增强2");
    }

    @Override
    public void select() {
        System.out.println("查询操作增强1");
        daoImpl.select();
        System.out.println("查询操作增强2s");
    }

}

package cn.zw.proxy;

import org.junit.Test;
/**
*测试类
*/
public class ProxyDemo {
    @Test
    public void fun01(){
        DaoWraper daoWraper = new DaoWraper();
        daoWraper.save();
        daoWraper.update();
        daoWraper.delete();
        daoWraper.select();
    }
}

image.png

动态代理

package cn.zw.proxy;
/**
 * 
 * @ClassName:  Dao   
 * @Description:TODO(Dao层的接口定义)   
 * @date:   2018年12月2日 下午8:52:09   
 */
public interface Dao {
    void save();
    void delete();
    void update();
    void select();
}

package cn.zw.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * 
 * @ClassName:  DaoProxyFactory   
 * @Description:TODO(动态代理的实现)   
 * @date:   2018年12月2日 下午9:21:39   
 */
public class DaoProxyFactory implements InvocationHandler {
    
    private Dao target; //增强目标
    
    
    public DaoProxyFactory(Dao target) {
        super();
        this.target = target;
    }

    public Dao getDaoImpl(){
        return (Dao) Proxy.newProxyInstance(this.getClass().getClassLoader(),new Class[]{Dao.class},this);
    }
    
    //对方法进行增强
    @Override
    public Object invoke(Object proxy, Method method, Object[] arg) throws Throwable {
        System.out.println("操作增强1"); 
        Object invoke = method.invoke(target,arg);
        System.out.println("操作增强2");
        return invoke;  //方法的返回值
    }
}

package cn.zw.proxy;

import org.junit.Test;
/**
 * 
 * @ClassName:  DemoTest   
 * @Description:TODO(动态代理测试)   
 * @date:   2018年12月2日 下午9:23:33   
 */
public class DemoTest {
    
    @Test
    public void fun01(){
        DaoProxyFactory daoProxyFactory = new DaoProxyFactory(new Dao() {
            
            @Override
            public void update() {
                System.out.println("更新");
            }
            
            @Override
            public void select() {
                System.out.println("查询");
            }
            
            @Override
            public void save() {
                System.out.println("新增");
            }
            
            @Override
            public void delete() {
                System.out.println("删除");
            }
        });
        Dao daoImpl = daoProxyFactory.getDaoImpl();
        daoImpl.save();
        daoImpl.delete();
        daoImpl.update();
        daoImpl.select();
    }
}

image.png

CGLIB代理

package cn.zw.cglib;
/**
 * 
 * @ClassName:  Dao   
 * @Description:TODO(Dao层的接口定义)   
 * @date:   2018年12月2日 下午8:52:09   
 */
public interface Dao {
    void save();
    void delete();
    void update();
    void select();
}

package cn.zw.cglib;
/**
 * 
 * @ClassName:  DaoImpl   
 * @Description:TODO(Dao的实现类用于CRUD操作)   
 * @date:   2018年12月2日 下午8:54:16   
 */
public class DaoImpl implements Dao {

    @Override
    public void save() {
        System.out.println("新增操作");
    }

    @Override
    public void delete() {
        System.out.println("删除操作");
    }

    @Override
    public void update() {
        System.out.println("修改操作");
    }

    @Override
    public void select() {
        System.out.println("查询操作");
    }

}

package cn.zw.cglib;


import java.lang.reflect.Method;

import org.aopalliance.intercept.MethodInvocation;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;


/**
 * 
 * @ClassName:  DaoProxyFactory   
 * @Description:TODO(演示cglib代理)   
 * @author: 穿梭在围城
 * @date:   2018年12月2日 下午9:29:22   
 */
public class DaoProxyFactory implements MethodInterceptor {
    
    
    public DaoImpl getDaoProxy(){
        //cglib的入口
        Enhancer enhancer = new Enhancer();
        //设置父类（代理的对象）
        enhancer.setSuperclass(DaoImpl.class);
        //设置回调函数（增强方法）
        enhancer.setCallback(this);
        return (DaoImpl) enhancer.create();
    }

    /**
     * 
     * <p>Title: intercept</p>   
     * <p>Description: </p>   
     * @param paramObject 代理对象
     * @param paraMethod 当前业务方法
     * @param paramArrayOfObject 业务方法参数
     * @param paramMethodProxy 代理方法对象
     * @return
     * @throws Throwable   
     */
    @Override
    public Object intercept(Object paramObject, Method paraMethod, Object[] paramArrayOfObject, MethodProxy paramMethodProxy) throws Throwable {
        System.out.println("业务增强1");
        Object invoke = paramMethodProxy.invokeSuper(paramObject, paramArrayOfObject);
        System.out.println("业务增强2");
        return invoke;
    }
    
}

package cn.zw.cglib;

import org.junit.Test;
/**
 * 
 * @ClassName:  DemoTest   
 * @Description:TODO(动态代理测试)   
 * @date:   2018年12月2日 下午9:23:33   
 */
public class DemoTest {
    
    @Test
    public void fun01(){
        DaoProxyFactory daoProxyFactory = new DaoProxyFactory();
        DaoImpl daoImpl = (DaoImpl) daoProxyFactory.getDaoProxy();
        daoImpl.save();
    }
}

image.png

四、AOP的专业名词

joinpoint：连接点可以被代理的方法

pointcut ：切点已经被或即将被增强的方法

advice ：通知需要为切点增强的功能

aspect ：切面切点+通知

proxy ：代理对象对目标对象医用了通知的对象

target ：目标对象待增强或者切点所在的类

weaver ：织入将通知织入到切点的过程

五、xml的配置AOP

package cn.zw.aop.xml;
/**
 * 
 * @ClassName:  UserDao   
 * @Description:TODO(Dao的接口)   
 * @date:   2018年12月3日 下午3:25:57   
 */
public interface UserDao {
    void save();
    void delete();
    void update();
    void select();
}

package cn.zw.aop.xml;

/**
 * 
 * @ClassName:  UserDaoImpl   
 * @Description:TODO(模拟数据层dao的操作)   
 * @date:   2018年12月3日 下午3:28:28   
 */
public class UserDaoImpl implements UserDao {

    @Override
    public void save() {
        System.out.println("增加");
    }

    @Override
    public void delete() {
        System.out.println("删除");
    }

    @Override
    public void update() {
        System.out.println("更新");
    }

    @Override
    public void select() {
        System.out.println("查询");
    }

}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans"
    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-4.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
    
    <!-- 配置通知对象 -->
    <bean name="myAdvice" class="cn.zw.aop.xml.MyAdvice"></bean>
    
    <!-- 配置目标对象 -->
    <bean name="userDaoImpl" class="cn.zw.aop.xml.UserDaoImpl"></bean>
    
    <!-- 配置切面 -->
    <aop:config>
        <!-- 
        配置切点：
            expression里面的内容是apesctj表达式：execution(表达式)这个是固定格式
                表达式：
                public void cn.zw.aop.xml.UserDaoImpl.save() 对UserDaoImpl内的save()函数进行增强
                void cn.zw.aop.xml.UserDaoImpl.save() public可以省略因为默认就有
                * cn.zw.aop.xml.UserDaoImpl.save() 表示任意返回值
                * cn.zw.aop.xml.*DaoImpl.save() 表示任意以DaoImpl结尾的类中的save方法（这样写的原因是dao层会根据业务拆分多个dao的实现类）
                * cn.zw.aop.xml.*DaoImpl.*() 表示任意以DaoImpl结尾的类中的任意方法（这个类中的所有方法都会被增强）
                * cn.zw.aop.xml.*DaoImpl.*(..) 表示任意的参数列表
                * cn.zw.aop.xml..*DaoImpl.*(..) 表示包括后代包
         -->
        <aop:pointcut id="myPointCut" expression="execution(* cn.zw.aop.xml.UserDaoImpl.save(..))" />
        
        <!-- 织入（切面的配置，将通知织入到切点中）
                ref：表示将myAdcice应用到定义的切点上
         -->
        <aop:aspect ref="myAdvice"> 
          <aop:around method="before" pointcut-ref="myPointCut"/> <!-- 将myadvice中的before方法织入到myPointCut方法中 -->
        </aop:aspect>
    </aop:config>
    
</beans>

package cn.zw.aop.xml;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:application-context5.xml")
public class DemoTest {
    
    @Resource(name="userDaoImpl")
    private UserDao userDao;
    
    @Test
    public void fun01(){
        userDao.save();
    }
    
}

六、注解形式AOP

package cn.zw.aop.annotion;
/**
 * 
 * @ClassName:  UserDao   
 * @Description:TODO(Dao的接口)   
 * @date:   2018年12月3日 下午3:25:57   
 */
public interface UserDao {
    void save();
    void delete();
    void update();
    void select();
}

package cn.zw.aop.annotion;

import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * 
 * @ClassName:  UserDaoImpl   
 * @Description:TODO(模拟数据层dao的操作)   
 * @date:   2018年12月3日 下午3:28:28   
 */
@Component
public class UserDaoImpl implements UserDao {

    @Override
    public void save() {
        System.out.println("增加");
    }

    @Override
    public void delete() {
        System.out.println("删除");
    }

    @Override
    public void update() {
        System.out.println("更新");
    }

    @Override
    public void select() {
        System.out.println("查询");
    }

}

package cn.zw.aop.annotion;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * 
 * @ClassName:  MyAdvice   
 * @Description:TODO(定义一个通知类)   
 * @date:   2018年12月3日 下午3:24:49   
 */
@Component
@Aspect //表示切面
public class MyAdvice {
    
    /**
     * @Title:  MyAdvice   
     * @Description:  通知类类型分为五种：前置通知，环绕通知，后置通知，后置通知（抛异常仍然执行），异常通知
     */
    
    //在切点之前执行
    @Before("execution(* cn.zw.aop.annotion.*DaoImpl.*(..))")
    public void before(){
        System.out.println("前置通知");
    }
    
    //在切点之前和切点之后都执行（事物的开启和提交）
    public void round(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕通知-前半段");
        proceedingJoinPoint.proceed(); //这里是执行切点方法
        System.out.println("环绕通知-后半段");
        
    }
    //在切点之后执行
    public void after(){
        System.out.println("后置通知");
    }
    //在切点出现异常后仍然执行
    public void afterThrows(){
        System.out.println("后置通知（异常）");
    }
    //在切点出现异常时执行
    public void exception(){
        System.out.println("出现了异常");
    }
    
}

package cn.zw.aop.annotion;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:application-context6.xml")
public class DemoTest {
    
    @Resource(name="userDaoImpl")
    private UserDao userDao;
    
    @Test
    public void fun01(){
        userDao.save();
    }
    
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans"
    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-4.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
    <!-- 扫描包 -->
    <context:component-scan base-package="cn.zw.aop.annotion"></context:component-scan>
    <!-- 注解式切面开关 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

Spring入门（二）之AOP实现原理

Spring入门之AOP实现原理

一、什么是AOP？

二、Spring使用的代理技术

什么是代理技术呢？（分为两种静态代理，动态代理）

静态代理

动态代理

CGLIB代理

四、AOP的专业名词

五、xml的配置AOP

六、注解形式AOP

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读