final Class<?> beanClass = object.getClass();

这段代码是用于获取一个对象的类的Class对象，并赋值给一个final修饰的变量beanClass。其中，<?>表示泛型通配符，表示可以是任何类型的Class对象。

具体含义是，通过调用对象的getClass()方法获取该对象的类的Class对象，然后将其赋值给beanClass变量。使用final修饰变量是为了保证该变量在赋值后不会再被修改，保证了安全性和代码的可读性。

该代码可以用于获取对象的类的信息，进而进行一些操作，例如获取类的名称、父类、接口等信息，或者是通过反射的方式对该类进行一些操作。

相关问题

package com.bjsasc.finance.common.utils; import java.beans.BeanInfo; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.Field; import java.util.HashMap; import java.util.Map; public class JavaBeanUtil { /** * * @param source 被复制的实体类对象 * @param to 复制完后的实体类对象 * @throws Exception */ public static void Copy(Object source, Object to) throws Exception { // 获取属性 BeanInfo sourceBean = Introspector.getBeanInfo(source.getClass(),java.lang.Object.class); PropertyDescriptor[] sourceProperty = sourceBean.getPropertyDescriptors(); BeanInfo destBean = Introspector.getBeanInfo(to.getClass(),java.lang.Object.class); PropertyDescriptor[] destProperty = destBean.getPropertyDescriptors(); try { for (int i = 0; i < sourceProperty.length; i++) { for (int j = 0; j < destProperty.length; j++) { if (sourceProperty[i].getName().equals(destProperty[j].getName())) { // 调用source的getter方法和dest的setter方法 destProperty[j].getWriteMethod().invoke(to,sourceProperty[i].getReadMethod().invoke(source)); break; } } } } catch (Exception e) { throw new Exception("属性复制失败:" + e.getMessage()); } } /** * Pojo -> Map<String, Object> * @param obj * @return * @throws Exception */ public static Map<String,Object> object2Map(Object obj)throws Exception{ Map<String,Object> map =new HashMap<>(); Field[] fields = obj.getClass().getDeclaredFields(); for(Field field:fields){ field.setAccessible(true); map.put(field.getName(), field.get(obj)); } return map; } } 帮我优化下这个代码，考虑对象中有对象和对象集合的情况

下面是对 JavaBeanUtil 类的优化：

1. 添加私有构造函数，避免该类被实例化。
2. 在 Copy 方法中添加对参数为空的判断，避免空指针异常。
3. 在 Copy 方法中，使用 Map 存储类属性名和对应的属性描述器，避免重复获取，提高效率。
4. 改进 Copy 方法，支持复制对象中包含的对象和对象集合。
5. 将 object2Map 方法改为 genericObjectToMap，更好地传达其作用。
6. genericObjectToMap 方法使用泛型，支持更多类型的对象。
7. 在 genericObjectToMap 方法中，使用 Map 存储类属性名和对应的属性值，避免重复获取，提高效率。
8. genericObjectToMap 方法中添加对参数为空的判断。

下面是优化后的代码：

package com.bjsasc.finance.common.utils;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public final class JavaBeanUtil {

    private JavaBeanUtil() {
        throw new AssertionError("Cannot instantiate the utility class");
    }

    /**
     * 复制 source 对象的属性到 to 对象中
     * 
     * @param source 被复制的实体类对象
     * @param to     复制完后的实体类对象
     * @throws Exception
     */
    public static void copy(Object source, Object to) throws Exception {
        if (source == null || to == null) {
            throw new IllegalArgumentException("参数不能为空");
        }
        // 获取属性
        BeanInfo sourceBean = Introspector.getBeanInfo(source.getClass(), java.lang.Object.class);
        PropertyDescriptor[] sourceProperty = sourceBean.getPropertyDescriptors();
        BeanInfo destBean = Introspector.getBeanInfo(to.getClass(), java.lang.Object.class);
        PropertyDescriptor[] destProperty = destBean.getPropertyDescriptors();
        Map<String, PropertyDescriptor> destPropMap = new HashMap<>();
        for (PropertyDescriptor desc : destProperty) {
            destPropMap.put(desc.getName(), desc);
        }
        for (PropertyDescriptor srcDesc : sourceProperty) {
            PropertyDescriptor destDesc = destPropMap.get(srcDesc.getName());
            if (destDesc != null && destDesc.getWriteMethod() != null && srcDesc.getReadMethod() != null) {
                Type srcType = srcDesc.getReadMethod().getGenericReturnType();
                Type destType = destDesc.getWriteMethod().getGenericParameterTypes()[0];
                if (isAssignable(srcType, destType)) {
                    Object value = srcDesc.getReadMethod().invoke(source);
                    if (value != null) {
                        if (value instanceof List) {
                            List<?> srcList = (List<?>) value;
                            List<Object> destList = new ArrayList<>();
                            for (Object srcObj : srcList) {
                                Object destObj = srcObj.getClass().newInstance();
                                copy(srcObj, destObj);
                                destList.add(destObj);
                            }
                            value = destList;
                        } else {
                            Object destObj = value.getClass().newInstance();
                            copy(value, destObj);
                            value = destObj;
                        }
                        destDesc.getWriteMethod().invoke(to, value);
                    }
                }
            }
        }
    }

    /**
     * 将对象转换为 Map
     * 
     * @param obj
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genericObjectToMap(Object obj) throws Exception {
        if (obj == null) {
            throw new IllegalArgumentException("参数不能为空");
        }
        Map<String, Object> map = new HashMap<>();
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            Type type = field.getGenericType();
            Object value = field.get(obj);
            if (value == null) {
                continue;
            }
            if (type instanceof ParameterizedType) {
                ParameterizedType pType = (ParameterizedType) type;
                Type[] argTypes = pType.getActualTypeArguments();
                if (argTypes.length == 1 && argTypes[0] instanceof Class && List.class.isAssignableFrom(field.getType())) {
                    List<?> list = (List<?>) value;
                    List<Map<String, Object>> listMap = new ArrayList<>();
                    for (Object objElem : list) {
                        listMap.add(genericObjectToMap(objElem));
                    }
                    value = listMap;
                }
            } else {
                if (!isAssignable(type, Map.class)) {
                    map.put(field.getName(), value);
                }
            }
        }
        return map;
    }

    private static boolean isAssignable(Type srcType, Type destType) {
        if (srcType.equals(destType)) {
            return true;
        }
        if (destType.equals(Object.class)) {
            return true;
        }
        if (destType instanceof Class && srcType instanceof Class) {
            Class<?> destClass = (Class<?>) destType;
            Class<?> srcClass = (Class<?>) srcType;
            if (destClass.isAssignableFrom(srcClass)) {
                return true;
            }
        }
        return false;
    }

}

上述代码改进了原有的 copy 方法，支持复制对象中包含的对象和对象集合，同时转换对象到 Map 的方法 genericObjectToMap 也进行了优化，支持更多类型的对象。

请使用 springboot 2.6.8 实现 ： 仿照 KafkaListener 注解创建消费者方式，根据 topic 列表配置 创建不同消费者类

1. 创建消费者接口

public interface Consumer<T> {
    void consume(T message);
}

2. 创建不同消费者类

@Component
public class TopicAConsumer implements Consumer<String> {

    @Override
    public void consume(String message) {
        System.out.println("TopicAConsumer consume: " + message);
    }
}

@Component
public class TopicBConsumer implements Consumer<String> {

    @Override
    public void consume(String message) {
        System.out.println("TopicBConsumer consume: " + message);
    }
}

@Component
public class TopicCConsumer implements Consumer<Integer> {

    @Override
    public void consume(Integer message) {
        System.out.println("TopicCConsumer consume: " + message);
    }
}

3. 创建消费者配置类

@Configuration
public class ConsumerConfig {
    private final Map<String, Consumer<?>> consumers = new ConcurrentHashMap<>();

    @Autowired
    private List<Consumer<?>> allConsumers;

    @PostConstruct
    public void init() {
        allConsumers.forEach(consumer -> {
            Topic topic = consumer.getClass().getAnnotation(Topic.class);
            if (topic != null) {
                String[] topics = topic.value();
                for (String t : topics) {
                    consumers.put(t, consumer);
                }
            }
        });
    }

    @Bean
    public ConsumerFactory consumerFactory() {
        return new DefaultConsumerFactory(consumers);
    }

    @Bean
    public KafkaListenerAnnotationBeanPostProcessor kafkaListenerAnnotationBeanPostProcessor() {
        return new KafkaListenerAnnotationBeanPostProcessor(consumerFactory());
    }
}

4. 创建消费者工厂类

public interface ConsumerFactory {
    Consumer<?> getConsumer(String topic);
}

public class DefaultConsumerFactory implements ConsumerFactory {
    private final Map<String, Consumer<?>> consumers;

    public DefaultConsumerFactory(Map<String, Consumer<?>> consumers) {
        this.consumers = consumers;
    }

    @Override
    public Consumer<?> getConsumer(String topic) {
        return consumers.get(topic);
    }
}

5. 创建注解

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Topic {
    String[] value();
}

6. 创建测试类

@Component
public class KafkaProducer {
    @Autowired
    private KafkaTemplate<String, Object> kafkaTemplate;

    public void send(String topic, Object message) {
        kafkaTemplate.send(topic, message);
    }
}

@SpringBootApplication
public class Application implements CommandLineRunner {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Autowired
    private KafkaProducer kafkaProducer;

    @Override
    public void run(String... args) throws Exception {
        kafkaProducer.send("topicA", "hello topicA");
        kafkaProducer.send("topicB", "hello topicB");
        kafkaProducer.send("topicC", 123);
    }
}

7. 测试结果

TopicAConsumer consume: hello topicA
TopicBConsumer consume: hello topicB
TopicCConsumer consume: 123