一、前言：

工作中，接触到很多系统要互相对接，因为大多数公司（项目）所用的平台不同，要想一方提供数据信息供对方提取，首先想到的就是开放出一个WebService接口调用文档和WebService地址，这样对方就能根据文档地址编程去调用。于是便在网上搜罗相关资料，尝试写一个WebService接口，非科班出身，仅供大家参考、指教。

二、WebService优点：

• 可远程调用（WebService可以向全世界提供信息，或提供某项功能，只要有网就OK）。
• 跨平台调用（WebService可以在Windows上调用linux上的WebService服务，反之同理）。
• 跨语言调用（WebService可以在Java语言中调用asp.net语言提供的WebService服务，反之其他编程语言同理）
• ......

三、详细开发步骤：

1）使用JDK开发WebService

WebService服务端

1.1首先我们先创建一个java项目，目录及Util工具类和所应用的包：

 这里我用的是 C3p0 JDBC连接池方式我给大家提供MySql和oracle工具类，代码如下：

MySql：

package Util;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;
public class JDBCUtil2 {
    static ComboPooledDataSource dataSource = null;
    static{
        dataSource = new ComboPooledDataSource();
    }
    
    public static DataSource getDataSource(){
        return dataSource;
    }
    
    /**
     * 获取连接对象
     * @return
     * @throws SQLException 
     */
    public static Connection getConn() throws SQLException{
        return dataSource.getConnection();
    }
    
    /**
     * 释放资源
     * @param conn
     * @param st
     * @param rs
     */
    public static void release(Connection conn , Statement st , ResultSet rs){
        closeRs(rs);
        closeSt(st);
        closeConn(conn);
    }
    public static void release(Connection conn , Statement st){
        closeSt(st);
        closeConn(conn);
    }

    
    private static void closeRs(ResultSet rs){
        try {
            if(rs != null){
                rs.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            rs = null;
        }
    }
    
    private static void closeSt(Statement st){
        try {
            if(st != null){
                st.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            st = null;
        }
    }
    
    private static void closeConn(Connection conn){
        try {
            if(conn != null){
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            conn = null;
        }
    }    
    
    public static void main(String[] args) throws Exception{
        System.out.println(getConn());
        System.out.println("---------------------------南清风工具类测试-------------------------------");
        System.out.println("+++++++++++++++++++MySql Connection Successful!+++++++++++++++++++++");
        System.out.println("---------------------------------------------------------------------");
    }
}

Oracle：

package Util;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class JDBCUtil {

    private static ComboPooledDataSource ds = new ComboPooledDataSource();
    private static ThreadLocal<Connection> tl=new ThreadLocal<>();
    
    /**
     * 从线程中获取连接
     * @return
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        //从线程中获取conneciton
        Connection conn = tl.get();
        if(conn==null){
            conn=ds.getConnection();
            //和当前线程绑定
            tl.set(conn);
        }
        return conn;
    }

    // 获取数据源
    public static DataSource getDataSource() {
        return ds;
    }

    // 释放资源
    public static void closeResource( Statement st, ResultSet rs) {
        closeResultSet(rs);
        closeStatement(st);
    }
    
    // 释放资源
    public static void closeResource(Connection conn, Statement st, ResultSet rs) {
        closeResource(st, rs);
        closeConn(conn);
    }

    // 释放 connection
    public static void closeConn(Connection conn) {
        if (conn != null) {
            try {
                conn.close();
                //和线程解绑
                tl.remove();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            conn = null;
        }
    }

    // 释放 statement ctrl + shift + f 格式化代码
    public static void closeStatement(Statement st) {
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            st = null;
        }
    }

    // 释放结果集
    public static void closeResultSet(ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            rs = null;
        }
    }
    
    
    //开启事务
    public static void startTransaction() throws SQLException{
        getConnection().setAutoCommit(false);
    }
    
    /**
     * 事务提交且释放连接
     */
    public static void commitAndClose(){
        Connection conn = null;
        try {
            conn=getConnection();
            //事务提交
            conn.commit();
            //关闭资源
            conn.close();
            //解除版定
            tl.remove();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 事务回滚且释放资源
     */
    public static void rollbackAndClose(){
        Connection conn = null;
        try {
            conn=getConnection();
            //事务回滚
            conn.rollback();
            //关闭资源
            conn.close();
            //解除版定
            tl.remove();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) throws Exception{
        System.out.println(getConnection());
        System.out.println("---------------------------南清风工具类测试-------------------------------");
        System.out.println("+++++++++++++++++++Oracle Connection Successful!+++++++++++++++++++++");
        System.out.println("---------------------------------------------------------------------");
    }
}

 1.2我们现在需要写一个接口类、封装对象类、实现类和拦截器，代码如下：

接口类：

package Dao;

import java.sql.SQLException;

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;

@WebService
public interface fwsyq {
    @WebMethod()
    String Get_fwsyq(
            @WebParam(name="cxtj",targetNamespace = "http://Dao.Get_fwsyq_impl.Get_fwsyq")String cxtj,
            @WebParam(name="cxnr",targetNamespace = "http://Dao.Get_fwsyq_impl.Get_fwsyq")String cxnr) throws SQLException;
}

Bean封装类：

package Bean;

public class fwsyq_table2 {
    private int id;         
    private String SLID;    
    private String DJYY;    
    private String DYH;  
    private String QLR; 
    private String BH;  
    private String ZH;   
    private float JZMJ;      
    private String FDZL;     
    private String XZ;     
    private String DJSJ;     
    private String djbzt;
    
    public fwsyq_table2() {
        super();
        
    }

    public fwsyq_table2(int id, String sLID, String dJYY, String dYH, String qLR, String bH, String zH, float jZMJ,
            String fDZL, String xZ, String dJSJ, String djbzt) {
        this.id = id;
        SLID = sLID;
        DJYY = dJYY;
        DYH = dYH;
        QLR = qLR;
        BH = bH;
        ZH = zH;
        JZMJ = jZMJ;
        FDZL = fDZL;
        XZ = xZ;
        DJSJ = dJSJ;
        this.djbzt = djbzt;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getSLID() {
        return SLID;
    }

    public void setSLID(String sLID) {
        SLID = sLID;
    }

    public String getDJYY() {
        return DJYY;
    }

    public void setDJYY(String dJYY) {
        DJYY = dJYY;
    }

    public String getDYH() {
        return DYH;
    }

    public void setDYH(String dYH) {
        DYH = dYH;
    }

    public String getQLR() {
        return QLR;
    }

    public void setQLR(String qLR) {
        QLR = qLR;
    }

    public String getBH() {
        return BH;
    }

    public void setBH(String bH) {
        BH = bH;
    }

    public String getZH() {
        return ZH;
    }

    public void setZH(String zH) {
        ZH = zH;
    }

    public float getJZMJ() {
        return JZMJ;
    }

    public void setJZMJ(float jZMJ) {
        JZMJ = jZMJ;
    }

    public String getFDZL() {
        return FDZL;
    }

    public void setFDZL(String fDZL) {
        FDZL = fDZL;
    }

    public String getXZ() {
        return XZ;
    }

    public void setXZ(String xZ) {
        XZ = xZ;
    }

    public String getDJSJ() {
        return DJSJ;
    }

    public void setDJSJ(String dJSJ) {
        DJSJ = dJSJ;
    }

    public String getDjbzt() {
        return djbzt;
    }

    public void setDjbzt(String djbzt) {
        this.djbzt = djbzt;
    }

    @Override
    public String toString() {
        return "fwsyq_table2 [id=" + id + ", SLID=" + SLID + ", DJYY=" + DJYY + ", DYH=" + DYH + ", QLR=" + QLR
                + ", BH=" + BH + ", ZH=" + ZH + ", JZMJ=" + JZMJ + ", FDZL=" + FDZL + ", XZ=" + XZ + ", DJSJ=" + DJSJ
                + ", djbzt=" + djbzt + "]";
    }    
}

接口实现类：

package Dao;

import java.util.List;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import Bean.fwsyq_table;
import Util.JDBCUtil2;
import net.sf.json.JSONArray;

public class Get_fwsyq_impl implements fwsyq {

    @Override
    public String Get_fwsyq(String cxtj, String cxnr) {
        try {
            QueryRunner qr = new QueryRunner(JDBCUtil2.getDataSource());if(cxtj!=null && cxnr!=null){
                String sql="select id,slid,djyy,dyh,qlr,bh,zh,jzmj,fdzl,xz,djsj,djbzt from bqh_fq1 where "+cxtj+"="+"'"+cxnr+"'" +"order by id";
                String sql1="select count(*) from bqh_fq1 where "+cxtj+"="+"'"+cxnr+"'";
                              
                List<fwsyq_table> data = qr.query(sql, new BeanListHandler<fwsyq_table>(fwsyq_table.class));
                Long total=(Long) qr.query(sql1, new ScalarHandler());  //统计查询总数
                System.out.println("来自客户端接口访问：查询成功！");
                
                int count=total.intValue();
                int code=0;
                String msg="\"查询成功\"";
                
                String json1="{\"code\":"+code+",\"msg\":"+msg+",\"count\":"+count+",\"data\":"+JSONArray.fromObject(data).toString()+"}";
                System.out.println(json1);
                return json1;
                    
            }else {
                List<fwsyq_table> data =null;
                System.out.println("来自客户端接口访问：查询失败！");
                int code=4;
                int count=0;
                String msg="\"查询失败\"";
                String json1="{\"code\":"+code+",\"msg\":"+msg+",\"count\":"+count+",\"data\":"+JSONArray.fromObject(data).toString()+"}";

                return json1;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;    
    }
}

1.3使用Endpoint类发布WebService

package Publish_interface;

import javax.xml.ws.Endpoint;

import Dao.Get_fwsyq_impl;

public class Get_FWSYQ { 
    public static void main(String[] args){
        //发布接口地址
        String address="http://192.168.0.188:9999/BDBDCDJ/Get_fwsyq"; 
        //jdk方法实现
        Endpoint.publish(address, new Get_fwsyq_impl());
        System.out.println("Published successfully！");
    }
}

1.4启动main方法运行这个类，打印出结果Published successfully，表示服务发布成功：

1.5打开浏览器，访问我们发布的地址（注意后面得加?wsdl），大家可以看到这样的效果：

WSDL结构描述： 

1.6我们可以用SoaoUI工具来测试一下接口：

 OK，这样一个简单的WebService接口就OK了。

2）使用CXF开发WebService

cxf是java开发webService的一种实现框架技术。目前，cxf是主流的webService实现框架。

2.1使用cxf开发需引入cxf开发jar包

Jetty是一个内嵌的web服务器，使用JaxWsServerFactoryBean类创建工厂设置接口地址、接口类、接口实现类，创建即可发布。所以我们得引入jetty包，作为WebService发布的Server。

 2.2增加一个拦截器：

package Interceptor;

import java.util.List;

import org.apache.cxf.binding.soap.SoapMessage;
import org.apache.cxf.interceptor.Fault;
import org.apache.cxf.phase.AbstractPhaseInterceptor;
import org.apache.cxf.phase.Phase;

public class MyInterceptor extends AbstractPhaseInterceptor<SoapMessage>{
     
    public MyInterceptor(){
        // 在调用方法之前调用拦截器
        super(Phase.PRE_INVOKE);
    }
    /**
     * 拦截获取消息
     */
    public void handleMessage(SoapMessage message) throws Fault {
        Object obj = message.getContent(List.class).get(0);
        System.out.println("参数1："+obj);
        
        Object obj1 = message.getContent(List.class).get(1);
        System.out.println("参数2："+obj1);
        
        if(!obj.equals("slid") || obj1==null){
            throw new Fault(new IllegalArgumentException("参数1错误，请求失败"));
        }
        if(obj1==null || obj1.equals("")){
            throw new Fault(new IllegalArgumentException("参数2为空，请求失败"));
        }
    }
}

2.3使用jaws发布WebService

package Publish_interface;

import org.apache.cxf.interceptor.LoggingInInterceptor;
import org.apache.cxf.interceptor.LoggingOutInterceptor;
import org.apache.cxf.jaxws.JaxWsServerFactoryBean;

import Dao.Get_fwsyq_impl;
import Dao.fwsyq;
import Interceptor.MyInterceptor;

public class CXF_Get_FWSYQ {
    public static void main(String[] args) {
        //1.使用jaws发布webservice
        JaxWsServerFactoryBean jsfb=new JaxWsServerFactoryBean();
        //2.设置发布服务的地址
        jsfb.setAddress("http://192.168.0.188:9999/BDBDCDJ/Get_fwsyq");
        //3.设置接口服务
        jsfb.setServiceClass(fwsyq.class);
        //4.设置服务的实现对象
        jsfb.setServiceBean(new Get_fwsyq_impl());
        jsfb.getInInterceptors().add(new LoggingInInterceptor()); // 添加in拦截器 日志拦截器
        jsfb.getOutInterceptors().add(new LoggingOutInterceptor()); // 添加out拦截器
        
        //添加自定义拦截器
        jsfb.getInInterceptors().add(new MyInterceptor());
        //5.通过工厂创建服务
        jsfb.create();
        System.out.println("Published successfully！");    
    }
}

2.4启动main方法运行这个类，打印出结果Cxfweb service published successfully，表示服务发布成功：

2.5打开浏览器，访问我们发布的地址（注意后面得加?wsdl），大家可以看到这样的效果：

 2.6我们可以用Postman工具来测试一下接口：

上边验证拦截器是否生效，下边正常填写参数，成功返回查询结果：

四、客户端调用接口：

3.1 新建一个客户端java web项目

3.2 java自带wsimport命令生成webservice客户端代码及服务调用

通过wsimport命令生成客户端代码（通过cmd进入到当前项目的src路径下，wsimport.exe命令在jdk的bin目录下）

• 第一种方式【远程地址】wsimport -s . 接口地址（加?wsdl）
• 第二种方式【xml文件】wsimport -s . 文件路径（文件路径后面不需要加?wsdl）

wsimport -s . http://192.168.0.188:9999/BDBDCDJ/Get_fwsyq?wsdl

 我们在看一下客户端项目：刷新一下如下：

 3.3新建一个测试类，调用一下接口方法：

package Test_client;

import dao.Fwsyq;
import dao.FwsyqService;

public class Test_class {
    public static void main(String[] args) throws Exception {
        //构建服务视图对象（从service标签name属性获取）
        FwsyqService service=new FwsyqService();
        //获取服务的实现类（从portType的name属性获取
        Fwsyq prot=service.getPort(Fwsyq.class);
        //调用方法（portType下的operation属性获取
        String info=prot.getFwsyq("slid", "202106070001");
        System.out.println("调用服务端接口方法结果是："+info);
    }
}

3.4运行测试类结果如下：

Client console：

server console：:

 OK！一个基本的接口开发过程到此结束。

• 感谢大家的耐心阅读，如有建议请私信或评论留言。
• 如有收获，劳烦支持，关注、点赞、评论、收藏均可，与大家共同进步。

参考地址：

WebService几个常见的异常

CXF报安全性错误 Cannot create a secure XMLInputFactory

WebService-JDK的wsimport命令和cxf的wsdl2java命令的区别和使用

摘要

由于公司对接第三方系统业务较多，所以就采用webservice进行对接，本文项目框架使用SSH搭建，其他框架也可以参考下具体使用流程，本文demo都是测试通过而且发布成功，有需要的可以直接copy根据自己的业务需求进行修改，这里的demo只能给大家一个参考，不能照搬。废话不多说，直接上代码。有需要的伙伴可以参考借鉴一下。

准备工作

1. 下载cfx所需jar包（使用cfx方式）

   1.1 下载地址：点击----->apache-cxf-2.6.16下载
   1.2 下载完成后解压放入项目lib目录下重新编译，如下图
   

步骤

第一步：webservice在项目中的配置，如下：

1. 创建service-ws.xml,如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:jaxws="http://cxf.apache.org/jaxws"
	xsi:schemaLocation="http://www.springframework.org/schema/beans  
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
	
	http://cxf.apache.org/jaxws 
    http://cxf.apache.org/schemas/jaxws.xsd">
	
	<import resource="classpath:META-INF/cxf/cxf.xml"/>
	<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml"/>
	<import resource="classpath:META-INF/cxf/cxf-servlet.xml"/>
	
	<!-- 企业信息同步接口 -->
	<bean id="companyImpl" class="com.hontek.webservice.service.impl.CompanyImpl">
		<property name="interAccountDao" ref="interAccountDao"/>
		<property name="enterpriseDao" ref="enterpriseDao"/>
		<property name="proTypeDao" ref="proTypeDao"/>
		<property name="proTypeQrcodeDao" ref="proTypeQrcodeDao"/>
		<property name="enterprseService" ref="enterprseService"/>
		<property name="proTypeBatchDao" ref="proTypeBatchDao"/>
		<property name="orderService" ref="orderService"/>
		<property name="zizhiDao" ref="zizhiDao"/>
		<property name="zizhiTypeDao" ref="zizhiTypeDao"/>
		<property name="zizhiAppendixDao" ref="zizhiAppendixDao"/>
		<property name="productServiceInter" ref="productService"/>
		<property name="traceService" ref="traceService"/>
		<property name="certificateDao" ref="certificateDao"/>
		<property name="certificateCheckDao" ref="certificateCheckDao"/>
		<property name="certificatePrintDao" ref="certificatePrintDao"/>
		<property name="certificateScanDao" ref="certificateScanDao"/>
		
	</bean>
	
	<jaxws:server serviceClass="com.hontek.webservice.service.inter.CompanyInter" address="/company">
		<jaxws:serviceBean>
			<ref bean="companyImpl"/>
		</jaxws:serviceBean>
	</jaxws:server>


	<!-- 检测设备接口 -->
	<bean id="detectionDeviceImpl" class="com.hontek.devicewebservice.service.impl.DetectionDeviceImpl">
		<property name="userDao" ref="userDao"/>
		<property name="enterpriseDao" ref="enterpriseDao"/>
		<property name="checkEquipmentDao" ref="checkEquipmentDao"/>
		<property name="proTypeQrcodeDao" ref="proTypeQrcodeDao"/>
		<property name="checkInfoDao" ref="checkInfoDao"/>
		<property name="checkInfoDetailDao" ref="checkInfoDetailDao"/>
		<property name="proTypeDao" ref="proTypeDao"/>
		<property name="spotCheckDao" ref="spotCheckDao"/>
		<property name="orderService" ref="orderService"/>
		<property name="dimennoRecordService" ref="dimennoRecordService"/>
		<property name="certificateService" ref="certificateServiceInter"/>
		<property name="caInfoDao" ref="caInfoDao"/>
		<property name="certificateCheckDao" ref="certificateCheckDao"/>
	</bean>

	<jaxws:server serviceClass="com.hontek.devicewebservice.service.inter.DetectionDeviceInter" address="/detectionDevice">
		<jaxws:serviceBean>
			<ref bean="detectionDeviceImpl"/>
		</jaxws:serviceBean>
	</jaxws:server>

	<!-- 圳品、菜篮子平台对接接口 -->
	<bean id="platformsImpl" class="com.hontek.platformswebservice.service.impl.PlatformsImpl">
		<property name="interAccountDao" ref="interAccountDao"/>
		<property name="enterprseService" ref="enterprseService"/>
		<property name="certificateServiceInter" ref="certificateServiceInter"/>
		<property name="proTypeDao" ref="proTypeDao"/>
		<property name="enterpriseDao" ref="enterpriseDao"/>
		<property name="proTypeQrcodeDao" ref="proTypeQrcodeDao"/>
		<property name="caInfoDao" ref="caInfoDao"/>
		<property name="userDao" ref="userDao"/>
		<property name="spotCheckDao" ref="spotCheckDao"/>
		<property name="checkReportDao" ref="checkReportDao"/>
		<property name="checkContentDao" ref="checkContentDao"/>
		<property name="xydaAppendixDao" ref="xydaAppendixDao"/>
		<property name="checkInfoDao" ref="checkInfoDao"/>
		<property name="checkInfoDetailDao" ref="checkInfoDetailDao"/>
	</bean>

	<jaxws:server serviceClass="com.hontek.platformswebservice.service.inter.PlatformsInter" address="/platform">
		<jaxws:serviceBean>
			<ref bean="platformsImpl"/>
		</jaxws:serviceBean>
	</jaxws:server>
	
	
	
</beans> 

apache-cxf-2.6.16版本需要在上面配置文件中加入下面三行

	<import resource="classpath:META-INF/cxf/cxf.xml"/>
	<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml"/>
	<import resource="classpath:META-INF/cxf/cxf-servlet.xml"/>

注意：如果你的版本是3.0以上的，因为多了下面两个xml文件，所以也会报错；只需要引入第一个就可以；如果你的CXF版本是3.0以下；那么需要引入三个配置文件。

2. 配置applicationContext.xml,如下：

	<!-- webservice 接口配置文件 -->
	<import resource="config/webservice/application/service-ws.xml"/>

3. 配置web.xml,如下：

  <servlet>
    <servlet-name>CXFService</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>CXFService</servlet-name>
    <url-pattern>/CXFService/*</url-pattern>
  </servlet-mapping>

第二步：创建webservice接口，如下：

package com.hontek.platformswebservice.service.inter;
import com.hontek.platformswebservice.comm.*;
import javax.jws.WebParam;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
import javax.jws.soap.SOAPBinding.Style;
import java.util.List;

@WebService
@SOAPBinding(style = Style.RPC)
@SuppressWarnings("deprecation")
public interface PlatformsInter {
	
	/**
	 * 获取口令
	 * @Author yang
	 * @Date   2020/05/06 16:55
	 **/
	public String getToken(@WebParam(name="account")String account,@WebParam(name="password")String password);

	/**
	 * 更新心跳接口
	 * @Author yang
	 * @Date   2020/05/06 16:59
	 **/
	public String active(@WebParam(name = "token") String token);

	/**
	 * 退出接口
	 * @Author yang
	 * @Date   2020/05/06 16:59
	 **/
	public String logout(@WebParam(name = "token") String token);

	/**
	 * 同步产品信息
	 * @Author yang
	 * @Date   2020/05/07 18:07
	 **/
	public String syncProTypeQrCode(@WebParam(name="token")String token, @WebParam(name="proTypeQrcode") ProTypeQrcodeEntity proTypeQrcode);
}

以上webservice接口使用RPC方式，并且包含系统对接时候需要的安全验证接口（获取token、更新心跳、退出，可以根据自己的需求进行修改）

第三步：创建webservice实现类，如下

package com.hontek.platformswebservice.service.impl;

import com.alibaba.fastjson.JSON;
import com.hontek.certificate.dao.CaInfoDao;
import com.hontek.certificate.pojo.CaInfo;
import com.hontek.certificate.pojo.Certificate;
import com.hontek.certificate.service.inter.CertificateServiceInter;
import com.hontek.comm.util.DateUtil;
import com.hontek.comm.util.DirectoryUtil;
import com.hontek.comm.util.IDUtil;
import com.hontek.comm.util.StringUtil;
import com.hontek.company.dao.CheckContentDao;
import com.hontek.company.dao.CheckReportDao;
import com.hontek.company.dao.SpotCheckDao;
import com.hontek.company.dao.XydaAppendixDao;
import com.hontek.company.pojo.CheckContent;
import com.hontek.company.pojo.CheckReport;
import com.hontek.company.pojo.SpotCheck;
import com.hontek.company.pojo.XydaAppendix;
import com.hontek.detectiondevice.comm.DetectionReportUtils;
import com.hontek.detectiondevice.dao.CheckInfoDao;
import com.hontek.detectiondevice.dao.CheckInfoDetailDao;
import com.hontek.detectiondevice.pojo.CheckInfo;
import com.hontek.detectiondevice.pojo.CheckInfoDetail;
import com.hontek.platformswebservice.comm.*;
import com.hontek.platformswebservice.service.inter.PlatformsInter;
import com.hontek.record.dao.ProTypeQrcodeDao;
import com.hontek.record.pojo.TbProTypeQrcode;
import com.hontek.review.dao.ProTypeDao;
import com.hontek.review.pojo.TbProType;
import com.hontek.sys.dao.EnterpriseDao;
import com.hontek.sys.dao.InterAccountDao;
import com.hontek.sys.dao.UserDao;
import com.hontek.sys.pojo.TbInterAccount;
import com.hontek.sys.pojo.TsEnterprise;
import com.hontek.sys.pojo.TsUser;
import com.hontek.sys.service.inter.EnterpriseServiceInter;
import net.sf.json.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.apache.cxf.transport.http.AbstractHTTPDestination;
import org.apache.log4j.Logger;

import javax.annotation.Resource;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
import javax.jws.soap.SOAPBinding.Style;
import javax.servlet.http.HttpServletRequest;
import javax.xml.ws.WebServiceContext;
import javax.xml.ws.handler.MessageContext;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.*;

@WebService
@SOAPBinding(style = Style.RPC)
public class PlatformsImpl implements PlatformsInter {


	private Logger logger = Logger.getLogger(PlatformsImpl.class);

	private InterAccountDao interAccountDao;
	private EnterpriseServiceInter enterprseService;
	private CertificateServiceInter certificateServiceInter;
	private ProTypeDao proTypeDao;
	private EnterpriseDao enterpriseDao;
	private ProTypeQrcodeDao proTypeQrcodeDao;
	private CaInfoDao caInfoDao;
	private UserDao userDao;


	public void setInterAccountDao(InterAccountDao interAccountDao) { this.interAccountDao = interAccountDao; }
	public void setEnterprseService(EnterpriseServiceInter enterprseService) { this.enterprseService = enterprseService; }
	public void setCertificateServiceInter(CertificateServiceInter certificateServiceInter) { this.certificateServiceInter = certificateServiceInter; }
	public void setProTypeDao(ProTypeDao proTypeDao) { this.proTypeDao = proTypeDao; }
	public void setEnterpriseDao(EnterpriseDao enterpriseDao) { this.enterpriseDao = enterpriseDao; }
	public void setProTypeQrcodeDao(ProTypeQrcodeDao proTypeQrcodeDao) { this.proTypeQrcodeDao = proTypeQrcodeDao; }
	public void setCaInfoDao(CaInfoDao caInfoDao) { this.caInfoDao = caInfoDao; }
	public void setUserDao(UserDao userDao) { this.userDao = userDao; }


	@Resource
	private WebServiceContext context;

	private HttpServletRequest getRequest(){
		MessageContext ctx = context.getMessageContext();
		HttpServletRequest request = (HttpServletRequest) ctx.get(AbstractHTTPDestination.HTTP_REQUEST);
		return request;
	}


	@Override
	public String getToken(String account, String password) {
		logger.info("-----获取token开始-----");
		ResultInfo result = new ResultInfo();
		result.setSuccess(false);
		try {
			if(account!=null&&!"".equals(account)&&password!=null&&!"".equals(password)){
				// 这里根据账号和密码获取账号信息可以根据自己业务需求进行修改
				String condition = " and account='"+account+"' and pass='"+password+"'";
				TbInterAccount interAccount = interAccountDao.getInterAccount(condition);
				if(interAccount!=null){
					String token = UUID.randomUUID().toString().replace("-", "");
					SoleManager manager = SoleManager.getInstance();
					interAccount.setTime(System.currentTimeMillis());
					manager.putAccount(token, interAccount);
					result.setCode("1000");
					result.setMsg("获取token成功");
					result.setData(token);
					result.setSuccess(true);
				}else {
					result.setCode("1003");
					result.setMsg("帐号或密码错误");
				}
			}else {
				result.setCode("1002");
				result.setMsg("帐号或密码为空");
			}
		} catch (Exception e) {
			e.printStackTrace();
			logger.info("获取token失败："+e.getMessage());
			result.setCode("1001");
			result.setMsg("获取token失败");
		}
		return JSONObject.fromObject(result).toString();
	}

	@Override
	public String active(String token) {
		logger.info("-----更新心跳开始-----");
		SoleManager manager = SoleManager.getInstance();
		TbInterAccount account = manager.getAccount(token);
		ResultInfo result = new ResultInfo();
		result.setSuccess(false);
		if(account != null){
			account.setTime(System.currentTimeMillis());
			result.setSuccess(true);
			result.setCode("1000");
			result.setMsg("更新心跳成功");
		}else {
			result.setCode("1004");
			result.setMsg("该令牌无效");
		}
		return JSONObject.fromObject(result).toString();
	}

	@Override
	public String logout(String token) {
		SoleManager manager = SoleManager.getInstance();
		TbInterAccount account = manager.getAccount(token);
		ResultInfo result = new ResultInfo();
		if(account != null){
			manager.cleanMap(token);
		}
		result.setSuccess(true);
		result.setCode("1000");
		result.setMsg("退出成功");
		return JSONObject.fromObject(result).toString();
	}

	@Override
	public String syncCompanyInfo(String token, CompanyEntity company) {
		logger.info("-----同步企业信息-----");
		ResultInfo result = new ResultInfo();
		result.setSuccess(false);
		SoleManager manager = SoleManager.getInstance();
		TbInterAccount account = manager.getAccount(token);
		if(account != null){
			try {
				//更新心跳
				manager.active(account);
				if(company != null){
					TsEnterprise ent = new TsEnterprise();
					ent.setParentId(account.getEntId());
					ent.setName(company.getCompanyName());
					ent.setIntro(company.getIntro());
					ent.setOrgCode(company.getOrgCode());
					ent.setLegalPerson(company.getLegalPerson());
					ent.setRegAddr(company.getRegAddr());
					ent.setManageAddr(company.getManagerAddr());
					ent.setEmail(company.getEmail());
					ent.setDomName(company.getDomName());
					ent.setCrtUserId(account.getUserId());
					ent.setFlag("3");//设置为企业
					ent.setSts("0");
					ent.setIsReported("1");//设置为上报企业
					ent.setEntType(Integer.parseInt(company.getEntType()==null?"2":company.getEntType()));//2默认设置为私企
					ent.setCrtDt(DateUtil.formatDateTime());
					ent.setMobile(company.getMobile());
					ent.setSysCode(account.getSysCode());
					ent.setOldEntId(company.getCompanyId());
					ent.setAreaName(company.getAreaName());
					ent.setQualificationType(company.getQualificationType());
					ent.setBusiness(company.getBusiness());
					ent.setPurl("");
					ent.setMurl("");
					Map<String, String> restMap = enterprseService.addSynchCompanyInfo(ent,getRequest());

					String flag = restMap.get("flag");
					if(flag!=null&&"0".equals(flag)){
						result.setCode("1000");
						result.setSuccess(true);
						result.setMsg("同步企业数据成功");
					}else if(flag!=null&&"2".equals(flag)){
						result.setCode("1000");
						result.setSuccess(true);
						result.setMsg("企业已存在，更新企业数据成功");
					}else if(flag!=null&&"3".equals(flag)){
						result.setCode("1005");
						result.setMsg("同步企业数据失败");
					}else {
						result.setCode("1006");
						result.setMsg("参数错误");
					}
				}
			}catch (Exception e){
				e.printStackTrace();
				result.setCode("1007");
				result.setMsg("同步企业数据异常");
				logger.info(e.getMessage());
			}
		}else {
			result.setCode("1008");
			result.setMsg("登陆超时,请重新登陆");
		}
		return JSONObject.fromObject(result).toString();
	}

	@Override
	public String syncProTypeQrCode(String token, ProTypeQrcodeEntity proTypeQrcode) {
		logger.info("-----同步产品信息-----");
		ResultInfo result = new ResultInfo();
		result.setSuccess(false);
		SoleManager manager = SoleManager.getInstance();
		TbInterAccount account = manager.getAccount(token);
		if(account != null){
			try {
				//更新心跳
				manager.active(account);
				String entId = String.valueOf(proTypeQrcode.getCompanyId());
				TsEnterprise enterprise = enterpriseDao.findEnterpriseBySysCodeAndOldEndId(account.getSysCode(), entId);
				if(enterprise!=null){
					if(proTypeQrcode != null){
						TbProTypeQrcode proTypeQrcode2 = new TbProTypeQrcode();
						proTypeQrcode2.setTypeId(Integer.parseInt(proTypeQrcode.getTypeId()));
						proTypeQrcode2.setProName(proTypeQrcode.getProName());
						proTypeQrcode2.setSysCode(account.getSysCode());
						proTypeQrcode2.setOldPtqId(String.valueOf(proTypeQrcode.getPtqId()));
						proTypeQrcode2.setOldDimenno(proTypeQrcode.getProCode());
						proTypeQrcode2.setProDesc(proTypeQrcode.getProDesc());
						//检查是否存在数据
						int count = proTypeQrcodeDao.countBySql("select count(*) from tb_pro_type_qrcode where sys_code='"+account.getSysCode()+"' and old_ptq_id='"+proTypeQrcode.getPtqId()+"'");
						if(count==0){
							proTypeQrcode2.setEntId(enterprise.getEntId());
							String ptqIdStr  = IDUtil.getPrimaryID();
							proTypeQrcode2.setPtqId(ptqIdStr);
							//产生二维码
							String dimenno = "";
							dimenno = enterprise.getEntCode();//entCode = 6位行政区域编码+6位（全省）顺序码
							String dimennoSeq = "01";
							String maxDimenno = proTypeQrcodeDao.findMaxDimennoByEntId(enterprise.getEntId());
							String lastTwoStr="";
							if(maxDimenno!=null&&!"".equals(maxDimenno)){
								lastTwoStr = maxDimenno.substring(maxDimenno.length()-2);
								dimennoSeq = StringUtil.getPtqLastTwoStr(lastTwoStr);
							}
							if("Z9".equals(dimennoSeq)){
								result.setCode("1010");
								result.setMsg("产品数量超出系统允许范围!");
							}else{
								dimenno += dimennoSeq;
								proTypeQrcode2.setDimenno(dimenno);
								proTypeQrcode2.setCrrtime(DateUtil.formatDateTime());
								logger.info("同步产品："+ JSON.toJSONString(proTypeQrcode2));
								proTypeQrcodeDao.save(proTypeQrcode2);
								result.setSuccess(true);
								result.setCode("1000");
								result.setMsg("同步产品数据成功!");
								result.setData(ptqIdStr);

							}
						}else {
							TbProTypeQrcode typeQrcode = proTypeQrcodeDao.getProTypeQrcode(" and sysCode = '"+account.getSysCode()+"' and oldPtqId = '"+proTypeQrcode.getPtqId()+"'");
							logger.info("该产品已同步："+JSON.toJSONString(proTypeQrcode));
							result.setCode("1011");
							result.setMsg("该产品已同步!");
							result.setData(typeQrcode.getPtqId());
						}
					}
				}else {
					logger.info("同步产品失败，该企业未同步："+JSON.toJSONString(proTypeQrcode));
					result.setCode("1012");
					result.setMsg("同步产品失败，该企业未同步!");
				}
			}catch (Exception e){
				e.printStackTrace();
				result.setCode("1013");
				result.setMsg("同步产品数据异常");
				logger.info(e.getMessage());
			}
		}else {
			result.setCode("1008");
			result.setMsg("登陆超时,请重新登陆");
		}
		return JSONObject.fromObject(result).toString();
	}

	
}

3.1 创建ResultInfo返回结果实体类,如下：

package com.hontek.platformswebservice.comm;

/**
 * 返回结果实体类
 * @Author yang
 **/
public class ResultInfo {

	private String code;		//code码
	private boolean success;	// 判断调用是否成功 true：成功 false:失败
	private Object data;		// 数据
	private String msg;			// 信息

	public String getCode() { return code; }
	public void setCode(String code) { this.code = code; }
	public boolean isSuccess() { return success; }
	public void setSuccess(boolean success) { this.success = success; }
	public Object getData() { return data; }
	public void setData(Object data) { this.data = data; }
	public String getMsg() { return msg; }
	public void setMsg(String msg) { this.msg = msg; }

}

3.1 创建SoleManager线程类实现token过期时间及更新和销毁,如下：

package com.hontek.platformswebservice.comm;

import com.hontek.sys.pojo.TbInterAccount;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;


public class SoleManager {

	static final private SoleManager instance = new SoleManager();

	private Map<String, TbInterAccount> accountMap = new HashMap<String, TbInterAccount>();

	public static SoleManager getInstance(){
		return instance;
	 }

	public SoleManager() {
		TimeOut timeout = new TimeOut();
		timeout.start();
	}
	
	synchronized public TbInterAccount getAccount(String token){
		TbInterAccount interAccount = accountMap.get(token);
		if(interAccount!=null)
			interAccount.setTime(System.currentTimeMillis());
		return interAccount;
	}
	
	synchronized public void putAccount(String token,TbInterAccount interAcount){
		this.accountMap.put(token, interAcount);
	}

	
	public class TimeOut extends Thread{
		public void run(){
			long keepTime = 1000L*60*60*10;
			
			while(true){
				try {
					Thread.sleep(1000*60*60*3);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				Set<String> setKey = accountMap.keySet();
				Iterator<String> it = setKey.iterator();
				while(it.hasNext()){
					String key = it.next();
					TbInterAccount interAccount = accountMap.get(key);
					if(System.currentTimeMillis()-interAccount.getTime()>keepTime){
						accountMap.remove(key);
					}
				}
				
			}
		}
	}
	
	/**
	 * 心跳
	 * @param interaccount
	 */
	public void active(TbInterAccount interaccount){
		if(interaccount!=null){
			interaccount.setTime(System.currentTimeMillis());
		}
	}
	/**
	 * 注销
	 * @param token
	 */
	synchronized public void cleanMap(String token){
		TbInterAccount interAccount = accountMap.get(token);
		if(interAccount!=null){
		    interAccount = null;
		    accountMap.remove(token);
		}
	}
}

第四步：发布

*访问路径：域名/项目/CXFService/platform?wsdl，出现如下xml格式的数据说明发布成功*

第五步：测试

5.1 idea中创建webservice客户端进行测试,如下：

5.2 使用测试工具如postman、SoapUI Pro 5.1.2进行测试,如下是soapui进行测试：

第六步：总结：

前期接口写好后首先自己先测试下看看代码有无问题是否能调通接口，如没问题，接下来最好是写一份对接文档进行说明（如下图），再一个跟对三方进行对接时要先在测试环境或者自己本地服务器进行联调（使用内网穿透，我这边使用的是花生壳进行内网穿透），最后发布到正式环境中。

欢迎小伙伴留言评论，需要完整代码的加我QQ：450938667