Java MimeTypeUtils类代码示例

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
@ApiOperation(value = "signup", notes = "create a new account", response = UserDetailsResponse.class)
@RequestMapping(value = "/auth/signup", method = RequestMethod.POST, consumes = MimeTypeUtils.APPLICATION_JSON_VALUE)
public ResponseEntity<UserDetailsResponse> signUp(@RequestBody  Map<String, String> data) {
    if (!securityConfigurationProperties.getMongo().isEnableSignup()) {
        return ResponseEntity.badRequest().build();
    }
    // Public access
    final String login = data.get("login"),
            password = data.get("password"),
            mail = data.get("email");
    if ( StringUtils.isNoneBlank(login, password, mail) && emailValidator.isValid(mail)) {
        return ResponseEntity.ok(UserDetailsResponse.wrap(accountService.createAccount(login, mail, password)));
    } else {
        return ResponseEntity.badRequest().build();
    }

}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
@Test
public void testSendBinaryDataWithContentType() throws Exception {
	try (ConfigurableApplicationContext context = SpringApplication.run(
			SourceApplication.class, "--server.port=0",
			"--spring.jmx.enabled=false",
			"--spring.cloud.stream.bindings.output.contentType=image/jpeg")) {
		MessageCollector collector = context.getBean(MessageCollector.class);
		Source source = context.getBean(Source.class);
		byte[] data = new byte[] { 0, 1, 2, 3 };
		source.output().send(MessageBuilder.withPayload(data)
				.build());
		Message<byte[]> message = (Message<byte[]>) collector
				.forChannel(source.output()).poll(1, TimeUnit.SECONDS);
		assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class)
						.includes(MimeTypeUtils.IMAGE_JPEG));
		assertThat(message.getPayload()).isEqualTo(data);
	}
}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
@ApiOperation(value = "update a conversation", response = Conversation.class)
@RequestMapping(value = "{id}", method = RequestMethod.PUT, consumes = MimeTypeUtils.APPLICATION_JSON_VALUE)
public ResponseEntity<?> updateConversation(
        AuthContext authContext,
        @PathVariable("id") ObjectId id,
        @RequestBody Conversation conversation
) {
    final Conversation storedC = authenticationService.assertConversation(authContext, id);

    // make sure the id is the right one
    conversation.setId(storedC.getId());
    final Client client = authenticationService.assertClient(authContext, conversation.getOwner());

    //TODO: check that the
    // * the user is from the client the stored conversation as as owner
    return ResponseEntity.ok(conversationService.update(client, conversation,true, null));
}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
@Test
public void handleErrorFrameWithConversionException() throws Exception {

	StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.ERROR);
	accessor.setContentType(MimeTypeUtils.APPLICATION_JSON);
	accessor.addNativeHeader("foo", "bar");
	accessor.setLeaveMutable(true);
	byte[] payload = "{'foo':'bar'}".getBytes(UTF_8);

	StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
	when(this.sessionHandler.getPayloadType(stompHeaders)).thenReturn(Map.class);

	this.session.handleMessage(MessageBuilder.createMessage(payload, accessor.getMessageHeaders()));

	verify(this.sessionHandler).getPayloadType(stompHeaders);
	verify(this.sessionHandler).handleException(same(this.session), same(StompCommand.ERROR),
			eq(stompHeaders), same(payload), any(MessageConversionException.class));
	verifyNoMoreInteractions(this.sessionHandler);
}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
@Test
public void handleMessageFrame() throws Exception {

	this.session.afterConnected(this.connection);

	StompFrameHandler frameHandler = mock(StompFrameHandler.class);
	String destination = "/topic/foo";
	Subscription subscription = this.session.subscribe(destination, frameHandler);

	StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.MESSAGE);
	accessor.setDestination(destination);
	accessor.setSubscriptionId(subscription.getSubscriptionId());
	accessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
	accessor.setMessageId("1");
	accessor.setLeaveMutable(true);
	String payload = "sample payload";

	StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
	when(frameHandler.getPayloadType(stompHeaders)).thenReturn(String.class);

	this.session.handleMessage(MessageBuilder.createMessage(payload.getBytes(UTF_8), accessor.getMessageHeaders()));

	verify(frameHandler).getPayloadType(stompHeaders);
	verify(frameHandler).handleFrame(stompHeaders, payload);
	verifyNoMoreInteractions(frameHandler);
}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
@Test
public void toNativeHeadersMessageFrame() {

	StompHeaderAccessor headers = StompHeaderAccessor.create(StompCommand.MESSAGE);
	headers.setSubscriptionId("s1");
	headers.setDestination("/d");
	headers.setContentType(MimeTypeUtils.APPLICATION_JSON);
	headers.updateStompCommandAsServerMessage();

	Map<String, List<String>> actual = headers.toNativeHeaderMap();

	assertEquals(actual.toString(), 4, actual.size());
	assertEquals("s1", actual.get(StompHeaderAccessor.STOMP_SUBSCRIPTION_HEADER).get(0));
	assertEquals("/d", actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER).get(0));
	assertEquals("application/json", actual.get(StompHeaderAccessor.STOMP_CONTENT_TYPE_HEADER).get(0));
	assertNotNull("message-id was not created", actual.get(StompHeaderAccessor.STOMP_MESSAGE_ID_HEADER).get(0));
}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
@Test
public void getShortLogMessage() {
	StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.SEND);
	accessor.setDestination("/foo");
	accessor.setContentType(MimeTypeUtils.APPLICATION_JSON);
	accessor.setSessionId("123");
	String actual = accessor.getShortLogMessage("payload".getBytes(Charset.forName("UTF-8")));
	assertEquals("SEND /foo session=123 application/json payload=payload", actual);

	StringBuilder sb = new StringBuilder();
	for (int i = 0; i < 80; i++) {
		sb.append("a");
	}
	final String payload = sb.toString() + " > 80";
	actual = accessor.getShortLogMessage(payload.getBytes(UTF_8));
	assertEquals("SEND /foo session=123 application/json payload=" + sb + "...(truncated)", actual);
}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
@Test
public void sendWebSocketBinary() throws Exception {
	StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.SEND);
	accessor.setDestination("/b");
	accessor.setContentType(MimeTypeUtils.APPLICATION_OCTET_STREAM);
	byte[] payload = "payload".getBytes(UTF_8);

	getTcpConnection().send(MessageBuilder.createMessage(payload, accessor.getMessageHeaders()));

	ArgumentCaptor<BinaryMessage> binaryMessageCaptor = ArgumentCaptor.forClass(BinaryMessage.class);
	verify(this.webSocketSession).sendMessage(binaryMessageCaptor.capture());
	BinaryMessage binaryMessage = binaryMessageCaptor.getValue();
	assertNotNull(binaryMessage);
	assertEquals("SEND\ndestination:/b\ncontent-type:application/octet-stream\ncontent-length:7\n\npayload\0",
			new String(binaryMessage.getPayload().array(), UTF_8));
}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
@Override
public Response serve(IHTTPSession session) {
    
    Method m = session.getMethod();
    switch(m)
    {
    
      case GET:
        return doGet(session);
      case POST:
        return doPost(session);
      default:
        return newFixedLengthResponse(Status.NOT_IMPLEMENTED, MimeTypeUtils.TEXT_PLAIN_VALUE,"HTTP "+m);
    
    }
}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
public void read(String mimeType, InputStream is) throws IOException {
    Assert.hasText(mimeType, "MimeType string is null or empty.");
    Assert.notNull(is, "InputStream is null or empty.");
    MimeType mimeTypeObj = MimeTypeUtils.parseMimeType(mimeType);
    if(MimeTypeUtils.APPLICATION_JSON.equals(mimeTypeObj)) {
        Assert.hasText(mimeType, "MimeType '" + mimeType + "' is not supported.");
    }
    AppConfigObject aco = objectMapper.readValue(is, AppConfigObject.class);
    final String version = aco.getVersion();
    if(!VERSION.equals(version)) {
        throw new RuntimeException("Unsupported version of config: " + version);
    }

    ConfigReadContext ctx = new ConfigReadContext();
    Map<String, Object> map = aco.getData();
    Assert.notNull(map, "config has empty map");
    for(Map.Entry<String, Object> oe : map.entrySet()) {
        String name = oe.getKey();
        ReConfigurableAdapter ca = adapters.get(name);
        Assert.notNull(ca, "Can not find adapter with name: " + name);
        Object value = oe.getValue();
        Assert.notNull(value, "Config object is null for name: " + name);
        ca.setConfig(ctx, value);
    }
}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
@RequestMapping(path = "config", method = RequestMethod.GET)
public ResponseEntity<StreamingResponseBody> getConfig() {
    HttpHeaders headers = new HttpHeaders();
    // 'produces' in annotation does not work with stream
    headers.setContentType(MediaType.APPLICATION_JSON);
    headers.set(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"cluman_config.json\"");
    return new ResponseEntity<>((os) -> {
        appConfigService.write(MimeTypeUtils.APPLICATION_JSON_VALUE, os);
    }, headers, HttpStatus.OK);
}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
/**
 * Uploads a byte array using FileResource and ExternalFileResource
 *
 * @param name  name of the file to be stored
 * @param bytes the byte array representing the file to be stored
 * @return url pointing to the uploaded resource
 * @throws IOException
 */
private String uploadImage( String name, byte[] bytes )
    throws IOException
{
    FileResource fileResource = new FileResource(
        name,
        MimeTypeUtils.IMAGE_PNG.toString(), // All files uploaded from PushAnalysis is PNG.
        bytes.length,
        ByteSource.wrap( bytes ).hash( Hashing.md5() ).toString(),
        FileResourceDomain.PUSH_ANALYSIS
    );

    fileResourceService.saveFileResource( fileResource, bytes );

    ExternalFileResource externalFileResource = new ExternalFileResource();

    externalFileResource.setFileResource( fileResource );
    externalFileResource.setExpires( null );

    String accessToken = externalFileResourceService.saveExternalFileResource( externalFileResource );

    return systemSettingManager.getInstanceBaseUrl() + "/api/externalFileResources/" + accessToken;

}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
@RequestMapping(value = "/{kudosId}/plusOnes", method = RequestMethod.POST, consumes = MimeTypeUtils.APPLICATION_JSON_VALUE, produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
public ResponseMessage addNewPlusOne(@RequestBody @Valid NewPlusOneRequest newPlusOneRequest, BindingResult result, @PathVariable("kudosId") Long kudosId) {
    logger.info("New request " + newPlusOneRequest.toString());
    if (result.hasErrors()) {
        throw new IllegalArgumentException("Invalid request data " + result.toString());
    }
    Kudos kudos = kudosRepository.findOne(kudosId);
    if(kudos == null) {
        throw new IllegalArgumentException("There is no kudos with id=" + kudosId);
    }

    PlusOne plusOne = new PlusOne(
            slackUsersProvider.mapSlackUserNameToUserId(newPlusOneRequest.getUserName()),
            newPlusOneRequest.getDescription(),
            kudos
    );
    plusOneRepository.save(plusOne);
    kudos.addPlusOne(plusOne);

    return new ResponseMessage("ok");
}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
@Test
public void testOneRequiredGroup() throws Exception {
	B binder = getBinder();
	PP producerProperties = createProducerProperties();
	DirectChannel output = createBindableChannel("output", createProducerBindingProperties(producerProperties));

	String testDestination = "testDestination" + UUID.randomUUID().toString().replace("-", "");

	producerProperties.setRequiredGroups("test1");
	Binding<MessageChannel> producerBinding = binder.bindProducer(testDestination, output, producerProperties);

	String testPayload = "foo-" + UUID.randomUUID().toString();
	output.send(MessageBuilder.withPayload(testPayload).setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build());

	QueueChannel inbound1 = new QueueChannel();
	Binding<MessageChannel> consumerBinding = binder.bindConsumer(testDestination, "test1", inbound1,
			createConsumerProperties());

	Message<?> receivedMessage1 = receive(inbound1);
	assertThat(receivedMessage1).isNotNull();
	assertThat(new String((byte[]) receivedMessage1.getPayload())).isEqualTo(testPayload);

	producerBinding.unbind();
	consumerBinding.unbind();
}
 

import org.springframework.util.MimeTypeUtils; //导入依赖的package包/类
@Test
public void testSendWithDefaultContentType() throws Exception {
	try (ConfigurableApplicationContext context = SpringApplication.run(
			SourceApplication.class, "--server.port=0",
			"--spring.jmx.enabled=false")) {

		MessageCollector collector = context.getBean(MessageCollector.class);
		Source source = context.getBean(Source.class);
		User user = new User("Alice");
		source.output().send(MessageBuilder.withPayload(user).build());
		Message<String> message = (Message<String>) collector
				.forChannel(source.output()).poll(1, TimeUnit.SECONDS);
		User received = mapper.readValue(message.getPayload(), User.class);
		assertThat(
				message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class)
						.includes(MimeTypeUtils.APPLICATION_JSON));
		assertThat(user.getName()).isEqualTo(received.getName());
	}
}