Apache CXF 学习-使用MTOM来从客户端发送带附件的SOAP消息到服务端

最新推荐文章于 2021-05-14 17:35:11 发布
最新推荐文章于 2021-05-14 17:35:11 发布
阅读量287 收藏
点赞数
文章标签： java runtime
原文链接：https://yq.aliyun.com/articles/427173
版权

引入：

通常意义上说，SOAP消息就是一个带字符串的内容包，其实CXF还可以发送/接收带附件的SOAP消息，这样SOAP的消息看起来就如下所示：

wKioL1MJpC3BbshFAAD12r-8yLU052.jpg

我们这篇文章就着重讲解如何来从客户端发送带附件的SOAP消息到服务器Endpoint,并且给出详细的例子，下篇文章会讲解相反过程，如何客户端接收并且处理来自Endpoint的带附件的SOAP消息。


实践：

我们假想有这样一个需求，假设我们现在有个ProfileManagement系统，用户需要在客户端吧自己的Profile上传到ProfileManagement系统，并且这个Profile中除了包含姓名，年龄外还包含自己的头像图片(portrait),所以如果用CXF来做的话，就是要上传一个带附件的SOAP消息。


服务端：

首先，我们要定义一个VO来表示Profile信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/**
  * 这个一个VO,我们定义了一个Profile类型，它会带有图片的附件信息。接下来，我们会用JAXB框架将其映射为wsdl文件中的类型定义
  */
package  com.charles.cxfstudy.server.vo;
import  javax.activation.DataHandler;
import  javax.xml.bind.annotation.XmlAccessType;
import  javax.xml.bind.annotation.XmlAccessorType;
import  javax.xml.bind.annotation.XmlMimeType;
import  javax.xml.bind.annotation.XmlRootElement;
import  javax.xml.bind.annotation.XmlType;
/**
  * 我们定义一个有姓名(name)，年龄(age)，图片(portrait)的Profile类
  * @author charles.wang
  *
  */
@XmlType (name= "profile" )
//注意，这里必须用下面这行指定XmlAccessType.FIELD,来标注利用JAXB框架在JAVA和XML之间转换只关注字段，
//而不会关注getter()，否则默认2个都会关注则会发生以下错误：
//com.sun.xml.bind.v2.runtime.IllegalAnnotationException
//Class has two properties of the same name "portrait",我调试了好久才解决这个问题的
@XmlAccessorType (XmlAccessType.FIELD)
public  class  Profile {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
     private  String name;
     private  int  age;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
     //这个字段是一个图片资源
     @XmlMimeType ( "application/octet-stream" )
     private  DataHandler portrait;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
     private  String imageFileExtension;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
     public  String getName() {
         return  name;
     }
     public  void  setName(String name) {
         this .name = name;
     }
     public  int  getAge() {
         return  age;
     }
     public  void  setAge( int  age) {
         this .age = age;
     }
     public  DataHandler getPortrait() {
         return  portrait;
     }
     public  void  setPortrait(DataHandler portrait) {
         this .portrait = portrait;
     }
     public  String getImageFileExtension() {
         return  imageFileExtension;
     }
     public  void  setImageFileExtension(String imageFileExtension) {
         this .imageFileExtension = imageFileExtension;
     }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
}

和一般情况一样，我们这里用了JAXB的注释，这样JAXB框架会自动的把我们的基于JAX-WS的请求/响应参数转为XML格式的消息。特别注意有2点：

a.对于附件资源，我们这里是用了@XmlMimeType("application/octet-stream")来标示，并且其字段类型为DataHandler,这样的目的是为了能让JAXB框架正确的处理附件资源，其实这里MIME类型也可以设为具体类型，比如 image/jpeg, 但是这种用法更通用。

b.需要加@XmlAccessorType(XmlAccessType.FIELD),这样可以使得JAXB只处理字段类型到附件的映射，而不会处理getter()方法，否则会报错

com.sun.xml.bind.v2.runtime.IllegalAnnotationException  
//Class has two properties of the same name "portrait"


然后，因为我们用的是JAX-WS的调用方式，所以我们可能从代码中看不到真正SOAP消息长什么样子，所以我们这里定义了一个LogHandler（具体参见http://supercharles888.blog.51cto.com/609344/1361866  ），它可以把入Endpoint和出Endpoint的SOAP消息进行区分，并且把消息内容打印到服务器的控制台上：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/**
  * SOAP Handler可以用来对SOAP消息进行访问。
  * 这里演示的是第一种，它必须实现SOAPHandler<SOAPMessageContext>接口
  */
package  com.charles.cxfstudy.server.handlers;
import  java.util.Set;
import  javax.xml.namespace.QName;
import  javax.xml.soap.SOAPMessage;
import  javax.xml.ws.handler.MessageContext;
import  javax.xml.ws.handler.soap.SOAPHandler;
import  javax.xml.ws.handler.soap.SOAPMessageContext;
/**
  * 记录进/出Endpoint的消息到控制台的Handler
  *
  * @author charles.wang
  *
  */
public  class  LogHandler  implements  SOAPHandler<SOAPMessageContext> {
     /**
      * 如何去处理SOAP消息的逻辑。 这里会先判断消息的类型是入站还是出站消息，然后把消息写到标准输出流
      */
     public  boolean  handleMessage(SOAPMessageContext context) {
         // 先判断消息来源是入站还是出站的
         // （入站表示是发送到web service站点的消息，出站表示是从web service站点返回的消息)
         boolean  outbound = (Boolean) context
                 .get(MessageContext.MESSAGE_OUTBOUND_PROPERTY);
         // 如果是出站消息
         if  (outbound) {
             System.out.println( "这是从Endpoint返回到客户端的SOAP消息" );
         }  else  {
             System.out.println( "这是客户端的请求SOAP消息" );
         }
         SOAPMessage message = context.getMessage();
         try  {
             message.writeTo(System.out);
             System.out.println( '\n' );
         }  catch  (Exception ex) {
             System.err.print( "Exception occured when handling message" );
         }
         return  true ;
     }
     /**
      * 如何去处理错误的SOAP消息 这里会先打印当前调用的方法，然后从消息上下文中取出消息，然后写到标准输出流
      */
     public  boolean  handleFault(SOAPMessageContext context) {
         SOAPMessage message = context.getMessage();
         try  {
             message.writeTo(System.out);
             System.out.println();
         }  catch  (Exception ex) {
             System.err.print( "Exception occured when handling fault message" );
         }
         return  true ;
     }
     /**
      * 这里没有资源清理的需求，所以我们只打印动作到控制台
      */
     public  void  close(MessageContext context) {
         System.out.println( "LogHandler->close(context) method invoked" );
     }
     public  Set<QName> getHeaders() {
         return  null ;
     }
}

我们定义一个HandlerChain文件，把LogHandler加进去：

1
2
3
4
5
6
7
8
9
10
<? xml  version = "1.0"  encoding = "UTF-8" ?>
< handler-chains  xmlns = "http://java.sun.com/xml/ns/javaee" >
    < handler-chain >
    <!-- 配置可以记录出/入Endpoint消息内容到控制台的Handler -->
     < handler >
         < handler-name >LogHandler</ handler-name >
         < handler-class >com.charles.cxfstudy.server.handlers.LogHandler</ handler-class >
     </ handler >
    </ handler-chain >
</ handler-chains >


现在我们就开始写服务器端的处理逻辑了，我们可以让其从客户端发过来的带附件的SOAP消息中提取一般字段和附件，对于附件的图片（头像文件），我们复制到指定位置。

首先，我们定义SEI，它是个服务接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
  * 这是一个web服务接口定义，定义了如何对于上传的Profile进行处理
  */
package  com.charles.cxfstudy.server.services;
import  javax.jws.WebParam;
import  javax.jws.WebService;
import  com.charles.cxfstudy.server.vo.Profile;
/**
  * @author Administrator
  *
  */
@WebService
public  interface  IUploadProfileService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
     /**
      * 上传Profile，并且对于Profile进行处理
      */
     void  uploadProfile( @WebParam (name= "profile" ) Profile profile);
}


然后我们定义SIB，它实现了SEI：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/**
  * 服务实现类，提供上传Profile的服务
  */
package  com.charles.cxfstudy.server.services;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.InputStream;
import  java.io.OutputStream;
import  javax.activation.DataHandler;
import  javax.jws.HandlerChain;
import  javax.jws.WebParam;
import  javax.jws.WebService;
import  com.charles.cxfstudy.server.vo.Profile;
/**
  * @author charles.wang
  *
  */
@WebService (endpointInterface =  "com.charles.cxfstudy.server.services.IUploadProfileService" )
@HandlerChain (file= "/handler_chains.xml" )
public  class  UploadProfileServiceImpl  implements  IUploadProfileService {
     /**
      * 上传Profile，并且对于Profile进行处理
      */
     public  void  uploadProfile( @WebParam (name= "profile" ) Profile profile){
                                                                                                                                                                                                                                                                                                                                                                                                                                            
         //从参数中获得相关信息
         String name = profile.getName();                   //姓名
         int     age  = profile.getAge();                    //年龄
                                                                                                                                                                                                                                                                                                                                                                                                                                            
         DataHandler portrait = profile.getPortrait();      //肖像图片
         String imageFileExtension = profile.getImageFileExtension();  //肖像图片的扩展名
                                                                                                                                                                                                                                                                                                                                                                                                                                            
         try {
             //获取输入流，来获取图片资源
             InputStream is = portrait.getInputStream();
             //打开一个输出流，来保存获得的图片
             OutputStream os =  new  FileOutputStream( "d:/tmp/uploadTo/" +name+ "." +imageFileExtension);
             //进行复制,把获得的肖像图片复制到
             byte [] b =  new  byte [ 10000 ];
             int  byteRead= 0 ;
             while  ( (byteRead=is.read(b))!= - 1 ){
                 os.write(b, 0 ,byteRead);
             }
             os.flush();
             os.close();
             is.close();
         } catch (IOException ex){
             ex.printStackTrace();
         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                
     }
                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                        
}

大体上代码很容易读懂（呵呵，我自信我代码的可读性），和惯例一样，我们用@HandlerChain注解来使得LogHandler可以作用到当前的服务类上并且打印进出当前服务器类的SOAP消息。


为了让MTOM生效（也就是让服务器端支持对带附件的SOAP消息处理），我们必须在当前SIB的bean定义文件中打开MTOM开关，如下的20-22行（在beans.xml中)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<? 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"
        xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">
<!-- 导入cxf中的spring的一些配置文件，他们都在cxf-<version>.jar文件中 -->
< import  resource = "classpath:META-INF/cxf/cxf.xml"  />
< import  resource = "classpath:META-INF/cxf/cxf-servlet.xml"  />
<!-- 这里是第一个web service,它提供上传用户Profile的功能（主要演示发送带附件的SOAP消息到服务器） -->
< jaxws:endpoint
id = "uploadProfileService"
implementor = "com.charles.cxfstudy.server.services.UploadProfileServiceImpl"
address = "/uploadProfile"  >
   <!-- 下面这段注释在服务器端开启了MTOM，所以它可以正确的处理来自客户端的带附件的SOAP消息 -->
    < jaxws:properties >
        < entry  key = "mtom-enabled"  value = "true" />
    </ jaxws:properties >
</ jaxws:endpoint >
...
</ beans >


现在打包完部署应用到服务器上，运行就可以了。


客户端：

现在我们来编写客户端，其实很简单，主要就是封装一个Profile对象（带附件），然后调用业务方法进行上传操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/**
  * 客户端测试代码
  */
package  com.charles.mtom.sendattachedsoap;
import  java.util.HashMap;
import  java.util.Map;
import  javax.activation.DataHandler;
import  javax.activation.DataSource;
import  javax.activation.FileDataSource;
import  org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
/**
  * @author charles.wang
  *
  */
public  class  MainTest {
                                                                                                                                                                                                                                                                              
     public  static  void  main(String [] args){
                                                                                                                                                                                                                                                                              
     JaxWsProxyFactoryBean factory =  new  JaxWsProxyFactoryBean();
     factory.setServiceClass(IUploadProfileService. class );
                                                                                                                                                                                                                                                                              
     //下面三行代码：激活客户端能处理带附件的SOAP消息的功能：
     Map<String,Object> props =  new  HashMap<String,Object>();
     props.put( "mtom-enabled" , Boolean.TRUE);
     factory.setProperties(props);
     factory.setAddress( "http://localhost:8080/cxf_mtom_service/services/uploadProfile" );
                                                                                                                                                                                                                                                                              
     //调用业务方法
     IUploadProfileService service = (IUploadProfileService) factory.create();
                                                                                                                                                                                                                                                                              
     //创建 一个要上传的Profile对象
     Profile profile =  new  Profile();
     profile.setName( "Charles" );
     profile.setAge( 28 );
                                                                                                                                                                                                                                                                              
     //下面两行特别注意如何去吧一个附件附加到请求中的
     DataSource source =  new  FileDataSource( "F:/images/myprofileImage.jpg" );
     profile.setPortrait( new  DataHandler(source));
     profile.setImageFileExtension( "jpg" );
                                                                                                                                                                                                                                                                              
     //调用业务方法，发送soap请求
     service.uploadProfile(profile);
                                                                                                                                                                                                                                                                              
     }
}

条理也很清楚，这里特别注意是第23-25行激活了客户端对MTOM的支持。第36到39行演示了如何把一个附件（比如图片文件）附加到SOAP消息上。


我们运行例子。

可以清楚的看到从客户端发送的SOAP消息和从服务器端返回的SOAP消息，显然，发送的消息是以attachment的形式附加在SOAP消息上的，符合我们文章开始的结构示意图。

wKiom1MJqsvj4wBgAAwYynEXQAo116.jpg

我们去文件系统检查，果然，客户端通过调用，把图片文件从F:/Images/myProfileImage.jpg传递给了webservice,然后webservice从SOAP消息中拿到附件，并且改名为Charles.jpg,然后存储到了D:/tmp/uploadTo目录

wKiom1MJq1nDrrw4AAI7L0l9pbU118.jpg


额外话题：

注意，对于客户端代码的开启MTOM的支持是必不可少的：

1
2
3
4
//下面三行代码：激活客户端能处理带附件的SOAP消息的功能：
Map<String,Object> props =  new  HashMap<String,Object>();
props.put( "mtom-enabled" , Boolean.TRUE);
factory.setProperties(props);


如果没有这3行的话，我们发送的SOAP消息就是一个不带附件的消息，而是把我们的资源文件（比如图片）转为Base64,然后把编码后的内容和普通字段一样放在SOAP消息中。


比如，当我们注释掉上面几行，再发送请求的时候，其请求的SOAP消息就如下：

wKiom1MJrT_BKTouAA604U_Tol0837.jpg

这显然就不是一个带附件的SOAP消息了，因为Base64编码很低效，要大量运算，所以如果附件文件很大，那么转为Base64就会花费很多时间，这不是一个很好的选择。





本文转自 charles_wang888 51CTO博客，原文链接：http://blog.51cto.com/supercharles888/1362358，如需转载请自行联系原作者
weixin_34217773
关注
java mtom_CXF实现MTOM协议
weixin_32683881的博客
02-16 409
MTOM(SOAP Message Transmission Optimization Mechanism)SOAP 消息传输优化机制，可以在SOAP 消息中发送二进制数据，与SAAJ 传输附件不同，MTOM需要XOP(XML-binaryOptimized Packing)来传输二进制数据。MTOM 允许将消息中包含的大型数据元素外部化，并将其作为无任何特殊编码的二进制数据随消息一起传送。MT...
cxf 发送 soap 请求(webService)
流窜的鱼
09-17 1013
import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory; public class CXFClient {     public CXFClient(){}          public  Object[] sendSoap(String wsdlUrl,String hostMethod,Obje
Apache CXF 学习-使用MTOM来让客户端接收从服务端发过来的带附件的SOAP消息
weixin_33932129的博客
02-23 216
引入：上文中我们很详实的演示了如何通过MTOM，让客户端构造一个带附件的SOAP消息，然后服务器端解析处理SOAP消息，并且通过LogHandler来观察请求和返回的SOAP消息的内容。这里我们演示相反过程，就是如何从服务器端下载一个带附件的SOAP消息，然后客户端对这个SOAP消息进行处理，尤其是对附件的处理。实践：因为大体上都和上文类似，所以这里我就不做太多的讲解了。我们...
webservice用cxf发布SOAP
weixin_30432579的博客
09-02 198
cxf的安装，就是把文件解压，然后配置环境变量 http://cxf.apache.org/download.html这是官网下载 解压到这里 环境变量 wsdl2java命令测试 1、新建java项目，然后导入cxf相关的jar 2、定义服务接口 1 package com.xiaostudy; 2 3 /** 4 * @desc 服务...
WebService CXF --- 传输文件MTOM
03-30
1. **启用MTOM**：在CXF服务端和客户端，都需要在配置文件中开启MTOM。对于服务端，可以在Spring配置文件中添加`<jaxws:endpoint>`元素，并设置`mtom-enabled="true"`属性。对于客户端，可以使用`...
axis2-1.8.0apache-cxf-3.4.4.rar
08-26
1. **SOAP处理**：Axis2能够处理各种SOAP消息，支持SOAP 1.1和1.2规范，包括处理附件（MTOM和SwA）和WS-Addressing等扩展。 2. **模块化架构**：Axis2采用模块化设计，允许开发者按需选择和组合功能，比如安全、...
apache-cxf-3.5.3.zip
09-26
Apache CXF 提供了`wsdl2java`工具，它能够将WSDL文档转换成Java代码，帮助开发者快速实现服务端和客户端的接口。通过这个工具，你可以自动生成服务接口、数据绑定类和服务实现的模板，极大地简化了基于WSDL的服务...
apache-cxf-3.4.5.zip
11-22
总的来说，"apache-cxf-3.4.5.zip"是一个用于构建高效、灵活Web服务的工具包，它提供了全面的Web服务开发支持，从简单的RESTful API到复杂的SOAP服务，都可轻松应对。开发者可以根据这个压缩包中的内容，快速集成和...
apache-cxf-2.5.2
10-31
在使用"apache-cxf-2.5.2"时，开发者通常会首先阅读文档，了解如何配置和启动CXF服务器，然后使用提供的示例或自己编写代码来创建和部署Web服务。此外，他们还需要了解如何在Spring框架中集成CXF，以便更好地管理...
SOAP-MTOM_Canon.pdf
12-23
SOAP使用
CXF应用整理（包括大文件上传MTOM、安全机制）
03-07
包括简单的HelloWorld、复杂对象传递、安全机制、大文件上传（MTOM）、嵌入jetty等。 呵呵，3分不多吧=,=!!
WebService之CXF、Spring web整合发布SOAP服务
hestyle的博客
12-10 384
在上一篇博客 WebService之CXF快速入门（附Demo演示） 演示通过CXF发布SOAP服务，需要手动创建一个服务端供客户端连接。在此篇博客，我们把CXF与Spring进行整合，让Spring负责创建服务端对象。 一、服务端开发 1、创建一个java web项目 2、导入CXF、Spring的jar包到WEB-INF/lib中 首先在WEB-INF文件夹下新建目录lib 复制CXF...
CXF+Spring整合发布SOAP服务（Web项目服务端）
鸭梨山大山大的博客
03-12 758
一、原理 当需要调用一个Web项目的service或其他层的功能时，这时我们需要Web项目也能提供相关的服务，供其他项目使用。 二、开发步骤 1、创建一个Web项目，假设创建了一个weatherService，提供天气查询的服务。 2、将该服务发布 第一步： 把【springmvc3.1.4与cxf2.7.11jar】jar包都导入，这里在IDEA工具导jar包的时候一定要注意，有时候会导不进...
使用 CXF 开发 SOAP 服务
u010509291的博客
07-29 822
转自其它网页，用来记下学习。 今天我们将视角集中在 REST 上，它是继 SOAP 以后，另一种广泛使用的 Web 服务。与 SOAP 不同，REST 并没有 WSDL 的概念，也没有叫做“信封”的东西，因为 REST 主张用一种简单粗暴的方式来表达数据，传递的数据格式可以是 JSON 格式，也可以是 XML 格式，这完全由您来决定。 REST 全称是 Representational
使用CXF框架发布SOAP协议的 WebService服务
Mr_YXX的博客
07-22 323
引言 Apache CXF = Celtix + XFire，开始叫 Apache CeltiXfire，后来更名为 Apache CXF 了，以下简称为 CXF。CXF 继承了 Celtix 和 XFire 两大开源项目的精华，提供了对 JAX-WS 全面的支持，并且提供了多种 Binding 、DataBinding、Transport 以及各种 Format 的支持，并且可以根据实际项目的需要，采用代码优先（Code First）或者 WSDL 优先（WSDL First）来轻松地实现 Web Se
javase javaee 总结
weixin_45392911的博客
04-19 301
javaee
CXF集成MTOM传输数据
weixin_40912627的博客
05-14 329
今天看互联互通共享文档传输需要MTOM/XOP编码，做个简单笔记 服务端代码 webservice接口 import com.aadata.qyhlht.entity.User; import javax.jws.WebMethod; import javax.jws.WebParam; import javax.jws.WebResult; import javax.jws.WebService; import javax.jws.soap.SOAPBinding; @WebService(
使用CXF和MTOM上传附件
jackyrongvip的专栏
10-04 1267
CXF是一个不错的开源的WS框架，支持多种WS协议，其中包括对附件上传的协议MTOM，下文以一个例子来说明，如何用CXF和MTOM来实现上传一个WORD的文件到服务端。首先是服务端WS的实现。我们编写一个POJO，来处理一个待上传的简历：Resume.javaimport javax.activation.DataHandler;  public class Resume{  pr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值