01-详解静态代理,动态代理(JDK动态代理原理和CGLIB动态代理原理)

最新推荐文章于 2024-08-28 20:58:28 发布
最新推荐文章于 2024-08-28 20:58:28 发布
阅读量69 收藏
点赞数 1
分类专栏： # AOP 文章标签： java 开发语言 静态代理 JDK动态代理 JDK动态代理原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57005976/article/details/134241128
版权

GoF之代理模式

概述

代理模式是GoF23种设计模式之一,属于结构型设计模式,本质就是通过引入代理对象间接实现对真实对象的操作

业务场景: 系统中有A、B、C三个模块,使用这些模块的前提是需要用户登录

  • 此时就可以为A、B、C三个模块提供一个代理,代理的逻辑请求来了之后先判断用户是否登录了,如果登录了则执行对应的目标,如果没有则跳转到登录页面

Java中的两种代理模式

  • 静态代理: 在编译期就生成代理对象
  • 动态代理: 在Java运行时动态生成代理对象,动态代理又有JDK代理和CGLib代理两种

代理模式的作用

  • 当一个对象需要受到保护的时候即不想让客户看到一些内容和服务,可以考虑使用代理对象去完成某个行为
  • 需要给某个对象的功能进行增强的时候,可以考虑找一个代理进行增强如添加客户需要的额外服务
  • 在程序中对象A和对象B无法直接交互时也可以使用代理模式来解决

代理模式分为三种角色

  • 目标对象(Real Subject): 实现最终核心的业务,是代理对象所代表的真实对象即最终要引用的对象
  • 代理对象(Proxy Subject): 其内部含有对目标对象的引用,它可以访问、控制或扩展目标对象的功能
  • 目标对象和代理对象的公共接口(Abstract Subject): 目标对象和代理对象需要具有相同的行为和动作,让客户端在使用代理对象时就像在使用目标对象一样

在这里插入图片描述

静态代理

准备对象和接口

OrderService接口是代理类和目标类实现的共同接口

public interface OrderService {
    /**
     * 生成订单
     */
    void generate();

    /**
     * 查看订单详情
     */
    void detail();

    /**
     * 修改订单
     */
    void modify();
}

OrderServiceImpl是目标类

public class OrderServiceImpl implements OrderService {
    @Override
    public void generate() {
        try {
            // 模拟生成订单的耗时
            Thread.sleep(1234);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已生成");
    }

    @Override
    public void detail() {
        try {
            // 模拟查看订单的耗时
            Thread.sleep(2541);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单信息如下：******");
    }

    @Override
    public void modify() {
        try {
            // 模拟修改订单的耗时
            Thread.sleep(1010);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已修改");
    }
}

统计每个业务方法耗费时长

第一种方案: 直接修改Java源代码在每个业务方法中添加统计耗时的逻辑

  • 缺点: 违背了OCP开闭原则另外代码没有得到复用
public class OrderServiceImpl implements OrderService {
    @Override
    public void generate() {
        long begin = System.currentTimeMillis();
        try {
            Thread.sleep(1234);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已生成");
        long end = System.currentTimeMillis();
        System.out.println("耗费时长"+(end - begin)+"毫秒");
    }

    @Override
    public void detail() {
        long begin = System.currentTimeMillis();
        try {
            Thread.sleep(2541);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单信息如下：******");
        long end = System.currentTimeMillis();
        System.out.println("耗费时长"+(end - begin)+"毫秒");
    }

    @Override
    public void modify() {
        long begin = System.currentTimeMillis();
        try {
            Thread.sleep(1010);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已修改");
        long end = System.currentTimeMillis();
        System.out.println("耗费时长"+(end - begin)+"毫秒");
    }
}

第二种方案: 编写一个业务类的子类OrderServiceImpl,在子类中重写父类的每个业务方法同时调用父类的业务方法(CGLIB动态代理实现的原理)

  • 缺点: 采用了继承(满足is a的关系)的方式会导致父类和子类的代码之间耦合度非常高,另外代码也没有得到复用
public class OrderServiceImplSub extends OrderServiceImpl{
    @Override
    public void generate() {
        long begin = System.currentTimeMillis();
        super.generate();
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
    }

    @Override
    public void detail() {
        long begin = System.currentTimeMillis();
        super.detail();
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
    }

    @Override
    public void modify() {
        long begin = System.currentTimeMillis();
        super.modify();
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
    }
}

第三种方案: 使用静态代理模式,编写一个代理类OrderServiceProxy实现OrderService接口,然后在代理对象中调用目标对象的目标方法

  • 优点: 符合OCP开闭原则,同时采用的是关联关系(满足has a的关系)所以程序的耦合度较低
  • 缺点: 每个目标对象都需要一个代理对象,随着目标对象越来越多就会导致类爆炸不好维护
// 代理类和目标类需要实现相同的接口,让客户端感觉使用代理对象就像在使用目标对象一样
public class OrderServiceProxy implements OrderService{ // 代理对象
    // 关联目标对象即将目标对象作为代理对象的一个属性,使用OrderService公共接口接收目标对象才能解耦合(目标对象一定实现了这个接口)
    private OrderService orderService;
    // 通过构造方法将目标对象传递给代理对象
    public OrderServiceProxy(OrderService orderService) {
        this.orderService = orderService;
    }
    @Override
    public void generate() {// 代理方法
        // 对目标对象的方法进行增强
        long begin = System.currentTimeMillis();
        // 执行目标对象的目标方法
        orderService.generate();
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
    }

    @Override
    public void detail() {// 代理方法
        // 对目标对象的方法进行增强
        long begin = System.currentTimeMillis();
        // 执行目标对象的目标方法
        orderService.detail();
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
    }

    @Override
    public void modify() {// 代理方法
        // 对目标对象的方法进行增强
        long begin = System.currentTimeMillis();
        // 执行目标对象的目标方法
        orderService.modify();
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
    }
}

测试OrderServiceImpl业务类中每个业务方法的耗时

public class Client {
    public static void main(String[] args) {
        // 创建目标对象
        OrderService target = new OrderServiceImpl();
        // 创建代理对象
        OrderService proxy = new OrderServiceProxy(target);
        // 调用代理对象的代理方法,底层是调用目标对象的目标方法
        proxy.generate();
        proxy.modify();
        proxy.detail();
    }
}

JDK动态代理

动态代理还是代理模式,只不过添加了字节码生成技术,可以在在程序运行时在内存中动态的生成字节码即代理类,有效减少代理类的数量同时解决代码复用的问题

在内存当中动态生成字节码的技术常见的包括三种

代理技术功能
JDK动态代理技术只能代理接口
CGLIB(Code Generation Library)动态代理技术既可以代理接口又可以代理类,通过继承的方式实现代理(生成目标类的子类作为),性能比JDK动态代理要好
底层通过使用一个小而快的字节码处理框架ASM
Javassist动态代理技术Javassist是一个开源的分析、编辑和创建Java字节码的类库
通过使用Javassist对字节码操作为JBoss应用服务器实现动态"AOP"框架

JDK动态代理原理

java.lang.reflect.Proxy是JDK提供的一个动态代理类,通过这个类可以在内存中生成代理类的字节码

方法功能
newProxyInstance(类加载器,公共接口类型,调用处理器接口的实现类)Proxy类提供的一个创建代理对象的静态方法
newProxyInstance方法执行结束后,首先在内存中动态生成一个代理类的字节码文件(Xxx.class)
然后通过类加载器获取代理类的字节码对象,使用Class对象实例化一个代理对象并返回
该方法的返回值是Object类型,但由于我们方法参数已经指定了代理对象实现的接口类型,所以可以放心的向下转型为对应的接口类型
invoke(代理对象,目标方法,目标方法调用时要传的参数)每次调用代理对象的任何方法最终都会先执行一次invoke方法(调用一次执行一次),调用代理对象的方法不同,invoke方法参数中的Method也对象不同,最终调用对应的目标类的方法
该方法的返回值由调用的目标对象的目标方法的执行结果决定,如果调用代理对象方法时需要接收返回值,那么就需要将目标对象的目标方法的执行结果返回

关于newProxyInstance()方法的三个重要的参数的含义

  • 类加载器: 要想执行JDK在内存中生成的字节码文件需要先把它通过类加载器加载到内存当中,并且JDK要求目标类的类加载器必须和代理类的类加载器是同一个
  • 公共接口类型: 告诉JDK动态代理生成的代理类要实现哪些接口,由于目标对象和代理对象实现的是同一个接口,所以可以直接通过目标对象获取接口类型
  • 调用处理器: JDK动态代理规定的java.lang.reflect.InvocationHandler是一个回调接口,调用这个接口中方法的程序已经写好了(自动调用 ),我们只要编写增强代码

InvocationHandler接口中invoke方法上的三个参数及调用

  • Object proxy: 设计这个参数只是为了后期需要在invoke方法中使用代理对象
  • Method method: 目标对象上的目标方法,即我们最终要执行的方法
  • Object[] args: 目标方法调用时需要传递的参数
  • 当你每调用一次代理对象的代理方法的时候,InvocationHandler接口的实现类中重写的invoke()方法就会被JDK调用一次,同时会携带方法需要的三个参数
  • 因为InvocationHandler接口的实现类存储的是我们需要增强的代码,所以需要手写,这样并不会造成类爆炸,因为这种实现类只需要写一次就好,代码可以复用

JDK动态生成的代理对象和目标对象的唯一联系就是它们都实现了同一个接口,可以在创建代理对象的时候向下转型

  • 代理类($Proxy0)将我们在Proxy.newProxyInstance方法参数中的匿名内部类对象传递给了父类Proxy

JDK动态代理实现

第一步: 提供OrderService接口及其实现类(目标类)OrderServiceImpl,UserServiceProxy代理类通过从在程序中动态生成

public interface OrderService {
    /**
     * 获取姓名
     */
    Srting getName();
    /**
     * 生成订单
     */
    void generate();

    /**
     * 查看订单详情
     */
    void detail();

    /**
     * 修改订单
     */
    void modify();
}

public class OrderServiceImpl implements OrderService {
    @Override
    public String getName() {
        System.out.println("执行getName方法");
        return "张三";
    }
    
    @Override
    public void generate() {
        try {
            Thread.sleep(1234);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已生成");
    }

    @Override
    public void detail() {
        try {
            Thread.sleep(2541);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单信息如下：******");
    }

    @Override
    public void modify() {
        try {
            Thread.sleep(1010);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已修改");
    }
}

第二步: 编写调用处理器接口的实现类TimerInvocationHandler同时实现接口中的invoke方法用来调用目标对象的目标方法并对其功能增强

  • 重写的方法名必须是invoke,因为invoke方法是JDK负责调用的,它已经把调用方法的程序写好了并且方法名就是invoke
  • 给TimerInvocationHandler提供一个构造方法,通过这个构造方法接收目标对象,然后在invoke方法执行过程中使用传递的method参数来调用目标对象的目标方法
/*	
专门负责计时的一个调用处理器对象,在这个调用处理器当中编写计时相关的增强代码,这个调用处理器只需要写一个就行了
*/
public class TimerInvocationHandler implements InvocationHandler {
    // 目标对象
    private Object target;
    public TimerInvocationHandler(Object target) {
        // 将接收的目标对象赋值给成员变量
        this.target = target;
    }
    
    // 负责调用目标对象的目标方法并对其功能增强
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long begin = System.currentTimeMillis();
        // 调用目标对象上的目标方法,方法四要素：哪个对象，哪个方法，传什么参数，返回什么值
        Object retValue = method.invoke(target, args);
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
        // 如果我们调用的目标对象的目标方法有返回值的话，invoke方法就必须将目标对象的目标方法执行结果继续返回
        return retValue;
    }
}

第三步: 测试调用代理对象的方法,底层JDK会调用invoke方法然后通过method参数去执行目标对象的目标方法

public class Client { 
    public static void main(String[] args) {
        // 第一步：创建目标对象
        OrderService target = new OrderServiceImpl();
        // 第二步：创建代理对象,由于我们方法参数已经指定了代理对象实现的接口类型,所以可以放心的向下转型为对应的接口类型
        OrderService orderServiceProxy = (OrderService)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new TimerInvocationHandler(target));
        // 第三步：调用代理对象的代理方法,调用代理对象的代理方法的时候，如果你要做增强的话目标对象的目标方法得保证执行
        orderServiceProxy.detail();
        orderServiceProxy.modify();
        orderServiceProxy.generate();    
        // 调用有返回值的代理对象的代理方法
        String name = orderServiceProxy.getName();
        System.out.println(name);
    }
}

封装创建代理对象的工具类

在工具类ProxyUtil封装方法,实现只要传递一个目标对象就可以通过这个方法获取代理对象

public class ProxyUtil {
    public static Object newProxyInstance(Object target){
        // 底层调用的还是JDK的动态代理
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new TimerInvocationHandler(target));
    }

}

// 进一步封装,使用匿名内部类的方式简化方法参数
public class ProxyUtil {
    public static Object newProxyInstance(Object target){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new TimerInvocationHandler(target){
                	 // 目标对象
    				private Object target;
    				public TimerInvocationHandler(Object target) {
        				// 赋值给成员变量。
        				this.target = target;
    				}
                    
                    @Override
    				public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        				// 这个接口的目的就是为了让你有地方写增强代码。
        				long begin = System.currentTimeMillis();

        				// 调用目标对象上的目标方法
        				// 方法四要素：哪个对象，哪个方法，传什么参数，返回什么值。
       					Object retValue = method.invoke(target, args);
       		 			long end = System.currentTimeMillis();
        				System.out.println("耗时"+(end - begin)+"毫秒");

        				//如果我们调用的代理对象的代理方法有返回值的话，invoke方法必须将目标对象的目标方法执行结果继续返回。
        				return retValue;
    				}    
                });
    }

}

使用工具类封装的newProxyInstance方法简化客户端代码

public class Client {
    public static void main(String[] args) {
        // 创建目标对象
        OrderService target = new OrderServiceImpl();
        // 使用工具类创建代理对象
        OrderService orderServiceProxy = (OrderService) ProxyUtil.newProxyInstance(target);
        // 调用代理对象的代理方法
        orderServiceProxy.detail();
        orderServiceProxy.modify();
        orderServiceProxy.generate();
    }
}

CGLIB动态代理原理

CGLIB动态代理既可以代理接口又可以代理类,底层通过继承的方式实现对目标类的代理,所以被代理的目标类不能使用fianl修饰

// CGLIB创建的代理对象的格式,可以根据这个名字推测框架底层是否使用了CGLIB动态代理
class UserService$$EnhancerByCGLIB$$82cb55e3 extends UserService{}

net.sf.cglib.proxy.MethodInterceptor是CGLIB中提供的方法拦截器接口,和JDK动态代理的调用处理器接口一样,我们也需要提供该接口实现类并重写方法

CGLIB中的Enhancer和JDK的Proxy类都是用来创建代理对象的类

  • 使用Proxy类是直接调用静态方法newProxyInstance()创建代理对象,在方法中设置目标对象相关参数和调用处理器接口实现类,直接返回代理对象
  • 使用Enhancer类需要先创建字节码增强对象,然后通过Enhancer对象的不同方法设置目标类相关参数和方法拦截器接口的实现类,最后再调用方法创建代理对象
方法名功能
intercept(目标对象,目标方法,目标方法调用时的实参,调用目标方法时需要用到的MethodProxy类)负责调用目标类的目标方法以及添加增强的代码的方法
invokeSuper(目标对象,目标方法调用时的实参)最中调用目标对象中目标方法的方法
setSuperclass(Class clazz)设置代理类的父类即目标类
setCallback()设置回调为拦截器接口的实现类,等同于JDK动态代理当中的调用处理器接口的实现类
create()创建代理对象
先在内存中生成目标类的子类即代理类的字节码,然后创建代理对象
返回值默认是Object类型,但由于我们已经设置了代理类的父类,所以可以放心强转

CGLIB动态代理实现

第一步: 引入CGLIB的依赖

<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.3.0</version>
</dependency>

第二步: 准备一个目标类UserService,这个类不需要实现任何接口

public class UserService {
    public void login(String username, String password){
        System.out.printn("系统正在验证身份...");
        if ("admin".equals(username) && "123".equals(password)) {
           	return true;
        }  
         return false;
    }

    public void logout(){
        System.out.println("用户正在退出系统....");
    }
}

第三步: 编写MethodInterceptor接口的实现类TimerMethodInterceptor并重写intercept()方法负责调用目标类的目标方法以及添加增强代码

public class TimerMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object target, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        // 前面增强
        long begin = System.currentTimeMillis();

        // 调用目标对象的目标方法
        Object retValue = methodProxy.invokeSuper(target, objects);

        // 后面增强
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");

        return retValue;
    }
}

第四步: 测试使用CGLIB在内存中为UserService类生成的代理类并创建代理对象,然后通过调用代理对象的方法去执行目标对象的目标方法

public class Client {
    public static void main(String[] args) {
        // 创建字节码增强器对象,这个对象是CGLIB库当中的核心对象，就是依靠它来生成代理类
        Enhancer enhancer = new Enhancer();

        // 告诉CGLIB生成的代理类的父类是谁即目标类是谁
        enhancer.setSuperclass(UserService.class);

        // 设置回调为方法拦截器接口MethodInterceptor的实现类,等同于JDK动态代理当中的调用处理器接口的实现类
        enhancer.setCallback(new TimerMethodInterceptor());

        // 创建代理对象,代理类的父类是UserService
        UserService userServiceProxy = (UserService) enhancer.create();

        // 查看CGLIB动态代理生成的代理对象
        System.out.println(userServiceProxy);

        // 调用代理对象的代理方法
        boolean success = userServiceProxy.login("admin", "123");
        System.out.println(success ? "登录成功" : "登录失败");
        userServiceProxy.logout();
    }
}

JDK高版本问题

如果高版本的JDK想要使用CGLIB就需要在启动项中添加两个启动参数

--add-opens java.base/java.lang=ALL-UNNAMED
--add-opens java.base/sun.net.util=ALL-UNNAMED

在这里插入图片描述

动态代理与静态代理比较

优缺点

动态代理与静态代理相比较的优点是在接口方法数量比较多的时候可以进行灵活处理

  • 接口中声明的所有方法都被转移到调用处理器InvocationHandler的一个集中方法invoke中处理,而不需要像静态代理那样在每一个方法进行中转

  • 不管你有多少个Service接口,由于我们的代理对象是在程序运行中动态生成的 , 所以可以实现任何接口代码不会写死

echo 云清
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代理模式之静态代理，JDK动态代理和cglib动态代理
烟雨星空的博客
12-27 1233
代理模式，顾名思义，就是通过代理去完成某些功能。比如，你需要购买火车票，不想跑那么远到火车站售票窗口买，可以去附近的火车票代售点买，或者到携程等第三方网站买。这个时候，我们就把火车站叫做目标对象或者委托对象，也可以叫被代理对象，而火车票代售点和携程就叫做代理对象。 一、静态代理 静态代理是最简单的代理模式。需要定义一个接口，然后委托类和代理类分别实现这个接口 //待实现的接口 public int...
Java 静态代理、JDK动态代理、CGLIB代理的区别及原理
Code-CHAN的博客
01-15 464
Java 静态代理、JDK动态代理、CGLIB代理 代理（Proxy）：是一种设计模式，提供了对目标对象另外的访问方式，即通过代理对象访问目标对象。 好处：可以在目标对象实现的基础上，增强额外的功能操作，即目标对象的扩展功能。 举个例子：假如产品经理提了一个新的需求，需要在某个方法调用之前以及调用之后打印日志。那么我们就可以通过代理的方式，不修改方法内部的代码而实现。 1. Java静态代理 静态代理： 代理对象和目标对象实现相同的接口或者继承相同的父类，然后通过调用代理对象的方法来调用目标对象的方法实现代
【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
热门推荐
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
JDK和cglib动态代理原理详解
tank的博客
01-07 2389
AOP的基础是Java动态代理，了解和使用两种动态代理能让我们更好地理解&nbsp;AOP，在讲解AOP之前，让我们先来看看Java动态代理的使用方式以及底层实现原理。转自https://www.jianshu.com/u/668d0795a95b本文是基于jdk1.8来对动态代理的底层机制进行探究的Java...
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...
静态代理、jdk动态代理、cglib动态代理
02-27
静态代理的优点是：它的实现方式简单易懂，易于维护和扩展。但是，它的缺点是：每个被代理的对象都需要创建一个代理类，这增加了系统的复杂度。 JDK 动态代理 JDK 动态代理是 Java 语言中的一种代理模式实现方式，...
Spring AOP里的静态代理和动态代理用法详解
08-18
Spring AOP里的静态代理和动态代理用法详解 Spring AOP里的静态代理和动态代理用法详解是关于 Spring AOP里的静态代理和动态代理的详细介绍。代理是一种设计模式，通过创建一个代理对象来控制对委托类对象的直接...
Java静态代理，jdk动态代理，cglib动态代理的区别
weixin_32629733的博客
11-28 327
Java静态代理和动态代理 1.代理模式 给某一个对象提供一个代理，并由代理对象来控制对真实对象的访问。代理模式是一种结构型设计模式。 代理模式角色分为 3 种： 抽象角色：一般是一个接口或者抽象类，定义了一些公共方法； 真实角色：真正实现业务逻辑的类，也是被代理的角色； 代理角色：用来代理和封装真实主题 真实角色和代理角色必须实现同一个抽象角色的接口。 2.静态代理 所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和真实主题角色的关系在运行前就确定了。 2.1 lol代练解释静态代理 以一个
Java 动态代理详解（学习资料）
06-17
JDK 动态代理JDK 提供了 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来支持动态代理。Proxy 类用于创建一个代理对象，而 InvocationHandler 接口则定义了代理对象的方法调用处理逻辑。...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 2146
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 2501
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 2756
linux上datax 安装以及使用
操作系统原子操作
zzt_is_me的博客
08-28 888
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
最新发布
weixin_39996520的博客
08-28 703
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 469
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 1287
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
C++的内存模型
qhu1600417010的博客
08-28 738
C++ 的内存模型包含了程序运行时如何分配、访问、管理内存的规则，涵盖了多线程环境下的数据一致性、内存对齐、以及虚拟内存管理等内容。掌握这些概念对于编写高效、安全的 C++ 程序至关重要。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 1464
@Transactional中使用线程锁导致了锁失效与解决方案
Java代理模式详解：静态代理、JDK与CGLIB动态代理
代理模式分为静态代理、JDK动态代理和CGLIB动态代理三种实现方式，每种都有其特定的优点和应用场景。静态代理虽然效率最高但灵活性较低，适用于已明确代理类的情况。JDK动态代理基于接口，适合通用业务，如性能日志...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值