Let's say that I have an application deployed to Tomcat. Ideally, I want to be able to undeploy said application without stopping my server and all classes that belong to the application should be cleanly unloaded from Tomcat.
But, it may happen that I've created some object somewhere that's preventing all classes from being unloaded. Is there a mechanism to list loaded classes so I can check if the application is being unloaded (undeployed) cleanly or not?
I'm aware of Tomcat's JMX interface but I haven't found any of the information I'm looking for in that.
I want to be able to undeploy said application without stopping my
server ...
Use the Admin Console also known as Tomcat Web Application Manager. It does exactly what you need: Stops particular application, unloads all its classes. Open URL your_host:port/manager/html.
Related
My web application is running in tomcat 6. We are using DOJO for UI and web services for data access.
Currently, there is a webservice available to clear/build the cache in our application.
As we are access this using a https/http, it is holding huge memory and taking much time to process.
so currently we are planning to take this process out of web services and wanted to execute as a standalone app.
I need to have a standalone (backend) application (may be main class) which should do the above activity.
The problem is that all beans used to clear/build the cache are available in application context (meaning inside the tomcat container).
I want to access the same available beans in external main class and do the process.. (possible ?)
How to get the application context outside the tomcat scope, I mean in external java class ?
Else, can i have another application (jar file with one main class file) which i will deploy it with the same application and trigger it via tomcat (possible?), so that the application context is available for the main class thereby we can access the beans/context.
Earlier in my previous project, we have used EJB home and remote interface to connect to main class (jar file with only one main class containing EJB connecting code) deployed along with the application.
But the applciation server is WEBSPHERE.
can we do the same thing in tomcat.
kindly help on this... thanks in advance for your replies...
I think it is not possible, JAVA manages its own memory, you are not allowed to manipulate the memory via another application.
I am not sure what I am asking is correct approach or not. So, let me first clarify my requirement.
Till date I was using each app as a root app and was deploying them in separate tomcat instance, but my app number are now growing and I can not keep on deploying a separate instance of tomcat for each app.
There are two things which make me deploy every app as root:
For updating an app you have to shutdown tomcat instance which will also stops other app running in same instance. And I do not want this to happen (as some users are live on one web app or some job is running on some app, so I can not stop all apps at any given time).
For writing urls, if I deploy a web app as root, then in web-app I can simply write "/students/list" , but if I deploy them in same instance with some different context name, then I have to write context name before the urls, like "ctxt1/students/list"
And for developers sake I don't want them to write context name before every url in web-app and also I don't want context names to appear to a user.
Is there any approach with which I can solve these 2 problems. I am thinking of migrating to Glassfish for some apps. If glassfish offer solution to these problems then I can migrate all apps to glassfish as well
Secondly I am running tomcat behind IIS, using ISAPI. If IIS can be of any help here?
You should not use one tomcat per App. The amount of tomcats should increase only when needed (really needed).
It is not true that you have to kill the whole tomcat, for one App update, you should only restart the specific context (going to http://your.tomcat:8080/manager/html).
About the URLs you can use an apache in front with mod_proxy_ajp configured to talk with tomcat (see this: http://httpd.apache.org/docs/2.2/mod/mod_proxy_ajp.html)
I am developing a web application in java using the Vaadin framework.
I am running that application on Apache Tomcat. What I want to ask is that, if I run that application on Apache Tomcat and access the same application using two different browsers on two different computers, then does the application then have two instances on Tomcat or does it have a single instance?? I have searched for it, but not been able to find a satisfactory answer.
Thanks !
If you run a web application in Tomcat, you'll have exactly one Tomcat instance, which will host your application. This single Tomcat instance (and therefore your web application) will be able to many different browser requests, from many different computers. This is exactly what web servers are designed to do: process requests from many different clients.
One instance of Tomcat, and many instances of your Vaadin app.
To access your Vaadin app, the user points their web browser to your Vaadin app's URL. Tomcat must already be running in order to accept the request from the web browser. When the already-running instance of Tomcat receives that request, Tomcat starts a new thread. In that thread a new instance of your subclass of the Vaadin "Application" class will be created and run.
So, if you have 5 simultaneous users running your Vaadin app, you will have one instance of Tomcat running. And that Tomcat instance will be running 5 sessions, each in its own thread running its own instance of your Vaadin "Application" subclass.
Anything marked "static" in your app applies to all 5 instances of your app, while anything not marked "static" applies only to a single instance of your app (a single user).
I have a client server application. The server is made of restful services with jersey and is deployed on tomcat 7. Actually, I need to create the context of the services (read some high sized files) before the client access to the services. Is it possible to create a main class of my webapp or not?
A web application in JavaEE doesn't have a "main class" in the same sense that a desktop application does; surely, the execution must start on a main method somewhere, but it'll be managed by the web container (Tomcat in your case) and outside of your reach.
What you can do instead, is create a servlet which preloads the data you need in the application context using its init method (assuming that the data will be the same for all the clients, and ideally, it won't be modified by them). Also, in the servlet configuration, you specify that the servlet must be loaded on startup, and in that way you make sure that the data will be loaded once at the beginning of the application, and that all the clients will be able to access it from the application context.
EDIT :
In more recent versions of the Servlet specification (2.3+) the preferred way is to use context listeners, see this answer for details.
I have a standalone java application which uses java based TCP NIO to collect some information from various clients (not on web/HTTP but through some indigenously developed middleware). Now I have to develop a front-end for the users to perform a lot of querying through HTTP. So is there a way to put this application inside tomcat, so that servlets can invoke required functions on this application ???
The thing is it has to listen on that middleware outside tomcat too and at the same time service servlets inside tomcat. How to do this ??
Putting this application outside tomcat and using RMI is an option but I don’t want to do that.
Can embedding tomcat inside my application is an option ???
The brand-new Tomcat 7 has Embedded version for download.
Tomcat is big. You should try to embed Jetty, which is meant in order to make it possible.
http://jetty.codehaus.org/jetty/
I don't know about embedding Tomcat, but you can embed a servlet container inside your application using embedded Jetty. If what you want is to add an HTTP interface to an existing server, I think that's the way to go.
It also should be perfectly workable to launch your server's TCP listening components from a standard servlet in Tomcat. Then the servlet can call methods in your existing application directly, while it continues to listen to its usual TCP ports.
A third option is to write a servlet that just talks to your existing server in the same way other clients do.
The way you want to go, is to have an embedded web server to your existing application since you just need a little bit of web functionality.
Going the other way is possible. You can use servlet listeners to get started and stopped, and you need to take great care of any thread you start since Tomcat have no idea they exist.
As Traroth said, embedding Jetty is a much better option than doing the same with Tomcat. You have an example and a small tutorial in the Jetty website:
http://docs.codehaus.org/display/JETTY/Embedding+Jetty
You can always open the ports and listen manually if the requests aren't complicated.
Have you considered going the other way? That is embedding your application inside a web application?
Using spring you can instantiate your web application and then inject in into the appropriate web classes (e.g. struts2 actions).
This way you can deploy your web application into any web server that is preconfigured separate from your application.
If you do have to use Tomcat, you're best just making your application as a .war file which when Tomcat is ran will deploy your code. This can then talk to any RMI/middleware you like.
I'm not sure I understand your comment regarding memory spaces.
At a very basic level you have two choices:
Run your appication and the web
application in the same virtual
machine.
Run your application and
the web application in a different
virtual machine
If you take approach 1, you will be able to get instances of your applications classes from the servlets and call methods on them.
Embed tomcat / jetty inside your application. You will start your application normally through its main method. After starting your app you will need to create instances of the tomcat / jetty classes which will start up their own threads.
Embed your application inside a war file to be deployed on tomcat / jetty. Similar to the previous option instead you will need to start your application from a context listener.
If you prefer approach 2; start tomcat / jetty and deploy your web app and separately deploy your application. You'll now have two jvms running. To communicate between these two processes you'll have to use some form of socket communication: OutputStream/InputStream over sockets; RMI; JMX; JMS etc.