Spring Batch读取txt文件并写入数据库的方法教程

项目需求

近日需要实现用户推荐相关的功能，也就是说向用户推荐他可能喜欢的东西。

我们的数据分析工程师会将用户以及用户可能喜欢的东西整理成文档给我，我只需要将数据从文档中读取出来，然后对数据进行进一步的清洗（例如去掉特殊符号，长度如果太长则截取）。然后将处理后的数据存入数据库（mysql）。

所以分为三步：

• 读取文档获得数据
• 对获得的数据进行处理
• 更新数据库（新增或更新）

考虑到这个数据量以后会越来越大，这里没有使用 poi 来读取数据，而直接使用了 springbatch。

实现步骤

本文假设读者已经能够使用 springboot 连接处理 mysql，所以这部分文中会省略。

1、创建 maven 项目，并在 pom.xml 中添加依赖

<parent>
 <groupid>org.springframework.boot</groupid>
 <artifactid>spring-boot-starter-parent</artifactid>
 <version>1.5.2.release</version>
</parent>
<properties>
 <java.version>1.8</java.version>
</properties>
<dependencies>
 <dependency>
  <groupid>org.springframework.boot</groupid>
  <artifactid>spring-boot-starter-batch</artifactid>
 </dependency>
 <dependency>
  <groupid>org.springframework.boot</groupid>
  <artifactid>spring-boot-starter-data-jpa</artifactid>
 </dependency>
 <dependency>
  <groupid>org.springframework.boot</groupid>
  <artifactid>spring-boot-starter-test</artifactid>
  <scope>test</scope>
 </dependency>
 <dependency>
  <groupid>org.mybatis.spring.boot</groupid>
  <artifactid>mybatis-spring-boot-starter</artifactid>
  <version>1.2.0</version>
 </dependency>
 <!-- 工具类依赖-->
 <dependency>
  <groupid>org.projectlombok</groupid>
  <artifactid>lombok</artifactid>
  <version>1.12.6</version>
 </dependency>
 <dependency>
  <groupid>org.apache.commons</groupid>
  <artifactid>commons-lang3</artifactid>
  <version>3.4</version>
 </dependency>
 <!-- 数据库相关依赖 -->
 <dependency>
  <groupid>mysql</groupid>
  <artifactid>mysql-connector-java</artifactid>
  <scope>runtime</scope>
 </dependency>
 <dependency>
  <groupid>com.alibaba</groupid>
  <artifactid>druid</artifactid>
  <version>1.0.26</version>
 </dependency>
 <dependency>
  <groupid>org.springframework.boot</groupid>
  <artifactid>spring-boot-starter-web</artifactid>
 </dependency>
</dependencies>

这里是这个小项目中用到的所有依赖，包括连接数据库的依赖以及工具类等。

2、编写 model 类

我们要从文档中读取的有效列就是 uid，tag，type，就是用户 id，用户可能包含的标签（用于推送），用户类别（用户用户之间互相推荐）。

usermap.java 中的 @entity，@column 注解，是为了利用 jpa 生成数据表而写的，可要可不要。

usermap.java

@data
@equalsandhashcode
@noargsconstructor
@allargsconstructor
//@entity(name = "user_map")
public class usermap extends basemodel {
 @column(name = "uid", unique = true, nullable = false)
 private long uid;
 @column(name = "tag")
 private string tag;
 @column(name = "type")
 private integer type;
}

3、实现批处理配置类

batchconfiguration.java

@configuration
@enablebatchprocessing
public class batchconfiguration {
 @autowired
 public jobbuilderfactory jobbuilderfactory;
 @autowired
 public stepbuilderfactory stepbuilderfactory;
 @autowired
 @qualifier("proddatasource")
 datasource proddatasource;
 @bean
 public flatfileitemreader<usermap> reader() {
  flatfileitemreader<usermap> reader = new flatfileitemreader<>();
  reader.setresource(new classpathresource("c152.txt"));
  reader.setlinemapper(new defaultlinemapper<usermap>() {{
   setlinetokenizer(new delimitedlinetokenizer("|") {{
    setnames(new string[]{"uid", "tag", "type"});
   }});
   setfieldsetmapper(new beanwrapperfieldsetmapper<usermap>() {{
    settargettype(usermap.class);
   }});
  }});
  return reader;
 }
 @bean
 public jdbcbatchitemwriter<usermap> importwriter() {
  jdbcbatchitemwriter<usermap> writer = new jdbcbatchitemwriter<>();
  writer.setitemsqlparametersourceprovider(new beanpropertyitemsqlparametersourceprovider<>());
  writer.setsql("insert into user_map (uid,tag,type) values (:uid, :tag,:type)");
  writer.setdatasource(proddatasource);
  return writer;
 }
 @bean
 public jdbcbatchitemwriter<usermap> updatewriter() {
  jdbcbatchitemwriter<usermap> writer = new jdbcbatchitemwriter<>();
  writer.setitemsqlparametersourceprovider(new beanpropertyitemsqlparametersourceprovider<>());
  writer.setsql("update user_map set type = (:type),tag = (:tag) where uid = (:uid)");
  writer.setdatasource(proddatasource);
  return writer;
 }
 @bean
 public usermapitemprocessor processor(usermapitemprocessor.processstatus processstatus) {
  return new usermapitemprocessor(processstatus);
 }
 @bean
 public job importuserjob(jobcompletionnotificationlistener listener) {
  return jobbuilderfactory.get("importuserjob")
    .incrementer(new runidincrementer())
    .listener(listener)
    .flow(importstep())
    .end()
    .build();
 }
 @bean
 public step importstep() {
  return stepbuilderfactory.get("importstep")
    .<usermap, usermap>chunk(100)
    .reader(reader())
    .processor(processor(import))
    .writer(importwriter())
    .build();
 }
 @bean
 public job updateuserjob(jobcompletionnotificationlistener listener) {
  return jobbuilderfactory.get("updateuserjob")
    .incrementer(new runidincrementer())
    .listener(listener)
    .flow(updatestep())
    .end()
    .build();
 }
 @bean
 public step updatestep() {
  return stepbuilderfactory.get("updatestep")
    .<usermap, usermap>chunk(100)
    .reader(reader())
    .processor(processor(update))
    .writer(updatewriter())
    .build();
 }
}

proddatasource 是假设用户已经设置好的，如果不知道怎么配置，也可以参考之前的文章进行配置：springboot 集成 mybatis。

reader()，这方法从文件中读取数据，并且设置了一些必要的参数。紧接着是写操作 importwriter() 和 updatewriter() ，读者看其中一个就好，因为我这里是需要更新或者修改的，所以分为两个。

processor(processstatus status) ，该方法是对我们处理数据的类进行实例化，这里我根据 status 是 import 还是 update 来获取不同的处理结果。

其他的看代码就可以看懂了，哈哈，不详细说了。

4、将获得的数据进行清洗

usermapitemprocessor.java

public class usermapitemprocessor implements itemprocessor<usermap, usermap> {
 private static final int max_tag_length = 200;
 
 private processstatus processstatus;
 public usermapitemprocessor(processstatus processstatus) {
  this.processstatus = processstatus;
 }
 @autowired
 iusermapservice usermapservice;
 private static final string tag_pattern_str = "^[a-za-z0-9\\u4e00-\\u9fa5_-]+$";
 public static final pattern tag_pattern = pattern.compile(tag_pattern_str);
 private static final logger log = loggerfactory.getlogger(usermapitemprocessor.class);
 @override
 public usermap process(usermap usermap) throws exception {
  long uid = usermap.getuid();
  string tag = cleantag(usermap.gettag());
  integer label = usermap.gettype() == null ? integer.valueof(0) : usermap.gettype();
  if (stringutils.isnotblank(tag)) {
   map<string, object> params = new hashmap<>();
   params.put("uid", uid);
   usermap usermapfromdb = usermapservice.selectone(params);
   if (usermapfromdb == null) {
    if (this.processstatus == processstatus.import) {
     return new usermap(uid, tag, label);
    }
   } else {
    if (this.processstatus == processstatus.update) {
     if (!tag.equals(usermapfromdb.gettag()) && !label.equals(usermapfromdb.gettype())) {
      usermapfromdb.settype(label);
      usermapfromdb.settag(tag);
      return usermapfromdb;
     }
    }
   }
  }
  return null;
 }
 /**
  * 清洗标签
  *
  * @param tag
  * @return
  */
 private static string cleantag(string tag) {
  if (stringutils.isnotblank(tag)) {
   try {
    tag = tag.substring(tag.indexof("{") + 1, tag.lastindexof("}"));
    string[] tagarray = tag.split(",");
    optional<string> reduce = arrays.stream(tagarray).parallel()
      .map(str -> str.split(":")[0])
      .map(str -> str.replaceall("\'", ""))
      .map(str -> str.replaceall(" ", ""))
      .filter(str -> tag_pattern.matcher(str).matches())
      .reduce((x, y) -> x + "," + y);
    function<string, string> str = (s -> s.length() > max_tag_length ? s.substring(0, max_tag_length) : s);
    return str.apply(reduce.get());
   } catch (exception e) {
    log.error(e.getmessage(), e);
   }
  }
  return null;
 }
 protected enum processstatus {
  import,
  update;
 }
 public static void main(string[] args) {
  string distincttag = cleantag("counter({'《重新定义》': 3, '轻想上的轻小说': 3, '小说': 2, 'fate': 2, '同人小说': 2, '雪狼八组': 1, " +
    "'社会': 1, '人文': 1, '短篇': 1, '重新定义': 1, 'amv': 1, '《fbd》': 1, '《雪狼六组》': 1, '战争': 1, '《灰羽联盟》': 1, " +
    "'谁说轻想没人写小说': 1})");
  system.out.println(distincttag);
 }
}

读取到的数据格式如 main() 方法所示，清理之后的结果如：

轻想上的轻小说,小说,fate,同人小说,雪狼八组,社会,人文,短篇,重新定义,amv,战争,谁说轻想没人写小说 。

去掉了特殊符号以及数字等。使用了 java8 的 lambda 表达式。

并且这里在处理的时候，判断如果该数据用户已经存在，则进行更新，如果不存在，则新增。

5、job 执行结束回调类

jobcompletionnotificationlistener.java

@component
public class jobcompletionnotificationlistener extends jobexecutionlistenersupport {
 private static final logger log = loggerfactory.getlogger(jobcompletionnotificationlistener.class);
 private final jdbctemplate jdbctemplate;
 @autowired
 public jobcompletionnotificationlistener(jdbctemplate jdbctemplate) {
  this.jdbctemplate = jdbctemplate;
 }
 @override
 public void afterjob(jobexecution jobexecution) {
  system.out.println("end .....");
 }
}

具体的逻辑可自行实现。

完成以上几个步骤，运行项目，就可以读取并写入数据到数据库了。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对的支持。