ibatis+spring+cxf+mysql搭建webservice

首先需必备：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创建出来吧：

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

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

我们先来配置数据库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. }

⊙０⊙这样我们就写完了？还木有哦，别忘了在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中我们这么配置的，大家还记得吧继续

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

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

你打开超链接WSDL : {http://impl.webservice.cy.com/}MyWebservice会来到这个界面

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

七、那俺们现在开始写客户端来测试一下，要有耐心哦。。。马上就成功鸟。。。

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

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

来看图操作。我们将编译文件放在webservice这个包下，选择webservice这个包，new->other

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

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

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

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

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. }

运行一下吧。。。哈哈成功了！！！数据库也有数据了！！！有木有花了一个多小时

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