Spring学习（七）代理模式和AOP

最新推荐文章于 2022-10-24 00:05:03 发布

遨游DATA

最新推荐文章于 2022-10-24 00:05:03 发布

阅读量113

点赞数

分类专栏： Spring 后端 Java 文章标签： spring aop

本文链接：https://blog.csdn.net/weixin_43964408/article/details/111478753

版权

Java 同时被 3 个专栏收录

46 篇文章 0 订阅

订阅专栏

后端

30 篇文章 0 订阅

订阅专栏

Spring

9 篇文章 0 订阅

订阅专栏

十、代理模式

代理模式分类

静态代理
动态代理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zmyDk5c0-1608541180941)(image-20201221102254927.png)]

10.1、静态代理

角色分析：

抽象角色：一般会使用接口或者抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后，一般会做一些附属操作
客户：访问代理对象的人

代理步骤：

接口

//租房
public interface Rent {
    public  void rent();
}

真实角色

public class Host  implements Rent{

    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

代理角色

public class Proxy implements Rent{

    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        hetong();
        fare();
    }

    /**
     * 看房
     */
    public void seeHouse() {
        System.out.println("中介带你看房···");
    }
    /**
     * 收中介费
     */
    public void fare() {
        System.out.println("收中介费····");
    }
    /**
     * 签合同
     */
    public void hetong() {
        System.out.println("签合同····");
    }
}

客户端访问代理

public class Client {

    public static void main(String[] args) {
        Host host = new Host();

        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

代理模式好处

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务就交给了代理角色了，实现了业务的分工
公共业务发生扩展的时候，方便集中管理

缺点：

一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低

##10.2、动态代理

动态代理角色和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的
动态代理分类
- 基于接口的动态代理
  - JDK的动态代理
- 基于类的动态代理
  - cglib
- Java字节码实现

需要了解两个类，proxy（代理）和 InvocationHandler（调用处理程序）

InvocationHandler

InvocationHandler是由代理实例的调用处理程序实现的接口
每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。

invoke

Object invoke(Object proxy,
              方法 method,
              Object[] args)
       throws Throwable

处理代理实例上的方法调用并返回结果。当在与之关联的代理实例上调用方法时，将在调用处理程序中调用此方法。

参数

proxy - 调用该方法的代理实例

method -所述方法对应于调用代理实例上的接口方法的实例。 方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。

args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。
结果

从代理实例上的方法调用返回的值。如果接口方法的声明返回类型是原始类型，则此方法返回的值必须是对应的基本包装类的实例; 否则，它必须是可声明返回类型的类型。如果此方法返回的值是null和接口方法的返回类型是基本类型，那么NullPointerException将由代理实例的方法调用抛出。如上所述，如果此方法返回的值，否则不会与接口方法的声明的返回类型兼容，一个ClassCastException将代理实例的方法调用将抛出。
异常

Throwable - 从代理实例上的方法调用抛出的异常。异常类型必须可以分配给接口方法的throws子句中声明的任何异常类型java.lang.RuntimeException检查的异常类型java.lang.RuntimeException或java.lang.Error 。如果检查的异常是由这种方法是不分配给任何的中声明的异常类型throws接口方法的子句，则一个UndeclaredThrowableException包含有由该方法抛出的异常将通过在方法调用抛出代理实例。

Proxy

Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。

动态代理的好处：

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务就交给了代理角色了，实现了业务的分工
公共业务发生扩展的时候，方便集中管理
一个动态代理类代理的是一个接口，一般对应的一类业务
一个动态代理类可以代理多个类，只要是实现的同一个接口

十一、AOP

11.1、什么是AOP

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

11.2、AOP在Spring中的作用

提供声明式事务：允许用户自定义切

横切关注点：跨越应用程序多个模块的方法或功能，即：与我们的业务逻辑无关的，但是我们需要关注的部分，就是横切关注点，如日志、安全、缓存、事务等等
切面（Aspect）：横切关注点被模块化的特殊对象，即，它是一个类
通知（Advice）：切面必须要完成的工作，即，它是类中的一个方法
目标（Target）：被通知的对象
代理（Proxy）：向目标对象应用通知之后创建的对象
切入点（PointCut）：切面通知执行的“地点”的定义
连接点（JoinPoint）：与切入点匹配的执行点

在这里插入图片描述

11.3、使用Spring实现AOP

使用AOP织入需要导入一个依赖

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
    <scope>runtime</scope>
</dependency>

方式一、使用spring的接口

public interface UserService {

    public void addUserService();
    public void delUserService();
    public void updateUserService();
    public void queryUserService();

}

public class UserServiceImpl implements UserService{
    @Override
    public void addUserService() {
        System.out.println("添加");
    }

    @Override
    public void delUserService() {
        System.out.println("删除");

    }

    @Override
    public void updateUserService() {
        System.out.println("修改");

    }

    @Override
    public void queryUserService() {
        System.out.println("查找");

    }
}

public class Log implements MethodBeforeAdvice {

    /**
     *
     * @param method 要执行目标对象的方法
     * @param objects 参数
     * @param o        目标对象
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {

        System.out.println(o.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);

    }
}

<?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="userService" class="com.zhang.service.UserServiceImpl"/>
    <bean id="log" class="com.zhang.log.Log"/>
    <bean id="afterLog" class="com.zhang.log.AfterLog"/>

    <!--配置aop 导入aop的约束-->
    <aop:config>
        <!--切入点：expression：表达式 execution（要执行的位置：修饰词 返回值 包的位置.类名 方法名（参数）-->
        <aop:pointcut id="pointcut" expression="execution(* com.zhang.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增强-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>

    </aop:config>


</beans>

@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("SpringApplicationContext.xml");


    //动态代理代理的为接口  不要写成具体的类
    UserService userService = context.getBean("userService", UserService.class);

    userService.addUserService();

}

方式二：使用自定义类实现AOP

public class DiyPointCut {

    public void before() {
        System.out.println("```````````````方法执行前");
    }
    public void after() {
        System.out.println("------------------方法执行后 ");
    }

}

<bean class="com.zhang.diy.DiyPointCut" id="diyPointCut"/>
<aop:config>
    <!--定义切面-->
    <aop:aspect ref="diyPointCut">
        <!--切入点 -->
        <aop:pointcut id="pointcut" expression="execution(* com.zhang.service.UserServiceImpl.*(..))"/>
    <!--通知-->
        <aop:before method="before" pointcut-ref="pointcut"/>
        <aop:after method="after" pointcut-ref="pointcut"/>
    </aop:aspect>
</aop:config>

方式三：使用注解方式AOP

@Aspect//标注这个类是一个切面
public class AnnoPointCut {

    @Before("execution(* com.zhang.service.UserServiceImpl.*(..))")
    public void before() {
        System.out.println("```````````````方法执行前");
    }
    @After("execution(* com.zhang.service.UserServiceImpl.* (..))")
    public void after() {
        System.out.println("------------------方法执行后 ");
    }

}

<bean class="com.zhang.diy.AnnoPointCut" id="annoPointCut"/>
 <!--开始注解支持-->
<aop:aspectj-autoproxy/>

遨游DATA

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Spring学习（七）代理模式和AOP

十、代理模式代理模式分类静态代理动态代理[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zmyDk5c0-1608541180941)(image-20201221102254927.png)]10.1、静态代理角色分析：抽象角色：一般会使用接口或者抽象类来解决真实角色：被代理的角色代理角色：代理真实角色，代理真实角色后，一般会做一些附属操作客户：访问代理对象的人代理步骤：接口//租房public interface Rent {
复制链接

扫一扫