How can I systematically determine which jars I'll need, and thus should include in my pom.xml file (I'm using maven as my project management tool)?
When learning spring, to keep things simple, added all the jars (even the ones I never used) to the classpath.
Right now for the most part, I'm guessing which jars to include. For example, I know in my spring configuration file, I have:
<tx:annotation-driven />
<context:annotation-config />
<aop:aspectj-autoproxy />
So, I guess I'll need: spring-context-x.x.x.jar, spring-tx-x.x.x.jar, spring-aop-x.x.x.jar
Thanks.
For the general problem of finding which JAR(s) contain which classes and their associated dependencies, you can try http://www.jarvana.com/jarvana/. It takes a class name as input and spits out a bunch of Maven dependencies you can use to get said class.
For Spring in particular, I believe you'll have to refer to its documentation. If you have IDE support for Maven, you can typically simply fill in the spring groupId (org.springframework) and activate autocompletion inside <artifactId></artifactId> to see which JARs are available. The main sections in the Spring docs tend to have their own separate jars.
As I'm sure you've seen, another good indicator that you'll need a separate JAR are the XML namespaces used in your applicationContext.xml file. For example, here's an XML root node from a project using aop, tx and beans:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"
default-autowire="byName">
The example above would imply that you need the spring-beans, spring-aop and spring-tx JARs (Spring's JAR naming is fairly consistent). I'm not sure if the above is always true, but it should at least give you an indication.
I see only two possible alternatives. Either:
"know what you're doing" and add the required dependencies before the fact ~or~
In doubt, don't add the dependency, let things fail and add the dependency after the fact
An easy way to completely forget about the JAR files is to use nexus.
If you're a corporation, you can set up your own Nexus server. If not, use a public server such as http://repository.sonatype.org (note: I haven't used this yet as we have our own) and search for the library.
Once you found the library, copy/paste the <dependency> ... </dependency> section into your POM file and you're good to go.
I forgot how we linked maven with the nexus server, but it's not too hard.. do a bit of searching and you're golden. No more worrying about JAR files!
Related
I was creating a simple Java project by importing 4 major jar packages of Spring(beans, core, context and expression, all are ver 5.2.6). However, IDEA kept indicating that "element bean is not allowed here" even though I checked repeatedly that the dependencies are placed correctly in the module section and restarted the IDE. The configuration is as follows:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--Creating User Object-->
<bean id = "user" class = "com.zhouss.User"><bean/> #bean is where it reports error
</beans>
And here's a snapshot of the dependency jars:
I'm a complete newbie on Spring, how do I resolve the issue?
As it turned out, it was a problem with the particular version of IDEA (2020.3, mac), I have updated to the latest version of 2022.1, mac and the error simply disappears by themselves.
I found very little info online when I tried to resolve this problem, so I find it necessary to write down my findings.
I'm trying to apply the solutions (proper XML schema resolution) mentioned here which requires me to enable Spring project nature in an existing project in STS 4. According to this, there would be a Spring Tools context menu on which one can do “Spring Tools -> Add Spring Project Nature”. I'm not seeing that menu:
My .project file has the following already:
<natures>
<nature>org.springframework.ide.eclipse.core.springnature</nature>
<nature>org.eclipse.jdt.core.javanature</nature>
<nature>org.eclipse.m2e.core.maven2Nature</nature>
<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
</natures>
What am I missing?
Update:
As per Martin's second comment, the following works:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:int="http://www.springframework.org/schema/integration"
xmlns:int-jdbc="http://www.springframework.org/schema/integration/jdbc"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration-5.0.xsd
http://www.springframework.org/schema/integration/jdbc http://www.springframework.org/schema/integration/jdbc/spring-integration-jdbc.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd">
The Spring Nature feature that you are referring to doesn't exist anymore in the STS4 public beta that you seem to use. Therefore there is no "Spring" section in the context-menu anymore that offers the Spring Nature. It is not simply not needed anymore in STS4.
The question here is: What exactly are you trying to do in STS4 that doesn't work? If something is strange and missing in STS4 that you would like to see it getting back from STS3, you should raise an issue at https://github.com/spring-projects/sts4/issues and attach a sample project that reproduces the underlying issue. I would be happy to take a more detailed look then.
As a workaround, you can go back and download the latest STS 3.9.2 distribution and work from there, it still has all the old features included.
I have this xml config
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:lang="http://www.springframework.org/schema/lang"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd">
<lang:groovy id="foo" script-source="${groovyBeanLocation}"/>
</beans>
I imported this config in my ApplicationConfig, but do not want to mix several types of configurations (java and xml).
How can I make a given configuration using java?
If you're using a Groovy class as a Spring bean, you don't need the <lang:groovy> tag at all. Just deploy your compiled class as though it was Java, and it should just work as long as you include the groovy-all jar file as a project dependency.
The <lang:groovy> tag with a script-source is for "refreshable" beans. That's where you deploy the source code (rather than the compiled version), and Spring detects changes and recompiles for you. It's how you can update code in a running application, which is cool but pretty rare.
If all you want to do is write your implementation classes in Groovy, just compile them as usual and add them to the JavaConfig files the way you would any other bean. It's all bytecodes to Spring.
I am trying to come up with a solution for managing XML configuration files for multi-environment builds that does not involve maintaining one configuration file for each environment. By XML configuration file, I mean XML files used at run-time, ie web.xml, and not the POM itself. I could of course maintain a separate XML file for each environment and then define a Maven property that contains the different file path and then have separate Maven profiles that point to the correct file path for the profile to correctly package them into the WAR/EAR/etc based upon environment, but I would prefer a different solution.
Like I am suggesting in the title, the differences are not something that can be accomplished by a simple token replacement - completely different XML structures are required in different environments. I originally tried using the maven Antrun plugin to run Ant's xmltask to add/remove/delete nodes via Xpath, but this is overly verbose and complicated to maintain, especially considering this plugin's inability to properly handle XML namespaces in a non-verbose manner.
Ideally, the XML file would like a normal template file, ie:
<x:if environment="production">
<a b="c">
<d>
</a>
</x:if>
<x:else>
<g />
</x:else>
At build time, ie during package or process-resources phases, the resultant XML file would contain only one set of XML or the other (in this example).
Note how, like I mentioned above, the node structures are completely different between environments.
Any ideas or suggestions?
There is "bean definition profiles".
Basic usage:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:c="http://www.springframework.org/schema/c"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="businessService"
class="com.c...s.springthreeone.business.SimpleBusinessServiceImpl"/>
<beans profile="dev,qa">
<bean id="constructorBean"
class="com.gordondickens.springthreeone.SimpleBean"
c:myString="Constructor Set"/>
<bean id="setterBean"
class="com.gordondickens.springthreeone.SimpleBean">
<property name="myString" value="Setter Set"/>
</bean>
</beans>
<beans profile="prod">
<bean id="setterBean"
class="com.gordondickens.springthreeone.SimpleBean">
<property name="myString" value="Setter Set - in Production YO!"/>
</bean>
</beans>
</beans>
Add to your WEB.XML for selecting active:
<context-param>
<param-name>spring.profiles.active</param-name>
<param-value>prod</param-value>
</context-param>
Or jUnit Tests:
#ActiveProfiles(profiles = "dev")
Or you could set Environment Variable/JVM Parameter:
SPRING_PROFILES_DEFAULT=dev
Oryou could set selected profile with maven:
mvn -DSPRING_PROFILES_DEFAULT=dev
You can create basic maven project with common stuff and create two projects with different web.xml and other files.
Use maven web-app overlays function to marge resources, in that case you will have one project with common files and two other projects - each for required env.
You could even make these projects as modules of another project and run required depending on maven profile.
I've been struggling with this issue for several days now. I am trying to initialize a standard Spring project with the usual spring namespaces: beans, aop, context, util... my current, very initial, beans.xml file is as follows:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xml
http://www.springframework.org/schema/context http://www.springframework.org/schema/beans/spring-context.xml
http://www.springframework.org/schema/aop http://www.springframework.org/schema/beans/spring-aop.xml
http://www.springframework.org/schema/util http://www.springframework.org/schema/beans/spring-util.xml"
</beans>
When I attempt to compile and run the project in Glassfish, I hit an IllegalStateException while invoking org.glassfish.weld.WeldDeployer. Further down it states that the XML of dependent documents must be well formed and shows the first line of one of the dependent files (e.g. spring-beans.xml) which is clearly HTML. After some further digging, I found that indeed in my mavencachedirs where these .xsd files are cached, every single one had identical HTML content referencing a 404 Not Found. I am working offline with internal maven repositories, but this should not be a problem given that my dependent Spring jar files all have the appropriate spring.schemas and spring.handlers files. It simply seems like my project is failing to recognize them.
I'm a bit new to Spring, but I feel like I've done my due diligence in researching this issue. Any suggestions that may point me in the right direction would be greatly appreciated.
UPDATE - Following some of the tips posted in Spring schemaLocation fails when there is no internet connection, I consolidated my spring.handlers and spring.schemas files into two files in src/main/resources/META-INF. Running getResource returns the consolidated version of each file in this directory. That said, this still did not resolve the problem.
UPDATE 2 - I've reproduced this issue at home. I created a new Spring project on Netbeans 7.3.1 using the following archetype:
Group ID: co.ntier
Version: 1.0.2
Artifact ID: spring-mvc-archetype
Repository: http://repo.maven.apache.org/maven2/
Once the project was created, I added a beans.xml file to the classpath and stripped it down to it's most basic form:
<?xml version="1.0" encoding="windows-1252"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
/>
I built the project and deployed to Glassfish 4.0 through NetBeans while still connected to the internet. This worked as expected with no errors. However, when I disconnected the computer from the internet and deployed again (AND cleared the cached xsd files from ...Netbeans\Cache\7.3.1\mavencachedirs), I got the following error several times:
WARNING: WELD-001210 Warning when validating file:/C:/Users/Elliott/Desktop/Development/SpringTest/target/SpringTest/WEB-INF/beans.xml#5 against xsd. schema_reference.4: Failed to read schema document 'http://www.springframework.org/schema/beans/spring-beans.xsd', because 1) could not find the document; 2) the document could not be read; 3) the root element of the document is not .
I understand that Spring is supposed to be reading from the spring.schemas and spring.handlers files to locate these resources, but it clearly isn't! I challenge anybody to attempt to reproduce this issue and demonstrate that this is actually working as it should be. Right now I'm not convinced.
PROGRESS!!
OK. I'm 90% sure I've figured out the problem. When I created the beans.xml file, Netbeans creates a nb-configuration.xml file with the following in it:
<spring-data xmlns="http://www.netbeans.org/ns/spring-data/1">
<config-files>
<config-file>beans.xml</config-file>
</config-files>
<config-file-groups/>
</spring-data>
If I create a servlet in the web.xml file:
<servlet>
<servlet-name>SpringDispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
and rename beans.xml file to SpringDispatcher-servlet.xml, the project compiles and loads the xsd files correctly, whether online or offline.
Since this worked when using the SpringDispatcher-servlet.xml, but not with beans.xml configured by Netbeans, I think it's safe to assume that when Netbeans is configured to load a spring config file through nb-configuration, it fails to reference the required spring.schemas and spring.handlers files in the classpath.
Maybe I'm completely wrong and just super noob-y when it comes to Spring (I am), but it doesn't seem like this behavior is correct. Regardless, at least I have a way to move forward now.