java - ActionPerformed (AWT) 的 BeanCurrentlyInCreationException

Question

创建新按钮我必须在新线程中运行代码。

通常我们使用 new Thread(....).start(); 但我想知道为什么我们不能使用 @Async-Annotation。

这是代码:

package net.vectorpublish.desktop.vp;

import java.awt.event.ActionEvent;
import java.awt.image.BufferedImage;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Named;
import javax.swing.ImageIcon;
import javax.swing.SwingUtilities;

import org.springframework.scheduling.annotation.Async;

import net.vectorpublish.desktop.vp.api.history.Redo;
import net.vectorpublish.desktop.vp.api.layer.Layer;
import net.vectorpublish.desktop.vp.api.ui.Dialog;
import net.vectorpublish.desktop.vp.api.ui.KeyframeSlider;
import net.vectorpublish.desktop.vp.api.ui.ToolBar;
import net.vectorpublish.desktop.vp.api.ui.VPAbstractAction;
import net.vectorpublish.desktop.vp.api.vpd.DocumentNode;
import net.vectorpublish.desktop.vp.api.vpd.VectorPublishNode;
import net.vectorpublish.desktop.vp.gantt.AddTaskData;
import net.vectorpublish.desktop.vp.gantt.AddTaskHistoryStep;
import net.vectorpublish.desktop.vp.gantt.Priority;
import net.vectorpublish.desktop.vp.utils.SetUtils;
import net.vectorpublish.destkop.vp.gantt.rule.VetoableTaskAdder;

@SuppressWarnings("restriction")
@Named
public class AddTask extends VPAbstractAction implements NodeSelectionChangeListener {

    public AddTask() {
        super(GanttText.ADD_TASK, GanttText.ADD_TASK_TT, false);
    }

    @Inject
    private final Dialog dlg = null;

    @Inject
    private final History hist = null;

    @Inject
    private final Redo redo = null;

    @Inject
    private final Layer layer = null;

    @Inject
    private final ToolBar toolbar = null;

    @Inject
    private final KeyframeSlider slider = null;

    @Inject
    private final Set<VetoableTaskAdder> council = null;

    private DocumentNode doc;

    @Async // <----------------------------------------------- This creates the Exception!
    public void actionPerformed(ActionEvent arg0) {
        try {
            VectorPublishNode selected = layer.getSelection().iterator().next();
            Future<String> taskId = dlg.ask(GanttText.NAMESPACE, "ID", "");
            Future<String> info = dlg.ask(GanttText.NAMESPACE, "Detail", "");
            Future<Priority> prio = dlg.ask(GanttText.NAMESPACE, "Name", Priority.values());
            Future<Float> points = dlg.ask(GanttText.NAMESPACE, "Storypoints", 3f);
            Future<String> username = dlg.ask(GanttText.NAMESPACE, "User", "");
            Future<String> avatar = dlg.ask(GanttText.NAMESPACE, "Avatar-Image", "www.test.com/User.png");
            AddTaskData addTaskData = new AddTaskData(taskId.get(), info.get(), prio.get(),
                    SetUtils.nodeToImmutableIndex(selected), slider.getTime(), points.get(), username.get(),
                    load(avatar.get()));
            AddTaskHistoryStep data = new AddTaskHistoryStep(hist, addTaskData);
            redo.actionPerformed(arg0);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }

    private BufferedImage load(String string) throws MalformedURLException {
        ImageIcon ii = new ImageIcon(new URL(string));
        return (BufferedImage) ii.getImage();
    }

    public void changedNodeSelection() {
        Set<VectorPublishNode> nodes = layer.getSelection();
        if (nodes.size() != 1) {
            setEnabled(false);
        } else {
            boolean veto = false;
            for (VetoableTaskAdder vetoableTaskAdder : council) {
                veto &= vetoableTaskAdder.hasVeto(nodes);
            }
            setEnabled(!veto);
        }
    }

    @PostConstruct
    public void setup() {
        toolbar.add(this);
    }
}

这是异常(exception):

DefaultI8nImageFactory Found: Image for key net.vectorpublish:io/new/large in cache!     (DefaultI8nImageFactory > NewFile)
DefaultI8nImageFactory Found: Image for key net.vectorpublish:io/open/small in cache!    (DefaultI8nImageFactory > OpenImpl)
DefaultI8nImageFactory Found: Image for key net.vectorpublish:io/open/large in cache!    (DefaultI8nImageFactory > OpenImpl)
Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'addTask': Bean with name 'addTask' has been injected into other beans [nodeSelectionChangeImpl,translation] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.
org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'addTask': Bean with name 'addTask' has been injected into other beans [nodeSelectionChangeImpl,translation] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:583)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:482)
    at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:306)
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:230)
    at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:302)
    at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:197)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:754)
    at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:866)
    at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:542)
    at org.springframework.context.annotation.AnnotationConfigApplicationContext.<init>(AnnotationConfigApplicationContext.java:84)
    at net.vectorpublish.desktop.vp.VectorPublishApplicationContext.<init>(VectorPublishApplicationContext.java:18)
    at net.vectorpublish.desktop.vp.Startup.main(Startup.java:30)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at org.codehaus.mojo.exec.ExecJavaMojo$1.run(ExecJavaMojo.java:282)
    at java.lang.Thread.run(Thread.java:745)

编辑

因为一些更高的决定我必须尊重:

1. 我必须有字段 final 和
2. 不能使用构造函数 Autowiring 。

Answer 1

在这种情况下，BeanCurrentlyInCreationException 的根本原因是由于使用了 @Inject(或其 Spring 的等效 @Autowired ) 在 final 字段上。

要了解应该考虑 bean 生命周期的行为。

• Spring 首先构造对象，其字段具有默认 值，即null。
• 构造对象后Spring使用反射注入(inject)即初始化字段的实际值

因此第二步与字段上的 final 声明相矛盾，该声明规定该字段可以有且只有一个值，该值应在构建时分配。

因此，要解决这个问题，要么从字段中删除 final 声明，要么改用构造函数注入(inject)(在这种特殊情况下，考虑到依赖项的数量，建议使用 former)

如果需要更多信息，请在评论中告知。

希望对您有所帮助!

P.S.:虽然我在任何官方文档中都找不到明确提及此行为，但 here在示例中对此进行了巧妙的解释，其中该字段被标记为 final only 在构造函数注入(inject)的情况下。

编辑:-
引入@Async强制Spring创建和使用bean proxies相反，如果存在循环引用，这将导致 BeanCurrentlyInCreationException。

发生这种情况是因为 Spring 最初注入(inject)了原始版本的 bean 并尝试对其应用方面，但由于 RawInjectionDespiteWrapping 默认情况下被禁用而失败，正如 Nicolas Labrot 所指出的。

为了克服这个问题

• 打破循环引用(虽然推荐但需要重新设计，因此需要付出很多努力)
• 使用惰性初始化(如下所述)

惰性 Bean 初始化
如果使用 xml 配置，请在根元素中提供 default-lazy-init="true"

<beans default-lazy-init="true" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns="http://www.springframework.org/schema/beans"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context.xsd">
   <!-- Other configuration(s) -->
</beans>

Java 配置使用如下

@Configuration
@Lazy // For all Beans to load lazily (equivalent to default-lazy-init="true")
public class SomeConfig {

    @Bean
    // @Lazy - Only if particular bean should load lazily
    public SomeBean someBean() {
        return new SomeBean();
    }
}

还要确保标记为 @Inject 的字段应伴随 @Lazy，以防使用组件扫描(通过 Java 或 xml 配置)例如引用下面

 @Inject
 @Lazy
 private Dialog dlg;