Is it necessary to install spring ide in eclipse to use spring security in a web application jsf2.0, although I added all the necessary .jar.
No, you can make a spring application without the ide installed. The ide just makes developing with spring easier with things like Advanced code completion, content-assist, validation, ... etc.
Related
I have very good pure Java basic knowledge. As long as there are no XML config and no project management tools involved, I am very good.
The things that really confused me are the project management tools, e.g.: Maven, Gradle.
I am learning Spring, and it is so confusing to me since it involves many XML files and there is no clear explanation for it.
I am learning Spring from this set of video tutorials, Lecture 6
Spring "Hello World".
I couldn't get a Spring hello world done because it requires a xxxxx.xml file to config the beans (Java object). To generate the XML files, I need to generate an XML file using a plugin on IntelliJ 2016.
The question is I can't find the plugin to generate a XML file for the bean by following this official tutorial. There is no such plugin called " Spring Support".
What should I do to generate the beans.xml? (The file to manage beans for Spring)
You can't enable Spring support with IntelliJ community Edition, it only available with paying version (Ultimate).
However, you can create the .xml file manually and CE version also supports it (a little bit).
To working with Spring or J2EE, you should get familiar with build tools like Maven, Gradle (or Ant in some special case). The concept is simple and you can get it easily from the official website (https://maven.apache.org/ - http://gradle.org/).
For Spring, if you are not familiar with creating a .xml file, you can use Java configuration instead or move to use Spring-boot to forget this configuration file (almost).
However, at first, I think you should get the basic concept of Spring and try to work well with .xml files configure. It'll be helpful in the future when you work with it deeply.
Let's take things one by one:
Your problem understanding builds management tools like maven and gradle. Try these links for tutorials: Maven in 5 Minutes, gradle is very advance build automation tool with continuous Integration features, you can find a good comparison between gradle and maven here.
If you are confused about spring to try this book: Spring in Action 3rd Edition (4th Edition is also available, I recommend 3rd edition as you will be able to link XML to annotations.)
You do not need any tool to generate XML files. Copy a sample spring configuration file from the internet, remove unwanted elements and write your own beans.
The Spring support plugin is a feature of IntelliJ IDEA Ultimate, which is a commercial IDE. It's not available in the free Community Edition.
You don't need any plugin to generate the beans.xml file; you can write it manually in the source code editor.
For Spring support, did you try "Spring Assistant" plugin ?
https://plugins.jetbrains.com/plugin/10229-spring-assistant
Good part it is it has active development.
Edit on Aug 21, 2020:
Seems like this plugin has no more active development. Its last release was in 2018 April.
No need to worry. We sill have some good news :-)
Its Github repository is here. We can clone the repo and make necessary changes what ever we specifically need.
I know you are asking about IntelliJ Idea but as it is a commercial tool, you should pay to let you use its plugins. Another way is using "Spring Tools for Eclipse" which is a great environment to develop Spring applications. But you need to be familiar with eclipse.
It can be downloaded from:
Spring Tools 4 for Eclipse
I'm used to writing Grails applications where my view or controller changes are automatically redeployed on save. I'm now stringing together a Spring Web-
MVC application and I'd like the same feature.
I'm using Netbeans as an IDE, Gradle as a build tool and the spring-boot plugin at the moment. I remember some talk of people using Jetty as it's so quick to restart that dynamic class reloading / deployment is no longer necessary. I've heard others mention JRebel which I used to use a few years back. I'm sure there is a more modern, spring-supported / spring-standard way of doing it.
I'd also like to know if you recommend deploying as a WAR or as a standalone executable JAR with a lightweight built-in web server.
Recommendations appreciated.
A yet unsolved challenge
It turns out that the Netbeans Gradle plugin does not support "compile on save" out-of-the box - and this means that a Java Agent won't be able to pick up the changes. The author kelemen suggested one or two approaches around this. It's a non-negotiable for me, so I decided to switch IDE's to Eclipse (terrible Gradle support), then IntelliJ Idea - which is looking very promising.
Netbeans Gradle Author Comment: https://github.com/kelemen/netbeans-gradle-project/issues/183
Alternatively, there is Jrebel, which is claimed to be able to support this Netbeans / Gradle combination. I wasn't able to get it working easily using a trial of JRebel. The JRebel support guys are there to help, so if you're willing to pay the price, it's likely that their support team will solve your problems.
JRebel: http://zeroturnaround.com/software/jrebel/
If anything changes, please comment below...
Spring class reloading is supported by HotswapAgent as well. It is free alternative to JRebel.
Spring has their own agent as well: https://github.com/spring-projects/spring-loaded. While developing why not just use embedded Tomcat/Jetty provided by Spring Boot.
We've got a product that is built on top of Spring Boot and deployed via an executable war via embedded Tomcat, but during development we've adopted the approach of developing on a hosted Tomcat so our IDEs (IntelliJ mostly) will have hot-swap / redeploy support (rather than cycling our entire app, which takes a while to boot).
We recently added spring-boot-starter-websocket to our project & have run into issues with the hosted Tomcat's classloader using the embedded Tomcat's resources and crapping out. We can get around it by using profiles and marking the embedded libs as provided so that only our CI builds include them, but it's error prone & hacky at best.
So, my question is this: is there a better way of doing things? Using the Maven plugin or the runnable class introduces problems, as the maven plugin won't hotswap and the runnable class has issues finding classpath things like JSPs (wish we had switched to Thymeleaf beforehand, but next time ;)
The requirements for a "better" development cycle would be:
Code hotswap - aka not having to restart the app / server while developing (outside of making changes to method signatures & whatnot)
Good tooling support
Easy, repeatable setup -- pretty much "checkout and run"
Thanks!
You don't need tomcat for class reloading anymore. With Spring-boot 1.2 you can just debug the maven target spring-boot:run and have class reloading.
This works for me in intellij.
I'm very new to server side programming, and I want to develop something by using java and Spring framework. I'm working in Android technology for the last two years and I'm very much familiar with Java and Eclipse IDE.
Can anyone provide me links to some useful tutorials and examples?
Which IDE will be more suitable for me? Eclipse or Netbeans?
Thanks in advance...
I think Eclipse is more suitable, Because you already know about Eclipse(Eclipse is used for android projects).
http://static.springsource.org/spring/docs/3.0.0.RELEASE/spring-framework-reference/html
http://static.springsource.org/docs/Spring-MVC-step-by-step/
It's a very vague question but I'll give you my opinion:
Learn Java EE - this includes:
JSP/JSF
Servlets
Web
EJB 3
Build an application using these technologies and only after you familiarize yourself with it, only then start using spring. Spring is using a lot of theses technologies behind the scenes and it is important to understand what is going on
Regarding eclipse vs netbeans - I'm a huge fan of eclipse and i think it is a great tool however netbeans has better integration with Glassfish (sun/oracle application server) and better GUI tools. so it is really a matter of taste.
As for web/application servers:
Tomcat is a great server to start with, but since it is a web server it does not support EJB.
For using EJB you'll need an application server like Jboss or glassfish.
I'd start with tomcat and then move to glassfish.
What IDEs are you used to? I recommend that you use STS - Spring Tool Suite, which is an Eclipse based IDE maintained by SpringSource. Alternatively, the IntelliJ IDEA Ultimate also provide good support for Spring projects.
I want to start a my first Java EE project. I have read a lot that springMVC framework is a good choice (never used though)
My earlier experience with java is not much. only some small app development using Netbeans. so I have some experience using Netbeans.
But I see that I can start a Java EE project in Netbeans. so what kind of framework netbeans is using underneath.
PS: My understanding of framework (e.g. SpringMVC) is that you follow rule of framework to configure your app. and then framework take care or linking your View, controller and model.
so if i am using netbeans, do i need to take care of linking of my MVC by myself?
I see that I can start a Java EE project in Netbeans. so what kind of framework netbeans is using underneath.
Hmm... Nothing. NetBeans is just an IDE and let you use whatever framework you want: JSF 2.0, Wicket, Struts 2, Stripes, Spring MVC, your own poison. Of course, one could say that NetBeans promotes (and supports) JSF 2.0 but this doesn't mean you can't use another framework, just add the required libraries to your project.
In any case, Spring MVC is just one options amongst others and is not an absolute requirement to write Java EE applications. Some Java EE applications don't even have a web interface actually. And believe it or not, you can write Java EE application - especially Java EE 6 applications - without Spring :)