⑴ java中spring框架中的beanConfig.xml配置文件放在哪里呢
这个不是一定的，随你自己的意思，你可以放在WEB-INF里，也可以放在classpath下。只需在配置web.xml时指定位置即可。
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath:beans.xml
</param-value>
</context-param>
上面就是web.xml中对spring容器的初始化配置，<context-param>中<param-value>中的classpath:beans.xml 即是spring配置文件beans.xml的位置（classpath下，在myeclipse的工程中是src目录下）
⑵ 想请问大仙 bean.xml 文件是配置在哪个路径下的呀 WEB-INF 路径下还是 src 或者其他路径呀
放哪都可以。不过如果你放在别的地方，在spring里面取就得ApplicationContext c1 = new (new String[] {"../beans.xml"});就得给bean.xml把路径带上。
⑶ J2ee中的S2SH怎么获取一个Bean，Bean是已经配置在applicationContext.xml文件中的，暂时还不想用注解
你说的两个问题其实是一个问题，sessionFactory本身也是一个Bean，无非是一个是你自己写的，一个不是，但是原理一样，在j2ee中都不用写那一长串代码，不知道你是否学过spring的依赖注入，感觉似乎是没学，推荐你看一下，在applicationContext.xml中配置好以后，只要在web.xml中加载spring的这些配置文件，那么服务器会自动将你的applicationContext中所有配置类自动注入进你的项目，就相当于帮你完成了，new Bean()的工作，直接拿来用就好了，举个例子
public class Bean1{
private Bean2 b = null;
public func(){
对b进行一对操作（不需要写b = new Bean2()，直接用，因为spring已经帮你注入了 ）
}
b的get/set方法（一定要有，注解的话可以不要）
}
相应配置
<bean id = "Bean1" class = "Bean1的项目路径" >
<property name="b" ref="Bean2"></property>
</bean>
<bean id = "Bean2" class = "Bean2的项目路径" >
</bean>
还有问题，欢迎追问
⑷ 关于java bean的配置，应该放在哪个文件夹下呢
放在SRC文件夹下，最好新建一个包，将这个文件放在一个包里面，包命名为Entity就可以了
⑸ bean是怎么配置的
本篇文章是对在Java中如何获取Spring中配置的bean进行了详细的分析介绍，需要的朋友参考下
一、什么是Spring？
Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架
二、如何在程序中获取Spring配置的bean呢？
方法一：在初始化时保存ApplicationContext对象
代码：
复制代码 代码如下:
ApplicationContext ac = new ("applicationContext.xml");
ac.getBean("beanId");
说明：这种方式适用于采用Spring框架的独立应用程序，需要程序通过配置文件手工初始化Spring的情况。
方法二：通过Spring提供的工具类获取ApplicationContext对象
代码：
复制代码 代码如下:
import org.springframework.web.context.support.WebApplicationContextUtils;
ApplicationContext ac1 = WebApplicationContextUtils
.(ServletContext sc)
ApplicationContext ac2 = WebApplicationContextUtils
.getWebApplicationContext(ServletContext sc)
ac1.getBean("beanId");
ac2.getBean("beanId");
方法三：继承自抽象类ApplicationObjectSupport
说 明：抽象类ApplicationObjectSupport提供getApplicationContext()方法，可以方便的获取到 ApplicationContext。Spring初始化时，会通过该抽象类的 setApplicationContext(ApplicationContext context)方法将ApplicationContext 对象注入。
方法四：继承自抽象类WebApplicationObjectSupport
说明：类似方法三，调用getWebApplicationContext()获取WebApplicationContext
方法五：实现接口ApplicationContextAware
说明：实现该接口的setApplicationContext(ApplicationContext context)方法，并保存ApplicationContext 对象。Spring初始化时，会通过该方法将ApplicationContext 对象注入。
⑹ java bean文件放哪才能被检测到
默认情况，tomcat_home下的webapp目录下：新建个文件夹（名字随便）
比如叫javatest，在javatest下再新建个文件夹叫WEB-INF，再在WEB-INF下建立classes文件夹.编译过的java文件就是放到这个文件夹下
但是，只用java文件放到tomcat里似乎什么也做不了
还得在javatest这个文件夹下建立相应的文件（可以看做访问java文件的入口）
也就是JSP文件，在JSP文件里有相应的调用javabean的方法，假设JSP名叫：test.jsp
然后在IE上访问http://localhost:8080/javatest/test.jsp
⑺ java bean应该放在哪里
java bean就是你源文件的一部分，当然要跟其他的类放在一块，当编译成功后，会自动生成class文件，它会自动保存在WEB-INF/class目录下。调用时也会自动来此寻找。
⑻ java bean的存放目录
classes下面放的是编译过的.class文件而不是java文件我觉得你的文件路径有问题我给你举个例子比如一个login程序应该是
\webapps\login
\webapps\login\META-INF
\webapps\login\WEB-INF
\webapps\login\WEB-INF\classes
而你的确是\webapps\ROOT\WEB-INF\classes即使直接放在root下也应该是
\webapps\ROOT\login\WEB-INF\classes中间少了一级目录吧
当你要部署的工程夺得时候我觉得放在root下面不怎么好，比较乱。
还是放再webapp下面比较好让我们的root保持一个比较整洁的面貌
也比较利于整理！
我曾经试过直接放到root下不怎么好用
或者你把你的工程打成war包放在root下看好不好！
⑼ spring 配置的bean在什么创建
在配置文件在resource目录下时，可以直接如下配置：
<build/>
<filters>
<filter>${project.basedir}/src/main/resources/environment/env-${profiles.active}.properties</filter>
</filters>
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
</build>
⑽ java怎么配置spring的bean
众所周知，Spring 框架是控制反转 (IOC) 或依赖性注入 (DI) 模式的推动因素，而这种推动是通过基于容器的配置实现的。过去，Spring 允许开发人员使用基于 XML 的配置，通过利用应用程序上下文 XML 文件来管理 bean 依赖性。此文件处于应用程序的外部，包含 bean 及其与该应用程序的依赖项的定义。尽管使用 XML 配置较为简单和便捷，但仍有另外一种方法可定义 bean 及其依赖项。这种方法也称为基于 Java 的配置。不同于 XML，基于 Java 的配置使您能够以编程方式管理 bean。这可通过运用多种注释来实现。 这篇文章将演示 Java 配置示例，并将其与传统 XML 配置方法相对比。本文将按照如下步骤演示基于 Java 的配置的基本用法：
理解 @Configuration 和 @Bean 注释
使用 注册配置类
配置 Web 应用程序
实现 bean 生命周期回调和范围
我们将使用一所在线大学的 “创建课程” 用例。在创建课程的过程中，还会创建主题或者模块，而各主题可能又有着不同的作业。因此，我们要创建三个 bean，分别为 Course、Mole 和 Assignment。Course bean 将包含一个对 Mole bean 的引用，后者包含对 Assignment bean 的引用。
理解 @Configuration 和 @Bean 注释
在理想的场景中，您可以在表示应用程序上下文的 XML 中定义 bean。以下代码展示了创建课程 用例中的上下文 XML 及 bean 定义：
清单 1. XML 与 bean 定义
<beans>
<bean id="course" class="demo.Course">
<property name="mole" ref="mole"/>
</bean>
<bean id="mole" class="demo.Mole">
<property name="assignment" ref="assignment"/>
</bean>
<bean id="assignment" class="demo.Assignment" />
</beans>
以上 XML 就是您在使用 Spring 配置 bean 时通常会编写的代码。这段 XML 代码定义了 Course bean，它引用 Mole bean。Mole bean 有一个 Assignment bean 的引用。您现在要删除这段 XML，编写同等效果的 Java 代码。您将使用基于 Java 的配置定义上面指定的 bean。我们会将 XML 替换为 Java 类，这个 Java 类现在将用作 bean 配置的平台。我们将这个类命名为 AppContext.java。以下代码展示了 AppContext类。
清单 2. 包含 bean 定义的 AppContext 配置类
@Configuration
public class AppContext {
@Bean
public Course course() {
Course course = new Course();
course.setMole(mole());
return course;
}
@Bean
public Mole mole() {
Mole mole = new Mole();
mole.setAssignment(assignment());
return mole;
}
@Bean
public Assignment assignment() {
return new Assignment();
}
}
正如您通过以上代码所看到的那样，现在可以以编程的方式将 bean 定义为基于 Java 的配置的一部分。AppContext 类现在就像 XML 一样表示配置类。这是通过利用 @Configuration 注释实现的。@Configuration 注释位于类的顶端。它告知 Spring 容器这个类是一个拥有 bean 定义和依赖项的配置类。@Bean 注释用于定义 bean。上述注释位于实例化 bean 并设置依赖项的方法上方。方法名称与 bean id 或默认名称相同。该方法的返回类型是向 Spring 应用程序上下文注册的 bean。您可使用 bean 的 setter 方法来设置依赖项，容器将调用它们来连接相关项。基于 Java 的配置也被视为基于注释的配置。
使用 注册配置类
在传统 XML 方法中，您可使用 类来加载外部 XML 上下文文件。但在使用基于 Java 的配置时，有一个 类。 类是 ApplicationContext 接口的一个实现，使您能够注册所注释的配置类。此处的配置类是使用 @Configuration 注释声明的 AppContext。在注册了所述类之后，@Bean 注释的方法返回的所有 bean 类型也会得到注册。以下代码演示了 类的使用：
清单 3. 使用 注册 AppContext 类
public static void main(String[] args) {
ApplicationContext ctx = new (AppContext.class);
Course course = ctx.getBean(Course.class);
course.getName();
}
正如以上代码所示，AppContext 配置类的注册方式是将其传递给 构造函数。此外，您还可以使用所述上下文类的 register 方法来注册配置类。以下代码展示了另外一种方法。
清单 4. 注册 AppContext 类：另外一种方法
public static void main(String[] args) {
ApplicationContext ctx = new ();
ctx.register(AppContext.class)
}
注册配置类将自动注册 @Bean 注释的方法名称，因而其对应的 bean 就是 Course、Mole 和 Assignment。随后您可以使用 getBean 方法来获取相关的 bean，并调用其业务方法。如您所见，编写 Java 的配置类并将其注册到 Spring 上下文非常简单。下一节将讨论如何将基于 Java 的配置与 Web 应用程序配合使用。
配置 Web 应用程序
过去，您通常要利用 XmlWebApplicationContext 上下文来配置 Spring Web 应用程序，即在 Web 部署描述符文件 web.xml 中指定外部 XML 上下文文件的路径。XMLWebApplicationContext 是 Web 应用程序使用的默认上下文类。以下代码描述了 web.xml 中指向将由ContextLoaderListener 监听器类载入的外部 XML 上下文文件的元素。
清单 5. 使用外部 XML 上下文文件的 web.xml
<web-app>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>sampleServlet</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
</servlet>
...
</web-app>
现在，您要将 web.xml 中的上述代码更改为使用 类。切记，XmlWebApplicationContext 是 Spring 为 Web 应用程序使用的默认上下文实现，因此您永远不必在您的 web.xml 文件中显式指定这个上下文类。现在，您将使用基于 Java 的配置，因此在配置 Web 应用程序时，需要在 web.xml 文件中指定 类。上述代码将修改如下：
清单 6. 修改后的使用 的 web.xml
<web-app>
<context-param>
<param-name>contextClass</param-name>
<param-value>
org.springframework.web.context.
support.
</param-value>
</context-param>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
demo.AppContext
</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>sampleServlet</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param>
<param-name>contextClass</param-name>
<param-value>
org.springframework.web.context.
support.
</param-value>
</init-param>
</servlet>
...
</web-app>
以上修改后的 web.xml 现在定义了 上下文类，并将其作为上下文参数和 servlet 元素的一部分。上下文配置位置现在指向 AppContext 配置类。这非常简单。下一节将演示 bean 的生命周期回调和范围的实现。
实现 bean 生命周期回调和范围
生命周期回调
您还可以使用基于 Java 的配置来管理 bean 的生命周期。@Bean 支持两种属性，即 initMethod 和 destroyMethod，这些属性可用于定义生命周期方法。在实例化 bean 或即将销毁它时，容器便可调用生命周期方法。生命周期方法也称为回调方法，因为它将由容器调用。使用 @Bean注释注册的 bean 也支持 JSR-250 规定的标准 @PostConstruct 和 @PreDestroy 注释。如果您正在使用 XML 方法来定义 bean，那么就应该使用 bean 元素来定义生命周期回调方法。以下代码显示了在 XML 配置中通常使用 bean 元素定义回调的方法。
清单 7. 使用 XML 方法实现生命周期回调
<bean id="course" class="demo.Course" init-method="setup" destroy-method="cleanup" >
<property name="mole" ref="mole"/>
</bean>
以下代码演示了使用 Java 配置的生命周期方法
清单 8. 使用 AppContext 配置类实现 bean 生命周期方法
@Configuration
public class AppContext {
@Bean(initMethod = "setup", destroyMethod = "cleanup")
public Course course() {
Course course = new Course();
course.setMole(mole());
return course;
}
@Bean(initMethod = "setup", destroyMethod = "cleanup")
public Mole mole() {
Mole mole = new Mole();
mole.setAssignment(assignment());
return mole;
}
...
}
public class Course {
private Mole mole;
private String name;
public Course() {
}
public void setup() {
this.name = "M100 Pythagoras Theorems"
}
public void setMole(Mole mole) {
this.mole = mole;
}
public void cleanup() {
mole = null;
}
}
上面的代码重新访问了 AppContext 配置类。@Bean 注释现在有两个额外的属性，即 initMethod 和 destroyMethod。它们定义了生命周期方法的设置和清除。这些方法是在已经注册的 bean 中实现的，最终由容器在 bean 初始化及其销毁之前调用它。这里以 Course bean 为例，提供了生命周期方法实现。所实现的方法是 setup 和 cleanup。同样，您还可以在 Mole 和 Assignment bean 中实现这些方法。
Bean 范围
bean 的方法是使用 @Scope 注释定义的。XML 中实现这一目标的方法是指定 bean 元素中的 scope 属性。
清单 9. 使用 XML 方法定义 bean 范围
<bean id="course" class="demo.Course" scope="prototype" >
<property name="mole" ref="mole"/>
</bean>
以下代码展示了使用 Java 配置的 bean 范围定义：
清单 10. 使用 AppContext 配置类定义 bean 范围
@Configuration
public class AppContext {
@Bean(initMethod = "setup", destroyMethod = "cleanup")
@Scope("prototype")
public Course course() {
Course course = new Course();
course.setMole(mole());
return course;
}
...
}
正如您在上面的代码中所看到的那样，在 Java 配置类中定义 bean 的范围非常简单。上面的 AppContext 配置类使用 @Scope 注释为 Coursebean 定义了一个 prototype 范围。默认范围是 singleton。
利用 Java 配置可以做许多事情。本文只触及了一些基础内容。使用 Java 配置并无显着优势，它仅仅是 Spring 提供的 XML 配置的替代方法。对于不喜欢在框架中使用 XML 的人来说，这是实现配置的一种出色方法。但缺点也是显而易见的，如果您对 Java 类中的配置做出了任何更改，就必须重新编译应用程序。
http://www.ibm.com/developerworks/cn/webservices/ws-springjava/