Est-il possible de lancer un chameau itinéraire à l'aide d'une interface java ou des haricots?

J'aimerais configurer un printemps bean (soit via l'interface ou classe d'haricot). que je peux appeler à "démarrer" un Itinéraire.

Dans cet exemple simple, lorsque j'appelle la méthode sayHello("monde") du code j'aimerais qu'il voie la valeur de retour de la méthode sayHello l'extrémité qui va l'écrire dans un fichier.

Personne ne sait si cela est possible, ou comment aller à ce sujet?
Je sais que je peux exposer la même interface via CXF et de faire ce travail, mais je veux juste appeler une méthode, de ne pas passer par la peine de l'envoi d'un jms message ou d'appeler un webservice.

public interface Hello{
   public String sayHello(String value);
}

from("bean:helloBean").to("file:/data/outbox?fileName=hello.txt");

OriginalL'auteur ScArcher2 | 2010-07-29

apache-camel java

10

Oui, vous pouvez utiliser le proxy/accès distant à dos de Chameau pour ce faire.

Ensuite, lorsque vous appelez la méthode sayHello(valeur) la valeur est routé vers l'itinéraire choisi. Et la réponse de l'itinéraire est retourné à partir de la méthode sayHello.

Voir ces liens

- http://camel.apache.org/spring-remoting.html

- http://camel.apache.org/hiding-middleware.html

- http://camel.apache.org/using-camelproxy.html

Chapitre 14 du Chameau en Action ce livre couvre beaucoup plus en détail:
http://www.manning.com/ibsen

Merci de répondre à ma question. Je suppose que j'ai besoin d'obtenir une mise à jour de mon MEAP livre. Pour le Chapitre 14, il est dit à DÉTERMINER. Le livre a été très utile!

OriginalL'auteur Claus Ibsen

Vous pouvez utiliser ProducerTemplate:

import org.apache.camel.Produce;
import org.apache.camel.ProducerTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

@Component
public class HelloImpl implements Hello {

    @Produce(uri = "direct:start")
    private ProducerTemplate template;

    @Override
    public Object sayHello(String value) throws ExecutionException, InterruptedException {
        Future future = template.asyncSendBody(template.getDefaultEndpoint(), value);
        return future.get();
    }
}

et votre chameau route devrait ressembler à:

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:camel="http://camel.apache.org/schema/spring"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
         http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.mycompany.camel"/>

    <camelContext xmlns="http://camel.apache.org/schema/spring">
        <route>
            <from uri="direct:start"/>
            <to uri="log:com.mycompany.camel?level=DEBUG"/>
        </route>
    </camelContext>

</beans>

(C'est la bonne réponse).

OriginalL'auteur mokshino

J'ai besoin de regarder dans Claus réponses, mais pour un rapide et sale de l'INTERFACE utilisateur, je suis allé avec une approche différente.

J'ai été en utilisant Spring MVC 3.1.X et ont une console d'administration de plusieurs articles de ma demande. J'ai écrit un Contrôleur pour afficher les routes et leurs statuts, ainsi que des liens pour démarrer et arrêter les routes en tant que de besoin. Voici une partie du code:

@Controller
public class CamelController {
private static final Log LOG = LogFactory.getLog(CamelController.class);
@Autowired
@Qualifier("myCamelContextID")
private CamelContext camelContext;
@RequestMapping(value = "/dashboard", method = RequestMethod.GET)
public String dashboard(Model model) {
if (LOG.isDebugEnabled()) {
LOG.debug("camel context is suspended : " + camelContext.isSuspended());
}
List<Route> routes = camelContext.getRoutes();
List<RouteStatus> routeStatuses = new ArrayList<RouteStatus>();
for (Route r : routes) {
RouteStatus rs = new RouteStatus();
rs.setId(r.getId());
rs.setServiceStatus(camelContext.getRouteStatus(r.getId()));
routeStatuses.add(rs);
}
model.addAttribute("routeStatuses", routeStatuses);
return "dashboard";
}
@RequestMapping(value = "/dashboard/{routeId}/start", method = RequestMethod.GET)
public String startRoute(@PathVariable String routeId) {
try {
camelContext.startRoute(routeId);
if (LOG.isDebugEnabled()) {
LOG.debug("camel context is starting route [" + routeId + "]");
}
} catch (Exception e) {
LOG.error("failed to start camel context [" + camelContext + "]");
}
return "redirect:/dashboard";
}
@RequestMapping(value = "/dashboard/{routeId}/stop", method = RequestMethod.GET)
public String stopRoute(@PathVariable String routeId) {
try {
camelContext.stopRoute(routeId);
if (LOG.isDebugEnabled()) {
LOG.debug("camel context is stopping route [" + routeId + "]");
}
} catch (Exception e) {
LOG.error("failed to stop camel context [" + camelContext + "]");
}
return "redirect:/dashboard";
}
}
}

Il y a un peu de POJO j'ai fait pour aller avec elle:

public class RouteStatus {
private String id;
private ServiceStatus serviceStatus;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public ServiceStatus getServiceStatus() {
return serviceStatus;
}
public void setServiceStatus(ServiceStatus serviceStatus) {
this.serviceStatus = serviceStatus;
}
}

OriginalL'auteur Greg

1

Aucun des autres répondu a fonctionné pour moi, ils ont tous été construits et sont valables, mais les routes n'ont pas de déclenchement.

C'est la solution que j'ai utilisé:
```
import org.apache.camel.Handler;
public class Hello{
@Produce(uri = "direct:start")
private ProducerTemplate producer;
@Handler   
public void sayHello() {
producer.sendBody("hello")
}
}
from("timer:hubspotContacts?repeatCount=1").bean(Hello.class);
from("direct:start").to("log:hello");
```
- La minuterie composant à partir de la première route a été la clé de la partie manquante pour moi. Avec repeatCount=1 il déclenche exactement une seule fois, au démarrage et les causes de la fève méthode à appeler. Il supporte également un taux d'appel ou de retard si vous avez besoin de la méthode est appelée plusieurs fois.
- la @Handler annotations sert de marqueur de sorte que le nom de la méthode n'a pas à être explicite dans la voie de la configuration
- la direct composant relie les producteurs avec les consommateurs
OriginalL'auteur Alpar
0

Depuis mes itinéraires ont été printemps composants à l'aide de CamelConfiguration. Je l'ai fait pour utiliser mon interface en chameau routes.
```
@Component
public class SomeRoute extends RouteBuilder {
@Autowired
private ApplicationContext applicationContext;
@Override
public void configure() throws Exception {
from("direct:someroute")
.bean(applicationContext.getBean(SomeInterface.class).getClass(), "someAbstractMethod")
.to("direct:otherroute");
}
}
```
C'était très simple, si vous avez plusieurs de haricots à l'aide de la même interface ou une classe abstraite, vous devrez sans doute faire un peu de logique avant d'utiliser .getClass() sur le haricot.

OriginalL'auteur Yogesh

Vous devez vous connecter pour publier un commentaire.