O2OA使用手册
第1章 功能简介及概述
第6章 平台部署与配置
  • 6.1 O2OA(翱途)开发平台如何基于nginx上下文分发的方式快速集群部署
  • 6.2 系统架构-平台集群化部署之基于Nginx端口分发机制实现集群部署
  • 6.3 系统架构-基于nginx快速集群部署-上下文分发
  • 6.4 安装部署-在Windows系统中部署O2OA开发平台
  • 6.5 安装部署-在Linux系统中部署O2OA开发平台
  • 6.6 安装部署-在宝塔/PHPStudy中部署O2OA开发平台
  • 6.7 安装部署-O2OA开发平台之HTTP端口规划
  • 6.8 安装部署-平台服务器版本升级操作说明
  • 6.9 安装部署-私有化部署服务器架构推荐
  • 6.10 安装部署-O2OA开发平台集群部署配置及操作说明
  • 6.11 安装部署-在线部署自定义应用的WAR包和JAR包
  • 6.12 服务器配置与管理-​O2OA主要配置文件说明
  • 6.13 服务器配置与管理-服务器端口冲突和端口修改
  • 6.14 服务器配置与管理-如何修改服务器内存占用率?
  • 6.15 服务器配置与管理-如何访问和操作H2内置数据库
  • 6.16 服务器配置与管理-​如何在O2OA中使用MySQL数据库?
  • 6.17 服务器配置与管理-如何修改平台支持的数据库驱动包
  • 6.18 服务器配置与管理-O2OA使用openGauss(华为高斯数据库)配置
  • 6.19 服务器配置与管理-O2OA开发平台平台数据库配置信息样例
  • 6.20 服务器配置与管理-配置O2OA服务器连接O2云
  • 6.21 服务器配置与管理-O2OA实现服务器随操作系统自动启动
  • 6.22 服务器配置与管理-文件存储服务器配置
  • 6.23 服务器配置与管理-工作日节假日配置
  • 6.24 服务器配置与管理-为平台增加全文检索功能
  • 6.25 服务器配置与管理-消息提醒配置说明
  • 6.26 服务器配置与管理-自定义消息提醒
  • 6.27 服务器配置与管理-定制消息通知的内容
  • 6.28 服务器配置与管理-消息通知过滤
  • 6.29 服务器配置与管理-为待办创建配置邮件通知
  • 6.30 服务器配置与管理-待办待阅数据的查询操作和管理
  • 6.31 服务器配置与管理-​自动执行平台数据的备份与恢复
  • 6.32 服务器配置与管理-数据导出导入与系统数据备份
  • 6.33 ​服务器配置与管理-定期自动执行数据备份与恢复
  • 6.34 系统安全-O2OA作为认证中心实现基于OAUTH2单点认证
  • 6.35 系统安全-O2OA基于Nginx的SSL跳转、转发配置
  • 6.36 系统安全-访问日志相关配置
  • 6.37 系统安全-审计日志相关配置
  • 6.38 系统安全-平台日志文件说明
  • 6.39 系统安全-O2OA日志输出设置log4j2.xml
  • 6.40 系统安全-用户密码初始化规则的设定
  • 6.41 系统安全-启用HTTPS(百度云版)
  • 6.42 系统安全-启用HTTPS(腾讯云版)
  • 6.43 系统安全-自签名SSL证书验证HTTPS功能
  • 6.44 系统安全-登录密码RSA加密
  • 6.45 系统安全-用户登录IP限制
  • 6.46 系统安全-在用户登录过程中启用图形验证码
  • 6.47 系统安全-平台部署之使用非root用户运行服务
  • 6.48 系统安全-O2Server启用国密加密设置
  • 6.49 系统安全-日志应用使用说明
  • 6.50 系统安全-用户重置密码操作
  • 6.51 系统安全-超级管理员(xadmin)密码修改
  • 6.52 系统安全-使用Web端运行服务器管理命令
  • 6.53 系统安全-o2server无法正常显示验证码解决办法
  • 6.54 O2OA(翱途)开发平台前端安全配置建议(一)
  • 第16章 开发知识及常见问题
  • 16.1 如何替换登录页面二维码中默认的logo图标
  • 16.2 O2OA(翱途)流程引擎中如何修改,定制流程的流转记录
  • 16.3 mysql数据库备份
  • 16.4 domain不正确的时候如何强制设置成正确的
  • 16.5 配置文件中使用密文存储密码
  • 16.6 常见问题-连接MySQL出现 Public Key Retrieval is not allowed 的错误
  • 16.7 常见问题-查看表结构
  • 16.8 常见问题-7.2及以上版本开启web代理后请求中没有正确使用web端口问题解决方式
  • 16.9 linux环境libreoffice安装及使用
  • 16.10 在O2OA中使用网络会议(二):Openmeetings与O2OA认证配置
  • 16.11 在O2OA中使用网络会议(一):Openmeetings-5.1.0亲手安装整理 Step-By-Step
  • 16.12 藕粉社区问答系列1
  • 16.13 藕粉社区问答系列2
  • 16.14 藕粉社区问答系列3
  • 16.15 快速入门-平台相关资料汇总
  • 16.16 快速入门-服务器总体介绍汇总
  • 16.17 快速入门-流程表单载入基础数据
  • 16.18 快速入门-常用表单脚本样例汇总
  • 16.19 快速入门-自定义表数据分页样例
  • 16.20 OEM白标-如何修改平台中的Logo图标和文字
  • 16.21 云服务器-阿里云ECS服务器的端口启用
  • 16.22 开发知识-React篇:在O2OA平台框架中使用React
  • 16.23 开发知识-React篇:在O2OA门户页面中使用React
  • 16.24 开发知识-Vue篇:在Vue应用中集成O2OA
  • 16.25 开发知识-Vue篇:使用Vue-CLI开发O2应用
  • 16.26 开发知识-Vue篇:在O2门户页面中使用Vue
  • 16.27 平台中使用Druid数据库连接及监控
  • 16.28 开发知识-在PAAS平台上部署O2OA开发平台
  • 16.29 开发知识-如何使用Tomcat架设webdav服务器
  • 16.30 开发知识-单个端口模式的Nginx和系统配置
  • 16.31 开发知识-Linux非root用户如何使用80端口启动O2OA
  • 16.32 开发知识-O2OA平台启用Eruda进行移动端调试
  • 16.33 开发知识-神通数据库安装
  • 16.34 开发知识-人大金仓数据安装
  • 16.35 开发知识-中标麒麟安装达梦数据库(DM8)
  • 16.36 开发知识-中标麒麟安装人大金仓详细步骤
  • 16.37 开发知识-使用VNC连接中标麒麟V7操作系统
  • 16.38 开发知识-鲲鹏(ARM)麒麟操作系统如何替换yum源?
  • 16.39 开发知识-数据优化知识点
  • 16.40 水印安全-附件水印|加密|文档格式转换图片|PDF
  • 16.41 消息队列-配置activeMQ、kafka消息队列
  • 16.42 常见问题-数据导出或者导入时发生OOM异常
  • 16.43 常见问题-如何让用户在首次登录时,必须对初始密码进行修改
  • 16.44 常见问题-如何在模块部署中控制模块的访问权限
  • 16.45 常见问题-如何在平台中开发Ftp文件上传文件的服务?
  • 16.46 常见问题-如何使用服务管理调用WebService
  • 16.47 常见问题-如何使用脚本调用外部服务
  • 16.48 常见问题-如何使用脚本控制流程自动流转
  • 16.49 常见问题-如何通过脚本调用系统内服务
  • 16.50 常见问题-接口代码疑惑解答汇总
  • 16.51 常见问题:Maven编译o2server错误: Java Heap Space
  • 16.52 常见问题-集群配置后启动报错:NullPointerException
  • 16.53 常见问题-服务器错误:can not decrypt token
  • 16.54 常见问题-IOS移动办公无法收到验证码
  • 16.55 常见问题-服务器和日志时间相差12小时的问题
  • 16.56 常见问题-为什么127.0.0.1可以访问但其他IP无法访问
  • 16.57 藕粉社区问答系列4
  • 16.58 开发知识-React篇:在React应用中集成O2OA

  • 服务集成-与外部系统数据交互

    时间:2022-08-03   

    O2OA允许用户自行修改源码或者增加源码来扩展系统服务,也可以包装功能更强的业务服务。本文主要介绍如何在O2OA中开发接口与外部系统进行数据交互

    外部系统调用接口发起流程

    1.在服务管理创建接口

    image - 2022-04-25T102300.571.png

    2.以发起一个收文流程为例,接口内容如下:

    /*
      //requestText为外系统传入的参数:title,from,to等为传入的业务数据(根据实际情况调整),contents为正文数组对象,slaves为附件数组对象,没有的可以不传。 
        假设requestText = {
            "title" : "关于某某某的通知公告(标题,必填)",  
            "from" : "办公室(来文单位,必填)",
            "to" : "qhsnynctrsc(OA的部门人事处ID,必填)",
            "date" : "2020-05-09(收文日期,选填)",
            "no" : "农123(字号,选填)",
            "key" : "nmt(文件加密私钥,选填,为空则认为没加密)",
            "contents" : [ {
                "filepath" : "http://xxxxx.com?file=aaaa.docx",
                "filename" : "aaaa.docx"
            } ],
            "slaves" : [ {
                "filepath" : "http://xxxxx.com?file=slaves.docx",
                "filename" : "slaves.docx"
            } ]
        }
    */
    try{
        var result = {     
        }
        print( "requestText="+requestText );
       
        var requestJson = JSON.parse(requestText);
        if( typeof(requestJson) === "string" ){
            requestJson = JSON.parse(requestJson);
        }
        if(requestJson.title === "" || requestJson.from === "" || requestJson.to === ""){//必填信息校验
            result.state = "NMT0002";
            result.message = "失败";
            result.data = "标题或者来文单位或者OA部门ID为空";
        }else{
            var processId = "d75fe1d2-6823-4e33-9798-6218d82f930f";  //需要启动的流程标识
            var identity = "xxxxx@474820e2-4c54-4e5c-8c82-5915d5ca6d2c@I";    //启动人员身份
       
            //传入的参数名和表单字段名不一致,所以重新拼接,subject,input_department,receive_date,input_file_no为流程表单字段标识
            var datastr = '{"subject":"'+requestJson.title+'","input_department":"'+requestJson.from+'","receive_date":"'+requestJson.date+'","input_file_no":"'+requestJson.no+'"}';
            datastr = JSON.parse(datastr);
            var applications = resources.getContext().applications();
            var data = {
                "title": requestJson.title,
                "identity": identity,
                "data" : datastr   //表单数据
            }
            var resp = applications.postQuery('x_processplatform_assemble_surface', 'work/process/'+processId, JSON.stringify( data ));  //调用平台启动流程接口
            var result1 = JSON.parse( resp.toString() );
            var workId = result1.data[0].work; //返回workid
           
           
            //上传附件-----------------------------------------------------------begin
            var token = getToken();  
           
            //print( "contents个数:" + requestJson.contents.length);
            //print( "slaves个数:" + requestJson.slaves.length);
            var contentsSite = "attachment"; //正文附件放置的附件区域
            var slavesSite = "attachment_1"; //普通附件放置的附件区域
            //处理contents
            var conArr = requestJson.contents;
            for(var i=0;i<conArr.length;i++){
                uploadAtt(workId,conArr[i].filepath,conArr[i].filename,token,contentsSite)
            }
            //处理slaves
            var slavesArr = requestJson.slaves;
            for(var j=0;j<slavesArr.length;j++){
                uploadAtt(workId,slavesArr[j].filepath,slavesArr[j].filename,token,slavesSite)
            }
           
            //上传附件-----------------------------------------------------------end
           
            result.state = "NMT0001";
            result.message = "成功";
            result.data = workId;    
        }  
    }catch(e){
        e.printStackTrace();
        result.state = "NMT0002";
        result.message = "失败";
        result.data = e.name + ": " + e.message
    }
    this.response.setBody(result,"application/json");
    
    /*
        var workid = "0b3eeab0-c3af-4223-b091-60fee7b733f9"; //workid:待办id
        var fileUrl = "http://127.0.0.1/x_desktop/js/base.js"; //附件下载链接
        var fileName = "base.js"; //附件名称
        var token = getToken();  
        site:附件放置区域
    */
    function uploadAtt(workid,fileUrl,fileName,token,site){ //上传附件   
        try {       
            print("token=============================="+token);       
            //实例化java类
            var HashMap = Java.type("java.util.HashMap");
            var LinkedHashMap = Java.type("java.util.LinkedHashMap");
            var HttpClientUtilsUpfile =  Java.type("com.z.custom.HttpClientUtilsUpfile"); 
            var headMap = new LinkedHashMap();
            headMap.put("x-token", token);
            headMap.put("accept", "*/*");
            headMap.put("connection", "Keep-Alive");
            headMap.put("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            var uploadParams = new LinkedHashMap();
            uploadParams.put("fileName", fileName); //附件名称
            uploadParams.put("site", site); //附件区域
            uploadParams.put("extraParam","");
           
            //密钥和向量是跟外系统做的加密参数约定
            //密钥
            var sessionKey = "12345678123456781234567812345678";
            //向量
            var iv =  "1234567812345678";
             
            //上传附件接口,传入文档的workid   
            var strurl = "http://localhost:20020/x_processplatform_assemble_surface/jaxrs/attachment/upload/work/" + workid;
            /*
            *方法功能:java模拟表单附件上传
            *strurl : 上传附件接口地址
            *fileUrl : 附件下载地址
            *fileName :附件名称
            *uploadParams : 上传附件接口参数
            *headMap : 表单头参数
            */
           //uploadByteFileImpl 此方法是用于双方AES加解密附件上传使用,如不需要加解密可使用:uploadUrlFileImpl方法进行附件上传
            HttpClientUtilsUpfile.getInstance().uploadByteFileImpl(strurl, fileUrl,fileName,"file", uploadParams, headMap,sessionKey,iv);
     
        } catch (e) {
            e.printStackTrace();
            e.printStackTrace();
            result.state = "NMT0002";
            result.message = "失败";
            result.data = e.name + ": " + e.message
        }
    }
    function getToken(){ //获取token
        var HttpClientUtilsUpfile =  Java.type("com.z.custom.HttpClientUtilsUpfile");
        //使用token进行Sso登陆
        var path = "http://localhost:20020/x_organization_assemble_authentication/jaxrs/sso";
        var login_uid = "13379254582"; //用户简称
        var client = "wwx"  //SSO名称 
        var sso_key = "987654321"; //SSO密钥
       
        //获取token
        var token = HttpClientUtilsUpfile.getInstance().getToken(path,client,login_uid,sso_key);
        return token;
    }


    将流程数据传回外部系统

    在服务管理创建接口,接口内容如下:

    /*
    requestText为入参
    */
    try{
        var result = {
           
        }
        var pushdata = {
            
        }
        
        var requestJson = JSON.parse(requestText);
        if( typeof(requestJson) === "string" ){
            requestJson = JSON.parse(requestJson);
        }
        print( "workId="+requestJson.workId);
        
        //通过workId得到所有附件列表
        var applications = resources.getContext().applications();
        var resp = applications.getQuery('x_processplatform_assemble_surface', 'attachment/list/work/'+requestJson.workId);
        
        var result1 = JSON.parse( resp.toString() );
        var dataArr = result1.data;
        
        var contentArr = [];
        var salvesArr = [];
        
        for(var i=0;i<dataArr.length;i++){
            var salvesStr = '';
            var filepath = '';       
            filepath = "http://localhost:20020/x_qhny_assemble_control/jaxrs/attachment/aes/"+ dataArr[i].id +"/stream"
            salvesStr = '{"filepath":"'+filepath+'","filename":"'+dataArr[i].name+'"}';
            if(dataArr[i].site === "attachment"){
                salvesArr.push(salvesStr)
            }else{
                contentArr.push(salvesStr)
            }
            
        }
      
        pushdata.title = requestJson.subject;//标题,必填
        pushdata.from = requestJson.danwei;//来文单位,必填
        pushdata.to = requestJson.to; //区划编号
        pushdata.date = ""; //收文日期,选填
        pushdata.no = requestJson.fone; //字号,选填
        pushdata.key = ""; //文件加密私钥,选填,为空则认为没加密
        pushdata.contents = JSON.parse("[" + contentArr + "]");
        pushdata.slaves = JSON.parse("[" + salvesArr + "]");
        
        var url =  'http://ip:端口/OAJoint/Document'; //外系统提供的接口
        var ArrayList = Java.type('java.util.ArrayList');
        var heads = new ArrayList();
        var NameValuePair = Java.type('com.x.base.core.project.bean.NameValuePair');
        var p1 = new NameValuePair('Content-Type', 'application/json; charset=utf-8');
        
        var AppId = "FF82CEDA-2334-4571-B326-DB37C8B66DAC";
        var Timestamp = parseInt(new Date().getTime()/1000)+"";
        var p2 = new NameValuePair('AppId', AppId);
        var p3 = new NameValuePair('Timestamp', Timestamp);
        heads.add(p1);
        heads.add(p2);
        heads.add(p3);
        
        var OASecret = "62717DB4-AD9A-4B07-BDD4-72163EEA3A02";//Md5加密的Key 
        var mac= AppId + OASecret + Timestamp
        print( "mac = " + mac );
        
        try{
            print(">>>>>>>>>尝试对Mac进行Md5加密");
            var md5Util = Java.type('com.z.custom.MD5Util');
            var md5Mac = md5Util.getMD5( mac );
            print( "md5Mac = " + md5Mac );
            
            var p3 = new NameValuePair('Mac', md5Mac);
            heads.add(p3)
        }catch(e){
            print(e);
        }
        print(">>>>>headers:")
        
        var HttpConnectionClass = Java.type('com.x.base.core.project.connection.HttpConnection');
    
        var docContent =JSON.stringify(pushdata);
        print("sendContent:"+docContent);
        
        var resp = HttpConnectionClass.postAsString(url, heads, docContent);
        print("返回1:"+ resp.toString());
        if(resp.toString()=='{"state":"NMT0001","message":"成功"}'){
            this.response.setBody(true);
        }else{
            this.response.setBody(false);
        }
        
    }catch(e){
        e.printStackTrace();
        result.state = "NMT0002";
        result.message = "失败";
        result.data = e.name + ": " + e.message
        this.response.setBody(false);
    }

    说明

    SSO配置

    getToken()方法里面的sso名称和sso密钥配置在“系统设置”里
    image - 2022-04-25T102345.436.png

    HttpClientUtilsUpfile类代码

    HttpClientUtilsUpfile类代码如下:

    package com.z.custom;
    
    import java.io.*;
    import java.net.*;
    import java.util.*;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import com.google.gson.JsonElement;
    import com.google.gson.JsonObject;
    import com.google.gson.JsonParser;
    import com.x.base.core.project.tools.Crypto;
    import org.apache.http.HttpEntity;
    import org.apache.http.NameValuePair;
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.entity.ContentType;
    import org.apache.http.entity.mime.MultipartEntityBuilder;
    import org.apache.http.entity.mime.content.FileBody;
    import org.apache.http.entity.mime.content.InputStreamBody;
    import org.apache.http.entity.mime.content.StringBody;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.util.EntityUtils;
    
    import javax.crypto.CipherInputStream;
    
    public class HttpClientUtilsUpfile {
        public static final int THREAD_POOL_SIZE = 5;
    
        public interface HttpClientDownLoadProgress {
            public void onProgress(int prgetInstanceogress);
        }
    
        private static HttpClientUtilsUpfile httpClientDownload;
    
        private ExecutorService downloadExcutorService;
    
        private HttpClientUtilsUpfile() {
            downloadExcutorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
        }
    
        public static HttpClientUtilsUpfile getInstance() {
            if (httpClientDownload == null) {
                httpClientDownload = new HttpClientUtilsUpfile();
            }
            return httpClientDownload;
        }
    
        /**
         * 下载文件
         *
         * @param url
         * @param filePath
         */
        public void download(final String url, final String filePath) { downloadExcutorService.execute(new Runnable() {
                public void run() {
                    httpDownloadFile( url, filePath, null, null);
                }
            });
        }
    
        /**
         * 下载文件
         *
         * @param url
         * @param filePath
         * @param progress
         *
         */
        public void download(final String url, final String filePath, final HttpClientDownLoadProgress progress) {
            downloadExcutorService.execute(new Runnable() {
                public void run() {
                    httpDownloadFile(url, filePath, progress, null);
                }
            });
        }
    
        /**
         *下载文件
         *
         * @param url
         * @param filePath
         */
        private void httpDownloadFile(String url, String filePath,
                                      HttpClientDownLoadProgress progress, Map<String, String> headMap) {
            CloseableHttpClient httpclient = HttpClients.createDefault();
            try {
                HttpGet httpGet = new HttpGet(url);
                setGetHead(httpGet, headMap);
                CloseableHttpResponse response1 = httpclient.execute(httpGet);
                try {
                    HttpEntity httpEntity = response1.getEntity();
                    long contentLength = httpEntity.getContentLength();
                    InputStream is = httpEntity.getContent();
    
                    ByteArrayOutputStream output = new ByteArrayOutputStream();
                    byte[] buffer = new byte[4096];
                    int r = 0;
                    long totalRead = 0;
                    while ((r = is.read(buffer)) > 0) {
                        output.write(buffer, 0, r);
                        totalRead += r;
                        if (progress != null) {
                            progress.onProgress((int) (totalRead * 100 / contentLength));
                        }
                    }
                    FileOutputStream fos = new FileOutputStream(filePath);
                    output.writeTo(fos);
                    output.flush();
                    output.close();
                    fos.close();
                    EntityUtils.consume(httpEntity);
                } finally {
                    response1.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    httpclient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 发送Get请求
         *
         * @param url
         * @return
         */
        public String httpGet(String url) {
            return httpGet(url, null);
        }
    
        /**
         * 发送Get请求
         *
         * @param url
         * @return
         */
        public String httpGet(String url, Map<String, String> headMap) {
            String responseContent = null;
            CloseableHttpClient httpclient = HttpClients.createDefault();
            try {
                HttpGet httpGet = new HttpGet(url);
                CloseableHttpResponse response1 = httpclient.execute(httpGet);
                setGetHead(httpGet, headMap);
                try {
                    System.out.println(response1.getStatusLine());
                    HttpEntity entity = response1.getEntity();
                    responseContent = getRespString(entity);
                    System.out.println("debug:" + responseContent);
                    EntityUtils.consume(entity);
                } finally {
                    response1.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    httpclient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return responseContent;
        }
    
        public String httpPost(String url, Map<String, String> paramsMap) {
            return httpPost(url, paramsMap, null);
        }
    
        /**
         * 发送Post请求
         *
         * @param url
         * @param paramsMap
         * @return
         */
        public String httpPost(String url, Map<String, String> paramsMap, Map<String, String> headMap) {
            String responseContent = null;
            CloseableHttpClient httpclient = HttpClients.createDefault();
            try {
                HttpPost httpPost = new HttpPost(url);
                setPostHead(httpPost, headMap);
                setPostParams(httpPost, paramsMap);
                CloseableHttpResponse response = httpclient.execute(httpPost);
                try {
                    System.out.println(response.getStatusLine());
                    HttpEntity entity = response.getEntity();
                    responseContent = getRespString(entity);
                    EntityUtils.consume(entity);
                } finally {
                    response.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    httpclient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("responseContent = " + responseContent);
            return responseContent;
        }
    
        /**
         * 设置Post请求的HttpHeader
         *
         * @param httpPost
         * @param headMap
         */
        private void setPostHead(HttpPost httpPost, Map<String, String> headMap) {
            if (headMap != null && headMap.size() > 0) {
                Set<String> keySet = headMap.keySet();
                for (String key : keySet) {
                    httpPost.addHeader(key, headMap.get(key));
                }
            }
        }
    
        /**
         * 设置Get请求的HttpHeader
         *
         * @param httpGet
         * @param headMap
         */
        private void setGetHead(HttpGet httpGet, Map<String, String> headMap) {
            if (headMap != null && headMap.size() > 0) {
                Set<String> keySet = headMap.keySet();
                for (String key : keySet) {
                    httpGet.addHeader(key, headMap.get(key));
                }
            }
        }
    
    
        /**
         * 上传文件的实现方法
         *
         * @param serverUrl
         * @param localFilePath
         * @param serverFieldName
         * @param params
         * @return
         * @throws Exception
         */
        public String uploadFileImpl(String serverUrl, String localFilePath,String serverFieldName, Map<String, String> params, Map<String, String> paramshead)
                throws Exception {
            String respStr = null;
            CloseableHttpClient httpclient = HttpClients.createDefault();
            try {
                HttpPost httppost = new HttpPost(serverUrl);
                setPostHead(httppost, paramshead);
                FileBody binFileBody = new FileBody(new File(localFilePath));
    
                MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
                // add the file params
                multipartEntityBuilder.addPart(serverFieldName, binFileBody);
                setUploadParams(multipartEntityBuilder, params);
                HttpEntity reqEntity = multipartEntityBuilder.build();
                httppost.setEntity(reqEntity);
                CloseableHttpResponse response = httpclient.execute(httppost);
                try {
                    HttpEntity resEntity = response.getEntity();
                    respStr = getRespString(resEntity);
                    EntityUtils.consume(resEntity);
                } finally {
                    response.close();
                }
            } finally {
                httpclient.close();
            }
            System.out.println("resp=" + respStr);
            return respStr;
        }
    
    
        /**
         * 上传文件的实现方法
         *
         * @param serverUrl
         * @param urlFilePath
         * @param urlFileName
         * @param serverFieldName
         * @param params
         * @return
         * @throws Exception
         */
        public String uploadUrlFileImpl(String serverUrl, String urlFilePath,String urlFileName,String serverFieldName, Map<String, String> params, Map<String, String> paramshead)
                throws Exception {
            String respStr = null;
            CloseableHttpClient httpclient = HttpClients.createDefault();
            try {
                HttpPost httppost = new HttpPost(serverUrl);
                setPostHead(httppost, paramshead);
                FileBody binFileBody = new FileBody(new File(urlFilePath));
                MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
                // add the file params
                BufferedInputStream in = getFileInputStream(urlFilePath);
                InputStreamBody inputStreamBody = new InputStreamBody(in,urlFileName);
                multipartEntityBuilder.addPart(serverFieldName, inputStreamBody);
                setUploadParams(multipartEntityBuilder, params);
                HttpEntity reqEntity = multipartEntityBuilder.build();
                httppost.setEntity(reqEntity);
    
                CloseableHttpResponse response = httpclient.execute(httppost);
                try {
                    System.out.println(response.getStatusLine());
                    HttpEntity resEntity = response.getEntity();
                    respStr = getRespString(resEntity);
                    EntityUtils.consume(resEntity);
                } finally {
                    response.close();
                }
            } finally {
                httpclient.close();
            }
            System.out.println("resp=" + respStr);
            return respStr;
        }
    
        /**
         * 上传文件的实现方法
         * 上传前 需要解密
         * @param serverUrl  上传附件服务
         * @param urlFilePath  附件URL
         * @param urlFileName  附件名称
         * @param serverFieldName
         * @param params  附件参数
         * @param paramshead  文件头
         * @param skey  密钥
         * @param siv  向量
         * @return
         * @throws Exception
         */
        public String uploadByteFileImpl(String serverUrl, String urlFilePath,String urlFileName,String serverFieldName, Map<String, String> params, Map<String, String> paramshead,String skey,String siv)
                throws Exception {
            String respStr = null;
            CloseableHttpClient httpclient = HttpClients.createDefault();
            try {
                HttpPost httppost = new HttpPost(serverUrl);
                setPostHead(httppost, paramshead);
                //ileBody binFileBody = new FileBody(new File(urlFilePath));
                MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
                // add the file params
    
                BufferedInputStream fis = getFileInputStream(URLDecoder.decode(urlFilePath, "UTF-8" ));;
                //解密
                CipherInputStream cis = AESFile.decryptedFile(fis,skey,siv);
    
                if(cis != null){
                    //InputStream inputByteFile = new ByteArrayInputStream(byteFile);
                    //BufferedInputStream in = new BufferedInputStream(inputByteFile);
                    InputStreamBody inputStreamBody = new InputStreamBody(cis,urlFileName);
                    multipartEntityBuilder.addPart(serverFieldName, inputStreamBody);
                    setUploadParams(multipartEntityBuilder, params);
                    HttpEntity reqEntity = multipartEntityBuilder.build();
                    httppost.setEntity(reqEntity);
    
                    CloseableHttpResponse response = httpclient.execute(httppost);
                    try {
                        System.out.println(response.getStatusLine());
                        HttpEntity resEntity = response.getEntity();
                        respStr = getRespString(resEntity);
                        EntityUtils.consume(resEntity);
                    } finally {
                        response.close();
                    }
                }else{
                    respStr = "解密失败";
                }
    
            } finally {
                httpclient.close();
            }
            System.out.println("resp=" + respStr);
            return respStr;
        }
    
        /**
         * 设置上传时的参数
         *
         * @param multipartEntityBuilder
         * @param params
         */
        private void setUploadParams(MultipartEntityBuilder multipartEntityBuilder,
                                     Map<String, String> params) {
            if (params != null && params.size() > 0) {
                Set<String> keys = params.keySet();
                for (String key : keys) {
                    multipartEntityBuilder.addPart(key, new StringBody(params.get(key),ContentType.APPLICATION_JSON));
    
                }
            }
        }
    
        /**
         * 获取响应内容
         *
         * @param entity
         * @return
         * @throws Exception
         */
        private String getRespString( HttpEntity entity ) throws Exception {
            if (entity == null) {
                return null;
            }
            InputStream is = entity.getContent();
            StringBuffer strBuf = new StringBuffer();
            byte[] buffer = new byte[4096];
            int r = 0;
            while ((r = is.read(buffer)) > 0) {
                strBuf.append(new String(buffer, 0, r, "UTF-8"));
            }
            return strBuf.toString();
        }
        /**
         * 设置Post请求发送的参数
         *
         * @param httpPost
         * @param paramsMap
         * @throws Exception
         */
        private void setPostParams(HttpPost httpPost, Map<String, String> paramsMap)
                throws Exception {
            if (paramsMap != null && paramsMap.size() > 0) {
                List<NameValuePair> nvps = new ArrayList<NameValuePair>();
                Set<String> keySet = paramsMap.keySet();
                for (String key : keySet) {
                    nvps.add(new BasicNameValuePair(key, paramsMap.get(key)));
                }
                httpPost.setEntity(new UrlEncodedFormEntity(nvps));
            }
        }
    
        /**
         * 发送Post请求
         * @param url
         * @param param
         * @return
         */
        public static String sendPost(String url, String param) {
            PrintWriter out = null;
            BufferedReader in = null;
            String result = "";
            try {
                URL realUrl = new URL(url);
                URLConnection conn = realUrl.openConnection();
                conn.setRequestProperty("accept", "*/*");
                conn.setRequestProperty("connection", "Keep-Alive");
                conn.setRequestProperty("Content-Type", "application/json; charset=utf-8");
                conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
                conn.setDoOutput(true);
                conn.setDoInput(true);
                out = new PrintWriter(conn.getOutputStream());
                out.print(param);
                out.flush();
                in = new BufferedReader( new InputStreamReader(conn.getInputStream()));
                String line;
                while ((line = in.readLine()) != null) {
                    result += line;
                }
            } catch (Exception e) {
                System.out.println(" POST"+e);
                e.printStackTrace();
            }
            finally{
                try{
                    if(out!=null){
                        out.close();
                    }
                    if(in!=null){
                        in.close();
                    }
                }
                catch(IOException ex){
                    ex.printStackTrace();
                }
            }
            System.out.println(result);
            return result;
        }
    
        /**
         * 根据ssoToken获取人员认证后的真实xtoken
         * @param url
         * @param client
         * @param login_uid
         * @param sso_key
         * @return
         */
        public String getToken(String url, String client, String login_uid, String sso_key ) {
            long time = new Date().getTime();
            String xtoken = null;
    
            try {
                xtoken = Crypto.encrypt( login_uid + "#" + time, sso_key );
                System.out.println(xtoken);
            } catch (Exception e1) {
                e1.printStackTrace();
            }
            String string = "{"token": "+xtoken+", "client": ""+ client +""}";
            String str = getInstance().sendPost( url,string );
            System.out.println("sso response: " + str );
            try {
                JsonElement jsonObj = new JsonParser().parse(str);
                if( jsonObj != null && jsonObj.getAsJsonObject().get("data") != null ){
                    JsonObject data = jsonObj.getAsJsonObject().get("data").getAsJsonObject();
                    System.out.println("getToken: " + data.get("token"));
                    return data.get("token").getAsString();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        private BufferedInputStream getFileInputStream(String urlPath) {
            BufferedInputStream bin=null;
            URL url;
            try {
                url = new URL(urlPath);
                URLConnection urlConnection = url.openConnection();
                HttpURLConnection httpURLConnection = (HttpURLConnection) urlConnection;
                httpURLConnection.setConnectTimeout(1000*5);
                httpURLConnection.setRequestMethod("GET");
                // 设置字符编码
                httpURLConnection.setRequestProperty("Charset", "UTF-8");
                httpURLConnection.connect();
                bin = new BufferedInputStream(httpURLConnection.getInputStream());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return bin;
        }
    
        private InputStream getInputStream(String urlPath) {
            InputStream bin=null;
            URL url;
            try {
                url = new URL(urlPath);
                URLConnection urlConnection = url.openConnection();
                HttpURLConnection httpURLConnection = (HttpURLConnection) urlConnection;
                httpURLConnection.setConnectTimeout(1000*5);
                httpURLConnection.setRequestMethod("GET");
                // 设置字符编码
                httpURLConnection.setRequestProperty("Charset", "UTF-8");
                httpURLConnection.connect();
                bin = httpURLConnection.getInputStream();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return bin;
        }
    
        public static void main(String[] args) throws IOException, Exception {
            
        }
    }

    AES加解密

    AESFile类代码:

    package com.z.custom;
    
    import org.bouncycastle.jce.provider.BouncyCastleProvider;
    import sun.misc.BASE64Decoder;
    
    import javax.crypto.Cipher;
    import javax.crypto.CipherInputStream;
    import javax.crypto.KeyGenerator;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.SecretKeySpec;
    import java.io.*;
    import java.security.*;
    import java.util.Random;
    
    public class AESFile {
    	@SuppressWarnings("static-access")
    	//文件加密的实现方法
    	public static void encryptFile2(String fileName,String encryptedFileName,String sKey,String siv){
    		try {
    			//导入支持AES/CBC/PKCS7Padding的Provider
    			Security.addProvider(new BouncyCastleProvider());
    
    			FileInputStream fis = new FileInputStream(fileName);
    			FileOutputStream fos = new FileOutputStream(encryptedFileName);
    
    			byte[] keyValue = sKey.getBytes();
    
    			SecretKeySpec encryKey= new SecretKeySpec(keyValue,"AES");//加密秘钥
    			
    			//byte[] ivValue=new byte[16];
    
    			byte[] ivValue = siv.getBytes();
    			Random random = new Random(System.currentTimeMillis());
    			random.nextBytes(ivValue);
    			IvParameterSpec iv = new IvParameterSpec(ivValue);//获取系统时间作为IV
    
    			fos.write(ivValue);	//记录IV
    			Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding","BC");
    			cipher.init(Cipher.ENCRYPT_MODE, encryKey,iv);
    			
    			CipherInputStream cis=new CipherInputStream(fis, cipher);
    			
    			byte[] buffer=new byte[1024];
    			int n=0;
    			while((n=cis.read(buffer))!=-1){
    				fos.write(buffer,0,n);
    			}
    			cis.close();
    			fos.close();
    		} catch (InvalidKeyException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (NoSuchAlgorithmException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (NoSuchPaddingException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (InvalidAlgorithmParameterException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (NoSuchProviderException e) {
    			e.printStackTrace();
    		}
    
    	}
    
    	@SuppressWarnings("static-access")
    	//文件解密的实现代码 通过文件流
    	public static CipherInputStream decryptedFile(InputStream fis,String sKey, String siv){
    
    			try {
    				//导入支持AES/CBC/PKCS7Padding的Provider
    				Security.addProvider(new BouncyCastleProvider());
    
    				byte[] keyValue = sKey.getBytes();
    
    					SecretKeySpec key= new SecretKeySpec(keyValue,"AES");
    
    					byte[] ivValue = siv.getBytes();
    					//fis.read(ivValue);//获取IV值
    					IvParameterSpec iv= new IvParameterSpec(ivValue);
    					Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding","BC");
    					cipher.init(Cipher.DECRYPT_MODE, key,iv);
    
    					CipherInputStream cis= new CipherInputStream(fis, cipher);
    
    					return cis;
    
    			} catch (NoSuchAlgorithmException e) {
    				e.printStackTrace();
    				return null;
    			} catch (InvalidKeyException e) {
    				e.printStackTrace();
    				return null;
    			} catch (InvalidAlgorithmParameterException e) {
    				e.printStackTrace();
    				return null;
    			} catch (NoSuchPaddingException e) {
    				e.printStackTrace();
    				return null;
    			} catch (NoSuchProviderException e) {
    				e.printStackTrace();
    				return null;
    			}
    	}
    	@SuppressWarnings("static-access")
    	//文件解密的实现代码
    	public static void decryptedFile2(String encryptedFileName,String decryptedFileName, String sKey, String siv){
    
    		try {
    			//导入支持AES/CBC/PKCS7Padding的Provider
    			Security.addProvider(new BouncyCastleProvider());
    
    			FileInputStream fis = new FileInputStream(encryptedFileName);
    			FileOutputStream fos = new FileOutputStream(decryptedFileName);
    			BASE64Decoder decoder = new BASE64Decoder();
    
    			//byte[] fileIdentifier=new byte[15];
    
    			//byte[] keyValue=new byte[16];
    			//String sKey= "12345678123456781234567812345678";
    			byte[] keyValue = sKey.getBytes();
    			//fis.read(keyValue);//读记录的文件加密密码的消息摘要
    			//fis.read(fileIdentifier);
    			//System.out.println("file=="+new String(fileIdentifier,"UTF-8"));
    			//if(new String (fileIdentifier).equals("MyFileEncryptor")){
    			SecretKeySpec key= new SecretKeySpec(keyValue,"AES");
    			//byte[] ivValue= new byte[16];
    			//String siv = "1234567812345678";
    			byte[] ivValue = siv.getBytes();
    			//fis.read(ivValue);//获取IV值
    			IvParameterSpec iv= new IvParameterSpec(ivValue);
    			Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding","BC");
    			cipher.init(Cipher.DECRYPT_MODE, key,iv);
    
    			CipherInputStream cis= new CipherInputStream(fis, cipher);
    			byte[] buffer=new byte[1024];
    
    			int n=0;
    			while((n=cis.read(buffer))!=-1){
    				fos.write(buffer,0,n);
    			}
    			cis.close();
    
    			fos.close();
    			//JOptionPane.showMessageDialog(null, "解密成功");
    			//}else{
    			//JOptionPane.showMessageDialog(null, "文件不是我加密的,爱找谁着谁去");
    			//}
    		} catch (IOException e) {
    			e.printStackTrace();
    
    		} catch (NoSuchAlgorithmException e) {
    			e.printStackTrace();
    
    		} catch (InvalidKeyException e) {
    			e.printStackTrace();
    
    		} catch (InvalidAlgorithmParameterException e) {
    			e.printStackTrace();
    
    		} catch (NoSuchPaddingException e) {
    			e.printStackTrace();
    
    		} catch (NoSuchProviderException e) {
    			e.printStackTrace();
    
    		}
    	}
    
    
    }

    MD5加密

    package com.z.custom;
    
    import org.apache.commons.codec.digest.DigestUtils;
    
    import java.math.BigInteger;
    import java.security.MessageDigest;
    
    /**
     * MD5通用类
     *
     */
    public class MD5Util {
    
        public static String getMD5(String str) {
            try {
                // 生成一个MD5加密计算摘要
                MessageDigest md = MessageDigest.getInstance("MD5");
                // 计算md5函数
                md.update(str.getBytes());
                // digest()最后确定返回md5 hash值,返回值为8为字符串。因为md5 hash值是16位的hex值,实际上就是8位的字符
                // BigInteger函数则将8位的字符串转换成16位hex值,用字符串来表示;得到字符串形式的hash值
                String md5=new BigInteger(1, md.digest()).toString(16);
                //BigInteger会把0省略掉,需补全至32位
                return fillMD5(md5);
            } catch (Exception e) {
                throw new RuntimeException("MD5加密错误:"+e.getMessage(),e);
            }
        }
    
        public static String fillMD5(String md5){
            return md5.length()==32?md5:fillMD5("0"+md5);
        }
    
        /**
         * MD5方法
         *
         * @param text 明文
         * @param key 密钥
         * @return 密文
         * @throws Exception
         */
        public static String md5(String text, String key) throws Exception {
            //加密后的字符串
            String encodeStr=DigestUtils.md5Hex(text + key);
            System.out.println("MD5加密后的字符串为:encodeStr="+encodeStr);
            return encodeStr;
        }
    
        /**
         * MD5验证方法
         *
         * @param text 明文
         * @param key 密钥
         * @param md5 密文
         * @return true/false
         * @throws Exception
         */
        public static boolean verify( String text, String key, String md5) throws Exception {
            //根据传入的密钥进行验证
            String md5Text = md5(text, key);
            if(md5Text.equalsIgnoreCase(md5))
            {
                System.out.println("MD5验证通过");
                return true;
            }
            return false;
        }
    
        public static void main(String[] args) throws Exception{
            String str = "lee81glee81glee81glee81glee81glee81glee81glee81glee81glee81glee81glee81glee81glee81glee81glee81glee81glee81glee81glee81glee81g";
            System.out.println("md5:"+getMD5(str));
            System.out.println("length:"+getMD5(str).length());
        }
    }

    搭建自定义工程

    以上所用到的java类不包含在平台源码中,需要以自定义工程的方式注入到平台中进行使用,搭建自定义工程及开发参考教程:https://www.yuque.com/o2oa/course/tuef8c