Spring代理模式，AOP

Posted 2021-08-15 a碟

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring代理模式，AOP相关的知识，希望对你有一定的参考价值。

1.代理模式

为什么要学习代理模式？因为这就是SpringAOP的底层！【SpringAOP和SpringMVC很重要】

代理模式的分类：

静态代理
动态代理

在这里插入图片描述

1.1.静态代理

角色分析：

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

代码步骤：

接口

package com.adie.pojo.demo01;
//租房
public interface Rent {
    public void rent();
}

真实角色

package com.adie.pojo.demo01;
//房东
public class Host implements Rent{

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

代理角色

package com.adie.pojo.demo01;

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 hetong(){
        System.out.println("签租赁合同");
    }

    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

客户端访问代理角色

package com.adie.pojo.demo01;

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理，中介帮房东租房子，但是代理角色一般会有一些附属操作
        Proxy proxy = new Proxy(host);
        //你不用面对房东，直接找中介租房即可
        proxy.rent();
    }
}

代理模式的好处：

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

缺点：

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

1.2.静态代理加深理解

1.创建一个抽象角色，比如我们平时做的增删改查

package com.adie.pojo.demo02;

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

2.需要一个真实对象来实现这些增删改查操作

package com.adie.pojo.demo02;

//真实对象
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 query() {
        System.out.println("查询了一个用户");
    }
}

3.这时候有一个需求，我们需要增加一个日志功能，如何实现？

方法一：在实现类上增加日志打印功能【如果实现类的方法很多，这样做很麻烦】

方法二：使用代理来做，在不改变原来的业务情况下，实现此功能

4.设置一个代理，来实现日志功能

package com.adie.pojo.demo02;

public class UserServiceProxy implements UserService{
    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    @Override
    public void add() {
        log("add");
        userService.add();
    }

    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }

    @Override
    public void update() {
        log("update");
        userService.update();
    }

    @Override
    public void query() {
        log("query");
        userService.query();
    }

    //日志方法
    public void log(String msg){
        System.out.println("使用了"+msg+"方法");
    }
}

5.客户端来访问代理角色

package com.adie.pojo.demo02;

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();

        UserServiceProxy proxy=new UserServiceProxy();
        proxy.setUserService(userService);

        proxy.add();
    }
}

重要的是我们需要理解代理模式的一个思想

我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想

纵向开发和横向开发

在这里插入图片描述

1.3.动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的！
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口—JDK动态代理【我们在这里使用】
- 基于类：cglib
- java字节码实现：javassist

需要了解两个类：Proxy：代理，InvocationHandler：调用处理程序

【Proxy : 代理】

在这里插入图片描述

//生成代理类
public Object getProxy(){
   return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                                 rent.getClass().getInterfaces(),this);
}

【InvocationHandler：调用处理程序】
在这里插入图片描述

InvocationHandler接口只有一个方法

Object invoke(Object proxy, 方法 method, Object[] args)；
//参数
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。

代码实现

1.Rent 接口，即抽象角色

package com.adie.pojo.demo03;
//租房
public interface Rent {
    public void rent();
}

2.Host 真实角色

package com.adie.pojo.demo01;//房东public class Host implements Rent{    @Override    public void rent() {        System.out.println("房东要出租房子了");    }}

3.ProxyInvocationHandler. java 即代理角色

package com.adie.pojo.demo03;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//我们用这个类，自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成得到代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }

    //处理代理实例，并返回结果。proxy : 代理类 method : 代理类的调用处理程序的方法对象.
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质就是使用反射机制
        seeHouse();
         //核心：本质利用反射实现！
        Object invoke = method.invoke(rent, args);
        fare();
        return invoke;
    }

    public void seeHouse(){
        System.out.println("中介带看房子");
    }

    public void fare(){
        System.out.println("收中介费");
    }
}

4.Client.java

package com.adie.pojo.demo03;

public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host=new Host();

        //代理角色:现在没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象！
        pih.setRent(host);

        Rent proxy = (Rent) pih.getProxy();//这里的proxy就是动态生成的，我们并没有写
        proxy.rent();
    }


}

核心：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！

1.4.动态代理加深理解

我们来使用动态代理实现代理我们后面写的UserService！

我们也可以编写一个通用的动态代理实现的类！所有的代理对象设置为Object即可！

package com.adie.pojo.demo04;

import com.adie.pojo.demo03.Rent;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//我们用这个类，自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口/
    private Object target;

    public void setTarget(Object target) {
        this.target = 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());
        System.out.println(args);
//        这是反射的用法，通过放射调用target的方法，args是参数
        Object invoke = method.invoke(target, args);
        return invoke;
    }

    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}

测试！

package com.adie.pojo.demo04;

import com.adie.pojo.demo02.UserService;
import com.adie.pojo.demo02.UserServiceImpl;

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService=new UserServiceImpl();
        //代理角色，不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService);//设置要代理的对象
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.add();
    }
}

测试，增删改查，查看结果！

动态代理的好处：

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

2.AOP

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

在这里插入图片描述

Aop在Spring中的作用

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

以下名词需要了解下：

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

在这里插入图片描述

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

在这里插入图片描述

即 Aop 在不改变原有代码的情况下 , 去增加新的功能 .

2.1使用Spring实现Aop

【重点】使用AOP织入，需要导入一个依赖包！

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

2.1.1第一种方式

通过 Spring API 实现

首先编写我们的业务接口和实现类

package com.adie.service;

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

package com.adie.service;

public class UserServiceImpl implements UserService{
    public void add() {
        System.out.println("增加了一个用户");
    }

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

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

    public void select() {
        System.out.println("查询了一个用户");
    }
}

然后去写我们的增强类 , 我们编写两个 , 一个前置增强一个后置增强

前置增强

package com.adie.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {

    //method:要执行的目标对象的方法
    //args:参数
    //target:目标对象
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

后置增强

package com.adie.log;

import org.spring以上是关于Spring代理模式，AOP的主要内容，如果未能解决你的问题，请参考以下文章 
 代理模式 - spring aop 抛砖
 代理模式 - spring aop 抛砖
 spring aop中this和target区别
 从代理模式到Spring AOP
 spring5：AOP操作
 Spring之AOP（核心思想：代理模式）

Spring代理模式，AOP

目录

1.代理模式

1.1.静态代理

1.2.静态代理加深理解

1.3.动态代理

1.4.动态代理加深理解

2.AOP

2.1使用Spring实现Aop

2.1.1第一种方式