spring-AOP-xml-实现aop方式快速入门-spring整个juint测试

最新推荐文章于 2024-04-13 04:11:55 发布
最新推荐文章于 2024-04-13 04:11:55 发布
阅读量90 收藏
点赞数
文章标签： spring 5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39696115/article/details/111581750
版权

 

 

 

---动态代理 jdk动态代理

jar文件

<?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">
    <parent>
        <artifactId>Spring</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring03-aop</artifactId>
    <dependencies>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <!--实现aop配置jar包-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>


    </dependencies>


</project>

--创建方法接口com.liuboss.proxy.jdk.TargetInterface

package com.liuboss.proxy.jdk;

public interface TargetInterface {
    public void save();
}

---实现接口方法com.liuboss.proxy.jdk.Target

package com.liuboss.proxy.jdk;

public class Target implements TargetInterface{
    public void save() {
        System.out.println("TargetInterface...save running");
    }
}

com.liuboss.proxy.jdk.Advice 创建前置对象和后置对象方法

package com.liuboss.proxy.jdk;

public class Advice {
    public void before(){
        System.out.println("before---前置增强");
    }
    public void after(){
        System.out.println("after---后置增强");
    }

}

---实现方法com.liuboss.proxy.jdk.ProxyText

package com.liuboss.proxy.jdk;

import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.cglib.proxy.Proxy;

import java.lang.reflect.Method;

public class ProxyText {
    public static void main(String[] args) {
        //创建目标对象
        final Target target = new Target();
        //增强对象
        final Advice advice = new Advice();
        //返回值 就是动态生成的代理对象
        TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    //调用代理对象的任何方法
                    public Object invoke(Object proxy, Method method, Object[] objects) throws Throwable {
                        Object invoke = method.invoke(target, objects);
                        advice.before();
                        advice.after();
                        return invoke;
                    }
                }
        );
        proxy.save();
    }

}

基于cglib 动态代理

--创建方法类com.liuboss.proxy.cglib.Target

package com.liuboss.proxy.cglib;


public class Target  {
    public void save() {
        System.out.println("TargetInterface...save running");
    }
}

--前置对象--后置对象方法

package com.liuboss.proxy.cglib;

public class Advice {
    public void before(){
        System.out.println("before---前置增强");
    }
    public void after(){
        System.out.println("after---后置增强");
    }
}

--测试类实现  动态代理com.liuboss.proxy.cglib.ProxyText

package com.liuboss.proxy.cglib;

import com.liuboss.proxy.jdk.TargetInterface;
import org.springframework.cglib.proxy.*;
import org.springframework.jndi.JndiObjectTargetSource;

import java.lang.reflect.Method;

public class ProxyText {
    public static void main(String[] args) {
        //创建目标对象
        final Target target = new Target();
        //增强对象
        final Advice advice = new Advice();
        //返回值 就是动态生成的代理对象 基于cglib
        //1.创建增强器
        Enhancer enhancer = new Enhancer();
        //2.创建父类（目标）
        enhancer.setSuperclass(Target.class);
        //3.设置回掉
        enhancer.setCallback(new MethodInterceptor() {
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                advice.before();
                advice.after();
                Object invoke = method.invoke(target,objects);
                return invoke;
            }
        });
        //4.创建代理对象
        Target proxy = (Target) enhancer.create();
        proxy.save();

    }

}



---xml实现aop快速入门案例

创建接口com.liuboss.aop.TargetInterface

package com.liuboss.aop;

public interface TargetInterface {
    public void save();
}

---前置后置方法 com.liuboss.aop.MyAspect

package com.liuboss.aop;

public class MyAspect {
    public void before(){
        System.out.println("前值增强");
    }
    public void after(){
        System.out.println("后置增强");
    }

}

--创建接口实现方法com.liuboss.aop.Target

package com.liuboss.aop;

public class Target implements TargetInterface {
    public void save() {
        System.out.println("TargetInterface...save running");
    }
}

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


    <!--配置目标对象-->
    <bean id="target" class="com.liuboss.aop.Target"/>
    <!--切面对象-->
    <bean id="myAspect" class="com.liuboss.aop.MyAspect">
    </bean>
    <!--配置织入，告诉spring哪些方法需要那些增强-->
    <aop:config>
        <!--声明切面-->
        <aop:aspect ref="myAspect">
            <!--切面，切点+通知|-->
            <aop:before method="before" pointcut="execution(public void com.liuboss.aop.Target.save())"/>
        </aop:aspect>
    </aop:config>


</beans>

---测试类中进行测试    测试采用juint方法测试 重点   

package com.liuboss.demo;

import com.liuboss.aop.TargetInterface;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test {
    @Autowired
    private TargetInterface target;

    @org.junit.Test
    public void test1() {
        target.save();
    }


}

---增加后置方法执行配置

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


    <!--配置目标对象-->
    <bean id="target" class="com.liuboss.aop.Target"/>
    <!--切面对象-->
    <bean id="myAspect" class="com.liuboss.aop.MyAspect">
    </bean>
    <!--配置织入，告诉spring哪些方法需要那些增强-->
    <aop:config>
        <!--声明切面-->
        <aop:aspect ref="myAspect">
            <!--切面，切点+通知|-->
            <!--<aop:before method="before" pointcut="execution(public void com.liuboss.aop.Target.save())"/>-->
            <aop:before method="before" pointcut="execution(* com.liuboss.aop.*.*(..))"/>
            <aop:after-returning method="after" pointcut="execution(* com.liuboss.aop.*.*(..))"/>
        </aop:aspect>
    </aop:config>


</beans>

---增加环绕方法进行测试

com.liuboss.aop.MyAspect

package com.liuboss.aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspect {
    public void before(){
        System.out.println("前值增强");
    }
    public void after(){
        System.out.println("后置增强");
    }
    //ProceedingJoinPoint 正在执行的连接点-切点
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前-增强");
        //添加切点方法
        Object proceed = pjp.proceed();
        System.out.println("环绕后-增强");
        return proceed;
    }

}

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


    <!--配置目标对象-->
    <bean id="target" class="com.liuboss.aop.Target"/>
    <!--切面对象-->
    <bean id="myAspect" class="com.liuboss.aop.MyAspect">
    </bean>
    <!--配置织入，告诉spring哪些方法需要那些增强-->
    <aop:config>
        <!--声明切面-->
        <aop:aspect ref="myAspect">
            <!--切面，切点+通知|-->
            <!--<aop:before method="before" pointcut="execution(public void com.liuboss.aop.Target.save())"/>-->
            <!--<aop:before method="before" pointcut="execution(* com.liuboss.aop.*.*(..))"/>
            <aop:after-returning method="after" pointcut="execution(* com.liuboss.aop.*.*(..))"/>-->
            <aop:around method="around" pointcut="execution(* com.liuboss.aop.*.*(..))"/>
        </aop:aspect>
    </aop:config>


</beans>

测试

package com.liuboss.demo;

import com.liuboss.aop.TargetInterface;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test {
    @Autowired
    private TargetInterface target;

    @org.junit.Test
    public void test1() {
        target.save();
    }


}

 

---

抛出异常增强  
package com.liuboss.aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspect {
    public void before(){
        System.out.println("前值增强");
    }
    public void after(){
        System.out.println("后置增强");
    }
    //ProceedingJoinPoint 正在执行的连接点-切点
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前-增强");
        //添加切点方法
        Object proceed = pjp.proceed();
        System.out.println("环绕后-增强");
        return proceed;
    }
    public void agterThrowing(){
        System.out.println("抛出异常增强。。。。。。");
    }

}

进行添加错误

package com.liuboss.aop;

public class Target implements TargetInterface {

    public void save() {
        int i=1/0;
        System.out.println("TargetInterface...save running");
    }
}

配置文件进行配置

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


    <!--配置目标对象-->
    <bean id="target" class="com.liuboss.aop.Target"/>
    <!--切面对象-->
    <bean id="myAspect" class="com.liuboss.aop.MyAspect">
    </bean>
    <!--配置织入，告诉spring哪些方法需要那些增强-->
    <aop:config>
        <!--声明切面-->
        <aop:aspect ref="myAspect">
            <!--切面，切点+通知|-->
            <!--<aop:before method="before" pointcut="execution(public void com.liuboss.aop.Target.save())"/>-->
            <!--<aop:before method="before" pointcut="execution(* com.liuboss.aop.*.*(..))"/>
            <aop:after-returning method="after" pointcut="execution(* com.liuboss.aop.*.*(..))"/>-->
            <aop:around method="around" pointcut="execution(* com.liuboss.aop.*.*(..))"/>
            <aop:after-throwing method="agterThrowing" pointcut="execution(* com.liuboss.aop.*.*(..))"/>
        </aop:aspect>
    </aop:config>


</beans>

测试

 

47p

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

W思聪、
关注
spring-aop demo及junit测试
07-03
本教程将介绍两种常见的Spring AOP配置方法，并通过JUnit进行测试，确保其正确运行。 首先，我们来看看什么是AOP。AOP的核心思想是将关注点分离，即把横切关注点（如日志、事务管理等）从业务逻辑中解耦出来。...
spring-mvc开发所有jar包【4.3.4】
01-08
6. **spring-test-4.3.4.RELEASE.jar**：提供了对Spring应用进行单元测试和集成测试的支持，包括TestContext框架、Mock对象和JUnit集成。 7. **jstl-1.2-sources.jar**：JavaServer Pages Standard Tag Library，是...
17. Spring AOP编程 切点表达式的抽取
Bi-Hu的博客
07-22 124
见文生义，其实就是偷懒。抽取你还不懂吗？ 正文： 当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替 pointcut 属性来引用抽取后的切点表达式。 其实是在配置文件中： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springfram...
xml方式实现aop-切点表达式的抽取
Leon_Jinhai_Sun的博客
09-05 160
当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替 pointcut 属性来引用抽取后的切点表达式。 <aop:config> <!--引用myAspect的Bean为切面对象--> <aop:aspect ref="myAspect"> <aop:pointcut id="myPointcut" expression="execution(* com.leon.aop.*.*
spring aop抽取切点表达式
学亮编程手记
02-16 484
19.Spring AOP 注解通知的类型 以及 切点表达式的抽取
Bi-Hu的博客
07-22 137
通知的配置语法：@通知注解(“切点表达式") 这几个 对应的 注解就是 这几个了啊。 直接在切面中的方法 直接 注解 贼方便啊 ！！ 我们示范一下 环绕 和 最终没其他的自己测试： package com.bihu.anno; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotatio...
22.springAOP切点表达式的抽取以及总结
weixin_45974277的博客
10-22 233
public class Target implements TargetInterface { @Override public void save() { System.out.println("save running..."); throw new ClassCastException(); } public void save2() { System.out.println("save2 run...
spring-netctoss.zip_netctoss_spring-netctoss_达内_达内netctoss_达内spr
09-15
学生可以通过此项目实战练习Spring框架的使用，包括配置、bean管理、AOP的实现、Spring MVC的运用、数据库集成以及RESTful API设计等。 压缩包内的"spring-netctoss"很可能包含了整个项目的所有源代码、配置文件、...
spring-framework-3.0.6.RELEASE.zip
最新发布
04-22
在3.0.6.RELEASE版本中，DI支持XML配置、注解配置以及基于Java的配置方式，使得配置更加灵活。 2. **AOP（Aspect Oriented Programming，面向切面编程）**：Spring的AOP模块允许开发者定义“切面”，这些切面可以...
spring-mvc-test-sample-master.zip_spring mvc_springmvc－test
09-19
9. **AOP（面向切面编程）**：Spring MVC可以与Spring的AOP模块结合，实现如日志记录、事务管理等功能。 10. **Unit Testing and Integration Testing**：在"spring-mvc-test-sample-master"项目中，很可能包含了对...
Spring-aop注解开发（切点表达式的抽取）
Kevinnsm的博客
11-17 431
接上一篇aop注解快速开发 @Component @Aspect //标注当前aspect是切面类 public class MyAspect { @Before("Pointcut()") public void before(){ System.out.println("前置增强..."); } @After("Pointcut()") public void afterReturning(){ System.out.pri
aop:抽取机制
weixin_34239592的博客
11-06 137
2019独角兽企业重金招聘Python工程师标准>>> ...
spring AOP 抽取redis实例
iteye_13271的博客
11-25 166
1. 定义注解 [code="java"] package com.efoxconn.ipebg.common.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; ...
spring aop中使用@Pointcut注解抽取可重用的切入点表达式
Rosen's
03-10 1588
针对同一个切入点，如果有多个通知方法将切入时，通常我们需要标注多个注解，每个注解需要使用切入点表达式，告诉spring，当前通知方法在何时执行。当一个切入点需要更改时，就需要同时更改多个。为了避免这种麻烦，提高切入点表达式的可重用性，以此衍生出的@Pointcut，可以用于标志一个切入点。 示例： 如前文中的切面类StudentServiceLogger ，针对StudentServiceIm...
SpringAOP基于XML、注解快速上手
Logicr的博客
12-13 149
前言 AOP相关概念就不说了，复制粘贴没意思，本文主要是把概念转化为实际应用，让虚无的概念落地。 工程结构 首先，做一个基于Xml的，全程不使用注解(但是注解是真的方便)。 写一个简单的接口，用于后面的AOP进行切片。 接口IworkerAop 打工人接口，专门提供打工方法。 public interface IworkerAop { /** * 打工人要干活儿 */ void work(); void work(String ...args);//用来测试参数
spring-AOP简介和实现方式（包含动态代理）
我不想学习但是必须学习
09-14 244
1.Spring 的 AOP 简介 1.1 什么是 AOP AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP 是 OOP （面向对象程序设计）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 1.2 AOP 的作用
Spring 之AOP AspectJ切入点语法详解（最全面、最详细。）
热门推荐
zhengchao1991的博客
11-29 9万+
6.5 AspectJ切入点语法详解 6.5.1 Spring AOP支持的AspectJ切入点指示符 切入点指示符用来指示切入点表达式目的，，在Spring AOP中目前只有执行方法这一个连接点，Spring AOP支持的AspectJ切入点指示符如下： execution：用于匹配方法执行的连接点； within：用于匹...
Spring三大核心思想之AOP（面向切面编程），大厂面试必备知识点
2401_84104883的博客
04-13 1117
当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替 pointcut 属性来引用抽取后的切点表达式。引用myAspect的Bean为切面对象(…))”/>
面试题8
t15263857960的博客
07-05 546
这份面试题包含了 19 个模块：Java 基础、容器、多线程、反射、对象拷贝、Java Web、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 等。 1、JS中”==”与“===”的区别？（详细链接） ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值