Develop Reference

How do I resolve “Element bean is not allowed here” when configuring the XML file?

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.

Maven builds for different environments using xml templating - differences too complicated for simply properties or token replacement

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.

Maven+Spring Project failing to load dependent xsd files

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.

"No persistence unit with name 'product' found"

I recently completed this tutorial: "http://static.springsource.org/docs/Spring-MVC-step-by-step/", but now I want it to work with Hibernate and annotations. I know I'm close but I've hit a roadblock and I can't figure it out. I've posted my code on the Spring forums here. I would greatly appreciate ANY help. Thanks
I'm trying to incorporate annotations and hibernate into it, but I've run into a problem and I can't figure it out. I keep getting errors of "No persistence unit with name 'product' found". ANY help would be greatly appreciated.

You need a META-INF/persistence.xml, with <persistence-unit name="product">. See here
(I usually put it in WEB-INF/classes/META-INF. As noted in the comments, with maven you can place it in src/main/resources/META-INF)

this is a example of file persistence.xml
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
version="2.0">
<persistence-unit name="poduct" transaction-type="RESOURCE_LOCAL">
</persistence-unit>
</persistence>
create this file inside "src/main/resources/META-INF" if you use Maven project.

I run onto the same problem and had to manually edit the Web Deployment Assembly Configuration so as to instruct /META-INF/persistence.xml to be deployed under WEB-INF/classes/ (the red box in the attached img was manually edited)

i have the same problem. But when you use the ide(for example eclipse) and configure your server in the ide. When you asosiate the piece and restart the server always have the same error because detected the persistence unit is used, you need delete that part of the server and deploy to the oldway. Enter to the console and install the peace of you project and works!!
And the other is when you check the diagnostic in wls you need said who user is the owner of the jdbc, only select and check (for example, AdminServer) and save and check again!!
:D

How to figure out which jars are needed?

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!