---
apiVersion: v1
kind: ConfigMap
metadata:
  labels:
    funktion.fabric8.io/kind: Connector
  name: bean
data:
  deployment.yml: |
    ---
    apiVersion: extensions/v1beta1
    kind: Deployment
    metadata:
      labels:
        funktion.fabric8.io/kind: Subscription
        connector: bean
    spec:
      replicas: 1
      template:
        metadata:
          labels:
            funktion.fabric8.io/kind: Subscription
            connector: bean
        spec:
          containers:
          - image: funktion/connector-bean:${project.version}
            name: connector
  schema.yml: |
    ---
    component:
      kind: component
      scheme: bean
      syntax: bean:beanName
      title: Bean
      description: The bean component is for invoking Java beans from Camel.
      label: core,java
      deprecated: false
      async: false
      producerOnly: true
      javaType: org.apache.camel.component.bean.BeanComponent
      groupId: org.apache.camel
      artifactId: camel-core
      version: 2.18.3
    componentProperties: {}
    properties:
      beanName:
        kind: path
        group: producer
        required: true
        type: string
        javaType: java.lang.String
        deprecated: false
        secret: false
        description: Sets the name of the bean to invoke
        order: 0
      method:
        kind: parameter
        group: producer
        type: string
        javaType: java.lang.String
        deprecated: false
        secret: false
        description: Sets the name of the method to invoke on the bean
        order: 1
      cache:
        kind: parameter
        group: advanced
        label: advanced
        type: boolean
        javaType: boolean
        deprecated: false
        secret: false
        defaultValue: false
        description: If enabled Camel will cache the result of the first Registry look-up. Cache can be enabled if the bean in the Registry is defined as a singleton scope.
        order: 2
      multiParameterArray:
        kind: parameter
        group: advanced
        label: advanced
        type: boolean
        javaType: boolean
        deprecated: true
        secret: false
        defaultValue: false
        description: 'How to treat the parameters which are passed from the message body;
          if it is true the message body should be an array of parameters. Note: This
          option is used internally by Camel and is not intended for end users to use.'
        order: 3
      parameters:
        kind: parameter
        group: advanced
        label: advanced
        type: object
        javaType: java.util.Map<java.lang.String,java.lang.Object>
        prefix: bean.
        multiValue: true
        deprecated: false
        secret: false
        description: Used for configuring additional properties on the bean
        order: 4
      synchronous:
        kind: parameter
        group: advanced
        label: advanced
        type: boolean
        javaType: boolean
        deprecated: false
        secret: false
        defaultValue: false
        description: Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
        order: 5
  documentation.adoc: |+
    [[Bean-BeanComponent]]
    Bean Component
    ~~~~~~~~~~~~~~

    The *bean:* component binds beans to Camel message exchanges.

    [[Bean-URIformat]]
    URI format
    ^^^^^^^^^^

    [source,java]
    ---------------------
    bean:beanID[?options]
    ---------------------

    Where *beanID* can be any string which is used to look up the bean in
    the link:registry.html[Registry]

    [[Bean-Options]]
    Options
    ^^^^^^^


    // component options: START
    The Bean component has no options.
    // component options: END



    // endpoint options: START
    The Bean component supports 6 endpoint options which are listed below:

    {% raw %}
    [width="100%",cols="2,1,1m,1m,5",options="header"]
    |=======================================================================
    | Name | Group | Default | Java Type | Description
    | beanName | producer |  | String | *Required* Sets the name of the bean to invoke
    | method | producer |  | String | Sets the name of the method to invoke on the bean
    | cache | advanced | false | boolean | If enabled Camel will cache the result of the first Registry look-up. Cache can be enabled if the bean in the Registry is defined as a singleton scope.
    | multiParameterArray | advanced | false | boolean | How to treat the parameters which are passed from the message body; if it is true the message body should be an array of parameters. Note: This option is used internally by Camel and is not intended for end users to use.
    | parameters | advanced |  | Map | Used for configuring additional properties on the bean
    | synchronous | advanced | false | boolean | Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
    |=======================================================================
    {% endraw %}
    // endpoint options: END


    You can append query options to the URI in the following format,
    `?option=value&option=value&...`

    [[Bean-Using]]
    Using
    ^^^^^

    The object instance that is used to consume messages must be explicitly
    registered with the link:registry.html[Registry]. For example, if you
    are using Spring you must define the bean in the Spring configuration,
    `spring.xml`; or if you don't use Spring, by registering the bean in
    JNDI.

    Error formatting macro: snippet: java.lang.IndexOutOfBoundsException:
    Index: 20, Size: 20

    Once an endpoint has been registered, you can build Camel routes that
    use it to process exchanges.

    A *bean:* endpoint cannot be defined as the input to the route; i.e. you
    cannot consume from it, you can only route from some inbound message
    link:endpoint.html[Endpoint] to the bean endpoint as output. So consider
    using a *direct:* or *queue:* endpoint as the input.

    You can use the `createProxy()` methods on
    http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/component/bean/ProxyHelper.html[ProxyHelper]
    to create a proxy that will generate BeanExchanges and send them to any
    endpoint:

    And the same route using Spring DSL:

    [source,xml]
    ----------------------------
    <route>
       <from uri="direct:hello">
       <to uri="bean:bye"/>
    </route>
    ----------------------------

    [[Bean-Beanasendpoint]]
    Bean as endpoint
    ^^^^^^^^^^^^^^^^

    Camel also supports invoking link:bean.html[Bean] as an Endpoint. In the
    route below:

    What happens is that when the exchange is routed to the `myBean` Camel
    will use the link:bean-binding.html[Bean Binding] to invoke the bean. +
     The source for the bean is just a plain POJO:

    Camel will use link:bean-binding.html[Bean Binding] to invoke the
    `sayHello` method, by converting the Exchange's In body to the `String`
    type and storing the output of the method on the Exchange Out body.

    [[Bean-JavaDSLbeansyntax]]
    Java DSL bean syntax
    ^^^^^^^^^^^^^^^^^^^^

    Java DSL comes with syntactic sugar for the link:bean.html[Bean]
    component. Instead of specifying the bean explicitly as the endpoint
    (i.e. `to("bean:beanName")`) you can use the following syntax:

    [source,java]
    -------------------------------------------------------
    // Send message to the bean endpoint
    // and invoke method resolved using Bean Binding.
    from("direct:start").beanRef("beanName");

    // Send message to the bean endpoint
    // and invoke given method.
    from("direct:start").beanRef("beanName", "methodName");
    -------------------------------------------------------

    Instead of passing name of the reference to the bean (so that Camel will
    lookup for it in the registry), you can specify the bean itself:

    [source,java]
    ---------------------------------------------------------------
    // Send message to the given bean instance.
    from("direct:start").bean(new ExampleBean());

    // Explicit selection of bean method to be invoked.
    from("direct:start").bean(new ExampleBean(), "methodName");

    // Camel will create the instance of bean and cache it for you.
    from("direct:start").bean(ExampleBean.class);
    ---------------------------------------------------------------

    [[Bean-BeanBinding]]
    Bean Binding
    ^^^^^^^^^^^^

    How bean methods to be invoked are chosen (if they are not specified
    explicitly through the *method* parameter) and how parameter values are
    constructed from the link:message.html[Message] are all defined by the
    link:bean-binding.html[Bean Binding] mechanism which is used throughout
    all of the various link:bean-integration.html[Bean Integration]
    mechanisms in Camel.

    [[Bean-SeeAlso]]
    See Also
    ^^^^^^^^

    * link:configuring-camel.html[Configuring Camel]
    * link:component.html[Component]
    * link:endpoint.html[Endpoint]
    * link:getting-started.html[Getting Started]

    * link:class.html[Class] component
    * link:bean-binding.html[Bean Binding]
    * link:bean-integration.html[Bean Integration]

