`

Spring配置文件总结

    博客分类：
  • java
Spring配置文件总结springaop 
阅读更多
Spring配置文件总结(转)

2010-06-07 23:51:02|  分类： Spring |  标签：property  value  class   |字号 订阅
首先来看一个标准的Spring配置文件 applicationContext.xml

<?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: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/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"
default-autowire="byName" default-lazy-init="true">

<!-- 配置数据源 -->
<bean id="dataSource"
  class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  <property name="driverClassName">
   <value>com.mysql.jdbc.Driver</value>
  </property>
  <property name="url">
   <value>
    jdbc:mysql://localhost/ssh?characterEncoding=utf-8
   </value>
  </property>
  <property name="username">
   <value>root</value>
  </property>
  <property name="password">
   <value>123</value>
  </property>
</bean>

<!--配置SessionFactory -->
<bean id="sessionFactory"
  class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  <property name="dataSource">
   <ref bean="dataSource" />
  </property>
  <property name="mappingResources">
   <list>
    <value>com/ssh/pojo/User.hbm.xml</value>
   </list>
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.show_sql">true</prop>
   </props>
  </property>
</bean>

<!-- 事务管理 -->
<bean id="transactionManager"
  class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory">
   <ref bean="sessionFactory" />
  </property>
</bean>

<!-- hibernateTemplate -->
<bean id="hibernateTemplate"
  class="org.springframework.orm.hibernate3.HibernateTemplate">
  <property name="sessionFactory">
   <ref bean="sessionFactory" />
  </property>
</bean>

<!-- 配置数据持久层 -->
<bean id="userDao"
  class="com.ssh.dao.impl.UserDaoImpl">
  <property name="hibernateTemplate" ref="hibernateTemplate"></property>
</bean>


<!-- 配置业务逻辑层 -->
<bean id="userService"
  class="com.ssh.service.impl.UserServiceImpl">
  <property name="userDao" ref="userDao"></property>
</bean>


<!-- 配置控制层 -->
<bean id="UserAction"
  class="com.ssh.action.UserAction"  scope="prototype">
  <property name="userService" ref="userService"></property>
</bean>
  <!-- 配置pojo -->
<bean id="User" class="com.ssh.pojo.User" scope="prototype"/>
</beans>



////////////////////////////////////////////////     下面是详解：  ////////////////////////////////////////////////////////////////////////

1.基本配置：
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                    http://www.springframework.org/schema/context
                    http://www.springframework.org/schema/context/spring-context-2.5.xsd
                    ">


<context:component-scan base-package="com.persia">
<!-- 开启组件扫描 -->
</context:component-scan>

<context:annotation-config>
<!--开启注解处理器-->
</context:annotation-config>

<!-- 使用注解,省去了propertity的xml配置，减少xml文件大小 -->
<bean id="personServiceAnno" class="com.persia.PersonServiceAnnotation"></bean>
<bean id="personDaoBeanAnno" class="com.persia.PersonDaoBean"></bean>
<bean id="personDaoBeanAnno2" class="com.persia.PersonDaoBean"></bean>

<!-- 自动注解 -->
<bean id="personServiceAutoInject" class="com.persia.PersonServiceAutoInject" autowire="byName"></bean>


<bean id="personService" class="com.persia.PersonServiceBean">
<!-- 由spring容器去创建和维护，我们只要获取就可以了 -->
</bean>

<bean id="personService2" class="com.persia.PersonServiceBeanFactory" factory-method="createInstance" lazy-init="true"
      init-method="init"  destroy-method="destory">
<!-- 静态工厂获取bean -->
</bean>

<bean id="fac" class="com.persia.PersonServiceBeanInsFactory"></bean>
<bean id="personService3" factory-bean="fac" factory-method="createInstance" scope="prototype">
<!-- 实例工厂获取bean，先实例化工厂再实例化bean-->
</bean>


<!-- ref方式注入属性 -->
<bean id="personDao" class="com.persia.PersonDaoBean"></bean>
<bean id="personService4" class="com.persia.PersonServiceBean">
  <property name="personDao" ref="personDao"></property>
</bean>

<!-- 内部bean方式注入 -->
<bean id="personService5" class="com.persia.PersonServiceBean">
  <property name="personDao">
     <bean class="com.persia.PersonDaoBean"></bean>
  </property>
  <property name="name" value="persia"></property>
  <property name="age" value="21"></property>
 
  <property name="sets">
    <!-- 集合的注入 -->
     <set>
       <value>第一个</value>
       <value>第二个</value>
       <value>第三个</value>
     </set>
  </property>
 
  <property name="lists">
    <!-- 集合的注入 -->
    <list>
        <value>第一个l</value>
       <value>第二个l</value>
       <value>第三个l</value>
    </list>
   
  </property>
 
  <property name="properties">
    <props>
      <prop key="key1">value1</prop>
      <prop key="key2">value2</prop>
      <prop key="key3">value3</prop>
    </props>
  </property>
 
  <property name="map">
   <map>
      <entry key="key1" value="value-1"></entry>
      <entry key="key2" value="value-2"></entry>
      <entry key="key3" value="value-3"></entry>
   </map>
  </property>
</bean>

<bean id="personService6" class="com.persia.PersonServiceBean">
   <constructor-arg index="0" value="构造注入的name" ></constructor-arg>
   <!-- 基本类型可以不写type -->
   <constructor-arg index="1" type="com.persia.IDaoBean" ref="personDao">
   </constructor-arg>
</bean>

</beans>2.开启AOP：
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                     http://www.springframework.org/schema/aop
                    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
                    http://www.springframework.org/schema/context
                    http://www.springframework.org/schema/context/spring-context-2.5.xsd
                   ">

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<bean id="myInterceptor" class="com.persia.service.MyInterceptor"></bean>
<bean id="personServiceImpl" class="com.persia.service.impl.PersonServiceImpl"></bean>
</beans>AOP的xml版本<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                     http://www.springframework.org/schema/aop
                    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
                    http://www.springframework.org/schema/context
                    http://www.springframework.org/schema/context/spring-context-2.5.xsd
                   ">

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

<bean id="personService" class="com.persia.service.impl.PersonServiceImpl"></bean>
<bean id="aspectBean" class="com.persia.service.MyInterceptor"></bean>

<aop:config>
<aop:aspect id="myaop" ref="aspectBean">
<aop:pointcut id="mycut" expression="execution(* com.persia.service.impl.PersonServiceImpl.*(..))"/>
<aop:pointcut id="argcut" expression="execution(* com.persia.service.impl.PersonServiceImpl.*(..)) and args(name)"/> 
<aop:before pointcut-ref="mycut" method="doAccessCheck"  />
<aop:after-returning pointcut-ref="mycut" method="doAfterReturning"/>
   <aop:after-throwing pointcut-ref="mycut" method="doThrowing"/>
   <aop:after pointcut-ref="argcut" method="doAfter" arg-names="name"/>
<aop:around pointcut-ref="mycut" method="arround"/>
</aop:aspect>
 
</aop:config>

</beans>3.开启事务和注解：
<?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: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/context
                    http://www.springframework.org/schema/context/spring-context-2.5.xsd
                    http://www.springframework.org/schema/aop
                    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
                    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
                   ">

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
                  
<!-- 配置数据源 -->  
  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>  
    <property name="url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8"/>  
    <property name="username" value="root"/>  
    <property name="password" value=""/>  
     <!-- 连接池启动时的初始值 -->  
     <property name="initialSize" value="1"/>  
     <!-- 连接池的最大值 -->  
     <property name="maxActive" value="500"/>  
     <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->  
     <property name="maxIdle" value="2"/>  
     <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->  
     <property name="minIdle" value="1"/>  
  </bean> 
  
  <!-- 配置事务管理器-->  
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
    <property name="dataSource" ref="dataSource"/>  
  </bean> 
  <!-- 配置业务bean -->
    <bean id="personService" class="com.persia.service.impl.PersonServiceImpl">
    <property name="ds" ref="dataSource"></property>
  </bean>
  
  <!-- 采用@Transactional注解方式来使用事务 -->  
  <tx:annotation-driven transaction-manager="txManager"/>


</beans>XML版本：

<?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: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/context
                    http://www.springframework.org/schema/context/spring-context-2.5.xsd
                    http://www.springframework.org/schema/aop
                    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
                    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
                   ">

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
                  
<!-- 配置数据源 -->  
  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>  
    <property name="url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8"/>  
    <property name="username" value="root"/>  
    <property name="password" value=""/>  
     <!-- 连接池启动时的初始值 -->  
     <property name="initialSize" value="1"/>  
     <!-- 连接池的最大值 -->  
     <property name="maxActive" value="500"/>  
     <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->  
     <property name="maxIdle" value="2"/>  
     <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->  
     <property name="minIdle" value="1"/>  
  </bean> 
  
<!-- 配置事务管理器 -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
    <property name="dataSource" ref="dataSource"/>  
  </bean> 
  <!-- 配置业务bean -->
   <bean id="personService" class="com.persia.service.impl.PersonServiceImpl">
    <property name="ds" ref="dataSource"></property>
  </bean>
 
 
    <!-- 使用XML来使用事务管理--> 
<aop:config> 
    <!-- 配置一个切面，和需要拦截的类和方法 -->  
    <aop:pointcut id="transactionPointcut" expression="execution(* com.persia.service..*.*(..))"/> 
    <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/> 
</aop:config>
<!-- 配置一个事务通知 -->   
<tx:advice id="txAdvice" transaction-manager="txManager"> 
      <tx:attributes>
      <!-- 方法以get开头的，不使用事务 -->
        <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
      <!-- 其他方法以默认事务进行 -->
        <tx:method name="*"/> 
      </tx:attributes> 
</tx:advice> 
  
 
</beans>4.SSH:
<?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: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/context
                    http://www.springframework.org/schema/context/spring-context-2.5.xsd
                    http://www.springframework.org/schema/aop
                    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
                    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
                   ">


<!-- 配置数据源 -->  
  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>  
    <property name="url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8"/>  
    <property name="username" value="root"/>  
    <property name="password" value=""/>  
     <!-- 连接池启动时的初始值 -->  
     <property name="initialSize" value="1"/>  
     <!-- 连接池的最大值 -->  
     <property name="maxActive" value="500"/>  
     <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->  
     <property name="maxIdle" value="2"/>  
     <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->  
     <property name="minIdle" value="1"/>  
  </bean> 
 
  <!-- 配置hibernate的sessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource"><ref bean="dataSource" /></property>
  <property name="mappingResources">
      <list>
        <value>com/persia/model/Person.hbm.xml</value>
      </list>
   </property>
  
     <!-- 1.首先在sessionFactory里面配置以上3条设置 -->
        <!-- 2.然后得在类路径下面添加一个ehcache.xml的缓存配置文件 -->
        <!-- 3.最后在要使用缓存的实体bean的映射文件里面配置缓存设置 -->
             <!--使用二级缓存-->
             <!-- 不使用查询缓存，因为命中率不是很高 -->
             <!-- 使用Ehcache缓存产品 --> 
  <property name="hibernateProperties">
      <value>
          hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
          hibernate.hbm2ddl.auto=update
          hibernate.show_sql=false
          hibernate.format_sql=false
          hibernate.cache.use_second_level_cache=true
                hibernate.cache.use_query_cache=false
             hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
      </value>
      </property>
</bean>

<!-- 配置Spring针对hibernate的事务管理器 -->
<bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

<!-- 配置使用注解的方式来使用事务 -->
<tx:annotation-driven transaction-manager="txManager"/>

<!-- 使用手工配置的注解方式来注入bean -->
<context:annotation-config></context:annotation-config>

<!--定义要注入的业务bean -->
<bean id="personService" class="com.persia.service.impl.PersonServiceImpl"></bean>

<!--将Struts的action交给Spring容器来管理 -->
<bean name="/person/list" class="com.persia.struts.PersonListAction">
<!--1.这里要求name和struts-config里面的action的path名称一致，因为id不允许有特殊字符-->
<!--2.还得在Struts-config文件里面添加Spring的请求处理器，该处理器会根据action的path属性到Spring容器里面寻找这个bean，若找到了则用这个bean来处理用户的请求-->
<!--3.然后去掉action的type标签和值（可选），当Spring处理器找不到该bean时，才会使用Struts的action-->
<!--4.最后在action里面使用Spring的注入方式来注入业务bean-->
</bean>

<bean name="/person/manage" class="com.persia.struts.PersonManageAction"></bean>
</beans>5.SSH2:
<?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: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/context
                    http://www.springframework.org/schema/context/spring-context-2.5.xsd
                    http://www.springframework.org/schema/aop
                    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
                    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
                   ">


<!-- 配置数据源 -->  
  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>  
    <property name="url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8"/>  
    <property name="username" value="root"/>  
    <property name="password" value=""/>  
     <!-- 连接池启动时的初始值 -->  
     <property name="initialSize" value="1"/>  
     <!-- 连接池的最大值 -->  
     <property name="maxActive" value="500"/>  
     <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->  
     <property name="maxIdle" value="2"/>  
     <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->  
     <property name="minIdle" value="1"/>  
  </bean> 
 
  <!-- 配置hibernate的sessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource"><ref bean="dataSource" /></property>
  <property name="mappingResources">
      <list>
        <value>com/persia/model/Person.hbm.xml</value>
      </list>
   </property>
  
     <!-- 1.首先在sessionFactory里面配置以上3条设置 -->
        <!-- 2.然后得在类路径下面添加一个ehcache.xml的缓存配置文件 -->
        <!-- 3.最后在要使用缓存的实体bean的映射文件里面配置缓存设置 -->
             <!--使用二级缓存-->
             <!-- 不使用查询缓存，因为命中率不是很高 -->
             <!-- 使用Ehcache缓存产品 --> 
  <property name="hibernateProperties">
      <value>
          hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
          hibernate.hbm2ddl.auto=update
          hibernate.show_sql=false
          hibernate.format_sql=false
          hibernate.cache.use_second_level_cache=true
                hibernate.cache.use_query_cache=false
             hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
      </value>
      </property>
</bean>

<!-- 配置Spring针对hibernate的事务管理器 -->
<bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

<!-- 配置使用注解的方式来使用事务 -->
<tx:annotation-driven transaction-manager="txManager"/>

<!-- 使用手工配置的注解方式来注入bean -->
<context:annotation-config></context:annotation-config>

<!--定义要注入的业务bean -->
<bean id="personService" class="com.persia.service.impl.PersonServiceImpl"></bean>

<!--注入Struts 2的action -->
<bean id="personList" class="com.persia.struts2.action.PersonListAction"></bean>
</beans>6.SSJ:
<?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: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/context
                    http://www.springframework.org/schema/context/spring-context-2.5.xsd
                    http://www.springframework.org/schema/aop
                    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
                    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
                   ">


<!-- 使用手工配置的注解方式来注入bean -->
<context:annotation-config></context:annotation-config>

<!-- 1.配置Spring集成JPA -->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
      <property name="persistenceUnitName" value="SpringJPAPU"/>
</bean>

<!--2.配置Spring针对JPA的事务 -->
    <bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
     <property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>

<!--3.开启事务注解 -->
<tx:annotation-driven transaction-manager="txManager"/>
 
<!--以上3个Spring集成JPA的配置，在web项目先添加Spring支持，后添加JPA支持时会自动生成 -->

<!-- 配置业务bean -->
<bean id="personService" class="com.persia.service.impl.PersonServiceImpl"></bean>

<!-- 配置Struts的action -->
<bean name="/person/list" class="com.persia.struts.PersonListAction"/>
<bean name="/person/manage" class="com.persia.struts.PersonManageAction"/>
</beans>
分享到：
| Spring 的微内核与FactoryBean扩展机制
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring配置文件加密实现

    总结来说，Spring配置文件加密实现涉及到以下几个关键步骤： 1. 选择并实现加密算法（如AES）。 2. 使用TE网络技术创建透明加密的文件系统。 3. 自定义或调整Spring的启动流程，使其能够通过加密层读取配置文件。 4...

    使用Spring配置文件实现AOP

    这篇教程将详细讲解如何通过Spring的配置文件来实现AOP。 一、理解AOP概念 AOP的核心思想是将分散在各个模块中的交叉性代码（如日志、事务处理）抽取出来，形成独立的切面，以便于复用和维护。它提供了一种模块化的...

    spring配置文件:整理总结Spring中XML配

    ### Spring配置文件：整理与总结Spring中XML配置的最佳实践 #### 概述 Spring框架作为一个强大的Java应用框架，在企业级应用开发中占据了重要的地位。它为普通的Java对象（Plain Old Java Objects, POJOs）提供了...

    spring配置文件模板

    《Spring配置文件模板详解》 在Java开发领域，Spring框架以其强大的依赖注入（Dependency Injection，简称DI）和面向切面编程（Aspect-Oriented Programming，简称AOP）能力，成为了企业级应用开发的重要选择。而...

    spring配置文件详解

    接着，`&lt;beans&gt;`标签是Spring配置的根元素，它包含了所有bean的定义。在这个例子中，我们看到多个命名空间的引入： 1. `xmlns:beans` 是Spring核心配置的命名空间，用于定义bean。 2. `xmlns:xsi` 是XML Schema ...

    如何加载jar包中的spring配置文件

    在Spring MVC项目中，加载jar包中的Spring配置文件是一个常见的需求，特别是在进行SSM（Spring、Spring MVC、MyBatis）整合时。SSM框架的整合通常涉及到多个配置文件的组织和管理，其中一部分配置可能会被打包到独立...

    spring所有配置文件详解

    ### Spring配置文件详解 #### 一、引言 在Java Web开发领域，Spring框架因其强大的功能和灵活性而受到广泛欢迎。对于初学者来说，理解Spring的配置方式是至关重要的第一步。本文将详细介绍Spring中常见的配置文件...

    Spring依赖包和配置文件

    二、Spring配置文件 1. **beans.xml**：这是Spring应用中最常见的配置文件，用于定义bean及其依赖关系。在这里，我们可以声明bean的类、属性、初始化方法、依赖注入等。 2. **applicationContext.xml**：此文件通常...

    Spring4 jar包和Spring配置文件

    Spring框架是Java开发中最常用的轻量级框架之一，它的核心在于IoC（Inversion of Control，控制反转）和AOP（Aspect Oriented ...深入学习Spring4的jar包和配置文件，将使你更好地驾驭Java开发环境，提高软件工程能力。

    myeclipse中spring配置文件输入提示配置.docx

    ### MyEclipse中Spring配置文件输入提示配置详解 #### 一、问题背景及解决思路概述 在使用MyEclipse进行Java开发时，特别是在涉及到Spring框架的应用中，经常会遇到配置文件编辑过程中缺乏智能提示的问题。这对于...

    spring读取jar中的配置文件

    总结起来，Spring提供了多种方式读取JAR内配置文件，包括`@PropertySource`、`@ConfigurationProperties`以及直接使用`Resource`接口。理解这些方法的使用和它们之间的差异对于开发和维护复杂的Spring应用至关重要。...

    spring加载多个配置文件

    总结来说，Spring支持灵活地加载多个配置文件，无论是XML、Java配置还是基于注解的配置，都能满足项目对不同模块和环境的配置需求。通过理解并熟练运用这些加载机制，开发者可以更好地组织和管理项目中的配置，提高...

    spring 配置文件详解.txt

    ### Spring配置文件详解 #### 一、Spring框架与配置文件的重要性 Spring框架是Java平台上的一个开源框架，它提供了一种轻量级的方式来管理和组织Java应用程序中的组件。Spring框架的核心特性之一是依赖注入...

    Spring之AOP配置文件详解

    ### Spring之AOP配置文件详解 #### 一、前言 在Java开发中，Spring框架因其强大的功能和灵活的配置而被广泛应用于企业级应用的开发。其中，面向切面编程（Aspect Oriented Programming，简称AOP）是Spring框架的...

    spring定时器的包和配置文件

    在标题"spring定时器的包和配置文件"中，我们讨论的核心是Spring如何配置和使用定时器来自动化执行特定的任务。 首先，让我们了解Spring定时任务的基本概念。Spring定时器基于Java的`java.util.Timer`和`java.util....

    spring配置JNDI数据源

    总结来说，Spring配置JNDI数据源主要涉及两部分：一是应用服务器中JNDI资源的注册，二是Spring配置文件中通过JNDI查找并使用这些资源。这种方式的好处在于解耦，应用不再直接依赖具体的数据库连接配置，而是通过JNDI...

    mybatis，spring，struts2，Hibernate的联想配置文件

    总结来说，MyBatis、Spring、Struts2和Hibernate的联想配置文件是Java Web开发中的关键部分，它们定义了框架间的协作方式，优化了开发流程，提高了代码的可读性和可维护性。理解和掌握这些配置文件的结构和用途，...

    spring xml配置文件思维导图

    自己总结的spring xml配置的思维导图，包括了spring的基础配置

    spring对AOP的支持(使用Spring的配置文件来演示)

    总结来说，Spring的AOP功能使得我们可以优雅地处理系统中的横切关注点，通过配置文件定义切面、切点和通知，实现代码的模块化和解耦。通过学习和实践，我们可以更高效地利用AOP提升软件开发的效率和质量。

Magicbox
Global site tag (gtag.js) - Google Analytics