简单了解静态代理，JDK提供的动态代理和cglib的动态代理

最新推荐文章于 2024-09-02 20:28:23 发布
最新推荐文章于 2024-09-02 20:28:23 发布
阅读量71 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/xiaoyoung/blog/3032659
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

静态代理：

定义一个公共接口和公共方法，

package proxy;

public interface Work {
	void sayHello();

	String getName();
}

创建一个被代理类，实现公共接口和方法；

package proxy;

public class People implements Work {

	@Override
	public void sayHello() {
		System.out.println("my name is A");
	}

	@Override
	public String getName() {

		return "A";
	}

}

创建一个代理类，实现公共接口和方法，这样它们就具有了相同的方法。 

代理类中，需要持有一个被代理类对象，可以当做代理类的成员变量，在代理类的构造方法中传入并赋值。

package proxy;

public class StaticProxyPeople implements Work {
	People A = new People();

	public StaticProxyPeople(People A) {
		this.A = A;
	}

	@Override
	public void sayHello() {
		System.out.println("代理方法开始：");
		A.sayHello();
		System.out.println("代理方法结束。");
	}

	@Override
	public String getName() {
		String name = A.getName();
		name = "代理处理过的name:" + name;
		return name;
	}

}

此时代理类和被代理类拥有相同的方法，然后在代理类的方法中，可以调用被代理类的方法，达到操作被代理类的目的。而在调用方法前后，又可以定义自己的特殊逻辑。

package proxy;

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

public class Test {
	public static void main(String[] args) {

		People people = new People();
		StaticProxyPeople staticProxyPeople = new StaticProxyPeople(people);

		staticProxyPeople.sayHello();
		System.out.println(staticProxyPeople.getName());
    }
}

输出结果：
代理方法开始：
my name is A
代理方法结束。
代理处理过的name:A

这样子当外界希望调用被代理类的方法时，可以创建一个代理类的对象，通过对代理类对象的方法的调用，达到操作被代理类对象的目的。

缺点：一个代理类，只能针对一个被代理类进行代理。

JDK实现的动态代理：

在java的动态代理机制中，有两个重要的类或接口，一个是 InvocationHandler接口、另一个则是Proxyle类，这一个类和接口是实现我们动态代理所必须用到的。

1、InvocationHandler

举例：

package proxy;

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

public class WrokHandler implements InvocationHandler {
	private Object subject; // 这个就是我们要代理的真实对象，也就是真正执行业务逻辑的类


	public WrokHandler(Object subject) {
		this.subject = subject;
	}

	/**
	 * proxy:	指代JDK动态生成的最终代理对象 
	 * method: 指代的是我们所要调用真实对象的某个方法的Method对象
	 * args:	指代的是调用真实对象某个方法时接受的参数
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		
		Object result = null;
		System.out.println("调用方法：" + method.getName()+ "之前");
		
		// 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
		result = method.invoke(subject, args);// 需要指定被代理对象和传入参数
		System.out.println("返回值：" + result);
		System.out.println("调用方法：" + method.getName()+ "之后");
		
		return result;
	}

}


package proxy;

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

public class SleepHandler implements InvocationHandler {
	private Object subject; // 这个就是我们要代理的真实对象，也就是真正执行业务逻辑的类

	public SleepHandler(Object subject) {
		this.subject = subject;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object result = null;
		System.out.println("SleepHandler.invoke 调用方法：" + method.getName() + "之前");

		// 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
		result = method.invoke(subject, args);// 需要指定被代理对象和传入参数
		System.out.println("SleepHandler.invoke 返回值：" + result);
		System.out.println("SleepHandler.invoke 调用方法：" + method.getName() + "之后");
		return result;
	}

}

解析：

每一个代理类都必须要实现InvocationHandler这个接口，

同时，也要持有一个被代理类真实对象。

代理类实现了InvocationHandler接口后，会重写invoke方法。

三个参数分别是：

proxy:    指代JDK动态生成的最终代理对象 

method: 指代的是我们所要调用真实对象的某个方法的Method对象

args:    指代的是调用真实对象某个方法时接受的参数

 

而在invoke方法中，我们通过method.invoke(subject, args); 来调用真实被代理对象的方法。

简单来说，就是当定义了以上WorkHandler后，对代理类对象方法的调用，都会由invoke方法来处理，才会传达到被代理对象。

2.Proxy

举例：

package proxy;

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

public class Test {
	public static void main(String[] args) {
		// 被代理的对象
		People A = new People();

		// 创建代理对象，代理对象持有一个被代理对象
		InvocationHandler handler = new WrokHandler(A);
		
		// 获得被代理类的，类加载器Classloader
		// 作用：
		// 负责将 Class 加载到 JVM 中
		// 审查每个类由谁加载（父优先的等级加载机制）
		// 将 Class 字节码重新解析成 JVM 统一要求的对象格式
		ClassLoader loader = A.getClass().getClassLoader();
		
		// 获得被代理类 实现的所有接口
		Class[] interfaces = A.getClass().getInterfaces();

		// 需要指定类装载器、一组接口及调用处理器生成动态代理类实例
		Work proxy = (Work) Proxy.newProxyInstance(loader, interfaces, handler);
		
		System.out.println("动态代理对象的类型：" + proxy.getClass().getName());
		proxy.sayHello();
		System.out.print(proxy.getName());
		
		
		InvocationHandler handler1 = new SleepHandler(A);
		Sleep proxy1 = (Sleep) Proxy.newProxyInstance(loader, interfaces, handler1);
		System.out.println("动态代理对象的类型：" + proxy.getClass().getName());
		proxy1.goToSleep();
		proxy1.getUp();

	}
}

输出结果：
动态代理对象的类型：$Proxy0
调用方法：sayHello之前
my name is A
返回值：null
调用方法：sayHello之后
调用方法：getName之前
返回值：A
调用方法：getName之后
A动态代理对象的类型：$Proxy0
SleepHandler.invoke 调用方法：goToSleep之前
i am go to sleep
SleepHandler.invoke 返回值：null
SleepHandler.invoke 调用方法：goToSleep之后
SleepHandler.invoke 调用方法：getUp之前
i am get up
SleepHandler.invoke 返回值：null
SleepHandler.invoke 调用方法：getUp之后

解析：

代理类同样需要持有一个真实代理对象

当我们希望创建一个代理类实例时，需要调用 Proxy.newProxyInstance(loader, interfaces, handler);方法

三个参数：

loader 被代理对象的类加载器，这里存有真实对象的父类，子类关系，和其他类的优先加载关系等等。

interfaces 被代理对象实现的所有接口，JDK提供的动态代理，说白了，就是让代理类也去实现被代理类的所有接口，重写被代理类的所有方法来实现的。

handler 我们自定义的代理类实例，它实现了InvocationHandler接口。用来处理Proxy中所有方法的调用 

首先解释一下JDK动态代理的大致流程，JDK主要会做以下工作： 

  1. 创建一个被代理类的实例
  2. 通过被代理类的实例，获取被代理类的加载器，和实现所有接口
  3. 调用Proxy.newProxyInstance()方法，需要传入被代理类的加载信息和它实现的接口信息，还有一个handler实例，这个实例决定创建出的代理类实例，在代理过程中，走哪个InvocationHandler实例的invoke方法，传入是的哪个handler实例，就走哪个实例的invoke方法。
  4. 同时Proxy类，也在代码中动态创建该代理类的字节码； 即代理类是在jvm的运行中创建的。  将对应的字节码转换为对应的class 对象； 
  5. Proxy 的class对象 以传入的handler对象为参数，实例化一个代理类对象；
  6. 在接收实例化的代理类对象时，我们无法具体指导代理类对象的类名，只能将它向上造型为某个业务接口，即我们希望代理类实例，能代理哪些方法，我就让它强转为哪个接口类型。我们希望代理类实例，在代理过程中，执行哪些特定逻辑，我们在Proxy.newProxyInstance()方法中传入哪个handler实例。

整理一下逻辑：

代理类实例创建之前，需要传入一个自定义的handler实例，而自定义的handler类需要实现InvocationHandler接口，重写invoke方法，在重写的invoke方法中，增加自定义逻辑。

代理类实例创建时，是Proxy.newInstance(loader, interface[], handler)方法根据传入的被代理类的类加载器信息，实现的所有接口，在jvm中动态的生成字节码文件和.class文件。

代理类实例创建后，又需要强转类型，向上造型为被代理类的某个接口类型，强制转换的是被代理类实现的某个接口类型，就可以调用这个接口的方法。如果强转的类型不是被代理类实现过的，就会有异常。

问题：

JDK是如何生成最终的代理类的，其实最根本的是通过动态生成代理类的字节码，然后通过这些字节码实现代理类的生成。

byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces);

public static byte[] generateProxyClass(final String name,  
                                           Class[] interfaces)  
   {  
       ProxyGenerator gen = new ProxyGenerator(name, interfaces);  
    // 这里动态生成代理类的字节码
       final byte[] classFile = gen.generateClassFile();  

    // 如果saveGeneratedFiles的值为true，则会把所生成的代理类的字节码保存到硬盘上  
       if (saveGeneratedFiles) {  
           java.security.AccessController.doPrivileged(  
           new java.security.PrivilegedAction<Void>() {  
               public Void run() {  
                   try {  
                       FileOutputStream file =  
                           new FileOutputStream(dotToSlash(name) + ".class");  
                       file.write(classFile);  
                       file.close();  
                       return null;  
                   } catch (IOException e) {  
                       throw new InternalError(  
                           "I/O exception saving generated file: " + e);  
                   }  
               }  
           });  
       }  

    // 返回代理类的字节码  
       return classFile;  
   }

代理类实例是怎么调用hanler的invoke方法的？我们来看一下代理类的class文件

 public final void hello(String paramString)
  {
    try
    {
      this.h.invoke(this, m3, new Object[] { paramString });
      //就是调用我们自定义的InvocationHandlerImpl的 invoke方法：
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

注意这里的this.h.invoke中的h，它是类Proxy中的一个属性

 protected InvocationHandler h;

因为这个代理类继承了Proxy，所以也就继承了这个属性，而这个属性值就是我们定义的

InvocationHandler handler = new InvocationHandlerImpl(realSubject);

同时我们还发现，invoke方法的第一参数在底层调用的时候传入的是this，也就是最终生成的代理对象ProxySubject，这是JVM自己动态生成的，而不是我们自己定义的代理对象。

JDK的动态代理通过ProxyGenerator.generateProxyClass()生成代理类的字节码，由Proxy.defineClass0()加载，可以看到这个代理类 extends Proxy implements Interface1, ... {...}。

而在代理类中，与Proxy有关的只有Proxy的变量protected InvocationHandler h;这个InvocationHandler实例的引用，在调用接口方法时实际调用的是super.h.invoke(this, method, args)。

缺点：使用JDK动态代理，目标类必须实现的某个接口，如果某个类没有实现接口则不能生成代理对象。

 

CGLIB

(Code Generation Library)是一个开源项目,是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口，通俗说cglib可以在运行时动态生成字节码。

使用cglib完成动态代理，大概的原理是：cglib继承被代理的类，重写方法，织入通知，动态生成字节码并运行，因为是继承所以final类和方法是没有办法动态代理的。具体实现如下

创建被代理类：

package proxy;

public class Person {
	public void sayHello() {
		System.out.println("my name is Person");
	}

	public String getName() {

		return "Person";
	}
}

创建代理类：

package proxy;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/*
 * 动态代理类
 * 实现了一个方法拦截器接口
 */
public class CglibProxyIntercepter implements MethodInterceptor {

	/*
	 * sub：cglib生成的代理对象，method：被代理对象方法，objects：方法入参，methodProxy:代理方法
	 */
	@Override
	public Object intercept(Object proxy, Method method, Object[] args,
			MethodProxy methodProxy) throws Throwable {
		System.out.println("执行前...");
		// 调用方法
		Object result = methodProxy.invokeSuper(proxy, args);
		System.out.println("执行后...");
		return result;
	}

	// 返回目标对象的代理对象
	public Object newProxy(Object target) {
		// 增强类，用于生成代理类的class文件
		Enhancer enhancer = new Enhancer();
		// 设置代理类的父类为被代理类
		enhancer.setSuperclass(target.getClass());
		// 设置代理类的回调方法，即这里指定了哪个类，就会执行哪个类的intercept方法
		enhancer.setCallback(this);
		// 设置被代理类的加载器，保证生成类的顺序和关系
		enhancer.setClassLoader(target.getClass().getClassLoader());
		// 生成代理类并返回实例
		return enhancer.create();
	}

}

解析：

所有的代理类，都需要实现MethodIntercpet接口，重写 intercept()方法，在方法中编写自定义逻辑。

且通过methodProxy.invokeSuper()方法执行被代理类方法。

Enhancer是一个增强类，通过设置被代理类为superClass，并指定由哪个方法拦截器来成为回调函数callBack，在调用creat()方法，动态生成代理类实例。

public class Test {
	public static void main(String[] args) {
		Person test = new Person();
		CglibProxyIntercepter methodIntercpt= new CglibProxyIntercepter();
		Person proxy2 = (Person) methodIntercpt.newProxy(test);
		proxy2.sayHello();
		proxy2.getName();
}
}


输出结果：
执行前...
my name is Person
执行后...
执行前...
执行后...

代理类实例也需要强制转型，才可以使用。可以转型为被代理类类型，和被代理类的接口类型，父类型。因为代理类是被代理类的子类。

生成代理类：

下面的源码是粘贴别人的，我们来看一下，生成一个代理类会生成三个class文件

1289596-20180122143632647-49186095.png

public class PersonService$$EnhancerByCGLIB$$eaaaed75
  extends PersonService
  implements Factory
{
  private boolean CGLIB$BOUND;
  private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
  private static final Callback[] CGLIB$STATIC_CALLBACKS;
  private MethodInterceptor CGLIB$CALLBACK_0;//拦截器
  private static final Method CGLIB$setPerson$0$Method;//被代理方法
  private static final MethodProxy CGLIB$setPerson$0$Proxy;//代理方法
  private static final Object[] CGLIB$emptyArgs;
  private static final Method CGLIB$finalize$1$Method;
  private static final MethodProxy CGLIB$finalize$1$Proxy;
  private static final Method CGLIB$equals$2$Method;
  private static final MethodProxy CGLIB$equals$2$Proxy;
  private static final Method CGLIB$toString$3$Method;
  private static final MethodProxy CGLIB$toString$3$Proxy;
  private static final Method CGLIB$hashCode$4$Method;
  private static final MethodProxy CGLIB$hashCode$4$Proxy;
  private static final Method CGLIB$clone$5$Method;
  private static final MethodProxy CGLIB$clone$5$Proxy;
  
  static void CGLIB$STATICHOOK1()
  {
    CGLIB$THREAD_CALLBACKS = new ThreadLocal();
    CGLIB$emptyArgs = new Object[0];
    Class localClass1 = Class.forName("com.demo.proxy.cglib.PersonService$$EnhancerByCGLIB$$eaaaed75");//代理类
    Class localClass2;//被代理类PersionService
    Method[] tmp95_92 = ReflectUtils.findMethods(new String[] { "finalize", "()V", "equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;" }, (localClass2 = Class.forName("java.lang.Object")).getDeclaredMethods());
    CGLIB$finalize$1$Method = tmp95_92[0];
    CGLIB$finalize$1$Proxy = MethodProxy.create(localClass2, localClass1, "()V", "finalize", "CGLIB$finalize$1");
    Method[] tmp115_95 = tmp95_92;
    CGLIB$equals$2$Method = tmp115_95[1];
    CGLIB$equals$2$Proxy = MethodProxy.create(localClass2, localClass1, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
    Method[] tmp135_115 = tmp115_95;
    CGLIB$toString$3$Method = tmp135_115[2];
    CGLIB$toString$3$Proxy = MethodProxy.create(localClass2, localClass1, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
    Method[] tmp155_135 = tmp135_115;
    CGLIB$hashCode$4$Method = tmp155_135[3];
    CGLIB$hashCode$4$Proxy = MethodProxy.create(localClass2, localClass1, "()I", "hashCode", "CGLIB$hashCode$4");
    Method[] tmp175_155 = tmp155_135;
    CGLIB$clone$5$Method = tmp175_155[4];
    CGLIB$clone$5$Proxy = MethodProxy.create(localClass2, localClass1, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
    tmp175_155;
    Method[] tmp223_220 = ReflectUtils.findMethods(new String[] { "setPerson", "()V" }, (localClass2 = Class.forName("com.demo.proxy.cglib.PersonService")).getDeclaredMethods());
    CGLIB$setPerson$0$Method = tmp223_220[0];
    CGLIB$setPerson$0$Proxy = MethodProxy.create(localClass2, localClass1, "()V", "setPerson", "CGLIB$setPerson$0");
    tmp223_220;
    return;
  }

我们通过代理类的源码可以看到，代理类会获得所有在父类继承来的方法，并且会有MethodProxy与之对应，比如 Method CGLIB$setPerson$0$Method、MethodProxy CGLIB$setPerson$0$Proxy;

方法的调用

  //代理方法（methodProxy.invokeSuper会调用）
   final void CGLIB$setPerson$0() {
      super.setPerson();
   }
   //被代理方法(methodProxy.invoke会调用，这就是为什么在拦截器中调用methodProxy.invoke会死循环，一直在调用拦截器)
   public final void setPerson() {
      MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
      if(this.CGLIB$CALLBACK_0 == null) {
         CGLIB$BIND_CALLBACKS(this);
         var10000 = this.CGLIB$CALLBACK_0;
      }

      if(var10000 != null) {
         //调用拦截器
         var10000.intercept(this, CGLIB$setPerson$0$Method, CGLIB$emptyArgs, CGLIB$setPerson$0$Proxy);
      } else {
         super.setPerson();
      }
   }

调用过程：代理对象调用this.setPerson方法->调用拦截器->methodProxy.invokeSuper->CGLIB$setPerson$0->被代理对象setPerson方法

缺点：cglib通过继承被代理类实现代理。final修饰的类和方法，没办法代理。

转载于:https://my.oschina.net/xiaoyoung/blog/3032659

weixin_33873846
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代理模式之静态代理，JDK动态代理和cglib动态代理
烟雨星空的博客
12-27 1233
代理模式，顾名思义，就是通过代理去完成某些功能。比如，你需要购买火车票，不想跑那么远到火车站售票窗口买，可以去附近的火车票代售点买，或者到携程等第三方网站买。这个时候，我们就把火车站叫做目标对象或者委托对象，也可以叫被代理对象，而火车票代售点和携程就叫做代理对象。 一、静态代理 静态代理是最简单的代理模式。需要定义一个接口，然后委托类和代理类分别实现这个接口 //待实现的接口 public int...
cglib初步使用代理
求人不如求己
12-13 403
业务类：public class UserServiceImpl { public void add() { System.out.println("add方法！"); } public final void delete() {//final方法不能被代理，直接输出，不会输出代理中打印语句 System.out.println("delete
Java动态代理CGLIB详解
weixin_57763462的博客
06-01 721
CGLIB介绍 CGLIB(Code Generation Library)是一个开源、高性能、高质量的Code生成类库（代码生成包）。 它可以在运行期扩展Java类与实现Java接口。Hibernate用它实现PO(Persistent Object 持久化对象)字节码的动态生成，Spring AOP用它提供方法的interception（拦截）。 CGLIB的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。但不鼓励大家直接使用ASM框架，因为对底层技术要求比较高。 .
两种动态代理实现方式浅析（jdk与cglib）
itquz
03-14 616
jdk动态代理生成： /** *jdk动态代理生成代码分析 *@authorquz */ //需要继承InvocationHandler publicclassAnalysisimplementsInvocationHandler{ @Override publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable...
实战CGLib系列之proxy篇(一)：方法拦截MethodInterceptor
05-22 897
本系列文章均整理自我在先前一家公司的CGLib使用总结和笔记。分享出来，希望对看到的人有所帮助，同时欢迎大家提出宝贵意见。如需转载，请勿修改，且注明作者shensy及出处。 -------------------------------------- 实战CGLib系列文章 本篇介绍通过MethodInterceptor和Enhancer实现一个动态代理。 一、首先说一下JDK中的动态...
JDK动态代理实现原理
qq603263371的博客
09-18 88
JDK动态代理实现原理 在JDK中提供了已个Proxy的工具类，专门用于生成代理对象。但是有一个前提是要求被代理的对象必须要有实现的接口。而核心创建代理对象的方法是newProxyInstance。 newProxyInstance方法工作流程 这个方法中有一行核心代码： Class<?> cl = getProxyClass0(loader, intfs); 这行代码作用是查找或生成...
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 8193
在SpringAOP中基于动态代理实现功能的增强，也就是动态的生成代理类，在代理类中织入增强的逻辑然后调用目标对象的方法。动态代理中用的比较多的两种：JDK动态代理、CGLIB动态代理。 JDK动态代理 使用JDK的java.lang.reflect.Proxy类的newProxyInstance方法实现的代理。 用一个测试接口看下具体实现： public interface JdkProxyDemoService { void queryTrs(); } @Service public
【动态代理】—— JDK和cglib的动态代理
1+1=王的博客
03-19 3965
概述 设计模式中有一个代理模式，它为其他对象提供一种代理以控制对这个对象的访问。 关于代理模式可以参考：【每天一个java设计模式（七）】 - 代理模式：https://blog.csdn.net/weixin_43598687/article/details/122072282 代理模式是指的静态代理。使用静态代理很容易就完成了对一个类的代理操作。但是静态代理的缺点也暴露了出来：由于代理只能为一个类服务，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐。 而动态代理可以在程序运行期间，在不修改源
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...
静态代理、jdk动态代理、cglib动态代理
02-27
静态代理的优点是：它的实现方式简单易懂，易于维护和扩展。但是，它的缺点是：每个被代理的对象都需要创建一个代理类，这增加了系统的复杂度。 JDK 动态代理 JDK 动态代理是 Java 语言中的一种代理模式实现方式，...
代理模式-静态动态代理-jdk动态代理-cglib动态代理
11-12
代理模式是一种设计模式，它允许我们在不修改...Java中的静态代理、JDK动态代理和CGLIB动态代理提供了多种实现方式，满足不同场景的需求。在实际开发中，理解并灵活运用这些代理方式，可以提高代码的可维护性和扩展性。
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 3026
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1141
浅析synchronized锁升级的原理与实现
操作系统原子操作
zzt_is_me的博客
08-28 8510
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
MapStruct-Java实体转换利器
最新发布
m0_63622279的博客
09-02 383
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 5629
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 822
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 5677
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
Java代理模式详解：静态代理、JDK与CGLIB动态代理
代理模式分为静态代理、JDK动态代理和CGLIB动态代理三种实现方式，每种都有其特定的优点和应用场景。静态代理虽然效率最高但灵活性较低，适用于已明确代理类的情况。JDK动态代理基于接口，适合通用业务，如性能日志...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值