【spring】静态代理与动态代理 | AOP面向切面编程

1.静态代理

1代理模式的核心结构

代理的步骤‘
1接口
2真实角色 （房东的方法只有一个。rent 很纯粹，不用关注一些公共的业务。
3代理角色（公共的业务交给代理。很多其他的乱七八糟的方法可以交给中介 ，实现业务的分工。 而且，这样公共业务发生拓展的时候，方便集中管理。
4客户端访问代理角色

缺点。一个真实的角色就会产生一个代理角色，代码量会翻倍

package demo01;

public class Proxy implements Rent {
    private Host host;  // 持有被代理对象
    
    // 构造函数
    public Proxy(Host host) {
        this.host = host;
    }
    
    // 实现接口方法
    public void rent() {
        host.rent();  // 调用真实对象的方法
    }
}

这段代码展示了代理模式的核心结构：

接口实现：
Proxy 实现了 Rent 接口
这保证了代理类和真实类有相同的方法
组合关系：
private Host host 持有真实房东对象
通过构造函数注入真实对象
方法委托：
rent() 方法内部调用真实对象的 rent() 方法
这是最简单的委托，没有添加额外操作

这种实现的特点是：

代理类和真实类实现相同接口
代理类通过组合方式持有真实对象
代理类可以在调用真实对象方法前后添加自己的处理逻辑

这是一个基础的代理模式实现，你可以根据需求在 rent() 方法中添加更多的处理逻辑，比如权限检查、日志记录等。

2 组合的方式

进一步解释这两行关键代码：

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

这段代码的含义是：

private Host host - 这是一个私有成员变量，类型是 Host 类。这里的 host 对象代表真实房东。
public Proxy(Host host){ this.host=host; } - 这是代理类的构造函数：

接收一个 Host 类型的参数
this.host = host 将传入的 host 对象赋值给代理类的成员变量 host

这是代理模式的典型实现方式，其中：

代理类(Proxy)持有一个被代理对象(Host)的引用
通过构造函数注入被代理对象
这样代理类就可以在需要时调用真实房东(Host)的方法，同时还可以在前后添加自己的处理逻辑

例如，在租房过程中：

带看房（代理类自己的方法）
签合同（可能需要调用房东的方法）
收中介费（代理类自己的方法）
组合的方式
这种设计使得代理类可以在不改变原有房东类的情况下，增加额外的功能。
组合的方式是什么意思Edit组合(Composition)是面向对象编程中一种常用的代码复用方式。让我通过实例来解释：

组合的定义：

// 这就是组合关系 - Proxy类包含了一个Host对象
class Proxy {
    private Host host;  // Proxy"有一个"Host
}

与继承的对比：

    // 继承方式
class Proxy extends Host {  // Proxy"是一个"Host
    // 继承了Host的所有方法和属性
}

组合的核心特点：

"有一个"关系：Proxy类拥有一个Host对象作为它的成员
更灵活：可以动态改变组合的对象
降低耦合：两个类之间的关系不像继承那样紧密

让我用一个生活中的例子来说明：
javaCopy// 汽车和引擎的关系就是组合
class Engine {
public void start() {
System.out.println(“引擎启动”);
}
}

class Car {
private Engine engine; // 组合关系

public Car(Engine engine) {
    this.engine = engine;  // 通过构造函数注入
}

public void drive() {
    engine.start();  // 使用引擎的功能
    System.out.println("汽车行驶");
}

}
在这个例子中：

汽车不是引擎的一种（不适合用继承）
汽车包含引擎（组合更合适）
可以更换不同的引擎（更灵活）

组合的优势：

更好的封装性
更强的灵活性
更低的耦合度
符合"组合优于继承"的设计原则

3.整个代理的实现代码

package demo01;

public interface Rent {
    public  void  rent();
}

package demo01;

import java.io.PipedOutputStream;

public class Host implements  Rent{
    public void rent() {
        System.out.println("房东要租房");
    }
}

package demo01;

public class Proxy implements Rent {
    private Host host;

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

    public void rent() {
        host.rent();
    }

    public  void  seeHouse(){
        System.out.println("中介带着看房子");
    }
    public  void  heTong(){
        System.out.println("中介带着签租房合同");
    }


}

package demo01;

import com.sun.org.apache.bcel.internal.generic.NEW;

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
//     host.rent();之前找房东租房子 后面找代理租房子
        Proxy proxy = new Proxy(host);//把房东的决策，给了代理

//      代理来租房子
        proxy.rent();
        proxy.seeHouse();
        proxy.heTong();

    }
}

执行结果

房东要租房
中介带着看房子
中介带着签租房合同

Process finished with exit code 0

4. 通过代理模式写一个log功能

代理的步骤‘
1接口
2真实角色 （房东的方法只有一个。rent 很纯粹，不用关注一些公共的业务。
3代理角色（公共的业务交给代理。很多其他的乱七八糟的方法可以交给中介 ，实现业务的分工。 而且，这样公共业务发生拓展的时候，方便集中管理。
4客户端访问代理角色

缺点。一个真实的角色就会产生一个代理角色，代码量会翻倍

1接口

package demo02;

public interface UserService {

        public void aad();
        public void delete();
        public void update();
        public void query();

    

}

2真实角色

package demo02;


public class UserServicecImpl implements  UserService{
    public void aad() {
        System.out.println(" 我是业务层，我增加了一个用户");
    }

    public void delete() {
        System.out.println("我是业务层，删除了一个用户");

    }

    public void update() {
        System.out.println("我是业务层，修改了一个用户");

    }

    public void query() {
        System.out.println("我是业务层，查询了一个用户");

    }
}

3.代理角色

package demo02;

import java.lang.reflect.Method;
//UserServiceProxy - 代理类，也实现了同样的接口，并在这个类中定义了 setUserService 方法
public class UserServiceProxy implements UserService {
    //UserServicecImpl - 实现接口的真实类
    private UserServicecImpl userService;
/*// 1 . 通过setter方法进行依赖注入
    //setUserService 就是定义在代理类（UserServiceProxy）中的一个普通方法，它的作用是让代理类能够持有和控制真实对象。
    public  void setUserService(UserServicecImpl userService) {
        this.userService = userService;
    }
*/

    // 2. 通过构造器方式进行依赖注入
    public UserServiceProxy(UserServicecImpl userService) {
        this.userService = userService;
    }





    public void aad() {
//        System.out.println("log:我是代理层，使用了add（）方法！\n  ");
        log("add");
        userService.aad();
    }

    public void delete() {
//        System.out.println("我是代理层，log:使用了delete（）方法！\n  ");
        log("delete");

        userService.delete();
    }

    public void update() {
//        System.out.println("我是代理层，log:使用了update（）方法！\n  ");
        log("update");

        userService.update();
    }

    public void query() {
//        System.out.println("我是代理层，log:使用了query（）方法！\n  ");
        log("query");

        userService.query();

    }

    //    log方法
    public void log(String methodname) {
        System.out.println("俺是代理层，log:使用了" + methodname + "（）方法！\n  ");

    }
}
/*
*
*
*
* */

4.客户端访问代理角色

	package demo02;

public class Client {
    public static void main(String[] args) {
        UserServicecImpl userService = new UserServicecImpl();
   /*
    1. 使用setter 方法进行依赖注入
        UserServiceProxy userServiceProxy=  new  UserServiceProxy();
        userServiceProxy.setUserService(userService);*/
        UserServiceProxy userServiceProxy = new UserServiceProxy(userService);
//2. 通过构造器方式进行依赖注入
        userServiceProxy.delete();
        userServiceProxy.query();


    }
}

2. 动态代理

前面的log案例，升级成动态代理。
其中 接口 接口的实现类都不变

1. 接口

package nuc.ss.demo04;

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

2，接口的实现 真实对象 业务层面

package nuc.ss.demo04;

//真实对象
public class UserServiceImpl implements UserService {
    public void add() {
        //System.out.println("使用了add方法");
        System.out.println("俺增加了一个用户");
    }

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

    public void update() {
        //System.out.println("使用了update方法");
        System.out.println("俺修改了一个用户");
    }

    public void query() {
        //System.out.println("使用了query方法");
        System.out.println("俺查询了一个用户");
    }

    // 1.改动原有的业务代码，在公司中是大忌！
}

3.开始进行动态代理 代理对象

package nuc.ss.demo04;

import nuc.ss.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);
    }

    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        //动态代理的本质，就是使用反射机制
        return method.invoke(target, args);
    }

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

}

详细注释的版本

package nuc.ss.demo04;

// 导入需要的包
import nuc.ss.demo03.Rent;
import java.lang.reflect.InvocationHandler;  // 处理器接口
import java.lang.reflect.Method;             // 用于方法的反射调用
import java.lang.reflect.Proxy;              // 用于创建代理对象

/**
 * 这个类就像一个中介（代理）公司的业务模板
 * InvocationHandler：就像是一个规范，规定了代理要做的事
 */
public class ProxyInvocationHandler implements InvocationHandler {
    
    /**
     * target就像是要代理的房东
     * 使用Object类型是因为它可以代表任何类型，不管是房东还是其他人
     */
    private Object target;
    
    /**
     * 设置要代理的对象，就像是告诉中介：这是你要代理的房东
     * @param target 要代理的对象（比如房东）
     */
    public void setTarget(Object target) {
        this.target = target;  // 保存房东的信息
    }
    
    /**
     * 获取代理对象，就像是生成一个中介人员
     * 比如：房东委托中介后，中介就可以代表房东做事了
     */
    public Object getProxy() {
        return Proxy.newProxyInstance(
            // 1. 获取当前类的类加载器（就像是找到中介公司的营业执照）
            this.getClass().getClassLoader(),
            // 2. 获取要代理的对象的所有接口（就像是获取房东能做的所有事情的清单）
            target.getClass().getInterfaces(),
            // 3. this表示当前对象，指定代理要做的具体操作（就像是中介的工作手册）
            this
        );
    }
    
    /**
     * 这个方法会在代理对象的每个方法被调用时执行
     * 就像是：每当有人找中介办事时，中介要执行的操作
     * 
     * @param proxy  代理对象自己（就像是中介自己）
     * @param method 被调用的方法（要做的事情，比如看房）
     * @param args   方法的参数（做这件事需要的材料）
     * @return 方法的返回结果
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在调用方法前先记录日志（就像是中介在办事前先记录一下）
        log(method.getName());
        
        // 调用目标对象的方法（让房东完成实际的事情）
        // method.invoke(target, args) 就相当于 房东.看房(参数)
        return method.invoke(target, args);
    }
    
    /**
     * 记录日志的方法
     * 就像是中介的工作记录本，记录做了什么事
     */
    private void log(String msg) {
        System.out.println("使用了" + msg + "方法");
    }
}

4，客户端

package nuc.ss.demo04;


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();
    }
}

执行结果

使用了add方法
俺增加了一个用户

Process finished with exit code 0

3,AOP面向切面

1、AOP

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

.2 Aop在Spring中的作用

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

横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 ….

切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。

通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。

目标（Target）：被通知对象。

代理（Proxy）：向目标对象应用通知之后创建的对象。

切入点（PointCut）：切面通知 执行的 “地点”的定义。

连接点（JointPoint）：与切入点匹配的执行点。

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

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

10.3 使用Spring实现Aop
【重点】使用AOP织入，需要导入一个依赖包！

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

1 第一种方式 通过 Spring API 实现

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

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

UserServiceImpl

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 search() {
        System.out.println("查询用户");
    }
}

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

public class Log implements MethodBeforeAdvice {
    //method : 要执行的目标对象的方法
    //objects : 被调用的方法的参数
    //Object : 目标对象
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了");
    }
}

AfterLog

public class AfterLog implements AfterReturningAdvice {
    //returnValue 返回值
    //method被调用的方法
    //args 被调用的方法的对象的参数
    //target 被调用的目标对象
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了" + target.getClass().getName()
        +"的"+method.getName()+"方法,"
        +"返回值："+returnValue);
    }
}

最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束 .

<?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-->

    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="log" class="com.kuang.log.Log"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
    <!--aop的配置-->
    <aop:config>
        <!--切入点  expression:表达式匹配要执行的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.search();
    }
}

Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解这一块 .

Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理 .

2 第二种方式 自定义类来实现Aop

目标业务类不变依旧是userServiceImpl

第一步 : 写我们自己的一个切入类
DiyPointcut

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

去spring中配置
方式二 自定义类

<!--  定义一个切面/一把刀，然后切那些切入点，怎么切，前面怎么切，后面怎么切。-->
<bean id="diy" class="nuc.ss.diy.DiyPointCut"/>
    <aop:config>
        <!--        自定义切面，ref要引用的类 -->

        <aop:aspect ref="diy">
            <!--        切入点-->

            <aop:pointcut id="point" expression="execution(* nuc.ss.service.UserServiceImpl.*(..))"/>
            <!--        通知-->

            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

测试：

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

3 第三种方式 使用注解实现

第一步：编写一个注解实现的增强类
AnnotationPointcut

package com.kuang.config;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class AnnotationPointcut {
    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("---------方法执行前---------");
    }
    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("---------方法执行后---------");
    }
    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        System.out.println("签名:"+jp.getSignature());
        //执行目标方法proceed
        Object proceed = jp.proceed();
        System.out.println("环绕后");
        System.out.println(proceed);
    }
}

第二步：在Spring配置文件中，注册bean，并增加支持注解的配置

<!--第三种方式:注解实现-->
<bean id="annotationPointcut" class="com.kuang.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

aop:aspectj-autoproxy：说明

通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了
<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为<aop:aspectj-autoproxy poxy-target-class=“true”/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。

执行结果

环绕前
============执行在方法前=============
查找了一个用户
============执行在方法后面=============
环绕后

Process finished with exit code 0