• 欢迎光临~

通过注解动态指定实现类,实现spring bean的动态代理

开发技术 开发技术 2022-07-16 次浏览

目录
  • 实现动态代理需要实现的类如下
  • demo联系
    • 需要应用的依赖
    • 先定义好自己的注解,为后续方法上指定做准备
    • 工作默认实现类注解
    • 自定义factorybean----HandlerInterfaceFactoryBean
    • 实现InvocationHandler
    • 自定义实现HandlerBeanDefinitionRegistry
  • 开始业务层的demo coding
    • 抽象一个HandlerRouter范型接口
    • 创建我们需要的工作接口定义
    • 再抽象一层工作的接口,同时在接口上添加@HandlerWorkAutoImpl注解
    • 创建工作的controller
    • 创建两个工作的实现demo类
    • 运行结果

当我们的一个接口需要被多次实现时,如果不用动态代理或者实现类,那么我们的代码就会十分的冗余,到处都是impl的实现类注入,很不友好。为此,我们可以通过动态代理类,将生成的对象注入到Spring容器中,业务层只要继承我们的上游接口,再通过注解指定名称的方式达到实时动态获取实现类。

实现动态代理需要实现的类如下

  • BeanDefinitionRegistryPostProcessor

实现自定义的注册bean定义的逻辑,官方解释

/**

 * Extension to the standard {@link BeanFactoryPostProcessor} SPI, allowing for

 * the registration of further bean definitions <i>before</i> regular

 * BeanFactoryPostProcessor detection kicks in. In particular,

 * BeanDefinitionRegistryPostProcessor may register further bean definitions

 * which in turn define BeanFactoryPostProcessor instances.

 **/

  • ApplicationContextAware

实现这个接口可以方便的获取所有的bean

  • FactoryBean

由{@link BeanFactory}中使用的对象实现本身就是单个对象的工厂。如果bean实现了这个接口,它被用作对象公开的工厂,而不是直接作为将自己公开的Bean实例。

*InvocationHandler


代理实现类的处理器

demo联系

需要应用的依赖


        <dependency>

            <groupId>org.reflections</groupId>

            <artifactId>reflections</artifactId>

            <version>0.9.10</version>

        </dependency>

先定义好自己的注解,为后续方法上指定做准备


工作类型注解,工作实现的方法上使用该注解

import java.lang.annotation.*;



@Documented

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)

public @interface WorkHandoverType {



    String type();



}

工作默认实现类注解


@Documented

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)

public @interface HandlerWorkAutoImpl {



    String name();



}

自定义factorybean----HandlerInterfaceFactoryBean


import lombok.Data;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.FactoryBean;

import org.springframework.context.ApplicationContext;





@Slf4j

@Data

public class HandlerInterfaceFactoryBean<T> implements FactoryBean<T> {



    private Class<T> interfaceClass;



    private String typeName;



    private ApplicationContext context;



    @Override

    public T getObject() {

        return (T) DynamicProxyBeanFactory.newMapperProxy(typeName, context, interfaceClass);

    }



    @Override

    public Class<?> getObjectType() {

        return interfaceClass;

    }



    @Override

    public boolean isSingleton() {

        return true;

    }

}

实现InvocationHandler


package io.hcbm.boot.wm.dynamic;



import io.hcbm.boot.wm.annotation.WorkHandoverType;

import lombok.extern.slf4j.Slf4j;

import org.springframework.context.ApplicationContext;



import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.HashMap;

import java.util.Map;





@Slf4j

public class DynamicProxyBeanFactory implements InvocationHandler {



    private String className;



    private ApplicationContext applicationContext;



    private Map<String, Object> clientMap = new HashMap<>();



    public DynamicProxyBeanFactory(String className, ApplicationContext applicationContext) {

        this.className = className;

        this.applicationContext = applicationContext;

    }



    @Override

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        if (clientMap.size() == 0) {

            initClientMap();

        }

        String workType = (String) args[0];

        return clientMap.get(workType);

    }



    private void initClientMap() throws ClassNotFoundException {

        Map<String,?> classMap = applicationContext.getBeansOfType(Class.forName(className));

        log.info("DynamicProxyBeanFactory className: [{}] , impl class: [{}]",className,classMap);



        for (Map.Entry<String,?> entry : classMap.entrySet()) {

            WorkHandoverType workHandoverType = entry.getValue().getClass().getAnnotation(WorkHandoverType.class);

            if (workHandoverType == null) {

                continue;

            }

            clientMap.put(workHandoverType.type(), entry.getValue());

        }

        log.info("DynamicProxyBeanFactory clientMap: [{}]",clientMap);

    }



    public static <T> T newMapperProxy(String classStr,ApplicationContext applicationContext,Class<T> mapperInterface) {

        ClassLoader classLoader = mapperInterface.getClassLoader();

        Class<?>[] interfaces = new Class[] {mapperInterface};

        DynamicProxyBeanFactory proxy = new DynamicProxyBeanFactory(classStr, applicationContext);

        return (T) Proxy.newProxyInstance(classLoader, interfaces, proxy);

    }

}



自定义实现HandlerBeanDefinitionRegistry


package io.hcbm.boot.wm.dynamic;



import io.hcbm.boot.wm.annotation.HandlerWorkAutoImpl;

import lombok.extern.slf4j.Slf4j;



import org.reflections.Reflections;

import org.reflections.scanners.SubTypesScanner;

import org.reflections.scanners.TypeAnnotationsScanner;

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

import org.springframework.beans.factory.support.BeanDefinitionBuilder;

import org.springframework.beans.factory.support.BeanDefinitionRegistry;

import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;

import org.springframework.beans.factory.support.GenericBeanDefinition;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

import org.springframework.stereotype.Component;



import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import java.util.Set;





@Slf4j

@Component

public class HandlerBeanDefinitionRegistry implements BeanDefinitionRegistryPostProcessor, ApplicationContextAware {



    private static final String INTERFACE_CLASS = "interfaceClass";

    private static final String TYPE_NAME = "typeName";

    private static final String CONTEXT = "context";



    private ApplicationContext applicationContext;



    @Override

    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {



        Set<Class<?>> classes = getAutoWorkClasses();

        for (Class<?> clazz : classes) {

            Type[] types = clazz.getGenericInterfaces();

            ParameterizedType type = (ParameterizedType) types[0];

            String typeName = type.getActualTypeArguments()[0].getTypeName();



            HandlerWorkAutoImpl handlerRouterAutoImpl = clazz.getAnnotation(HandlerWorkAutoImpl.class);

            BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(clazz);

            GenericBeanDefinition definition = (GenericBeanDefinition) builder.getRawBeanDefinition();



            definition.getPropertyValues().add(INTERFACE_CLASS, clazz);

            definition.getPropertyValues().add(TYPE_NAME, typeName);

            definition.getPropertyValues().add(CONTEXT, applicationContext);



            definition.setBeanClass(HandlerInterfaceFactoryBean.class);

            definition.setAutowireMode(GenericBeanDefinition.AUTOWIRE_BY_TYPE);

            beanDefinitionRegistry.registerBeanDefinition(handlerRouterAutoImpl.name(), definition);

        }

    }



    @Override

    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }



    private Set<Class<?>> getAutoWorkClasses() {

        Reflections reflections = new Reflections(

                "io.hcbm.*",//这里包路径改为自己的

                new TypeAnnotationsScanner(),

                new SubTypesScanner());



        return reflections.getTypesAnnotatedWith(HandlerWorkAutoImpl.class);

    }



    @Override

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

        this.applicationContext = applicationContext;

    }



}

以上我们的动态代理需要重新实现的方法完成*

开始业务层的demo coding

抽象一个HandlerRouter范型接口


public interface HandlerRouter<T> {



    /**

     * 工作交接处理方法

     * @param workType 工作交接类型

     * @param args 参数

     * @return T

     */

    T workHandler(String workType, Object... args);

}

创建我们需要的工作接口定义


public interface WorkHandler {



    /**

     * 工作交接执行方法

     * @param workType 工作交接类型

     * @param obj obj

     */

    void invoke(String workType, Object obj);



}

再抽象一层工作的接口,同时在接口上添加@HandlerWorkAutoImpl注解


import io.hcbm.boot.wm.annotation.HandlerWorkAutoImpl;





@HandlerWorkAutoImpl(name = "workHandlerRouter")

public interface WorkHandlerRouter extends HandlerRouter<WorkHandler> {



    /**

     *

     * @param workType

     * @return

     */

    WorkHandler getWorkHandler(String workType);



}

创建工作的controller


import com.alibaba.fastjson.JSONObject;

import io.hcbm.boot.wm.service.WorkHandler;

import io.hcbm.boot.wm.service.WorkHandlerRouter;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.*;





@Slf4j

@RestController

@RequestMapping("/v1/work")

public class WorkHandoverController {



    @Autowired

    private WorkHandlerRouter deviceHandlerRouter;



    @GetMapping

    @Permission(permissionPublic = true)

    public ResponseEntity<Object> test() {



        WorkHandler work01 = deviceHandlerRouter.workHandler("work01",null);

        System.out.println("----WorkHandler---实现类-->" + work01);



        WorkHandler work02 = deviceHandlerRouter.workHandler("work02", null);

        System.out.println("----WorkHandler---实现类-->" + work02);

        return ResponseEntity.ok("success");

    }

    

}



创建两个工作的实现demo类


import io.hcbm.boot.wm.annotation.WorkHandoverType;

import io.hcbm.boot.wm.service.WorkHandler;

import lombok.extern.slf4j.Slf4j;

import org.springframework.stereotype.Component;



@WorkHandoverType(type = "work01")

@Component

@Slf4j

public class Work01HandlerImpl implements WorkHandler {



    @Override

    public void invoke(String workType, Object obj) {

        System.out.println("Work01HandlerImpl---------> " + workType);

    }

}





import io.hcbm.boot.wm.annotation.WorkHandoverType;

import io.hcbm.boot.wm.service.WorkHandler;

import lombok.extern.slf4j.Slf4j;

import org.springframework.stereotype.Component;



@WorkHandoverType(type = "work02")

@Component

@Slf4j

public class Work02HandlerImpl implements WorkHandler {



    @Override

    public void invoke(String workType, Object obj) {

        System.out.println("Work02HandlerImpl---------> " + workType);

    }

}

运行结果

  • 可以发现,我们没有实现具体的impl,但通过传参数可以动态指定具体实现哪个service
    通过注解动态指定实现类,实现spring bean的动态代理
程序员灯塔
转载请注明原文链接:通过注解动态指定实现类,实现spring bean的动态代理
喜欢 (0)