JAVA的代理模式 静态代理 jdk动态代理 cgilb动态代理 SpringBoot的切面

最新推荐文章于 2024-06-05 16:47:57 发布
最新推荐文章于 2024-06-05 16:47:57 发布
阅读量310 收藏 3
点赞数 1
分类专栏： java 学习笔记 设计模式 文章标签： 代理模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NiKaBoy/article/details/127466434
版权

1.什么事代理模式

代理模式的主要作用是为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式的思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行通信。

 2.租房为例子，理解带代理模式

来到新的城市我们想租房，但是不熟悉哪里有房子出租，租房平台上的二房东上就有很多房源，他们作为中介高价出租房子给我们，代理模式恰恰是这个思维，一手房东是被代理者， 中介是代理者 。

3.Java的代理模式实现方式

3.1 静态代理

通过代理类（HouseAgent ）二手房东 去实现（Tenement）出租房子接口，达到代理的效果，缺点就是需要实现接口和创造出一个代理类。

/**
 * @Description 租房接口
 * @Version 1.0.0
 * @Date 2022/9/28 22:01
 * @Author NiKaBoy
 * @Email 123456789@qq.com
 */
public interface Tenement {

    /**
     * @Description:  出租接口
     * @Data:[houseDesc, price]
     * @return: void
     * @Author: NiKaBoy
     * @Email: 123456789@qq.com
     * @Date: 22-09-271 22:16:57
     */
    void rent();
}

 

/**
 * @Description  二手房东 中介
 * @Version 1.0.0
 * @Date 2022/9/28 22:03
 * @Author NiKaBoy
 * @Email 123456789@qq.com
 */
public class HouseAgent implements Tenement{


    private Landlord landlord;

    public HouseAgent(Landlord landlord) {
        this.landlord = landlord;
    }

    /**
     * @Description:
     * @Data:[houseDesc, price]
     * @return: void
     * @Author: NiKaBoy
     * @Email: 123456789@qq.com
     * @Date: 22-09-271 22:12:09
     */
    @Override
    public void rent() {
        landlord.setHouseDesc("豪华单人间，水电全免");
        landlord.setPrice(new BigDecimal(3000));
        landlord.rent();
    }
}
/**
 * @Description 房东
 * @Version 1.0.0
 * @Date 2022/9/28 22:02
 * @Author NiKaBoy
 * @Email 123456789@qq.com
 */
public class Landlord implements  Tenement{


    private String houseDesc ="普通单间人";
    private BigDecimal  price = new BigDecimal(1000);

    public void setHouseDesc(String houseDesc) {
        this.houseDesc = houseDesc;
    }

    public void setPrice(BigDecimal price) {
        this.price = price;
    }

    /**
     * @Description:  租售房子
     * @Data:[houseDesc, price]
     * @return: void
     * @Author: NiKaBoy
     * @Email: 123456789@qq.com
     * @Date: 22-09-271 22:08:47
     */
    @Override
    public void rent(){
        System.out.println("市中心房子,"+this.houseDesc+"出租"+",每月"+this.price+"元");
    }

}
public static void main(String[] args) {
    HouseAgent houseAgent = new HouseAgent(new Landlord());
    houseAgent.rent();//市中心房子,豪华单人间，水电全免出租,每月3000元
}

3.2 JDK动态代理

使用静态代理的时候，我们需要手动去写一个代理类，而JDK的动态代理就可以帮我们生成代理对象，从而实现对代理，缺点需要实现接口，对类无法代理。

/**
 * @Description jdk 动态代理,会自动生成一个代理对象
 * @Version 1.0.0
 * @Date 2022/9/28 22:02
 * @Author NiKaBoy
 * @Email 123456789@qq.com
 */
public class JdkProxyHandler implements InvocationHandler {

    private Object target;

    public JdkProxyHandler(Object target) {
        this.target = target;
    }

    /***切面类**/
    private Aspect aspect;

    public void setAspect(Aspect aspect) {
        this.aspect = aspect;
    }


    /**
     * @Description: 调用方法
     * @Data:[proxy, method, args]
     * @return: java.lang.Object
     * @Author: NiKaBoy
     * @Email: 123456789@qq.com
     * @Date: 22-09-273 22:35:19
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        if (aspect != null) {
            JoinPoint joinPoint = new JoinPoint();
            joinPoint.setMethodName(method.getName());
            joinPoint.setTarget(target);
            aspect.before(joinPoint);
            try {
                result = method.invoke(target, args);
            } catch (Exception e) {
                aspect.cast(joinPoint, e);
            }
            aspect.after(joinPoint);
            return result;
        }
        return method.invoke(target, args);
    }
}
public interface Tenement {

    /**
     * @Description:  出租接口
     * @Data:[houseDesc, price]
     * @return: void
     * @Author: NiKaBoy
     * @Email: 123456789@qq.com
     * @Date: 22-09-271 22:16:57
     */
    void rent();
}
/**
 * @Description 切面顶级类
 * @Version 1.0.0
 * @Date 2022/9/30 21:53
 * @Author NiKaBoy
 * @Email 123456789@qq.com
 */
public abstract class Aspect {
    /**
     * @Description: 前置方法
     * @Data:[]
     * @return: void
     * @Author: NiKaBoy
     * @Email: 123456789@qq.com
     * @Date: 22-09-273 21:54:46
     */
    public abstract void before(JoinPoint joinPoint);
    /**
     * @Description: 后置方法
     * @Data:[]
     * @return: void
     * @Author: NiKaBoy
     * @Email: 123456789@qq.com
     * @Date: 22-09-273 21:57:00
     */
    public abstract void after(JoinPoint joinPoint);

    /**
     * @Description: 异常方法
     * @Data:[]
     * @return: void
     * @Author: NiKaBoy
     * @Email: 123456789@qq.com
     * @Date: 22-09-273 21:57:27
     */
    public abstract void cast(JoinPoint joinPoint,Exception ex);



}
@Data
public class JoinPoint {
    /**实现的目标类**/
    private Object target;
    /**目标方法名**/
    private String methodName;
    /**目标方法的参数**/
    private Object [] args;

}
public class LandlordAspect extends  Aspect{
    @Override
    public void before(JoinPoint joinPoint) {
        Object target = joinPoint.getTarget();
        if(target instanceof Landlord){
            System.out.println("【前置方法】");
            Landlord landlord = (Landlord) target;

        }
    }

    @Override
    public void after(JoinPoint joinPoint) {
        Object target = joinPoint.getTarget();
        if(target instanceof Landlord){
            System.out.println("【后置方法】");
        }
    }

    @Override
    public void cast(JoinPoint joinPoint, Exception ex) {
        Object target = joinPoint.getTarget();
        if(target instanceof Landlord){
            System.out.println("【异常方法】"+ex);
        }
    }
}
public static void main(String[] args) {
    //被代理类
    Landlord landlord = new Landlord();
    JdkProxyHandler invocationHandler = new JdkProxyHandler(landlord);
    invocationHandler.setAspect(new LandlordAspect());
    Tenement tenement= (Tenement)Proxy.newProxyInstance(
            landlord.getClass().getClassLoader(),
            landlord.getClass().getInterfaces(),
            invocationHandler);

    tenement.rent();
}

3.3 CGLIB代理

jdk代理虽然帮我们生成了代理对象，但是它不能对类直接进行生成代理对象，需要存在一个接口，而cglib通过类就可以生成“代理对象”，不需要接口，当然也存在问题，对于代理方法是静态方法或者final修饰是无法实现拦截代理。

public class ProxyInterceptor implements MethodInterceptor {

    

    /**
     * 当对基于代理的方法回调时，拦截其方法，进行自定义处理
     *
     * @param target 代理对象
     * @param method 拦截的方法
     * @param args   拦截的方法的参数
     * @param proxy  代理
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        if (target instanceof Landlord) {
            System.out.println("[前置处理]");
            args[0] = "豪华一室一厅";
            args[1] = new BigDecimal(3000);
        }
        Object o = proxy.invokeSuper(target, args);
        System.out.println("[后置处理]");
        return o;
    }
}
public class Landlord {

    /**
     * @Description:  租售房子
     * @Data:[houseDesc, price]
     * @return: void
     * @Author: NiKaBoy
     * @Email: 123456789@qq.com
     * @Date: 22-09-271 22:08:47
     */
    public  void rent(String houseDesc,BigDecimal price){
        System.out.println("市中心房子,"+houseDesc+"出租"+",每月"+price+"元");
    }

}
public static void main(String[] args) {
    // 创建Enhancer类,用作实现Landlord类的代理
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(Landlord.class);
    ProxyInterceptor proxyInterceptor = new ProxyInterceptor();
    enhancer.setCallback(proxyInterceptor);
    Landlord landlord =(Landlord) enhancer.create();
    landlord.rent("一室一厅",new BigDecimal(1000));
}

3.4使用hutool工具实现代理并切面

开发中使用到代理场景一般都是用于切面，对某个被代理对象进行拦截进行前置处理和后置处理，Spring的aop就是利用jdk和cglib两种方式实现切面，当然也可以使用一些封装好的工具类去实现切面，例如hutool工具。

public class  Landlord  {

    /**
     * @Description:  租售房子
     * @Data:[houseDesc, price]
     * @return: void
     * @Author: NiKaBoy
     * @Email: 123456789@qq.com
     * @Date: 22-09-271 22:08:47
     */
    public void rent(String houseDesc,BigDecimal price){
        System.out.println("市中心房子,"+houseDesc+"出租"+",每月"+price+"元");
    }

}
/**
 * @Description 重写hutool工具的简单代理类
 * @Version 1.0.0
 * @Date 2022/10/13 21:32
 * @Author NiKaBoy
 * @Email 123456789@qq.com
 */
public class LandlordAspect extends SimpleAspect {

    @Override
    public boolean before(Object target, Method method, Object[] args) {
        args[0] = "豪华一室一厅";
        args[1] = new BigDecimal(3000);
        return super.before(target, method, args);
    }

    @Override
    public boolean after(Object target, Method method, Object[] args, Object returnVal) {
        return super.after(target, method, args, returnVal);
    }

    @Override
    public boolean afterException(Object target, Method method, Object[] args, Throwable e) {
        return super.afterException(target, method, args, e);
    }
}
public static void main(String[] args) {
    Landlord proxy = ProxyUtil.proxy(new Landlord(), new LandlordAspect());
    proxy.rent("一室一卫",new BigDecimal(1000));

}

3.5 SpringBoot 项目使用代理

@Aspect
@Component
public class TestAspect {

    @Autowired
    private AspectServer aspectServer;
    /**
     * 注解的方式指定切面的切入点
     */
    @Pointcut("@annotation(com.nika.boy.aop.TestAnnotation)")
    public void pointcutAnnotation() {
    }

    /***
    *根据包路径方式切入点
    */
    @Pointcut("execution(* com.nikaboy.service.api.*.*(..))")
	public void pointcutAnnotation() {
	}  

    /**
     * 前置通知：执行目标方法前 触发
     */
    @Before(value = "pointcutAnnotation()")
    public void methodBefore(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
       
      
    }
 
    /**
     * 后置通知：执行目标方法后触发
     */
    @After(value = "pointcutAnnotation()")
    public void methodAfter(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        Son arg = (Son)args[0];
         System.out.println(":::"+arg.getName());
        String methodName = joinPoint.getSignature().getName();
        System.out.println("[" + DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                + "]后置通知：方法名：" + methodName + "，参数" + Arrays.asList(joinPoint.getArgs()));



    }
 
    /**
     * 返回通知：目标方法执行完并返回参数后触发。
     */
    @AfterReturning(value = "pointcutAnnotation()", returning = "result")
    public void methodAfterReturning(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("[" + DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                + "]返回通知：方法名：" + methodName + "，" +
                "参数" + Arrays.asList(joinPoint.getArgs()) + "，" +
                "返回结果：");
        if (result instanceof String[]) {
            Arrays.stream((String[]) result).forEach(System.out::println);
        } else {
            System.out.println(result);
        }
    }
 
    /**
     * 异常通知：目标方法抛出异常后触发
     */
    @AfterThrowing(value = "pointcutAnnotation()", throwing="ex")
    public void methodExceptionOccurred(JoinPoint joinPoint, Exception ex) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("[" + DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                + "]异常通知：方法名：" + methodName + "，参数" + Arrays.asList(joinPoint.getArgs()) + "，异常信息：" + ex.getMessage());
        if(ex != null){
            ex = null;
        }
    }
    /**
     * 环绕通知，围绕着方法执行
     * 环绕通知需要携带ProceedingJoinPoint类型的参数
     * 环绕通知类似于动态代理的全过程：ProceedingJoinPoint类型的参数可以决定是否执行目标方法。
     * 而且环绕通知必须有返回值，返回值即为目标方法的返回值
     */
    @Around(value = "pointcutAnnotation()")
    public Object methodAround(ProceedingJoinPoint proceedingJoinPoint) {
        Object result = null;
        String methodName = proceedingJoinPoint.getSignature().getName();
        System.out.println("[" + DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                + "]环绕通知：方法名：" + methodName + "，参数" + Arrays.asList(proceedingJoinPoint.getArgs()));
        //执行目标方法
        try {
            result = proceedingJoinPoint.proceed();
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        return result;
    }
/**
 * 测试切面注解
 */
@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TestAnnotation {
}

NiKaBoy
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...
【从入门到学废---SpringBoot】
小汤圆
04-30 290
持续更新，建议收藏
Spring-Boot初体验，入门级学习教程
蜗牛背着那重重的壳呀，一步一步地往上爬.......
04-29 277
Spring Boot 是由 Pivotal 团队提供的全新框架。Spring Boot 是所有基于 Spring Framework 5.0 开发的项目的起点。Spring Boot 的设计是为了让你尽可能快的跑起来 Spring 应用程序并且尽可能减少你的配置文件。 准备工作 1.安装maven http://maven.apache.org/download.cgi 1.1下载对应的包...
HuTool设置请求代理报Proxy returns “HTTP/1.1 407 Proxy Authentication Required“
最新发布
重复生活的博客
06-05 274
最近在通过hutool工具进行代理请求时发现一个报错,大致代码如下。添加启动参数,放在springboot项目main方法中就行。其它 : 推荐使用 HttpClient。调用的是https,报错信息如下。
带你了解代理模式中的静态代理和动态代理以及cgilib代理^_^
leyasuzhou的博客
11-29 293
在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。或者特定的工具自动生成源代码在对其进行编译，举个简单例子：猪八戒去找高翠兰结果是孙悟空变的，可以这样理解：把高翠兰的外貌抽象出来，高翠兰本人和孙悟空都实现了这个接口，猪八戒访问高翠兰的时候看不出来这个是孙悟空，所以说孙悟空是高翠兰代理类。
Springboot物理地址映射和Nginx静态资源代理实现前端上传并访问服务器图片
泡泡的博客
12-20 6193
Springboot物理地址映射+Nginx静态资源代理实现前端上传并访问服务器图片前言一、Nginx 静态资源代理配置二、Springboot 物理地址映射配置总结 前言 为什么要配置物理地址映射：因为前端的 <img :src="">或者 :style="background-img(url)"这些，如果要给这些标签动态赋值，从后端传来的路径必须是 url 形式，也就是说带冒号的动态src或者url不支持绝对路径的物理地址。 所以要配置物理地址映射把图片的的物理地址映射为 url 地址传给
JoinPoint 对象
apmvn的博客
11-08 1333
JoinPoint对象以及JoinPoint核心方法，之前做的笔记比较烂，后面补冲
代理模式-静态动态代理-jdk动态代理-cglib动态代理
11-12
在Java中，代理模式有多种实现方式，包括静态代理、JDK动态代理和CGLIB动态代理。 **静态代理** 静态代理是最早也是最基础的代理实现方式。在静态代理中，我们需要创建一个代理类，这个代理类与原始类（被代理类）...
java jdk 动态代理用法、资料、demo
06-09
java jdk 动态代理用法、资料、demo
Java设计模式：静态代理、装饰者、动态代理详解
12-21
总结来说，代理模式在Java中主要用于在调用实际对象时添加额外的功能，而静态代理、装饰者和动态代理则是三种不同的实现方式。静态代理简单直观，但需要手动编写代理类；装饰者模式更注重扩展对象功能；动态代理则...
AOP框架（二）
等价交换
11-24 777
在有了之前的数据基础之后，我们还需要再明确几个知识点,AOP把软件系统分为两个部分：核心关注点和横切关注点。 业务处理的主要流程是核心关注点（本框架中就是指PersonDAO这样的类），与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似,比如权限认证、日志、事务处理(本框架中就是指Check这样的类)。Aop的作用在于分离系统中的各种关注点，
记录hutool http通过代理模式proxy访问外面的链接
sun
08-17 3508
记录hutool http通过代理模式proxy访问外面的链接
代理模式(十五)
两个蝴蝶飞
06-15 1512
1. 代理模式
Spring中的代理方式 -- JDK动态代理
weixin_46567672的博客
03-31 264
关于Spring中的动态代理，有两种实现方式，分别是JDK和CgLib。这篇文章我们来实现JDK动态代理的过程。
spring boot jdk 动态代理
m0_56385869的博客
07-03 522
Spring boot jdk 动态代理
springboot中aop的代理模式
java技术博客
11-05 1826
Spring 中的 AOP，有接口就用 JDK 动态代理，没有接口就用 Cglib 动态代理。Spring Boot 中的 AOP，2.0 之前和 Spring 一样；2.0 之后首选 Cglib 动态代理，如果用户想要使用 JDK 动态代理，需要自己手动配置。
Java+SpringBoot+RestTemplate实现接口代理二次转发
大数据开发、JAVA开发、人工智能AI
07-21 3806
用Java+Springboot服务器实现接口代理的二次转发，即接口接受到请求后，需要将请求转发到另一处服务器上，并将请求返回的结果返回给客户端
实战：第二十五章：HttpUtil代理
Java程序员廖志伟
11-02 1504
package com.common.entity.utils; import okhttp3.*; import org.springframework.http.HttpStatus; import java.io.IOException; import java.net.SocketTimeoutException; import java.util.concurrent.TimeUnit; /** * @author zhiwei Liao * @version 1.0 * @Date 2
Http请求-hutool工具类的使用
热门推荐
三横同学的博客
08-24 1万+
工具类的使用
注解实现methodinterceptor
05-24
MethodInterceptor是CGLib提供的一个拦截器接口，它可以在执行目标方法前后进行一些额外的操作，比如记录日志、性能监控、事务管理等。下面是一个注解实现MethodInterceptor的例子。 首先定义一个注解@Interceptor，用来标识需要被拦截的方法： ```java @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface Interceptor { } ``` 然后定义一个拦截器类MyInterceptor，实现MethodInterceptor接口： ```java public class MyInterceptor implements MethodInterceptor { @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { if (method.isAnnotationPresent(Interceptor.class)) { // 判断方法是否被注解@Interceptor标识 // 在目标方法执行前进行一些额外的操作 System.out.println("Before method invocation: " + method.getName()); // 执行目标方法 Object result = proxy.invokeSuper(obj, args); // 在目标方法执行后进行一些额外的操作 System.out.println("After method invocation: " + method.getName()); return result; } else { // 如果方法没有被注解@Interceptor标识，则直接执行目标方法 return proxy.invokeSuper(obj, args); } } } ``` 最后，在需要被拦截的方法上使用@Interceptor注解即可： ```java public class UserService { @Interceptor public void saveUser(User user) { // 保存用户信息 } } ``` 使用CGLib生成UserService的代理类，并调用代理类的saveUser方法： ```java public static void main(String[] args) { Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(UserService.class); enhancer.setCallback(new MyInterceptor()); UserService userService = (UserService) enhancer.create(); userService.saveUser(new User()); } ``` 输出结果如下： ``` Before method invocation: saveUser After method invocation: saveUser ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值