spring配置文件说明

合集下载

SpringMVC使用MultipartFile文件上传配置,多文件上传

SpringMVC使用MultipartFile文件上传配置，多文件上传，.基本的SpringMVC的搭建在我的上一篇文章里已经写过了，这篇文章主要说明一下如何使用SpringMVC进行表单上的文件上传以及多个文件同时上传的步骤一、配置文件：SpringMVC 用的是的MultipartFile来进行文件上传所以我们首先要配置MultipartResolver:用于处理表单中的file1.2.<beans:bean id="multipartResolver"class="org.springframework.web.multipmonsMultipartResolver"3.p:defaultEncoding="UTF-8"4.p:maxUploadSize="5400000"5.p:uploadTempDir="fileUpload/temp"6.>7.</beans:bean>其中属性详解：defaultEncoding="UTF-8"是请求的编码格式，默认为iso-8859-1maxUploadSize="5400000"是上传文件的大小，单位为字节uploadTempDir="fileUpload/temp"为上传文件的临时路径二、创建一个简单的上传表单：1.<body>2.<h2>文件上传实例</h2>3.4.5.<form action="fileUpload.html"method="post"enctype="multipart/form-data">6.选择文件:<input type="file"name="file">7.<input type="submit"value="提交">8.</form>9.10.11.</body>注意要在form标签中加上enctype="multipart/form-data"表示该表单是要处理文件的,这是最基本的东西，很多人会忘记然而当上传出错后则去找程序的错误，却忘了这一点三、编写上传控制类1、创建一个控制类: FileUploadController和一个返回结果的页面list.jsp2、编写提交表单的action:1.//通过Spring的autowired注解获取spring默认配置的request2.@Autowired3.private HttpServletRequest request;4.5./***6. * 上传文件用@RequestParam注解来指定表单上的file为MultipartFile7. *8. * @param file9. * @return10. */11.@RequestMapping("fileUpload")12.public String fileUpload(@RequestParam("file") MultipartFile file) {13.// 判断文件是否为空14.if (!file.isEmpty()) {15.try {16.// 文件保存路径17. String filePath = request.getSession().getServletContext().getRealPath("/") + "upload/"18. + file.getOriginalFilename();19.// 转存文件20. file.transferTo(new File(filePath));21. } catch (Exception e) {22. e.printStackTrace();23. }24. }25.// 重定向26.return"redirect:/list.html";27. }28.29./***30. * 读取上传文件中得所有文件并返回31. *32. * @return33. */34.@RequestMapping("list")35.public ModelAndView list() {36. String filePath = request.getSession().getServletContext().getRealPath("/") + "upload/";37. ModelAndView mav = new ModelAndView("list");38. File uploadDest = new File(filePath);39. String[] fileNames = uploadDest.list();40.for (int i = 0; i < fileNames.length; i++) {41.//打印出文件名42. System.out.println(fileNames[i]);43. }44.return mav;45. }3、使用SpringMVC注解RequestParam来指定表单中的file参数；4、指定一个用于保存文件的web项目路径5、通过MultipartFile的transferTo(File dest)这个方法来转存文件到指定的路径。

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文档

spring是一个开源的控制反转（inversion of control）和面向切面（AOP）的容器框架，她主要设计目标是简化开发。

如：public class UserService {private UserDAO userDAO = new UserDAO();public void addUser(User user) {userDAO.add(user);}}userDAO是在应用内部创建和维护，控制反转是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护由外部容器负责，这种控制权由应用转移到外部容器就称为反转。

当把这种控制权力交给外部容器处理之后代码可以改为public class UserService {private UserDAO userDAO;public void addUser(User user) {userDAO.add(user);}}针对这个属性可以提供构造方法中传递参数或者提供setter方法进行注入。

依赖注入（Dependency Injection）：由容器动态地将依赖对象注入到组件中。

Spring带来的好处1、降低组件之间的耦合度，实现软件各层之间的解耦。

Action →service →DAO2、可以使用容器提供相关服务，如：事务管理服务等，使用spring管理服务之后不再需要手工控制事务。

（hibernate或者是jdbc的事务相关操作代码都可以去掉）Spring的声明式事务管理可以实现复杂的事务操作。

3、容器提供单例模式，开发人员不再编写单例代码。

4、容器提供AOP技术，利用它很容易实现权限拦截、监控、日志等功能。

5、容器提供很多辅助类，利用这些类能够加快应用的开发，如：JdbcTemplate、HibernateTemplate等6、spring对于一些主流的框架提供了集成支持，如hibernate、struts、ibatis等搭建spring开发环境使用spring需要的jar在官网上下载spring的安装包dist\spring.jarlib\jakarta-commons\commons-logging.jar如果使用aop还需要Lib\aspectj\aspectjweaver.jar、aspectjrt.jarLib\cglib\cglib-nodep-2.1.3.jar如果使用JSR-250中的注解还需要使用lib\j2ee\common-annotations.jarspring配置文件，规范参考文档手册实例化spring容器方法一、在类路径下寻找配置文件来实例化容器ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{“beans.xml”,”user.xml”});方法二、在文件系统路径下需找配置文件来实例化容器ApplicationContext ctx = new FileSystemXmlApplicationContext(new String[]{“c:\\beans.xml”}); 注意：spring配置文件可以有多个，这时通过string数组传入。

SpringBoot配置文件——加载顺序

SpringBoot配置⽂件——加载顺序⼀、存放⽬录Application属性⽂件，按优先级排序，位置⾼的将覆盖位置1. 当前项⽬⽬录下的⼀个/config⼦⽬录2. 当前项⽬⽬录3. 项⽬的resources即⼀个classpath下的/config包4. 项⽬的resources即classpath根路径（root）如图：⽬录⼆、读取顺序如果在不同的⽬录中存在多个配置⽂件，它的读取顺序是：1、config/application.properties（项⽬根⽬录中config⽬录下）2、config/application.yml3、application.properties（项⽬根⽬录下）4、application.yml5、resources/config/application.properties（项⽬resources⽬录中config⽬录下）6、resources/config/application.yml7、resources/application.properties（项⽬的resources⽬录下）8、resources/application.yml顺序可以通过实验验证：1~8 个位置分别定义不同的 server 端⼝号 9001~9008即可验证结果顺序注：1、如果同⼀个⽬录下，有application.yml也有application.properties，默认先读取application.properties。

2、如果同⼀个配置属性，在多个配置⽂件都配置了，默认使⽤第1个读取到的，后⾯读取的不覆盖前⾯读取到的。

3、创建SpringBoot项⽬时，⼀般的配置⽂件放置在项⽬的resources⽬录下，因为配置⽂件的修改，通过热部署不⽤重新启动项⽬，⽽热部署的作⽤范围是classpath下三、配置⽂件的⽣效顺序，会对值进⾏覆盖1. @TestPropertySource 注解2. 命令⾏参数3. Java系统属性（System.getProperties()）4. 操作系统环境变量5. 只有在random.*⾥包含的属性会产⽣⼀个RandomValuePropertySource6. 在打包的jar外的应⽤程序配置⽂件（application.properties，包含YAML和profile变量）7. 在打包的jar内的应⽤程序配置⽂件（application.properties，包含YAML和profile变量）8. 在@Configuration类上的@PropertySource注解9. 默认属性（使⽤SpringApplication.setDefaultProperties指定）四、配置随机值roncoo.secret={random.value} roncoo.number={random.int}roncoo.bignumber={random.long} roncoo.number.less.than.ten={random.int(10)}roncoo.number.in.range=${random.int[1024,65536]}读取使⽤注解：@Value(value = "${roncoo.secret}")注：出现黄点提⽰，是要提⽰配置元数据，可以不配置五、属性占位符当application.properties⾥的值被使⽤时，它们会被存在的Environment过滤，所以你能够引⽤先前定义的值（⽐如，系统属性）=roncoo.desc = ${} is a domain nameYou can automatically expand properties from the Maven project by using resource filtering. If you use the spring-boot-starter-parent, you can then refer to your Maven ‘project properties’ with @..@ placeholders, as shown in the following example:app.encoding=@project.build.sourceEncoding@app.java.version=@java.version@六、其他配置的介绍端⼝配置server.port=8090时间格式化spring.jackson.date-format=yyyy-MM-dd HH:mm:ss时区设置spring.jackson.time-zone=Asia/Chongqing。

springmvc框架搭建之xml配置说明(spring4+hibernate4)

SpringMVC框架搭建说明Spring4.1.4 + hibernate4.3.81、web.xml配置程序运行时从web.xml开始，加载顺序为：context-param -> listener -> filter ->structs (如果使用structs的话)-> servlet如下为web.xml的配置说明<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance"xmlns="/xml/ns/javaee"xmlns:web="/xml/ns/javaee/web-app_2_5.xsd"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5"><!—-显示项目名称--><display-name>bmymis2</display-name> <context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext-*.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener </listener-class></listener><!—-字符编码过滤器,解决中文乱码问题--><filter><filter-name>encodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param><init-param><param-name>forceEncoding</param-name><param-value>true</param-value></init-param></filter><!—- springmvc配置--><servlet><servlet-name>springServlet</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet </servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath*:/spring-mvc.xml</param-value></init-param><load-on-startup>1</load-on-startup> //容器启动时首先初始化该servlet </servlet><servlet-mapping><servlet-name>springServlet</servlet-name><url-pattern>/</url-pattern> //表示所有页面都由springmvc处理</servlet-mapping><!—-浏览器输入到项目名，默认打开如下配置页面--><welcome-file-list><welcome-file>/web/login.jsp</welcome-file></welcome-file-list><!—-错误跳转页面--><error-page><error-code>404</error-code><location>/404.html</location></error-page></web-app>2、applicationContext-common.xml配置：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:xsi="/2001/XMLSchema-instance"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-4.0.xsd/schema/context/schema/context/spring-context-4.0.xsd/schema/aop/schema/aop/spring-aop-4.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd"><context:property-placeholder location="classpath:application.properties"/><!—-扫描包路径选项，使用annotation 自动注册bean,并保证@Required,@Autowired的属性被注入，有了该配置,那么<context:annotation-config/>这个配置就可以省略（以下配置包含了<context:annotation-config/>配置）--><context:component-scan base-package="xxx.xxx.xxx"/><bean id="dataSource" class="mons.dbcp.BasicDataSource"destroy-method="close"><property name="driverClassName" value="${jdbc.driverClassName}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${ername}"/><property name="password" value="${jdbc.password}"/></bean><!—Hibernate的注解配置 --><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="dataSource" ref="dataSource"/><property name="hibernateProperties"><props><prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop><prop key="hibernate.dialect">${hibernate.dialect}</prop><prop key="hibernate.show_sql">${hibernate.show_sql}</prop></props></property><property name="packagesToScan" value="xxx.xxx.xxx.model" /></bean><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="persistenceExceptionTranslationPostProcessor"class="org.springframework.dao.annotation.PersistenceExceptionTranslationPost Processor"/> <tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="add*" propagation="REQUIRED"/><tx:method name="get*" propagation="REQUIRED"/><tx:method name="*" read-only="true"/></tx:attributes></tx:advice><aop:config expose-proxy="true"><aop:pointcut id="txPointcut"expression="execution(*xxx.xxx.xxx.service..*.*(..))"/><aop:advisor pointcut-ref="txPointcut" advice-ref="txAdvice"/> </aop:config></beans>3、application.properties配置jdbc.driverClassName=org.postgresql.Driverjdbc.url=jdbc:postgresql://ip:5432/数据库名ername=postgresjdbc.password=123hibernate.dialect=org.hibernate.dialect.PostgreSQLDialecthibernate.show_sql=truehibernate.format_sql=false4、spring-mvc.xml配置<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xmlns:xsi="/2001/XMLSchema-instance"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd/schema/mvc/schema/mvc/spring-mvc-3.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd"><mvc:annotation-driven><context:component-scan base-package="xxx.xxx.xxx "use-default-filters="false"></context:component-scan><beanclass="org.springframework.web.servlet.view.InternalResourceView Resolver"><property name="prefix"value="/jsp/"/><property name="suffix"value=".jsp"/></bean> <mvc:default-servlet-handler/><mvc:view-controller path="/"view-name="login"/></beans>。

Springboot的slf4j的配置文件模板

Springboot的slf4j的配置⽂件模板使⽤⽅式在类上打上@slf4j注解打上注解后可以操作log对象增加配置⽂件在resources下增加配置⽂件。

注意⽂件名和⽬录名的修改，也可以使⽤yml⽅式配置。

<?xml version="1.0" encoding="UTF-8"?><!-- scanPeriod:设置监测配置⽂档是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。

当scan为true时，此属性⽣效。

默认的时间间隔为1分钟。

--><!-- debug:当此属性设置为true时，将打印出logback内部⽇志信息，实时查看logback运⾏状态。

默认值为false。

--><configuration scan="true" scanPeriod="10 seconds"><contextName>logback-spring</contextName><!-- name的值是变量的名称，value的值时变量定义的值。

通过定义的值会被插⼊到logger上下⽂中。

定义后，可以使“${}”来使⽤变量。

--><property name="logging.path" value="/data/jar/log/" /><conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" /><conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" /><conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" /><property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(% <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender"><filter class="ch.qos.logback.classic.filter.ThresholdFilter"><level>debug</level></filter><encoder><Pattern>${CONSOLE_LOG_PATTERN}</Pattern><charset>UTF-8</charset></encoder></appender><appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"><file>${logging.path}/calc_info.log</file><encoder><pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern><charset>UTF-8</charset></encoder><rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"><fileNamePattern>${logging.path}/calc_info-%d{yyyy-MM-dd}.%i.log</fileNamePattern><timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP"><maxFileSize>100MB</maxFileSize></timeBasedFileNamingAndTriggeringPolicy><maxHistory>15</maxHistory></rollingPolicy><filter class="ch.qos.logback.classic.filter.LevelFilter"><level>info</level><onMatch>ACCEPT</onMatch><onMismatch>DENY</onMismatch></filter></appender><!--<logger>⽤来设置某⼀个包或者具体的某⼀个类的⽇志打印级别、以及指定<appender>。

Spring的xml文件详解

Spring的xml⽂件详解spring的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-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd">........</beans>⼀直在复制黏贴，但是不知道作⽤是什么，不理解的话常出错。

xmlns和命名空间⾸先，介绍⼀下xmlns的作⽤，如下所⽰，⼀个 xml ⽂档中如果包含如下两种定义不同，但是名称相同的元素， xml 解析器是⽆法解析的，因为它不能确定当你调⽤document.getElementsByTagName("book") 时应该返回哪个元素。

<table><tr><td>Apples</td><td>Bananas</td></tr></table><table><name>African Coffee Table</name><width>80</width><length>120</length></table>这时候可以通过在名称增加前缀解决这个问题<h:table> <h:tr><h:td>Apples</h:td><h:td>Bananas</h:td></h:tr></h:table><f:table> <f:name>African Coffee Table</f:name><f:width>80</f:width><f:length>120</f:length></f:table>由此，引⼊⼀个概念命名空间，通过增加前缀表⽰不同的那是不同命名空间下的table，从⽽解决了⽭盾，但是不同的⼈都有⾃⼰创建的不同的命名空间来描述同样的东西，不利于xml⽂件信息的解析，⽐如说，同样都是⽔果，可以从颜⾊和⾹味不同⾓度来定义成如下两种形式：<perfume:fruit><name>....</name><perfume>.....</perfume></perfume:fruit><color:fruit><name>....</name><color>....</color></color:fruit>为此，w3c(万维⽹联盟)对于⼀些类型，定义了对应的命名空间和这些类型的标准，xml解释器碰到这些类型的时候就会通过这些标准去解析这类型的标签，为了确保命名空间的唯⼀，所以不同的命名空间的通常使⽤URL作为被识别的id，如下例⼦:xmlns:xsi="/2001/XMLSchema-instance"这句话的作⽤是当前引⼊了⼀个叫做xsi的命名空间，xsi可以在接下来要使⽤该命名空间时所使⽤的，如下:<xsi:schemaLocation="...... ......">⽽这个很长的字符串，则是xsi这个名称空间被xml解释器内部所识别的时候所真正使⽤的id，但也本⾝只是被当做⼀个字符串名字去处理，xml解释器根据这个id去获取它对应的标准，从⽽知道这个命名空间定义有什么样的标签(xml解释器⾃带有⼀些通⽤的命名空间的标准)，这个字符串虽然看起来是URL，但是和对应的⽹页上的信息没有关系，只是⽤来提供命名空间唯⼀性的作⽤，⽹址有时可以被打开，上⾯会有关于该命名空间的信息。

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的文件路径，配置文件

springboot的⽂件路径，配置⽂件
⽣成springboot会指定⼀个包路径，启动的class⽂件在这个⽬录下，其他的controller等也要在这个⽬录的⼦⽬录下，不然会扫不到。

⼀般我们会维护两三个配置⽂件：⽣产环境，开发环境，测试环境
所以application.yml
⼀般
spring:
profiles:
active: shydev
只需要配⼀个激活配置就⾏
这是项⽬的配置⽂件明细
这是shydev的配置⽂件
spring:
profiles: shydev
我看到很多⼈⽣产环境喜欢命名为pro，不过我踩了⼀个坑，在配置jekins启动的脚本的时候 sed -i s/pro/dev/ application.yml,项⽬启动失败，我⾮常纳闷⼉，
最后才发现，配置⽂件⾥有profiles这个单词也有pro，所以配置⽂件命名最好起不撞车的。

不然很莫名其妙的就出问题。

springboot目录结构和配置文件详解

springboot目录结构和配置文件详解Spring Boot是一个用于创建独立的、基于生产级别的Spring应用程序的框架。

它具备了自动配置、内嵌服务器和依赖管理等特性，使得开发人员可以更加便捷地创建和部署Spring应用程序。

在使用Spring Boot开发应用程序时，了解其目录结构和配置文件是非常重要的。

本文将详细介绍Spring Boot的目录结构和配置文件。

一、目录结构Spring Boot的项目目录结构与传统的Java Web项目有些不同，主要包括以下几个目录：1. src/main/java：该目录用于存放项目的源代码文件。

2. src/main/resources：该目录用于存放项目的资源文件，如配置文件、静态资源文件等。

3. src/test/java：该目录用于存放项目的测试用例代码文件。

4. src/test/resources：该目录用于存放项目的测试用例的资源文件。

除了以上几个目录外，还有一些重要的文件如下：1. pom.xml：该文件是项目的依赖管理文件，用于配置项目所需的依赖库。

2. application.properties/application.yml：这是Spring Boot 的配置文件，用于配置应用程序的参数。

二、配置文件在Spring Boot中，配置文件主要包括两种形式：properties和yml。

1. application.properties：application.properties是以key=value的形式配置的文本文件。

其中，key为配置项的名称，value为配置项的值。

以下是一个示例的application.properties文件：```#数据库连接配置#服务器端口配置server.port=8080#日志级别配置.springframework=INFO```在上述示例中，配置了数据库连接URL、用户名和密码，服务器端口和日志级别等配置项。

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与构造函数参数相同类型，则一个致命的错误会产生。

springMVC配置（XML配置详解）

springMVC配置（XML配置详解）原⽂出⾃：web.xml配置：servlet><servlet-name>dispatcher</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><description>加载/WEB-INF/spring-mvc/⽬录下的所有XML作为Spring MVC的配置⽂件</description><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/spring-mvc/*.xml</param-value></init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>dispatcher</servlet-name><url-pattern>*.htm</url-pattern></servlet-mapping>这样，所有的.htm的请求，都会被DispatcherServlet处理；初始化 DispatcherServlet 时，该框架在 web 应⽤程序WEB-INF ⽬录中寻找⼀个名为[servlet-名称]-servlet.xml的⽂件，并在那⾥定义相关的Beans，重写在全局中定义的任何Beans，像上⾯的web.xml中的代码，对应的是dispatcher-servlet.xml；当然也可以使⽤<init-param>元素，⼿动指定配置⽂件的路径；dispatcher-servlet.xml 配置：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd/schema/aop/schema/aop/spring-aop-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/mvc/schema/mvc/spring-mvc-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"><context:component-scan base-package="com.minx.crm.web.controller"/><bean id="viewResolver"class="org.springframework.web.servlet.view.InternalResourceViewResolver"p:prefix="/WEB-INF/jsp/"p:suffix=".jsp" /></beans>第⼀个Controller：package com.minx.crm.web.controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;@Controllerpublic class IndexController {@RequestMapping("/index")public String index() {return "index";}}@Controller注解标识⼀个控制器，@RequestMapping注解标记⼀个访问的路径（/index.htm），return "index"标记返回视图（index.jsp）；注：如果@RequestMapping注解在类级别上，则表⽰⼀相对路径，在⽅法级别上，则标记访问的路径；从@RequestMapping注解标记的访问路径中获取参数：Spring MVC ⽀持RESTful风格的URL参数，如：@Controllerpublic class IndexController {@RequestMapping("/index/{username}")public String index(@PathVariable("username") String username) {System.out.print(username);return "index";}}在@RequestMapping中定义访问页⾯的URL模版，使⽤{}传⼊页⾯参数，使⽤@PathVariable 获取传⼊参数，即可通过地址：http://localhost:8080/crm/index/tanqimin.htm 访问；根据不同的Web请求⽅法，映射到不同的处理⽅法：使⽤登陆页⾯作⽰例，定义两个⽅法分辨对使⽤GET请求和使⽤POST请求访问login.htm时的响应。

SpringBoot-application：application.yml配置文件详解

SpringBoot-application：application.yml配置⽂件详解springboot采纳了建⽴⽣产就绪应⽤程序的观点。

Spring Boot优先于配置的惯例，旨在让您尽快启动和运⾏。

在⼀般情况下，我们不需要做太多的配置就能够让spring boot正常运⾏。

在⼀些特殊的情况下，我们需要做修改⼀些配置，或者需要有⾃⼰的配置属性。

1.1、⼀、⾃定义属性当我们创建⼀个springboot项⽬的时候，系统默认会为我们在src/main/Java/resources⽬录下创建⼀个application.properties。

个⼈习惯，我会将application.properties改为application.yml⽂件，两种⽂件格式都⽀持。

在application.yml⾃定义⼀组属性：my:name: forezpage: 12如果你需要读取配置⽂件的值只需要加@Value(“${属性名}”)：@RestControllerpublic class MiyaController {@Value("${}")private String name;@Value("${my.age}")private int age;@RequestMapping(value = "/miya")public String miya(){return name+":"+age;}}启动⼯程，访问：localhost:8080/miya,浏览器显⽰：forezp:12⼆、将配置⽂件的属性赋给实体类当我们有很多配置属性的时候，这时我们会把这些属性作为字段来创建⼀个javabean，并将属性值赋予给他们,⽐如：my:name: forezpage: 12number: ${random.int}uuid : ${random.uuid}max: ${random.int(10)}value: ${random.value}greeting: hi,i'm ${}其中配置⽂件中⽤到了${random} ，它可以⽤来⽣成各种不同类型的随机值。

Spring部分配置详解

Spring组件扫描<context:component-scan/>使用详解1.如果不想在xml文件中配置bean，我们可以给我们的类加上spring组件注解，只需再配置下spring的扫描器就可以实现bean的自动载入。

<context:annotation-config></context:annotation-config><context:component-scan base-package="mon.service.impl" /><context:component-scan base-package="mon.dao.ibatis" /><context:component-scan base-package="com.liantuo.hotel.app.dao.ibatis" /><context:component-scan base-package="com.liantuo.hotel.app.service" /><context:component-scan base-package="com.liantuo.hotel.app.service.ibatis" />2.下面是引用spring framework开发手册中的一段话“Spring 2.5引入了更多典型化注解(stereotype annotations)：@Component、@Service和@Controller。

@Component是所有受Spring管理组件的通用形式；而@Repository、@Service和@Controller则是@Component的细化，用来表示更具体的用例(例如，分别对应了持久化层、服务层和表现层)。

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所对应的加载配置⽂件的路径。

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><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><url-pattern>/</url-pattern></servlet-mapping>这里需要注意，springmvc.xml是spring配置文件，将在后面讨论。

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";}区别在最后⼀句，我们不需要给出⽬标视图的全路径了。

SpringBoot的核心配置文件

SpringBoot的核⼼配置⽂件⽬录Spring Boot 的核⼼配置⽂件⽤于配置 Spring Boot 程序，名字必须以 application 开始⼀、核⼼配置格式1. .properties ⽂件（默认采⽤该⽂件）在 02-springboot-springmvc 项⽬基础上，进⾏修改，也就是在上⼀个项⽬上项⽬名称为：03-springboot-port-context-path通过修改 application.properties 配置⽂件，在修改默认 tomcat 端⼝号及项⽬上下⽂件根键值对的 properties 属性⽂件配置⽅式#设置内嵌的Tomcat的端⼝号server.port=9090#配置项⽬的上下⽂根server.servlet.context-path=/03-springboot-port-context-path配置完毕之后，启动，浏览器测试页⾯显⽰结果2. .yml ⽂件项⽬名称：04-springboot-yml在03的项⽬基础上为了区分，把SpringbootController稍作修改package com.md.springboot.web;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;/*** @author MD* @create 2020-08-20 16:40*/@Controllerpublic class SpringbootController {@RequestMapping(value = "/say")@ResponseBodypublic String say(String name){return "hello " + name;}}yml 是⼀种 yaml 格式的配置⽂件，主要采⽤⼀定的空格、换⾏等格式排版进⾏配置。

springboot配置文件和第三方依赖包外部配置

springboot配置⽂件和第三⽅依赖包外部配置⼀、导出相关的依赖包mvn clean install解压当前项⽬的jar包将这个 lib 拷贝被linux的⼀个⽬录下⼆、去除项⽬打包的第三⽅依赖包1. 修改 pom<plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration> <mainClass>com.gdfxit.foundwater.PrjApplication</mainClass> <layout>ZIP</layout><includes><include><groupId>nothing</groupId><artifactId>nothing</artifactId></include></includes></configuration></plugin>执⾏ mvn clean install将打好的包放在，linux服务器，跟 lib同个⽬录（可以不同，启动时得指定绝对路径）三、读取外部配置⽂件jar同个⽬录新建 config 这个⽂件加，然后把配置⽂件放进去四、启动测试java -Dloader.path=/path/to/lib -jar 名称.jar/path/to/lib 是依赖包的绝对路径或者相对路径五、编写脚本⼯具启动可以在 jar同⽬录下新建⼀个 .sh⽂件#!/bin/shjarpath=/jar路径/名称.jarlogspath=/⽇志⽂件路径/prod.logpid=`ps aux | grep $jarpath | grep -v grep | awk '{print $2}'` if [ ! $pid = '' ]thenecho '存在 ' $jarpath ' 进程！'echo '开始杀掉PID为 ' $pid ' 的进程！'kill -9 $pidecho '进程已杀掉！'elseecho '没有 ' $jarpath ' 的进程！'fiecho '开始执⾏ ' $jarpathnohup java -Dloader.path=/lib路径/lib -jar $jarpath > $logspath 2>&1 & echo '执⾏ ' $jarpath ' 成功，⽇志⽬录为 ' $logspath。