Spring的AOP与动态代理「建议收藏」

Spring的AOP与动态代理「建议收藏」Spring的AOP与动态代理

大家好,又见面了,我是你们的朋友全栈君。

  • AOP
    在这里插入图片描述
    Aspect Oriented Programming(AOP) “面向切面编程”。
    在Spring中提供了面向切面编程的丰富支持,允许通过分离应用的业务逻辑与系统级服务
    (例如审计(auditing)和事务(transaction)管理)进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。
    主要功能
    日志记录,性能统计,安全控制,事务处理,异常处理等等
    通过动态代理,可以在不修改源码的前提下,实现功能的注入

AOP概念和7个专业术语

  • 1.增强(Advice)
        增强就很好理解了,AOP(切面编程)是用来给某一类特殊的连接点,添加一些特殊的功能,那么我们添加的功能也就是增强啦~
        比如:添加日志、管理事务。
        不过增强不仅仅包含需要增加的功能代码而已,它还包含了方位信息。
        那什么是方位信息呢?
        方位信息就是相对于方法的位置信息,如:方法前、方法后、方法环绕
        为什么要方位信息呢?切点不是确定了需要增强的位置了吗?
        切点定位的是“在什么类的什么方法上”,也就是说,切点只是定位到了方法本身(也叫执行点,特殊的连接点),但是我们增强的内容是放在该方法的前面呢、后面呢?还是前后都要呢?这些切点却没有告诉我们,那么我们该如何确定具体位置呢?
        所以,我们才需要用到方位信息,进一步的定位到具体的增强代码放置的位置。
        咦?增强即包含了【功能】又包含了【方位】,那我是不是不用切点就可以匹配哪些方法,并添加功能了呢?
        恩,确实如此,因为通过方位信息,虽然只是简单的描述了【功能】需要放在方法前、后、还是前后都要等信息,但是我们还是可以通过方位定位到位置。只不过,是匹配到所有类的所有方法!因为方位只是说明在方法前还是方法后,并没有要求是哪些类?哪    些方法? — So,我们可以直接使用增强来生成一个切面,而不需要切点,但这并不怎么推荐,因为它是匹配所有方法的。所以,我们才需要用切点来进一步确认位置。
  • 2.切点(Pointcut)
        一个项目中有很多的类,一个类有很多个连接点,当我们需要在某个方法前插入一段增强(advice)代码时,我们就需要使用切点信息来确定,要在哪些连接点上添加增强。
        那么切点是什么?
        如果把连接点当做数据库中的记录,那么切点就是查找该记录的查询条件。
        所以,一般我们要实现一个切点时,那么我们需要判断哪些连接点是符合我们的条件的,如:方法名是否匹配、类是否是某个类、以及子类等。
  • 3.连接点(Joinpoint)
        连接点就是程序执行的某个特定的位置,如:类开始初始化前、类初始化后、类的某个方法调用前、类的某个方法调用后、方法抛出异常后等。Spring 只支持类的方法前、后、抛出异常后的连接点。
  • 4.切面(Aspect)
        切面由切点和增强(或引介)组成,或者只由增强(或引介)实现。
  • 5.目标对象(Target)
        目标对象就是我们需要对它进行增强的业务类~
        如果没有AOP,那么该业务类就得自己实现需要的功能。
  • 6.AOP代理(AOP proxy)
        一个类被AOP织入后生成出了一个结果类,它是融合了原类和增强逻辑的代理类。
  • 7.织入(Weaving)
        织入就是将增强添加到目标类具体连接点上的过程。
         编译期织入,这要求使用特殊java编译器
        类装载期织入,这要求使用特殊的类装载器
        动态代理织入,在运行期为目标类添加增强生成子类的方式
        Spring采用的是动态代理织入,而AspectJ采用编译期织入和类装载期织入。
    在这里插入图片描述

原生的动态代理

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>groupId</groupId>
    <artifactId>dome03</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</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.1.5.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/cglib/cglib -->
        <!--基于子类的动态代理 t2的测试类使用-->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.1</version>
        </dependency>
    </dependencies>
    
</project>

UserDao.java

package com.xbj.dao;

/** * @Author:晓宇码匠 * @Date:2019/6/15 0015 */
 public interface UserDao { 
   
    void addUser();
    void delUser();
}

UserDaoImpl.java

package com.xbj.dao.impl;

import com.xbj.dao.UserDao;

/** * @Author:晓宇码匠 * @Date:2019/6/15 0015 */
public class UserDAOImpl implements UserDao { 
   
    public void addUser() { 
   
        System.out.println("addUser");
    }

    public void delUser() { 
   
        System.out.println("delUser");
    }

    //定义初始化方法
    public void myInit(){ 
   
        System.out.println("init...");

    }
    //定义销毁方法
    public void dest(){ 
   
        System.out.println("dest...");
    }

}

MyAdvice.java

package com.xbj;

/** * @Author:晓宇码匠 * @Date:2019/6/15 0015 */
public class MyAdvice { 
   //通知
        public void before(){ 
   
            System.out.println("开启事务");
        }

        public void after(){ 
   
            System.out.println("关闭事务");
        }

}

test测试类:

import com.xbj.MyAdvice;
import com.xbj.dao.UserDao;
import com.xbj.dao.impl.UserDAOImpl;
import org.junit.Test;

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

/** * @Author:晓宇码匠 * @Date:2019/6/15 0015 */
public class test { 
   
    @Test
    public void  t1(){ 
   
        //目标类
        final UserDAOImpl userDAO = new UserDAOImpl();
        //通知(植入的功能)
        final MyAdvice advice = new MyAdvice();

        InvocationHandler handler = new InvocationHandler() { 
   
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
   
                if (method.equals("delUser")){ 
   
                    advice.before();
                }
                Object object=method.invoke(userDAO,args);

                if (method.getName().equals("addUser")){ 
   
                    advice.after();
                }
                return object;
            }
        };
        //Proxy.newProxyInstance(类加载器, 接口ming.,回调函数;
        UserDao proxyClass = (UserDao) Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), userDAO.getClass().getInterfaces(),handler);
        proxyClass.addUser();
        System.out.println("------------------");
        proxyClass.delUser();

    }
}

控制台输出:

addUser
关闭事务
------------------
delUser

基于子类的动态代理

代码同上
test测试类添加了t2测试方法:

import com.xbj.MyAdvice;
import com.xbj.dao.UserDao;
import com.xbj.dao.impl.UserDAOImpl;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.junit.Test;

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

/** * @Author:晓宇码匠 * @Date:2019/6/15 0015 */
public class test { 
   
    @Test
    public void  t1(){ 
   
        //目标类
        final UserDAOImpl userDAO = new UserDAOImpl();
        //通知(植入的功能)
        final MyAdvice advice = new MyAdvice();

        InvocationHandler handler = new InvocationHandler() { 
   
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
   
                if (method.equals("delUser")){ 
   
                    advice.before();
                }
                Object object=method.invoke(userDAO,args);

                if (method.getName().equals("addUser")){ 
   
                    advice.after();
                }
                return object;
            }
        };
        //Proxy.newProxyInstance(类加载器, 接口ming.,回调函数;
        UserDao proxyClass = (UserDao) Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), userDAO.getClass().getInterfaces(),handler);
        proxyClass.addUser();
        System.out.println("------------------");
        proxyClass.delUser();

    }
    @Test
    public void t2(){ 
   
        //目标类
        final UserDAOImpl userDAOimpl=new UserDAOImpl();
        //通知(植入的功能)
        final MyAdvice advice=new MyAdvice();
        Callback callback=new MethodInterceptor() { 
   
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
   
                advice.before();
                Object obj=method.invoke(userDAOimpl,objects);
                advice.after();
                return obj;
            }
        };
        //superclass callback
        UserDao proxyClass= (UserDao) Enhancer.create(userDAOimpl.getClass(),callback);
        proxyClass.delUser();
    }
}

运行t2测试方法,控制台输出:

开启事务
delUser
关闭事务

Spring 自动代理

@Component @Controller @Repository @Service 都是将bean放入Ioc容器中,只是为了代码的可读性而去区别开
@Autowired 是从Ioc容器拿对象
在这里插入图片描述
流程:

<!--1. 扫描:发现Bean  哪里的Bean你想被我管理-->
    <!--2. 在被扫描的目录去做标注,哪些具体的类要被管理-->
    <!--3.配置AOP 动态代理
     1. 哪里增强(切入点)
     2. 增强什么(advice)-->
    <!-- 4.切入点:方法 void  包.类.方法(args) -->

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

    <context:component-scan base-package="com.xbj"/>
    
    <!--配置 自动代理-->
    <aop:config proxy-target-class="true">
        <!--<aop:pointcut id="myPointcut" expression="execution(* com.xbj.service.impl.*.*(..))" />-->
        <!--<aop:advisor advice-ref="myAspect" pointcut-ref="myPointcut" />-->
        <aop:advisor advice-ref="myAspect" pointcut="execution(* com.xbj.service.impl.*.*(..))" />
    </aop:config>
</beans>

UserController.java

package com.xbj.controller;

import com.xbj.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

/** * @Author:晓宇码匠 * @Date:2019/6/15 0015 */
/* @Controller @Repository @Component @Service 都是将bean放入Ioc容器中,只是为了代码的可读性而去区别开 * @Autowired 是从Ioc容器拿对象 * */
@Controller
public class UserController { 
   

    @Autowired
    private UserService userService;

    public void addUser(){ 
   
        userService.addUser();
    }
}

UserDao.java

package com.xbj.dao;

/** * @Author:晓宇码匠 * @Date:2019/6/15 0015 */
 public interface UserDao { 
   
    void addUser();
    void delUser();
}

UserDaoImpl.java

package com.xbj.dao.impl;

import com.xbj.dao.UserDao;
import org.junit.runner.RunWith;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

/** * @Author:晓宇码匠 * @Date:2019/6/15 0015 */
@Repository
public class UserDaoImpl implements UserDao { 
   
    public void addUser() { 
   
        System.out.println("addUser");
    }

    public void delUser() { 
   
        System.out.println("delUser");
    }

    //定义初始化方法
    public void myInit(){ 
   
        System.out.println("init...");

    }
    //定义销毁方法
    public void dest(){ 
   
        System.out.println("dest...");
    }

}

UserService.java

package com.xbj.service;

/** * @Author:晓宇码匠 * @Date:2019/6/15 0015 */
public interface UserService { 
   
    void addUser();
    void delUser();
}

UserServiceImpl.java

package com.xbj.service.impl;

import com.xbj.dao.UserDao;
import com.xbj.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/** * @Author:晓宇码匠 * @Date:2019/6/15 0015 */
@Service
public class UserServiceImpl implements UserService { 
   
    @Autowired
    private UserDao userDao;
    public void addUser() { 
   
       userDao.addUser();
    }

    public void delUser() { 
   
        userDao.delUser();
    }
}

MyAspect.java

package com.xbj;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;

/** * @Author:晓宇码匠 * @Date:2019/6/15 0015 */
/* * 注意包名:org.aopalliance.intercept.MethodInterceptor;MyAspect * */
//切面
@Component
public class MyAspect implements MethodInterceptor { 
   
    public Object invoke(MethodInvocation invocation) throws Throwable { 
   
        System.out.println("前置增强");
        Object obj=invocation.proceed();   //invocation 调用
        System.out.println("后置增强");
        return obj;
    }

}

test.java


import com.xbj.controller.UserController;
import com.xbj.dao.UserDao;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


/** * @Author:晓宇码匠 * @Date:2019/6/15 0015 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { 
   "classpath:applicationContext.xml"})
public class test { 
   
    @Autowired
    private UserController controller;
    @Test
    public void t1() { 
   
        controller.addUser();
    }


}

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/106639.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • [夜记] — 通州

    [夜记] — 通州

  • Vue(4)Vue指令的学习1

    Vue(4)Vue指令的学习1前言Vue官网一共有提供了14个指令,分别如下v-textv-htmlv-showv-if☆☆☆v-else☆☆☆v-else-if☆☆☆v-for☆☆☆v-on☆☆☆v

  • 线程同步和锁_自旋锁的实现

    线程同步和锁_自旋锁的实现一什么是自旋锁自旋锁(Spinlock)是一种广泛运用的底层同步机制。自旋锁是一个互斥设备,它只有两个值:“锁定”和“解锁”。它通常实现为某个整数值中的某个位。希望获得某个特定锁得代码测试

  • visual C++ 项目和解决方案的区别

    项目:项目是构成某个程序的全部组件的容器,该程序可能是控制台程序、基于窗口的程序或某种别的程序。程序通常由一个或多个包含用户代码的源文件,可能还要加上包含其它辅助数据的文件组成。某个项目的所有文件都

    2021年12月24日
  • 常量指针和指针常量的详解一样吗_指针是常量还是变量

    常量指针和指针常量的详解一样吗_指针是常量还是变量说一下常量指针和指针常量的区别。常量指针  指向常量的指针,也就是说指针指向的对象是常量,指向的常量不能修改。指针不是一个常量,可以把指针指向别一个常量。常量指针是我们最常用的,一般声明形式如下:constint*p;intconst*p;例:inta=1,b=2;constint*p;//或者是intconst*p;p=&…

    2022年10月21日
  • 函数模板参数(函数参数在哪)

    C++模板实参的省略下面列举的几种情况不能省略模板实参:1)从模板函数实参表获得的信息有矛盾之处。template<typenameT>voidfun(Tconst&a,Tconst&b);但是你调用时却是fun(250,250.4);那你就必须写成fun<int>(250,250.4);2)需要获得特定类型的返回值,而不管参数…

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号