Java NotFoundException类代码示例

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
public Response deleteQueue(String queueName, Boolean ifUnused, Boolean ifEmpty) {
    if (Objects.isNull(ifUnused)) {
        ifUnused = true;
    }

    if (Objects.isNull(ifEmpty)) {
        ifEmpty = true;
    }

    try {
        if (broker.deleteQueue(queueName, ifUnused, ifEmpty)) {
            return Response.ok().build();
        } else {
            throw new NotFoundException("Queue " + queueName + " doesn't exist.");
        }
    } catch (BrokerException e) {
        throw new BadRequestException(e.getMessage(), e);
    }
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
/**
 *  Add a segment of a binary.
 *
 *  <p>Note: the response will be a json structure, such as:</p>
 *  <pre>{
 *    "digest": "a-hash"
 *  }</pre>
 *
 *  @param id the upload session identifier
 *  @param partNumber the part number
 *  @param part the input stream
 *  @return a response
 */
@PUT
@Timed
@Path("{partNumber}")
@Produces("application/json")
public String uploadPart(@PathParam("id") final String id,
        @PathParam("partNumber") final Integer partNumber,
        final InputStream part) {

    final JsonObjectBuilder builder = Json.createObjectBuilder();

    if (!binaryService.uploadSessionExists(id)) {
        throw new NotFoundException();
    }

    final String digest = binaryService.uploadPart(id, partNumber, part);

    return builder.add("digest", digest).build().toString();
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
@Override
public Response toResponse(NotFoundException ex) {
  if (ex.getCause() instanceof IllegalArgumentException) {
    // If a URL parameter cannot be decoded (e.g. an invalid UUID) an IllegalArgumentException will be wrapped inside
    // a NotFoundException. But a 412 should be returned in this case.
    return ResultStash.builder()
            .setStatus(Response.Status.PRECONDITION_FAILED)
            .addActionError("Invalid URL parameter detected.", "invalid.url.parameter")
            .buildResponse();
  }

  return ResultStash.builder()
          .setStatus(Response.Status.NOT_FOUND)
          .addActionError("Requested URL does not exist.", "url.not.exist")
          .buildResponse();
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
@GET
@Path("{LraId}")
@Produces(MediaType.TEXT_PLAIN)
@ApiOperation(value = "Obtain the status of an LRA as a string",
        response = String.class)
@ApiResponses( {
        @ApiResponse( code = 404, message =
                "The coordinator has no knowledge of this LRA" ),
        @ApiResponse( code = 204, message =
                "The LRA exists and has not yet been asked to close or cancel "
                       + " - compare this response with a 200 response.s"),
        @ApiResponse( code = 200, message =
                "The LRA exists. The status is reported in the content body.")
} )
public Response getLRAStatus(
        @ApiParam( value = "The unique identifier of the LRA", required = true )
        @PathParam("LraId")String lraId) throws NotFoundException {
    CompensatorStatus status = lraService.getTransaction(toURL(lraId)).getLRAStatus();

    if (status == null)
        return Response.noContent().build(); // 204 means the LRA is still active

    return Response.ok(status.name()).build();
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
@PUT
@Path("{LraId}/renew")
@ApiOperation(value = "Update the TimeLimit for an existing LRA",
        notes = "LRAs can be automatically cancelled if they aren't closed or cancelled before the TimeLimit\n"
                + "specified at creation time is reached.\n"
                + "The time limit can be updated.\n")
@ApiResponses({
        @ApiResponse( code = 200, message = "If the LRA timelimit has been updated" ),
        @ApiResponse( code = 404, message = "The coordinator has no knowledge of this LRA" ),
        @ApiResponse( code = 412, message = "The LRA is not longer active (ie in the complete or compensate messages have been sent" )
} )
public Response renewTimeLimit(
        @ApiParam( value = "The new time limit for the LRA", required = true )
        @QueryParam(TIMELIMIT_PARAM_NAME) @DefaultValue("0") Long timelimit,
        @PathParam("LraId")String lraId) throws NotFoundException {

    return Response.status(lraService.renewTimeLimit(toURL(lraId), timelimit)).build();
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
@PUT
@Path("{LraId}/close")
@Produces(MediaType.APPLICATION_JSON)
@ApiOperation(value = "Attempt to close an LRA",
        notes = "Trigger the successful completion of the LRA. All"
                +" compensators will be dropped by the coordinator."
                +" The complete message will be sent to the compensators."
                +" Upon termination, the URL is implicitly deleted."
                +" The invoker cannot know for sure whether the lra completed or compensated without enlisting a participant.",
        response = Boolean.class)
@ApiResponses( {
        @ApiResponse( code = 404, message = "The coordinator has no knowledge of this LRA" ),
        @ApiResponse( code = 200, message = "The complete message was sent to all coordinators" )
} )
public Response closeLRA(
        @ApiParam( value = "The unique identifier of the LRA", required = true )
        @PathParam("LraId")String txId) throws NotFoundException {
    return endLRA(toURL(txId), false, false);
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
@PUT
@Path("{LraId}/cancel")
@Produces(MediaType.APPLICATION_JSON)
@ApiOperation(value = "Attempt to cancel an LRA",
        notes =   " Trigger the compensation of the LRA. All"
                + " compensators will be triggered by the coordinator (ie the compensate message will be sent to each compensators)."
                + " Upon termination, the URL is implicitly deleted."
                + " The invoker cannot know for sure whether the lra completed or compensated without enlisting a participant.",
        response = Boolean.class)
@ApiResponses( {
        @ApiResponse( code = 404, message = "The coordinator has no knowledge of this LRA" ),
        @ApiResponse( code = 200, message = "The compensate message was sent to all coordinators" )
} )
public Response cancelLRA(
        @ApiParam( value = "The unique identifier of the LRA", required = true )
        @PathParam("LraId")String lraId) throws NotFoundException {
    return endLRA(toURL(lraId), true, false);
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
private <T> Try<NestedCollectionRoutes<T>> _getNestedCollectionRoutesTry(
	String name, String nestedName) {

	Try<Optional<NestedCollectionRoutes<T>>> optionalTry = Try.success(
		_nestedCollectionRouterManager.getNestedCollectionRoutesOptional(
			name, nestedName));

	return optionalTry.map(
		Optional::get
	).recoverWith(
		__ -> _getReusableNestedCollectionRoutesTry(nestedName)
	).mapFailMatching(
		NoSuchElementException.class,
		() -> new NotFoundException("No resource found for path " + name)
	);
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
private Response joinLRA(URL lraId, long timeLimit, String compensatorUrl, String linkHeader, String userData)
        throws NotFoundException {
    final String recoveryUrlBase = String.format("http://%s/%s/",
            context.getRequestUri().getAuthority(), NarayanaLRAClient.RECOVERY_COORDINATOR_PATH_NAME);

    StringBuilder recoveryUrl = new StringBuilder();

    int status = lraService.joinLRA(recoveryUrl, lraId, timeLimit, compensatorUrl, linkHeader, recoveryUrlBase, userData);

    try {
        return Response.status(status)
                .entity(recoveryUrl)
                .location(new URI(recoveryUrl.toString()))
                .header(LRA_HTTP_RECOVERY_HEADER, recoveryUrl)
                .build();
    } catch (URISyntaxException e) {
        LRALogger.i18NLogger.error_invalidRecoveryUrlToJoinLRA(recoveryUrl.toString(), lraId);
        throw new GenericLRAException(lraId, Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), "Invalid recovery URL", e);
    }
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
public Response handle(final MinijaxRequestContext context) {
    final MinijaxResourceMethod rm = findRoute(context.getMethod(), (MinijaxUriInfo) context.getUriInfo());
    if (rm == null) {
        return toResponse(context, new NotFoundException());
    }

    context.setResourceMethod(rm);

    try {
        if (securityContextClass != null) {
            context.setSecurityContext(get(securityContextClass));
        }

        runRequestFilters(context);
        checkSecurity(context);
        final Response response = toResponse(rm, rm.invoke(context));
        runResponseFilters(context, response);
        return response;
    } catch (final Exception ex) {
        LOG.debug(ex.getMessage(), ex);
        return toResponse(context, ex);
    }
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
/**
 * Tests that a fetch of a non-existent port chain object throws an exception.
 */
@Test
public void testBadGet() {
    expect(portChainService.getPortChain(anyObject()))
    .andReturn(null).anyTimes();
    replay(portChainService);
    WebTarget wt = target();
    try {
        wt.path("port_chains/78dcd363-fc23-aeb6-f44b-56dc5aafb3ae")
                .request().get(String.class);
        fail("Fetch of non-existent port chain did not throw an exception");
    } catch (NotFoundException ex) {
        assertThat(ex.getMessage(),
                   containsString("HTTP 404 Not Found"));
    }
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
@Override
public Response toResponse(Exception exception) {
    if (exception instanceof NotFoundException) {
        return Response.status(Response.Status.NOT_FOUND).build();
    }
    UUID eventId = UUID.randomUUID();
    LOG.error(MessageFormat.format("{0} - Exception while processing request.", eventId), exception);
    StringBuilder sb = new StringBuilder();
    sb.append(exception.getClass().getName());

    if (configuration.getReturnStackTraceInResponse()) {
        sb.append(" : ");
        sb.append(exception.getMessage());
        sb.append("\n");
        for (StackTraceElement element : exception.getStackTrace()) {
            sb.append("! ");
            sb.append(element.toString());
            sb.append("\n");
        }
    }
    return Response.serverError().entity(sb.toString()).build();
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
/**
 * Tests that a fetch of a non-existent intent object throws an exception.
 */
@Test
public void testBadGet() {

    expect(mockIntentService.getIntent(Key.of(0, APP_ID)))
            .andReturn(null)
            .anyTimes();
    replay(mockIntentService);

    WebTarget wt = target();
    try {
        wt.path("intents/0").request().get(String.class);
        fail("Fetch of non-existent intent did not throw an exception");
    } catch (NotFoundException ex) {
        assertThat(ex.getMessage(),
                containsString("HTTP 404 Not Found"));
    }
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
/**
 * Tests that a fetch of a non-existent device object throws an exception.
 */
@Test
public void testBadGet() {
    expect(mockFlowService.getFlowEntries(anyObject()))
            .andReturn(null).anyTimes();
    replay(mockFlowService);
    replay(mockDeviceService);

    WebTarget wt = target();
    try {
        wt.path("flows/0").request().get(String.class);
        fail("Fetch of non-existent device did not throw an exception");
    } catch (NotFoundException ex) {
        assertThat(ex.getMessage(),
                containsString("HTTP 404 Not Found"));
    }
}
 

import javax.ws.rs.NotFoundException; //导入依赖的package包/类
/**
 * Tests that a fetch of a non-existent port pair group object throws an exception.
 */
@Test
public void testBadGet() {
    expect(portPairGroupService.getPortPairGroup(anyObject()))
    .andReturn(null).anyTimes();
    replay(portPairGroupService);
    WebTarget wt = target();
    try {
        wt.path("port_pair_groups/78dcd363-fc23-aeb6-f44b-56dc5aafb3ae")
                .request().get(String.class);
        fail("Fetch of non-existent port pair group did not throw an exception");
    } catch (NotFoundException ex) {
        assertThat(ex.getMessage(),
                   containsString("HTTP 404 Not Found"));
    }
}