Spring入门——day4

一 . 代理

　　指为一个目标对象提供一个代理对象，由代理对象控制对目标对象的引用

　　使用代理对象是为了在不修改原有目标对象的基础上，增强目标对象的业务逻辑

二 . 静态代理

　　每一个业务需要增强时，都提供一个代理类，有代理类来创建对象

三 . 动态代理

　　动态代理不存在代理类，代理对象是直接由代理生成工具来动态生成的

InvocationHandler：

　　每一个动态代理类都必须实现 InvocationHander 这个接口，而且每个代理类的实例都关联到一个 handler

　　当通过代理对象调用方式时，都会由 InvocationHandler 这个接口的唯一一个方法 invoke 来进行调用

　　那些增强的操作就是在 invoke方法中去编写实现的

流程：

　　1 . 先执行 invoke方法

　　　　打印身份确认

　　　　然后

四 . AOP （aspect oriented programming：面向切面编程）

　　通过预编译方式和运行期间动态代理的统一维护的一种技术

　　通过以下几个接口来实现不改动原有代码的情况下，增加新的功能

　　1 . 使用 Spring 的API接口实现 AOP （advice）

　　　　导包：　　　

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
</dependency>

　　　　前置增强：

public class Log implements MethodBeforeAdvice {
    //method：执行目标对象的方法
    //object：对应方法所需参数
    //target：目标对象
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName() +"的"+ method.getName()+"被执行了");
    }
}

　　　　后置增强：

public class AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为:"+returnValue);
    }
}

　　　　接口：

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

　　　　接口实现类：

public class UserServiceImpl  implements UserService{

    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }

    @Override
    public void select() {
        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
       https://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="UserService" class="com.ma.service.UserServiceImpl"/>
    <bean id="log" class="com.ma.log.Log"/>
    <bean id="afterLog" class="com.ma.log.AfterLog"/>

    <!--方法一：使用原生的Spring API接口-->
    <!--配置AOP，需要导入AOP的约束-->
    <aop:config>
        <!--切入点：说人话就是 要在哪个地方去执行 增强的代码-->
        <!--expression：表达式，execution：要执行的位置-->
        <!-- 第一个位置的 * 号：返回值类型 ，
            第二个位置：类.方法名
            第三个位置(..)：表示可有任意多个参数
            参数之间用 空格 分隔
        -->
        <aop:pointcut id="pointcut" expression="execution(* com.ma.service.UserServiceImpl.*(..) )"/>

        <!--执行环绕增强：说人话就是 要执行的是什么代码
            advice-ref：引用自哪个类
            pointcut-ref：引用哪个切入点
            这一段的意思就是把 log和afterLog类 切入到 UserServiceImpl接口中所有的方法中
        -->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

　　　　测试类：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = context.getBean("UserService", UserService.class);

        userService.add();
    }
}

　　　　结果：

　　　　方法一总结：用Spring原生API由两个步骤：

　　　　　　　　　　　　1 . 用 aop:pointcut 的 expression 中的 execution 指定要执行增强操作的位置，参数之间用空格分割

　　　　　　　　　　　　2 . 用 aop:advisor 的 advice-ref 指定引用自哪个类，pointcut-ref 指定切入点是哪个

　　2 . 自定义类实现AOP （aspect）：

<!--方法二：自定义类实现 AOP-->
    <bean id="diy" class="com.ma.diy.DiyPointCut"/>
    <aop:config>
        <!--自定义切面，
            ref：要引用的类-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="point" expression="execution(* com.ma.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

　　　　方法二总结：通过自定义类来实现 AOP

　　　　　　　　　　　　1 . 用 aop:aspect ref 指定在bean中注册类的id

　　　　　　　　　　　　2 . 用 aop:pointcut 的 expression 中的 execution 指定要执行增强操作的位置，参数之间用空格分割

　　　　　　　　　　　　3 . 用 aop:before 和 after 的 method 直接指定增强时执行的方法，pointcut-ref 指定增强引用位置的 id　　　　

　　3 . 使用注解实现AOP

//使用注解实现AOP
//用注解把这个类标注为一个切面
@Aspect
public class AnnotationPointCut {

    @Before("execution(* com.ma.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("=====方法执行前=====");
    }

    @After("execution(* com.ma.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("=====方法执行后=====");
    }

    @Around("execution(* com.ma.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("=====环绕前=====");

        //执行方法
        Object proceed = jp.proceed();
        System.out.println("=====环绕后=====");

    }
}

　　　　applicationContext.xml:

 <!--方法三：使用注解实现AOP-->
    <bean id="AannotationPointCut" class="com.ma.diy.AnnotationPointCut"/>
    <!--开启注解支持-->
    <aop:aspectj-autoproxy/>

　　　　总结：注解就是将xml中配置 expression 的部分直接移到注解后的括号中

　　　　　　再将自定义类实现AOP中的 <aop:before/> 和 <aop:after/>直接用 @before/after代替

posted @ 2022-03-19 12:26 TRUENO-86 阅读(19) 评论(0) 收藏举报

刷新页面返回顶部

Spring入门——day4

公告