spring-AOP

目录

AOP

简介：

概念

AOP:Aspect Oriented Programming 面向对象编程，是OOP面向对象的一种补充。
将程序中交叉业务逻辑(事物、日志)代码提取出来，封装成切面，由AOP在合适的位置将它封装的切面动态的织入到具体业务逻辑中。
AOP不是spring特有的

原理;

spring原理就是使用动态代理

  • 对于实现接口的目标类，使用的是jdk动态代理
  • 对于没有实现任何接口的目标列，使用的是cglib动态代理

应用的场合

适用于具有很切逻辑的场合，比如事物管理、日志记录、性能检测、异常通知、访问控制等。

作用：

  • 在不改变原有代码基础上动态添加新功能。
  • 模块化

术语

  • 连接点 JoinPoint
    程序执行的某个特定位置，如方法调用前、方法调用后、方法抛出异常时、方法调用前后等。
  • 切入点 Pointcut
    定位查找到需要连接的点，即切点
  • 增强Advice 也成为通知
    在切点上执行一段代码程序，用来实现某些功能
  • 目标对象 Traget
    将执行增强处理的目标类
  • 织入Weaving
    将增强添加到目标类具体切入点上的过程
  • 代理 Proxy
    一个类被织入增强后，会产生一个代理类
  • 切面 Aspect
    切面和增强的组合
  • 引介 Introduction 也成为引入

实现原理：

代理模式回顾

  • 概念：
    为其他对象提供一种代理，以控制对这个对象的访问，起到中介的作用。通过代理对象访问目标对象，可以增强额外的操作，扩展目标对象的功能。

代理三要素

  • 目标类的接口
  • 目标类的实例
  • 交叉业务逻辑,要执行的操作

代理分类

静态代理

  • 解释：
    代理类是程序员创建或者工具生成。所谓静态代理就是程序运行之前你在代理类的字节码文件
  • 缺点：
    代理对象需要和目标对象实现相同的接口，如果接口增加方法，目标对象和代理对象都要维护。
  • 静态代理实操：

service 接口：


public interface UserService {


    void  login(String username, String password) throws NoSuchMethodException;
    public String logout() throws NoSuchMethodException;
}

service 接口实现类：


public class UserServiceImpl implements UserService {
    @Override
    public void login(String username, String password) {
        
          System.out.println("username:"+username+"password:"+password);
        
    }

    @Override
    public String logout() {
          System.out.println("UserServiceImpl.logout");
        return "bytebyte";
    }
}

代理类：


public class UserServiceProxy implements UserService { //目标类的接口

    private    UserService userService=new UserServiceImpl();  //代理目标实例

    @Override
    public void login(String username, String password) throws NoSuchMethodException {

         /* System.out.println("login start at:["+new Date().getTime()+"]");
           userService.login(username, password);*/
        invoke(userService.getClass().getMethod("login",String.class,String.class),username,password); //具体业务逻辑
        
        


    }

    @Override
    public String logout() throws NoSuchMethodException {

       /* System.out.println("logout start at:["+new Date().getTime()+"]");
         return userService.logout();*/
       return invoke(userService.getClass().getMethod("logout")).toString();
    }
    //封装到公共方法中
    private Object invoke(Method method, Object... args)
    {
        //1.打印日记
          System.out.println(method.getName()+"login start at:["+new Date().getTime()+"]");
        try {
           return method.invoke(userService,args);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return null;
    }
}

main入口

public static void main(String[] args) {

    UserService userservice=new UserServiceProxy();
    try {
        System.out.println(userservice.logout());
        userservice.login("zhangsan","里斯");
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }


}

动态代理

代理类是程序在运行期间由JVM根据反射等机制动态生成的，自动生成代理类和代理对象。所谓动态代理就是程序在运行前不存在代理类的字节码文件。

动态代理的三种技术:

Proxy
特点

JDK自带技术，使用Jdk自带的Proxy必须实现一个或多个接口，如果没有实现任何接口，则无法使用jdk自带的Proxy技术。

用法
  • 语法：

    Proxy.newProxyInstance{
                                  classLoader,//目标类的加载器
                                  interfaces,// 目标累的接口
                                  InvocationHandler 交叉业务逻辑
               }
  • 实现步骤：
  • UserService
public interface UserService {


    void  login(String username, String password) throws NoSuchMethodException;
    public String logout() throws NoSuchMethodException;
}
  • UserServiceImpl
public class UserServiceImpl implements UserService {
    @Override
    public void login(String username, String password) {
        
          System.out.println("username:"+username+"password:"+password);
        
    }

    @Override
    public String logout() {
          System.out.println("UserServiceImpl.logout");
        return "bytebyte";
    }
}
  • main:

public static void main(String[] args) throws NoSuchMethodException {

    UserService userservice = (aop02.service.UserService)Proxy.newProxyInstance(
            UserServiceImpl.class.getClassLoader(),//目标类的加载器
            new Class[]{UserService.class},
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                  System.out.println("方法名:" + method.getName());
                 try{
                     System.out.println("开始事务");
                     Object obj=method.invoke(UserServiceImpl.class, args);
                       System.out.println("提交事务");
                     return obj;
                 }
                 catch (Exception ex)
                 {
                       System.out.println("回滚事务");
                 }
                    return null;
                }

            }


    );
      System.out.println(userservice.logout());
    userservice.login("张三", "123456");

}
cglib
解释

如果没有实现接口，可以使用cglib，它是通过继承来实现。

语法
Enhancer.create(
        Class type,
        Callback callback
)
实现步骤
  • 添加jar包
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.1</version>
</dependency>
  • 使用cglib

HelloWorld helloWorld = (HelloWorld) Enhancer.create(
        HelloWorld.class, //目标类的类型
        new InvocationHandler() { //交叉业务逻辑
            @Override
            public Object invoke(Object o, Method method, Object[] args) throws Throwable {
                System.out.println(method.getName() + " start at:[" + new Date().getTime() + "]");
                return method.invoke(new HelloWorld(), args);
            }
        }
);

helloWorld.sayHello();

Spring AOP配置方式

Spring 增强的类型

通知类型 实现接口 描述
前置通知 MethodBeforeAdvice 在方法执行前添加功能
后置通知 AfterReturnAdvice 在方法执行后添加功能
环绕通知 MethedInterceptor 在方法前后执行
异常通知 ThrowsAdvice 异常通知
引入通知 IntroductionInterceptor 在目标类添加新方法和属性
注：多个通知之间不允许有耦合，即多个Advice之间不允许有业务交叉。像事务处理就必须使用环绕通知

Spring AOP1.x

  • 使用ProxyFactoryBean 手动代理

使用步骤：

  • 添加jar 包
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
</dependency>
  • 定义接口
public interface UserService {

    public void login(String username, String password) throws ClassNotFoundException;

    public String logout();
}
  • 实现接口
public class UserServiceImpl implements UserService {
    @Override
    public void login(String username, String password) {
        
          System.out.println("username:"+username+"password:"+password);
          System.out.println("UserServiceImpl.login");
        
    }

    @Override
    public String logout() {
          System.out.println("UserServiceImpl.logout");
        return "bytebyte";
    }
}
  • 配置Advice 实现相应的接口
public class logAdvice implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(method.getName()+" start at:["+new Date().getTime()+"],args:"+ Arrays.toString(args)+",target:"+target);


    }
}
  • xml文件配置：

<bean class="aop05.service.impl.UserServiceImpl " id="UserServicetarget"/>

<bean class="aop05.Advice.logAdvice " id="logAdvice"/>


<bean class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor" id="logAdvisor">
    <property name="advice" ref="logAdvice"/>
    <property name="mappedNames">
        <list>
            <value>login</value>
            <value>logout</value>
        </list>
    </property>
</bean>

<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="calcService">
    
    <property name="target" ref="UserServicetarget"/>
    <property name="interfaces">
        <list>
            <value>aop05.service.UserService </value>
        </list>
    </property>
    <property name="interceptorNames">
        <list>
            <value>logAdvisor</value>
        </list>
    </property>
    
</bean>
  • 使用
public class test {
      public static void main(String[] args) {

          ApplicationContext ac = new ClassPathXmlApplicationContext("ioc04/spring.xml");
          UserService userService = (UserService) ac.getBean("userService");
          try {
              userService.login("sss", "ffff");
              System.out.println(userService.logout());
              System.out.println(userService.getClass());
          } catch (Exception ex) {
              ex.printStackTrace();

          }
      }
    
}

Spring AOP 2.x 配置

简介

基于命名空间的配置，原来是使用后处理器,更简单

特点:

  • 简化配置
  • 非入侵性:编写通知时不需要实现任何接口
  • 使用AspectJ表达式定义切点
    介绍：
    一种表达式，用来定义切点位置
    两种用法
    • within（包名.类型）匹配类中的所有方法
    • execution(返回值类型 包名.类名.方法名(参数类型)) 可使用通配符*和..
execution(void aop06.service.impl.UserServiceImpl.login(String,String))

四种写法

方法名 说明
public void 方法名(JoinPoint) 一般用于前置通知
public void 方法名(JoinPoint,Object) 有返回值，一般用户后置通知
public void 方法名(JoinPoint,Exception)
异常通知
public void 方法名(ProceedingJoinPoint)
环绕通知

步骤：

  • 定义接口
public interface UserService {


    public void login(String username, String password) throws ClassNotFoundException;

    public String logout();
}
  • 实现接口
public class UserServiceImpl implements UserService {
    @Override
    public void login(String username, String password) {

          System.out.println("username:"+username+"password:"+password);
          System.out.println("UserServiceImpl.login");
        
    }

    @Override
    public String logout() {
          System.out.println("UserServiceImpl.logout");
        return "bytebyte";
    }
}
  • 定义增强类，不需要实现任何接口。
public class logAdvice {

    public  void log(JoinPoint joinPoint)
    {
          System.out.println("joinPoint.getArgs():"+ Arrays.toString(joinPoint.getArgs()));
          System.out.println("joinPoint.getClass():"+joinPoint.getClass());
          System.out.println("joinPoint.getThis():"+joinPoint.getThis());
            System.out.println("joinPoint.getTarget():"+joinPoint.getTarget());
        Signature signature = joinPoint.getSignature();
        MethodSignature signaturemethod=(MethodSignature)signature;
        Method method = signaturemethod.getMethod();
        System.out.println("method.getName():"+method.getName());
    }   
}
  • 配置
    <!---Spring 2.x配置 -->

    <!---配置目標對象 -->
    <bean id="userService" class="aop06.service.impl.UserServiceImpl"/>
    <!---配置增強類 -->

    <bean id="logAdvice" class="aop06.advice.logAdvice"/>

    <!---配置pointCut 并织入 -->
    <aop:config>
        <!---配置pointCut -->
     <!--   <aop:pointcut id="pc" expression="within(aop06.service.impl.UserServiceImpl)"/>-->
     <!--   <aop:pointcut id="pc" expression="within(aop06.service.impl.*ServiceImpl)"/>-->

        <aop:pointcut id="pc" expression="execution(void aop06.service.impl.UserServiceImpl.login(String,String))"/>
        <aop:aspect ref="logAdvice">
            <!---將logAdvice中的log方法以前入通知的方式织入到pc中-->
           <!-- <aop:before method="log"  pointcut-ref="pc"/>-->
           <!-- <aop:after-returning method="log2" pointcut-ref="pc" returning="returnValue"/>-->
            <!--<aop:after-throwing method="log3" pointcut-ref="pc" throwing="ex"/>-->
            <aop:around method="log4" pointcut-ref="pc"/>
        </aop:aspect>
    </aop:config>
</beans>
  • 测试

public static void main(String[] args) {

        ApplicationContext ac=new ClassPathXmlApplicationContext("aop06/spring.xml");
    UserService userServicetarget = (UserService)ac.getBean("userService");
    try {
        userServicetarget.login("zhanghua","lisi");
        userServicetarget.logout();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/lilihai/p/10142086.html