Java模式中的静态代理与动态代理

最新推荐文章于 2024-07-14 14:59:27 发布
最新推荐文章于 2024-07-14 14:59:27 发布
阅读量1.1k 收藏
点赞数 1
文章标签： java primitive interface class parameters wrapper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun2445067/article/details/6492191
版权

某些接口的实现类，我们要做一个代理，来代理对这些实现类对象的方法调用。


该类的简单代理


使用代理的原因

public  class  SomeClassImpl  {
  private String userName;  
  public SomeClassImpl(final String userName) {
    this.userName = userName;
  }    
    public void someMethod( ) {
    System.out.println(this.userName);
  }
  public void someOtherMethod(final String text) {
    System.out.println(text);
  }
}

 

public  class  SomeClassProxy  {
  private final SomeClassImpl impl;
  public SomeClassProxy(final SomeClassImpl impl) {
    this.impl = impl;
  }

  public void someMethod( ) {
    this.impl.someMethod( );
  }
  public void someOtherMethod(String text) {
    this.impl.someOtherMethod(text);
  }
}

 

有一些原因，你需要做代理来在你的应用和实现类之间插入一些有用的代码。
1.实现类的源码不能拿到。比如第三方实现的。
2.有时代理要添加的代码与实现类的功能没有直接联系，不能将那些代码放入实现者内部，会破化一种对象应该只实现一个概念。
3.实现者所展现出来的特点应该对各种用户做隐藏。
4.你可能想隐藏实现方法的名字给用户，出于一些安全的考虑。这需要代理有一个特殊的面貌，也就是方法名与真正实现者的方法名不同。
5.也许要的功能依赖于对象所在的上下文。例如，如果计算机连接到工厂的机械手臂，不需要网络代码来访问手臂，但是工厂的另一端确实需要这段代码。
6.也许这些功能只是用于在开发阶段。例如，你能使用一个代理来实现程序的跟踪，来记录对象的调用次数。这代码在真正部署时不需要。

7.实现者的位置或许是变化的，就好像企业编程。对象进行实际的操作在企业级网络中，经常更换位置取决于负载平衡和故障转移。你可能需要一个智能的代理定位该对象来提供服务给其他用户。

工厂的应用

获得一个代理，经常通过一个工厂对象获得。使用工厂的原因是因为你不用特别关心哪一种实现者来实现你的功能，只要他们能正确实现就好了。


 

public  class  SomeClassFactory  {
  public final static SomeClassProxy getProxy( ) {
  SomeClassImpl impl = new SomeClassImpl(System.getProperty("user.name"));
    return new SomeClassProxy(impl);
  }
}

 

public  class  DemoProxyFactory  {
  public static final void main(final String[] args) {
    SomeClassProxy proxy = SomeClassFactory.getProxy( );
    proxy.someMethod( );
    proxy.someOtherMethod("Our Proxy works!");
  }
}



代理与接口

 

用户有时并不想知道实现的具体细节，也就是到底是代理还是真正实现者完成的功能。如果像上面的工厂类的实现，用户必须知道什么情况下，使用何种代理，这对于用户的使用提高了难度。需要特殊方法来引用合适的代理，Java的接口就使用用于解决这样的问题。

为了隔离实现代理的细节，你能使用接口来描述功能。


 

public  interface  SomeClass  {
  [public abstract] void someMethod( );
  [public abstract] void someOtherMethod(final String text);
}

 

public  class  SomeClassImpl  implements  SomeClass  {
  // same as before
}


 

public  class  SomeClassProxy  implements  SomeClass  {
  // same as before
}

public  class  SomeClassCountingProxy  implements  SomeClass  {
  // same as before
}


 

public  class  SomeClassFactory  {
  public static final SomeClass getSomeClassProxy( ) {
      SomeClassImpl impl = new SomeClassImpl(System.getProperty("user.name"));
if (LOGGER.isDebugEnabled( )) {
          return new SomeClassCountingProxy(impl);      
      } else {
          return new SomeClassProxy(impl);      
      }
  }
}


使用

 

public  class  DemoInterfaceProxy  {
  public static final void main(final String[] args) {
    SomeClass proxy = SomeClassFactory.getSomeClassProxy( );
    proxy.someMethod( );
    proxy.someOtherMethod("Our Proxy works!");
  }
}



 

提示

if (proxy instanceof SomeClassCountingProxy) {

静态代理的缺点
 System.out.println(((SomeClassCountingProxy)proxy).getInvocationCount());
}

一个静态代理的实例代码：

 

public  class  SomeClassCountingProxy  {
  private final SomeClassImpl impl;
  private int invocationCount = 0;
  public SomeClassCountingProxy(final SomeClassImpl impl) {
    this.impl = impl;
  }
  public int getInvocationCount( ) {
    return invocationCount;
  }
  public void someMethod( ) {
    this.invocationCount++;
    this.impl.someMethod( );
  }
  public void someOtherMethod(String text) {
    this.invocationCount++;
    this.impl.someOtherMethod(text);
  }
}

 

当给不同的对象，编写相同功能的代理类时，会发现需要做很多相同的工作，产生很多相同的代码。例如，都是对实现对象的调用进行计数，对于不同对象，要有不同的代理，但是实际上，他们的逻辑是一样的。这么多代码不容易维护，一个改了，所有的都要修改，是很可怕的。
动态代理，主要使用反射来实行。

主要工作是实现一个InvocationHandler，他会截住对实现者的调用，进行一些逻辑，这时在将请求发给实现者，一旦实现者返回，invocationhandler也返回结果。


 

public  class  MethodCountingHandler  implements  InvocationHandler  {
  private final Object impl;
  private int invocationCount = 0;
  public MethodCountingHandler(final Object impl) {
    this.impl = impl;
  }
  public int getInvocationCount( ) {
    return invocationCount;
  }
  public Object invoke(Object proxy, Method meth, Object[] args)
                throws Throwable {
    try {
      this.invocationCount++;
      Object result = meth.invoke(impl, args);
      return result;
    } catch (final InvocationTargetException ex) {
      throw ex.getTargetException( );
    }
  }
}

 

这代理提供着与静态代理相同的功能。然而，他使用反射来完成工作的，当用户执行代理的方法时，invocation handler被替换成实现者来被调用。在其内部增加了invocationCount的值并转发调用给实现者通过调用Method对象的invoke()方法。一旦调用完成，实现将会返回一个value给handler。可以将value返回给调用者。
When writing invocation handlers, be careful of methods that return primitive types. The JDK will wrap primitive types in their corresponding wrapper types to return them from a reflexive invocation. The problem is that your handler can return null, but the actual method being called on the implementation cannot. Therefore, if you try to return null after calling a method that returns a primitive, the proxy class will throw a NullPointerException. This NullPointerException applies to the return value, not to the parameters of the method.

可以在invoke方法中加入复杂的逻辑。

得到一个实现者接口的实现者（这里当然就是那个动态代理对象），通过工厂。


 

public  class  SomeClassFactory  {
  public static final SomeClass getDynamicSomeClassProxy( ) {
    SomeClassImpl impl = new SomeClassImpl(System.getProperty("user.name"));
    InvocationHandler handler = new MethodCountingHandler(impl);
    Class[] interfaces = new Class[] { SomeClass.class };
    ClassLoader loader = SomeClassFactory.class.getClassLoader( );
    SomeClass proxy = (SomeClass)Proxy.newProxyInstance(loader, 
                                                        interfaces, 
                                                        handler);
    return proxy;
  }
}



 

In this version of the factory method, SomeClass is an interface implemented by the actual implementation, named SomeClassImpl. This allows you to tell the Proxy class to generate a new proxy that implements the interface SomeClass and uses the invocation handler.
 
One limitation of this system is that the implementation class must implement the interfaces used in the proxy. Therefore, if the implementation did not implement the interface in the first place and the source code is out of your control, this paradigm won't work.

 

public class DemoDynamicProxy {
  public static final void main(final String[] args) {
    SomeClass proxy = SomeClassFactory.getDynamicSomeClassProxy( );
    proxy.someMethod( );
    proxy.someOtherMethod("Our Proxy works!");
  }  
}

 

InvocationHandler handler = Proxy.getInvocationHandler(proxy);
if (handler instanceof MethodCountingHandler) {
 System.out.println(((MethodCountingHandler)handler).getInvocationCount( ));
}

===========================================================================================
 某些接口的实现类，我们要做一个代理，来代理对这些实现类对象的方法调用。

 

 

package  com.ljl.proxy;

 import  java.lang.reflect.InvocationHandler;
 import  java.lang.reflect.Method;
 import  java.lang.reflect.Proxy;
 import  java.util.List;
 import  java.util.Vector;

 public  class  VectorProxy  implements  InvocationHandler {

    private Object proxyobj;
    public VectorProxy(Object obj) {
        super();
        this.proxyobj = obj;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        System.out.println("before calling " + method);
        if(args!=null)
        {
            for(int i = 0; i < args.length;i++)
            {
                System.out.println(args[i]+" ");
            }
        }
        Object o = method.invoke(proxyobj,args);        
        System.out.println("after calling " + method);
        
        return o;
    }
    
    public static Object factory(Object obj)
    {
        Class cls = obj.getClass();
        return Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),new VectorProxy(obj));
    }
    
    public static void main(String[] args)
    {
        List v = null;
        v = (List)factory(new Vector(10));
        v.add("ljl");
        v.add("hus");
    }

}

 

public class SomeClassImpl {
  private String userName;  
  public SomeClassImpl(final String userName) {
    this.userName = userName;
  }    
    public void someMethod( ) {
    System.out.println(this.userName);
  }
  public void someOtherMethod(final String text) {
    System.out.println(text);
  }
}

该类的简单代理

 

 

public class SomeClassProxy {
  private final SomeClassImpl impl;
  public SomeClassProxy(final SomeClassImpl impl) {
    this.impl = impl;
  }

  public void someMethod( ) {
    this.impl.someMethod( );
  }
  public void someOtherMethod(String text) {
    this.impl.someOtherMethod(text);
  }
}

使用代理的原因

 

有一些原因，你需要做代理来在你的应用和实现类之间插入一些有用的代码。
1.实现类的源码不能拿到。比如第三方实现的。
2.有时代理要添加的代码与实现类的功能没有直接联系，不能将那些代码放入实现者内部，会破化一种对象应该只实现一个概念。
3.实现者所展现出来的特点应该对各种用户做隐藏。
4.你可能想隐藏实现方法的名字给用户，出于一些安全的考虑。这需要代理有一个特殊的面貌，也就是方法名与真正实现者的方法名不同。
5.也许要的功能依赖于对象所在的上下文。例如，如果计算机连接到工厂的机械手臂，不需要网络代码来访问手臂，但是工厂的另一端确实需要这段代码。
6.也许这些功能只是用于在开发阶段。例如，你能使用一个代理来实现程序的跟踪，来记录对象的调用次数。这代码在真正部署时不需要。

7.实现者的位置或许是变化的，就好像企业编程。对象进行实际的操作在企业级网络中，经常更换位置取决于负载平衡和故障转移。你可能需要一个智能的代理定位该对象来提供服务给其他用户。

工厂的应用

获得一个代理，经常通过一个工厂对象获得。使用工厂的原因是因为你不用特别关心哪一种实现者来实现你的功能，只要他们能正确实现就好了。


 

public class SomeClassFactory {
  public final static SomeClassProxy getProxy( ) {
  SomeClassImpl impl = new SomeClassImpl(System.getProperty("user.name"));
    return new SomeClassProxy(impl);
  }
}

 

public class DemoProxyFactory  {
  public static final void main(final String[] args) {
    SomeClassProxy proxy = SomeClassFactory.getProxy( );
    proxy.someMethod( );
    proxy.someOtherMethod("Our Proxy works!");
  }
}



代理与接口

 

用户有时并不想知道实现的具体细节，也就是到底是代理还是真正实现者完成的功能。如果像上面的工厂类的实现，用户必须知道什么情况下，使用何种代理，这对于用户的使用提高了难度。需要特殊方法来引用合适的代理，Java的接口就使用用于解决这样的问题。

为了隔离实现代理的细节，你能使用接口来描述功能。

 

public interface SomeClass {
  [public abstract] void someMethod( );
  [public abstract] void someOtherMethod(final String text);
}

 

 

public class SomeClassImpl implements SomeClass  {
  // same as before
}


 

public class SomeClassProxy implements SomeClass  {
  // same as before
}

public class SomeClassCountingProxy implements SomeClass  {
  // same as before
}


 

public class SomeClassFactory  {
  public static final SomeClass getSomeClassProxy( ) {
      SomeClassImpl impl = new SomeClassImpl(System.getProperty("user.name"));
if (LOGGER.isDebugEnabled( )) {
          return new SomeClassCountingProxy(impl);      
      } else {
          return new SomeClassProxy(impl);      
      }
  }
}


使用

 

public class DemoInterfaceProxy  {
  public static final void main(final String[] args) {
    SomeClass proxy = SomeClassFactory.getSomeClassProxy( );
    proxy.someMethod( );
    proxy.someOtherMethod("Our Proxy works!");
  }
}



 

提示

if (proxy instanceof SomeClassCountingProxy) {

静态代理的缺点
 System.out.println(((SomeClassCountingProxy)proxy).getInvocationCount());
}

一个静态代理的实例代码：

public class SomeClassCountingProxy {
  private final SomeClassImpl impl;
  private int invocationCount = 0;
  public SomeClassCountingProxy(final SomeClassImpl impl) {
    this.impl = impl;
  }
  public int getInvocationCount( ) {
    return invocationCount;
  }
  public void someMethod( ) {
    this.invocationCount++;
    this.impl.someMethod( );
  }
  public void someOtherMethod(String text) {
    this.invocationCount++;
    this.impl.someOtherMethod(text);
  }
}

 

当给不同的对象，编写相同功能的代理类时，会发现需要做很多相同的工作，产生很多相同的代码。例如，都是对实现对象的调用进行计数，对于不同对象，要有不同的代理，但是实际上，他们的逻辑是一样的。这么多代码不容易维护，一个改了，所有的都要修改，是很可怕的。
动态代理，主要使用反射来实行。

主要工作是实现一个InvocationHandler，他会截住对实现者的调用，进行一些逻辑，这时在将请求发给实现者，一旦实现者返回，invocationhandler也返回结果。

 

public class MethodCountingHandler implements InvocationHandler {
  private final Object impl;
  private int invocationCount = 0;
  public MethodCountingHandler(final Object impl) {
    this.impl = impl;
  }
  public int getInvocationCount( ) {
    return invocationCount;
  }
  public Object invoke(Object proxy, Method meth, Object[] args)
                throws Throwable {
    try {
      this.invocationCount++;
      Object result = meth.invoke(impl, args);
      return result;
    } catch (final InvocationTargetException ex) {
      throw ex.getTargetException( );
    }
  }
}

 

 

这代理提供着与静态代理相同的功能。然而，他使用反射来完成工作的，当用户执行代理的方法时，invocation handler被替换成实现者来被调用。在其内部增加了invocationCount的值并转发调用给实现者通过调用Method对象的invoke()方法。一旦调用完成，实现将会返回一个value给handler。可以将value返回给调用者。
When writing invocation handlers, be careful of methods that return primitive types. The JDK will wrap primitive types in their corresponding wrapper types to return them from a reflexive invocation. The problem is that your handler can return null, but the actual method being called on the implementation cannot. Therefore, if you try to return null after calling a method that returns a primitive, the proxy class will throw a NullPointerException. This NullPointerException applies to the return value, not to the parameters of the method.

可以在invoke方法中加入复杂的逻辑。

得到一个实现者接口的实现者（这里当然就是那个动态代理对象），通过工厂。


 

public class SomeClassFactory {
  public static final SomeClass getDynamicSomeClassProxy( ) {
    SomeClassImpl impl = new SomeClassImpl(System.getProperty("user.name"));
    InvocationHandler handler = new MethodCountingHandler(impl);
    Class[] interfaces = new Class[] { SomeClass.class };
    ClassLoader loader = SomeClassFactory.class.getClassLoader( );
    SomeClass proxy = (SomeClass)Proxy.newProxyInstance(loader, 
                                                        interfaces, 
                                                        handler);
    return proxy;
  }
}



 

In this version of the factory method, SomeClass is an interface implemented by the actual implementation, named SomeClassImpl. This allows you to tell the Proxy class to generate a new proxy that implements the interface SomeClass and uses the invocation handler.
 
One limitation of this system is that the implementation class must implement the interfaces used in the proxy. Therefore, if the implementation did not implement the interface in the first place and the source code is out of your control, this paradigm won't work.
public class DemoDynamicProxy {
  public static final void main(final String[] args) {
    SomeClass proxy = SomeClassFactory.getDynamicSomeClassProxy( );
    proxy.someMethod( );
    proxy.someOtherMethod("Our Proxy works!");
  }  
}

 

InvocationHandler handler = Proxy.getInvocationHandler(proxy);
if (handler instanceof MethodCountingHandler) {
 System.out.println(((MethodCountingHandler)handler).getInvocationCount( ));
}

===========================================================================================
 
package com.ljl.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.List;
import java.util.Vector;

public class VectorProxy implements InvocationHandler{

    private Object proxyobj;
    public VectorProxy(Object obj) {
        super();
        this.proxyobj = obj;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        System.out.println("before calling " + method);
        if(args!=null)
        {
            for(int i = 0; i < args.length;i++)
            {
                System.out.println(args[i]+" ");
            }
        }
        Object o = method.invoke(proxyobj,args);        
        System.out.println("after calling " + method);
        
        return o;
    }
    
    public static Object factory(Object obj)
    {
        Class cls = obj.getClass();
        return Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),new VectorProxy(obj));
    }
    
    public static void main(String[] args)
    {
        List v = null;
        v = (List)factory(new Vector(10));
        v.add("ljl");
        v.add("hus");
    }

}
sun2445067
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
Java设计模式——代理设计模式（静态代理和动态代理）
04-15
代理设计模式分为静态代理和动态代理两种类型。 ### 静态代理 静态代理是在编译时就已经确定了代理关系，代理类和真实类的关系是硬编码在代理类中的。下面我们将详细介绍静态代理的实现方式： 1. **定义接口**：...
Java 代理 代理模式 静态代理与动态代理 常见的动态代理实现 .md
08-11
- 静态代理与动态代理 - 常见的动态代理实现 - JDK Proxy - CGLIB - JDK Proxy 和 CGLIB 的对比 - 动态代理的实际应用 - Spring AOP 说在前面：今天我们来聊一聊 Java 中的代理，先来聊聊故事背景： 小明想...
Testng 测试框架源码阅读（二）
lxlmycsdnfree的博客
02-07 1434
surefire接着调入testng中的方法，testNG.run -> runSuites -> runSutiesLocally -> runSuitesSequentially -> SuiteRunnerWorker.run -> runSuites -> SuiteRunner.run -> privateRun -> invokeTestMethods  ->test
java基础-静态代理与动态代理
qq_27246079的博客
08-16 2673
再说一个真实场景帮助大家理解，当我们进行Android开发时会用到网络请求框架，比如最早使用的是Volley框架，之后我想换成okhttp框架，如果之前是强关联（即在业务代码中直接引用Volley），想要做框架替换无疑是痛苦的，如果在设计之初，我们写了一个代理层则可以快速进行框架转换，哪怕将来要求替换为Retrofit也会毫不费力，代理模式可以增强我们代码的扩展性。首先需要说明的是静态代理和动态代理的思想和原理是一模一样的，只是实现代理类的方式不同。正因静态代理的缺点，由此引出动态代理。...
java 代理（静态代理、动态代理的不同实现）详解及示例
热门推荐
alanchanchn的专栏
06-13 4万+
代理模式上，基本上有Subject角色，RealSubject角色，Proxy角色。Subject角色负责定义RealSubject和Proxy角色应该实现的接口；RealSubject角色用来真正完成业务服务功能；Proxy角色负责将自身的Request请求，调用realsubject 对应的request功能来实现业务功能，自己不真正做业务。代理对象和被代理对象一般实现相同的接口，调用者与代理对象进行交互。代理的存在对于调用者来说是透明的，调用者看到的只是接口。
Java 静态代理和动态代理
涂涂写写的笔记
10-31 785
静态代理，动态代理
Java中的代理模式(动态代理和静态代理)
qq_64064246的博客
03-21 1182
我们先了解一下代理模式：在开发中，当我们要访问目标类时，不是直接访问目标类，而是访问器代理类。通过调用完成操作。简单来说就是：把直接访问变为间接访问。比如说：我们可以在方法开始和结束前记录日志：在方法执行前进行额外的参数校验，进行事务管理，如手动提交、权限校验等。代理模式是一种设计思想，实际实现方式上有和之分。
[Java]静态代理与动态代理（基于JDK1.8）
进步*于辰的博客
04-02 1万+
本篇文章主要是对静态代理和动态代理实现思路的简述，以示例为主，少涉及理论。 如果文中阐述不全或不对的，多多交流。
Java静态代理和动态代理（代理模式）详解
_Hihi_的博客
05-12 3566
1、代理模式 代理模式是一种比较好理解的设计模式。简单来说就是 我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。 代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。 代理模式有静态代理和动态代理两种实现方式。 2、静态代理 静态代理中，我们对目标对象的每个方法的增强都是手动完成的（后面会具体演示代码），非常不灵活（比如接口一旦新增加方法，目标对象和代理
java动态代理与静态代理的区别
shinecjj的博客
10-03 935
动态代理
java中的代理模式
weixin_39038328的博客
03-13 1044
java代理模式的学习：静态代理、JDK动态代理、CGLIB动态代理
一篇文章让你搞懂Java中的静态代理和动态代理
阿杰的博客
10-17 1735
代理模式是常用的java设计模式，在Java中我们通常会通过new一个对象再调用其对应的方法来访问我们需要的服务。代理模式则是通过创建代理类（proxy）的方式间接地来访问我们需要的服务。举一个生活中的例子：像我们在网上通过中介租到其背后房东的房子，因为房东也嫌麻烦想省事，此时中介就相当于代理而房东则是被代理，两者是分开的，这样我们就不会直接访问到房东，大部分情况下在中介手中租到的房子都会比原价要贵一些，这好比代理的作用，即不需要通过房东。
Java代理模式模板代码，包含动态代理与静态代理
07-31
总结，Java代理模式提供了两种实现方式，静态代理适用于代理类数量较少且不需要频繁改动的情况，而动态代理则更加灵活，适用于代理类数量多或者需要动态改变代理行为的场景。了解并熟练运用这两种代理模式，可以极大...
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...
Java设计模式：静态代理、装饰者、动态代理详解
12-21
总结来说，代理模式在Java中主要用于在调用实际对象时添加额外的功能，而静态代理、装饰者和动态代理则是三种不同的实现方式。静态代理简单直观，但需要手动编写代理类；装饰者模式更注重扩展对象功能；动态代理则...
配置Java开发环境
Broken_x的博客
07-10 1522
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 495
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
最新发布
persistence_PSH的博客
07-14 674
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 605
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
《剑指offer》Java代理.pdf
01-04
代理可以分为静态代理和动态代理两种类型： 1. 静态代理： - 优点：静态代理的代码结构清晰，实现相对简单。当代理类和目标类的接口已知时，可以直接编写代理类来实现对目标对象的控制。 - 缺点：静态代理的局限...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值