spring AbstractBeanDefinition创建bean类型是动态代理类的方式

最新推荐文章于 2024-08-05 23:51:30 发布
最新推荐文章于 2024-08-05 23:51:30 发布
阅读量179 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java
原文链接：https://yq.aliyun.com/articles/565389
本文介绍了一个具体的Spring动态代理实现案例，包括自定义的抽象类ProxyFactoryBean及其子类ProviderProxyFactoryBean，展示了如何使用Spring AOP特性来创建动态代理对象，并提供了一种注册JDK动态代理类型Bean的方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

v1.接口 Class<?> resourceClass

v2.获取builder

BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(resourceClass);

v3.获取接口对应的动态代理class

Class<?> targetProxyClass = Proxy.getProxyClass(XXX.class.getClassLoader(), new Class[]{resourceClass});

v4.targetProxyClass构造参数类型 InvocationHandler，通过builder设置

   builder.addConstructorArgValue(Proxy.getInvocationHandler(xxxProxyBean) 或者 new InvocationHandler(){...});

　AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();

   beanDefinition.setBeanClass(targetProxyClass);

   registry.registerBeanDefinition("beanName", beanDefinition);

 

v5.记录一下自己曾经写的一个例子

v5.1 抽象类ProxyFactoryBean

复制代码
package com.hjzgg.apigateway.soa.proxy;

import com.hjzgg.apigateway.soa.exceptions.SoaException;
import com.hjzgg.apigateway.soa.proxy.consumer.ConsumerProxyFactoryBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.util.ClassUtils;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Created by hujunzheng on 2017/7/7.
 */
public abstract class ProxyFactoryBean implements FactoryBean {

    protected Class<?> selfDynamicProxyClass;//代理类
    protected Class<?> resourceClass;//接口类
    protected String version;//dubbo 版本
    protected String group;//dubbo 分组
    protected Object proxy;//代理对象
    protected Method createProxyMethod;

    public ProxyFactoryBean(Class<?> selfDynamicProxyClass, Class<?> resourceClass, String version, String group) throws SoaException {
        if (Objects.isNull(selfDynamicProxyClass)) {
            throw new SoaException("selfDynamicProxyClass 动态代理类不能为null");
        }
        try {
            this.createProxyMethod = Stream.of(selfDynamicProxyClass.getMethods())
                    .filter(method -> Modifier.isStatic(method.getModifiers())
                            && Modifier.isPublic(method.getModifiers())
                            && !Modifier.isAbstract(method.getModifiers())
                            && method.getParameters().length == 2
                            && method.getParameters()[0].getType().equals(ProxyFactoryBean.class)
                            && method.getParameters()[1].getType().equals(Class.class)
                            && !method.getReturnType().equals(void.class))
                    .collect(Collectors.toList())
                    .get(0);
        } catch (Exception e) {
            throw new SoaException("500", String.format("%s %s %s和%s %s, %s %s"
                    , ClassUtils.getQualifiedName(selfDynamicProxyClass)
                    , " 没有参数类型是 "
                    , ClassUtils.getQualifiedName(ConsumerProxyFactoryBean.class)
                    , ClassUtils.getQualifiedName(Class.class)
                    , " 的、公共的、非抽象的、返回值非void的方法"
                    , "请将你的动态代理类继承"
                    , ClassUtils.getQualifiedName(DynamicProxyAdapter.class)
            ), e);
        }

        this.selfDynamicProxyClass = selfDynamicProxyClass;
        this.resourceClass = resourceClass;
        this.version = version;
        this.group = group;
    }

    protected Object newInstance() throws SoaException {
        if(this.isSingleton() && this.proxy != null) {
            return proxy;
        }
        synchronized (this) {
            Object target;
            try {
                target = this.createProxyMethod.invoke(null,this, selfDynamicProxyClass);
            } catch (Exception e) {
                throw new SoaException("500", String.format("%s %s %s"
                        , ClassUtils.getQualifiedName(selfDynamicProxyClass)
                        , createProxyMethod.getName()
                        , "创建代理类异常")
                        , e);
            }
            if(proxy == null) {
                proxy = target;
            }
            return target;
        }
    }

    public Class<?> getSelfDynamicProxyClass() {
        return selfDynamicProxyClass;
    }

    public void setSelfDynamicProxyClass(Class<?> selfDynamicProxyClass) {
        this.selfDynamicProxyClass = selfDynamicProxyClass;
    }

    public Class<?> getResourceClass() {
        return resourceClass;
    }

    public void setResourceClass(Class<?> resourceClass) {
        this.resourceClass = resourceClass;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    public String getGroup() {
        return group;
    }

    public void setGroup(String group) {
        this.group = group;
    }
}
复制代码

v5.2 ProxyFactoryBean具体实现类ProviderProxyFactoryBean

复制代码
package com.hjzgg.apigateway.soa.proxy.provider;

import com.hjzgg.apigateway.soa.exceptions.SoaException;
import com.hjzgg.apigateway.soa.proxy.ProxyFactoryBean;
import org.springframework.aop.SpringProxy;
import org.springframework.aop.TargetClassAware;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author hujunzheng
 * @create 2018-02-18 下午3:01
 **/
public class ProviderProxyFactoryBean extends ProxyFactoryBean {
    public ProviderProxyFactoryBean(Class<?> selfDynamicProxyClass, Class<?> resourceClass, String version, String group) throws SoaException {
        super(selfDynamicProxyClass, resourceClass, version, group);
    }

    @Override
    public Object getObject() throws Exception {
        return this.newInstance();
    }

    @Override
    public Class<?> getObjectType() {
        return resourceClass;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }

    public static Class<?> getProxyClass(Class<?> resourceClass) {
        /**
         * @see com.hjzgg.apigateway.dubbo.configure.SelfDubboAnnotationBean#postProcessAfterInitialization(Object, String)
         * @see org.springframework.aop.support.AopUtils#isAopProxy(Object)
         * @see org.springframework.aop.support.AopUtils#getTargetClass(Object)
         * @see com.hjzgg.apigateway.soa.proxy.provider.ProviderDynamicProxy#invoke(Object, Method, Object[])
         * */
        return Proxy.getProxyClass(ProviderProxyFactoryBean.class.getClassLoader(), new Class[]{resourceClass, SpringProxy.class, TargetClassAware.class});
    }
}
复制代码

v5.3 动态代理适配器DynamicProxyAdapter

复制代码
package com.hjzgg.apigateway.soa.proxy;

import com.hjzgg.apigateway.soa.exceptions.SoaException;
import org.springframework.util.ClassUtils;

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

/**
 * @author hujunzheng
 * @create 2018-02-04 上午12:00
 **/
public class DynamicProxyAdapter implements InvocationHandler {
    public DynamicProxyAdapter(ProxyFactoryBean factoryBean) {
        this.bean = factoryBean;
    }

    protected ProxyFactoryBean bean;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        throw new SoaException(String.format("%s %s %s", "你应当重写", ClassUtils.getQualifiedName(DynamicProxyAdapter.class), "invoke方法"));
    }

    public static Object createJDKProxy(ProxyFactoryBean factoryBean, Class<?> selfDynamicProxyClass) throws SoaException {
        if (!DynamicProxyAdapter.class.equals(selfDynamicProxyClass.getSuperclass())) {
            throw new SoaException(String.format("%s %s %s"
                    , ClassUtils.getQualifiedName(selfDynamicProxyClass)
                    , "需要继承"
                    , ClassUtils.getQualifiedName(DynamicProxyAdapter.class)
            ));
        }
        Object selfDynamicProxyInstance;
        try {
            selfDynamicProxyInstance = selfDynamicProxyClass.getConstructor(factoryBean.getClass()).newInstance(factoryBean);
        } catch (Exception e) {
            throw new SoaException("500", "动态代理类创建失败", e);
        }
        Object proxy = Proxy.newProxyInstance(selfDynamicProxyClass.getClassLoader(),
                new Class[]{factoryBean.getResourceClass()}, (InvocationHandler) selfDynamicProxyInstance);
        return proxy;
    }
}
复制代码

v5.4 继承DynamicProxyAdapter 实现invoke接口 ProviderDynamicProxy

复制代码
package com.hjzgg.apigateway.soa.proxy.provider;

import com.hjzgg.apigateway.commons.utils.ContextUtils;
import com.hjzgg.apigateway.soa.annotation.SOAImplements;
import com.hjzgg.apigateway.soa.exceptions.SoaException;
import com.hjzgg.apigateway.soa.proxy.DynamicProxyAdapter;
import com.hjzgg.apigateway.soa.proxy.consumer.ConsumerProxyFactoryBean;
import org.springframework.aop.TargetClassAware;
import org.springframework.util.ClassUtils;

import java.lang.reflect.Method;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Stream;

public class ProviderDynamicProxy extends DynamicProxyAdapter {

    private static final ConcurrentHashMap<Class<?>, Object> map = new ConcurrentHashMap<>();

    public ProviderDynamicProxy(ProviderProxyFactoryBean factoryBean) {
        super(factoryBean);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            if (method.equals(TargetClassAware.class.getMethod("getTargetClass", new Class[]{}))) {
                return bean.getResourceClass();
            }
            return method.invoke(this.findRelevantServiceProvider(), args);
        } catch (Exception e) {
            throw new SoaException("500", String.format("%s %s %s"
                    , "invoke service proxy object error!"
                    , ClassUtils.getQualifiedName(this.bean.getResourceClass())
                    , method.getName()
            ), e);
        }
    }

    private Object findRelevantServiceProvider() throws SoaException {
        Class<?> resourceClass = super.bean.getResourceClass();

        if (!map.contains(resourceClass)) {
            Stream<?> stream = ContextUtils.getBeans(SOAImplements.class)
                    .stream()
                    .filter(serviceProvider -> resourceClass.isAssignableFrom(serviceProvider.getClass()));
            if (stream.count() > 1) {
                throw new SoaException(String.format(
                        "multiple relevant service provider found with annotation %s and interface is %s"
                        , ClassUtils.getQualifiedName(SOAImplements.class)
                        , ClassUtils.getQualifiedName(resourceClass))
                );
            }

            if (stream.count() == 1) {
                map.put(resourceClass, stream.findFirst().get());
            } else {
                List<?> objects = ContextUtils.getBeans(SOAImplements.class);
                if (objects.size() > 1) {
                    throw new SoaException(String.format(
                            "multiple relevant service provider found with annotation %s"
                            , ClassUtils.getQualifiedName(SOAImplements.class))
                    );
                }

                if (objects.size() == 1) {
                    map.put(resourceClass, objects.get(0));
                } else {
                    try {
                        Object object = ContextUtils.getBean(resourceClass);
                        map.put(resourceClass, object);
                    } catch (Exception e) {
                        throw new SoaException("500", String.format(
                                "find relevant service provider with interface %s error"
                                , ClassUtils.getQualifiedName(resourceClass)), e
                        );
                    }
                }
            }
        }

        return map.get(resourceClass);
    }
}
复制代码

v5.5 注册类型是jdk proxy类型的bean

复制代码
//参数dynamicProxyClass 是 ProviderDynamicProxy
public static boolean registerProvider(BeanDefinitionRegistry registry, Class<?> dynamicProxyClass, Class<?> resourceClass) {
    String apiClassInfo = ClassUtils.getQualifiedName(resourceClass);
    try {
        /**
         * 通过代理bean的方式创建创建 服务bean
         * @see com.hjzgg.apigateway.dubbo.configure.SelfDubboAnnotationBean#postProcessAfterInitialization(Object, String)
         * if (AopUtils.isAopProxy(bean)), 判断bean的类型如果是代理类型，进行dubbo注解解析处理
         * */
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(resourceClass);
        String dubboVersion = resourceClass.getAnnotation(Service.class).version();
        String dubboGroup = resourceClass.getAnnotation(Service.class).group();
        ProviderProxyFactoryBean providerProxyFactoryBean = new ProviderProxyFactoryBean(dynamicProxyClass, resourceClass, dubboVersion, dubboGroup);
        /**
         * providerProxyFactoryBean.getObject() 得到的是通过 Proxy.newInstance方法获取到的代理类
         * @see com.hjzgg.apigateway.soa.proxy.DynamicProxyAdapter#createJDKProxy(ProxyFactoryBean, Class)
         * 可通过 Proxy.getInvocationHandler方法拿到 InvocationHandler实例
         */
        Class<?> targetProxyClass = ProviderProxyFactoryBean.getProxyClass(resourceClass);
        builder.addConstructorArgValue(Proxy.getInvocationHandler(providerProxyFactoryBean.getObject()));
        AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
        beanDefinition.setBeanClass(targetProxyClass);

        beanDefinition.setAttribute(Constants.API_CLASS_INFO, resourceClass);
        String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
        if (registry.containsBeanDefinition(beanName)) {
            log.debug(beanName + " already exists! Class is " + apiClassInfo + " .");
            return false;
        }
        registry.registerBeanDefinition(beanName, beanDefinition);
        return true;
    } catch (Exception e) {
        log.error("registerProvider proxy bean error! Class is " + apiClassInfo + " .");
        return false;
    }
}
复制代码

v5.6 附加SelfDubboAnnotationBean

 View Code

v 5.7 附加AopUtils相关方法

复制代码
/**
 * Check whether the given object is a JDK dynamic proxy or a CGLIB proxy.
 * <p>This method additionally checks if the given object is an instance
 * of {@link SpringProxy}.
 * @param object the object to check
 * @see #isJdkDynamicProxy
 * @see #isCglibProxy
 */
public static boolean isAopProxy(Object object) {
    return (object instanceof SpringProxy &&
            (Proxy.isProxyClass(object.getClass()) || ClassUtils.isCglibProxyClass(object.getClass())));
}


/**
 * Determine the target class of the given bean instance which might be an AOP proxy.
 * <p>Returns the target class for an AOP proxy or the plain class otherwise.
 * @param candidate the instance to check (might be an AOP proxy)
 * @return the target class (or the plain class of the given object as fallback;
 * never {@code null})
 * @see org.springframework.aop.TargetClassAware#getTargetClass()
 * @see org.springframework.aop.framework.AopProxyUtils#ultimateTargetClass(Object)
 */
public static Class<?> getTargetClass(Object candidate) {
    Assert.notNull(candidate, "Candidate object must not be null");
    Class<?> result = null;
    if (candidate instanceof TargetClassAware) {
        result = ((TargetClassAware) candidate).getTargetClass();
    }
    if (result == null) {
        result = (isCglibProxy(candidate) ? candidate.getClass().getSuperclass() : candidate.getClass());
    }
    return result;
}
复制代码









本文转自 小眼儿 博客园博客，原文链接：http://www.cnblogs.com/hujunzheng/p/8527338.html，如需转载请自行联系原作者
AOP原理——2. AbstractAutoProxyCreator 创建动态代理对象
姜希成的博客
12-03 3732
SmartInstantiationAwareBeanPostProcessor接口继承自InstantiationAwareBeanPostProcessor接口，因此AbstractAutoProxyCreator是通过InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法来生成动态代理对象的。 public abstract class AbstractAutoProxyCreator extends ProxyPr
3.8 spring - AbstractBeanDefinition 介绍
weixin_34008805的博客
04-06 176
　　之前,我们已尽完成了xml 文档到 GenericBeanDefinition的转换, 也就是说,到这里,所有的配置都可以在GenericBeanDefinition 的实例中找到对应的配置.   　　GenericBeanDefinition只是子类实现,而大部分功能都是通用属性,都是保存在AbstractBeanDefinition中, 那么我们再次通过AbstractBeanDe...
Spring源码学习(七)---AbstractBeanDefinition
12-15 367
这里主要是使用org.springframework:spring-beans:5.2.0.RELEASE进行分析 文章目录一. AbstractBeanDefinition 1. 查看源码相关的快捷键 快捷键 作用 Ctrl + Shift+i 出现类似于预览的小窗口 Ctrl + Enter （接上步）完全打开源码 Ctrl + 鼠标左键 一步到位打开源码 = Ctrl + Shift+i –>Ctrl + Enter Alt+7 查看类的有什么方法 ctrl+f.
Spring源码解析之AbstractBeanDefinition
fomeiherz的专栏
01-10 289
primary 自动装配时当出现多个bean候选者时，将作为首选者。 对应XML配置中bean标签属性的primary。<bean id="xxx" class="xxx" primary="true"> 对应注解：@org.springframework.context.annotation.Primary initMethodName 初始化方法。 对应XML配置中bean标签属性...
spring4.0源码分析━━━（AbstractBeanDefinition类）
吾日五省我身！
08-05 223
上一篇有讲解析xml，其中有说道BeanDefinition，但是不够详细。AbstractBeanDefinition是spring配置文件bean标签的实现，了解这个类很关键。源代码如下：   public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor implements ...
Spring源码(四)：bean的创建
最新发布
bashenanking的博客
08-05 1084
本节紧接上一篇，深入讨论一个标准bean在Spring中究竟是如何生成&销毁的（重点关注Spring对bean的构造方法、注入字段、各种扩展方法的处理，以及围绕整个bean的全生命周期，Spring留了那些扩展点给用户实现）
Spring IOC 之 bean创建createBean()源码
Deep Water Slow
06-24 767
spring bean创建过程，bean构造函数匹配过程
Spring创建Bean过程
weixin_43843164的博客
07-17 469
一、初始化Bean，XXXAware @Service public class UserService implements InitializingBean, BeanNameAware, ApplicationContextAware{ public UserService(){ System.out.println("userService构造方法"); } @Autowired private UserDao userDao; // @.
【Spring源码】 Spring IoC容器启动之Bean创建流程
hahazz233的博客
06-17 327
上篇已经分析完中大部分方法，也已经把解析成注册到容器中，还剩下一个非常重要的方法，就是下面将要分析的：，用以完成创建、依赖注入和初始化等工作。 关键代码是最后一句：。 非创建走的是，内部又会委托给方法。注意，这里出现了另一个重要的扩展点：，从代码上看就是所有非Lazy类型的Singleton实例都被全部创建完成后，会触发回调。案例可参见：待所有创建完毕，找到其中标注了注解的方法，利用反射和为其创建，并添加到事件派发器的缓存中。 createBean() 这句代码比较关键，这里有个关键的扩
Spring源码之BeanDefinition的加载
wsb_2526的博客
06-02 1144
Spring提供了BeanDefinitionRegistry去操作BeanDefinition，BeanDefinitionRegistry接口具有增、删、查（这里的增删查指的是对存放BeanDefinition的集合进行操作）BeanDefinition的能力。通过上面的debug，目前已经知道了Spring怎么注册 配置类以及Processor的BeanDefinition，那么配置类中通过@Bean注解注册的Bean的BeanDefinition是在怎么时候注册的呢？
spring-相关知识点-AbstractBeanDefinition
菜鸡在路上找食吃
08-14 680
文章目录前言分析applyDefaultsBeanClass相关方法实验Bean基本属性设置这一个个的API 我就想一一演示的相关文章 前言 在了解 spring 源码 的是我们知道 我们的Bean 都会被包装成 BeanDefinition进行操作 所以需要对其有一个基本的了解 这是一个抽象类 其子类有 RootBeanDefinition GenericBeanDefinition 分析 该分析仅会分析主要内容… applyDefaults 传递一个 BeanDefinitionDefa
Spring中的BeanDefinition系列（二）—— AbstractBeanDefinition
LCDZhao的艺术世界
02-03 1095
typora-copy-images-to: ./ 前言 ​ AbstractBeanDefinition是最终全功能BeanDefinition实现类的基类 。因此它非常重要，搞明白了它，基本上也就明白了一大部分的Spring中的Bean组件。 ​ 一个因为实现了BeanDefinition接口的类有一些共用的方法和属性，因此需要一个类来完成它们公用的方法和属性，而AbstractBeanDe...
AbstractBeanDefinition
lhj501382150的博客
09-24 301
//Bean 的作用范围 private String scope = ""; 是否单例 scope private boolean singleton = true; 是否原型 scope private boolean prototype = false; 是否抽象 abstract private boolean abstractFlag = false; ...
SpringBoot底层源码_AbstractBeanDefinition
qq_26771639的博客
07-16 449
Spring 的AbstractBeanDefinition的内容
Spring 中的BeanDefinition及其实现和BeanDefinitionReader
wc_150xxxxxx26的博客
08-22 1427
什么是BeanDefinition?在回答这个问题之前，先想一下我们通常是如何去定义一个Bean?1、通过xml文件配置Bean，<bean />2、通过配置类配置Bean，@Bean3、通过注解自动扫描成Bean，@Component（@Service，@Controller等）其实上面的三种我们通常定义Bean的方式，最终也都会被解析成BeanDefinition对象。再由BeanFactory根据BeanDefinition生成对应的Bean。
SpringBoot强化系列：BeanDefinition源码解析及测试样例
天然玩家的博客
11-07 235
1 简介 BeanDefinition用于描述Bean实例，在具体的实现中配置Bean的属性。 BeanDefinition是最小单元接口，主要是为了BeanFactoryPostProcessors接口修改经过标准初始化的内部Bean。 AbstractBeanDefinition是BeanDefinition实现的最小单元抽象类。 2 源码解析 2.1 方法及属性 序号 属性 描述 1 SCOPE_SINGLETON 2 SCOPE_PROTOTYPE 3 ROLE_APPL
Spring的bean定义 2 : 通用bean定义逻辑 -- AbstractBeanDefinition
Details Inside Spring
12-30 2568
概述 AbstractBeanDefinition是最终全功能BeanDefinition实现类的基类，也就是这些类的共同属性和公用逻辑实现。 AbstractBeanDefinition中并没有太复杂的实现逻辑，而是主要是用于： 定义共用的构造函数。 定义共用BeanDefinition属性以及提供它们的getter/setter方法。 其他一些共用工具方法 : 从另外一个bean定义覆盖当前...
【Spring源码--IOC容器的实现】（三）BeanDefinition的载入和解析【II】
Frankenstein的博客
08-16 3014
本文主要对bean的属性进行源码分析，通过对property子元素逐层分析，完成Spring对xml文件的封装。
Spring源码 --- BeanDefinition接口，及其各种子类结构关系
Feverasa的博客
07-05 565
Spring中关于一个Bean的基本描叙接口 -- BeanDefinition的定义： BeanMetadataElement接口：获取Source。 public interface BeanMetadataElement { /** * Return the configuration source {@code Object} for this metadata elemen...
Spring框架中创建Bean的三种方法详解
在Spring框架中，Bean的实例化是其核心功能之一，它允许开发者通过不同的方式创建和管理Bean。以下详细说明这三种实例化方式： 1. **调用构造器创建Bean实例** 这是最常见的实例化方式，通常适用于需要通过无参...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值