from torchtext.data import Field,Example,Dataset
from torchtext import vocab
import os
import nltk

一、Field

1. 参数说明

squential：数据是否为序列数据，默认为Ture。如果为False，则不能使用分词。

use_vocab：是否使用词典，默认为True。如果为False，那么输入的数据类型必须是数值类型(即使用vocab转换后的)。

init_token：文本的其实字符，默认为None。

eos_token：文本的结束字符，默认为None。

fix_length：所有样本的长度，不够则使用pad_token补全。默认为None，表示灵活长度。

tensor_type：把数据转换成的tensor类型 默认值为torch.LongTensor。

preprocessing：预处理pipeline， 用于分词之后、数值化之前，默认值为None。

postprocessing：后处理pipeline，用于数值化之后、转换为tensor之前，默认为None。

lower：是否把数据转换为小写，默认为False；

tokenize：分词函数，默认为str.split

include_lengths：是否返回一个已经补全的最小batch的元组和和一个包含每条数据长度的列表，默认值为False。

batch_first：batch作为第一个维度；

pad_token：用于补全的字符，默认为<pad>。

unk_token：替换袋外词的字符，默认为<unk>。

pad_first：是否从句子的开头进行补全，默认为False；

truncate_first：是否从句子的开头截断句子，默认为False；

stop_words：停用词；

2. 例子

# 1.数据
corpus = ["D'aww! He matches this background colour",
         "Yo bitch Ja Rule is more succesful then",
         "If you have a look back at the source"]
labels = [0,1,0]
# 2.定义不同的Field
TEXT = Field(sequential=True, lower=True, fix_length=10,tokenize=str.split,batch_first=True)
LABEL = Field(sequential=False, use_vocab=False)
fields = [("comment", TEXT),("label",LABEL)]
# 3.将数据转换为Example对象的列表
examples = []
for text,label in zip(corpus,labels):
    example = Example.fromlist([text,label],fields=fields)
    examples.append(example)
print(type(examples[0]))
print(examples[0].comment)
print(examples[0].label)
# 4.构建词表
new_corpus = [example.comment for example in examples]
TEXT.build_vocab(new_corpus)
print(TEXT.process(new_corpus))

<class 'torchtext.data.example.Example'>
["d'aww!", 'he', 'matches', 'this', 'background', 'colour']
0
tensor([[ 8, 10, 15, 22,  5,  7,  1,  1,  1,  1],
        [23,  6, 13, 17, 12, 16, 19, 21,  1,  1],
        [11, 24,  9,  2, 14,  4,  3, 20, 18,  1]])

二、Tokenize

Field中的参数tokenize必须是一个函数，其作用是给定一个字符串，该函数以列表的形式返回分词结果。这里以jieba分词为例：

import jieba
# jieba分词返回的是迭代器，因此不能直接作为tokenize
print(jieba.cut("我爱北京天安门"))
# 使用lambda定义新的函数cut，其直接返回分词结果的列表，这样才可以作为tokenize
cut = lambda x:list(jieba.cut(x))
cut("我爱北京天安门")

<generator object Tokenizer.cut at 0x000002038CEFF938>
['我', '爱', '北京', '天安门']

三、Vocab

前面的代码中Field对象TEXT通过调用build_vocab()方法来生成一个内置的Vocab对象，即TEXT.build_vocab(new_corpus)。下面看一下Vocab对象的常见用法：

print(type(TEXT.vocab.freqs)) # freqs是一个Counter对象，包含了词表中单词的计数信息
print(TEXT.vocab.freqs['at'])
print(TEXT.vocab.itos[1]) # itos表示index to str
print(TEXT.vocab.stoi['<unk>']) # stoi表示str to index
print(TEXT.vocab.unk_index)
print(TEXT.vocab.vectors) # 词向量

<class 'collections.Counter'>
1
<pad>
0
0
None

四、Vectors

可以看到TEXT.vocab.vectors为None，因为在build_vocab()没有指定参数vectors，此时可以通过load_vectors方法来加载词向量。load_vectors的参数可以是字符串(例如:“fasttext.en.300d”)，其会自动下载词向量并缓存到本地。但如果是自己训练的词向量，则需要指定词向量在本地的路径。

1. 自动下载并加载词向量

TEXT.vocab.load_vectors('fasttext.en.300d')
print(TEXT.vocab.vectors.shape)

torch.Size([25, 300])

2.加载本地词向量

p = os.path.expanduser("~\\.vector_cache\\sgns.wiki.bigram-char")
TEXT.vocab.load_vectors(vocab.Vectors(p))

五、自定义Field

这里自定义Field，其通过字符串(例如:“nltk”、“jieba”、“str”)等方式指定tokenize，并且能够通过名称来指定自定义的词向量。

1. 定义

class MyField(Field):
    def __init__(self, tokenize="nltk",**kwargs):
        self.tokenize_name = tokenize
        tokenize = MyField._get_tokenizer(tokenize)
        super(MyField, self).__init__(tokenize=tokenize, **kwargs)
        
    @staticmethod
    def _get_tokenizer(tokenizer):
        if tokenizer=='nltk':
            return nltk.word_tokenize
        elif tokenizer=='jieba':
            return lambda x:list(jieba.cut(x))
        elif tokenizer=='split':
            return str.split
        else:
            raise ValueError("不支持的tokenizer")
    
    @classmethod
    def _get_vector_data(cls, vecs):
        if not isinstance(vecs, list):
            vecs = [vecs]
            
        vec_datas = []
        for vec in vecs:
            if not isinstance(vec, vocab.Vectors):
                if vec=="fasttext":
                    embed_file = os.path.expanduser("~\\.vector_cache\\wiki-news-300d-1M.vec")
                    vec_data = vocab.Vectors(embed_file)
                elif vec=='sgns':
                    embed_file = os.path.expanduser("~\\.vector_cache\\sgns.wiki.bigram-char")
                    vec_data = vocab.Vectors(embed_file)
                else:
                    raise ValueError("不支持的词向量类型")
                vec_datas.append(vec_data)            
            else:
                vec_datas.append(vec)
        return vec_datas
    
    def build_vocab(self, *args, vectors=None, **kwargs):
        if vectors is not None:
            vectors = MyField._get_vector_data(vectors)
        super(MyField, self).build_vocab(*args, vectors=vectors, **kwargs)

2.调用

corpus = ["D'aww! He matches this background colour",
         "Yo bitch Ja Rule is more succesful then",
         "If you have a look back at the source"]
TEXT = MyField(sequential=True, lower=True, fix_length=10,tokenize="jieba",batch_first=True)
fields = [("comment", TEXT)]
examples = []
for text in corpus:
    example = Example.fromlist([text],fields=fields)
    examples.append(example)
data = Dataset(examples, fields)
TEXT.build_vocab(data, vectors="sgns")
print(len(TEXT.vocab.freqs))
print(TEXT.vocab.vectors.shape)

<class 'torchtext.vocab.Vectors'>
27
torch.Size([29, 300])

问题概述

在项目开发过程中，使用基于字段变量的依赖注入（通过注解@Autowired进行注入）时（据大部分人在通常情况下都是使用@Autowired进行注入操作的）出现一个黄色警告下划线,提示 “ field injection is not recommended ”，作为一个现代的老码畜也看得很不爽，如下图：

解决办法

首先，我们需要了解三种常用的依赖注入方式：

基于构造器的依赖注入
基于Setter的依赖注入
基于字段变量的依赖注入

（当然还有其它不常用的注入方式：静态工厂方法注入、动态工厂方法注入）

各个依赖注入的实现方式：

构造器注入：

    private final InventoryMapper inventoryMapper;

    public InventoryController(InventoryMapper inventoryMapper) {
        this.inventoryMapper = inventoryMapper;
    }

Setter注入：

    private InventoryMapper inventoryMapper;

    public void setInventoryMapper(InventoryMapper inventoryMapper) {
        this.inventoryMapper = inventoryMapper;
    }

字段变量注入：

字段变量注入是基于注解实现的，即@Resource或者@Autowired，

    @Autowired
    private InventoryMapper inventoryMapper;

@Autowired：表示自动注入，自动从spring的上下文找到合适的bean来注入

@Resource：表示按指定名称注入，@Resource 可以通过 byName 和 byType的方式注入， 默认先按 byName的方式进行匹配，如果匹配不到，再按 byType的方式进行匹配。 当然，还可以为 @Service和@Resource 添加 name 这个属性来区分不同的实现。

@Component：表示一种泛指，被标记类即组件，Spring扫描注解配置时，会标记这些类要生成对应的bean。

@Qualifier和@Autowired配合使用，当一个接口有多个实现的时候，@Qualifier的value定了具体调用哪个类的实现（需要在实现类中通过@Service来表示每个不同的bean），也就是说指定了注入bean的名称。

Controller、Service、、Repository分别作用类是控制层类、业务层类、数据访问层类，Spring扫描注解配置时，会标记这些类要生成对应的bean。

@Autowired和@Resource是用来修饰字段，构造函数，或者方法，其作用是注入bean。而@Service，@Controller，@Repository，@Component则是用来修饰类，标记这些类要生成bean。

基于字段变量的依赖注入：

优点：基于字段变量的依赖注入方式非常简洁，没有任何多余代码，有效的提高了Java的简洁性。

缺点：不能指明具体的依赖。可能会遇见依赖注入的对象为null，所以这种方式过于依赖注入容器，当没有启动整个依赖容器时，这个类就不能运转，在反射时无法提供这个类需要的依赖。

如果使用基于Setter的依赖注入方式，它是一种选择性注入，可有可无的，即使没有注入这个依赖，也不会影响整个项目的运行。
如果基于构造器的依赖注入方式，它是一种强制性的，显示的注入。通过显示指明依赖注入来保证整个项目的运行。

对依赖注入的理解：
首先了解关于注入的两个概念IOC（控制反转）和DI（依赖注入），简单的说，IoC是一种思想，而DI则是一种行为。也可以说IoC是目的，DI是手段。IoC是指让生成类的方式由传统方式（new）反过来，开发程序时不需要调用new，当需要使用某个类的时候由框架来注入（DI）即可。

好了，上面关于依赖注入的知识就介绍到这儿吧，回归到问题！

关于 “ field injection is not recommended  ” 这个问题，其实不影响使用的，可以不必理会，

Spring 官方使用的注解方式：

如果只想代码简洁，只想使用@Autowired基于字段变量的依赖注入

终极解决办法：

Settings->Editor->Inspections->Spring->Spring Core->Core->Field Injection warning将Severity属性值改为 “ No highlighting,only fix ” 如下图：

修改完成后，如下图：

参考文献：

【spring-framework5.3.4docs】

【spring-guides】

 好了，关于 field injection is not recommended 的解决办法  就写到这儿了，如果还有什么疑问或遇到什么问题欢迎扫码提问，也可以给我留言哦，我会一一详细的解答的。 
歇后语：“ 共同学习，共同进步 ”，也希望大家多多关注CSND的IT社区。

欢迎访问我的GitHub

这里分类和汇总了欣宸的全部原创(含配套源码)：https://github.com/zq2599/blog_demos

系列文章汇总

• jackson学习之一：基本信息
• jackson学习之二：jackson-core
• jackson学习之三：常用API操作
• jackson学习之四：WRAP_ROOT_VALUE（root对象）
• jackson学习之五：JsonInclude注解
• jackson学习之六：常用类注解
• jackson学习之七：常用Field注解
• jackson学习之八：常用方法注解
• jackson学习之九：springboot整合(配置文件)
• jackson学习之十(终篇)：springboot整合(配置类)

本篇概览

1. 本文是《jackson学习》系列的第七篇，继续学习jackson强大的注解能力，本篇学习的是常用的Field注解，并通过实例来加深印象，下图是常用Field注解的简介：
   

2. 接下来逐个学习；

不止是Filed

• 虽然标题说是常用Field注解，其实上图中的这些注解也能用在方法上，只不过多数情况下这些注解修饰在field上更好理解一些，例如JsonIgnore，放在field上和get方法上都是可以的；

• 接下来逐个学习；

源码下载

1. 如果您不想编码，可以在GitHub下载所有源码，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)：

2. 这个git项目中有多个文件夹，本章的应用在jacksondemo文件夹下，如下图红框所示：
   
3. jacksondemo是父子结构的工程，本篇的代码在annotation子工程中，里面的fieldannonation这个package下，如下图：
   

JsonProperty

1. JsonProperty可以作用在成员变量和方法上，作用是在序列化和反序列化操作中指定json字段的名称；
2. 先来看序列化操作（JsonPropertySerialization.java），如下所示，JsonProperty修饰了私有成员变量field0和公共方法getField1，并且field0没有get和set方法，是通过构造方法设置的，另外还要注意JsonProperty注解的index属性，用来指定序列化结果中的顺序，这里故意将field1的顺序设置得比field0靠前：

    static class Test {

        @JsonProperty(value="json_field0", index = 1)
        private String field0;

        @JsonProperty(value="json_field1", index = 0)
        public String getField1() {
            return "111";
        }

        public Test(String field0) {
            this.field0 = field0;
        }
    }

3. 执行结果如下图红框所示，可见JsonProperty的value就是序列化后的属性名，另外带有JsonProperty注解的成员变量，即使是私有而且没有get和set方法，也能被成功序列化，而且顺序也和index属性对应：
   

4. 接下来看反序列化操作（JsonPropertyDeserialization.java），注解相关代码如下，field0是私有且没有get和set方法，另外setField1方法也有JsonProperty注解：

    static class Test {

        @JsonProperty(value = "json_field0")
        private String field0;

        private String field1;

        @JsonProperty(value = "json_field1")
        public void setField1(String field1) {
            this.field1 = field1;
        }

        @Override
        public String toString() {
            return "Test{" +
                    "field0='" + field0 + '\'' +
                    ", field1='" + field1 + '\'' +
                    '}';
        }
    }

5. 用json字符串尝试反序列化，结果如下，可见field0和field1都能被正确赋值：

JsonIgnore

1. JsonIgnore好理解，作用在成员变量或者方法上，指定被注解的变量或者方法不参与序列化和反序列化操作；
2. 先看序列化操作（JsonIgnoreSerialization.java），如下所示，Test类的field1字段和getField2方法都有JsonIgnore注解：

    static class Test {

        private String field0;

        @JsonIgnore
        private String field1;

        private String field2;

        public String getField0() { return field0; }
        public void setField0(String field0) { this.field0 = field0; }
        public String getField1() { return field1; }
        public void setField1(String field1) { this.field1 = field1; }
        public void setField2(String field2) { this.field2 = field2; }

        @JsonIgnore
        public String getField2() { return field2; }
    }

3. 给field0、field1、field2三个字段都赋值，再看序列化结果，如下图，可见field0和field2都被忽略了：
   

4. 再来尝试JsonIgnore注解在反序列化场景的作用，注意反序列化的时候，JsonIgnore作用的方法应该是set了，如下图：
   

5. 另外实测发现，反序列化的时候，JsonIgnore注解在get方法上也可以让对应字段被忽略；

JacksonInject

1. JacksonInject的作用是在反序列化的时候，将配置好的值注入被JacksonInject注解的字段；
2. 如下所示，Test类的field1和field2都有JacksonInject注解，不同的是field1指定了注入值的key为defaultField1，而field2由于没有指定key，只能按照类型注入：

    static class Test {
        private String field0;
        @JacksonInject(value = "defaultField1")
        private String field1;
        @JacksonInject
        private String field2;

3. 注入时所需的数据来自哪里呢？如下所示，通过代码配置的，可以指定key对应的注入值，也可以指定类型对应的注入值：

        InjectableValues.Std injectableValues = new InjectableValues.Std();
        // 指定key为"defaultField1"对应的注入参数
        injectableValues.addValue("defaultField1","field1 default value");
        // 指定String类型对应的注入参数
        injectableValues.addValue(String.class,"String type default value");
        ObjectMapper mapper = new ObjectMapper();        // 把注入参数的配置设置给mapper
        mapper.setInjectableValues(injectableValues);

4. 反序列化结果如下图，可见field1和field2的值都是被注入的：
   

JsonSerialize

1. JsonSerialize用于序列化场景，被此注解修饰的字段或者get方法会被用于序列化，并且using属性指定了执行序列化操作的类；
2. 执行序列化操作的类，需要继承自JsonSerializer，如下所示，Date2LongSerialize的作用是将Date类型转成long类型：

    static class Date2LongSerialize extends JsonSerializer<Date> {

        @Override
        public void serialize(Date value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            gen.writeNumber(value.getTime());
        }
    }

3. Test类的field0字段是私有的，且没有get和set方法，但是添加了注释JsonDeserialize就能被反序列化了，并且使用Date2LongSerialize类对将json中的long型转成field0所需的Date型：

    static class Test {
        @JsonDeserialize(using = Long2DateDeserialize.class)
        private Date field0;
        @Override
        public String toString() { return "Test{" + "field0='" + field0 + '\'' + '}'; }
    }

4. 执行结果如下：
   

JsonDeserialize

1. JsonDeserialize用于反序列化场景，被此注解修饰的字段或者set方法会被用于反序列化，并且using属性指定了执行反序列化操作的类；
2. 执行反序列化操作的类需要继承自JsonDeserializer，如下所示，Long2DateDeserialize的作用是将Long类型转成field0字段对应的Date类型：

    static class Long2DateDeserialize extends JsonDeserializer<Date> {

        @Override
        public Date deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {

            if(null!=p && null!=ctxt && p.getLongValue()>0L ) {
                return new Date(p.getLongValue());
            }

            return null;
        }
    }

3. 测试反序列化，结果如下：
   

JsonRawValue

最后要介绍的是JsonRawValue，使用该注解的字段或者方法，都会被序列化，但是序列化结果是原始值，例如字符串是不带双引号的：

• 至此，常用的Filed注解就操作完毕了，希望能带给您一些参考，助您更精确控制自己的序列化和反序列化操作；

欢迎关注公众号：程序员欣宸

微信搜索「程序员欣宸」，我是欣宸，期待与您一同畅游Java世界…