java - 基于注解的工厂方法

Question

我希望能够自动装配单例 bean ( foo)

@Component
public class FooUser {

  @Autowire Foo foo;
}

由另一个单例方法 ( FooFactory.createFoo)创建

@Service
public class FooFactory {

  public Foo createFoo() {...}
}

使用 xml 很简单factory-method。我如何使用注释来做到这一点？

Answer 1

改用Java @Configuration：

@Configuration 
public class Config {

    @Bean
    public FooUser fooUser() {
        return new FooUser(foo());
    }

    @Bean
    public FooFactory fooFactory() {
        return new FooFactory();
    }

    @Bean
    public Foo foo() {
        return fooFactory().createFoo();
    }

}

Answer 2

您需要 java-config -注释。@Bean

将您的类定义为@Configuration，将您的方法定义为@Bean

Answer 3

Spring Components 也可以定义工厂方法。从文档中截取的：

@Component
public class FactoryMethodComponent {

  @Bean @Qualifier("public")
  public TestBean publicInstance() {
      return new TestBean("publicInstance");
  }

  public void doWork() {
      // Component method implementation omitted
  }
}

Answer 4

使用 FactoryBean Spring 接口。然后你将能够自动连接 T 本身

---

编辑： BeanFactory 是 Spring 中的一个接口，如果你实现它，你可以创建一个对象工厂，例如：

public class FooFactoryBean implements FactoryBean<Foo>{
   .................. 
   } 

然后你可以初始化bean：

@Bean
public FooFactoryBean foo(){ 
      return new FooFactoryBean(); 
    } 

那么如果你自动装配 Foo 它Spring会理解 FooFactoryBean 是所需的工厂

   @Autowired
       Foo foo;

Answer 5

Spring Boot：工厂方法

import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

enum ParsersConst {
    bofa, jpm, wellsforgo
}

interface Parser {
    String readFromFile(String file);
}

class JPM implements Parser {
    @Override
    public String readFromFile(String file) {
        System.out.println("From JPM Parser");
        //LOGIC to read file data
        return "JPM";
    }
}

class Bofa implements Parser {
    @Override
    public String readFromFile(String file) {
        System.out.println("From Bofa Parser");
        //LOGIC to read file data
        return "BOFA";
    }
}

class WellsForgo implements Parser {
    @Override
    public String readFromFile(String file) {
        System.out.println("From Wellsforgo Parser"); 
        //LOGIC to read file data
        return "WellsForgo";
    }
}

class ParserCreator {
    private Map<ParsersConst, Parser> parserMap;

    public Parser createParser(ParsersConst parsConst) {
        Parser parser = parserMap.get(parsConst);
        if (parserMap.get(parsConst) != null) {
            return parser;
        }
        throw new IllegalArgumentException("Unknown Parser");
    }

    public void setParserMap(Map<ParsersConst, Parser> parserMap) {
        this.parserMap = parserMap;
    }
}

@Configuration
class ParserConfig {

    @Bean
    public ParserCreator parserCreatorFactory() {
        ParserCreator factory = new ParserCreator();
        Map<ParsersConst, Parser> map = new HashMap<ParsersConst, Parser>();
        map.put(ParsersConst.bofa, new Bofa());
        map.put(ParsersConst.wellsforgo, new WellsForgo());
        map.put(ParsersConst.jpm, new JPM());
        factory.setParserMap(map);
        return factory;

    }

    @Bean
    public Parser bofa() {
        return parserCreatorFactory().createParser(ParsersConst.bofa);
    }

    @Bean
    public Parser wellsforgo() {
        return parserCreatorFactory().createParser(ParsersConst.wellsforgo);
    }

    @Bean
    public Parser jpm() {
        return parserCreatorFactory().createParser(ParsersConst.jpm);
    }
}

@Component
public class StaticFacotryDemo implements CommandLineRunner {
    @Autowired
    private ApplicationContext context;

    @Override
    public void run(String... args) throws Exception {

        Parser parser = (Parser) context.getBean(ParsersConst.jpm.toString());
        System.out.println(parser.readFromFile("jan_stmt.pdf"));

    }

}