You are viewing a plain text version of this content. The canonical link for it is here.
Posted to users@activemq.apache.org by Mirage16 <da...@hotmail.com> on 2014/06/25 02:45:02 UTC
project not running
Hej everyone,
I've a ready java project. It's supposed to be a small online shop.
Therefore JMS is used.
Now I'm tryjing to make the project run on my pc.
Therefore I've installed ActiveMQ on my pc as descriped on the website:
http://activemq.apache.org/getting-started.html
I can run the server. Everything fine till this step.
The problem ist, that I can not figure out, how to make the projekt run
successfuly.
Here is the code for the sender:
package client;
import java.util.List;
import java.util.Map;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.ObjectMessage;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueReceiver;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.jms.TemporaryQueue;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import client.requestCommand.BestellungAufgebenRequestCommand;
import client.requestCommand.BestellungStornierenRequestCommand;
import client.requestCommand.GetAlleArtikelRequestCommand;
import client.requestCommand.GetAlleBestellungenRequestCommand;
import client.requestCommand.GetEinzelneBestellungRequestCommand;
import client.requestCommand.GetKundendatenRequestCommand;
import client.requestCommand.IstKundeEingeloggtRequestCommand;
import client.requestCommand.LoginRequestCommand;
import client.requestCommand.LogoutRequestCommand;
import client.requestCommand.RequestCommand;
import
client.requestCommand.ueberpruefeObArtikelnummerInArtikelKarteiRequestCommand;
import
client.requestCommand.ueberpruefeObBestellnummerInBestellKarteiRequestCommand;
import model.Artikel;
import model.Bestellposition;
import model.Bestellung;
import model.Kunde;
import service.OrderManager;
/**
* @author
*
* Erstellungsdatum: 08.05.2014
*
* Repräsentiert die clientseitige OrderManager_JMS_Adapterklasse. Der
Client spricht über die Menu-Commands
* die OrderManagerJmsClientAdapter-Klasse an und ruft darüber
Request-Commands auf, welche dann in Form einer
* ObjectMessage über ActiveMQ zum Server geschickt werden.
*
* Die serverseitige OrderManager_JMS_Adapterklasse ist mit einem
Listener versehen und "horcht" ständig nach
* Anfragen. Sobald sie einen Request-Command bekommt führt sie bzw. der
enthaltene OrderManager diese Reqeust-
* Commands aus und sendet das Ergebnis wieder an die
JMS_Client_Adapterklasse zurück.
*
* Das Ergebnis gelangt dann so über den OrderManagerJmsClientAdapter
wieder zum Client-Menü.
*
*/
public class OrderManagerJmsAdapterClient implements OrderManager
{
private static final String DESTINATION = "queue/myQueue1";
private static final String USER = "guest";
private static final String PASSWORD = "guest";
private QueueConnectionFactory factory;
private Queue queue;
private QueueConnection connection;
private QueueSession session;
/**
* JNDI Kontext wird erzeugt, die ConnectionsFactory und Zieladresse
über den Namensdienst ausgelesen
*
* @throws NamingException
* @throws JMSException
*/
public OrderManagerJmsAdapterClient() throws NamingException,
JMSException
{
Context ctx = new InitialContext();
factory = (QueueConnectionFactory)
ctx.lookup("ConnectionFactory");
queue = (Queue) ctx.lookup(DESTINATION);
}
/**
* Die Verbindung zum Server wird aufgebaut. Eine Session und ein
Receiver werden erzeugt.
* Die zu ausführenden RequestCommands werden dann zum Server
geschickt.
*
* Es wird außerdem eine temporäre Queue für die Antwort erzeugt. Es
wird nun auf eine
* Antwort gewartet. Der Server wird die Antwort über die temporäre
Queue schicken.
*
* Am Schluss werden alle Ressourcen wieder freigegeben.
*
* @param command Der auszuführende RequestCommand
* @return response Die Antwort vom Server
*/
private Message MessageSendenUndWartenAufEmpfang(RequestCommand
command)
{
Message response = null;
TemporaryQueue tempQueue = null;
QueueReceiver receiver = null;
QueueSender sender = null;
try
{
connection = factory.createQueueConnection(USER, PASSWORD);
session = connection.createQueueSession(false,
Session.AUTO_ACKNOWLEDGE);
tempQueue = session.createTemporaryQueue();
sender = session.createSender(queue);
receiver = session.createReceiver(tempQueue);
connection.start();
ObjectMessage request = session.createObjectMessage();
request.setObject(command);
request.setJMSReplyTo(tempQueue);
sender.send(request);
response = receiver.receive();
}
catch (JMSException e)
{
e.printStackTrace();
}
finally
{
try
{
sender.close();
receiver.close();
tempQueue.delete();
session.close();
connection.close();
}
catch (JMSException e)
{
e.printStackTrace();
}
}
return response;
}
/**
* {@inheritDoc}
*/
public boolean bestellungAufgeben(Map<Integer, Integer>
artikelUndAnzahl)
{
try
{
ObjectMessage response = (ObjectMessage)
MessageSendenUndWartenAufEmpfang(new
BestellungAufgebenRequestCommand(artikelUndAnzahl));
if ((Boolean) response.getObject())
{
return true;
}
}
catch (JMSException e)
{
e.printStackTrace();
}
return false;
}
/**
* {@inheritDoc}
*/
public Map<Integer, Bestellung> bestellungenAnzeigen()
{
Map<Integer, Bestellung> alleBestellungen = null;
try
{
ObjectMessage response = (ObjectMessage)
MessageSendenUndWartenAufEmpfang(new GetAlleBestellungenRequestCommand());
alleBestellungen = (Map<Integer, Bestellung>)
response.getObject();
}
catch (JMSException e)
{
e.printStackTrace();
}
return alleBestellungen;
}
/**
* {@inheritDoc}
*/
public List<Bestellposition> getEinzelneBestellung(int
bestellnummer)
{
List<Bestellposition> alleBestellpositionen = null;
try
{
ObjectMessage response = (ObjectMessage)
MessageSendenUndWartenAufEmpfang(new
GetEinzelneBestellungRequestCommand(bestellnummer));
alleBestellpositionen = (List<Bestellposition>)
response.getObject();
}
catch (JMSException e)
{
e.printStackTrace();
}
return alleBestellpositionen;
}
/**
* {@inheritDoc}
*/
public boolean bestellungStornieren(int bestellnummer)
{
try
{
ObjectMessage response = (ObjectMessage)
MessageSendenUndWartenAufEmpfang(new
BestellungStornierenRequestCommand(bestellnummer));
if ((Boolean) response.getObject())
{
return true;
}
}
catch (JMSException e)
{
e.printStackTrace();
}
return false;
}
/**
* {@inheritDoc}
*/
public Kunde getKundendaten()
{
Kunde derKunde = null;
try
{
ObjectMessage response = (ObjectMessage)
MessageSendenUndWartenAufEmpfang(new GetKundendatenRequestCommand());
derKunde = (Kunde) response.getObject();
}
catch (JMSException e)
{
e.printStackTrace();
}
return derKunde;
}
/**
* {@inheritDoc}
*/
public List<Artikel> getAlleArtikel()
{
List<Artikel> alleArtikel = null;
try
{
ObjectMessage response = (ObjectMessage)
MessageSendenUndWartenAufEmpfang(new GetAlleArtikelRequestCommand());
alleArtikel = (List<Artikel>) response.getObject();
}
catch (JMSException e)
{
e.printStackTrace();
}
return alleArtikel;
}
/**
* {@inheritDoc}
*/
public boolean login(String userName, String passwort)
{
try
{
ObjectMessage response = (ObjectMessage)
MessageSendenUndWartenAufEmpfang(new LoginRequestCommand(userName,
passwort));
if ((Boolean) response.getObject())
{
return true;
}
}
catch (JMSException e)
{
e.printStackTrace();
}
return false;
}
/**
* {@inheritDoc}
*/
public boolean logout()
{
try
{
ObjectMessage response = (ObjectMessage)
MessageSendenUndWartenAufEmpfang(new LogoutRequestCommand());
if ((Boolean) response.getObject())
{
return true;
}
}
catch (JMSException e)
{
e.printStackTrace();
}
return false;
}
/**
* {@inheritDoc}
*/
public boolean istKundeEingeloggt()
{
try
{
ObjectMessage response = (ObjectMessage)
MessageSendenUndWartenAufEmpfang(new IstKundeEingeloggtRequestCommand());
if ((Boolean) response.getObject())
{
return true;
}
}
catch (JMSException e)
{
e.printStackTrace();
}
return false;
}
/**
* {@inheritDoc}
*/
public boolean ueberpruefeObArtikelnummerInArtikelKartei(int
artikelnummer)
{
try
{
ObjectMessage response = (ObjectMessage)
MessageSendenUndWartenAufEmpfang(new
ueberpruefeObArtikelnummerInArtikelKarteiRequestCommand(artikelnummer));
if ((Boolean) response.getObject())
{
return true;
}
}
catch (JMSException e)
{
e.printStackTrace();
}
return false;
}
/**
* {@inheritDoc}
*/
public boolean ueberpruefeObBestellnummerInBestellKartei(int
bestellnummer)
{
try
{
ObjectMessage response = (ObjectMessage)
MessageSendenUndWartenAufEmpfang(new
ueberpruefeObBestellnummerInBestellKarteiRequestCommand(bestellnummer));
if ((Boolean) response.getObject())
{
return true;
}
}
catch (JMSException e)
{
e.printStackTrace();
}
return false;
}
}
Here I've got some problems:
tempQueue = session.createTemporaryQueue();
The method createTemporaryQueue() is undefined for the type QueueSession
sender = session.createSender(queue);
The method createSender(Queue) is undefined for the type QueueSession
receiver = session.createReceiver(tempQueue);
The method createReceiver(TemporaryQueue) is undefined for the type
QueueSession
ObjectMessage request = session.createObjectMessage();
-The method createObjectMessage() is undefined for the type QueueSession
Here is the code for the receiver:
package main;
import java.io.Serializable;
import javax.jms.JMSException;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueReceiver;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import client.requestCommand.RequestCommand;
import service.OrderManager;
/**
* @author
*
* Repräsentiert die serverseitige OrderManager_JMS_Adapterklasse.
*
* Die serverseitige OrderManager_JMS_Adapterklasse ist mit einem Listener
versehen und "horcht" ständig nach
* Anfragen. Sobald sie einen Request-Command bekommt führt sie bzw. der
enthaltene OrderManager diese Reqeust-
* Commands aus und sendet das Ergebnis wieder an die
JMS_Client_Adapterklasse zurück.
*
*/
public class OrderManagerJmsAdapterServer
{
private static final String DESTINATION = "queue/myQueue1";
private static final String USER = "guest";
private static final String PASSWORD = "guest";
private QueueConnectionFactory factory;
private Queue queue;
private OrderManager orderManager;
private QueueSession session;
private ObjectMessage objectRequest;
/**
* JNDI Kontext wird erzeugt, die ConnectionsFactory und Zieladresse
über den Namensdienst auslesen
*
* @param orderManager Der OrderManager
* @throws NamingException
* @throws JMSException
*/
public OrderManagerJmsAdapterServer(OrderManager orderManager) throws
NamingException, JMSException
{
this.orderManager = orderManager;
Context ctx = new InitialContext();
factory = (QueueConnectionFactory) ctx.lookup("ConnectionFactory");
queue = (Queue) ctx.lookup(DESTINATION);
serverStartenUndaufEingehendeObjectMessagesWarten();
}
/**
* Die Verbindung zum Server wird aufgebaut. Eine Session und Receiver
wird erzeugt.
* Der Server horcht nach eingehenden Messages.
*
* @throws JMSException
*/
public void serverStartenUndaufEingehendeObjectMessagesWarten() throws
JMSException
{
QueueConnection connection = factory.createQueueConnection(USER,
PASSWORD);
session = connection.createQueueSession(false,
Session.AUTO_ACKNOWLEDGE);
QueueReceiver receiver = session.createReceiver(queue);
connection.start();
System.out.println("----------Server gestartet----------");
while (true)
{
objectRequest = (ObjectMessage) receiver.receive();
kommandosAusfuehrenUndErgebnisZurueck((RequestCommand)
objectRequest.getObject());
}
}
/**
* Die einkommenden RequestCommands werden über den OrderManager
ausgeführt. Das Ergebnis
* wird dann über die vom Client erzeugte temporäre Queue zurück zum
Client gesendet.
* @param objekt
*/
private void kommandosAusfuehrenUndErgebnisZurueck(RequestCommand
objekt)
{
objekt.setOrderManager(orderManager);
Object objektAusfuehren = objekt.execute();
Queue tempQueue;
try
{
tempQueue = (Queue) objectRequest.getJMSReplyTo();
ObjectMessage response = session.createObjectMessage();
response.setObject((Serializable) objektAusfuehren);
QueueSender sender = session.createSender(tempQueue);
sender.send(response);
}
catch (JMSException e)
{
e.printStackTrace();
}
}
}
The method createReceiver(Queue) is undefined for the type QueueSession
QueueReceiver receiver = session.createReceiver(queue);
I would be very thanfull, if you could help me to fix the project.
I've uploaded the whole project on my dropbox. Check it out, if you like to
help me: https://www.dropbox.com/s/b4clafl4oun56mw/JMS_ACTIVEMQ.zip
Regards, Mirage16
--
View this message in context: http://activemq.2283324.n4.nabble.com/project-not-running-tp4682456.html
Sent from the ActiveMQ - User mailing list archive at Nabble.com.