非常详细SSM+CXF做接口开发实现跨域跨平台案列

最新推荐文章于 2025-05-16 11:34:54 发布
最新推荐文章于 2025-05-16 11:34:54 发布
阅读量1.8k 收藏 4
点赞数 1
CC 4.0 BY-SA版权
分类专栏： java SSM+CXF 文章标签： spring mybatis java cxf webservice
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_36832411/article/details/77893522
本文详述了如何使用Spring、Mybatis和CXF实现接口开发，以支持跨域和跨平台请求。通过提供完整的配置文件和代码示例，包括pom.xml、web.xml、applicationContext-*.xml、mapper文件和Java代码，展示了如何构建这样的系统。同时，还创建了一个简单的Web项目用于测试跨域请求，并给出了在Linux环境下通过HTTP GET方式实现跨平台请求的示例。附带源码下载链接和交流QQ群，鼓励学习者互相交流。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

这是一个spring+mybatis+cxf做的接口开发实现跨域跨平台请求调用
参考文档：
参考文章
由于参考文档没给全资料，在这里我给大家补全了，希望能帮助到大家学习接口开发；
首先是pom.xml：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.neusoft.icelake</groupId>
  <artifactId>restservice</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>restservice</name>  

    <properties>  
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
        <java.version>1.7</java.version>  
        <spring.version>3.2.8.RELEASE</spring.version>  
        <servlet-api.version>2.5</servlet-api.version>  
        <slf4j.version>1.7.5</slf4j.version>  
        <cxf.version>2.7.12</cxf.version>  
        <jackson.version>2.1.4</jackson.version>  

        <mybatis.version>3.2.8</mybatis.version>  
        <mybatisspring.version>1.2.2</mybatisspring.version>  
        <druid.version>1.0.11</druid.version>  
    </properties>  

    <dependencies>  
        <!-- spring begin -->  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-core</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-beans</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-orm</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-context</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-webmvc-portlet</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-webmvc</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-web</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
        <!-- spring end -->  

        <!-- @Inject begin -->  
        <dependency>  
            <groupId>javax.inject</groupId>  
            <artifactId>javax.inject</artifactId>  
            <version>1</version>  
        </dependency>  
        <!-- @Inject end -->  

        <!-- servlet begin -->  
        <dependency>  
            <groupId>javax.servlet</groupId>  
            <artifactId>servlet-api</artifactId>  
            <version>${servlet-api.version}</version>  
        </dependency>  
        <!-- servlet end -->  

        <!-- cxf begin -->  
        <dependency>  
            <groupId>org.apache.cxf</groupId>  
            <artifactId>cxf-rt-frontend-jaxws</artifactId>  
            <version>${cxf.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.cxf</groupId>  
            <artifactId>cxf-rt-frontend-jaxrs</artifactId>  
            <version>${cxf.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.cxf</groupId>  
            <artifactId>cxf-rt-rs-extension-providers</artifactId>  
            <version>${cxf.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.cxf</groupId>  
            <artifactId>cxf-rt-transports-http</artifactId>  
            <version>${cxf.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.codehaus.jettison</groupId>  
            <artifactId>jettison</artifactId>  
            <version>1.3.2</version>  
        </dependency>  
        <dependency>  
            <groupId>javax.ws.rs</groupId>  
            <artifactId>jsr311-api</artifactId>  
            <version>1.1.1</version>  
        </dependency>  
        <!-- cxf end -->  

        <!-- JSON begin -->  
        <dependency>  
            <groupId>com.fasterxml.jackson.core</groupId>  
            <artifactId>jackson-core</artifactId>  
            <version>${jackson.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>com.fasterxml.jackson.core</groupId>  
            <artifactId>jackson-databind</artifactId>  
            <version>${jackson.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>com.fasterxml.jackson.core</groupId>  
            <artifactId>jackson-annotations</artifactId>  
            <version>${jackson.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>com.fasterxml.jackson.module</groupId>  
            <artifactId>jackson-module-jaxb-annotations</artifactId>  
            <version>${jackson.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>com.fasterxml.jackson.jaxrs</groupId>  
            <artifactId>jackson-jaxrs-json-provider</artifactId>  
            <version>${jackson.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.codehaus.jackson</groupId>  
            <artifactId>jackson-mapper-asl</artifactId>  
            <version>1.9.0</version>  
        </dependency>  
        <dependency>  
            <groupId>org.codehaus.jackson</groupId>  
            <artifactId>jackson-core-asl</artifactId>  
            <version>1.9.0</version>  
        </dependency>  
        <!-- JSON end -->  

        <!-- MyBatis -->  
        <dependency>  
            <groupId>org.mybatis</groupId>  
            <artifactId>mybatis</artifactId>  
            <version>${mybatis.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.mybatis</groupId>  
            <artifactId>mybatis-spring</artifactId>  
            <version>${mybatisspring.version}</version>  
        </dependency>  
        <!-- AOP begin -->  
        <dependency>  
            <groupId>org.aspectj</groupId>  
            <artifactId>aspectjrt</artifactId>  
            <version>1.7.4</version>  
        </dependency>  
        <dependency>  
            <groupId>org.aspectj</groupId>  
            <artifactId>aspectjweaver</artifactId>  
            <version>1.7.4</version>  
        </dependency>  
        <dependency>  
            <groupId>cglib</groupId>  
            <artifactId>cglib</artifactId>  
            <version>3.1</version>  
        </dependency>  
        <!-- AOP end -->        
        <!-- jdbc driver -->  
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.10</version>
        </dependency>  
        <!-- 整合数据库连接池 -->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>   
    </dependencies>  

    <build>  
        <plugins>  
            <!-- compiler插件, 设定JDK版本 -->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-compiler-plugin</artifactId>  
                <version>3.0</version>  
                <configuration>  
                    <source>1.7</source>  
                    <target>1.7</target>  
                </configuration>  
            </plugin>  
        </plugins>  
    </build>  

    <!-- PROGRAMER INFO -->  
    <organization>  
        <name>Neusoft</name>  
        <url>http://www.neusoft.com</url>  
    </organization>
</project>

接着是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" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"  
    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">  
    <display-name>restservice</display-name>  
    <context-param>  
        <param-name>contextConfigLocation</param-name>  
        <param-value>classpath*:/applicationContext-*.xml</param-value>  
    </context-param>  
    <listener>  
        <description>spring listener</description>  
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
    </listener>  
    <servlet>  
        <servlet-name>CXFServlet</servlet-name>  
        <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>  
        <load-on-startup>1</load-on-startup>  
    </servlet>  
    <servlet-mapping>  
        <servlet-name>CXFServlet</servlet-name>  
        <url-pattern>/*</url-pattern> 
    </servlet-mapping>  

    <filter>  
        <filter-name>encodingFilter</filter-name>  
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
        <init-param>  
            <param-name>encoding</param-name>  
            <param-value>UTF-8</param-value>  
        </init-param>  
        <init-param>  
            <param-name>forceEncoding</param-name>  
            <param-value>true</param-value>  
        </init-param>  
    </filter>  
    <filter-mapping>  
        <filter-name>encodingFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  
    <welcome-file-list>  
        <welcome-file>index.html</welcome-file>  
        <welcome-file>index.htm</welcome-file>  
        <welcome-file>index.jsp</welcome-file>  
        <welcome-file>default.html</welcome-file>  
        <welcome-file>default.htm</welcome-file>  
        <welcome-file>default.jsp</welcome-file>  
    </welcome-file-list>  
</web-app>

再接着是applicationContext-mybatis.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:tx="http://www.springframework.org/schema/tx"  
    xmlns:context="http://www.springframework.org/schema/context"  
    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/aop   
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">  

    <context:property-placeholder ignore-unresolvable="true" location="classpath:jdbc.properties" />  

    <!-- 3. 数据源dataSource  C3P0 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClassName}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

        <property name="maxPoolSize" value="${c3p0.pool.maxPoolSize}"/>
        <property name="minPoolSize" value="${c3p0.pool.minPoolSize}"/>
        <property name="initialPoolSize" value="${c3p0.pool.initialPoolSize}"/>
        <property name="acquireIncrement" value="${c3p0.pool.acquireIncrement}"/>
    </bean>  

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
        <property name="dataSource" ref="dataSource" />  
        <property name="mapperLocations" value="classpath:com/neusoft/icelake/modules/standard/mapper/*.xml" />  
    </bean>  
    <!-- <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
        <property name="basePackage" value="mapper" />  
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />  
    </bean> -->

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
        <property name="dataSource" ref="dataSource" />  
    </bean>  
    <tx:advice id="transactionAdvice" transaction-manager="transactionManager">  
        <tx:attributes>  
            <tx:method name="add*" propagation="REQUIRED" />  
            <tx:method name="append*" propagation="REQUIRED" />  
            <tx:method name="insert*" propagation="REQUIRED" />  
            <tx:method name="save*" propagation="REQUIRED" />  
            <tx:method name="update*" propagation="REQUIRED" />  
            <tx:method name="modify*" propagation="REQUIRED" />  
            <tx:method name="edit*" propagation="REQUIRED" />  
            <tx:method name="delete*" propagation="REQUIRED" />  
            <tx:method name="remove*" propagation="REQUIRED" />  
            <tx:method name="repair" propagation="REQUIRED" />  
            <tx:method name="delAndRepair" propagation="REQUIRED" />  

            <tx:method name="get*" propagation="SUPPORTS" />  
            <tx:method name="find*" propagation="SUPPORTS" />  
            <tx:method name="load*" propagation="SUPPORTS" />  
            <tx:method name="search*" propagation="SUPPORTS" />  
            <tx:method name="datagrid*" propagation="SUPPORTS" />  

            <tx:method name="*" propagation="SUPPORTS" />  
        </tx:attributes>  
    </tx:advice>  
    <aop:config>  
        <aop:pointcut id="transactionPointcut" expression="execution(* com.neusoft.icelake..*impl.*(..))" />  
        <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice" />  
    </aop:config>  

</beans>

applicationContext-server.xml

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxrs="http://cxf.apache.org/jaxrs"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd  
    http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd">  

    <context:component-scan base-package="com.neusoft.icelake" />  

    <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" />  

    <jaxrs:server id="restServiceContainer" address="/rest">  
        <jaxrs:providers>  
            <ref bean="jacksonProvider" />  
        </jaxrs:providers>  
        <jaxrs:extensionMappings>  
            <entry key="json" value="application/json" />  
            <entry key="xml" value="application/xml" />  
        </jaxrs:extensionMappings>  

        <jaxrs:serviceBeans>  
            <ref bean="wholeQuantityService" />
        </jaxrs:serviceBeans>  

        <jaxrs:inInterceptors>  
            <bean class="org.apache.cxf.interceptor.LoggingInInterceptor"></bean>  
        </jaxrs:inInterceptors>  
        <jaxrs:outInterceptors>  
            <bean class="org.apache.cxf.interceptor.LoggingOutInterceptor"></bean>  
        </jaxrs:outInterceptors>  
    </jaxrs:server>  

    <bean id="jacksonObjectMapper"  
        class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean"></bean>  
    <bean id="jacksonProvider"  
        class="com.fasterxml.jackson.jaxrs.json.JacksonJaxbJsonProvider">  
        <property name="mapper" ref="jacksonObjectMapper" />  
    </bean>  

</beans>

mapper文件：

<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >  
<mapper namespace="com.neusoft.icelake.modules.standard.mapper.OrgMapper">    
    <resultMap id="OrgResultMap"  
        type="com.neusoft.icelake.modules.standard.entity.Org">  
        <id column="child_id" property="child_id" jdbcType="VARCHAR" />  
        <result column="child_desc" property="child_desc" jdbcType="VARCHAR" />  
        <result column="child_short" property="child_short" jdbcType="VARCHAR" />  
        <result column="parent_id" property="parent_id" jdbcType="VARCHAR" />  
        <result column="parent_desc" property="parent_desc" jdbcType="VARCHAR" />  
        <result column="org_sort" property="org_sort" jdbcType="VARCHAR" />  
    </resultMap>    
    <sql id="Org_Column_List">  
        parent_id, parent_desc, child_id, child_desc, child_short,  
        org_sort  
    </sql>  
    <select id="getOrgAll" resultMap="OrgResultMap">  
        select  
        <include refid="Org_Column_List" />  
        from v_sap_org_node
    </select>  
</mapper>

java代码：

package com.neusoft.icelake.modules.standard.dao.impl;

import com.neusoft.icelake.modules.standard.dao.BaseDao;


import java.io.Serializable;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import org.springframework.beans.factory.annotation.Autowired;


public abstract class BaseDaoImpl extends SqlSessionDaoSupport implements BaseDao{
    @Autowired
    //mybatis-spring 1.0无需此方法；mybatis-spring1.2必须注入。
    public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory){
        super.setSqlSessionFactory(sqlSessionFactory);
    }

    private String ns;      //命名空间
    public String getNs() {
        return ns;
    }
    public void setNs(String ns) {
        this.ns = ns;
    }



}




package com.neusoft.icelake.modules.standard.dao;

import java.io.Serializable;
import java.util.List;
import java.util.Map;


/**
 * @Description: 泛型类，基础的DAO接口
 * @Author: yanggang
 */
public interface BaseDao {

}



package com.neusoft.icelake.modules.standard.dao.impl;

import java.util.List;
import java.util.Map;

import org.springframework.stereotype.Repository;

import com.neusoft.icelake.modules.standard.dao.IWholeQuantityDao;
import com.neusoft.icelake.modules.standard.entity.Org;

@Repository
public class IWholeQuantityDaoImpl extends BaseDaoImpl implements IWholeQuantityDao {

    public IWholeQuantityDaoImpl() {
        // TODO Auto-generated constructor stub
        //设置命名空间
        super.setNs("com.neusoft.icelake.modules.standard.mapper.OrgMapper");
    }
    public List<Org> getOrgAll() {
        return super.getSqlSession().selectList(super.getNs()+".getOrgAll");
    }

}




package com.neusoft.icelake.modules.standard.dao;

import java.util.List;
import java.util.Map;

import com.neusoft.icelake.modules.standard.entity.Org;

public interface IWholeQuantityDao extends BaseDao {

    List<Org> getOrgAll();

}




package com.neusoft.icelake.modules.standard.entity;

import java.io.Serializable;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "SapOrg")
public class Org implements Serializable {

    private static final long serialVersionUID = 7446548875479453298L;  

    private String parent_id;  

    private String parent_desc;  

    private String child_id;  

    private String child_desc;  

    private String child_short;  

    private String org_sort;  

    public String getParent_id() {  
        return parent_id;  
    }  

    public void setParent_id(String parent_id) {  
        this.parent_id = parent_id;  
    }  

    public String getParent_desc() {  
        return parent_desc;  
    }  

    public void setParent_desc(String parent_desc) {  
        this.parent_desc = parent_desc;  
    }  

    public String getChild_id() {  
        return child_id;  
    }  

    public void setChild_id(String child_id) {  
        this.child_id = child_id;  
    }  

    public String getChild_desc() {  
        return child_desc;  
    }  

    public void setChild_desc(String child_desc) {  
        this.child_desc = child_desc;  
    }  

    public String getChild_short() {  
        return child_short;  
    }  

    public void setChild_short(String child_short) {  
        this.child_short = child_short;  
    }  

    public String getOrg_sort() {  
        return org_sort;  
    }  

    public void setOrg_sort(String org_sort) {  
        this.org_sort = org_sort;  
    }  

    @Override  
    public String toString() {  
        return "Org [parent_id=" + parent_id + ", parent_desc=" + parent_desc + ", child_id=" + child_id  
                + ", child_desc=" + child_desc + ", child_short=" + child_short + ", org_sort=" + org_sort  
                + "]";  
    }
}



package com.neusoft.icelake.modules.standard.entity;

import java.util.List;  
import java.util.Map;  

import javax.xml.bind.annotation.XmlRootElement;  

@XmlRootElement(name = "SapOrgs")  
public class Orgs {  
    private List<Org> list;  

    private Org[] array;  

    private Map<String, Org> map;  

    public List<Org> getList() {  
        return list;  
    }  

    public void setList(List<Org> list) {  
        this.list = list;  
    }  

    public Org[] getArray() {  
        return array;  
    }  

    public void setArray(Org[] array) {  
        this.array = array;  
    }  

    public Map<String, Org> getMap() {  
        return map;  
    }  

    public void setMap(Map<String, Org> map) {  
        this.map = map;  
    }  
}



package com.neusoft.icelake.modules.standard.service;

import javax.ws.rs.GET;  
import javax.ws.rs.POST;
import javax.ws.rs.Path;  
import javax.ws.rs.Produces;  
import javax.ws.rs.core.MediaType;  


import com.neusoft.icelake.modules.standard.entity.Orgs;  

@Path("/wq")  
public interface IWholeQuantityService {  

    @POST  
    @Path("/orglist")  
    @Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })  
    public Orgs getOrgList();  

}



package com.neusoft.icelake.modules.standard.service.impl;

import java.util.List;  

import javax.annotation.Resource;
import javax.inject.Named;  




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




import com.neusoft.icelake.modules.standard.dao.IWholeQuantityDao;
import com.neusoft.icelake.modules.standard.entity.Org;  
import com.neusoft.icelake.modules.standard.entity.Orgs;  
import com.neusoft.icelake.modules.standard.service.IWholeQuantityService;  

@Named("wholeQuantityService")  
public class WholeQuantityServiceImpl implements IWholeQuantityService {  
    @Resource
    private IWholeQuantityDao wholeQuantityDao;  

    public IWholeQuantityDao getWholeQuantityDao() {  
        return wholeQuantityDao;  
    }  

    @Autowired  
    public void setWholeQuantityDao(IWholeQuantityDao wholeQuantityDao) {  
        this.wholeQuantityDao = wholeQuantityDao;  
    }  

    public Orgs getOrgList() {  
        Orgs orgs = new Orgs();  
        List<Org> orglist = wholeQuantityDao.getOrgAll();  
        orgs.setList(orglist);  
        return orgs;  
    }  

}

接着新建一个项目试验跨域跨系统请求
就是一个web项目，里面只有一个index.html
代码如下

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<script type="text/javascript" src="js/jquery-3.1.1.min.js"></script>
<script type="text/javascript">
    $(function(){
        $(".id").click(function(){
            $.ajax({
                type: "post",
                dataType: "json",
                url: '/restservice/rest/wq/orglist',
                data:{'_type':'json', 'password':'jjjj'},
                success: function (data) {
                    alert(data);  
                    $("#target").html(data);  
                    alert("服务加载成功"); 
                }
            });
            });
        });
</script>
<body>
    <a class="id" >点击</a>
</body>
</html>

效果图：
这里写图片描述
这里写图片描述
这里写图片描述
在test系统下实现跨域跨系统
这里写图片描述
这里写图片描述
这里写图片描述
http://localhost:8080/restservice
这里写图片描述
这里写图片描述
这里写图片描述
请在Linux系统下使用get方式请求实现跨平台：
http://你自己的访问的地址ip:8080/restservice/rest/wq/orglist?_type=json
这里写图片描述
数据库自己随便建一个就行，请根据上面的访问地址进行访问
附上本项目的源码下载地址：
这里写链接内容

如果有需要的大家可以加我的qq群438581190，大家一起开始自学，互相交流，互相学习。
请尊重我努力的成果，转载或者借鉴请注明出处，谢谢！

WebService-CXF-jQuery跨域访问
球球之家
05-16 2873
通过JS来调用WebService: 通过jQuery的ajax方法向服务器发送xml数据。 必须要先了解xml的数据格式，通过拦截器获取。 •可以从LoggingInInterceptor中获取发出的数据格式。 •可以从LoggingOutInterceptor中获取返回的数据。 导入jQuery1.5.js文件,放到js/jquery1.5.js
ssm整合cxf
12-04
现在对于多个应用之间通信最新的方式，可以使用。。。。
ssm+cxf(基于Maven开发的ssm框架集成cxf发布web service服务)
11-23
源码里面包含了了一个简单的插入功能，主要是为了测试mybatis是否连接上数据库的时候写的测试类，作为一个刚学java,被抓壮丁的写服务器端的妹子，我只想说，画了我3周才解决了所有的错误啊，真的要自己因为不懂乱写乱改的时候遇到的那些莫名其妙的错误，因此对android客户端的好感上升了不止一个Level啊.咳咳， 如题，基于maven项目的ssm框架和cxf框架的整合。
cxf实现跨域
qq_45147812的博客
03-26 400
添加cros过滤器 <filter> <filter-class>org.apache.catalina.filters.CorsFilter</filter-class> <filter-name>CorsFilter</filter-name> </filter> <filter-map...
CXF Web服务项目实战：接口设计、发布与调用
最新发布
weixin_35749786的博客
05-16 985
Apache CXF是一个功能强大的开源服务框架，旨在简化和加速面向服务架构（SOA）的开发和部署。CXF提供了全面的服务开发工具，可以创建和开发Web服务端点，并将它们发布到多种传输和协议上。它支持SOAP（简单对象访问协议）和RESTful（代表性状态转移）风格的服务，具备强大的数据绑定能力和拦截器机制，使得开发者能够灵活地控制服务行为。Web服务是基于Web的自包含、自描述、模块化的应用，它能被发布、定位以及调用。它们通常使用标准化的互联网协议来支持不同的系统进行互操作。
CXF整合 ssm（重点CXF实现WebService以及客户端动态调用）
这个柠檬有丶酸的博客
01-14 918
1.先将ssm框架搭好 2.添加CXF的Maven <dependency> <groupId>org.apache.cxf</groupId> <artifactId>cxf-rt-frontend-jaxws</artifactId> <version>3.1.6</...
SSM整合CXF发布WebService(服务端、客户端)
HUMM
09-05 542
SSM(四)WebService入门详解 ssm+cxf3.0 Spring和cxf3的整合，以maven的方式 WebService客户端几种实现方式
java cxf webservice接口解决跨域问题
05-02
java cxf webservice接口解决跨域问题，cors-filter-1.7.jar、java-property-utils-1.9.jar，以及web.xml文件配置
SSM+CXF进行接口开发实现跨域跨平台
09-08
理解并掌握SSM+CXF的集成应用，可以提升你开发高效、可扩展的后端服务的能力。通过实践这个案例，你不仅能学习到如何创建RESTful API，还能了解到如何处理跨域问题，这对于构建现代Web应用至关重要。同时，这也会让...
ssM+cxf接口发布demo原型
10-18
【ssM+cxf接口发布demo原型】是一种基于Spring Boot（ssM）和Apache CXF（cxf）技术实现的Web服务发布示例。这个项目旨在展示如何将Java应用程序中的业务逻辑封装为Web服务，以便其他系统能够通过标准的SOAP协议进行...
webservice ssm+cxf服务端
10-12
总的来说，"webservice ssm+cxf服务端"是一个利用SSM框架和CXF服务框架构建的Web Service应用，它实现了服务发布和调用的功能，适合于需要跨系统交互的场景。通过学习和实践这个项目，开发者可以深入理解SSM和CXF的...
SSM+cxf+log4j整合框架
11-16
SSM+cxf+log4j整合框架是一种常见的Java企业级应用开发模式，它结合了Spring、SpringMVC、MyBatis以及CXF和Log4j等多个组件，为开发者提供了高效、灵活的开发环境。让我们详细了解一下这些技术及其整合的关键点。 1...
SSM框架与CXF整合
01-23
本代码事例是SSM框架和CXF整合，仅供大家学习，本代码事例是SSM框架和CXF整合，仅供大家学习
基于SSM+CXF构建的RESTFul webservice
04-22
使用cxf、spring构建的rest风格webservice，其他相关技术springmvc、mybatis、druid等。代码中使用的数据库为sybase，请根据实际环境更改，需修改pom中引用的数据库驱动，依照entity类的属性建对应表，并修改config.properties中各属性值。相关博文：http://blog.youkuaiyun.com/iamlake/article/details/51217303
cxf支持cors跨域
0123456789
09-01 2016
摘要：前台直接ajax请求后台webService服务，可能涉及跨域，是否同源，可以参考http://www.ruanyifeng.com/blog/2016/04/same-origin-policy.html 环境：spring+cxf 顺便把搭建cxf rest服务的一些代码配置也贴出来了一.所需jar <!-- cxf --> <dependency>
MYSQL如何使用外键
yilufa666666的博客
11-09 1507
这里写自定义目录标题MYSQL如何使用外键一、增加外键二、删除外键三、外键作用四、外键约束新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 MYSQL如何使用外键 外键也称之为外键约束: foreign key 外键: 外面
SSM+CXF服务
pref_mail的博客
07-05 3476
最近在做CXF类型的项目 ,把最近项目中的架构分享给大家. 1.基础环境 JDK1.8+maven+nexus 2.软件 IDEA3.目录结构:其余的基本就是SSM的内容,除开webservice包 项目中的webService接口都会在这个包中发布 ,webservice为父接口,下面的impl包为具体实现类4.POM<project xmlns="http://mave
ajax访问cxf,CXF发布支持ajax跨域访问的restful webservice
weixin_33504324的博客
08-05 322
用apache cxf构建了一个玩具型restful webservice，内嵌jetty，加上gradle，发布无比轻松。applyplugin:'java'applyplugin:'application'repositories{maven{url"http://maven.oschina.net/content/groups/public"}}[compileJava,com...
ajax调用cxf webservice接口和跨域
zhshchilss的专栏
11-16 4330
1.配置webservice （可以参考博客上cxf  webservice的配置http://blog.youkuaiyun.com/zhshchilss/article/details/43763271） 按照上述配置，就可以使用java客户端调用接口了 ajax的调用 1.额外的配置 新增两个jar包：cors-filter-1.7.jar，java-property-utils-1.
SSM与CXF结合实现接口开发的跨域跨平台案例解析
本案例以Java为开发语言，SSM（Spring、SpringMVC、MyBatis）框架为基础，结合Apache CXF框架，实现了接口开发的跨域跨平台能力。为了深入理解这一技术实现，我们需分别探讨Spring、MyBatis、CXF及跨域跨平台的概念...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值