forked from eclipse-ee4j/jersey
-
Notifications
You must be signed in to change notification settings - Fork 0
/
DataSourceProvider.java
170 lines (148 loc) · 5.45 KB
/
DataSourceProvider.java
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
/*
* Copyright (c) 2010, 2023 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0, which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception, which is available at
* https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
*/
package org.glassfish.jersey.message.internal;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import javax.ws.rs.Consumes;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.activation.DataSource;
/**
* Provider for marshalling/un-marshalling of {@code application/octet-stream}
* entity type to/from a {@link DataSource} instance.
*
* @author Paul Sandoz
* @author Marek Potociar
*/
@Produces({"application/octet-stream", "*/*"})
@Consumes({"application/octet-stream", "*/*"})
public class DataSourceProvider extends AbstractMessageReaderWriterProvider<DataSource> {
/**
* Modified from javax.mail.util.ByteArrayDataSource
*
* A DataSource backed by a byte array. The byte array may be
* passed in directly, or may be initialized from an InputStream
* or a String.
*
* @since JavaMail 1.4
* @author John Mani
* @author Bill Shannon
* @author Max Spivak
*/
public static class ByteArrayDataSource implements DataSource {
private final String type;
private byte[] data;
private int len = -1;
private String name = "";
static class DSByteArrayOutputStream extends ByteArrayOutputStream {
public byte[] getBuf() {
return buf;
}
public int getCount() {
return count;
}
}
public ByteArrayDataSource(final InputStream is, final String type) throws IOException {
final DSByteArrayOutputStream os = new DSByteArrayOutputStream();
ReaderWriter.writeTo(is, os);
this.data = os.getBuf();
this.len = os.getCount();
/*
* ByteArrayOutputStream doubles the size of the buffer every time
* it needs to expand, which can waste a lot of memory in the worst
* case with large buffers. Check how much is wasted here and if
* it's too much, copy the data into a new buffer and allow the
* old buffer to be garbage collected.
*/
if (this.data.length - this.len > 256 * 1024) {
this.data = os.toByteArray();
this.len = this.data.length; // should be the same
}
this.type = type;
}
@Override
public InputStream getInputStream() throws IOException {
if (data == null) {
throw new IOException("no data");
}
if (len < 0) {
len = data.length;
}
return new ByteArrayInputStream(data, 0, len);
}
@Override
public OutputStream getOutputStream() throws IOException {
throw new IOException("cannot do this");
}
@Override
public String getContentType() {
return type;
}
@Override
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
}
@Override
public boolean isReadable(final Class<?> type,
final Type genericType,
final Annotation[] annotations,
final MediaType mediaType) {
return DataSource.class == type;
}
@Override
public DataSource readFrom(
final Class<DataSource> type,
final Type genericType,
final Annotation[] annotations,
final MediaType mediaType,
final MultivaluedMap<String, String> httpHeaders,
final InputStream entityStream) throws IOException {
return new ByteArrayDataSource(entityStream, (mediaType == null) ? null : mediaType.toString());
}
@Override
public boolean isWriteable(final Class<?> type,
final Type genericType,
final Annotation[] annotations,
final MediaType mediaType) {
return DataSource.class.isAssignableFrom(type);
}
@Override
public void writeTo(
final DataSource t,
final Class<?> type,
final Type genericType,
final Annotation[] annotations,
final MediaType mediaType,
final MultivaluedMap<String, Object> httpHeaders,
final OutputStream entityStream) throws IOException {
final InputStream in = t.getInputStream();
try {
ReaderWriter.writeTo(in, entityStream);
} finally {
in.close();
}
}
}