spring配置

合集下载

spring配置文件各个属性详解

spring配置文件各个属性详解分类：spring 2012-08-09 11:25 9316人阅读评论(2) 收藏举报springaophibernateattributesxhtmlwebsphere目录(?)[+]一、引用外部属性文件<bean id="propertyConfigurer"class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="locations"><list><value>classpath:mail.properties</value><value>classpath:jdbc.properties</value></list></property></bean>我们定义了一个PropertyPlaceholderConfigurer类的实例，并将其位置属性设置为我们的属性文件。

该类被实现为Bean工厂的后处理器，并将使用定义在文件中的属性来代替所有的占位符（${...}value）。

注意：而在spring2.5的版本中提供了一种更简便的方式，如：1.<context:property-placeholderlocation="classpath:config/jdbc.properties"/>这样以后要使用属性文件中的资源时，可以使用${属性名}来获得。

二、常用数据源的配置第一种是：DBCP数据源，（需要加入2个jar文件，在spring中的lib下jakarta-commons/commons-dbcp.jar和commons-pools.jar）主要配置如下：<bean id="dataSource"class="mons.dbcp.BasicDataSource"><property name="driverClassName"value="com.mysql.jdbc.Driver"></property><property name="url"value="${jdbc.url}"></property><property name="username" value="${ername}"></property><property name="password" value="${jdbc.password}"></property></bean>第二种是：c3p0数据源，跟第一种一个类型，需加入c3p0.jar包。

spring MVC原理及配置

spring MVC原理及配置springmvc原理及配置springmvc原理及配置1.springmvc详述：springmvc就是spring提供更多的一个强悍而有效率的web框架。

借助注释，springmvc提供更多了几乎就是pojo的研发模式，使控制器的研发和测试更加直观。

这些控制器通常不轻易处置命令，而是将其委托给spring上下文中的其他bean，通过spring的倚赖转化成功能，这些bean被转化成至控制器中。

springmvc主要由dispatcherservlet、处理器映射、处理器(控制器)、视图解析器、视图组成。

他的两个核心是两个核心：处理器映射：选择使用哪个控制器来处理请求视图解析器：选择结果应该如何渲染通过以上两点，springmvc确保了如何挑选掌控处置命令和如何挑选视图展现出输入之间的松耦合。

2.springmvc运行原理这里写图片描述(2)找寻处理器：由dispatcherservlet控制器查阅一个或多个handlermapping，找出处置命令的controller。

(3)调用处理器：dispatcherservlet将请求提交到controller。

(4)(5)调用业务处置和回到结果：controller调用业务逻辑处置后，回到modelandview。

3.springmvc接口解释（1）dispatcherservlet接口：spring提供的前端控制器，所有的请求都有经过它来统一分发。

在dispatcherservlet将请求分发给springcontroller 之前，需要借助于spring提供的handlermapping定位到具体的controller。

（2）handlermappingUSB：能够完成客户请求到controller映射。

（3）controller接口：须要为mammalian用户处置上述命令，因此同时实现controllerUSB时，必须确保线程安全并且可以器重。

Spring中注解配置与xml配置分析

虽然 2.0 版本发布以来，Spring 陆续提供了十多个注解，但是提供的这些注解只是为了在某些情况下简化 XML 的配置，并非要取代 XML 配置方式。这一点可以从 Spring IoC 容器的初始化类可以看出：ApplicationContext 接口的最常用的实现类是 ClassPathXmlApplicationContext 和 FileSystemXmlApplicationContext，以及面向 Portlet 的 XmlPortletApplicationContext 和面向 web 的 XmlWebApplicationContext，它们都是面向 XML 的。Spring 3.0 新增了另外两个实现类：AnnotationConfigApplicationContext 和 AnnotationConfigWebApplicationContext。从名字便可以看出，它们是为注解而生，直接依赖于注解作为容器配置信息来源的 IoC 容器初始化类。由于 AnnotationConfigWebApplicationContext 是 AnnotationConfigApplicationContext 的 web 版本，其用法与后者相比几乎没有什么差别
也可以单独显式地来启用某个注解处理器，而且可以给处理器添加拦截器：
<be.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
<bean class="monAnnotationBeanPostProcessor"/>
<mvc:annotation-driven />
当然了也可以使用如下的方式显式地加载：

实验一Spring环境配置

<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="/schema/beans"
xmlns:xsi="/2001/XMLSchema-instance"
xsi:schemaLocation="/schema/beans
传统J2EE应用的开发效率低，应用服务器厂商对各种技术的支持并没有真正统一，导致J2EE的应用没有真正实现Write Once及Run Anywhere的承诺。Spring作为开源的中间件，独立于各种应用服务器，甚至无须应用服务器的支持，也能提供应用服务器的功能，如声明式事务、事务处理等。
Spring致力于J2EE应用的各层的解决方案，而不是仅仅专注于某一层的方案。可以说Spring是企业应用开发的“一站式”选择，并贯穿表现层、业务层及持久层。然而，Spring并不想取代那些已有的框架，而是与它们无缝地整合。
}
publicvoidrecharge(){
System.out.println("您好"+user.getAccount()+"用户,你的账户充值成功！");
System.out.println("充值金额为:"+user.getMoney());
}
publicvoidread(){
try(BufferedReader reader =newBufferedReader(
（三）Spring由哪些模块组成？它们分别有些什么作用？
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图所示：

spring注解注入properties配置文件

spring注解注⼊properties配置⽂件早期，如果需要通过spring读取properties⽂件中的配置信息，都需要在XML⽂件中配置⽂件读取⽅式。

基于XML的读取⽅式：1<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">2<property name="locations">3<list>4<value>classpath:properties/thread-pool.properties</value>5</list>6</property>7</bean>当然，这种⽅式可以统⼀管理properties配置⽂件，也能实现代码的松耦合。

但为了⽅便开发，提⾼开发效率，spring官⽅后来提供了基于注解的配置读取⽅式。

两种⽅式各有优势，可以基于对项⽬的考虑选择最合适的⽅式。

接下来就介绍如何通过注解注⼊properties的配置信息。

⾸先，准备配置⽂件：1 core.pool.size=22 max.pool.size=33 keep.alive.time=14 task.queue.size=35 await.termination.time=5定义配置类：1package org.cellphone.config;23import com.google.gson.Gson;4import org.springframework.beans.factory.annotation.Value;5import org.springframework.context.annotation.Bean;6import org.springframework.context.annotation.PropertySource;7import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;8import ponent;910/**11 *12*/13 @Component14 @PropertySource("classpath:properties/thread-pool.properties")15public class ThreadPoolConfig {16/**17 * 核⼼线程个数18*/19 @Value("${core.pool.size}")20private int corePoolSize;21/**22 * 最⼤线程个数23*/24 @Value("${max.pool.size}")25private int maxPoolSize;26/**27 * 保持⼼跳时间28*/29 @Value("${keep.alive.time}")30private int keeAliveTime;31/**32 * 任务队列长度33*/34 @Value("${task.queue.size}")35private int taskQueueSize;36/**37 * 等待任务结束的时间38*/39 @Value("${await.termination.time}")40private int awaitTerminationTime;4142/**43 * 使⽤@value注解注⼊properties中的属性44 * 1. 在类名上⾯使⽤ @PropertySource("classpath:*") 注解,*代表属性⽂件路径,可以指向多个配置⽂件路径45 * 如果是多个配置⽂件,则是 @PropertySource({"classpath:*","classpath:*"....})46 * 2. 在字段上直接使⽤@value注解47 * 3. 注解内使⽤${core.pool.size} core.pool.size 代表属性⽂件⾥⾯的key48 * 5. 需要新增 PropertySourcesPlaceholderConfigurer 的 bean49 * 6. 在 PropertySourcesPlaceholderConfigurer 增加@bean注解,申明返回的是⼀个bean,否则会注⼊失败50 *51*/525355 @Bean56public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {57return new PropertySourcesPlaceholderConfigurer();58 }5960public int getCorePoolSize() {61return corePoolSize;62 }6364public void setCorePoolSize(int corePoolSize) {65this.corePoolSize = corePoolSize;66 }6768public int getMaxPoolSize() {69return maxPoolSize;70 }7172public void setMaxPoolSize(int maxPoolSize) {73this.maxPoolSize = maxPoolSize;74 }7576public int getKeeAliveTime() {77return keeAliveTime;78 }7980public void setKeeAliveTime(int keeAliveTime) {81this.keeAliveTime = keeAliveTime;82 }8384public int getTaskQueueSize() {85return taskQueueSize;86 }8788public void setTaskQueueSize(int taskQueueSize) {89this.taskQueueSize = taskQueueSize;90 }9192public int getAwaitTerminationTime() {93return awaitTerminationTime;94 }9596public void setAwaitTerminationTime(int awaitTerminationTime) {97this.awaitTerminationTime = awaitTerminationTime;98 }99100 @Override101public String toString() {102return new Gson().toJson(this);103 }104 }这⾥注⼊了⼀个 PropertySourcesPlaceholderConfigurer bean，spring是通过 PropertySourcesPlaceholderConfigurer 的 locations 来查找属性⽂件，然后再根据注解将匹配的属性set进去，下⾯通过源码来了解注解可以进⾏⼀些什么操作。

Spring事务配置的五种方式

Spring事务原理统观spring事务，围绕着两个核心PlatformTransactionManager和TransactionStatusspring提供了几个关于事务处理的类：TransactionDefinition //事务属性定义TranscationStatus //代表了当前的事务，可以提交，回滚。

PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。

一般事务定义步骤：TransactionDefinition td = new TransactionDefinition();TransactionStatus ts = transactionManager.getTransaction(td);try{ //do sthmit(ts);}catch(Exception e){transactionManager.rollback(ts);}spring提供的事务管理可以分为两类：编程式的和声明式的。

编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。

编程式主要使用transactionTemplate。

省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.void add(){transactionTemplate.execute( new TransactionCallback(){pulic Object doInTransaction(TransactionStatus ts){ //do sth}}}声明式：使用TransactionProxyFactoryBean:<bean id="userManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"><property name="transactionManager"><ref bean="transactionManager"/></property><property name="target"><ref local="userManagerTarget"/></property><property name="transactionAttributes"><props><prop key="insert*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="*">PROPAGATION_REQUIRED,readOnly</prop></props></property></bean>围绕Poxy的动态代理能够自动的提交和回滚事务org.springframework.transaction.interceptor.TransactionProxyFactoryBeanPROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。

【SpringFramework】Spring入门教程（三）使用注解配置

【SpringFramework】Spring⼊门教程（三）使⽤注解配置本⽂主要介绍四个⽅⾯：(1) 注解版本IOC和DI(2) Spring纯注解(3) Spring测试(4) SpringJDBC - Spring对数据库的操作使⽤注解配置Spring⼊门说在前⾯学习基于注解的IoC配置，⼤家脑海⾥⾸先得有⼀个认知，即注解配置和xml配置要实现的功能都是⼀样的，都是要降低模块间的耦合度。

仅仅只是配置的形式不⼀样。

关于实际的开发中到底使⽤xml还是注解，每家公司有着不同的使⽤习惯。

所以这两种配置⽅式我们都需要掌握。

基于注解配置的⽅式也已经逐渐代替xml配置。

所以我们必须要掌握使⽤注解的⽅式配置Spring。

配置步骤注意：如果使⽤Eclipse需要先安装了STS插件，或者使⽤STS开发⼯具创建项⽬。

本⽂使⽤IDEA进⾏演⽰。

1.2.1. 第⼀步：拷贝必备jar包到⼯程的lib⽬录。

注意：在基于注解的配置中，我们还要多拷贝⼀个aop的jar包。

如下图：1.2.2. 第⼆步：在类的根路径下创建⼀个任意名称的xml⽂件（不能是中⽂）注意：基于注解整合时，Spring配置⽂件导⼊约束时需要多导⼊⼀个context命名空间下的约束。

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"></beans>1.2.3. 第⼆步：创建⼀个服务类创建⼀个测试的服务类，并且加⼊使⽤@Component注解，声明该类允许注⼊到Spring容器package org.cjw.service;import ponent;/*使⽤注解配置时，需要将Spring框架启动就创建对象的类表⽰为组件类表⽰组件类使⽤@Component注解*/@Componentpublic class CustomerService {public void save() {System.out.println("-保存数据-");}}1.2.4. 第四步在spring的配置⽂件加⼊扫描注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"><context:component-scan base-package="org.cjw" /></beans>1.2.5. 第五步：测试调⽤代码package org.cjw.test;import org.cjw.service.CustomerService;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class CustomerServiceTest {@Testpublic void testSave() {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");CustomerService customerService = context.getBean(CustomerService.class);customerService.save();}}--测试结果，如果可以调⽤服务⽅法，测试成功。

SpringMVC目录结构配置

SpringMVC目录结构配置SpringMVC是一种常见的Java Web框架，它遵循MVC（Model-View-Controller）设计模式，用于构建灵活可扩展的Web应用程序。

SpringMVC的目录结构对于项目的开发和维护非常重要，下面会详细介绍SpringMVC的标准目录结构以及配置方式。

1.标准目录结构1.1 src/main/java：主要用于存放Java源代码。

1.2 src/main/resources：主要用于存放配置文件和资源文件。

1.3 src/main/webapp：主要用于存放Web应用的静态资源。

1.4 src/test/java：主要用于存放测试用例的Java源代码。

1.5 src/test/resources：主要用于存放测试用例的配置文件和资源文件。

2.详细解析2.1 src/main/java目录src/main/java目录是存放Java源代码的默认目录，它包括以下几个子目录：- config：用于存放Spring配置类，如配置数据库连接、配置事务管理等。

- interceptor：用于存放SpringMVC的拦截器。

- model：用于存放数据模型相关的实体类。

- util：用于存放工具类。

- web：用于存放SpringMVC的控制器。

2.2 src/main/resources目录src/main/resources目录是存放配置文件和资源文件的默认目录，它包括以下几个子目录：- static：用于存放静态资源文件，如CSS、JavaScript、图片等。

- templates：用于存放模板文件，如HTML、Thymeleaf模板等。

- application.properties：存放项目的配置信息，如数据库配置、端口配置等。

- logback.xml：存放日志配置，如日志级别、输出路径等。

- mapper：存放MyBatis的Mapper.xml文件。

spring中的数据库配置

spring中的数据库配置spring中的数据库配置1.使⽤org.springframework.jdbc.datasource.DriveManagerDataSource1 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">2 <property name="driverClassName">3 <value>${jdbc.driverClassName}</value>4 </property>5 <property name="url">6 <value>${jdbc.url}</value>7 </property>8 <property name="username">9 <value>${ername}</value>10 </property>11 <property name="password">12 <value>${jdbc.password}</value>13 </property>14 </bean>说明：DriverManagerDataSource建⽴连接是只要能建⽴连接就新建⼀个connection，根本没有连接池的概念。

2.使⽤org.springframework.jndi.JndiObjectFactoryBean1 <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">2 <property name="jndiName">3 <value>java:comp/env/jdbc/roseindiaDB_local</value>4 </property>5 </bean>说明：JndiObjectFactoryBean能够通过JNDI获取DataSource,但是这种⽅式需要在web服务器中配置数据源，⽐如在tomcat的server.xml处配置数据源。

SSH矿建中spring配置步骤

输入sequence ------》（如果有关系表那么还要选中Enable many-to-many）
---》next -- --》------》 finish 完成
第六步：开始写底层代码，先写接口 ---》再写实现类 (实现类要继承hibernateDaoSupport)
写完底层代码要在 spring.xml文件中进行配置
在 struts 中配置国际化

<constant name="struts.custom.i18n.resources" value="message"></constant>
在页面中如何应用国际化
</tag>
第十四步：创建tree节点
要导入 dtree.css样式， img图片文件，dtree.js文件
在页面上也要引用

<script type="text/javascript" src="js/dtree.js"></script>
和两个文件（jquery.easyui.min.js，jquery-1.7.2.min.js）；
Unable to load configuration. - [unknown location]错误：
解决问题步骤：
第一，jar包冲突，检查项目中的jar包是否同时有
xerce.jar和xml-apis.jar这两个jar包，有的话删除xerce.jar

Spring_c3p0 配置详解

<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
配置一个数据源
Spring在第三方依赖包中包含了两个数据源的实现类包，其一是Apache的DBCP，其二是 C3P0。可以在Spring配置文件中利用这两者中任何一个配置数据源。
DBCP数据源
DBCP类包位于 /lib/jakarta-commons/commons-dbcp.jar，DBCP是一个依赖 Jakarta commons-pool对象池机制的数据库连接池，所以在类路径下还必须包括/lib/jakarta- commons/commons-pool.jar。下面是使用DBCP配置MySql数据源的配置片断：
<property name="maxIdleTime">
<value>60</value>
</property>

<property name="acquireIncrement">
<value>root</value>
</property>
<property name="password">

Spring的Bean配置说明

<beans> Spring配置文件的根元素，包含一个或多个bean元素。

<bean> 用于告诉Spring容器一个类以及它是如何配置的。

class属性：Java Bean 类名(全路经)。

id属性：Java Bean在BeanFactory中的唯一标识，代码中通过BeanFactory获取JavaBean实例时需以此作为索引名称。

name属性：同上，如果给bean增加别名，可以通过name属性指定一个或多个id。

singleton属性：指定此Java Bean是否采用单例（Singleton）模式，如果设为“true”，则在BeanFactory作用范围内，只维护此Java Bean的一个实例，代码通过BeanFactory获得此Java Bean实例的引用。

反之，如果设为“false”，则通过BeanFactory获取此Java Bean实例时，BeanFactory每次都将创建一个新的实例返回。

abstract属性：设定ApplicationContext是否对bean进行预先的初始化。

parent属性：定义一个模板。

autowire属性：bean自动装配模式。

可选5种模式。

no：不使用自动装配。

Bean的引用必须通过ref元素定义。

byName：通过属性名字进行自动装配。

byType：如果BeanFactory中正好有一个同属性类型一样的bean，就自动装配这个属性。

如果有多于一个这样的bean，就抛出一个致命异常，它指出你可能不能对那个bean使用byType的自动装配。

如果没有匹配的bean，则什么都不会发生，属性不会被设置。

如果这是你不想要的情况（什么都不发生），通过设置dependency-check="objects"属性值来指定在这种情况下应该抛出错误。

constructor：这个同byType类似，不过是应用于构造函数的参数。

如果在BeanFactory中不是恰好有一个bean与构造函数参数相同类型，则一个致命的错误会产生。

Spring中配置DataSource的六种方式

Spring中配置DataSource的六种⽅式第⼀种：beans.xmlXml代码1. <bean id="dataSource" class="mons.dbcp.BasicDataSource"2. destroy-method="close">3. <property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver" />4. <property name="url"5. value="jdbc:sqlserver://localhost:1433;DatabaseName=spring" />6. <property name="username" value="sa" />7. <property name="password" value="********" />8. </bean>第⼆种：beans.xml<bean id="mappings"Xml代码1. class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">2. <property name="locations" value="classpath:jdbc.properties"></property>3. </bean>4. <bean id="dataSource" class="mons.dbcp.BasicDataSource"5. destroy-method="close">6. <property name="driverClassName" value="${jdbc.driverClassName}" />7. <property name="url" value="${jdbc.url}" />8. <property name="username" value="${ername}" />9. <property name="password" value="${jdbc.password}" />10. </bean>在src⽂件夹⾥新建⼀个jdbc.properties⽂件，⾥⾯的内容为如下：Xml代码1. jdbc.driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver2. jdbcjdbc.url=jdbc:sqlserver://localhost:1433;DatabaseName=spring3. ername=sa4. jdbc.password=********第三种：beans.xmlXml代码1. <bean id="mappings"2. class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">3. <property name="locations" value="classpath:jdbc.properties"></property>4. </bean>5. <bean id="dataSource" class="mons.dbcp.BasicDataSource"6. destroy-method="close">7. <property name="driverClassName" value="${jdbc.driverClassName}" />8. <property name="url" value="${jdbc.url}" />9. <property name="username" value="${ername}" />10. <property name="password" value="${jdbc.password}" />11. </bean>12.13. <context:property-placeholder location="classpath:jdbc.properties" />在src⽂件夹⾥新建⼀个jdbc.properties⽂件，⾥⾯的内容为如下：14. jdbc.driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver15. jdbcjdbc.url=jdbc:sqlserver://localhost:1433;DatabaseName=spring16. ername=sa17. jdbc.password=********其中第⼆种与第三种类似，只是指定配置⽂件的⽅法不⼀样。

Spring线程池配置

Spring线程池配置Spring通过ThreadPoolTaskExecutor实现线程池技术，它是使⽤jdk中的Java.util.concurrent.ThreadPoolExecutor进⾏实现。

Spring 配置线程池，有两种⽅式：⽅式⼀：XML定义bean<context:component-scan base-package="spring.task"/><bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"><property name="corePoolSize" value="5" /><property name="maxPoolSize" value="10" /><property name="keepAliveSeconds" value="60" /><property name="queueCapacity" value="50" /><property name="allowCoreThreadTimeOut" value="true"/><property name="rejectedExecutionHandler"><bean class="java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy" /></property></bean>当⼀个新任务来临时：1）如果此时线程池中的数量⼩于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务；2）如果此时线程池中的数量等于corePoolSize，但是缓冲队列workQueue未满，那么任务被放⼊缓冲队列；3）如果此时线程池中的数量⼤于corePoolSize，缓冲队列workQueue满，并且线程池中的数量⼩于maxPoolSize，建新的线程来处理被添加的任务；4）如果此时线程池中的数量⼤于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maxPoolSize，那么通过handler所指定的策略来处理此任务；5）当线程池中的线程数量⼤于corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终⽌，如果allowCoreThreadTimeOut为false，则线程数量维持在corePoolSize，如果为true，则线程数量可最低降⾄0；⽅式⼆：使⽤task:executor⽅式<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:task="/schema/task"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd/schema/task /schema/task/spring-task.xsd"><context:component-scan base-package="spring.task"/><task:executor id="executor" pool-size="5" queue-capacity="10" rejection-policy="DISCARD_OLDEST"/></beans>测试代码@Componentpublic class AsyncTask {@Autowiredprivate ThreadPoolTaskExecutor executor;@PostConstructpublic void testAsycTask() {for (int i = 0; i < 10; i++) {executor.execute(new Runnable() {public void run() {asyncTask();}});}}private void asyncTask(){System.out.println( "---" + Thread.currentThread().getName());}}测试结果---executor-1---executor-2---executor-3---executor-4---executor-5---executor-6---executor-7---executor-8---executor-9---executor-10。

spring配置详解

spring配置详解1.前⾔公司⽼项⽬的后台，均是基于spring框架搭建，其中还⽤到了log4j.jar等开源架包。

在新项⽬中，则是spring和hibernate框架均有使⽤，利⽤了hibernate框架，来实现持久化，简化sql操作等。

Hibernate配置⽂件可以有两种格式，⼀种是 hibernate.properties，另⼀种是hibernate.cfg.xml。

后者稍微⽅便⼀些，当增加hbm映射⽂件的时候，可以直接在 hibernate.cfg.xml ⾥⾯增加，不必像 hibernate.properties 必须在初始化代码中加⼊。

我们新项⽬中使⽤的是hibernate.cfg.xml格式。

不过在本⽂中不将细述，后续有机会再补上。

公司项⽬中，中间件主要有tomcat，webshpere，WebLogic。

以下，将对项⽬中spring基本配置，log4j的配置，还有中间件的相关参数配置做⼀个初步的介绍。

2.spring配置——以⽼GIS项⽬为例⼦GISV13中的配置涉及到了SpringMVC,IOC,AOP, Quartz⽅⾯的配置。

配置的实现是通过注记配置和XML配置来合作实现。

这⾥，我将按照Spring的配置流程，将其他⼏个⽅⾯的配置融合其中，来进⾏全⾯解析。

2.1SpringMVC的配置2.1.1.web.xml的配置Web程序中，当中间件启动时，中间件会⾸先读取web.xml中的配置。

在web.xml中可以配置监听器，过滤器，servlet映射等等。

在Spring 框架中，我们主要需配置容器初始化时读取的spring容器配置⽂件的路径以及springMVC中的分发器DispatcherServlet。

在GISV13的web.xml中，我们定义了如下内容：InitGISConfigServlet定义了容器启动时，⾸先要运⾏这个⽅法。

然后servletname为MVC的这部分便是定义了springMVC的分发器以及此servlet所对应的加载配置⽂件的路径。

Spring多数据源事务配置问题

Spring多数据源事务配置问题第⼀步、测试能否配置多个DataSource第⼆步、测试能否配置多个SessionFactory第三步、测试能否配置多个TransactionManager第四步、测试能否使⽤多个TransactionManager，也就是看能否配置多个<tx:annotation-driven/>基本上到第四步就应该⾛不通了，因为Spring中似乎不能配置多个<tx:annotation-driven/>，⽽且@transactional注解也⽆法让⽤户选择具体使⽤哪个TransactionManager。

也就是说，在SpringSide的应⽤中，不能让不同的数据源分别属于不同的事务管理器，多数据源只能使⽤分布式事务管理器，那么测试思路继续如下进⾏：第五步、测试能否配置JTATransactionManager如果到这⼀步，项⽬还能顺利在Tomcat中运⾏的话，我们就算⼤功告成了。

但我总认为事情不会那么顺利，我总觉得JTATransactionManager需要应⽤服务器的⽀持，⽽且需要和JNDI配合使⽤，具体是不是这样，那只有等测试后才知道。

如果被我不幸⾔中，那么进⾏下⼀步：第六步、更换Tomcat为GlassFish，更换JDBC的DataSource为JNDI查找的DataSource，然后配置JTATransactionManager下⾯测试开始，先假设场景，还是继续⽤上⼀篇中提到的简单的⽂章发布系统，假设该系统运⾏⼀段时间后⾮常⽕爆，单靠⼀台服务器已经⽆法⽀持巨⼤的⽤户数，这时候，站长想到了把数据进⾏⽔平划分，于是，需要建⽴⼀个索引数据库，该索引数据库需保存每⼀篇⽂章的Subject及其内容所在的Web服务器，⽽每⼀个Web服务器上运⾏的项⽬，需要同时访问索引数据库和内容数据库。

所以，需要创建索引数据库，如下：create database puretext_index;use puretext_index;create table articles(id int primary key auto_increment,subject varchar(256),webserver varchar(30));第⼀步测试，配置多个DataSource，配置⽂件如下：application.properties：jdbc.urlContent=jdbc:mysql://localhost:3306/PureText?useUnicode=true&characterEncoding=utf8jdbc.urlIndex=jdbc:mysql://localhost:3306/PureText_Index?useUnicode=true&characterEncoding=utf8applicationContext.xml：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="mons.dbcp.BasicDataSource" destroy-method="close"><property name="driverClassName" value="com.mysql.jdbc.Driver"/><property name="url" value="${jdbc.urlContent}"/><property name="username" value="${ername}"/><property name="password" value="${jdbc.password}"/><property name="initialSize" value="5"/><property name="maxActive" value="100"/><property name="maxIdle" value="30"/><property name="maxWait" value="1000"/><property name="poolPreparedStatements" value="true"/><property name="defaultAutoCommit" value="false"/></bean><bean id="dataSourceIndex" class="mons.dbcp.BasicDataSource" destroy-method="close"><property name="driverClassName" value="com.mysql.jdbc.Driver"/><property name="url" value="${jdbc.urlIndex}"/><property name="username" value="${ername}"/><property name="password" value="${jdbc.password}"/><property name="initialSize" value="5"/><property name="maxActive" value="100"/><property name="maxIdle" value="30"/><property name="maxWait" value="1000"/><property name="poolPreparedStatements" value="true"/><property name="defaultAutoCommit" value="false"/></bean><bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"><property name="dataSource" ref="dataSourceContent"/><property name="namingStrategy"><bean class="org.hibernate.cfg.ImprovedNamingStrategy"/></property><property name="hibernateProperties"><props><prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop><prop key="hibernate.show_sql">${hibernate.show_sql}</prop><prop key="hibernate.format_sql">${hibernate.format_sql}</prop><prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop><prop key="hibernate.cache.provider_configuration_file_resource_path">${hibernate.ehcache_config_file}</prop></props></property><property name="packagesToScan" value="cn.puretext.entity.*"/></bean><bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory"/></bean><tx:annotation-driven transaction-manager="transactionManager"/></beans>这个时候运⾏上⼀篇⽂章中写好的单元测试DaoTest.java，结果发现还是会出错，错误原因如下：org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'cn.puretext.unit.service.DaoTest': Autowiring of methods failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire method: public void org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests.setDataSource(javax.sql.DataSource); nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No unique bean of type [javax.sql.DataSource] is defined: expected single matching bean but found 2: [dataSourceContent, dataSourceIndex]经过分析，发现是测试类的基类需要注⼊DataSource，⽽现在配置了多个DataSource，所以Spring不知道哪个DataSource匹配了，所以需要改写DaoTest.java，如下：package cn.puretext.unit.service;import java.util.List;import javax.annotation.Resource;import javax.sql.DataSource;import org.junit.Test;import org.springframework.beans.factory.annotation.Autowired;import org.springside.modules.orm.Page;import org.springside.modules.test.junit4.SpringTxTestCase;import cn.puretext.dao.ArticleDao;import cn.puretext.entity.web.Article;public class DaoTest extends SpringTxTestCase {@Autowiredprivate ArticleDao articleDao;public ArticleDao getArticleDao() {return articleDao;}public void setArticleDao(ArticleDao articleDao) {this.articleDao = articleDao;}@Override@Resource(name = "dataSourceContent")public void setDataSource(DataSource dataSource) {// TODO Auto-generated method stubsuper.setDataSource(dataSource);}@Testpublic void addArticle() {Article article = new Article();article.setSubject("article test");article.setContent("article test");articleDao.save(article);}@Testpublic void pageQuery() {Page<Article> page = new Page<Article>();page.setPageSize(10);page.setPageNo(2);page = articleDao.getAll(page);List<Article> articles = page.getResult();}}改变的内容主要为重写了基类中的setDataSource⽅法，并使⽤@Resource注解指定使⽤的DataSource为dataSourceContent。

如何使用多个Spring的xml配置文件

如何使用多个Spring的xml配置文件(多模块配置)在用Struts Spring Hibernate进行项目团队开发的时候，我们每个开发人员可能都会用到spring的配置文件，如果我们每个开放人员都用同一个的话，这样会给项目开发带来一定的影响，不过大家不用急，Spring为我们提供了很好的方法，我们可以写多个xml文件，然后将每个文件引入进来就行了，话不多说了，马上开始！！方法一、在web.xml中定义 contextConfigLocation参数.spring会使用这个参数加载.所有”逗号”分割的xml.如果没有这个参数,spring默认加载WEB-INF/applicationContext.xml文件(我们现在将Spring配置文件都放在WEB-INF下面)<context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:conf/spring/applicationContext_core*.xml,classpath*:conf/spring/applicationContext_dict*.xml,classpath*:conf/spring/applicationContext_hibernate.xml,classpath*:conf/spring/applicationContext_staff*.xml,classpath*:conf/spring/applicationContext_security.xmlclasspath*:conf/spring/applicationContext_modules*.xmlclasspath*:conf/spring/applicationContext_cti*.xmlclasspath*:conf/spring/applicationContext_apm*.xml</param-value></context-param>contextConfigLocation 参数定义了要装入的 Spring 配置文件。

Spring@Configuration注解及配置方法

Spring@Configuration注解及配置⽅法Spring @Configuration注解Spring3.0开始，@Configuration⽤于定义配置类，定义的配置类可以替换xml⽂件，⼀般和@Bean注解联合使⽤。

@Configuration注解主要标注在某个类上，相当于xml配置⽂件中的<beans>@Bean注解主要标注在某个⽅法上，相当于xml配置⽂件中的<bean>等价于注意：@Configuration注解的配置类有如下要求：@Configuration不可以是final类型；@Configuration不可以是匿名类；嵌套的configuration必须是静态类。

Configuration⾥⾯有⼀个component组件来标识，说明此类也是⼀个bean，可以被调⽤，来看看哪些主要的注解含有component：Annotation 的装配 Spring 中，尽管使⽤ XML 配置⽂件可以实现 Bean 的装配⼯作，但如果应⽤中有很多 Bean 时，会导致 XML 配置⽂件过于靡肿，给后续的维护和升级⼯作带来⼀定的困难为此， Spring 提供了对 Annotation (注解)技术的全⾯⽀持 Spring 中定义了⼀系列的注解，常⽤的注解如下所⽰• @Component: 可以使⽤此注解描述 Spring 中的 Bean ，但它是⼀个泛化的概念，仅仅表⽰⼀个组件 (Bean ，并且可以作⽤在任何层次使⽤时只需将该注解标注在相应类上即可• @Repository: ⽤于将数据访问层( DAO 层)的类标识为 Spring 中的 Bean ，其功能与 @Component 相同• @Service: 通常作⽤在业务层( Service ，⽤于将业务层的类标识为 Spring 中的 Bean 其功能与@Component 相同• @Controller: 通常作⽤在控制层(如 Spring MVC Controller ，⽤于将控制层的类标识 Spring 中的 Bean ，其功能与@Component 相同• @Autowired: ⽤于对 Bean 的属性变量、属性的 setter ⽅法及构造⽅法进⾏标注，配合对应的注解处理器完成 Bean 的⾃动配置⼯作默认按照 Bean 的类型进⾏装配• @Resource: 其作⽤与 Autowired ⼀样其区别在于@Autowired 默认按照 Bean 类型装配，⽽@Resource 默认按照 Bean 实例名称进⾏装配 @Resource 中有两个重要属性: name type Spring name 属性解析为 Bean 实例名称， type 属性解析为 Bean 实例类型如果指定 name 属性，贝IJ 按实例名称进⾏装配;如果指定 type 属性，则按 Bean 类型进⾏装配;如果都不指定，则先按 Bean 实例名称装配，如果不能匹配，再按照 Bean 类型进⾏装⾃⼰;如果都⽆法匹配，则抛出NoSuchBeanDefinitionException 异常• @Qualifier: @Autowired 注解配合使⽤，会将默认的按 Bean 类型装配修改为接 Bean 的实例名称装配， Bean 的实例名称由 @Qualifier 注解的参数指定在上⾯⼏个注解中，虽然@Repository @Service @Controller 功能与@Component 注解的功能相同，但为了使标注类本⾝⽤途更加清晰，建议在实际开发中使⽤@Repository @Service @Controller 分别对实现类进⾏标注下⾯。

springmvc+druid+dataSource配置的两种方式

springmvc+druid+dataSource配置的两种⽅式⼀、⼀般的配置⽅式数据库连接配置在jdbc.properties⽂件中，这种⽅式有⼀个最⼤的缺点，数据库的配置信息对开发⼈员是完全可见的，⼗分⽅便程序员删库跑路。

spring配置具体如下：1、jdbc.properties⽂件：driver=com.mysql.jdbc.Driverurl=jdbc:mysql://127.0.0.1:3306/test_table?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true& username=rootpassword=root2、spring和druid配置：<bean id="propertyConfigurer"class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="location" value="classpath:jdbc.properties"/></bean><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"><property name="driverClassName" value="${driver}"/><property name="url" value="${url}"/><property name="username" value="${username}"/><property name="password" value="${password}"/><property name="initialSize" value="1"/><property name="minIdle" value="1"/><property name="maxActive" value="20"/><property name="maxWait" value="60000"/><property name="timeBetweenEvictionRunsMillis" value="60000"/><property name="minEvictableIdleTimeMillis" value="300000"/><property name="validationQuery" value="SELECT 'x'"/><property name="testWhileIdle" value="true"/><property name="testOnBorrow" value="false"/><property name="testOnReturn" value="false"/><property name="poolPreparedStatements" value="false"/><property name="maxPoolPreparedStatementPerConnectionSize" value="20"/><property name="filters" value="stat"/></bean>以上简单的配置就好了。

spring中增加自定义配置支持

spring中增加⾃定义配置⽀持
spring.schemas
在使⽤spring时，我们会⾸先编写spring的配置⽂件，在配置⽂件中，我们除了使⽤基本的命名空间/schema/beans之外，我们还会⽤到多种其他命名空间，每⼀种命名空间还有⼀个对应的xsd⽂档。

⽐如springmvc的/schema/mvc对应/schema/mvc/spring-mvc.xsd，aop的
/schema/aop对应/schema/aop/spring-aop.xsd。

图为spring-mvc的命名空间和xsd⽂档的映射关系。

命名空间和xsd的映射关系保存在classpath或者jar包的META-INF/spring.schemas⽂件中。

此⽂件会在多个jar包中存在，可通过ClassLoader.getSystemResources⽅法，获取所有⽂件的URL信息。

spring.handlers
命名空间中元素的处理，通过何种handler处理，META-INF/spring.handlers⽂件中保存了其映射关系。

当spring在解析配置⽂件时，碰到了指定命名空间的元素，便使⽤对应的handler进⾏元素的处理。

图为spring-mvc的命名空间和handler的映射关系。

handler
在handler中主要定义，元素的BeanDefinitionParser，通过BeanDefinitionParser处理元素，组成⼀个BeanDefinition，并保存到IOC中。

⾃定义实现
在启动spring时，会发现控制台打印出了配置⽂件中的name值。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

作者简介：Craig Walls是Texas-based公司的软件开发人员，有着超过13年的开发经验，涉及的领域有通信，金融，零售，教育以及软件业等。

他是Spring Framework的狂热拥护者，频繁的在当地local user groups讨论组和相关会议上演讲Spring，并且他的Blog上也有很多关于Spring的内容。

出版的著作有：z Spring in Action, 2nd Edition, 2007z XDoclet in Action, 2003他的Blog是：z 所参与的项目：z Committer to XDoclet project;z Originator of Portlet and Spring modules for XDoclet本手册主要是将分布于文档中的那些零散的配置文件部分统一成一个比较系统的整体。

结合Spring文档一起查阅也许能节省你一些时间。

不过，并不推荐你全部掌握；很多陌生的元素或标签只应用于特定场合。

本手册英文版本可以在：下载。

Spring配置全书作者Craig Walls译者superleo 关于Spring的配置Spring Framework总是不断的改变着Java企业开发的方向，它用一种松耦合的方式来配置和组装应用程序对象和业务对象，比以往的Java企业开发来的更加简洁。

一旦你开发了基于Spring 的应用程序，在Spring上下文配置的那些资源简直就是唾手可得。

依赖注入是Spring容器的核心尽管Spring Framework可以做很多事，但依赖注入却是Spring容器提供的最基本的功能。

任何稍微复杂一点的应用程序都至少由两个或两个以上的对象协作在一起，共同完成一些业务逻辑。

以往的Java企业开发，每个对象都要自己去主动获得他们所引用（或依赖）的对象，才可正常运作。

这将导致代码之间的紧耦合，难以测试。

有了依赖注入后，对象所依赖的资源则可通过外部来获得。

换句话说，对象所依赖的资源是按照它们的需要给注入进去的。

对于基于Spring的应用程序来说，是Spring容器将这些对象所依赖的资源帮助实现注入依赖的。

用XML来配置Spring到了Spring2.0，Spring鼓励你使用基于XML Scheme的配置方式来应用于你的系统，这比起过去基于DTD的方式要更加灵活。

一个典型的Spring2.5配置文件至少拥有以下结构：<?xml version=”1.0” encoding=”UTF-8”?><beans xmlns=”/schema/beans”xmlns:xsi=”/2001/XMLSchema-instance”xsi:schemaLocation=”/schema/beans/schema/beans/spring-beans-2.5.xsd></beans>在<beans>元素中，你可以放置“bean”的声明以及其它元素来配置你的应用程序上下文。

“beans”命名空间是Spring配置文件中所有元素的父类，但它不是孤立的。

Spring还包括其它七种以上的命名空间，稍后我将会在本手册中一一介绍。

如果你想使用其它命名空间的话，你需要事先声明它们。

比如说，如果你想使用“context”命名空间的话，你应该在XML声明如下：<?xml version=”1.0” encoding=”UTF-8”?><beans xmlns=”/schema/beans”xmlns:xsi=”/2001/XMLSchema-instance”xmlns:context=”/schema/context”xsi:schemaLocation=”/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd”></beans>Beans 命名空间简介Schema URI/schema/beansSchema XSD/schema/beans/spring-beans-2.5.xsdbeans命名空间是Spring命名空间的核心，也是你配置Spring时使用最多的一个。

根元素是<beans>，它不仅可以包含一个或多个<bean>子元素，而且还可以包含其它命名空间的元素，甚至在<beans>下你可以不配置任何<bean>子元素。

Spring XML 图表的一些约定Spring XML图通常使用以下符号来表示哪些元素是必选的，可选的以及它们之间的包含关系。

Bean命名空间下的元素简介元素描述<alias> 为一个定义过的bean起一个别名<bean> 在Spring容器中定义bean元素<constructor-arg> 向bean的构造函数注入值或引用。

这就是我们常说的构造函数注入。

<description> 用来描述Spring context或每个bean元素。

虽然它会被Spirng容器所忽略，但<description>元素可以通过工具生成属于你的是Spring context文档。

<import> 导入其它Spring context的定义。

<lookup-method> 使用方法来代替getter注入。

指定一个方法，它会在运行被复写从而返回一个指定的bean。

这就是我们常说的getter注入。

仅在一些特殊场合下有用。

<property> 为bean的特定属性注入一个值或者引用。

这就是我们常说的setter注入。

<replaced-method> 用一个新的实现来代替bean的某个方法。

<bean>元素揭密虽然有很多XML元素可以用来配置Spring context，但也许你用的最多的可能还是<bean>元素。

因此，让你深入了解<bean>标签是十分必要的。

属性描述abstract 如果设置为true，那么Spring容器认定此bean为抽象的，并且不会对它进行初始化。

autowire 如果该bean需要autowire的话，声明采用哪一种autowire。

可选的值有:byTye,byname,constractor,autodetect或noautowire-candidate 如果设置为false，该bean不会被当作其它bean的autowire候选对象。

（也许就是说就算别的bean设置了autowire，仍然会忽略掉该bean）class 用来指定bean的全限定名dependency-check 要求Spring采用何种方式来检查bean的setting属性设置情况。

可用值如下：simple:检查所有的原始类型属性注入情况objects:检查所有复杂类型属性注入的情况其它可选的值还有 default, none 或 all.depends-on 该bean初始化之前，要求Spring容器事先将所依赖的bean也实例化。

destroy-method 该bean从Spring容器卸载时，指定一个方法供Spring容器回调 factory-bean 指定一个工厂方法来创建此bean。

id 该bean在Spring容器中的唯一标识。

init-method 该bean被初始化或被注入到别的bean中时，Spring容器回调应该方法。

lazy-init 如果为true那么bean将延迟加载。

name bean在spring容器中定义的名称。

它是除使用id外的另一个选择。

parent 指定bean在配置文件中的父类。

Scope 设置该bean的作用域。

默认情况下，所有的beans都是singleton。

其它可选的包括：prototype, request和session.Bean命名空间实例下面的Spring XML配置文件配置了两个beans，其中一个注入到另一个中去：<?xml version=”1.0” encoding=”UTF-8”?><beans xmlns=”/schema/beans”xmlns:xsi=”/2001/XMLSchema-instance”xsi:schemaLocation=”/schema/beans/schema/beans/spring-beans-2.5.xsd”><bean id=”pirate” class=”Pirate”><constructor-arg value=”Long John Silver” /><property name=”map” ref=”treasureMap” /></bean><bean id=”treasureMap” class=”TreasureMap” /></beans>第一个bean的ID为“pirate”，类型为“Pirate”。

它使用了构造函数注入，该构造函数带有一个String参数，在这个例子中参数的值为“Long John Silver”。

另外，它的“map”属性引用了另一个叫“treasureMap”的bean，该bean是TreasureMap的一个实例。

温馨提示：不要把你所有的beans都定义在一个XML文件中。

一旦你的应用程序变得越来越复杂，在Spring 的XML配置文件中定义的beans的数量一定让你印象深刻。

也没有什么理由要把所有的beans 都定义在一个XML配置文件中去。

通过将所有的beans分别放在多个XML文件中，有助于你的Spring配置文件更易于管理。

当应用程序上下文(application context)建立的时候，可以使用<import>元素将它们全部组装起来：<import resource=”service-layer-config.xml” /><import resource=”data-layer-config.xml” /><import resource=”transaction-config.xml” />Context 命名空间简介Schema URI/schema/contextSchema XSD/schema/context/spring-context-2.5.xsd在Spring2.5中，context命名空间主要用来提供多种application context特定的配置。