大数据综合项目DocCloud之需求分析与功能实现详细（续更）

DocCloud项目需求

项目背景：

在一些大型企事业单位，工作中存在各种各样的工作文档，技术文档，规范等等。这些文档以word,xls,ppt,wps,pdf,txt存在。在此项目之前，文档的分享主要靠单位内部人员的互相发送。没有一个统一的平台对企业现存的各种文档进行统一管理。DocCloud项目提供了统一的文档管理平台。用户可以将文档上传至平台，所有其他用户可以在线查看此文档。同时满足搜索文档，分享，收藏等等一系列需求。在实践中，有百度文库，doc88，豆丁等公网项目。但是没有一个专门为企业用户服务的一个文档管理平台。

项目需求：

1.文档的统一存储

2.文档的检索

3.文档的在线预览

4.文档分享

5.文档推荐

6.文档上传下载

7.用户的注册，登录

8.文档权限管理

项目架构：

HDFS+LibreOffice6.0+solr+nginx+flume+hive+springboot+jpa+js+html+css

文档存储： HDFS

文件存储：1.本地（linux）-web服务器 优缺点：内存小，但是存储方便

2.ftp服务器（搭建一个存储文件的集群）优缺点：文档存储内存够，但是不能容错

3.hdfs （hadoop集群）优缺点：可扩展、容错、分布式存储

文档格式转换： LibreOffice6.0

因为存储的内容不是纯文本，就是传统的io流不能用、需要变成纯文本文件（txt）

doc、docx、ppt---→html---→txt

使用LibreOffice6.0，不适用word的原因：1.没有接口（不开源）2.不能再linux上运行

进程间通信：hadoop ipc

全文检索： solr

日志记录服务器：ngnix

web日志采集：flume

日志分析：hive

webMvc:springboot

持久层框架：jpa

单元测试：junit4

前端：css+html+js+jquery+bootstrap

版本管理：svn

依赖管理：maven

开发环境：idea

部署环境：linux

数据库：mysql

 

项目具体设计：

1.文档的上传下载

a.用户在前端点击上传按钮

b.在本地选择上传文档

c.开始上传

b.服务端校验文件后缀是否符合文档格式。

允许格式：doc,docx,ppt,pptx,xls,xlsx,pdf,txt

目的：避免上传不能转码的文档如：exe,zip,….

e.校验文档大小，允许128兆以下的文档上传。

128M：为了使文档在hdfs是一个块的形式保存。

f.计算文档的md5值，判断文档是否在文库中已经存在，如果存在，告知用户已经存在。

g.不存在，则上传至hdfs，同时数据库中保存用户上传文档信息。

数据保存在hdfs上，元数据保存在数据库mysql

2.上传成功以后需要提交文档转换任务(主要功能如下)

      1>转换成html

       2>转换成pdf提取缩略图，页数

       3>提取文本 建立索引

---

以下代码没有涉及前端、只是后台测试（使用Postman测试），部分参数都没有从session中获取，都是随机生成的

没有软件的附上资源（下载双击安装就可以）：链接：https://pan.baidu.com/s/1SibrDOB4GwkX4L0iw3nYTA 
提取码：bisn

一、功能一：上传文件/2018.10.29

日志配置：

         在类名上添加注解

         @Slf4j

         直接在类中使用log记录日志

文件上传：

         关键注解：

         @RequestParam("file") MultipartFile file

         获取上传文件名：

         file.getOriginalFilename()

 

创建一个java项目DocCloud

在DocCloud中创建model---->doccloudweb(模块名要小写)

在module中选择Spring Initializr

在创建module时，选择pom中的依赖如下,选完之后一路下一步

core下选择DevTools、LomBok

web下选择web

sql下选择JPA、mysql

NoSQL下选solr

 

<dependencies>
    <!--数据相关依赖-持久层-->
    <!--<dependency>-->
        <!--<groupId>org.springframework.boot</groupId>-->
        <!--<artifactId>spring-boot-starter-data-jpa</artifactId>-->
    <!--</dependency>-->
    <!--全文检索-->
    <!--<dependency>-->
        <!--<groupId>org.springframework.boot</groupId>-->
        <!--<artifactId>spring-boot-starter-data-solr</artifactId>-->
    <!--</dependency>-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--热部署-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!--数据库连接-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!--单元测试-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.6.RELEASE</version>
    </dependency>                   
</dependencies>

<!--编译、打jar包-->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

以上是创建项目选择的依赖，请添加以下外加依赖

<!--上传文件到hdfs上-->

        <dependency>

            <groupId>org.apache.hadoop</groupId>

            <artifactId>hadoop-common</artifactId>

            <version>2.7.5</version>

        </dependency>

        <dependency>

            <groupId>org.apache.hadoop</groupId>

            <artifactId>hadoop-hdfs</artifactId>

            <version>2.7.5</version>

        </dependency>

数据库创建Doc_cloud

Doc:记录文件属性

使用jpa---->java+persistence+api

JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中

1.配置数据源application.properties

#数据源配置
spring.datasource.name=root
spring.datasource.password=123
#true：表示展示sql语句
spring.jpa.show-sql=true
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/doc_cloud

2..上传文件到hdfs上用到的core-site.xml

<?xml version="1.0" encoding="UTF-8"?>

<configuration>

    <property>

        <name>fs.defaultFS</name>

        <value>hdfs://master2:9000</value>

    </property>

    <property>

        <name>fs.hdfs.impl</name>

        <value>org.apache.hadoop.hdfs.DistributedFileSystem</value>

    </property>

</configuration>

3.编写controller层-- DocController

import com.zhiyou100.doccloudweb.service.DocService;

import com.zhiyou100.doccloudweb.util.HdfsUtil;

import com.zhiyou100.doccloudweb.util.MD5Util;

import com.zhiyou100.doccloudweb.entity.Doc;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Optional;

import java.util.Random;

@Controller  //表示是controller层--业务层

@RequestMapping("/doc")

@Slf4j

public class DocController {

    @Autowired

    private DocService docService;

    //定义合法的文件后缀类型

    public static final String[] DOC_SUFFIXS= new String[]{"doc", "docx", "ppt", "pptx", "txt", "xls", "xlsx", "pdf"};

    //定义文件最大大小

    public static final int DOC_MAX_SIZE = 128*1024*1024;

    //定义文件保存到hdfs上的根目录

    public static final String HOME="hdfs://192.168.228.13:9000/doccloud";

    @RequestMapping("/upload")

    @ResponseBody

    public String upload(@RequestParam("file") MultipartFile file){

        //判断是否是文件

        if (file.isEmpty()){

            return "file is empty";

        }

        //获取文件名

        String filename = file.getOriginalFilename();

        //以点分割-获取文件后缀

        String[] strings = filename.split("\\.");

        if (strings.length==1){

            return "file does not has suffix";

        }

        String suffix = strings[1];

        log.info("doc suffix is {}",suffix);

        //1.判断文件后缀是否合法

        boolean flag = isSuffixLegal(suffix);

        if (!flag){

            return "file is illegal";

        }

        try {

            //2.判断文件大小是否合法

            byte[] bytes = file.getBytes();

            log.info("file size is {}",bytes.length);

            if (bytes.length>DOC_MAX_SIZE){

                return "file is large,file Max size:"+DOC_MAX_SIZE;

            }

            //3.计算文档的MD5值

            String md5 = getMD5(bytes);

            log.info("file is md5 {} ",md5);

            //用户上传文件，保存到数据库

            //1.校验数据库中的md5值，判断数据库中是否存在

            Optional<Doc> doc = docService.findByMd5(md5);

            if (doc.isPresent()){

                //2.如果存在，更新

                // 2.1获取文件对象

                Doc docEntity = doc.get();

                //2.2设置文件更新的人

                docEntity.setUserId(new Random().nextInt());

                //2.3保存到数据库

                docService.save(docEntity);

            }else {

                //3.如果不存在,将文件元数据保存到数据库，将数据保存到hdfs

                //3.1保存数据到hdfs

                //3.1.1生成文件保存路径:HOME+当前时间

                String date = getDate();

                String dst = HOME+"/"+date+"/"+file.getOriginalFilename()+"/";

                log.info("file dst {}",dst);

                //3.1.2上传文件

                HdfsUtil.upload(bytes,file.getOriginalFilename(),dst);

                //3.2将元数据保存到数据库

                //3.2.1创建一个文件对象

                Doc docEntity = new Doc();

                //3.2.2设置作者

                docEntity.setUserId(new Random().nextInt());

                //3.2.3设置备注

                docEntity.setDocComment("hadoop");

                //3.2.4设置文件路径

                docEntity.setDocDir(dst);

                //3.2.5设置文件名

                docEntity.setDocName(filename);

                //3.2.6设置文件大小

                docEntity.setDocSize(bytes.length);

                //3.2.7设置文件权限

                docEntity.setDocPermission("1");

                //3.2.8设置文件类型（后缀）

                docEntity.setDocType(suffix);

                //3.2.9设置文件状态

                docEntity.setDocStatus("upload");

                //3.2.10设置文件的md5值--保证文件的唯一性

                docEntity.setMd5(md5);

                //3.2.11设置文件创作时间

                docEntity.setDocCreateTime(new Date());

                //3.2.12保存元数据

                docService.save(docEntity);

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

        return "upload success";

    }

    /**

     * 获取当前是时间，用于文件的保存路径

     * @return

     */

    private String getDate() {

        Date date = new Date();

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");

        return simpleDateFormat.format(date);

    }

    /**

     * 计算字节数组的MD5值

     * @param bytes

     * @return

     */

    private String getMD5(byte[] bytes) {

        return MD5Util.getMD5String(bytes);

    }

    /**

     * 判断文件后缀是否合法

     * @param suffix

     * @return

     */

    private boolean isSuffixLegal(String suffix) {

        for (String docsuffix :

                DOC_SUFFIXS) {

            if (suffix.equals(docsuffix)){

                return true;

            }

        }

        return false;

    }

}

 

4.编写业务层service层-- DocService

import com.zhiyou100.doccloudweb.dao.DocRepository;

import com.zhiyou100.doccloudweb.entity.Doc;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import java.util.Optional;

@Service

public class DocService {

    @Autowired

    private DocRepository docRepository;

    //通过id获取文件对象

    public Optional<Doc> findById(int id) {

        return docRepository.findById(id);

    }

    //通过MD5获取文件对象

    public Optional<Doc> findByMd5(String md5) {

        return docRepository.findByMd5(md5);

    }

    //保存文件对象到数据库

    public void save(Doc docEntity) {

        docRepository.save(docEntity);

    }

}

    //定义合法的文件后缀类型

    public static final String[] DOC_SUFFIXS= new String[]{"doc", "docx", "ppt", "pptx", "txt", "xls", "xlsx", "pdf"};

    //定义文件最大大小

    public static final int DOC_MAX_SIZE = 128*1024*1024;

    @RequestMapping("/doclist")

    @ResponseBody

    Doc doList(){

        Optional<Doc> id = docService.findById(1);

        return null;

    }

 

5.dao层—持久层--DocRepository

import com.zhiyou100.doccloudweb.entity.Doc;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.stereotype.Repository;

import java.util.Optional;

@Repository

//Doc:表示定义的实体类，Integer：表示主键类型

public interface DocRepository extends JpaRepository<Doc,Integer> {

    //利用反射机制自动识别

    Optional<Doc> findByMd5(String md5);

}

 

6.实体层—Doc

import lombok.Data;

import org.springframework.web.bind.annotation.ResponseBody;

import javax.persistence.*;

import java.util.Date;

/**

 * 文件属性

 */

@Entity

@Table(name = "doc") //映射到数据库中的表

@Data //get/set

public class Doc {

 

    @Id //主键

    //告诉框架id生成策略（怎么生成）GenerationType.IDENTITY：表示自动生成

    @GeneratedValue(strategy = GenerationType.IDENTITY)

    private int id;

    @Column(name = "md5")//如果数据库字段与entity中字段名一样，则不用加此注解

    private String md5;

    @Column(name = "doc_name")

    private String docName;

    @Column(name = "doc_type")

    private String docType;

    @Column(name = "doc_status")

    private String docStatus;

    @Column(name = "doc_size")

    private int docSize;

    @Column(name = "doc_dir")

    private String docDir;

    @Column(name = "user_id")

    private int userId;

    @Column(name = "doc_create_time")

    private Date docCreateTime;

    @Column(name = "doc_comment")

    private String docComment;

    @Column(name = "doc_permission")

    private String docPermission;

}

7.工具类

HdfsUtil 

import com.google.common.io.Resources;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
 
import java.io.IOException;
 
/*
*@ClassName:HdfsUtil
 @Description:TODO
 @Author:
 @Date:2018/10/29 17:17 
 @Version:v1.0
*/
public class HdfsUtil {
    //文档上传工具类
    public static void upload(byte[] src, String docName, String dst) throws IOException {
        //加载配置文件
        Configuration coreSiteConf = new Configuration();
        coreSiteConf.addResource(Resources.getResource("core-site.xml"));
        //获取文件系统客户端对象
        FileSystem fileSystem = FileSystem.get(coreSiteConf);
 
        FSDataOutputStream fsDataOutputStream = fileSystem.create(new Path(dst + "/" + docName));
 
        fsDataOutputStream.write(src);
        fsDataOutputStream.close();
        fileSystem.close();
    }
}

MD5Util 

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
 
public class MD5Util {
    protected static char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
    protected static MessageDigest messagedigest = null;
 
    /**
     * MessageDigest初始化
     *
     * @author
     */
    static {
        try {
            messagedigest = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException e) {
            System.err.println("MD5FileUtil messagedigest初始化失败");
            e.printStackTrace();
        }
    }
 
    /**
     * 对文件进行MD5加密
     *
     * @author
     */
    public static String getFileMD5String(File file) throws IOException {
        FileInputStream in = new FileInputStream(file);
        FileChannel ch = in.getChannel();
        MappedByteBuffer byteBuffer = ch.map(FileChannel.MapMode.READ_ONLY, 0, file.length());
        messagedigest.update(byteBuffer);
        return bufferToHex(messagedigest.digest());
    }
 
    /**
     * 对字符串进行MD5加密
     *
     * @author
     */
    public static String getMD5String(String s) {
        return getMD5String(s.getBytes());
    }
 
    /**
     * 对byte类型的数组进行MD5加密
     *
     * @author
     */
    public static String getMD5String(byte[] bytes) {
        messagedigest.update(bytes);
        return bufferToHex(messagedigest.digest());
    }
 
    private static String bufferToHex(byte bytes[]) {
        return bufferToHex(bytes, 0, bytes.length);
    }
 
    private static String bufferToHex(byte bytes[], int m, int n) {
        StringBuffer stringbuffer = new StringBuffer(2 * n);
        int k = m + n;
        for (int l = m; l < k; l++) {
            char c0 = hexDigits[(bytes[l] & 0xf0) >> 4];
            char c1 = hexDigits[bytes[l] & 0xf];
            stringbuffer.append(c0);
            stringbuffer.append(c1);
        }
        return stringbuffer.toString();
    }
}

---

二、功能：文档转换

上传成功以后需要提交文档转换任务(主要功能如下)

      1>转换成html

       2>转换成pdf提取缩略图，页数

       3>提取文本 建立索引

1.定义一个docjob对象，用于封装任务信息

2.实现writable接口。因为要通过hadoop ipc序列化实现文档转换守护进程
该进程的作用是完成存放在本节点文档的转换，索引的任务。

1.文档转换成htm!通过runtime.exec执行命令来实现

2.通过hadoop ipc来接受任务

hadoop ipc
hadoop ipc是一套hadoop自带的成熟的rpc框架，性能高，稳定性性强。

server:
a.服务端定义接口b.定义按口的实现类
c用hadoop ipc暴露服务

client;
通过rpc.geproxy来调用服务岗的接口。

---

下面创建的是服务端的代码： 

1.新建模块--docservicedeamon文件转换守护进程

2.pom文件中的依赖

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.5</version>
</dependency>
<!--ipc通信模块-->
<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-common</artifactId>
    <version>2.7.5</version>
</dependency>
<!--注解、-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.16.20</version>
</dependency>
<!--berklydb数据库依赖-->
<!-- https://mvnrepository.com/artifact/com.sleepycat/je -->
<dependency>
    <groupId>com.sleepycat</groupId>
    <artifactId>je</artifactId>
    <version>5.0.73</version>
</dependency>
<!--hdfs文件上传与下载-->
<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-hdfs</artifactId>
    <version>2.7.5</version>
</dependency>

 

3.配置core-site.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <property>
        <name>fs.defaultFS</name>
        <value>hdfs://master2:9000</value>
    </property>
    <property>
        <name>fs.hdfs.impl</name>
        <value>org.apache.hadoop.hdfs.DistributedFileSystem</value>
    </property>
</configuration>

4.类一---DocJob

import lombok.Data;
import org.apache.hadoop.io.Writable;
 
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.io.Serializable;
 
/**
 *此方法用于封装任务信息
 */
@Data
public class DocJob implements Writable,Serializable {
    private static final long serialVersionUID = 12345678L;
    //任务id
    private int id;
    //任务名
    private String name;
    //任务类型
    private DocJobType jobType;
    //提交者
    private int userId;
    //提交时间
    private long submitTime;
    //完成时间
    private long finishTime;
    //任务状态
    private JobStatus jobStatus;
    //任务重试次数
    private int retryTime;
    //文档输入路径
    private String input;
    //任务输出路径
    private String output;
    //文件名
    private String fileName;
    public void write(DataOutput out) throws IOException {
        out.writeInt(id);
        out.writeUTF(name);
        out.writeUTF(jobType.name());
        out.writeInt(userId);
        out.writeLong(finishTime);
        out.writeLong(submitTime);
        out.writeUTF(jobStatus.name());
        out.writeInt(retryTime);
        out.writeUTF(input);
        out.writeUTF(output);
        out.writeUTF(fileName);
    }
 
    public void readFields(DataInput in) throws IOException {
        id= in.readInt();
        name=in.readUTF();
        jobType=DocJobType.valueOf(in.readUTF());
        userId=in.readInt();
        finishTime=in.readLong();
        submitTime=in.readLong();
        jobStatus=JobStatus.valueOf(in.readUTF());
        retryTime=in.readInt();
        input=in.readUTF();
        output=in.readUTF();
        fileName=in.readUTF();
    }
}

5.类二、DocJobType

/**
 * 项目的类型：文档转换、定义索引...
 */
public enum DocJobType {
    DOC_JOB_CONVERT,DOC_JOB_CREATE_INDEX,DOC_JOB_UPDATE_INDEX
}

6.类三、JobStatus

/**
 * 文档状态：准备、提交、运行、失败、完成
 */
public enum JobStatus {
    PREPARE,SUBMIT,RUNNING,FAILED,SUCCEED,
}

7类四、.JobDaemonService

/**
 * 服务端
 * 1.定义接口继承VersionedProtocol
 */
public interface JobDaemonService extends VersionedProtocol {
    //定义通信间的暗号
    long versionID=1L;
    //定义提交方法
    void submitDocJob(DocJob job);
 
}

8.类五、JobDaemonServiceImpl

import com.zhiyou100.doccloud.utils.BdbPersistentQueue;
import lombok.extern.slf4j.Slf4j;
import org.apache.hadoop.ipc.ProtocolSignature;
 
 
import java.io.File;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
/**
 * 2.定义接口的实现类
 * 实现Runnable接口：是为了使用多线程处理
 */
@Slf4j
public class JobDaemonServiceImpl implements JobDaemonService,Runnable{
    //定义将hdfs下载到本地的目录的根路径
    private static final String WORK_DIR="/tmp/docjobdaemon/";
    //定义持久化对象
    public  BdbPersistentQueue<DocJob> queue;
    //定义线程池--多线程并行处理
    private ExecutorService pool = Executors.newFixedThreadPool(4);
    //定义一个标准-让线程运行
    private boolean flag = true;
 
    //构造方法：用于创建berkly数据库目录，并初始化持久化队列
    public JobDaemonServiceImpl(){
        //创建工作目录--本地保存路径
        File workDir = new File(WORK_DIR + "/" + "bdb/");
        if (!workDir.exists()){
            //如果不存在将创建
            workDir.mkdirs();
            System.out.println(workDir.getAbsolutePath());
        }
        //初始化持久化队列
        queue = new BdbPersistentQueue<DocJob>(WORK_DIR+"/"+"bdb/", "docjob", DocJob.class);
    }
 
    public void submitDocJob(DocJob job) {
        System.out.println(job);
        //将任务保存在序列化队列中，1.保证任务不丢失   2.并发控制，内存溢出
        log.info("receive job {}",job);
        queue.offer(job);
    }
 
    public long getProtocolVersion(String s, long l) throws IOException {
        return versionID;
    }
 
    public ProtocolSignature getProtocolSignature(String s, long l, int i) throws IOException {
        return null;
    }
 
    @Override
    public void run() {
        while (flag){
            //将任务从序列化队列中取出任务,poll:每取出一个就从磁盘中移除一个
            DocJob docJob = queue.poll();
            //判断docjob中否为空
            if (docJob==null){
                //为空，等待5000毫秒
                try {
                    Thread.sleep(5000);
                    System.out.println("waiting for docjob");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {
                pool.submit(new DocJobHandler(docJob));
            }
        }
    }
}

9.类六、Main

import com.zhiyou100.doccloud.job.JobDaemonService;
import com.zhiyou100.doccloud.job.JobDaemonServiceImpl;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.ipc.RPC;
 
import java.io.IOException;
 
/**
 * 守护进程--项目的入口类
 * 3.服务端：暴露端口
 */
public class Main {
    public static void main(String[] args) throws IOException {
        //创建服务端接口实现类对象
        JobDaemonServiceImpl instance = new JobDaemonServiceImpl();
        //开启线程
        new Thread(instance).start();
 
        // 创建一个RPC builder
        RPC.Builder builder = new RPC.Builder(new Configuration());
 
        //指定RPC Server的参数
        builder.setBindAddress("localhost");
        builder.setPort(7788);
 
        //将自己的程序部署到server上
        builder.setProtocol(JobDaemonService.class);
        builder.setInstance(instance);
 
        //创建Server
        RPC.Server server = builder.build();
 
        //启动服务
        server.start();
    }
}

10.类七--DocJobHandler

import com.zhiyou100.doccloud.utils.HdfsUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
 
import java.io.File;
import java.io.IOException;
import java.util.UUID;
 
@Slf4j
public class DocJobHandler implements Runnable {
    private DocJob docJob;
 
    public DocJobHandler(DocJob docJob) {
        this.docJob = docJob;
        log.info("start to deal job {}",docJob);
    }
 
    /**
     *将文件冲hdfs上下载到本地，再将文件格式转化成HTML，最终上传到hdfs上
     */
    @Override
    public void run() {
        //1.将hdfs上的文件下载到本地
        //1.1获取文件的下载路径（在hdfs上的位置）
        String input = docJob.getInput();
        //1.2创建目标路径（下载到本地的路径）
        String tmpWorkDirPath = "/tmp/docjobdaemon/" + UUID.randomUUID().toString() + "/";
        File tmpWorkDir = new File(tmpWorkDirPath);
        tmpWorkDir.mkdirs();
        System.out.println("tmpWorkDirPath: "+tmpWorkDirPath);
        //1.3下载文件到临时目录
        try {
            HdfsUtil.copyToLocal(input,tmpWorkDirPath);
            log.info("download file to {}",tmpWorkDirPath);
            //step1:将下载到本地的文件格式转化成HTML
            String command = "D:\\soft\\LibreOffice_6.0.6\\program\\soffice --headless --invisible --convert-to html " + docJob.getFileName();
            Process process = Runtime.getRuntime().exec(command, null, tmpWorkDir);
            //结果信息
            System.out.println(IOUtils.toString(process.getInputStream()));
            //错误信息
            System.out.println(IOUtils.toString(process.getErrorStream()));
            //step2 转换成pdf
            //step3 提取页码
            //step4 提取首页缩略图
            //step5 利用solr建立索引
            //step6 上传结果
            //step7 清理临时目录
            //step8 任务成功回调
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }
}

---

工具类、

将hdfs上的文件下载到本地--HdfsUtil

import com.google.common.io.Resources;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;

import java.io.IOException;
import java.net.URI;

public class HdfsUtil {
    public static final String HOME="hdfs://192.168.228.13:9000/";
    //文档上传工具类
    public static void upload(byte[] src, String docName, String dst) throws IOException {
        //加载配置文件
        Configuration coreSiteConf = new Configuration();
        coreSiteConf.addResource(Resources.getResource("core-site.xml"));
        //获取文件系统客户端对象
        FileSystem fileSystem = FileSystem.get(coreSiteConf);

        FSDataOutputStream fsDataOutputStream = fileSystem.create(new Path(dst + "/" + docName));

        fsDataOutputStream.write(src);
        fsDataOutputStream.close();
        fileSystem.close();
    }

    /**
     * 将集群的问价下载到本地
     * @param dst
     * @param localPath
     * @throws IOException
     */
    public static void copyToLocal(String dst,String localPath) throws IOException {
        Configuration conf = new Configuration();
        conf.addResource(Resources.getResource("core-site.xml"));
        FileSystem fs = FileSystem.get(URI.create(dst),conf);
        fs.copyToLocalFile(new Path(dst),new Path(localPath));
        fs.close();
    }
}

持久化队列,基于BDB实现--BdbPersistentQueue&&BdbEnvironment

import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.util.AbstractQueue;
import java.util.Iterator;
import java.util.concurrent.atomic.AtomicLong;
 
import org.apache.commons.io.FileUtils;
 
import com.sleepycat.bind.EntryBinding;
import com.sleepycat.bind.serial.SerialBinding;
import com.sleepycat.bind.serial.StoredClassCatalog;
import com.sleepycat.bind.tuple.TupleBinding;
import com.sleepycat.collections.StoredMap;
import com.sleepycat.collections.StoredSortedMap;
import com.sleepycat.je.Database;
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.DatabaseExistsException;
import com.sleepycat.je.DatabaseNotFoundException;
import com.sleepycat.je.EnvironmentConfig;
/**
 * 持久化队列,基于BDB实现,也继承Queue,以及可以序列化.但不等同于Queue的时,不再使用后需要关闭
 * 相比一般的内存Queue,插入和获取值需要多消耗一定的时间
 * 这里为什么是继承AbstractQueue而不是实现Queue接口,是因为只要实现offer,peek,poll几个方法即可,
 * 其他如remove,addAll,AbstractQueue会基于这几个方法去实现
 *
 * @contributor 
 * @param <E>
 */
public class BdbPersistentQueue<E extends Serializable> extends AbstractQueue<E> implements
        Serializable {
    private static final long serialVersionUID = 3427799316155220967L;
    private transient BdbEnvironment dbEnv;            // 数据库环境,无需序列化
    private transient Database queueDb;             // 数据库,用于保存值,使得支持队列持久化,无需序列化
    private transient StoredMap<Long,E> queueMap;   // 持久化Map,Key为指针位置,Value为值,无需序列化
    private transient String dbDir;                 // 数据库所在目录
    private transient String dbName;                // 数据库名字
    //AtomicLong:元子类型，线程安全
    //i++线程不安全
    private AtomicLong headIndex;                   // 头部指针
    private AtomicLong tailIndex;                   // 尾部指针
    private transient E peekItem=null;              // 当前获取的值
 
    /**
     * 构造函数,传入BDB数据库
     *
     * @param db
     * @param valueClass
     * @param classCatalog
     */
    public BdbPersistentQueue(Database db,Class<E> valueClass,StoredClassCatalog classCatalog){
        this.queueDb=db;
        this.dbName=db.getDatabaseName();
        headIndex=new AtomicLong(0);
        tailIndex=new AtomicLong(0);
        bindDatabase(queueDb,valueClass,classCatalog);
    }
    /**
     * 构造函数,传入BDB数据库位置和名字,自己创建数据库
     *
     * @param dbDir
     * @param dbName
     * @param valueClass
     */
    public BdbPersistentQueue(String dbDir,String dbName,Class<E> valueClass){
        //headIndex=new AtomicLong(0);
        //tailIndex=new AtomicLong(0);
        this.dbDir=dbDir;
        this.dbName=dbName;
        createAndBindDatabase(dbDir,dbName,valueClass);
    }
    /**
     * 绑定数据库
     *
     * @param db
     * @param valueClass
     * @param classCatalog
     */
    public void bindDatabase(Database db, Class<E> valueClass, StoredClassCatalog classCatalog){
        EntryBinding<E> valueBinding = TupleBinding.getPrimitiveBinding(valueClass);
        if(valueBinding == null) {
            valueBinding = new SerialBinding<E>(classCatalog, valueClass);   // 序列化绑定
        }
        queueDb = db;
        queueMap = new StoredSortedMap<Long,E>(
                db,                                             // db
                TupleBinding.getPrimitiveBinding(Long.class),   //Key 序列化类型
                valueBinding,                                   // Value
                true);                                          // allow write
        //todo
        Long firstKey = ((StoredSortedMap<Long, E>) queueMap).firstKey();
        Long lastKey = ((StoredSortedMap<Long, E>) queueMap).lastKey();
 
        headIndex=new AtomicLong(firstKey == null ? 0 : firstKey);
        tailIndex=new AtomicLong(lastKey==null?0:lastKey+1);
    }
    /**
     * 创建以及绑定数据库
     *
     * @param dbDir
     * @param dbName
     * @param valueClass
     * @throws DatabaseNotFoundException
     * @throws DatabaseExistsException
     * @throws DatabaseException
     * @throws IllegalArgumentException
     */
    private void createAndBindDatabase(String dbDir, String dbName,Class<E> valueClass) throws DatabaseNotFoundException,
            DatabaseExistsException,DatabaseException,IllegalArgumentException{
        File envFile = null;
        EnvironmentConfig envConfig = null;
        DatabaseConfig dbConfig = null;
        Database db=null;
 
        try {
            // 数据库位置
            envFile = new File(dbDir);
 
            // 数据库环境配置
            envConfig = new EnvironmentConfig();
            envConfig.setAllowCreate(true);
            //不支持事务
            envConfig.setTransactional(false);
 
            // 数据库配置
            dbConfig = new DatabaseConfig();
            dbConfig.setAllowCreate(true);
            dbConfig.setTransactional(false);
            //是否要延迟写
            dbConfig.setDeferredWrite(true);
 
            // 创建环境
            dbEnv = new BdbEnvironment(envFile, envConfig);
            // 打开数据库
            db = dbEnv.openDatabase(null, dbName, dbConfig);
            // 绑定数据库
            bindDatabase(db,valueClass,dbEnv.getClassCatalog());
 
        } catch (DatabaseNotFoundException e) {
            throw e;
        } catch (DatabaseExistsException e) {
            throw e;
        } catch (DatabaseException e) {
            throw e;
        } catch (IllegalArgumentException e) {
            throw e;
        }
 
 
    }
 
    /**
     * 值遍历器
     */
    @Override
    public Iterator<E> iterator() {
        return queueMap.values().iterator();
    }
    /**
     * 大小
     */
    @Override
    public int size() {
        synchronized(tailIndex){
            synchronized(headIndex){
                return (int)(tailIndex.get()-headIndex.get());
            }
        }
    }
 
    /**
     * 插入值
     */
    @Override
    public boolean offer(E e) {
        synchronized(tailIndex){
            queueMap.put(tailIndex.getAndIncrement(), e);// 从尾部插入
            //将数据不保存在缓冲区，直接存入磁盘
            dbEnv.sync();
        }
        return true;
    }
 
    /**
     * 获取值,从头部获取
     */
    @Override
    public E peek() {
        synchronized(headIndex){
            if(peekItem!=null){
                return peekItem;
            }
            E headItem=null;
            while(headItem==null&&headIndex.get()<tailIndex.get()){ // 没有超出范围
                headItem=queueMap.get(headIndex.get());
                if(headItem!=null){
                    peekItem=headItem;
                    continue;
                }
                headIndex.incrementAndGet();    // 头部指针后移
            }
            return headItem;
        }
    }
 
    /**
     * 移出元素,移出头部元素
     */
    @Override
    public E poll() {
        synchronized(headIndex){
            E headItem=peek();
            if(headItem!=null){
                queueMap.remove(headIndex.getAndIncrement());
                //从磁盘上移除
                dbEnv.sync();
                peekItem=null;
                return headItem;
            }
        }
        return null;
    }
 
    /**
     * 关闭,也就是关闭所是用的BDB数据库但不关闭数据库环境
     */
    public void close(){
        try {
            if(queueDb!=null){
                queueDb.sync();
                queueDb.close();
            }
        } catch (DatabaseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (UnsupportedOperationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
    /**
     * 清理,会清空数据库,并且删掉数据库所在目录,慎用.如果想保留数据,请调用close()
     */
    @Override
    public void clear() {
        try {
            close();
            if(dbEnv!=null&&queueDb!=null){
                dbEnv.removeDatabase(null, dbName==null?queueDb.getDatabaseName():dbName);
                dbEnv.close();
            }
        } catch (DatabaseNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (DatabaseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally{
            try {
                if(this.dbDir!=null){
                    FileUtils.deleteDirectory(new File(this.dbDir));
                }
 
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
 
}

 

import java.io.File;
 
import com.sleepycat.bind.serial.StoredClassCatalog;
import com.sleepycat.je.Database;
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
/**
 * BDB数据库环境,可以缓存StoredClassCatalog并共享
 *
 * @contributor 
 */
public class BdbEnvironment extends Environment {
    StoredClassCatalog classCatalog;
    Database classCatalogDB;
 
    /**
     * Constructor
     *
     * @param envHome 数据库环境目录
     * @param envConfig config options  数据库换纪念馆配置
     * @throws DatabaseException
     */
    public BdbEnvironment(File envHome, EnvironmentConfig envConfig) throws DatabaseException {
        super(envHome, envConfig);
    }
 
    /**
     * 返回StoredClassCatalog
     * @return the cached class catalog
     */
    public StoredClassCatalog getClassCatalog() {
        if(classCatalog == null) {
            DatabaseConfig dbConfig = new DatabaseConfig();
            dbConfig.setAllowCreate(true);
            try {
                //事务、数据库名、配置项
                classCatalogDB = openDatabase(null, "classCatalog", dbConfig);
                classCatalog = new StoredClassCatalog(classCatalogDB);
            } catch (DatabaseException e) {
                // TODO Auto-generated catch block
                throw new RuntimeException(e);
            }
        }
        return classCatalog;
    }
 
    @Override
    public synchronized void close() throws DatabaseException {
        if(classCatalogDB!=null) {
            classCatalogDB.close();
        }
        super.close();
    }
 
}

 

客户端--doccloudweb

1.将上面客户端的DocJob、DocJobType、JobDeamonService、JobStatus类复制到客户端

2.将DocController中接着添加

//上传成功以后需要提交文档转换任务
//转换成html,
submitDocJob(docEntity,new Random().nextInt());

/**
 * 提交任务到集群上运行--文档转换任务
 * @param docEntity
 * @param userId
 */
private void submitDocJob(Doc docEntity, int userId) throws IOException {
    //创建一个文档转换任务对象
    DocJob docJob = new DocJob();
    //1.设置提交者
    docJob.setUserId(userId);
    //2.设置任务名
    docJob.setName("doc convent");
    //3.任务的状态
    docJob.setJobStatus(JobStatus.SUBMIT);
    //4.设置任务类型
    docJob.setJobType(DocJobType.DOC_JOB_CONVERT);
    //5.设置提交时间
    docJob.setSubmitTime(System.nanoTime());
    //6.设置输入路径
    docJob.setInput(docEntity.getDocDir()+"/"+docEntity.getDocName());
    //7.设置输出路径
    docJob.setOutput(docEntity.getDocDir());
    //8.设置重试次数
    docJob.setRetryTime(4);
    //9.设置文件名
    docJob.setFileName(docEntity.getDocName());
    //todo 将job元数据保存到数据库
    //获取动态代理对象
    JobDaemonService jobDaemonService = RPC.getProxy(JobDaemonService.class, 1L, new InetSocketAddress("localhost", 7788), new Configuration());
    //提交任务到服务器（hdfs上）
    log.info("submit job:{}",docJob);
    jobDaemonService.submitDocJob(docJob);
 
}

 

将上传到hdfs上的文件下载到本地，将下载的文件转化为HTML（通过runtime调用exec来执行命令）并保存到本地（客户端提交任务到服务器）通过hadoop IPC来接受任务。将任务保存在序列化队列中，1.保证任务不丢失 2.并发控制，内存溢出

---------------------------<待更>-------------------------