JDK 动态代理 和 CGLib 动态代理

已于 2023-02-08 00:11:39 修改
阅读量317 收藏
点赞数 1
分类专栏： Java 学习笔记 Spring、Spring Boot 学习笔记 文章标签： java jvm 开发语言 代理模式 动态代理
于 2022-12-10 23:20:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46766584/article/details/128270602
版权

文章目录

JDK 动态代理 和 CGLib 动态代理

  • 动态代理就是：在程序运行期，创建目标对象的代理对象，并对目标对象中的方法进行功能性增强的一种技术。

  • 在生成代理对象的过程中，目标对象不变，代理对象中的方法是目标对象方法的增强方法。

  • 可以理解为运行期间，对象中方法的动态拦截，在拦截方法的前后执行功能操作。

  • 特点：方法修改基本无影响：方法增强与原先的功能分开，与方法名称无关、
    动态代理工厂的数量小于静态代理类数量、代理工厂创建的代理类一般不保存，不占用内存。

JDK 动态代理

  • JDK 动态代理是：代理类实例在程序运行时，由 JVM 根据反射机制动态的生成，而不是自行在程序编码期间创建。

  • 创建的是：代理类对象。是在运行后才能创建的。

  • 代理类是用来：替待 A 类调用 C 类的。

    • 由于某种限制，A 类无法调用 C 类的方法，可以创建一个代理类 B 类。

    • 让 B 类访问 C 类，A 类访问 B 类，完成该功能。

  • JDK 动态代理，必须有接口，目标类必须实现接口，且只能代理实现接口的类。

  • JDK Proxy 是 Java 语言自带的功能，无需通过加载第三方类实现。

  • JDK Proxy 是通过拦截器加反射的方式实现的。

创建代理对象

  • 使用 JDK 官方的 Proxy 类创建代理对象。

  • Proxy.newProxyInstance(ClassLoader, Class<?>[], InvocationHandler);

  • ClassLoader：JVM 提供的类加载器，用来加载类。

  • Class<?>[]：目标类所实现的接口集。

  • InvocationHandler：调用处理程序，用来调用、增强目标类方法。

核心类

InvocationHandler 接口

  • 代理实例的调用处理器需要实现 InvocationHandler 接口，并且每个代理实例都有一个关联的调用处理器。

  • 创建的每一个代理实例都要有一个关联的 InvocationHandler。

  • 在调用代理实例的方法时，会被转到 InvocationHandler 的 invoke 方法上。

  • 只有一个 invoke() 方法，在方法内调用目标类的方法（所有方法都可以调用），同时在调用前后可以增强方法功能。

  • invoke() 方法的三个参数：

    • proxy（Object）：是调用该方法的代理实例。

    • method（Method）：是在代理实例上调用的接口方法对应的 Method 实例。

    • args（Object[]）：一个 Object 数组，是在代理实例上的方法调用中传递的参数值；如果接口方法为无参，则该值为 null。

    • 返回值：调用代理实例上的方法的返回值。

Proxy 类

  • 提供了创建动态代理类及其实例的静态方法，该类也是动态代理类的超类。

  • 代理类的名称以 $Proxy 开头，后面跟着一个数字序号，如 P r o x y 0 、 Proxy0、 Proxy0、Proxy1。

  • 代理类继承了 Proxy 类，类实现了创建时指定的接口（JDK动态代理是面向接口的）。

  • 每个代理类都有一个公共构造函数，它接受一个参数（接口 InvocationHandler 的实现），用于设置代理实例的调用处理器。

示例代码

  • 代理目标接口 UsbSellProxy 中，定义了两个方法，代理目标接口的实现类 UsbSellProxyImpl 实现了这两个方法。

  • JDK 的代理工厂用来创建 UsbSellProxy 接口的代理类。

  • 在方法调用上，没有区别。

  • 方法增强是对所有方法的，所有方法都要经过 InvocationHandler 的 invoke() 方法调用。

public class ProxyTest {
	
	/**
	 * 动态代理
	 * <p>
	 * JDK
	 */
	public static void main(String[] args) {
		// 目标对象
		UsbSellProxyImpl usbSellProxy = new UsbSellProxyImpl();
		// 使用 JDK 动态代理为【目标对象】创建代理对象
		UsbSellProxyImpl proxy = JdkProxyFactory.getProxy(usbSellProxy);
		System.out.println(proxy.sell(3));
		System.out.println(proxy.batchSell(30));
	}

}

/**
 * 代理目标 类（必须要有）
 * <p>
 * 动态 代理 测试
 * <p>
 * 或者说是 A、B、C 三个类都要实现的公共方法接口
 * <p>
 * 表示功能的接口，厂家，商家都要完成的功能
 */
interface UsbSellProxy {
	
	/**
	 * 购买 USB
	 *
	 * @param amount 购买数量
	 *
	 * @return 总价
	 */
	float sell(int amount);
	
	/**
	 * 批量 购买 USB
	 * <p>
	 * 打折
	 *
	 * @param amount 购买数量
	 *
	 * @return 打折后的总价
	 */
	float batchSell(int amount);

}

/**
 * 动态 代理 测试
 * <p>
 * 代理目标 类 的实现类
 */
class UsbSellProxyImpl implements UsbSellProxy {
	
	/**
	 * USB 单价
	 */
	private float price = 128F;
	
	public float getPrice() {
		return price;
	}
	
	public void setPrice(float price) {
		this.price = price;
	}
	
	@Override
	public float sell(int amount) {
		System.out.println("动态代理 接口实现类（单买）");
		System.out.println("USB 单价：" + price);
		if(amount <= 0) {
			System.out.println("购买 USB 的数量不对，结束！");
			return 0;
		}
		System.out.println("发出 USB " + amount + " 件。");
		return amount * price;
	}
	
	@Override
	public float batchSell(int amount) {
		System.out.println("动态代理 接口实现类（批发）");
		System.out.println("USB 单价：" + price);
		if(amount <= 0) {
			System.out.println("购买 USB 的数量不对，结束！");
			return 0;
		}
		System.out.println("发出 USB " + amount + " 件。");
		float result = amount * price;
		if(amount <= 10) {
			System.out.println("批量购买，打【九五】折！");
			result = 0.95F * result;
		} else if(amount <= 20) {
			System.out.println("批量购买，打【九】折！");
			result = 0.9F * result;
		} else if(amount <= 30) {
			System.out.println("批量购买，打【八五】折！");
			result = 0.85F * result;
		} else {
			System.out.println("批量购买，打【八】折！");
			result = 0.8F * result;
		}
		return result;
	}

}

/**
 * JDK 动态代理
 * <p>
 * 生成代理类的工厂
 */
class JdkProxyFactory {
	
	/**
	 * 创建 target 类的代理对象
	 * <p>
	 * 当调用代理对象中的方法时，其实就是调用的 InvocationHandler里面的 invoke 方法，
	 * 然后在 invoke 方法里调用目标对象对应的方法
	 * <p>
	 * 即：Java 反射中调用类方法
	 *
	 * @param target 要创建代理对象的类
	 * @param <T>    泛型
	 *
	 * @return 代理对象
	 */
	public static <T> T getProxy(final Object target) {
		// 创建代理实例
		// Proxy 的静态方法 newProxyInstance() 参数分别是：target 类的类加载器、target 类实现的接口、InvocationHandler
		Object proxyInstance = Proxy.newProxyInstance(
				target.getClass().getClassLoader(),
				target.getClass().getInterfaces(),
				(proxy, method, args) -> {
					System.out.println("执行目标类的目标方法前！（可以适当增强方法）");
					Object invoke = method.invoke(target, args);
					System.out.println("执行目标类的目标方法后！（可以适当增强方法）");
					return invoke;
				}
		);
		// 返回代理对象
		return (T) proxyInstance;
	}

}

CGLib（Code Generation Library） 动态代理

  • CGLIB 通过动态生成一个需要被代理类的子类（即被代理类作为父类），该子类重写被代理类的所有不是 final 修饰的方法，并在子类中采用方法拦截的技术拦截父类所有的方法调用，进而织入横切逻辑。

  • 因为 CGLIB 采用整型变量建立了方法索引，这比使用 JDK 动态代理（使用 Java 反射技术创建代理类的实例）更快。

  • 第三方的 CGLib，如果出现 asmXXXX 异常，就需要导入 asm.jar 包。

  • 而没有接口时，需要使用 CGLib 动态代理。

  • 被代理对象不能用 final 修饰。

  • CGLib 无需通过接口来实现，它是针对类实现代理，主要是对指定的类生成一个子类，它是通过实现子类的方式来完成调用的。

  • 类包：org.springframework.cglib.proxy。

创建代理对象

  • 使用 CGLIB 的 Enhancer 类创建代理对象。

  • Enhancer.create(Class, MethodInterceptor);

  • Class：目标类的 Class 对象。

  • MethodInterceptor：方法拦截器，用来调用、增强目标类方法。

    • 同样的，在 invoke() 方法中调用目标类的方法（所有方法都可以调用），同时在调用前后可以增强方法功能。

核心类

Enhancer 类

  • Enhancer 是一个类的增强器，可以完成对类的代理。

  • 在 Spring 中经常可以看到他的身影,比如 @Configuration 注解的类就会被 Enhancer 代理。

  • Enhancer 目的就是：完成代理，所以我们称之为代理类，而被代理的类我们称目标类。

MethodInterceptor 接口

  • 是一个拦截器，父类（代理目标类）在调用方法时，都会被其拦截，跳转到 intercept() 方法。

  • Callback: 声明式接口，主要利用其子接口自定义实现类完成代理对象的逻辑增强，作用相当于 JDK 动态代理中的 InvocationHandler。

  • MethodInterceptor 就是 Callback 的子接口之一，或者说：Enhancer.create() 方法的第二个参数是 Callback 接口。

  • intercept() 方法有四个参数：

    • o（Object）：是调用该方法的代理实例。

    • method（Method）：是在代理实例上调用的接口方法对应的 Method 实例。

    • objects（Object[]）：一个 Object 数组，是在代理实例上的方法调用中传递的参数值；如果接口方法为无参，则该值为 null。

    • methodProxy（MethodProxy）：是在代理实例上调用的接口方法对应的 Method 实例的代理对象。

    • 返回值：调用代理实例上的方法的返回值。

示例代码

  • 代理目标接口 UsbSellProxy 中，定义了两个方法，代理目标接口的实现类 UsbSellProxyImpl 实现了这两个方法。

  • CGLib 的代理工厂用来创建 UsbSellProxyImpl 类的代理类。

  • 在方法调用上，没有区别。

  • 方法增强是对所有方法的，所有方法都要经过 MethodInterceptor 的 intercept() 方法调用。

public class ProxyTest {
	
	/**
	 * 动态代理
	 * <p>
	 * CgLib
	 */
	public static void main(String[] args) {
		// 目标对象
		UsbSellProxyImpl usbSellProxy = new UsbSellProxyImpl();
		// 使用 JDK 动态代理为【目标对象】创建代理对象
		UsbSellProxyImpl proxy = CglibProxyFactory.getProxy(usbSellProxy);
		System.out.println(proxy.sell(3));
		System.out.println(proxy.batchSell(30));
	}

}

/**
 * 代理目标 类（必须要有）
 * <p>
 * 动态 代理 测试
 * <p>
 * 或者说是 A、B、C 三个类都要实现的公共方法接口
 * <p>
 * 表示功能的接口，厂家，商家都要完成的功能
 */
interface UsbSellProxy {
	
	/**
	 * 购买 USB
	 *
	 * @param amount 购买数量
	 *
	 * @return 总价
	 */
	float sell(int amount);
	
	/**
	 * 批量 购买 USB
	 * <p>
	 * 打折
	 *
	 * @param amount 购买数量
	 *
	 * @return 打折后的总价
	 */
	float batchSell(int amount);

}

/**
 * 动态 代理 测试
 * <p>
 * 代理目标 类 的实现类
 */
class UsbSellProxyImpl implements UsbSellProxy {
	
	/**
	 * USB 单价
	 */
	private float price = 128F;
	
	public float getPrice() {
		return price;
	}
	
	public void setPrice(float price) {
		this.price = price;
	}
	
	@Override
	public float sell(int amount) {
		System.out.println("动态代理 接口实现类（单买）");
		System.out.println("USB 单价：" + price);
		if(amount <= 0) {
			System.out.println("购买 USB 的数量不对，结束！");
			return 0;
		}
		System.out.println("发出 USB " + amount + " 件。");
		return amount * price;
	}
	
	@Override
	public float batchSell(int amount) {
		System.out.println("动态代理 接口实现类（批发）");
		System.out.println("USB 单价：" + price);
		if(amount <= 0) {
			System.out.println("购买 USB 的数量不对，结束！");
			return 0;
		}
		System.out.println("发出 USB " + amount + " 件。");
		float result = amount * price;
		if(amount <= 10) {
			System.out.println("批量购买，打【九五】折！");
			result = 0.95F * result;
		} else if(amount <= 20) {
			System.out.println("批量购买，打【九】折！");
			result = 0.9F * result;
		} else if(amount <= 30) {
			System.out.println("批量购买，打【八五】折！");
			result = 0.85F * result;
		} else {
			System.out.println("批量购买，打【八】折！");
			result = 0.8F * result;
		}
		return result;
	}

}

/**
 * cglib 动态代理
 * <p>
 * 生成代理类的工厂
 */
class CglibProxyFactory {
	
	/**
	 * 创建 target 类的代理对象
	 *
	 * @param target 要创建代理对象的类
	 * @param <T>    泛型
	 *
	 * @return 代理对象
	 */
	public static <T> T getProxy(final Object target) {
		// 创建代理实例
		// Enhancer 的静态方法 create() 参数分别是：target 类的 Class 对象、MethodInterceptor
		Object proxyInstance = Enhancer.create(
				target.getClass(),
				(MethodInterceptor) (o, method, objects, methodProxy) -> {
					System.out.println("执行目标类的目标方法前！（可以适当增强方法）");
					Object invoke = method.invoke(target, objects);
					System.out.println("执行目标类的目标方法后！（可以适当增强方法）");
					return invoke;
				});
		// 返回代理对象
		return (T) proxyInstance;
	}

}

JDK 动态代理 和 CGLib 动态代理 的区别

  • JDK 动态代理只能对接口进行代理，不能对普通的类进行代理，这是因为 JDK 动态代理生成的代理类，其父类是 Proxy，且 Java 不支持类的多继承。

  • CGLib 动态代理能够代理接口和普通的类，但是被代理的类不能被 final 修饰，且接口中的方法不能使用 final 修饰。

  • JDK 动态代理使用 Java 反射技术进行操作，在生成类上更高效。

  • CGLib 动态代理使用 ASM 框架直接对字节码进行修改，使用了 FastClass 的特性。在某些情况下，类的方法执行会比较高效。

  • FastClass 机制就是对一个类的方法建立索引，通过索引来直接调用相应的方法。

  • CGLib 动态代理 是第三方提供的工具，基于 ASM 实现的，性能比较高。

  • Java 对 JDK 动态代理 提供了稳定的支持，并且会持续的升级和更新，Java 8 版本中的 JDK Proxy 性能相比于之前版本提升了很多。

动态代理的作用

  • 功能增强：在不改变原来目标方法功能的前提下，可以在代理中增强自己的功能代码。

  • 控制访问：代理类规定好访问目标，不能越界。

静态代理

  • 代理类是自己手工实现的，自己创建一个 java类，表示代理类。（在编码期创建代理类）

  • 所要代理的目标类是确定的。

  • 特点：实现简单、容易理解。

  • 缺点：代理类数量过多：当目标类增加了，代理类可能也需要成倍的增加、
    修改时影响大：接口中功能增加了、或者修改了，会影响众多的实现类、厂家类、代理类，都需要修改。

/**
 * 静态 代理 测试
 * <p>
 * 表示功能的接口，厂家，商家都要完成的功能
 */
interface UsbSell {
	
	/**
	 * 购买 USB
	 *
	 * @param amount 购买数量
	 *
	 * @return 总价
	 */
	float sell(int amount);

}

public class JdkProxyTest {
	
	/**
	 * USB 买家
	 */
	public static void main(String[] args) {
		// 创建商家 1
		UsbBusinessOne business = new UsbBusinessOne();
		int amount = 5;
		// 购买 USB
		float price = business.sell(amount);
		System.out.println("买家通过商家 " + business.getClass().toString() + " 购买 USB " + amount + " 件，总价：" + price);
		
		System.out.println("========================");
		// 创建商家 2
		UsbBusinessTwo business2 = new UsbBusinessTwo();
		// 购买 USB
		float price1 = business2.sell(amount);
		System.out.println("买家通过商家 " + business2.getClass().toString() + " 购买 USB " + amount + " 件，总价：" + price1);
	
	}

}

/**
 * USB 生产工厂 1（金士顿）
 */
class UsbFactoryOne implements UsbSell {
	
	/**
	 * USB 单价
	 */
	private float price = 128F;
	
	public float getPrice() {
		return price;
	}
	
	public void setPrice(float price) {
		this.price = price;
	}
	
	@Override
	public float sell(int amount) {
		System.out.println("USB 生产工厂 UsbFactoryOne（金士顿），Usb 单价：" + price);
		if(amount <= 0) {
			return 0;
		}
		System.out.println("USB 生产工厂 UsbFactoryOne（金士顿）发出 USB " + amount + " 件。");
		return amount * price;
	}

}

/**
 * USB 生产工厂 2（华为）
 */
class UsbFactoryTwo implements UsbSell {
	
	/**
	 * USB 单价
	 */
	private float price = 106F;
	
	public float getPrice() {
		return price;
	}
	
	public void setPrice(float price) {
		this.price = price;
	}
	
	@Override
	public float sell(int amount) {
		System.out.println("USB 生产工厂 UsbFactoryTwo（华为），Usb 单价：" + price);
		if(amount <= 0) {
			return 0;
		}
		System.out.println("USB 生产工厂 UsbFactoryTwo（华为）发出 USB " + amount + " 件。");
		return amount * price;
	}

}

/**
 * USB 商家 1（金士顿 旗舰店）
 */
class UsbBusinessOne implements UsbSell {
	
	/**
	 * 声明商家代言的工厂
	 */
	private UsbFactoryOne factory = new UsbFactoryOne();
	
	/**
	 * 单件溢价
	 */
	private float premium = 20F;
	
	public float getPremium() {
		return premium;
	}
	
	public void setPremium(float premium) {
		this.premium = premium;
	}
	
	@Override
	public float sell(int amount) {
		System.out.println("USB 商家 UsbBusinessOne（金士顿 旗舰店），USB 单件溢价：" + premium);
		if(amount <= 0) {
			return 0;
		}
		// 成本
		float cost = factory.sell(amount);
		System.out.println("USB 商家 UsbBusinessOne（金士顿 旗舰店），购入 USB " + amount + " 件，并发出。");
		return cost + premium * amount;
	}

}

/**
 * USB 商家 2（华为 旗舰店）
 */
class UsbBusinessTwo implements UsbSell {
	
	/**
	 * 声明商家代言的工厂
	 */
	private UsbFactoryTwo factory = new UsbFactoryTwo();
	
	/**
	 * 单件溢价
	 */
	private float premium = 22F;
	
	public float getPremium() {
		return premium;
	}
	
	public void setPremium(float premium) {
		this.premium = premium;
	}
	
	@Override
	public float sell(int amount) {
		System.out.println("USB 商家 UsbBusinessTwo（华为 旗舰店），USB 单件溢价：" + premium);
		if(amount <= 0) {
			return 0;
		}
		// 成本
		float cost = factory.sell(amount);
		System.out.println("USB 商家 UsbBusinessTwo（华为 旗舰店），购入 USB " + amount + " 件，并发出。");
		return cost + premium * amount;
	}

}

  • 从代码中看出，明确好目标类后，使用上十分方便，相应的类的数量也会变多。

  • 同样的，方法的增强要重复添加，不同名称功能相近的方法也需要重复添加。

十⑧
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【JVM与性能调优】JVM动态代理、JDK动态代理和CGLib动态代理傻傻分不清楚
本本本添哥
04-14 1277
JDK动态代理和CGLib动态代理都是Java中用于创建动态代理的方法，但它们的实现方式不同。
Java两种动态代理JDK动态代理和CGLIB动态代理
热门推荐
Java相关领域
08-07 14万+
目录 代理模式 JDK动态代理 cglib动态代理 测试 代理模式 代理模式是23种设计模式的一种，他是指一个对象A通过持有另一个对象B，可以具有B同样的行为的模式。为了对外开放协议，B往往实现了一个接口，A也会去实现接口。但是B是“真正”实现类，A则比较“虚”，他借用了B的方法去实现接口的方法。A虽然是“伪军”，但它可以增强B，在调用B的方法前后都做些其他的事情。Spring AOP...
JDK动态代理和CGLIB动态代理
努力努力再努力的小笼包
05-30 8213
在SpringAOP中基于动态代理实现功能的增强，也就是动态的生成代理类，在代理类中织入增强的逻辑然后调用目标对象的方法。动态代理中用的比较多的两种：JDK动态代理、CGLIB动态代理。 JDK动态代理 使用JDK的java.lang.reflect.Proxy类的newProxyInstance方法实现的代理。 用一个测试接口看下具体实现： public interface JdkProxyDemoService { void queryTrs(); } @Service public
通俗易懂 快速理解 JDK动态代理 和 cglib动态代理
weixin_43935152的博客
05-05 1万+
动态代理有两种： ① jdk动态代理，要求必须有接口，最终生成的代理类和目标类实现相同的接口，在com.sun.proxy包下，类名为$proxy+数字 （例如：$proxy6） ② cglib动态代理，最终生成的代理类会继承目标类，并且和目标类在相同的包下
JDK动态代理和CGLib动态代理
javaergogoing的博客
03-28 1383
JDK动态代理和CCGLib动态代理小案例
Jdk动态代理与Cglib动态代理
syh121的博客
09-13 3509
前言 在前面的spring中，提到了aop的原理就是使用了动态代理，这篇文章就写一下jdk代理和cglib代理。 先在这里贴一下相关的需要代理的对象和接口。 首先是接口： public interface TestDao { void test(); } 复制代码 然后是实现类： public class TestDaoImpl implements TestDao { @Override public void test() { System.out.println("
JDK动态代理和Cglib动态代理实例源码
01-04
- **灵活性**：JDK代理要求目标类实现接口，而Cglib无此限制。 - **使用场景**：如果目标类已经实现了接口，且不关心性能，优先选择JDK代理；否则，Cglib是更好的选择。 在`DynamicProxyTest`源码中，我们可以看到...
JAVA动态代理实现Demo（JDK动态代理和CGLIB动态代理）
12-19
Java提供了两种主要的动态代理实现方式：JDK动态代理和CGLIB动态代理。 **JDK动态代理**： JDK动态代理基于接口实现，也就是说，被代理的对象必须实现至少一个接口。代理机制的核心是`java.lang.reflect.Proxy`类和...
jdk动态代理和CGlib动态代理
04-13
JDK动态代理和CGlib动态代理是Java中实现这一目标的两种主要方式。 ### JDK动态代理 JDK动态代理基于Java的接口实现。如果一个类实现了至少一个接口，我们就可以为这个类创建一个动态代理。动态代理通过`java.lang....
浅谈JDK动态代理与CGLIB代理去区别
03-01
本篇文章将深入探讨JDK动态代理和CGLIB代理的区别，以及它们在实际应用中的选择。 首先，JDK动态代理主要依赖于java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。Proxy类用于创建一个代理对象...
spring事务详细讲解-深入浅出
小电玩
09-08 473
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1458
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
yang_brother的博客
09-10 530
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
【学习笔记】手写 Tomcat 三
最新发布
LearnTech_123的博客
09-12 574
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
自定义Stater
m0_63624484的博客
09-07 724
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 550
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于SpringBoot的旅游管理系统
heye0910032的博客
09-08 435
随着科技的发展，旅游管理系统的信息化成为提升旅游服务效率的关键。本系统采用JSP技术和SpringBoot框架，结合MySQL数据库，旨在实现一个功能全面、操作简便、安全可靠的旅游管理平台。系统通过需求分析、系统设计、功能实现和测试，确保了良好的用户体验和数据处理能力，为旅游业务的现代化管理提供了强有力的技术支持。本研究成功开发了一个基于SpringBoot的旅游管理系统，该系统通过集成多种旅游管理功能，显著提高了旅游服务的效率和质量。系统的用户友好界面和强大的后端功能，使得管理员和用户都能从中受益。
Linux服务器Java启动脚本
Jack魏
09-08 553
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
MyBatis面试
Tony_yitao的博客
09-09 690
MyBatis面试
jdk动态代理和cglib动态代理
09-20
jdk动态代理和cglib动态代理是Java中常用的两种动态代理方式。jdk动态代理是基于接口实现的代理方式，而cglib动态代理则是基于继承实现的代理方式。 在jdk动态代理中，代理类通过实现InvocationHandler接口，并重写invoke方法来实现对目标对象方法的代理。通过Proxy类的newProxyInstance方法，可以动态地在运行时生成代理类对象。 相比之下，cglib动态代理则是通过创建目标对象的子类来实现代理。在cglib动态代理中，代理类通过继承Enhancer类，并重写intercept方法来实现对目标对象方法的代理。通过Enhancer类的create方法，可以动态地在运行时生成代理类对象。 jdk动态代理和cglib动态代理的区别在于： 1. jdk动态代理只能代理实现了接口的类，而cglib动态代理可以代理没有实现接口的类。 2. jdk动态代理是通过创建代理对象的接口来实现代理的，而cglib动态代理是通过创建目标对象的子类来实现代理的。 3. jdk动态代理的性能相对较好，但只能代理接口方法，而cglib动态代理的性能相对较差，但可以代理普通类的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十⑧

你的鼓励将是我创作的最大动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值