spring配置文件各个属性详解
spring配置文件头文件解读
<beans
xmlns="/schema/beans"
xmlns:xsi="/2001/XMLSchema-instance"
xmlns:p="/schema/p"
xmlns:tx="/schema/tx"
xmlns:aop="/schema/aop"
xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-3.1.xsd /schema/tx
/schema/tx/spring-tx-3.1.xsd
/schema/aop
/schema/aop/spring-aop-3.1.xsd"> xmlns:意思为域,为提供xml命名空间支持而添加的域。
首先,xml有格式,而为了spring的配置文件增加的节点能满足要求合法,所以必须引用校验该xml的格式文件。
下面解释上面代码的每一行。
1. 第一行:初始化bean的格式文件地址
2. 第二行:辅助初始化bean
3. 第三行:Spring的p标签是基于xml Schema的配置方式,
目的是简化配置方式,如果不需要简化,可删除
4. 第四行:关于spring的上下文
5. 第五行:关于面向切面编程
6. 第六行:用来定义xmlschema的地址,也就是xml书写时需
要遵循的语法,两部分组成,前面是命名空间的名字,后面是
xsd(xmlschema)的地址。
Spring配置文件中事务的属性
Spring配置⽂件中事务的属性1.事务传播属性# propagation: 传播REQUIRED: 需要事务,外部存在事务融⼊当前事务,外部没有事务,开启新的事务SUPPORTS: ⽀持事务,外部存在事务融⼊当前事务,外部没有事务,不开启新的事务REQUIRES_NEW: 每次开启新的事务,如果外部存在事务外部事务挂起,开启新的事务运⾏,运⾏结束后回复外部事务NOT_SUPPORTED: 不⽀持事务,如果外部存在事务外部事务挂起,已⾮事务⽅式运⾏.NEVER: 不⽀持事务,存在事务报错MANDATORY: 强制事务没有事务报错NESTED: 嵌套事务,数据库不⽀持2.事务的隔离级别# isolation 隔离级别DEFAULT: 采⽤数据库默认隔离级别READ_UNCOMMITTED: 读未提交READ_COMMITTED: 读提交⽤来避免脏读现象出现的 oracle默认隔离级别REPEATABLE_READ: 可重复读主要是⽤来避免不可重复读现象出现的 (在⼀次事务中⼀⽅更新,导致两次查询结果不⼀致这种情况叫不可重复读) mysql默认隔离级别 SERIALIZABLE: 序列化读⽤来避免幻影读现象出现 (在⼀次事务中⼀⽅插⼊,导致两次查询结果不⼀致这种情况叫幻影读)3.读写和异常性# readonlytrue: 本次事务只读false: 本次事务⾮只读<tx:method name="save*" propagation="REQUIRES_NEW" read-only="true|false" isolation="SERIALIZABLE"/># rollback-for && no-rollback-for=""rollback-for: 遇到什么类异常回滚no-rollback-for: 遇到什么类异常不回滚<tx:method name="save*" rollback-for="" no-rollback-for="" propagation="REQUIRES_NEW" read-only="true" isolation="SERIALIZABLE"/># timeout 超时性timeout: -1 永不超时。
Spring配置解析之Properties
Spring配置解析之Properties 1.简单⽰例:SpringBoot中的的配置简单属性类⽀持ConfigurationProperties⽅式,看⼀个简单的⽰例。
1 @ConfigurationProperties(prefix = "org.dragonfei.demo")2public class DemoProperties {3private String name;4private String password;5private String test;67public String getName() {8return name;9 }1011public void setName(String name) { = name;13 }1415public String getPassword() {16return password;17 }1819public void setPassword(String password) {20this.password = password;21 }2223public String getTest() {24return test;25 }2627public void setTest(String test) {28this.test = test;29 }3031 @Override32public String toString() {33return "DemoProperties{" +34 "name='" + name + '\'' +35 ", password='" + password + '\'' +36 ", test='" + test + '\'' +37 '}';38 }39 }定义Properties类1 =dragonfei2 org.dragonfei.demo.password=password3 org.dragonfei.demo.test=test添加配置1 @Configuration2 @EnableConfigurationProperties({DemoProperties.class})3public class DemoConfiguration {4 }注⼊Properties1 @RunWith(SpringJUnit4ClassRunner.class)2 @SpringApplicationConfiguration(classes = DemoConfiguration.class)3 @EnableAutoConfiguration4public class DemoPropertiesTest {56 @Autowired7private DemoProperties properties;8 @Test9public void testProperties(){10 System.out.println(properties.toString());11 }12 }简单单元测试1 DemoProperties{name='dragonfei', password='password', test='test'}运⾏单元测试结果DemoProperties神奇的注⼊到Spring容器中了。
spring配置文件详解
spring配置文件详解Spring是一个轻量级的开源Java框架,它提供了一种简化Java应用开发的方式。
在Spring框架中,配置文件起着非常重要的作用,它用于配置应用程序中的各种组件和对象。
Spring配置文件通常使用XML格式,但也可以使用注解或Java代码进行配置。
在配置文件中,我们可以定义Bean(对象)、依赖关系、AOP(面向切面编程)等等。
下面将详细介绍Spring配置文件的各个部分。
1. 命名空间和约束在Spring配置文件的开头,我们需要声明命名空间和约束。
命名空间用于引入Spring的命名空间,以便我们可以使用Spring提供的各种功能。
约束用于验证配置文件的正确性。
2. Bean定义在Spring配置文件中,我们可以定义多个Bean。
每个Bean都有一个唯一的ID和一个类名或接口名。
我们可以使用构造函数或工厂方法来创建Bean,并指定Bean的属性值。
3. 依赖注入依赖注入是Spring框架的核心特性之一。
通过依赖注入,我们可以将一个Bean的依赖关系委托给Spring容器来管理。
在配置文件中,我们可以使用<property>元素来设置Bean的属性值,也可以使用<constructor-arg>元素来设置构造函数的参数。
4. 别名和引用在配置文件中,我们可以为Bean定义别名,以便在其他地方使用更简洁的名称来引用Bean。
我们还可以使用<ref>元素来引用其他Bean。
5. 集合和数组Spring配置文件还支持定义集合和数组类型的属性。
我们可以使用<list>、<set>、<map>和<props>元素来定义不同类型的集合。
6. 自动装配自动装配是Spring框架的另一个重要特性。
通过自动装配,Spring容器可以根据Bean之间的依赖关系自动将它们连接起来。
在配置文件中,我们可以使用autowire属性来指定自动装配的方式。
springlog4j2.xml配置文件详解
springlog4j2.xml配置⽂件详解⼀、log4j2介绍 log4j 2.x版本不再⽀持像1.x中的.properties后缀的⽂件配置⽅式,2.x版本配置⽂件后缀名只能为".xml",".json"或者".jsn"。
配置⽂件的格式:log2j配置⽂件可以是xml格式的,也可以是json格式的。
配置⽂件的位置:log4j2默认会在classpath⽬录下寻找log4j2.xml、log4j.json、log4j.jsn等名称的⽂件。
系统选择配置⽂件的优先级(从先到后)如下: (1).classpath下的名为log4j2-test.json 或者log4j2-test.jsn的⽂件. (2).classpath下的名为log4j2-test.xml的⽂件. (3).classpath下名为log4j2.json 或者log4j2.jsn的⽂件. (4).classpath下名为log4j2.xml的⽂件. 我们⼀般默认使⽤log4j2.xml进⾏命名。
⼆、配置⽂件节点解析 (1).根节点Configuration有两个属性:status和monitorinterval,有两个⼦节点:Appenders和Loggers(表明可以定义多个Appender和Logger)。
status⽤来指定log4j本⾝的打印⽇志的级别。
monitorinterval⽤于指定log4j⾃动重新配置的监测间隔时间,单位是s,最⼩是5s。
(2).Appenders节点,常见的有三种⼦节点:Console、RollingFile、File。
Console节点⽤来定义输出到控制台的Appender。
name:指定Appender的名字. target:SYSTEM_OUT 或 SYSTEM_ERR,⼀般只设置默认:SYSTEM_OUT。
PatternLayout:输出格式,不设置默认为:%m%n。
SpringBoot入门篇--关于properties和yml两种配置文件的一些事情
SpringBoot⼊门篇--关于properties和yml两种配置⽂件的⼀些事
情
我们在使⽤SpringBoot这个框架的时候都⼀定使⽤或者说是见到过application.properties或者是application.yml,经不住有⼈就会问这俩⽂件到底是什么情况,其实说⽩了这两个都是SpringBoot留下的配置⽂件,都可以进⾏配置,接下来我们就讲讲他们两个的⼀些区别。
⾸先我们最关注的应该是格式问题,两个⽂件在进⾏配置的时候的格式都是⼀样的么?properties⽂件在进⾏配置的时候⼀定是⼀个key---value,对于这⼀条的解释就是⼀个可以对某电配置完整解释的⼀定是在同⼀级别,就是我们可以如下图所⽰看到的:
然后我们再来看⼀下在yml⽂件中我们应该怎样进⾏配置达到相同的效果:
我们可以观察到的格式就是yml⽂件是梯级呈现的,我们应该注意⼀下⼏个⽅⾯:
1>在properties⽂件⾥⾯的 “ .” 连接在yml⽂件⾥⾯全部换成 ":" 进⾏连接,并且每⼀级之间必须换⾏,在第⼆级开始应该进⾏⼀个Tab键的缩进,当然如果是同级的就不需要进⾏缩进
2>在yml⽂件⾥⾯如果是需要进⾏赋值那么必须是要在 ":" 后⾯进⾏⼀个空格键的缩进
3>在yml⽂件⾥⾯所有的配置,相同级别只能出现⼀次,⽐如我们使⽤了spring这个级别,那么我们在后边进⾏spring级别的配置的时候就必须在这个地⽅进⾏,不能在写⼀个spring级别。
Spring中属性文件properties的读取与使用详解
Spring中属性⽂件properties的读取与使⽤详解Spring中属性⽂件properties的读取与使⽤详解实际项⽬中,通常将⼀些可配置的定制信息放到属性⽂件中(如数据库连接信息,邮件发送配置信息等),便于统⼀配置管理。
例中将需配置的属性信息放在属性⽂件/WEB-INF/configInfo.properties中。
其中部分配置信息(邮件发送相关):#邮件发送的相关配置email.host = email.port = xxxername = xxxemail.password = xxxemail.sendFrom=***********在Spring容器启动时,使⽤内置bean对属性⽂件信息进⾏加载,在bean.xml中添加如下:Xml代码<!-- spring的属性加载器,加载properties⽂件中的属性 --><bean id="propertyConfigurer"class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="location"><value>/WEB-INF/configInfo.properties</value></property><property name="fileEncoding" value="utf-8" /></bean>属性信息加载后其中⼀种使⽤⽅式是在其它bean定义中直接根据属性信息的key引⽤value,如邮件发送器bean的配置如下:Xml代码<!-- 邮件发送 --><bean id="mailSender"class="org.springframework.mail.javamail.JavaMailSenderImpl"><property name="host"><value>${email.host}</value></property><property name="port"><value>${email.port}</value></property><property name="username"><value>${ername}</value></property><property name="password"><value>${email.password}</value></property><property name="javaMailProperties"><props><prop key="mail.smtp.auth">true</prop><prop key="sendFrom">${email.sendFrom}</prop></props></property></bean>另⼀种使⽤⽅式是在代码中获取配置的属性信息,可定义⼀个javabean:ConfigInfo.java,利⽤注解将代码中需要使⽤的属性信息注⼊;如属性⽂件中有如下信息需在代码中获取使⽤:Java代码#⽣成⽂件的保存路径file.savePath = D:/test/#⽣成⽂件的备份路径,使⽤后将对应⽂件移到该⽬录file.backupPath = D:/test bak/ConfigInfo.java 中对应代码:Java代码@Component("configInfo")public class ConfigInfo {@Value("${file.savePath}")private String fileSavePath;@Value("${file.backupPath}")private String fileBakPath;public String getFileSavePath() {return fileSavePath;}public String getFileBakPath() {return fileBakPath;}}业务类bo中使⽤注解注⼊ConfigInfo对象:Java代码@Autowiredprivate ConfigInfo configInfo;需在bean.xml中添加组件扫描器,⽤于注解⽅式的⾃动注⼊:Xml代码<context:component-scan base-package="com.my.model" />(上述包model中包含了ConfigInfo类)。
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>
<!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
<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事务概念跟配置详解(叮嘣)新
[转载] Java事务处理总结2008年07月23日星期三12:49一、什么是Java事务通常的观念认为,事务仅与数据库相关。
事务必须服从ISO/IEC所制定的ACID原则。
ACID是原子性(atomicity)、一致性(consistency)、隔离性(isolation)和持久性(durability)的缩写。
事务的原子性表示事务执行过程中的任何失败都将导致事务所做的任何修改失效。
一致性表示当事务执行失败时,所有被该事务影响的数据都应该恢复到事务执行前的状态。
隔离性表示在事务执行过程中对数据的修改,在事务提交之前对其他事务不可见。
持久性表示已提交的数据在事务执行失败时,数据的状态都应该正确。
通俗的理解,事务是一组原子操作单元,从数据库角度说,就是一组SQL指令,要么全部执行成功,若因为某个原因其中一条指令执行有错误,则撤销先前执行过的所有指令。
更简答的说就是:要么全部执行成功,要么撤销不执行。
既然事务的概念从数据库而来,那Java事务是什么?之间有什么联系?实际上,一个Java应用系统,如果要操作数据库,则通过JDBC来实现的。
增加、修改、删除都是通过相应方法间接来实现的,事务的控制也相应转移到Java程序代码中。
因此,数据库操作的事务习惯上就称为Java事务。
二、为什么需要事务事务是为解决数据安全操作提出的,事务控制实际上就是控制数据的安全访问。
具一个简单例子:比如银行转帐业务,账户A要将自己账户上的1000元转到B账户下面,A账户余额首先要减去1000元,然后B账户要增加1000元。
假如在中间网络出现了问题,A账户减去1000元已经结束,B因为网络中断而操作失败,那么整个业务失败,必须做出控制,要求A账户转帐业务撤销。
这才能保证业务的正确性,完成这个操走就需要事务,将A账户资金减少和B账户资金增加方到一个事务里面,要么全部执行成功,要么操作全部撤销,这样就保持了数据的安全性。
三、Java事务的类型Java事务的类型有三种:JDBC事务、JTA(Java Transaction API)事务、容器事务。
SpringBoot中的Properties的使用详解
SpringBoot中的Properties的使用详解Properties文件的格式1. .properties文件:这是一种常用的配置文件格式,它使用"键=值"的形式来定义属性。
2. .yml文件:这是一种基于缩进的配置文件格式,它使用空格来表示层级关系,可以更加清晰地表示属性的结构。
Properties的加载顺序1. 配置文件的默认位置:Spring Boot会首先在默认的位置加载Properties文件,即在classpath下的/config文件夹或者是jar包的根目录下。
2. 配置文件的自定义位置:如果在默认位置找不到Properties文件,Spring Boot会尝试在工作目录下寻找,即在当前工作目录下的./config/文件夹或者是jar包的同级目录下。
3. 命令行参数:可以通过在启动应用程序时使用--和--spring.config.location参数来指定Properties文件的名称和位置。
Properties的使用在Spring Boot中,可以通过多种方式来使用Properties文件的属性值:Properties文件的加载和刷新在Spring Boot中,Properties文件的加载是在应用程序启动的过程中进行的,一旦加载完成,属性值将被缓存在内存中,并可以在整个应用程序中使用。
如果需要动态地从外部文件加载Properties文件的属性值,可以使用Spring的Environment对象,并通过调用其refresh(方法来刷新属性值。
总结Spring Boot中的Properties是一种用于配置应用程序的机制,可以通过多种方式来使用和获取属性值。
在Properties文件的加载和使用过程中,需要注意属性文件的加载顺序和使用方式,并可以根据自己的需求来选择合适的方式来使用Properties文件的属性值。
通过灵活地使用Properties,可以实现应用程序的动态配置和定制化。
spring配置
Spring事务配置的五种方式前段时间对Spring的事务配置做了比较深入的研究,在此之间对Spring的事务配置虽说也配置过,但是一直没有一个清楚的认识。
通过这次的学习发觉Spring的事务配置只要把思路理清,还是比较好掌握的。
总结如下:Spring配置文件中关于事务配置总是由三个组成部分,分别是DataSource、TransactionManager和代理机制这三部分,无论哪种配置方式,一般变化的只是代理机制这部分。
DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化,比如使用Hibernate进行数据访问时,DataSource实际为SessionFactory,TransactionManager 的实现为HibernateTransactionManager。
具体如下图:根据代理机制的不同,总结了五种Spring事务的配置方式,配置文件如下:第一种方式:每个Bean都有一个代理<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schem a/beans"xm lns:xsi="/2001/XMLSchem a-instance"xm lns:context="/schem a/context"xm lns:aop="/schem a/aop"xsi:schem aLocation="/schem a/beans /schem a/beans/spring-beans-2.5.xsd/schem a/context/schem a/context/spring-context-2.5.xsd /schem a/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springfram ework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/> <property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务)--><bean id="t ransactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager" ><property name="sessionFactory" ref="sessionFactory"/> </bean><!-- 配置DAO --><bean id="userDaoTarget" class="erDaoImpl"> <property name="sessionFactory" ref="sessionFactory"/> </bean><bean id="userDao"class="org.springframework.transaction.interceptor.TransactionProxyFactor yBean"><!-- 配置事务管理器--><property nam e="t ransactionManager" ref="transactionManager"/><property name="target" ref="userDaoTarget"/><property nam e="proxyInterfaces"value="com.bluesky.spring.dao.GeneratorDao"/><!-- 配置事务属性--><property name="t ransactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean></beans>第二种方式:所有Bean共享一个代理基类<?xml version="1.0" enc oding="UTF-8"?><beans xmlns="/schem a/beans"xm lns:xsi="/2001/XMLSchem a-instance"xm lns:context="/schem a/context"xm lns:aop="/schem a/aop"xsi:schem aLocation="/schem a/beans/schem a/beans/spring-beans-2.5.xsd/schem a/context/schem a/cont ext/spring-context-2.5.xsd /schem a/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springfram ework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/> <property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务)--><bean id="t ransactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager" ><property name="sessionFactory" ref="sessionFactory"/> </bean><bean id="t ransactionBase"class="org.springfram ework.transaction.interceptor.TransactionProxyFact oryBean"lazy-init="true" abstract="t rue"><!-- 配置事务管理器--><property name="t ransactionManager" ref="transactionManager"/><!-- 配置事务属性--><property name="t ransactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><!-- 配置DAO --><bean id="userDaoTarget" class="erDaoImpl"> <property name="sessionFactory" ref="sessionFactory"/> </bean><bean id="userDao" parent="transactionBase"><property name="target" ref="userDaoTarget"/></bean></beans>第三种方式:使用拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schem a/beans"xm lns:xsi="/2001/XMLSchem a-instance"xm lns:context="/schem a/context"xm lns:aop="/schem a/aop"xsi:schem aLocation="/schem a/beans /schem a/beans/spring-beans-2.5.xsd/schem a/context/schem a/context/spring-context-2.5.xsd /schem a/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springfram ework.orm.hibernate3.LocalSessionFactoryBean"><property name="configLocation" value="classpath:hibernate.cfg.xml"/> <property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务)--><bean id="t ransactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager" ><property name="sessionFactory" ref="sessionFactory"/> </bean><bean id="t ransactionInterceptor"class="org.springframework.transaction.interceptor.TransactionInterceptor" ><property name="t ransactionManager" ref="transactionManager"/><!-- 配置事务属性--><property name="t ransactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><beanclass="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreat or"><property name="beanNames"><list><value>*Dao</value></list></property><property name="interceptorNames"><list><value>t ransactionInterceptor</value></list></property></bean><!-- 配置DAO --><bean id="userDao" class="erDaoImpl"> <property name="sessionFactory" ref="sessionFactory"/> </bean></beans>第四种方式:使用t x标签配置的拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schem a/beans"xm lns:xsi="/2001/XMLSchem a-instance"xm lns:context="/schem a/context"xm lns:aop="/schem a/aop"xm lns:tx="/schema/tx"xsi:schem aLocation="/schem a/beans /schem a/beans/spring-beans-2.5.xsd/schem a/context/schem a/context/spring-context-2.5.xsd /schem a/aop/schema/aop/spring-aop-2.5.xsd/schem a/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:com ponent-scan base-package="com.bluesky"/><bean id="sessionFactory"class="org.springfram ework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/> <property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务)--><bean id="t ransactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager" ><property name="sessionFactory" ref="sessionFactory"/> </bean><tx:advice id="txAdvice" transaction-m anager="transactionManager"> <t x:attributes><tx:method nam e="*" propagation="REQUIRED"/></t x:attributes></tx:advice><aop:config><aop:pointcut id="interceptorPointCuts"expression="execution(* com.bluesky.spring.dao.*.*(..))"/> <aop:advisor advice-ref="t xAdvice"pointcut-ref="interceptorPointCuts"/></aop:config></beans>第五种方式:全注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schem a/beans"xm lns:xsi="/2001/XMLSchem a-instance"xm lns:context="/schem a/context"xm lns:aop="/schem a/aop"xm lns:tx="/schema/tx"xsi:schem aLocation="/schem a/beans /schem a/beans/spring-beans-2.5.xsd/schem a/context/schem a/context/spring-context-2.5.xsd /schem a/aop/schema/aop/spring-aop-2.5.xsd/schem a/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:com ponent-scan base-package="com.bluesky"/><tx:annotation-driven transaction-m anager="transactionManager"/><bean id="sessionFactory"class="org.springfram ework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/> <property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务)--><bean id="t ransactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager" ><property name="sessionFactory" ref="sessionFactory"/> </bean></beans>此时在DAO上需加上@Transactional注解,如下:package com.bluesky.spring.dao;import java.util.List;import org.hibernate.SessionFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.orm.hibernate3.support.HibernateDaoSupport; import ponent;import er;@Transactional@Component("userDao")public class UserDaoImpl extends HibernateDaoSupport implements UserDao {public List<User> listUsers() {return this.getSession().createQuery("from User").list();}}。
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配置文件详解,通过spring的配置文件的配置你可以实现你的业务要求,下面就让我们来看看spring的配置文件怎么配置:想必用过Spring的程序员们都有这样的感觉,Spring把逻辑层封装的太完美了(个人感觉View层封装的不是很好)。
以至于有的初学者都不知道Spring配置文件的意思,就拿来用了。
所以今天我给大家详细解释一下Spring的applicationContext.xml文件。
Ok,还是通过代码加注释的方式为大家演示:以下是详解Spring的applicationContext.xml文件代码:<!-- 头文件,主要注意一下编码--><?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "/dtd/spring-beans.dtd"><beans><!-- 建立数据源--><bean id="dataSource" class="mons.dbcp.BasicDataSource"><!-- 数据库驱动,我这里使用的是Mysql数据库--><property name="driverClassName"><value>com.mysql.jdbc.Driver</value></property><!-- 数据库地址,这里也要注意一下编码,不然乱码可是很郁闷的哦!--><property name="url"><value>jdbc:mysql://localhost:3306/tie?useUnicode=true&characterEncoding=utf-8</value></property><!-- 数据库的用户名--><property name="username"><value>root</value></property><!-- 数据库的密码--><property name="password"><value>123</value></property></bean><!-- 把数据源注入给Session工厂--><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><property name="dataSource"><ref bean="dataSource" /></property><!-- 配置映射文件--><property name="mappingResources"><list><value>com/alonely/vo/User.hbm.xml</value></list></property></bean><!-- 把Session工厂注入给hibernateTemplate --><!-- 解释一下hibernateTemplate:hibernateTemplate提供了很多方便的方法,在执行时自动建立HibernateCallback 对象,例如:load()、get()、save、delete()等方法。
springMVC配置文件详解
web.xml的配置web.xml应该是整个项目最重要的配置文件了,不过servlet3.0中已经支持注解配置方式了。
在servlet3.0以前每个servlet必须要在web.xml中配置servlet及其映射关系。
但是在spring框架中就不用了,因为Spring中是依赖注入(Dependency Injection)的也叫控制反转(Inversion of Control)。
但是也要配置一个重要的servlet,就是前端控制器(DispatcherServlet)。
配置方式与普通的servlet基本相似。
配置内容如下:<!-- 配置前端控制器--><servlet><servlet-name>spring</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><!-- ContextconfigLocation配置springmvc加载的配置文件适配器、处理映射器等--><param-name>contextConfigLocation</param-name><param-value>WEB-INF/classes/spring/springmvc.xml</param-value></init-param></servlet><servlet-mapping><servlet-name>spring</servlet-name><!-- 1、.action访问以.action结尾的由DispatcherServlet进行解析2、/,所有访问都由DispatcherServlet进行解析--><url-pattern>/</url-pattern></servlet-mapping>这里需要注意,springmvc.xml是spring配置文件,将在后面讨论。
Springboot配置文件与配置类的属性映射方式
Springboot配置⽂件与配置类的属性映射⽅式⼀、使⽤注解@Value映射我们可以通过@Value注解将配置⽂件中的值映射到⼀个Spring管理的Bean的字段上例如:application.properties配置如下:person:name: zhangsanage: 18或者,application.yml配置如下:person:name: zhangsanage: 18实体Bean代码如下:@Controllerpublic class QuickStartController { @Value("${}") private String name; @Value("${person.age}") private Integer age; @RequestMapping("/quick") @ResponseBody public String quick(){ return "springboot 访问成功! name="+name+",age="+age; }}⼆、使⽤注解@ConfifigurationProperties映射通过注解@ConfifigurationProperties(prefifix="配置⽂件中的key的前缀")可以将配置⽂件中的配置⾃动与实体进⾏映射application.properties配置如下:person:name: zhangsanage: 18或者,application.yml配置如下:person:name: zhangsanage: 18实体Bean代码如下:@Controller@ConfigurationProperties(prefix = "person")public class QuickStartController {private String name;private Integer age;@RequestMapping("/quick")@ResponseBodypublic String quick(){ return "springboot 访问成功! name="+name+",age="+age; }public void setName(String name) { = name; } public void setAge(Integer age) { this.age = age; }}注意:使⽤@ConfifigurationProperties⽅式可以进⾏配置⽂件与实体字段的⾃动映射,但需要字段必须提供set⽅法才可以,⽽使⽤@Value注解修饰的字段不需要提供set⽅法。
SpringMVC的配置文件
SpringMVC的配置⽂件⼀、root标签跟spring配置⼀样,root标签是beans,毕竟springmvc是spring的⼀个模块在springmvc⾥,⾃动扫描主要是配置controller:⼆、⾃动扫描:⼆、⾃动扫描:在<context:component-scan base-package="com.xxx.controller"/>三、解析器Resolver:解析器有很多种,⽐较重要的是ViewResolverViewResolver也有很多种,其中⽐较重要和常⽤的是InternalResourceViewResolver(内部资源视图解析器)代码:<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"><property name="prefix" value="/WEB-INF/jsp/" /><property name="suffix" value=".jsp" /></bean>如果没有视图解析器,我们在controller⾥⾯的代码是这样的:@Controllerpublic class LoginActionController {@RequestMapping("/index")public String toIndex(HttpServletRequest request, ModelMap map, HttpSession session) {return "/WEB-INF/jsp/index.jsp";}⽽使⽤了视图解析器,我们的代码是这样的:@Controllerpublic class LoginActionController {@RequestMapping("/index")public String toIndex(HttpServletRequest request, ModelMap map, HttpSession session) {return "index";}区别在最后⼀句,我们不需要给出⽬标视图的全路径了。
Spring中Xml属性配置的解析全过程记录
Spring中Xml属性配置的解析全过程记录⽬录1 ⼯程概述1.1 pom⽂件1.2 applicationContext.xml1.3 StudentBean1.4 RoshTest1.5 运⾏结果2 流程解析2.1 源码Debug2.2 总结流程3 解析Bean标签4 ⾃定义标签解析4.1 步骤4.2 流程解析4.3 Debug总结1 ⼯程概述1.1 pom⽂件<properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><piler.source>1.8</piler.source><piler.target>1.8</piler.target><spring.version>5.2.8.RELEASE</spring.version></properties><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.16.20</version></dependency><!-- ⽇志相关依赖 --><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>1.7.10</version></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId><version>1.1.2</version></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-core</artifactId><version>1.1.2</version></dependency></dependencies>1.2 applicationContext.xml<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"default-lazy-init="false"><bean id="student" class="com.rosh.bean.StudentBean"/><context:component-scan base-package="com.rosh.service"/></beans>1.3 StudentBean@Data@AllArgsConstructor@NoArgsConstructor@ToStringpublic class StudentBean {private String name = "rosh";private String school = "杜桥中学";private String hobby = "篮球";}1.4 RoshTestpublic class RoshTest {@Testpublic void mainTest(){ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml"); StudentBean student = applicationContext.getBean(StudentBean.class);System.out.println(student.toString());}}1.5 运⾏结果2 流程解析2.1 源码Debug描述:调⽤构造⽅法中的refresh⽅法描述:调⽤AbstractApplicationContext refresh()⽅法进⾏xml解析重点:创建XML对象的解析器重点:⽤xml⽂件解析器把xml⽂件转换成Reource对象重点: Resource对象转Document对象**重点:**创建Document解析器总结: DefaultBeanDefinitionDocumentReader(Document解析器)解析xml⽂件2.2 总结流程⼤概步骤:(1) 构造。
【SpringBoot】二、SpringBoot中配置文件详解
【SpringBoot】二、SpringBoot中配置文件详解2020-04-14 23:09:39SpringBoot使用一个全局的配置文件,配置文件名是固定的,支持两种格式1、两种格式(properties,yml)application.propertiesapplication.propertiesapplication.yml由此可以看出 application.yml 文件格式的内容更为简洁,清晰,目前大部分都是YML 格式,我们主要讲 YML 格式的配置文件注意:1、以空格的缩进来控制层级关系,左对齐的一列数据,属于同一个层级2、、yml 格式:k: v,之间的空格必须有3、k 和 v 对大小写敏感4、k: v,字符串默认不用加上单引号或者双引号2、属性: 值的两种写法# k: v 方式user:name: jaychouage: 35# 行内写法user: {name: jaychou,age: 35}3、数组(List、Set)# 用- 值表示数组中的一个元素page:- page1- page2# 行内写法page: {page1,page2}4、从配置文件中取值1、手动取值ConfigurableApplicationContext context = SpringApplication.run(Applica tion.class, args);context.getEnvironment().getProperty("server.port");2、@Value(“${key}”) 取值@Value("${alipay.oauth.appid}")public String APPID;3、配置文件中${key}引用配置信息user:name: jaychouserver:name: this is ${}5、多个配置文件我们在实际的开发过程中,需要不断调试,测试,上传到云服务器中,数据库配置,redis配置,nginx配置等等,需要在云服务器和本地服务器中来回切换,我们可以创建多个配置文件,在本地开发的时候,切换为本地配置文件,上传云服务器之前切换为云服务器配置文件,这样避免了配置信息修改错误我们只需要在 application.yml 配置文件中配置:spring:# 配置文件,多个用逗号隔开profiles:active: oauth,db-localdb-local,为本地配置文件,本地开发测试用当我们上传云服务器时,只需要将配置信息修改为 db-cloud spring:# 配置文件,多个用逗号隔开profiles:active: oauth,db-cloud如您在阅读中发现不足,欢迎留言!!!。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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)主要配置如下:<!-- Mysql版--><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包。
第三种是:JNDI数据源,配置在高性能的应用服务器(如WebLogic、WebSphere等)1.<bean id="dataSource"class="org.springframework.jndi.JndiObjectFactoryBean">2.<property name="jndiName"value="java:comp/env/jdbc/bbt"/>3.</bean>从spring2.0开始提供jee命名空间,可以简化配置如下:1. <jee:jndi-lookup id="dataSource"jndi-name="java:comp/env/jdbc/bbt"/>三、配置事务管理器1、Spring JDBC 和iBatis事务管理器的配置<!-- 配置事务管理器--><bean id="TransactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource" /></bean>2、Hibernate3以上事务管理器的配置(先要集成hibernate,再配置事务管理器)1.<!-- 集成hibernate -->2.<bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">3.<property name="dataSource"ref="dataSource"/>4.<property name="mappingResources">5.<list>6.<value>classpath:product.hbm.xml</value>7.</list>8.</property>9.<property name="hibernateProperties">10.<props>11.<prop key="hibernate.dialect">12.</props>13.</property>14.</bean>15.16.<!-- 配置Hibernate事务策略 -->17.<bean id="txManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager">18.<property name="sessionFactory"ref="sessionFactory"></property>19.</bean>3、配置tx/aop声明式事务<!-- 声明一个切面-->1. <tx:advice id="txAdvice"transaction-manager="txManager">2. <tx:attributes>3. <tx:method name="find*"propagation="REQUIRED"read-only="true"/>4. <tx:method name="save*"propagation="REQUIRED"/>5. <tx:method name="update*"propagation="REQUIRED"/>6. <tx:method name="*"propagation="SUPPORTS"read-only="true"/>7. </tx:attributes>8. </tx:advice>别的例子,可以进行对比下:<tx:advice id="userTxAdvice" transaction-manager="TransactionManager"><tx:attributes><tx:method name="delete*" propagation="REQUIRED" read-only="false"rollback-for="ng.Exception" no-rollback-for="ng.RuntimeException"/><tx:method name="insert*" propagation="REQUIRED" read-only="false"rollback-for="ng.RuntimeException" /><tx:method name="update*" propagation="REQUIRED" read-only="false"rollback-for="ng.Exception" /><tx:method name="find*" propagation="SUPPORTS"/><tx:method name="get*" propagation="SUPPORTS"/><tx:method name="select*" propagation="SUPPORTS"/></tx:attributes></tx:advice><!-- 把切面注入到业务中-->1. <aop:config>2. <aop:pointcut id="productServiceMethods"expression="execution(*com.wzc.student.business.*.*(..))"/>3. <aop:advisor advice-ref="txAdvice"pointcut-ref="productServiceMethods"/>4. </aop:config>对比:<aop:config><aop:pointcut id="pc" expression="execution(public *com.haso.bscsserver.service.*.*(..))" /> <!--把事务控制在Service层--><aop:advisor pointcut-ref="pc" advice-ref="userTxAdvice" /></aop:config>四、context:component-scan<!-- 对包中的所有类进行扫描,以完成Bean创建和自动依赖注入的功能--><context:component-scan base-package="com.haso.bscsserver"><!-- 允许定义过滤器将基包下的某些类纳入或排除<context:include-filter type="annotation"expression="org.springframework.stereotype.Controller"/> --></context:component-scan>请参考/ydwuli06/article/details/6993219,具体的自己还深入研究过五、aop注解支持<!-- aop注解支持--><aop:aspectj-autoproxy proxy-target-class="true"/>六、缓存配置<!-- 缓存配置--><bean id="cacheManager"class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"><property name="configLocation" value="/WEB-INF/ehcache.xml"/></bean><!-- A facade to the Ehcache cache class --><bean id="cacheProviderFacade"class="org.springmodules.cache.provider.ehcache.EhCacheFacade"><property name="cacheManager" ref="cacheManager" /></bean><?xml version="1.0" encoding="UTF-8"?><ehcache>ehcache.xml文件:<!--name:Cache的唯一标识maxElementsInMemory:内存中最大缓存对象数maxElementsOnDisk:磁盘中最大缓存对象数,若是0表示无穷大eternal:Element是否永久有效,一但设置了,timeout将不起作用overflowToDisk:配置此属性,当内存中Element数量达到maxElementsInMemory时,Ehcache将会Element写到磁盘中timeToIdleSeconds:设置Element在失效前的允许闲置时间。