ibatis+spring+cxf+mysql搭建webservice

2021-07-10 02:36:02

首先需必备：mysql、myeclipse6.5、apache-cxf-2.6.2

一、建数据库，库名：cxf_demo；表名：book

  1. CREATE DATABASE `cxf_demo`  --数据库
  1. --表
  2. CREATE TABLE `book` (
  3. `id` varchar(32) NOT NULL COMMENT 'id',
  4. `book_name` varchar(100) DEFAULT NULL COMMENT '名称',
  5. `author` varchar(100) DEFAULT NULL COMMENT '作者',
  6. `status` int(11) DEFAULT NULL COMMENT '状态',
  7. `type_id` varchar(32) DEFAULT NULL COMMENT '类型',
  8. `price` double DEFAULT NULL COMMENT '金额',
  9. `brief` varchar(100) DEFAULT NULL COMMENT '简介',
  10. `book_No` int(11) DEFAULT NULL COMMENT '编号',
  11. `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  12. PRIMARY KEY (`id`)
  13. ) ENGINE=InnoDB DEFAULT CHARSET=utf8

二、好了，现在来建一个web项目名为：myWebservice，大概的package结构如下，大家就将package创建出来吧：

ibatis+spring+cxf+mysql搭建webservice

三、建了项目后要将cxf的jar包导入哦，呵呵我不知道哪些cxf jar是必要的，所以就将所有的jar包都导入了，apache-cxf-2.6.2这个版本的。。。

四、好了，现在我们来写resource这个包下面的配置文件，⊙０⊙噢，resource的结构是酱紫滴，看如下图：

ibatis+spring+cxf+mysql搭建webservice

我们先来配置数据库jdbc.properties这个文件

  1. jdbc.driverClassName=com.mysql.jdbc.Driver
  2. jdbc.url=jdbc:mysql://localhost:3306/cxf_demo?useUnicode=true&characterEncoding=UTF-8&failOverReadOnly=false&maxReconnects=10&autoReconnect=true
  3. jdbc.username=root
  4. jdbc.password=root

然后是配置applicationContext-common.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jee="http://www.springframework.org/schema/jee"
  4. xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
  5. xmlns:aop="http://www.springframework.org/schema/aop"
  6. xsi:schemaLocation="http://www.springframework.org/schema/beans
  7. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  8. http://www.springframework.org/schema/tx
  9. http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
  10. http://www.springframework.org/schema/jee
  11. http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
  12. http://www.springframework.org/schema/aop
  13. http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
  14. http://www.springframework.org/schema/context
  15. http://www.springframework.org/schema/context/spring-context-3.0.xsd"
  16. default-lazy-init="true">
  17. <description>Spring配置</description>
  18. <!-- 使用annotation 自动注册bean,并检查@Required,@Autowired的属性已被注入 -->
  19. <context:component-scan base-package="com.cy" />
  20. <!-- 加载JDBC property文件 -->
  21. <context:property-placeholder location="classpath*:config/jdbc.properties" ignore-unresolvable="true"/>
  22. <!-- 连接数据库   -->
  23. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  24. <property name="driverClassName" value="${jdbc.driverClassName}"/>
  25. <property name="url" value="${jdbc.url}"/>
  26. <property name="username" value="${jdbc.username}"/>
  27. <property name="password" value="${jdbc.password}"/>
  28. <!-- Connection Pooling Info -->
  29. <!-- <property name="initialSize" value="1" /> 初始化连接数量 -->
  30. <property name="maxIdle" value="5" /><!-- 最大等待连接中的数量,设 0 为没有限制 -->
  31. <property name="minIdle" value="1"/><!-- 最小等待连接中的数量,设 0 为没有限制  -->
  32. <property name="maxActive" value="25" /><!-- 连接池的最大数据库连接数。设为0表示无限制。 -->
  33. <!-- <property name="maxWait" value="60000"/> 最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。  -->
  34. <!-- <property name="timeBetweenEvictionRunsMillis" value="3600000" />  -->
  35. <!--    <property name="minEvictableIdleTimeMillis" value="3600000" /> -->
  36. <!-- <property name="removeAbandoned" value="true" />强制自我中断避免dbcp自身bug出现连接过久资源耗尽-->
  37. <!--    <property name="removeAbandonedTimeout" value="60" />自我中断时间秒 -->
  38. </bean>
  39. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  40. <property name="dataSource" ref="dataSource"/>
  41. </bean>
  42. <!-- 使用annotation定义事务  -->
  43. <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />
  44. <!-- ibatis -->
  45. <bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
  46. <property name="configLocation" value="classpath:sqlmap-config.xml"/>
  47. <property name="dataSource" ref="dataSource"/>
  48. </bean>
  49. <!-- 配置切面   -->
  50. <aop:config>
  51. <aop:aspect id="logAspecter" ref="logAspcet">
  52. <aop:pointcut id="mypointcut" expression="execution(* com.cy.*.service.impl.*.*(..))"/>
  53. </aop:aspect>
  54. </aop:config>
  55. </beans>

五、好啦，现在我们来写dto在Book.java文件里

  1. package com.cy.business.dto;
  2. import java.util.Date;
  3. public class Book {
  4. private static final long serialVersionUID = -2672626820160275114L;
  5. private String id;
  6. private String bookName;
  7. private String author;
  8. private String typeId;
  9. private Double price;
  10. private String brief;
  11. private Integer bookNo;
  12. private Integer status;
  13. private Date createTime;
  14. public String getId() {
  15. return id;
  16. }
  17. public void setId(String id) {
  18. this.id = id;
  19. }
  20. public String getBookName() {
  21. return bookName;
  22. }
  23. public void setBookName(String bookName) {
  24. this.bookName = bookName;
  25. }
  26. public String getAuthor() {
  27. return author;
  28. }
  29. public void setAuthor(String author) {
  30. this.author = author;
  31. }
  32. public String getTypeId() {
  33. return typeId;
  34. }
  35. public void setTypeId(String typeId) {
  36. this.typeId = typeId;
  37. }
  38. public Double getPrice() {
  39. return price;
  40. }
  41. public void setPrice(Double price) {
  42. this.price = price;
  43. }
  44. public String getBrief() {
  45. return brief;
  46. }
  47. public void setBrief(String brief) {
  48. this.brief = brief;
  49. }
  50. public Integer getBookNo() {
  51. return bookNo;
  52. }
  53. public void setBookNo(Integer bookNo) {
  54. this.bookNo = bookNo;
  55. }
  56. public Integer getStatus() {
  57. return status;
  58. }
  59. public void setStatus(Integer status) {
  60. this.status = status;
  61. }
  62. public Date getCreateTime() {
  63. return createTime;
  64. }
  65. public void setCreateTime(Date createTime) {
  66. this.createTime = createTime;
  67. }
  68. }

然后咧，就是在sqlmap文件夹里写Book_SqlMap.xml与dto关联哦：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE sqlMap PUBLIC "-//iBATIS.com//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">
  3. <!-- 定义命名空间 -->
  4. <sqlMap  namespace="BookNS">
  5. <!-- 定义缓存 -->
  6. <cacheModel id="Book_Cache" type="OSCACHE" readOnly="true">
  7. <flushInterval hours="24" />
  8. <!-- 配置哪些SQL将清空缓存 -->
  9. <flushOnExecute statement="saveBook" />
  10. <flushOnExecute statement="deleteBook" />
  11. <flushOnExecute statement="updateBook" />
  12. <flushOnExecute statement="changeBookStatus" />
  13. <property name="size" value="1000" />
  14. </cacheModel>
  15. <!-- 对象引用 -->
  16. <typeAlias alias="BookPo" type="com.cy.business.dto.Book"/>
  17. <!-- 定义结果 -->
  18. <resultMap class="BookPo" id="BookPo_Result">
  19. <result column="id" property="id" />
  20. <result column="book_name" property="bookName" />
  21. <result column="author" property="author" />
  22. <result column="type_id" property="typeId" />
  23. <result column="price" property="price" />
  24. <result column="brief" property="brief" />
  25. <result column="book_No" property="bookNo" />
  26. <result column="status" property="status" />
  27. <result column="create_time" property="createTime"/>
  28. </resultMap>
  29. <select id="queryBook" parameterClass="BookPo" resultMap="BookPo_Result" cacheModel="Book_Cache">
  30. select * from book
  31. <dynamic prepend=" WHERE ">
  32. <isNotEmpty property="id" prepend="and">
  33. id=#id:VARCHAR#
  34. </isNotEmpty>
  35. <isNotEmpty property="bookName" prepend="and">
  36. instr(book_Name,#bookName:VARCHAR#)
  37. </isNotEmpty>
  38. <isNotEmpty property="author" prepend="and">
  39. instr(author,#author:VARCHAR#)
  40. </isNotEmpty>
  41. <isNotEmpty property="bookNo" prepend="and">
  42. book_No=#bookNo:VARCHAR#
  43. </isNotEmpty>
  44. </dynamic>
  45. </select>
  46. <insert id="saveBook" parameterClass="BookPo">
  47. insert into book(id,book_name,author,type_id,price,brief,book_no,status,create_time)
  48. values(#id#,#bookName#,#author#,#typeId#,#price#,#brief#,#bookNo#,0,sysdate());
  49. </insert>
  50. <update id="changeBookStatus" parameterClass="BookPo">
  51. <![CDATA[
  52. update book set status=#status# where id=#id#
  53. ]]>
  54. </update>
  55. <update id="updateBook" parameterClass="BookPo">
  56. <![CDATA[
  57. update book set book_name=#bookName#,author=#author#,type_id=#typeId#
  58. ,price=#price#,brief=#brief#,book_no=#bookNo# where id=#id#
  59. ]]>
  60. </update>
  61. <delete id="deleteBook" parameterClass="BookPo">
  62. <![CDATA[
  63. delete from book where id=#id#
  64. ]]>
  65. </delete>
  66. </sqlMap>

写完这些，然后来实现业务逻辑层，这些添删改查功能。。。

接口IBookService.java

  1. package com.cy.business.service;
  2. import java.util.List;
  3. import com.cy.business.dto.Book;
  4. public interface IBookService {
  5. public List<Book> findBook(Book book);
  6. public boolean updateBook(Book book);
  7. public boolean deleteBook(Book book);
  8. public boolean changeBookStatus(Book book);
  9. public boolean saveBook(Book book);
  10. }

实现接口方法BookService.java

  1. package com.cy.business.service.impl;
  2. import java.util.List;
  3. import javax.annotation.Resource;
  4. import javax.inject.Inject;
  5. import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;
  6. import org.springframework.stereotype.Service;
  7. import org.springframework.transaction.annotation.Transactional;
  8. import com.cy.business.dto.Book;
  9. import com.cy.business.service.IBookService;
  10. import com.ibatis.sqlmap.client.SqlMapClient;
  11. @Service
  12. @Transactional
  13. public class BookService extends SqlMapClientDaoSupport implements IBookService {
  14. //及其重要，完成进行注入
  15. @Inject
  16. @Resource(name="sqlMapClient")
  17. public void setSuperSqlMapClient(SqlMapClient sqlMapClient) {
  18. super.setSqlMapClient(sqlMapClient);
  19. }
  20. public boolean changeBookStatus(Book book) {
  21. try {
  22. int result = this.getSqlMapClientTemplate().update("changeBookStatus", book);
  23. if (result > 0) {
  24. return true;
  25. } else {
  26. return false;
  27. }
  28. } catch (Exception e) {
  29. return false;
  30. }
  31. }
  32. public boolean deleteBook(Book book) {
  33. try {
  34. int result = this.getSqlMapClientTemplate().delete("deleteBook", book);
  35. if (result > 0) {
  36. return true;
  37. } else {
  38. return false;
  39. }
  40. } catch (Exception e) {
  41. return false;
  42. }
  43. }
  44. @SuppressWarnings("unchecked")
  45. public List<Book> findBook(Book book) {
  46. try {
  47. return this.getSqlMapClientTemplate().queryForList("queryBook", book);
  48. } catch (Exception e) {
  49. e.printStackTrace();
  50. return null;
  51. }
  52. }
  53. public boolean saveBook(Book book) {
  54. try {
  55. this.getSqlMapClientTemplate().insert("saveBook", book);
  56. return true;
  57. } catch (Exception e) {
  58. e.printStackTrace();
  59. return false;
  60. }
  61. }
  62. public boolean updateBook(Book book) {
  63. try {
  64. int result = this.getSqlMapClientTemplate().update("updateBook", book);
  65. if (result > 0) {
  66. return true;
  67. } else {
  68. return false;
  69. }
  70. } catch (Exception e) {
  71. e.printStackTrace();
  72. return false;
  73. }
  74. }
  75. }

嗯，完成这些，就开始来写webservice接口咯，在package名为webservice下，

接口IMyWebservice.java

  1. package com.cy.webservice;
  2. import javax.jws.WebMethod;
  3. import javax.jws.WebParam;
  4. import javax.jws.WebService;
  5. import org.springframework.stereotype.Component;
  6. import com.cy.business.dto.Book;
  7. @WebService(name = "IMyWebservice", targetNamespace = "http://webservice.cy.com/")
  8. @Component()
  9. public interface IMyWebservice {
  10. @WebMethod(operationName = "pushData", action = "urn:PushData")
  11. public boolean pushData(@WebParam(name="book")Book book);
  12. }

实现类MyWebService.java

  1. package com.cy.webservice.impl;
  2. import java.util.List;
  3. import javax.annotation.Resource;
  4. import javax.jws.WebService;
  5. import com.cy.business.dto.Book;
  6. import com.cy.business.service.IBookService;
  7. import com.cy.webservice.IMyWebservice;
  8. @WebService(targetNamespace = "http://impl.webservice.cy.com/", portName = "MyWebservicePort", serviceName = "MyWebservice")
  9. public class MyWebService implements IMyWebservice {
  10. @Resource
  11. private IBookService bookService;
  12. public boolean pushData(Book book) {
  13. try {
  14. System.out.println("进入webservice了。。。");
  15. boolean flag = bookService.saveBook(book);//先保存数据
  16. if(flag){
  17. Book bk = new Book();
  18. bk.setBookNo(89757);
  19. List<Book> list = bookService.findBook(book);
  20. if(list!=null && !list.isEmpty()){//然后更改数据。。。
  21. bk = new Book();
  22. bk = list.get(0);
  23. bk.setStatus(1);
  24. bk.setBookName("岑逸951560368");
  25. return bookService.updateBook(bk);
  26. }else{
  27. return false;
  28. }
  29. }else{
  30. return false;
  31. }
  32. } catch (Exception e) {
  33. e.printStackTrace();
  34. return false;
  35. }
  36. }
  37. }

⊙０⊙ibatis+spring+cxf+mysql搭建webservice这样我们就写完了？还木有哦，别忘了在resource包下还有个配置文件还木有写哈。。。applicationContext-cxf.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:jaxws="http://cxf.apache.org/jaxws" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:jee="http://www.springframework.org/schema/jee"
  5. xsi:schemaLocation="http://www.springframework.org/schema/beans
  6. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  7. http://cxf.apache.org/jaxws
  8. http://cxf.apache.org/schemas/jaxws.xsd"
  9. default-lazy-init="true">
  10. <bean id="myWebservice" class="com.cy.webservice.impl.MyWebService"></bean>
  11. <jaxws:endpoint address="/myWebservice" implementor="#myWebservice"></jaxws:endpoint>
  12. </beans>

六、好啦，我们的工作做了一大半了！现在来让我们运行一下这个webservice吧，在项目http://localhost:8080/myWebservice/后边需要加上"service"，这是因为在web.xml中我们这么配置的，大家还记得吧ibatis+spring+cxf+mysql搭建webservice继续

  1. <servlet-mapping>
  2. <servlet-name>cxf</servlet-name>
  3. <url-pattern>/service/*</url-pattern>
  4. </servlet-mapping>

ibatis+spring+cxf+mysql搭建webservice

能够打开这个就说明你成功了................................................................一大半，为嘛这么说呢，因为还需要测试啊！！！

你打开超链接WSDL : {http://impl.webservice.cy.com/}MyWebservice会来到这个界面
ibatis+spring+cxf+mysql搭建webservice

哈哈，你的webservice写的差不多了，开心吧。。。

七、那俺们现在开始写客户端来测试一下，要有耐心哦。。。马上就成功鸟。。。ibatis+spring+cxf+mysql搭建webserviceibatis+spring+cxf+mysql搭建webservice

建一个名为myWebclient的JavaProject，大家跟着我建吧。。。看如下图package结构：

ibatis+spring+cxf+mysql搭建webservice

我们通过myeclipse6.5来快捷的创建客户端。。。

ibatis+spring+cxf+mysql搭建webservice来看图操作。我们将编译文件放在webservice这个包下，选择webservice这个包，new->other

ibatis+spring+cxf+mysql搭建webservice

搜索出这个工具哦，然后next->next会有如下界面 wsdl url这个地址就是刚才打开的http://localhost:8080/myWebservice/service/myWebservice?wsdl      ibatis+spring+cxf+mysql搭建webservice

然后next->到下一个图了，切记myWebservice这个项目一定是部署了正在运行的哦！！！

ibatis+spring+cxf+mysql搭建webservice

finish之后，所以的文件编译完成了！

ibatis+spring+cxf+mysql搭建webservice

八、我们现在来完成webUtil这个package下的文件吧！

ibatis+spring+cxf+mysql搭建webservice

Util.java文件

  1. package com.cy.client.webUtil;
  2. import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
  3. public class Util {
  4. @SuppressWarnings({ "unchecked" })
  5. public static Object getService(Class clazz, String url){
  6. JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
  7. Object srv = null;
  8. factory.setServiceClass(clazz);
  9. factory.setAddress(url);
  10. srv=(Object) factory.create();
  11. return srv;
  12. }
  13. }

UtilWebService.java文件是连接webservice的接口地址：

  1. package com.cy.client.webUtil;
  2. import com.cy.client.webservice.IMyWebservice;
  3. public class UtilWebService {
  4. public static IMyWebservice getMyWebService(){
  5. String url="http://localhost:8080/myWebservice/service/myWebservice?wsdl";
  6. IMyWebservice service = (IMyWebservice) Util.getService(IMyWebservice.class,url);
  7. return service;
  8. }
  9. }

现在我们在client包下建Client.java客户端

  1. package com.cy.client;
  2. import java.util.UUID;
  3. import com.cy.client.webUtil.UtilWebService;
  4. import com.cy.client.webservice.Book;
  5. import com.cy.client.webservice.IMyWebservice;
  6. public class Client {
  7. private IMyWebservice myWebservice;
  8. public boolean getBookInfo(){
  9. myWebservice = UtilWebService.getMyWebService();
  10. // 创建 GUID 对象
  11. UUID uuid = UUID.randomUUID();
  12. // 得到对象产生的ID
  13. String a = uuid.toString();
  14. // 转换为大写
  15. a = a.replaceAll("-", "");
  16. Book book = new Book();
  17. book.setId(a);
  18. book.setAuthor("岑逸");
  19. book.setBookName("随园诗话");
  20. book.setBookNo(89757);
  21. book.setBrief("哈哈");
  22. return myWebservice.pushData(book);
  23. }
  24. public static void main(String[] args) {
  25. boolean flag = new Client().getBookInfo();
  26. System.out.println("推送："+flag);
  27. }
  28. }

运行一下吧。。。哈哈成功了！！！ibatis+spring+cxf+mysql搭建webserviceibatis+spring+cxf+mysql搭建webservice数据库也有数据了！！！有木有ibatis+spring+cxf+mysql搭建webservice花了一个多小时

ibatis+spring+cxf+mysql搭建webserviceibatis+spring+cxf+mysql搭建webservice

ibatis+spring+cxf+mysql搭建webservice

非常感谢本文的作者，原文地址：http://blog.csdn.net/cenyi2013/article/details/17315755

上一篇：CMS垃圾收集器


下一篇：Python 函数相关概念