AOP 与 Spring中AOP使用（下）

最新推荐文章于 2024-01-08 09:45:46 发布
最新推荐文章于 2024-01-08 09:45:46 发布
阅读量63 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/xzh0717/p/10850929.html
版权

AOP通知类型

前置通知

在目标方法执行之前进行操作

UserDao.java

public class UserDao {
    public void add(){
        System.out.println("添加用户");
    }
}

切面类 MyAspect.java

public class MyAspect {
    public void check(){
        System.out.println("权限校验");
    }
}

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

    <bean id="userDao" class="com.xzh.spring.demo4.UserDao"/>
    <bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
    <!--配置AOP-->
    <aop:config>
        <!--切点：给那个方法做增强-->
        <aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
        <!--配置切面：增强的功能是什么-->
        <aop:aspect ref="myAspect">
            <!--前置通知-->
            <aop:before method="check" pointcut-ref="point1"/>
        </aop:aspect>
    </aop:config>
</beans>

AOP测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Resource(name = "userDao")
    private UserDao userDao;
    @Test
    public void test() {
        this.userDao.add();
    }
}

后置通知

在目标方法执行之后 进行操作

UserDao.java

public class UserDao {
    public void add(){
        System.out.println("添加用户");
    }

    public void update(){
        System.out.println("更新用户");
    }
}

切面类 MyAspect.java

public class MyAspect {
    public void check(){
        System.out.println("权限校验");
    }

    public void log(){
        System.out.println("日志记录");
    }
}

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

    <bean id="userDao" class="com.xzh.spring.demo4.UserDao"/>
    <bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
    <!--配置AOP-->
    <aop:config>
        <!--切点：给那个方法做增强-->
        <aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
        <aop:pointcut id="point2" expression="execution(* com.xzh.spring.demo4.UserDao.update(..))"/>
        <!--配置切面：增强的功能是什么-->
        <aop:aspect ref="myAspect">
            <!--前置通知-->
            <aop:before method="check" pointcut-ref="point1"/>
            <!--后置通知-->
            <aop:after-returning method="log" pointcut-ref="point2"/>
        </aop:aspect>
    </aop:config>
</beans>

AOP测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Resource(name = "userDao")
    private UserDao userDao;
    @Test
    public void test() {
        this.userDao.update();
    }
}
后置通知获取切入点的返回值

UserDao.java

public class UserDao {
    public void add(){
        System.out.println("添加用户");
    }

    public String update(){
        System.out.println("更新用户");
        return "更新成功!";
    }
}

切面类 MyAspect.java

public class MyAspect {
    public void check(){
        System.out.println("权限校验");
    }

    public void log(Object res){
        System.out.println("日志记录:" + res);
    }
}

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

    <bean id="userDao" class="com.xzh.spring.demo4.UserDao"/>
    <bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
    <!--配置AOP-->
    <aop:config>
        <!--切点：给那个方法做增强-->
        <aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
        <aop:pointcut id="point2" expression="execution(* com.xzh.spring.demo4.UserDao.update(..))"/>
        <!--配置切面：增强的功能是什么-->
        <aop:aspect ref="myAspect">
            <!--前置通知-->
            <aop:before method="check" pointcut-ref="point1"/>
            <!--后置通知-->
            <aop:after-returning method="log" pointcut-ref="point2" returning="res"/>
        </aop:aspect>
    </aop:config>
</beans>

AOP测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Resource(name = "userDao")
    private UserDao userDao;
    @Test
    public void test() {
        this.userDao.update();
    }
}

环绕通知

在目标方法执行之前 和之后进行操作

UserDao.java

public class UserDao {
    public void add(){
        System.out.println("添加用户");
    }

    public String update(){
        System.out.println("更新用户");
        return "更新成功!";
    }

    public void delete(){
        System.out.println("删除用户");
    }
}

切面类 MyAspect.java

public class MyAspect {
    public void check(){
        System.out.println("权限校验");
    }

    public void log(Object res){
        System.out.println("日志记录:" + res);
    }

    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("开启事务");
        Object proceed = joinPoint.proceed();
        System.out.println("提交事务");
        return proceed;
    }
}

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

    <bean id="userDao" class="com.xzh.spring.demo4.UserDao"/>
    <bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
    <!--配置AOP-->
    <aop:config>
        <!--切点：给那个方法做增强-->
        <aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
        <aop:pointcut id="point2" expression="execution(* com.xzh.spring.demo4.UserDao.update(..))"/>
        <aop:pointcut id="point3" expression="execution(* com.xzh.spring.demo4.UserDao.delete(..))"/>
        <!--配置切面：增强的功能是什么-->
        <aop:aspect ref="myAspect">
            <!--前置通知-->
            <aop:before method="check" pointcut-ref="point1"/>
            <!--后置通知-->
            <aop:after-returning method="log" pointcut-ref="point2" returning="res"/>
            <!--环绕通知-->
            <aop:around method="around" pointcut-ref="point3"/>
        </aop:aspect>
    </aop:config>
</beans>

AOP测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Resource(name = "userDao")
    private UserDao userDao;
    @Test
    public void test() {
        this.userDao.delete();
    }
}

异常抛出通知

在程序出现异常时进行操作

UserDao.java

public class UserDao {
    public void add(){
        System.out.println("添加用户");
    }

    public String update(){
        System.out.println("更新用户");
        return "更新成功!";
    }

    public void delete(){
        System.out.println("删除用户");
    }

    public void find(){
        System.out.println("查找用户");
        int i = 1 / 0;
    }
}

切面类 MyAspect.java

public class MyAspect {
    public void check(){
        System.out.println("权限校验");
    }

    public void log(Object res){
        System.out.println("日志记录:" + res);
    }

    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("开启事务");
        Object proceed = joinPoint.proceed();
        System.out.println("提交事务");
        return proceed;
    }

    public void exceptionMethod(){
        System.out.println("有异常");
    }
}

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

    <bean id="userDao" class="com.xzh.spring.demo4.UserDao"/>
    <bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
    <!--配置AOP-->
    <aop:config>
        <!--切点：给那个方法做增强-->
        <aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
        <aop:pointcut id="point2" expression="execution(* com.xzh.spring.demo4.UserDao.update(..))"/>
        <aop:pointcut id="point3" expression="execution(* com.xzh.spring.demo4.UserDao.delete(..))"/>
        <aop:pointcut id="point4" expression="execution(* com.xzh.spring.demo4.UserDao.find(..))"/>
        <!--配置切面：增强的功能是什么-->
        <aop:aspect ref="myAspect">
            <!--前置通知-->
            <aop:before method="check" pointcut-ref="point1"/>
            <!--后置通知-->
            <aop:after-returning method="log" pointcut-ref="point2" returning="res"/>
            <!--环绕通知-->
            <aop:around method="around" pointcut-ref="point3"/>
            <!--异常抛出通知-->
            <aop:after-throwing method="exceptionMethod" pointcut-ref="point4"/>
        </aop:aspect>
    </aop:config>
</beans>

AOP测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Resource(name = "userDao")
    private UserDao userDao;
    @Test
    public void test() {
        this.userDao.find();
    }
}
异常抛出通知获取异常信息

UserDao.java

public class UserDao {
    public void add(){
        System.out.println("添加用户");
    }

    public String update(){
        System.out.println("更新用户");
        return "更新成功!";
    }

    public void delete(){
        System.out.println("删除用户");
    }

    public void find(){
        System.out.println("查找用户");
        int i = 1 / 0;
    }
}

切面类 MyAspect.java

public class MyAspect {
    public void check(){
        System.out.println("权限校验");
    }

    public void log(Object res){
        System.out.println("日志记录:" + res);
    }

    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("开启事务");
        Object proceed = joinPoint.proceed();
        System.out.println("提交事务");
        return proceed;
    }

    public void exceptionMethod(Throwable ex){
        System.out.println("有异常:" + ex.getMessage());
    }
}

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

    <bean id="userDao" class="com.xzh.spring.demo4.UserDao"/>
    <bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
    <!--配置AOP-->
    <aop:config>
        <!--切点：给那个方法做增强-->
        <aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
        <aop:pointcut id="point2" expression="execution(* com.xzh.spring.demo4.UserDao.update(..))"/>
        <aop:pointcut id="point3" expression="execution(* com.xzh.spring.demo4.UserDao.delete(..))"/>
        <aop:pointcut id="point4" expression="execution(* com.xzh.spring.demo4.UserDao.find(..))"/>
        <!--配置切面：增强的功能是什么-->
        <aop:aspect ref="myAspect">
            <!--前置通知-->
            <aop:before method="check" pointcut-ref="point1"/>
            <!--后置通知-->
            <aop:after-returning method="log" pointcut-ref="point2" returning="res"/>
            <!--环绕通知-->
            <aop:around method="around" pointcut-ref="point3"/>
            <!--异常抛出通知-->
            <aop:after-throwing method="exceptionMethod" pointcut-ref="point4" throwing="ex"/>
        </aop:aspect>
    </aop:config>
</beans>

AOP测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Resource(name = "userDao")
    private UserDao userDao;
    @Test
    public void test() {
        this.userDao.find();
    }
}

最终通知

无论代码是否有异常，都会执行

UserDao.java

public class UserDao {
    public void add(){
        System.out.println("添加用户");
    }

    public String update(){
        System.out.println("更新用户");
        return "更新成功!";
    }

    public void delete(){
        System.out.println("删除用户");
    }

    public void find(){
        System.out.println("查找用户");
        int i = 1 / 0;
    }
}

切面类 MyAspect.java

public class MyAspect {
    public void check(){
        System.out.println("权限校验");
    }

    public void log(Object res){
        System.out.println("日志记录:" + res);
    }

    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("开启事务");
        Object proceed = joinPoint.proceed();
        System.out.println("提交事务");
        return proceed;
    }

    public void exceptionMethod(Throwable ex){
        System.out.println("有异常:" + ex.getMessage());
    }

    public void after(){
        System.out.println("最终通知");
    }
}

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

    <bean id="userDao" class="com.xzh.spring.demo4.UserDao"/>
    <bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
    <!--配置AOP-->
    <aop:config>
        <!--切点：给那个方法做增强-->
        <aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
        <aop:pointcut id="point2" expression="execution(* com.xzh.spring.demo4.UserDao.update(..))"/>
        <aop:pointcut id="point3" expression="execution(* com.xzh.spring.demo4.UserDao.delete(..))"/>
        <aop:pointcut id="point4" expression="execution(* com.xzh.spring.demo4.UserDao.find(..))"/>
        <!--配置切面：增强的功能是什么-->
        <aop:aspect ref="myAspect">
            <!--前置通知-->
            <aop:before method="check" pointcut-ref="point1"/>
            <!--后置通知-->
            <aop:after-returning method="log" pointcut-ref="point2" returning="res"/>
            <!--环绕通知-->
            <aop:around method="around" pointcut-ref="point3"/>
            <!--异常抛出通知-->
            <aop:after-throwing method="exceptionMethod" pointcut-ref="point4" throwing="ex"/>
            <!--最终通知-->
            <aop:after method="after" pointcut-ref="point4"/>
        </aop:aspect>
    </aop:config>
</beans>

AOP测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Resource(name = "userDao")
    private UserDao userDao;
    @Test
    public void test() {
        this.userDao.find();
    }
}

AOP切入点表达式

  • 基于execution函数完成

execution语法：

【访问修饰符】 方法返回值 包名.类名.方法名（参数）
public com.myxq.demo2.GoodsDaoImpl.save(..)     // 参数为任意参数

* com.myxq.demo2.GoodsDaoImpl.save(..)       // * 为任意类型

* com.myxq.demo2.GoodsDaoImpl+.save(..)      // + 当前类和子类

* com.myxq..*.*(..)                   // com.myxq包以及子包下面所有类的所有方法

AOP注解方式ApsectJ开发

GoodsDao 接口：

public interface GoodsDao {
    public void save();
    public String update();
    public void delete();
    public void find();
}

GoodsDao 实现类 GoodsDaoImpl：

public class GoodsDaoImpl implements GoodsDao {
    @Override
    public void save() {
        System.out.println("保存操作");
    }

    @Override
    public String update() {
        System.out.println("更新操作");
        return "更新完成";
    }

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

    @Override
    public void find() {
        System.out.println("查询操作");
        int i = 1 / 0;
    }
}

1. 引入Jar包

1472533-20190512153230259-549434903.png

2. 引入配置文件

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

</beans>

3. 编写切面类配置

public class GoodsDaoAspect {
    public void log(){
        System.out.println("前置增强");
    }
}

将切面类交给 spring 管理，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: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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="goodsDao" class="com.xzh.spring.demo5.GoodsDaoImpl"/>
    <bean id="goodsAspect" class="com.xzh.spring.demo5.GoodsDaoAspect"/>

</beans>

4. 使用注解的AOP对象目标类进行增强

在配置文件 applicationContext.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: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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--AOP配置开启注解-->
    <aop:aspectj-autoproxy/>

    <bean id="goodsDao" class="com.xzh.spring.demo5.GoodsDaoImpl"/>
    <bean id="goodsAspect" class="com.xzh.spring.demo5.GoodsDaoAspect"/>

</beans>
在切面类上添加注解
@Aspect
public class GoodsDaoAspect {
    @Before(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.save(..))")
    public void before(){
        System.out.println("前置增强");
    }
}
测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class GoodsTest {
    @Resource(name = "goodsDao")
    private GoodsDao goodsDao;
    @Test
    public void test(){
        this.goodsDao.save();
    }
}

5. 注解AOP通知类型

@Before 前置通知

切面类：

@Aspect
public class GoodsDaoAspect {
    @Before(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.save(..))")
    public void before(){
        System.out.println("前置增强");
    }
}
@AfterReturning 后置通知

（1）没有返回值

切面类：

@Aspect
public class GoodsDaoAspect {
    @AfterReturning(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.update(..))")
    public void afterReturning(){
        System.out.println("后置通知");
    }
}

（2）有返回值

切面类：

@Aspect
public class GoodsDaoAspect {
    @AfterReturning(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.update(..))", returning = "res")
    public void afterReturning(Object res){
        System.out.println("后置通知" + res);
    }
}

1472533-20190512153240090-929795259.png

@Around 环绕通知

切面类：

@Aspect
public class GoodsDaoAspect {
    @Around(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.delete(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("开启事务");
        Object proceed = joinPoint.proceed();
        System.out.println("提交事务");
        return proceed;
    }
}
@AfterThrowing 异常抛出通知

（1）没有获取异常信息

切面类：

@Aspect
public class GoodsDaoAspect {
    @AfterThrowing(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.find(..))")
    public void afterThrowing(){
        System.out.println("异常通知");
    }
}

（2）获取异常信息

切面类：

@Aspect
public class GoodsDaoAspect {
    @AfterThrowing(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.find(..))", throwing = "ex")
    public void afterThrowing(Throwable ex){
        System.out.println("异常通知" + ex.getMessage());
    }
}
@After 最终通知

无论代码是否有异常，都会执行

切面类：

@Aspect
public class GoodsDaoAspect {
    @After(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.find(..))")
    public void after(){
        System.out.println("最终通知");
    }
}

6. 定义多个切入点

一个通知同时定义到多个方法当中

@Aspect
public class GoodsDaoAspect {
    @Before(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.save(..)) || execution(* com.xzh.spring.demo5.GoodsDaoImpl.delete(..))")
    public void before (){
        System.out.println("前置通知");
    }
}

7. AOP的注解切入点的配置

可以在切面当中定义好切入点，在通知当中直接使用定义好的切入点表达式

@Aspect
public class GoodsDaoAspect {
    @Before(value = "GoodsDaoAspect.pointSave() || GoodsDaoAspect.pointDelete()")
    public void before (){
        System.out.println("前置通知");
    }

    @Pointcut(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.save(..))")
    private void pointSave(){}  // 写一个空方法，相等于给切点起别名

    @Pointcut(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.delete(..))")
    private void pointDelete(){}
}

8. 当使用接口时与不使用接口内部代理区别

（1）使用接口 JDK动态代理

1472533-20190512155826782-396600856.png

（2）不使用接口 CGLIB代理

1472533-20190512155830614-1409246284.png

转载于:https://www.cnblogs.com/xzh0717/p/10850929.html

weixin_33675507
关注
Spring中AOP的使用
Harrison
12-28 125
AOP是面向切面编程。是指通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。简单来讲就是不改变原来业务代码的情况下给程序动态的添加功能的一种技术。例如通过AOP进行 日志记录、异常处理、事务处理等。 引入依赖包：spring-aspects <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId>
Spring AOP中使用args表达式的方法示例
08-25
Spring AOP中使用args表达式的方法示例 Spring AOP（Aspect-Oriented Programming）是一种面向切面编程的技术， args表达式是AOP中的一种表达式，它可以用来指定目标方法的参数类型和数量。下面我们将详细介绍...
Spring AOP的使用
daijianzhou的专栏
04-19 645
Spring AOP的使用 AOP框架是Spring的关键组件之一，可以通过AOP对项目的权限和日志等进行管理 AOP的相关概念 Aspect：切面，一般以类的形式展示，通过@Aspect实现。 Pointcut：切点，连接点的集合。 Join point：连接点，代表的是一个方法。 Advice：通知，织入到连接点的一段代码。通知包括“环绕”通知、“前置”通知和“后置”通知等。 Target object：目标对象，需要织入的目标。 AOP proxy：AOP 代理，APO代理包括 JDK 动态代理和
spring18--spring中的通知
月落孤城的博客
04-29 382
1、前置通知 org.springframework.aop.MethodBeforeAdvice * 在目标方法执行前实施增强 2、后置通知 org.springframework.aop.AfterReturningAdvice * 在目标方法执行后实施增强 3、环绕通知 org.aopalliance.intercept.MethodInterceptor * 在目标方法执行前后实...
spring 之 AOP基本用法
weixin_40230655的博客
06-09 345
AOP：【动态代理】 指在程序运行期间动态的将某段代码切入到指定方法位置进行运行的编程方式 1、导入aop模块：Spring AOP： (Spring-aspects) 2、创建一个业务逻辑类（MathCalculator）：在业务逻辑运行的时候将日志进行打印（方法运行之前，方法运行之后，异常，返回） 3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到那一步，然后执行； 通知方法： 前置通知(@Begore)：logStart：在目
Spring IOC和Spring AOP_spring aop_springIOC
09-24
面向切面编程（AOP）是Spring框架的另一大特色，它允许程序员将关注点分离，比如日志记录、事务管理、安全检查等，可以编写一次，然后在整个应用中到处使用。AOP通过切面（Aspect）和通知（Advice）来实现。 1. **...
Spring Boot中使用AOP统一处理web层异常的方法
08-27
"Spring Boot中使用AOP统一处理web层异常的方法" 本文主要介绍了在Spring Boot中使用AOP（Aspect-Oriented Programming，面向方面编程）来统一处理web层异常的方法。该方法可以使得系统在出现异常时能够正确地处理...
详解在Spring中如何使用AspectJ来实现AOP
08-27
2. Spring中使用AspectJ：在Spring框架中，可以使用AspectJ来实现AOP，通过引入AspectJ相关类库，使用AspectJ注解来描述切点和增强，并使用Spring的AOP支持来织入增强。 3. 编程方式：使用AspectJ来实现AOP，需要...
Spring AOP教程
12-07
Spring框架的关键组件之一是面向方面编程(AOP)框架。 面向方面的编程需要将程序逻辑分解成不同的部分。 此教程将通过简单实用的方法来学习Spring框架提供的AOP/面向方面编程。
SpringAop使用详解
最新发布
灏的博客
01-08 1523
Spring Aop的简单使用
Spring中使用AOP的几种方式
愤怒的小兵
06-15 886
在Spring中使用AOP进行切面编程主要有以下几种方式： XML配置 XML+注解 纯注解 XML配置 新建实体类XmlAopBean及切片类XmlAopService 实体类XmlAopBean package XmlAopBean; import java.text.MessageFormat; public class XmlAopBean { public void runWithoutArgs() { System.out.println("这是无参方法。");
Spring中的AOP的使用
weixin_40055163的博客
09-10 1101
Spring中的AOP的使用 1.1 什么是AOP AOP：全称是Aspect Oriented Programming即：面向切面编程。 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。 1.2 AOP的作用及优势 作用： 在程序运行期间，不修改源码对已有方法进行增强。 优势： 减少重复代码 提高开发效率 维护方便。 1.3 AOP相关术语 Joinpoint(连接点): 所谓连接点是指那些被拦截到的点。在spring中,这
Spring AOP用法详解
深圳市多克创新科技有限公司
10-23 1089
AOP：Aspect Oriented Programming，中文翻译为”面向切面编程“。面向切面编程是一种编程范式，它作为OOP面向对象编程的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、权限控制、缓存控制、日志打印等等。AOP采取横向抽取机制，取代了传统纵向继承体系的重复性代码
SpringAOP的使用
小菜鸟笔记
01-12 5066
1 什么是AOP AOP(Aspect Orient Programming)，直译过来就是面向切面编程。AOP是一种编程思想，是面向对象（OOP）的一种补充和完善。对于面向对象来说是将程序抽象成各个层次的对象，而面向切面则是将程序抽象成各个切面。通俗一点来讲就是面向切面就是将面向对象的一些通用性的功能或非核心功能单独抽取出来。 2 为什么要使用AOP 在聊这个问题之前，我们先看下假如在项目中有如下需求： 记录每个方法的入参及出参 记录每个方法的耗时 检查某些方法的入参是否合法 真实场景可能远不止这些，
Spring(AOP)的使用方法
m0_74795259的博客
11-24 4946
完成日志记录功能，当用户进行数据库增、删、改的时候记录操作日志。}}
Spring-Aop的使用
软泥人的博客
10-08 1575
Spring-Aop的使用
SpringAOP详细配置与使用
青元子的博客
06-11 5万+
目录 SpringAOP简介 AOP概念 Spring AOP简单流程图 Spring AOP之Annotation 前置通知(Before advice) 返回后通知(After reurning advice) 抛出异常后通知(After throwing advice) 后置通知(After (finally) advice) 环绕通知(Around advice) 引入...
Spring AOP使用示例
热门推荐
最怕一生碌碌无为，还安慰自己平凡可贵
06-13 6万+
AOP:【面向切面编程】 指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式。 1、导入aop模块：Spring AOP：（spring-aspects） 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候讲日志进行打印（方法之前、方法运行结束、方法出现异常等) 3、定义一个日志切面类（LOgAspects）；切面类里面...
Spring AOP 5.2.15中文API文档下载及使用指南
Spring AOP与Spring IoC容器紧密集成，这使得在Spring容器管理的bean中，可以很容易地应用AOP。此外，通过Maven依赖信息文件，开发者可以更简便地将Spring AOP集成到项目中，借助于Maven的强大依赖管理能力，可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值