Java 基于注释的工厂方法

我希望能够自动连接单例bean（

foo

）

由另一个单例方法（

FooFactory.createFoo

）创建

使用xml，它只是工厂方法。如何使用注释进行操作？

您需要java配置-

将类定义为

@Configuration

，将方法定义为

@Bean

，您需要java配置-

---

将类定义为

@Configuration

，将方法定义为

@Bean

改用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();
    }

}

---

请改用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();
    }

}

---

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

---

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

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

然后，如果您自动连接FooIt-Spring，则会理解FooFactoryBean是所需的工厂

   @Autowired
       Foo foo;

---

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

---

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

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

然后，如果您自动连接FooIt-Spring，则会理解FooFactoryBean是所需的工厂

   @Autowired
       Foo foo;

---

弹簧组件还可以定义工厂方法。从墙上剪下的一张照片：

---

弹簧组件还可以定义工厂方法。从墙上剪下的一张照片：

---

弹簧靴：工厂方法

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"));

    }

}

import java.util.HashMap；
导入java.util.Map；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.boot.CommandLineRunner；
导入org.springframework.context.ApplicationContext；
导入org.springframework.context.annotation.Bean；
导入org.springframework.context.annotation.Configuration；
导入org.springframework.stereotype.Component；
枚举解析器常量{
美国银行、摩根大通、wellsforgo
}
接口解析器{
字符串readFromFile（字符串文件）；
}
类JPM实现语法分析器{
@凌驾
公共字符串readFromFile（字符串文件）{
System.out.println（“来自JPM解析器”）；
//读取文件数据的逻辑
返回“JPM”；
}
}
类Bofa实现语法分析器{
@凌驾
公共字符串readFromFile（字符串文件）{
System.out.println（“来自美国银行解析器”）；
//读取文件数据的逻辑
返回“美国银行”；
}
}
类WellsForgo实现解析器{
@凌驾
公共字符串readFromFile（字符串文件）{
System.out.println（“来自Wellsforgo解析器”）；
//读取文件数据的逻辑
返回“WellsForgo”；
}
}
类解析器创建者{
私有地图；
公共解析器createParser（parserConst parscont）{
Parser=parserMap.get（parscont）；
if（parserMap.get（parscont）！=null）{
返回解析器；
}
抛出新的IllegalArgumentException（“未知解析器”）；
}
公共void setParserMap（映射parserMap）{
this.parserMap=parserMap；
}
}
@配置
类ParserConfig{
@豆子
公共ParserCreator parserCreatorFactory（）{
ParserCreator工厂=新的ParserCreator（）；
Map Map=newhashmap（）；
map.put（parserconst.bofa，new bofa（））；
put（parserconst.wellsforgo，new wellsforgo（））；
put（parserconst.jpm，newjpm（））；
工厂.setParserMap（地图）；
返回工厂；
}
@豆子
美国银行{
返回parserCreatorFactory（）.createParser（parserConst.bofa）；
}
@豆子
公共语法分析器wellsforgo（）{
返回parserCreatorFactory（）.createParser（parserConst.wellsforgo）；
}
@豆子
公共解析器jpm（）{
返回parserCreatorFactory（）.createParser（parserConst.jpm）；
}
}
@组成部分
公共类StaticFacoderydemo实现CommandLineRunner{
@自动连线
私有应用程序上下文上下文；
@凌驾
公共无效运行（字符串…参数）引发异常{
Parser=（Parser）context.getBean（parserconst.jpm.toString（））；
System.out.println（parser.readFromFile（“jan_stmt.pdf”）；
}
}

弹簧靴：出厂方法

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"));

    }

}

import java.util.HashMap；
导入java.util.Map；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.boot.CommandLineRunner；
导入org.springframework.context.ApplicationContext；
导入org.springframework.context.annotation.Bean；
导入org.springframework.context.annotation.Configuration；
导入org.springframework.stereotype.Component；
枚举解析器常量{
美国银行、摩根大通、wellsforgo
}
接口解析器{
字符串readFromFile（字符串文件）；
}
类JPM实现语法分析器{
@凌驾
公共字符串readFromFile（字符串文件）{
System.out.println（“来自JPM解析器”）；
//读取文件数据的逻辑
返回“JPM”；
}
}
类Bofa实现语法分析器{
@凌驾
公共字符串readFromFile（字符串文件）{
System.out.println（“来自美国银行解析器”）；
//读取文件数据的逻辑
返回“美国银行”；
}
}
类WellsForgo实现解析器{
@凌驾
公共字符串readFromFile（字符串文件）{
System.out.println（“来自Wellsforgo解析器”）；
//读取文件数据的逻辑
返回“WellsForgo”；
}
}
类解析器创建者{
私有地图；
公共解析器createParser（parserConst parscont）{
Parser=parserMap.get（parscont）；
if（parserMap.get（parscont）！=null）{
返回解析器；
}
抛出新的IllegalArgumentException（“未知解析器”）；
}
公共void setParserMap（映射parserMap）{
this.parserMap=parserMap；
}
}
@配置
类ParserConfig{
@豆子
公共ParserCreator parserCreatorFactory（）{
ParserCreator工厂=新的ParserCreator（）；
Map Map=newhashmap（）；
map.put（parserconst.bofa，new bofa（））；
put（parserconst.wellsforgo，new wellsforgo（））；
put（parserconst.jpm，newjpm（））；
fa