Examples with ClientEndpoint javax.websocket.ClientEndpoint used on opensource projects

Example 6 with ClientEndpoint

use of javax.websocket.ClientEndpoint in project jetty.project by eclipse.

the class ClientContainer method getClientEndpointMetadata.

public EndpointMetadata getClientEndpointMetadata(Class<?> endpoint, EndpointConfig config) {
    synchronized (endpointClientMetadataCache) {
        EndpointMetadata metadata = endpointClientMetadataCache.get(endpoint);
        if (metadata != null) {
            return metadata;
        }
        ClientEndpoint anno = endpoint.getAnnotation(ClientEndpoint.class);
        if (anno != null) {
            // Annotated takes precedence here
            AnnotatedClientEndpointMetadata annoMetadata = new AnnotatedClientEndpointMetadata(this, endpoint);
            AnnotatedEndpointScanner<ClientEndpoint, ClientEndpointConfig> scanner = new AnnotatedEndpointScanner<>(annoMetadata);
            scanner.scan();
            metadata = annoMetadata;
        } else if (Endpoint.class.isAssignableFrom(endpoint)) {
            // extends Endpoint
            @SuppressWarnings("unchecked") Class<? extends Endpoint> eendpoint = (Class<? extends Endpoint>) endpoint;
            metadata = new SimpleEndpointMetadata(eendpoint, config);
        } else {
            StringBuilder err = new StringBuilder();
            err.append("Not a recognized websocket [");
            err.append(endpoint.getName());
            err.append("] does not extend @").append(ClientEndpoint.class.getName());
            err.append(" or extend from ").append(Endpoint.class.getName());
            throw new InvalidWebSocketException(err.toString());
        }
        endpointClientMetadataCache.put(endpoint, metadata);
        return metadata;
    }
}

Example 7 with ClientEndpoint

use of javax.websocket.ClientEndpoint in project jetty.project by eclipse.

the class ClientAnnotatedEndpointScanner_GoodSignaturesTest method testScan_Basic.

@Test
public void testScan_Basic() throws Exception {
    AnnotatedClientEndpointMetadata metadata = new AnnotatedClientEndpointMetadata(container, testcase.pojo);
    AnnotatedEndpointScanner<ClientEndpoint, ClientEndpointConfig> scanner = new AnnotatedEndpointScanner<>(metadata);
    scanner.scan();
    Assert.assertThat("Metadata", metadata, notNullValue());
    JsrCallable cm = (JsrCallable) testcase.metadataField.get(metadata);
    Assert.assertThat(testcase.metadataField.toString(), cm, notNullValue());
    int len = testcase.expectedParameters.length;
    for (int i = 0; i < len; i++) {
        Class<?> expectedParam = testcase.expectedParameters[i];
        Class<?> actualParam = cm.getParamTypes()[i];
        Assert.assertTrue("Parameter[" + i + "] - expected:[" + expectedParam + "], actual:[" + actualParam + "]", actualParam.equals(expectedParam));
    }
}

Example 8 with ClientEndpoint

use of javax.websocket.ClientEndpoint in project undertow by undertow-io.

the class ServerWebSocketContainer method addEndpointInternal.

private synchronized void addEndpointInternal(final Class<?> endpoint, boolean requiresCreation) throws DeploymentException {
    ServerEndpoint serverEndpoint = endpoint.getAnnotation(ServerEndpoint.class);
    ClientEndpoint clientEndpoint = endpoint.getAnnotation(ClientEndpoint.class);
    if (serverEndpoint != null) {
        JsrWebSocketLogger.ROOT_LOGGER.addingAnnotatedServerEndpoint(endpoint, serverEndpoint.value());
        final PathTemplate template = PathTemplate.create(serverEndpoint.value());
        if (seenPaths.contains(template)) {
            PathTemplate existing = null;
            for (PathTemplate p : seenPaths) {
                if (p.compareTo(template) == 0) {
                    existing = p;
                    break;
                }
            }
            throw JsrWebSocketMessages.MESSAGES.multipleEndpointsWithOverlappingPaths(template, existing);
        }
        seenPaths.add(template);
        Class<? extends ServerEndpointConfig.Configurator> configuratorClass = serverEndpoint.configurator();
        EncodingFactory encodingFactory = EncodingFactory.createFactory(classIntrospecter, serverEndpoint.decoders(), serverEndpoint.encoders());
        AnnotatedEndpointFactory annotatedEndpointFactory = AnnotatedEndpointFactory.create(endpoint, encodingFactory, template.getParameterNames());
        InstanceFactory<?> instanceFactory = null;
        try {
            instanceFactory = classIntrospecter.createInstanceFactory(endpoint);
        } catch (Exception e) {
            //so it is possible that this is still valid if a custom configurator is in use
            if (configuratorClass == ServerEndpointConfig.Configurator.class) {
                throw JsrWebSocketMessages.MESSAGES.couldNotDeploy(e);
            } else {
                instanceFactory = new InstanceFactory<Object>() {

                    @Override
                    public InstanceHandle<Object> createInstance() throws InstantiationException {
                        throw JsrWebSocketMessages.MESSAGES.endpointDoesNotHaveAppropriateConstructor(endpoint);
                    }
                };
            }
        }
        ServerEndpointConfig.Configurator configurator;
        if (configuratorClass != ServerEndpointConfig.Configurator.class) {
            try {
                configurator = classIntrospecter.createInstanceFactory(configuratorClass).createInstance().getInstance();
            } catch (InstantiationException | NoSuchMethodException e) {
                throw JsrWebSocketMessages.MESSAGES.couldNotDeploy(e);
            }
        } else {
            configurator = DefaultContainerConfigurator.INSTANCE;
        }
        ServerEndpointConfig config = ServerEndpointConfig.Builder.create(endpoint, serverEndpoint.value()).decoders(Arrays.asList(serverEndpoint.decoders())).encoders(Arrays.asList(serverEndpoint.encoders())).subprotocols(Arrays.asList(serverEndpoint.subprotocols())).extensions(Collections.<Extension>emptyList()).configurator(configurator).build();
        ConfiguredServerEndpoint confguredServerEndpoint = new ConfiguredServerEndpoint(config, instanceFactory, template, encodingFactory, annotatedEndpointFactory, installedExtensions);
        configuredServerEndpoints.add(confguredServerEndpoint);
        handleAddingFilterMapping();
    } else if (clientEndpoint != null) {
        JsrWebSocketLogger.ROOT_LOGGER.addingAnnotatedClientEndpoint(endpoint);
        EncodingFactory encodingFactory = EncodingFactory.createFactory(classIntrospecter, clientEndpoint.decoders(), clientEndpoint.encoders());
        InstanceFactory<?> instanceFactory;
        try {
            instanceFactory = classIntrospecter.createInstanceFactory(endpoint);
        } catch (Exception e) {
            try {
                //this endpoint cannot be created by the container, the user will instantiate it
                instanceFactory = new ConstructorInstanceFactory<>(endpoint.getConstructor());
            } catch (NoSuchMethodException e1) {
                if (requiresCreation) {
                    throw JsrWebSocketMessages.MESSAGES.couldNotDeploy(e);
                } else {
                    instanceFactory = new InstanceFactory<Object>() {

                        @Override
                        public InstanceHandle<Object> createInstance() throws InstantiationException {
                            throw new InstantiationException();
                        }
                    };
                }
            }
        }
        AnnotatedEndpointFactory factory = AnnotatedEndpointFactory.create(endpoint, encodingFactory, Collections.<String>emptySet());
        ClientEndpointConfig.Configurator configurator = null;
        try {
            configurator = classIntrospecter.createInstanceFactory(clientEndpoint.configurator()).createInstance().getInstance();
        } catch (InstantiationException | NoSuchMethodException e) {
            throw JsrWebSocketMessages.MESSAGES.couldNotDeploy(e);
        }
        ClientEndpointConfig config = ClientEndpointConfig.Builder.create().decoders(Arrays.asList(clientEndpoint.decoders())).encoders(Arrays.asList(clientEndpoint.encoders())).preferredSubprotocols(Arrays.asList(clientEndpoint.subprotocols())).configurator(configurator).build();
        ConfiguredClientEndpoint configuredClientEndpoint = new ConfiguredClientEndpoint(config, factory, encodingFactory, instanceFactory);
        clientEndpoints.put(endpoint, configuredClientEndpoint);
    } else {
        throw JsrWebSocketMessages.MESSAGES.classWasNotAnnotated(endpoint);
    }
}