> If using maven... [I'm not]... If not, please give us more detail about 
what you are using (or intend to use).
After further investigation, much of my issues around this seem to be that 
the. appropriate java command to run the web app (or Jetty itself) is not 
being assembled correctly by either Eclipse, the GWT plugin, or both. 
 There are various options that are needed and are not properly set.  That 
said, even if I do/can get that working, I don't think that's the right 
approach.  As you're going to deprecate the embedded Jetty server, I should 
do whatever is needed there to run my own external server(s).  That's 
what's unclear to me.  There are ancient references to it in the 
documentation at gwt.project.org, but I'm unclear on what is really needed. 
 Do I need to set up and run a code server with my own Jetty or Tomcat 
local installation?  If so, how is that set up?  Or do I need to run my own 
app server (again, either Jetty or Tomcat).  The web app setup is obvious 
(I think... or are there special runtime parameters to direct it to the 
proper code server port?).  Forgive my ignorance on this, but if this is 
the path forward for GWT in general, I'd really like to see some clear 
documentation on how to set this up or at least what it is going to look 
like (in general, no specifics, obviously it should involve thinking and 
work on my part). Last note: I am assuming the code server will be easier 
to get working with Java 17 modules because it will (in my case) have less 
jar dependencies, as it only needs them for shared and client code.  That 
said... I might need to run both externally to get it all sorted out. 
 Again, my own thinking on this isn't that clear because I'm not in the 
weeds enough on what the plugin is really doing and how things work under 
the hood.

To give a shorter, more direct answer: I want to develop code in Eclipse in 
Java 17, and be able to run the code server and web app any way possible, 
so that GWT code compiles/recompiles as needed, and the web app can be 
accessed in the browser, and I can do iterative test-code-test-code 
development on a daily basis.


Traditionally GWT SDK only had the class com.google.gwt.dev.DevMode. It is 
responsible to launch classic dev mode (the one that does require an 
obsolete browser plugin) or SuperDevMode together with an embedded servlet 
container, by default Jetty. SuperDevMode is implemented in class 
com.google.gwt.dev.codeserver.CodeServer and DevMode basically calls this 
class if you request it to launch SuperDevMode (which is the default 
behavior). Class DevMode has a parameter "-noserver" which skips starting 
Jetty and assumes you have your own server and deployment running. Because 
we advocate running your own servlet container, e.g. Jetty/Tomcat/..., it 
is enough to just launch CodeServer yourself. However you could also 
continue to use class DevMode and replace the embedded Jetty with your own 
implementation using DevMode -server your.impl.of.ServletContainerLauncher. 
Your own implementation could then be based on Jetty 12 for example (and 
possibly jakarta)

Personally I use Gradle and have a task that just launches CodeServer by 
executing a command line. I am pretty sure you could also write a similar 
ANT task using your current ANT setup. The command line looks like 

com.google.gwt.dev.codeserver.CodeServer -sourceLevel 11 -strict 
-failOnError - bindAddress 0.0.0.0 -port 9876 -style PRETTY 
-XmethodNameDisplayMode ABBREVIATED -workDir /client-project/build/gwt/work 
-launcherDir /client-project/build/gwt/war -src 
/shared-project/src/main/java -src /shared-project/src/main/resources 
com.example.MyGwtModule

The classpath should contain gwt-user/gwt-dev/gwt-codeserver, all 
compile-time dependencies you need for GWT compilation as well as classes + 
sources + resources related to your GWT UI and DTOs. You would need to use 
ANT fileset/dirset/files to include/exclude only the files of your single 
project that are relevant for GWT compilation. Once you have that set of 
files figured out you can run GWT CodeServer in isolation via ANT with its 
own GWT focused classpath and you should not have any trouble with other 
dependencies that you need on the server only.

Once you have that running, you need to decide how you want to run a 
servlet container. Personaly I use Docker + docker-compose + Jetty image + 
shell script.

 

-- 
You received this message because you are subscribed to the Google Groups "GWT 
Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to [email protected].
To view this discussion on the web visit 
https://groups.google.com/d/msgid/google-web-toolkit/3a1c5304-b647-4fec-aba2-a557ad78834en%40googlegroups.com.

Reply via email to