Spring和WebService发布的服务端

最新推荐文章于 2023-10-09 17:38:44 发布
最新推荐文章于 2023-10-09 17:38:44 发布
阅读量223 收藏
点赞数
分类专栏： 接口
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang666zoo/article/details/86243609
版权 
web.xml 里配置使用cxf发布的
<servlet>
   <servlet-name>cxf</servlet-name>
   <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
   <load-on-startup>1</load-on-startup>
</servlet>
访问时使用http://localhost:8082/2BMPM/rdmuWS?wsdl<servlet-mapping>
   <servlet-name>cxf</servlet-name>
   <url-pattern>/rdmuWS/*</url-pattern>
</servlet-mapping>

maven

<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf</artifactId>
    <version>2.7.15</version>
</dependency>

接口代码

package com.rdmu.product.webservice.pdmserver;

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
@WebService
public interface IntPdmbackWeb {
  @WebMethod
  public String getPdmBackStatus(@WebParam(name = "bizData", targetNamespace = "http://pdmserver.webservice.product.rdmu.com/") String bizData);
  @WebMethod
  public String reviewInformationFeedback(@WebParam(name = "bizData", targetNamespace = "http://pdmserver.webservice.product.rdmu.com/") String bizData);
  @WebMethod
  public String reviewUpcomingTasks(@WebParam(name = "bizData", targetNamespace = "http://pdmserver.webservice.product.rdmu.com/") String bizData);
}

实现类

package com.rdmu.product.webservice.pdmserver;
import com.rdmu.ecubeframework.core.utils.StringUtil;
import com.rdmu.framework.common.utils.PropertyUtil;
import com.rdmu.framework.entity.Sysuser;
import com.rdmu.framework.web.system.service.SysuserService;
import com.rdmu.framework.web.system.service.WebServiceLogService;
import com.rdmu.product.entity.*;
import com.rdmu.product.web.PlanwebClient.services.JavaToXmlPlanService;
import com.rdmu.product.web.mywork.services.TaskApproveInfoService;
import com.rdmu.product.web.pm.services.PlanService;
import com.rdmu.product.web.pm.services.ProjectDocService;
import com.rdmu.product.web.pm.services.SummaryService;
import com.rdmu.product.web.revenueBudget.services.ProjectRevenueInfoService;
import com.rdmu.product.web.revenueBudget.services.RevenuePortService;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
@Component
@Transactional
public  class IntPdmbackWebImpl implements IntPdmbackWeb {

    @Autowired
    private PlanService planService;
    @Autowired
    private JavaToXmlPlanService javaToXmlPlanService;
    @Autowired
    private ProjectDocService  projectDocService;
    @Autowired
    private RevenuePortService revenuePortService;
    @Autowired
    private ProjectRevenueInfoService projectRevenueInfoService;
    @Autowired
    private TaskApproveInfoService taskApproveInfoService;
    @Autowired
    private  SummaryService summaryService;
    @Autowired
    private WebServiceLogService  webServiceLogService;
    @Autowired
    private SysuserService sysuserService;

    @Override
    public String getPdmBackStatus(String bizData) {
    webServiceLogService.genWebServiceLog("","",bizData,"","Pdm修改任务状态","");
        String num = null;
        String result=null;
        String newbizData = bizData.trim();
        try {
            Document personDoc = DocumentHelper.parseText(newbizData);
            Element rootElt = personDoc.getRootElement(); // 获取根节点
            System.out.println("根节点：" + rootElt.getName()); // 拿到根节点的名称
            Iterator body = rootElt.elementIterator("list");

            while (body.hasNext()) {
                Element task = (Element) body.next();
                Iterator tasks = task.elementIterator("task");

                while (tasks.hasNext()){
                    Element Datas = (Element) tasks.next();
                    Iterator delivrylist = Datas.elementIterator("delivrylist");
                    List<ProjectTasks>projectTasksList=this.planService.find("from ProjectTasks ps where ps.id = ? ",Datas.elementTextTrim("taskID"));
                    if(projectTasksList.size()>0&&projectTasksList!=null){
                        for(ProjectTasks projectTask :projectTasksList){
                            if(Datas.elementTextTrim("taskStatus").equals("6005")){

                                projectTask.setStatus(ProjectTasks.STARTING);
                            }
                            if(Datas.elementTextTrim("taskStatus").equals("6007")){

                                projectTask.setStatus("6007");
                                projectTask.setCustomItem2("0");
                                projectTask.setProgress(100);

                            }
                            //进度
                            if(stringUtil(Datas.elementTextTrim("taskProgress"))!=null){
                                projectTask.setProgress(Integer.valueOf(Datas.elementTextTrim("taskProgress")));
                            }
                            //开始时间
                            if(stringUtil(getDate(Datas.elementTextTrim("realBeginTime")))!=null){
                                projectTask.setRealBeginDate(getDate(Datas.elementTextTrim("realBeginTime")));
                            }
                            //结束时间
                            if(stringUtil(getDate(Datas.elementTextTrim("realEndTime")))!=null){
                                projectTask.setRealEndDate(getDate(Datas.elementTextTrim("realEndTime")));
                            }
                            //交付物路径
                            while (delivrylist.hasNext()) {
                                Element delivery = (Element) delivrylist.next();
                                Iterator deliverys = delivery.elementIterator("delivery");
                                while (deliverys.hasNext()){
                                    Element data = (Element) deliverys.next();
                                    if(StringUtil.validateString(data.elementTextTrim("docName"))){
                                        ActivityOResult activityOResult=new ActivityOResult();
                                        activityOResult.setProjectTasks(projectTask);
                                        activityOResult.setName(data.elementTextTrim("docName"));
                                        activityOResult.setCreateUser(this.planService.getTaskSysuserById(data.elementTextTrim("taskID")));
                                        activityOResult.setCustomItem2(data.elementTextTrim("docUrl").replaceAll("喆","&"));
                                        this.planService.save(activityOResult);
                                        ProjectDoc projectDoc = new ProjectDoc();
                                        projectDoc.setProjectTasks(projectTask);
                                        projectDoc.setDocName(data.elementTextTrim("docName"));
                                        projectDoc.setDocSubmitTime(new Date());
                                        projectDoc.setDocType("5011");
                                        projectDoc.setActivityOResult(activityOResult);
                                        projectDoc.setSysuser(this.planService.getTaskSysuserById(data.elementTextTrim("taskID")));
                                        this.projectDocService.save(projectDoc);
                                    }
                                }
                            }

                            this.planService.save(projectTask);
                            planService.calculateParentProgress(projectTask);//计算百分比
                            Properties p = PropertyUtil.initPropertiesFile("system.properties");
                            String http = p.getProperty("systemName");
                            this.summaryService.setPlanProcessApprove(projectTask, http);
                        }
                    }

                }
            }
            result=javaToXmlPlanService.buildResult("0");

        } catch (DocumentException e) {
            e.printStackTrace();
            result=javaToXmlPlanService.buildResult("1");
        }

        return   result;
    }



    public Date getDate(String stringdate){
        Date date = null;
        try {
            SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
            date =sf.parse(stringdate);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return date;
    }


    public  String  stringUtil (Object obj){

        String str= null;
        if(obj!=null){

            str=obj.toString();

        }
        return  str;
    }

    //Pdm反馈评审信息
@Override
public String reviewInformationFeedback(String bizData) {
    webServiceLogService.genWebServiceLog("","",bizData,"","PDM反馈评审信息","");
    String num = null;
    String result=null;
    String newbizData = bizData.trim();//去掉字符串两端的多余的空格
    try {
        Document personDoc = DocumentHelper.parseText(newbizData);
        Element Datas = personDoc.getRootElement(); // 获取根节点
//        Iterator body = rootElt.elementIterator("isLeftProblem");
        Iterator body = Datas.elementIterator("taskId");

//                Element Datas = (Element) body.next();
                //评审信息反馈表
//                ReviewInformation reviewInformationNew = new ReviewInformation();
                //任务id不能为空
                if(StringUtil.validateString(Datas.elementTextTrim("taskId"))){
                    List<ProjectTasks> projectTasksList=this.planService.find("from ProjectTasks ps where ps.id = ? ",Datas.elementTextTrim("taskId"));
                    List<ReviewInformation> reviewInformations =this.planService.find("from ReviewInformation rf where rf.reviewNumber = ? ",Datas.elementTextTrim("reviewNumber"));
                    ReviewInformation reviewInformation;
                    if (reviewInformations.size()>0){
                         reviewInformation = reviewInformations.get(0);
                    }else {
                        reviewInformation = new ReviewInformation();
                    }
                    if(projectTasksList.size()>0){
                        try {
                                reviewInformation.setProjectTasks(projectTasksList.get(0));
                                //型号类别
                                reviewInformation.setModelType(Datas.elementTextTrim("modelType"));
                                //阶段标识
                                reviewInformation.setPhase(Datas.elementTextTrim("phase"));
                                //评审名称
                                reviewInformation.setReviewName(Datas.elementTextTrim("reviewName"));
                                //评审时间
                                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                                if (StringUtil.validateString(Datas.elementTextTrim("reviewTime"))) {
                                    try {
                                        reviewInformation.setReviewTime(sdf.parse(timeStrToDateStr(Datas.elementTextTrim("reviewTime"))));
                                    } catch (ParseException e) {
                                        result = javaToXmlPlanService.buildResult("4");
                                        e.printStackTrace();
                                        return result;
                                    }
                                }
                                //评审级别
                                reviewInformation.setReviewLev(Datas.elementTextTrim("reviewLev"));
                                //评审类别
                                reviewInformation.setReviewClasses(Datas.elementTextTrim("reviewClasses"));
                                //评审类型
                                reviewInformation.setReviewType(Datas.elementTextTrim("reviewType"));
                                //评审形式
                                reviewInformation.setReviewForm(Datas.elementTextTrim("reviewForm"));
                                //评审单号
                                reviewInformation.setReviewNumber(Datas.elementTextTrim("reviewNumber"));
                                //组织单位
                                reviewInformation.setOrgDepart(Datas.elementTextTrim("orgDepart"));
                                //评审组长
                                if (StringUtil.validateString(Datas.elementTextTrim("reviewGroup"))) {
//                                Sysuser reviewGroup = this.sysuserService.get(Datas.elementTextTrim("reviewGroup"));
                                    Sysuser reviewGroup = this.sysuserService.findUnique("select p from Sysuser p where p.pid=?", Datas.elementTextTrim("reviewGroup"));

                                    if (reviewGroup != null) {
                                        reviewInformation.setReviewGroup(reviewGroup);
                                    } else {
//                                        reviewInformation.setReviewGroup(new Sysuser());
                                    }
                                }
                                //有无专家意见
                                if (StringUtil.validateString(Datas.elementTextTrim("isLeftProblem"))) {
                                    reviewInformation.setIsLeftProblem(Integer.parseInt(Datas.elementTextTrim("isLeftProblem")));
                                }
                                //评审结果
                                reviewInformation.setReviewResult(Datas.elementTextTrim("reviewResult"));
                                //项目主管
                                if (StringUtil.validateString(Datas.elementTextTrim("reviewLeader"))) {
//                                Sysuser reviewLeader = this.sysuserService.get(Datas.elementTextTrim("reviewLeader"));
                                    Sysuser reviewLeader = this.sysuserService.findUnique("select p from Sysuser p where p.pid=?", Datas.elementTextTrim("reviewLeader"));
                                    if (reviewLeader != null) {
                                        reviewInformation.setReviewLeader(reviewLeader);
                                    } else {
//                                        reviewInformation.setReviewLeader(new Sysuser());
                                    }
                                }

                                //实际评审费用
                                if (StringUtil.validateString(Datas.elementTextTrim("reviewCharge"))) {
                                    reviewInformation.setReviewCharge(Double.parseDouble(Datas.elementTextTrim("reviewCharge")));
                                }
                                //成本类别
                                reviewInformation.setCostType(Datas.elementTextTrim("costType"));
                                //是否一次通过
                                if (StringUtil.validateString(Datas.elementTextTrim("isFirstPass"))) {
                                    reviewInformation.setIsFirstPass(Integer.parseInt(Datas.elementTextTrim("isFirstPass")));
                                }

                                this.planService.save(reviewInformation);
                                result = javaToXmlPlanService.buildResult("0");

                        } catch (Exception e) {
                            result=javaToXmlPlanService.buildResult("5");
                            e.printStackTrace();
                        }
                    }else{
                        result=javaToXmlPlanService.buildResult("3");
                    }
                }else{
                    result=javaToXmlPlanService.buildResult("2");
                }

    } catch (DocumentException e) {
        e.printStackTrace();
        result=javaToXmlPlanService.buildResult("1");
    }

    return   result;
    }
        //PDM反馈评审中的待办任务回MPM系统
    @Override
    public String reviewUpcomingTasks(String bizData) {
        webServiceLogService.genWebServiceLog("","",bizData,"","PDM反馈评审中的待办任务回MPM系统","");
        String num = null;
        String result=null;
        String newbizData = bizData.trim();//去掉字符串两端的多余的空格
        try {
            Document personDoc = DocumentHelper.parseText(newbizData);
            Element rootElt = personDoc.getRootElement(); // 获取根节点
            Iterator<Element> body = rootElt.elementIterator("question");

                while (body.hasNext()){
                    Element Datas = (Element) body.next();
                    //评审中的待办任务反馈表
                    //评审单号不能为空
                    if(StringUtil.validateString(Datas.elementTextTrim("reviewNumber"))){
                        ReviewUpcomingTasks reviewUpcomingTasks;
                        List<ReviewInformation> reviewInformationList=this.planService.find("from ReviewInformation R where R.reviewNumber = ? ",Datas.elementTextTrim("reviewNumber"));
                        if(reviewInformationList.size()>0){
                            try {
                                reviewUpcomingTasks =this.planService.findUnique("from ReviewUpcomingTasks ru where ru.customItem1 = ? ",Datas.elementTextTrim("ID"));
                                if (reviewUpcomingTasks==null){
                                    reviewUpcomingTasks = new ReviewUpcomingTasks();
                                }
                                reviewUpcomingTasks.setCustomItem1(Datas.elementTextTrim("ID"));
                                reviewUpcomingTasks.setReviewInformation(reviewInformationList.get(0));
                                //专家意见
                                reviewUpcomingTasks.setExpertIdea(Datas.elementTextTrim("expertIdea"));
                                //提出人
                                if(StringUtil.validateString(Datas.elementTextTrim("introducer"))){
//                                 Sysuser dutyPer = this.sysuserService.get(Datas.elementTextTrim("dutyPer"));
                                    Sysuser introducer = this.sysuserService.findUnique("select p from Sysuser p where p.pid=?",Datas.elementTextTrim("introducer"));
                                    if(introducer != null){
                                        reviewUpcomingTasks.setIntroducer(introducer);
                                    }else{
//                                        reviewUpcomingTasks.setIntroducer(new Sysuser());
                                    }
                                }

                                //提出时间
                                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                                if(StringUtil.validateString(Datas.elementTextTrim("applyTime"))){
                                    try {
                                        reviewUpcomingTasks.setApplyTime(sdf.parse(timeStrToDateStr(Datas.elementTextTrim("applyTime"))));
                                    } catch (ParseException e) {
                                        result=javaToXmlPlanService.buildResult("4");
                                        e.printStackTrace();
                                        return   result;
                                    }
                                }

                                //责任部门
                                reviewUpcomingTasks.setResDepart(Datas.elementTextTrim("resDepart"));
                                //责任人
                                if(StringUtil.validateString(Datas.elementTextTrim("dutyPer"))){
//                                 Sysuser dutyPer = this.sysuserService.get(Datas.elementTextTrim("dutyPer"));
                                    Sysuser dutyPer = this.sysuserService.findUnique("select p from Sysuser p where p.pid=?",Datas.elementTextTrim("dutyPer"));
                                    if(dutyPer != null){
                                        reviewUpcomingTasks.setDutyPer(dutyPer);
                                    }else{
//                                        reviewUpcomingTasks.setDutyPer(new Sysuser());
                                    }
                                }


                                //是否采纳
                                if(StringUtil.validateString(Datas.elementTextTrim("isPass"))){
                                    reviewUpcomingTasks.setIsPass(Integer.parseInt(Datas.elementTextTrim("isPass")));
                                }
                                //不采纳情况说明
                                reviewUpcomingTasks.setAdoptExplain(Datas.elementTextTrim("adoptExplain"));
                                //问题落实情况说明
                                reviewUpcomingTasks.setProExplain(Datas.elementTextTrim("proExplain"));
                                //遗留到下阶段解决的事项
                                reviewUpcomingTasks.setLeftoverExplain(Datas.elementTextTrim("leftoverExplain"));
                                //问题落实时间
                                if(StringUtil.validateString(Datas.elementTextTrim("proTime"))){
                                    try {
                                        reviewUpcomingTasks.setProTime(sdf.parse(timeStrToDateStr(Datas.elementTextTrim("proTime"))));
                                    } catch (ParseException e) {
                                        result=javaToXmlPlanService.buildResult("4");
                                        e.printStackTrace();
                                        return   result;
                                    }
                                }
                                //验证情况
                                reviewUpcomingTasks.setVerifyState(Datas.elementTextTrim("verifyState"));
                                //验证时间
                                if(StringUtil.validateString(Datas.elementTextTrim("verifyTime"))){
                                    try {
                                        reviewUpcomingTasks.setVerifyTime(sdf.parse(timeStrToDateStr(Datas.elementTextTrim("verifyTime"))));
                                    } catch (ParseException e) {
                                        result=javaToXmlPlanService.buildResult("4");
                                        e.printStackTrace();
                                        return   result;
                                    }
                                }
                                //组织单位
                                reviewUpcomingTasks.setStatus(Datas.elementTextTrim("status"));

                                this.planService.save(reviewUpcomingTasks);
                                result=javaToXmlPlanService.buildResult("0");
                            } catch (Exception e) {
                                //字段类型不匹配
                                result=javaToXmlPlanService.buildResult("5");
                                e.printStackTrace();
                            }
                        }else{
                            //评审单号查不到数据
                            result=javaToXmlPlanService.buildResult("3");
                        }
                    }else{
                        //评审单号不能为空
                        result=javaToXmlPlanService.buildResult("2");
                    }
                }

        } catch (DocumentException e) {
            e.printStackTrace();
            result=javaToXmlPlanService.buildResult("1");
        }

        return   result;
    }


    public static String timeStrToDateStr(String timeStr){
        if (null == timeStr) {
            return null;
        }
        String dateStr = null;
        SimpleDateFormat sdf_input = new SimpleDateFormat("yyyyMMdd");//输入格式
        SimpleDateFormat sdf_target =new SimpleDateFormat("yyyy-MM-dd"); //转化成为的目标格式
        try {
            //将20160325160000转化为Fri Mar 25 16:00:00 CST 2016,再转化为2016-03-25 16:00:00
            dateStr = sdf_target.format(sdf_input.parse(timeStr));
        } catch (Exception e) {
        }
        return dateStr;
    }


}

Spring核心配置文件里的代码

<?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:tx="http://www.springframework.org/schema/tx"
      xmlns:jaxws="http://cxf.apache.org/jaxws"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:util="http://www.springframework.org/schema/util"
      xmlns:aop="http://www.springframework.org/schema/aop"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
                  http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
                  http://www.springframework.org/schema/tx 
                  http://www.springframework.org/schema/tx/spring-tx-3.0.xsd 
                  http://www.springframework.org/schema/context
                  http://www.springframework.org/schema/context/spring-context-3.0.xsd
                  http://www.springframework.org/schema/util
                  http://www.springframework.org/schema/util/spring-util-3.0.xsd
                  http://cxf.apache.org/jaxws
                  http://cxf.apache.org/schemas/jaxws.xsd
                  http://www.springframework.org/schema/aop
                     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"

   default-lazy-init="true">
接口发布需要代码
id随便起名，class为实现类
<bean id="pdmPorts" class="com.rdmu.product.webservice.pdmserver.IntPdmbackWebImpl" />
address也是随便起名，bean用上面的id
<jaxws:server address="/PdmToMpmPorts">
   <jaxws:serviceBean>
      <ref  bean="pdmPorts" />
   </jaxws:serviceBean>
</jaxws:server>

以上就是发布WebService的所有代码。

 

WangBoHao66666
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE6.0 Web Service学习笔记
linliangyi2006的专栏
03-01 387
[size=large][b]Web Service概述[/b][/size] [b]Web Service的定义[/b] W3C组织对其的定义如下，它是一个软件系统，为了支持跨网络的机器间相互操作交互而设计。Web Service服务通常被定义为一组模块化的API，它们可以通过网络进行调用，来执行远程系统的请求服务。 这里我们从一个程序员的视角来观察web service。在传...
spring调用webservice
tianzhen620的博客
03-03 2949
spring调用webservice一、WebService入门1.1 什么是WebService1.2 调用网络上的WebService服务1.3 SOAP和WSDL概念1.3.1 SOAP（Simple Object Access Protocol）：简单对象访问协议1.3.2 WSDL Web服务描述语言二、基于jdk1.7发布一个WebService服务2.1 服务端发布2.2 客户端调用...
[spring处理webservice报文] 1 spring如何搭建webservice服务
wltsysterm的博客
05-14 3643
1 背景 最近收到一个需求，比较坑，但是大概的意思看懂了，但是其中让我大意的是： 需求说，双方通信采用报文的形式，如下： <soap:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ws="http://ws.ws.future.com/"> <soap:Header/> <soap:Body> 报文密文 </soap:Body&g...
Spring系列学习之Spring Web Services
web13618542420的博客
04-27 2016
英文原文：https://spring.io/projects/spring-ws 目录 概述 特性 Spring Boot配置 快速开始 学习 文档 概述 Spring Web Services（Spring-WS）是Spring社区的一个产品，专注于创建文档驱动的Web服务。 Spring Web Services旨在促进契约优先的SOAP服务开发，允许使用多种方式之一来操作XML有效负载来创建灵活的Web服务。该产品基于Spring本身，这意味着您可以使用Spring概念（如依赖注入）作为Web服务
spring-创建Webservice服务
最新发布
毅香雪海的博客
10-09 1333
webservice
Spring Boot 实现Restful webservice服务端示例代码
08-28
Spring Boot 实现Restful Webservice 服务端示例代码 Spring Boot 是一个基于 Java 的框架，用于快速构建生产级别的应用程序。它提供了许多有用的特性，如自动配置、嵌入式容器、生产准备等。下面，我们将探讨如何...
springboot+webservice搭建webservice服务端
11-10
Spring Boot是一个流行的Java框架，用于简化Spring应用的创建和管理。本教程将讲解如何使用Spring Boot来搭建一个Web Service服务端，并介绍如何利用Java客户端进行调用。 ### 一、Spring Boot与Web Service ...
Spring-ws搭建WebService服务端demo
08-14
总结起来，本示例展示了如何使用Spring、Spring-WS和Maven构建一个简单的Web Service服务端。从定义XML Schema到创建服务接口、实现业务逻辑、配置Spring-WS Servlet，每一个步骤都是为了使Web Service能够正确地...
发布webService服务接口与spring整合教程
12-04
Spring支持基于注解的Web Service发布，如使用`@WebService`和`@WebServiceClient`。你也可以使用Spring-WS或Apache CXF等库来创建WSDL并部署服务。 4. **测试和调试**：确保编写了单元测试来验证Web Service接口的...
cxf+spring开发webservice客户端与服务端实例
02-04
本实例将详细阐述如何利用CXF和Spring来构建Web服务的客户端和服务端。 一、CXF简介 CXF是一个开源的Java框架，专门用于构建和消费Web服务。它支持SOAP、RESTful等多种服务模型，并且可以方便地与Spring框架集成，...
Spring+CXF 发布WebService服务
03-11
Spring+CXF 发布WebService服务
【十二】springboot整合WebService
热门推荐
weixin_56995925的博客
09-22 1万+
springboot整合WebService
springboot开发webservice服务端，发布多个webservice服务案例（带你玩转webservice）
Brave_heart4pzj的博客
09-05 5929
webservice
（SpringCloud中的WebService）SpringBoot整合CXF——服务端
fyk的博客
08-16 9589
文章目录引入jar包修改配置文件CXF配置类WS接口编写测试 在SpringBoot和SpringCloud微服务中，整合CXF都是一样的。直接上代码： 引入jar包 这里只给出了CXF先关的jar包，项目中的其他jar依赖略。 <!-- cxf start --> <dependency> <groupId>org.apache.cxf</groupI......
基于spring+cxf框架webService接口开发（1）--服务器端
zhoumimi_comeon123的博客
11-07 4698
WebService接口开发（Spring+cxf） 服务器端(认证+加密) 导入Apache  cxf.jar包 什么是cxf CXF是建立在SOAP协议上的一个Web service框架。 什么是SOAP协议？ 简单来说就是两个不同项目（开发语言不同等）通过xml文件来描述要传输的东西，然后通过HTTP协议传输，接收方把收到的xml解析成需要的对象使用，返回的时候将xml封...
WebService学习之旅（三）JAX-WS与Spring整合发布WebService
weixin_34345753的博客
03-25 138
Spring本身就提供了对JAX-WS的支持，有兴趣的读者可以研究下Spring的Spring-WS项目，项目地址： http://docs.spring.io/spring-ws/sites/1.5/downloads/releases.html 基于Spring IoC容器发布Web服务，能够大大降低WebService实现过程，也能够更好的与企业级应用进行整合，本文將...
SpringBoot创建webService客户端并调用服务（最简单实用）
dou747172348的博客
12-30 7786
springboot调用webservice服务
基于Spring注解的WebService接口，服务端编码与客户端调用
阳光不锈的博客
07-19 1万+
网上已经有很多spring注解实现WebService的文章，写这一篇主要是为了记录自己写的这个WebService。并为以后再写接口提供参考和改进的依据。开搞======================================服务端：建项目、jar包导入jar包下载地址：(稍后修改)代码部分（一个接口、一个实现类、一个工厂类、两个xml配置文件）：接口类接口实现类：工厂类：两个配置文件：...
WebService学习总结九 使用Spring发布WebService
男儿当自强
07-17 1万+
服务端WebService接口使用Spring发布，客户端使用java测试。 服务端： 导入对应的jar包，编写服务接口并实现，和之前方式相同，然后在src下加个配置文件，引入cxf的核心配置。在web.xml引入这个配置文件，开启spring监听，引入CXFServlet处理请求。 package ws.spring.server; public class UserBean { pr
使用springboot+cxf搭建一个webservice的服务端
04-25
好的，我了解了您的问题。使用Spring Boot和CXF框架搭建一个Webservice服务端的步骤如下： 1. 首先，在您的项目中添加CXF和Spring Boot的依赖，例如： ``` <dependency> <groupId>org.apache.cxf</groupId> <artifactId>cxf-spring-boot-starter-jaxws</artifactId> <version>3.3.6</version> </dependency> ``` 注意，这里使用的是CXF的JAX-WS模块，您也可以根据需要选择其他模块。 2. 接着，在您的配置文件中添加CXF的配置，例如： ``` @Configuration public class CxfConfig { @Bean public ServletRegistrationBean<CXFServlet> cxfServlet() { return new ServletRegistrationBean<>(new CXFServlet(), "/yourWebserviceUrl/*"); } @Bean(name = Bus.DEFAULT_BUS_ID) public SpringBus springBus() { return new SpringBus(); } @Bean public YourWebService yourWebService() { return new YourWebService(); } @Bean public Endpoint yourWebServiceEndpoint() { EndpointImpl endpoint = new EndpointImpl(springBus(), yourWebService()); endpoint.publish("/YourWebServiceUrl"); return endpoint; } } ``` 这里配置了CXF的Servlet，以及您自己实现的Webservice服务类和Endpoint。注意，您需要将 "/yourWebserviceUrl/" 和 "/YourWebServiceUrl" 替换为您自己的URL。 3. 最后，您可以实现您的Webservice服务类，例如： ``` @Service @WebService(serviceName = "YourWebService") public class YourWebService { @WebMethod public String hello(@WebParam(name = "name") String name) { return "Hello, " + name + "!"; } } ``` 这里实现了一个简单的hello方法，接收一个name参数并返回一个包含该参数的问候语。 完成以上步骤后，您就成功地搭建了一个基于CXF和Spring Boot的Webservice服务端。当您在浏览器中输入"http://localhost:8080/YourWebServiceUrl?wsdl"时，您将看到您的Webservice服务的WSDL文档。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值