Java程序webService应用

最新推荐文章于 2024-07-15 22:27:12 发布

手撕面包师

最新推荐文章于 2024-07-15 22:27:12 发布

阅读量748

点赞数 1

分类专栏： java框架文章标签： java

本文链接：https://blog.csdn.net/qq_40133129/article/details/106907886

版权

java框架专栏收录该内容

2 篇文章 0 订阅

订阅专栏

开始接触webservice看网上的资料零零散散的，看来看去也没有看懂是怎么搞得，很是头大，今天决定手撸一下webservice

webservice基本概念

webservice是一种远程方法调用，主要使用在异构系统的交互如：Java和c++,同样也可以是连个java项目之间交互
webservice基于http协议，使用的是soap协议，soap协议分为soap1.1和soap1.2,1.2兼容1.1协议
wsdl是webservice的描述语言
静态方法，和final修饰的方法不可发布

一、jdk下的webservice使用

1.1 jdk下类的发布与调用

1.1.1 服务端代码

jdk中不用导入jar包，因为C:\Program Files\Java\jdk1.8.0_181\bin目录下有一个：wsimport.exe文件，这就是jdk自带的生成服务段代码的命令依赖包

服务类发布代码是：PersonService.java和Publisher发布类

发布类PersonService.java

package com.rl.server;

import javax.jws.WebService;
//**jdk发布服务类的时候，必须加上@WebService注解**
@WebService
public class PersonService {
	public String sayHello(String name) {
		return name + "hello";
	}
}

发布类：Publisher.java

package com.rl.server;

import javax.xml.ws.Endpoint;

public class Publisher {
    public static void main(String[] args) {
		//发布方法：                   发布地址                    服务类的对象
    	Endpoint.publish("http://192.168.20.125:8089/hello", new PersonService());
	}
}

1.1.2 调用服务端代码（客户端）

1.服务端发布服务后，可以在浏览器访问如下地址：
http://192.168.20.125:8089/hello?wsdl可以查看发布的描述语言
客户端调用使用指令wsimport生成客户端可以调用的代码：
wsimport：jdk中的命令
- -s生成源代码，-p生成代码后的包名(自定义)， -Xnocompile只生成java文件
- 操作：找一个空文件夹，使用命令窗口cmd,进入该目录下，执行下列命令
- - wsimport -s . -p com.ws http://192.168.20.125:8089/hello?wsdl （生成java和class）
  - wsimport -s . -p com.ws http://192.168.20.125:8089/hello?wsdl -Xnocompile（只生成java）
  - wsdl2java -d . -p com.rl.class address?wsdl （cxf中调用生成客户端代码，soap1.1和soap1.2都可以使用该命令）
    删除生成的class代码，留下java拷到项目下src下
- 报错
  - 1.在空文件夹生执行指令提示失败，解决方案：可以cmd中进入jdk的bin目录下，然后执行该命令，可在jdk的bin目录下生成该包
    *2. src下改变指定生成源代码的包名和类路径会报错
    
    将生成的代码拷贝待src下，然后调用Client.java

package com.ws;

public class Client {
    public static void main(String[] args) {
		//1.创建服务访问点集合
    	PersonServiceService  pss  =new PersonServiceService();
    	//2.获得服务点绑定的类，使用get+port的名字获取
    	PersonService  ps=pss.getPersonServicePort();
    	//3.调用服务端方法
    	String  result =ps.sayHello("li");
    	System.out.println(result);
	}
}

1.2 jdk下接口的发布与调用

1.2.1 服务端代码

接口中@WebService加载Impl上，Endpoint中发布的是Impl类，接口中发布实现的是实现类
```
      **接口UserInterFace**
```

package com.rl.server;
/**
 * 
 * @author MB158
 * jdk对接口支持不是很好，wsdl中体现的是实现类的类
 */
public interface UserInterface {
    public String  sayHello(String  name);
}

         **实现类UserImpl**

package com.rl.server;

import javax.jws.WebService;

/**
 * 
 * @author MB158
 * 接口加在实现类上
 */
@WebService
public class UserImpl  implements UserInterface {
	@Override
	public String sayHello(String name) {
		// TODO Auto-generated method stub
		return name+"接口实现";
	}
}

         **发布类Publish**


package com.rl.server;

import javax.xml.ws.Endpoint;

public class Publisher {

    public static void main() {
  		//发布方法：                  发布地址                    服务类实现的对象
      	Endpoint.publish("http://192.168.20.125:8089/hello", new UserImpl());
  	}
}

1.2.2 调用服务端代码（客户端）

同样接口实现是生成代码，然后获取服务访问集合点，获得接口实现类的get+port，然后调用方法，同上

二、cxf框架下的webservice使用

2.1 cxf框架下类的发布与调用

     类发布：使用cxf框架需要导入jar包，bin地址：
     链接：https://pan.baidu.com/s/1HVN09Kq95VyMKPObSTwYYQ 
     提取码：a18a
     PersonService2.java

package com.rl.server;

import javax.jws.WebService;

@WebService
public class PersonService2 {
    public  String  sayHello(String name) {
    	return  "hello"+name;
    }
}

发布类：

package com.rl.server;

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

public class Publisher {
    public static void main(String[] args) {
    	publishImplJaxWsServerFactoryBean();
    }
    /**
     * 1.服务类不需要写注解，不建议使用这种方式来发布webservices服务
     *   生成的wsdl不规范
     */
    public static  void  ServerFactoryBean() {
    	//创建cxf发布的服务对象
		ServerFactoryBean   sfb=new ServerFactoryBean();
		//设置服务的类
		sfb.setServiceClass(PersonService.class);
		//设置服务地址
		sfb.setAddress("http://localhost:5555/hello");
		//设置服务类对象
		sfb.setServiceBean(new PersonService());
		//发布
		sfb.create();
	}
    /**
     * 1.ServerFactoryBean的子类JaxWsServerFactoryBean；服务类需要添加webservice注解，要不发布无效
     * 2.生成的wsdl的文档是规范的
     */
    public static  void  publishWSWithJaxWsServerFactoryBean() {
    	//创建cxf发布的服务对象
		JaxWsServerFactoryBean   sfb=new JaxWsServerFactoryBean();
		//设置服务的类
		sfb.setServiceClass(PersonService2.class);
		//设置服务地址
		sfb.setAddress("http://localhost:5555/hello");
		//设置服务类对象
		sfb.setServiceBean(new PersonService2());
		//发布
		sfb.create();
    }
    /**
     * 发布带有接口的类，注解加载带有接口类上：支持soap1.2
     */
    public static  void  publishImplJaxWsServerFactoryBean() {
    	//创建cxf发布的服务对象
		JaxWsServerFactoryBean   sfb=new JaxWsServerFactoryBean();
		//设置服务的类：设置接口类
		sfb.setServiceClass(UserService.class);
		//设置服务地址
		sfb.setAddress("http://localhost:7777/hello");
		//设置服务类对象:设置实现的接口类
		sfb.setServiceBean(new UserServiceImpl());
		//增加设置消息输入输出的消息拦截器
		sfb.getInInterceptors().add(new LoggingInInterceptor());
		sfb.getOutInterceptors().add(new LoggingOutInterceptor());
		//发布
		sfb.create();
    }
}

jdk下的webservice接口，注释加在实现类impl上，调用返回的是Impl类

cxf框架下的webservice下，注释加载接口类上interface,返回的也是interface类，即接口类

     类调用同上

2.2 cxf框架下接口的发布与调用

   类发布
   接口：
   UserService.java

package com.rl.server;

import javax.jws.WebService;
import javax.xml.ws.BindingType;

/**
 * 
 * @author MB158
 * 1.发布带有接口的类，接口需要加webService
 * 2.定义soap12的版本用wsimport生成代码，会发生问题，使用cxf提供的生成，不加版本号为soap11可以使用wsimport
 *   可以使用：wsdl2java需要配置bin,  wsdl2java  -d .  -p  pagename  address?wsdl    ;  -d生成在当前目录
 */
@WebService
//2.默认情况下soap的版本是soap11,如果想要使用soap12需要使用@BindingType
@BindingType(value=javax.xml.ws.soap.SOAPBinding.SOAP12HTTP_BINDING)
public interface UserService {
   public  String  sayLove(String name);
}

   UserServiceImpl.java

package com.rl.server;

public class UserServiceImpl implements UserService {
	@Override
	public String sayLove(String name) {
		// TODO Auto-generated method stub
		return "hell0"+name;
	}
}

发布：

    /**
     * 发布带有接口的类，注解加载带有接口类上：支持soap1.2
     */
    public static  void  publishImplJaxWsServerFactoryBean() {
    	//创建cxf发布的服务对象
		JaxWsServerFactoryBean   sfb=new JaxWsServerFactoryBean();
		//设置服务的类：设置接口类
		sfb.setServiceClass(UserService.class);
		//设置服务地址
		sfb.setAddress("http://localhost:7777/hello");
		//设置服务类对象:设置实现的接口类
		sfb.setServiceBean(new UserServiceImpl());
		//增加设置消息输入输出的消息拦截器
		sfb.getInInterceptors().add(new LoggingInInterceptor());
		sfb.getOutInterceptors().add(new LoggingOutInterceptor());
		//发布
		sfb.create();
    }

   接口调用：执行命令，然后拷贝到src下，然后执行代码

package com.rl.client;

import com.code.ws.UserService;
import com.code.ws.UserServiceService;

/**
 * 生成客户端代码:在jdk的bin目录下，然后拷贝下来
 * @author MB158
 * wsimport  -s . -p   com.rl.person  address?wsdl
 */
public class Client {
       public static void main(String[] args) {
		UserServiceService  ser =new UserServiceService();
		//返回接口类interface
		UserService  userservice=ser.getUserServicePort();
		System.out.println(userservice.sayLove("no  user"));
	}
}

jdk下的webservice接口，注释加在实现类impl上，调用返回的是Impl类*
cxf框架下的webservice下，注释加载接口类上interface,返回的也是interface类，即接口类

三、解析wsdl文件

  <?xml version="1.0" encoding="UTF-8" ?> 
- <!--  Published by JAX-WS RI (http://jax-ws.java.net). RI's version is JAX-WS RI 2.2.9-b130926.1035 svn-revision#5f6196f2b90e9460065a4c2f4e30e065b245e51e. 
  --> 
- <!--  Generated by JAX-WS RI (http://jax-ws.java.net). RI's version is JAX-WS RI 2.2.9-b130926.1035 svn-revision#5f6196f2b90e9460065a4c2f4e30e065b245e51e. 
  --> 
  #读从下往上
- <definitions xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://www.w3.org/ns/ws-policy" xmlns:wsp1_2="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:wsam="http://www.w3.org/2007/05/addressing/metadata" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://server.rl.com/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.xmlsoap.org/wsdl/" targetNamespace="http://server.rl.com/" name="PersonServiceService">
- 
  #types:对输入输出消息体的约束
 <types>
- <xsd:schema>
  <xsd:import namespace="http://server.rl.com/" schemaLocation="http://192.168.20.125:8089/hello?xsd=1" /> 
  </xsd:schema>
  </types>
  
  #6.input：
- <message name="sayHello">
  <part name="parameters" element="tns:sayHello" /> 
  </message>
  
- <message name="sayHelloResponse">
  <part name="parameters" element="tns:sayHelloResponse" /> 
  </message>
  
  
  #5.portType:服务类有n个operation，operation:服务类中的方法：00
- <portType name="PersonService">
- <operation name="sayHello">
  #5.1：input输入的消息，output:输出的消息。  远程要考虑什么形式在网络上传输和返回，message：输入输出消息体，分别对应服务段接受的参数和响应的返回值。
  soap请求体是xml.xml不能随便写，需要约束使用schema
  #找input:sayHello
  <input wsam:Action="http://server.rl.com/PersonService/sayHelloRequest" message="tns:sayHello" /> 
  <output wsam:Action="http://server.rl.com/PersonService/sayHelloResponse" message="tns:sayHelloResponse" /> 
  </operation>
  </portType>
  
  
  #4.binding：把服务访问点和服务类绑定在一起，调用端不用关心这个标签里面的内容，只要直到type属性，
  这个属性指定了绑定服务类的元素，tns表示当前命名空间
- <binding name="PersonServicePortBinding" type="tns:PersonService">
  <soap:binding transport="http://schemas.xmlsoap.org/soap/http" style="document" /> 
- <operation name="sayHello">
  <soap:operation soapAction="" /> 
- <input>
  <soap:body use="literal" /> 
  </input>
- <output>
  <soap:body use="literal" /> 
  </output>
  </operation>
  </binding>
  
  #1.service**服务访问集合**，name属性调用时需要使用://1.创建服务访问点集合
    	PersonServiceService  pss  =new PersonServiceService();
- <service name="PersonServiceService">
  #2.port服务访问点，name属性调用是需要使用， 从下往上找binding:指定了服务访问点和服务类绑定元素:
  获得服务绑定的类，使用get+port:PersonService  ps=pss.getPersonServicePort();
- <port name="PersonServicePort" binding="tns:PersonServicePortBinding">
  #3.当前服务点的访问地址soap作为协议访问
  <soap:address location="http://192.168.20.125:8089/hello" /> 
  </port>
  </service>
  </definitions>

四、最终使用webService在Javaweb项目中的使用

web发布一类的形式发布：默认发布的是soap1.1,发布1.2需要指定要指定
客户端调用方式还是一样 wsdl2java -d . -p com.rl.class address?wsdl

类发布
类：PersonService.java

package cxf_web_webservice;

import javax.jws.WebService;
/**
 * @author MB158
 * web发布一类的形式发布：默认发布的是soap11,发布12怎么要指定
 *     客户端调用方式还是一样  wsdl2java  -d . -p  com.rl.class  address?wsdl
 */
@WebService
public class PersonService {
	
   public String  syaLove(String name) {
	   return  name+"love";
   }
}

cxf-servlet.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"
xmlns:soap="http://cxf.apache.org/bindings/soap"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
                    http://cxf.apache.org/bindings/soap
                    http://cxf.apache.org/schemas/configuration/soap.xsd
                    http://cxf.apache.org/jaxws
                    http://cxf.apache.org/schemas/jaxws.xsd
                    http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/aop
                        http://www.springframework.org/schema/aop/spring-aop.xsd
                        http://www.springframework.org/schema/tx
                        http://www.springframework.org/schema/tx/spring-tx.xsd
                    ">
       <!--引入cxf中的配置文件，自带的，早起版本使用解决兼容问题 :
                  问题不注释：报找不到，注释后就可以了
        -->
        <!-- <import resource="classpath:META-INF/cxf/cfx.xm"/>
        <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml"/>
         <import resource="classpath:META-INF/cxf/cxf-servlet.xml"/> -->
         
         <!--配置personServie,通过配置文件发布服务,
           endpoint针对与类的方式发布,
           wsdl的全路径：http://localhost:8080/cxf_web_webservice/[url-partten]/address
           address地址的规则:配置时前面必须加斜线
           implementor：类的全路径
         -->
             
         <jaxws:endpoint  id="personService"  address="/personService"  implementor="cxf_web_webservice.PersonService">
                   <!-- 配置拦截器 -->
                   <jaxws:inInterceptors>
                   <bean class="org.apache.cxf.interceptor.LoggingInInterceptor" />  
                   </jaxws:inInterceptors>
                   <jaxws:outInterceptors>
                   <bean  class="org.apache.cxf.interceptor.LoggingOutInterceptor"/> 
                   </jaxws:outInterceptors>
         </jaxws:endpoint>
         
</beans>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  
 <servlet>
    <servlet-name>mycxf</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>mycxf</servlet-name>
    <url-pattern>/services/*</url-pattern>
  </servlet-mapping>
  
</web-app>

接口发布
接口类：UserService
接口发布：客户端调用的也是接口类，而非实现类

package com.user;
/**
 * 接口发布：客户端调用的也是接口类，而非实现类
 * 默认是soap11
 */
import javax.jws.WebService;

@WebService
public interface UserService {
    public  String  sayHate(String name);
}

接口实现类：UserServiceImpl

package com.user;

public class UserServiceImple implements UserService {
	@Override
	public String sayHate(String name) {
		// TODO Auto-generated method stub
		return  name+"ooo";
	}
}

WEB-INF中配置文件：
cxf-servlet.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"
xmlns:soap="http://cxf.apache.org/bindings/soap"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
                    http://cxf.apache.org/bindings/soap
                    http://cxf.apache.org/schemas/configuration/soap.xsd
                    http://cxf.apache.org/jaxws
                    http://cxf.apache.org/schemas/jaxws.xsd
                    http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/aop
                        http://www.springframework.org/schema/aop/spring-aop.xsd
                        http://www.springframework.org/schema/tx
                        http://www.springframework.org/schema/tx/spring-tx.xsd
                    ">
       <!--引入cxf中的配置文件，自带的，早起版本使用解决兼容问题 :
                  问题不注释：报找不到，注释后就可以了
        -->
        <!-- <import resource="classpath:META-INF/cxf/cfx.xm"/>
        <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml"/>
         <import resource="classpath:META-INF/cxf/cxf-servlet.xml"/> -->
         
         <!--配置personServie,通过配置文件发布服务,
           endpoint针对与类的方式发布,
           wsdl的全路径：http://localhost:8080/cxf_web_webservice/[url-partten]/address
           address地址的规则:配置时前面必须加斜线
           implementor：类的全路径
         -->
         
       <!--用接口的方式cxf使用jaxws:server
       serviceClass:接口类
                 可以发布n多个webservice服务
         -->
       <jaxws:server  id="userService"  address="/userService"  serviceClass="com.user.UserService">
         <!--具体实现类:impl  -->
          <jaxws:serviceBean>
          <bean  class="com.user.UserServiceImple"></bean>
          </jaxws:serviceBean>
          
            <!-- 配置拦截器 -->
                   <jaxws:inInterceptors>
                   <bean class="org.apache.cxf.interceptor.LoggingInInterceptor" />  
                   </jaxws:inInterceptors>
                   <jaxws:outInterceptors>
                   <bean  class="org.apache.cxf.interceptor.LoggingOutInterceptor"/> 
                   </jaxws:outInterceptors>
       </jaxws:server>
       
</beans>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  
 <servlet>
    <servlet-name>mycxf</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>mycxf</servlet-name>
    <url-pattern>/services/*</url-pattern>
  </servlet-mapping>
  
</web-app>

spring+webservice

接口形式可以发布多个webservice服务，在mycxf-servlet.xml中配置
jra包：链接：https://pan.baidu.com/s/1LuyXOh8dBuHeMr8MTSJxgQ
提取码：c3al
在这里插入图片描述 mvc形式：Model-View-Controller(模型-视图-控制器)
Model：建立数据对象和数据库的连接
View:显示数据的页面
Controller:控制数据流向模型对象，并在数据变化的时候更新视图

com.pojo.Person

package com.pojo;

public class Person {
	private int id;
	private String name;

	public int getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

Dao
PersonServiceDao.java
@Repository:注解接口，把该接口的实现类交给spring管理，在那个地方需要这个类作为依赖的时候，就可以注入

package com.dao;

import java.util.List;

import org.springframework.stereotype.Repository;

import com.pojo.Person;
@Repository
public interface PersonServiceDao {
    public  void  add(Person  p);
    public  List<Person>  find(int  id);
}

PersonDaoImpl.java

package com.dao.impl;

import java.util.ArrayList;
import java.util.List;

import org.springframework.stereotype.Repository;

import com.dao.PersonServiceDao;
import com.pojo.Person;


public class PersonDaoImpl  implements  PersonServiceDao {
   List<Person>  plist =new ArrayList<Person>();
	@Override
	public void add(Person p) {
		// TODO Auto-generated method stub
		plist.add(p);
	}

	@Override
	public List<Person> find(int id) {
		// TODO Auto-generated method stub
		return plist;
	}
  
}

对外发布的接口和实现
PersonService.java

package com.wsservice;

import java.util.List;

import javax.jws.WebService;

import org.springframework.stereotype.Service;

import com.pojo.Person;

@WebService
public interface PersonService {
    public  void  add(Person  p);
    public  List<Person>  find(int  id);
}

PersonServiceImpl.java: @Service用于标注业务层组件

package com.wsservice.impl;

import java.util.List;

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

import com.pojo.Person;
import com.wsservice.PersonService;
import com.dao.PersonServiceDao;

@Service
public class PersonSeriveImpl implements PersonService {
    
	@Autowired
	private  PersonServiceDao  perdao;
	@Override
	public void add(Person p) {
		// TODO Auto-generated method stub
         perdao.add(p);
	}

	@Override
	public List<Person> find(int id) {
		// TODO Auto-generated method stub
		return perdao.find(id);
	}

}

src目录下的配置文件beans.xml和mycxf-servlet.xml
beans.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"
xmlns:soap="http://cxf.apache.org/bindings/soap"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
                    http://cxf.apache.org/bindings/soap
                    http://cxf.apache.org/schemas/configuration/soap.xsd
                    http://cxf.apache.org/jaxws
                    http://cxf.apache.org/schemas/jaxws.xsd
                    http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/aop
                        http://www.springframework.org/schema/aop/spring-aop.xsd
                        http://www.springframework.org/schema/tx
                        http://www.springframework.org/schema/tx/spring-tx.xsd
                    ">
<!--扫描器  -->
<context:component-scan base-package="com"/>                    
</beans>

mycxf-servlet.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"
xmlns:soap="http://cxf.apache.org/bindings/soap"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
                    http://cxf.apache.org/bindings/soap
                    http://cxf.apache.org/schemas/configuration/soap.xsd
                    http://cxf.apache.org/jaxws
                    http://cxf.apache.org/schemas/jaxws.xsd
                    http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/aop
                        http://www.springframework.org/schema/aop/spring-aop.xsd
                        http://www.springframework.org/schema/tx
                        http://www.springframework.org/schema/tx/spring-tx.xsd
                    ">
       <!--引入cxf中的配置文件，自带的，早起版本使用解决兼容问题 :
                  问题不注释：报找不到，注释后就可以了
        -->
        <!-- <import resource="classpath:META-INF/cxf/cfx.xm"/>
        <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml"/>
         <import resource="classpath:META-INF/cxf/cxf-servlet.xml"/> -->
         
         <!--配置personServie,通过配置文件发布服务,
           endpoint针对与类的方式发布,
           wsdl的全路径：http://localhost:8080/cxf_web_webservice/[url-partten]/address
           address地址的规则:配置时前面必须加斜线
           implementor：类的全路径
         -->
         
       <!--用接口的方式cxf使用jaxws:server
       serviceClass:接口类
                 可以发布n多个webservice服务
         -->
       <jaxws:server  id="wspersonService"  address="/wspersonrService"  serviceClass="com.wsservice.PersonService">
         <!--具体实现类:impl  -->
          <jaxws:serviceBean>
          <bean  class="com.wsservice.impl.PersonSeriveImpl"></bean>
          </jaxws:serviceBean>
          
            <!-- 配置拦截器 -->
                   <jaxws:inInterceptors>
                   <bean class="org.apache.cxf.interceptor.LoggingInInterceptor" />  
                   </jaxws:inInterceptors>
                   <jaxws:outInterceptors>
                   <bean  class="org.apache.cxf.interceptor.LoggingOutInterceptor"/> 
                   </jaxws:outInterceptors>
       </jaxws:server>
       
</beans>

配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  
  <!--使用spring来加载cxf的服务类配置文件，服务类对象有spring来创建，服务类的对象存在springIoc容器中  -->
  <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <context-param>
      <param-name>contextConfigLocation</param-name>
     <!--  <param-value>classpath:config/mycxf-servlet.xml</param-value> -->
     <!--加载两个文件,既加载beans又加载cxf  -->
     <param-value>classpath*:mycxf-servlet.xml,classpath*:beans.xml</param-value>
  </context-param>
  
  
  <!--servlet负责发布服务类  -->
 <servlet>
    <servlet-name>mycxf</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>mycxf</servlet-name>
    <url-pattern>/services/*</url-pattern>
  </servlet-mapping>
  
</web-app>

客户端对应使用指令生成代码：
 wsdl2java  -d . -p  com.rl.class  address?wsdl
 然后进行相应的调用

手撕面包师

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java程序webService应用

开始接触webservice看网上的资料零零散散的，看来看去也没有看懂是怎么搞得，很是头大，今天决定手撸一下webservicewebservice基本概念webservice是一种远程方法调用，主要使用在异构系统的交互如：Java和c++,同样也可以是连个java项目之间交互webservice基于http协议，使用的是soap协议，soap协议分为soap1.1和soap1.2,1.2兼容1.1协议wsdl是webservice的描述语言一、jdk下的webservice使用1.1 j
复制链接

扫一扫