2021-09-24 Spring回顾第二天之AOP

于 2021-09-24 17:57:19 发布
阅读量71 收藏
点赞数
分类专栏： spring 文章标签： spring java aop 软件框架 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45823022/article/details/120460236
版权

一、代理模式

1. 代理模式简介

客户端不直接调用实际对象，而是通过代理间接调用实际的对象

SpringAOP的底层就是代理模式

代理模式分为静态代理模式和动态代理模式

请添加图片描述

2. 静态代理

2.1 角色

1. 抽象角色：
一般会用接口或抽象类来实现（租房）
2. 真实角色：
被代理的角色（房东）
3. 代理角色：
代理真实角色（中介）
4. 客户：
访问代理对象的人（租客）

2.2. 代码实现

2.2.1 原本
1. 租房接口
//租房接口
public interface Rent
{
    public void rent();
}
2. 房东
//房东
public class Host implements Rent
{
    @Override
    public void rent()
    {
        System.out.println("房东要出租房子了！");
    }
}
3. 客户端
//客户端（租客）
public class Client
{
    public static void main(String[] args) {
        Host host=new Host();
        host.rent();
    }
}
2.2.2 静态代理
1. 代理类
public class MyProxy implements Rent
{
    Host host=new Host();
    @Override
    public void rent() {
        host.rent();
    }
}
2. 客户端

原本调用的是Host的方法，现在是代理类的方法

//客户端（租客）
public class Client
{
    public static void main(String[] args) {
       MyProxy myProxy=new MyProxy();
       myProxy.rent();
    }
}

代理一般会有一些附属操作，如带租客去看房子，签合同，这些是房东不用做的，房东只负责出租房子

因此在中介的rent方法里，可以加入一些附属操作

public class MyProxy implements Rent
{
    Host host=new Host();
    @Override
    public void rent() {
        seeHouse();
        sign();
        host.rent();
    }

    public void seeHouse()
    {
        System.out.println("中介带租客去看房子");
    }
    public void sign()
    {
        System.out.println("中介与租客签合同");
    }
}

这就像我们的业务类
此时若需要在已经写好的业务类里面，添加新的方法
为了不改变原有代码，我们用一个代理类，和业务类实现同样的接口，实现接口的方法
然后在代理类里，编写其他要添加的附属方法即可。

2.3. 优点

  1. 让真实角色更加纯粹，不用去关注一些公共的业务
  2. 公共的方法交给代理角色，实现角色的分工
  3. 公共业务发生扩展时，方便集中管理

2.4. 缺点

一个真实角色产生一个代理角色，代码量翻倍，开发效率低------>动态代理

请添加图片描述

3. 动态代理

3.1 动态代理简介

动态代理的代理类是动态生成的，不是我们直接写好的，也就是我们不需要去写代理类了

3.2 动态代理分类

  1. 基于接口的动态代理（jdk）
  2. 基于类的动态代理（cglib）

3.3 动态代理实现

3.3.1 两个类
1. InvocationHandler
简介：

InvocationHandler是由代理实例的调用处理程序实现的接口。也就是有一个代理实例的调用处理程序的类，实现了该接口，我们需要去写一个代理实例的调用处理程序，去实现该接口。

每个代理实例都有一个关联的调用处理程序

当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法

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

处理代理实例上的方法调用并返回结果

当在与之关联的代理实例上调用方法时，将在调用处理程序中调用该方法

参数：

1. proxy：调用该方法的代理实例

2. method：所述方法对应于调用代理实例上的接口方法的实例（也就是原方法）

           方法对象的声明类将是该方法声明的接口

3. args：包含的方法调用传递代理实例的参数值的对象的阵列
2. Proxy
public class Proxy extends Object implements Serializable

提供了创建动态代理类和实例的静态方法

也就是说可以用该类去调用该类内部的一个方法，来达到创建动态代理类的功能

Proxy本身也是由这些方法创建的所有动态代理类的超类

动态代理类：

是一个实现在类创建时，在运行时指定的接口列表的类

代理接口是由代理类实现的接口

代理实例是代理类的一个实例

每个代理实例都有一个关联的调用处理程序对象，它实现了接口InvocationHandler

通过其代理接口之一的代理实例上的方法调用，将被分派到实例调用处理程序的invoke方法，传递代理实例，方法和参数

调用处理程序适当地处理编码方法调用，并且返回的结果将作为 方法在代理实例上调用的结果 返回
3.3.2 代码实现
调用处理程序处理角色
//等会会用该类来自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler
{
    private Rent rent;
    public void setRent(Rent rent)
    {
        this.rent=rent;
    }
    public Object getProxy()
    {
        //Proxy.newProxyInstance(类加载器,接口,InvocationHandler)创建代理实例
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //反射
        Object invoke = method.invoke(rent, args);
        return invoke;
    }
}
客户端
public class Client
{
    public static void main(String[] args) {
        //真实角色
        Host host=new Host();
        //代理角色，现在没有
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象
        proxyInvocationHandler.setRent(host);
        //获得代理类
        Rent proxy = (Rent) proxyInvocationHandler.getProxy();
        //用代理类去调用方法
        proxy.rent();
    }
}
在调用处理程序的类里面，添加附属方法
//等会会用该类来自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler
{
    private Rent rent;
    public void setRent(Rent rent)
    {
        this.rent=rent;
    }
    public Object getProxy()
    {
        //Proxy.newProxyInstance(类加载器,接口,InvocationHandler)创建代理实例
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        //反射
        Object invoke = method.invoke(rent, args);
        return invoke;
    }

    public void seeHouse()
    {
        System.out.println("中介带租客去看房子啦！");
    }
}

3.4 通用实现

public class ProxyInvocationHandler implements InvocationHandler 
{
    //被代理的接口
    private Object target;

    public Object getTarget() {
        return target;
    }

    public Object getProxy()
    {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object invoke = method.invoke(target, args);
        return invoke;
    }
    
    public void log(String msg)
    {
        System.out.println("执行了"+msg+"方法");
    }
}

public class Client
{
    public static void main(String[] args)
    {
        //真实角色
        Service service = new ServiceImpl();
        //代理角色，不存在
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        //设置要代理的对象
        proxyInvocationHandler.setTarget(service);
        //动态生成代理类
        Service  proxy = (Service) proxyInvocationHandler.getProxy();
        //调用方法
        proxy.add();
        proxy.delete();
        proxy.select();
        proxy.update();
    }
}

在这里插入图片描述

二、AOP

1. AOP简介

1.1 AOP在Spring中的作用
  1. 提供声明式事务
  2. 允许用户自定义切面
1.2 抽象概念
  1. 横切关注点：跨越应用程序多个模块的方法或功能。即与业务逻辑无关的，但需要关注的部分
  2. 切面（aspect）：横切关注点被模块化的特殊对象，即将横切关注点整合成一个类
  3. 通知（advice）：切面必须要完成的工作，即类中的一个方法
  4. 目标（target）：被通知的对象，即被扩展方法的对象
  5. 代理（Proxy）：向目标对象应用通知之后创建的对象
  6. 切入点（pointcut）：切面通知执行的地点，即扩展的方法要在哪里实现
  7. 连接点（joinpoint）：与切入点匹配的执行点
1.3 通知类型
  1. 前置通知
  2. 后置通知
  3. 环绕通知
  4. 异常抛出通知
  5. 引介通知：在类中增加新的方法属性
1.4 总结
即AOP在不改变原有代码的情况下，去增加新的功能

2. AOP实现

要使用AOP织入，首先要导入一个包

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

2.1 SpringAPI接口实现

前置日志
//实现接口
public class BeforeLog implements MethodBeforeAdvice
{
    /**
     *
     * @param method 要执行的目标对象的方法
     * @param args 参数
     * @param target 目标对象
     * @throws Throwable
     */
    @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
{
    /**
     *
     * @param returnValue 返回值
     * @param method
     * @param args
     * @param target
     * @throws Throwable
     */
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"类的"+method.getName()+"方法被执行了,返回结果为："+returnValue);
    }
}
Spring配置
<bean id="userService" class="com.xk.aop1.service.UserServiceImpl"/>
        <bean id="beforelog" class="com.xk.aop1.log.BeforeLog"/>
        <bean id="afterlog" class="com.xk.aop1.log.AfterLog"/>
 
        <!--方式一：使用原生的SpringAPI接口-->
        <aop:config>
                <!--切入点-->
                <aop:pointcut id="pointcut" expression="execution(* com.xk.aop1.service.UserServiceImpl.*(..))"/>

                <!--执行通知-->
                <aop:advisor advice-ref="beforelog" pointcut-ref="pointcut"/>
                <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/>
        </aop:config>
测试
public class Test
{
    public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
      UserService userService = context.getBean("userService",UserService.class);
      userService.add();
      userService.delete();
      userService.select();
      userService.update();
    }
}
结果

在这里插入图片描述

2.2 自定义实现（切面定义）

自定义日志类
public class MyLog
{
    public void before()
    {
        System.out.println("这是前置通知");
    }
    public void after()
    {
        System.out.println("这是后置通知");
    }
}
Spring配置
 <!--方式二：自定义-->
        <bean id="mylog" class="com.xk.aop2.log.MyLog"/>
        <aop:config>
                <!--切面-->
                <aop:aspect ref="mylog">
                        <!--切入点-->
                        <aop:pointcut id="point" expression="execution(* com.xk.aop2.service.UserServiceImpl.*(..))"/>
                        <!--通知-->
                        <aop:before method="before" pointcut-ref="point"></aop:before>
                        <aop:after method="after" pointcut-ref="point"></aop:after>
                </aop:aspect>
        </aop:config>
结果

在这里插入图片描述

2.3 注解实现

日志
@Aspect //标注这是一个切面
public class AnnotationPointCut
{
   @Before("execution(* com.xk.aop3.service.UserServiceImpl.*(..))")
   public void before()
   {
       System.out.println("方法执行前");
   }
}
Spring配置
 <!--方式三：注解-->
        <bean id="annotationPointCut" class="com.xk.aop3.log.AnnotationPointCut"/>
        <!---开启注解支持-->
        <aop:aspectj-autoproxy/>
结果

在这里插入图片描述

小矮人有大力量
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值