applicationContext配置文件

基于spring-mvc.xml和application-context.xml的配置与深入理解

基于spring-mvc.xml和application-context.xml的配置与深⼊理解⽬录前沿1、application-context.xml是全局的2、spring-mvc.xml 是spring mvc的配置（1）application-context.xml配置1、⾸先介绍⼀下启动⼀个项⽬的整体流程：2、现在开始正式讲解applicationContext.xml中的配置内容⾸先准备db.properties 配置⽂件SqlSessionTemplate介绍：applicationContext.xml配置：Spring和Mybatis整合有两种⽅式事务管理的两种⽅式：（2）sping-mvc.xml的配置1.⾃动扫描2.注解驱动3.静态资源处理4.避免IE执⾏AJAX时，返回JSON出现下载⽂件5.启动SpringMVC的注解功能，完成请求和注解POJO的映射6.配置⽂件上传7.配置viewResolver视图解析8.定义跳转的⽂件的前后缀，视图模式配置前沿1、application-context.xml是全局的应⽤于多个serverlet，配合listener⼀起使⽤，web.xml中配置如下：<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value></context-param>2、spring-mvc.xml 是spring mvc的配置web.xml中配置如下：<servlet><servlet-name>springMVC</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:config/spring-mvc.xml</param-value></init-param><load-on-startup>1</load-on-startup><async-supported>true</async-supported></servlet>application-context.xml这个⼀般是采⽤⾮spring mvc架构，⽤来加载Application Context。

Spring中加载xml配置文件的几种方式

项目中一个需求就是所有的功能都是插件的形式装入系统，这就需要利用Spring去动态加载某一位置下的配置文件，就总结了下Spring中加载xml配置文件的方式, xml是最常见的spring 应用系统配置源。

Spring中的几种容器都支持使用xml装配bean，包括：XmlBeanFactory,ClassPathXmlApplicationContext,FileSystemXmlApplicationContext,XmlWebApplicationContext,.....一: XmlBeanFactory 引用资源1.Resource cr = new ClassPathResource("applicationContext.xml");BeanFactory bf=new XmlBeanFactory(cr);UserDao userDao = (UserDao)bf.getBean("userDao");二: ClassPathXmlApplicationContext 编译路径使用ClassPathXmlApplicationContext对象获取，必须把applicationContext.xml放置到类的加载路径中，也就是Src下面1.ApplicationContext factory=new ClassPathXmlApplicationContext("classpath:appcontext.xml");// src目录下的2.ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao userDao = (UserDao)context.getBean("userDao");3.ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext-oracle.xml","applicationContext.xml"});UserDao userDao = (UserDao)context.getBean("userDao");// src/conf 目录下的4.ApplicationContext factory=new ClassPathXmlApplicationContext("conf/appcontext.xml");5.ApplicationContext factory=new ClassPathXmlApplicationContext("file:G:/Test/src/appcontext.xml");三: FileSystemXmlApplicationContext用文件系统的路径必须把applicationContext.xml放置到工程目录下面，也就是项目路径的下面1.ApplicationContext factory=newFileSystemXmlApplicationContext("src/appcontext.xml");//使用了classpath: 前缀,作为标志, 这样,FileSystemXmlApplicationContext 也能够读入classpath下的相对路径没有classpath的话就是从当前的工作目录2.ApplicationContext factory=newFileSystemXmlApplicationContext("classpath:appcontext.xml");3.ApplicationContext factory=newFileSystemXmlApplicationContext("file:G:/Test/src/appcontext.xml");4.ApplicationContext factory=newFileSystemXmlApplicationContext("G:/Test/src/appcontext.xml");四: XmlWebApplicationContext是专为Web工程定制的。

Web.xml配置详解之context

Web.xml配置详解之context•格式定义：[html] view plaincopy1.<context-param>2.<param-name>contextConfigLocation</param-name>3.<param-value>contextConfigLocationValue></param-value>4.</context-param>作用：该元素用来声明应用范围(整个WEB项目)内的上下文初始化参数。

param-name 设定上下文的参数名称。

必须是唯一名称param-value 设定的参数名称的值•初始化过程：1.在启动Web项目时，容器(比如Tomcat)会读web.xml配置文件中的两个节点<listener>和<contex-param>。

2.接着容器会创建一个ServletContext(上下文),应用范围内即整个WEB项目都能使用这个上下文。

3.接着容器会将读取到<context-param>转化为键值对,并交给ServletContext。

4.容器创建<listener></listener>中的类实例,即创建监听（备注：listener定义的类可以是自定义的类但必须需要继承ServletContextListener）。

5.在监听的类中会有一个contextInitialized(ServletContextEvent event)初始化方法，在这个方法中可以通过event.getServletContext().getInitParameter("contextConfigLocat ion") 来得到context-param 设定的值。

在这个类中还必须有一个contextDestroyed(ServletContextEvent event) 销毁方法.用于关闭应用前释放资源，比如说数据库连接的关闭。

jersey+spring+hibernate配置

3.3. 创建 Hibernate 配置文件 hibernate.cfg.xml
如果在src/resource目录下面建立，需要把resource目录作为源代码路径，目的是使applicationContext.xml可以输出到WebRoot\WEB-INF\CLASSES目录下面；
第 6 页共 11 页
Hibernate.cfg.xml配置文件的内容如下：
<?xml version='1.0' encoding='UTF-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "/hibernate-configuration3.0.dtd"> <hibernate-configuration> <session-factory> <property name="connection.url">jdbc:mysql://localhost:3306/test</property> <property name="ername">root</property> <property name="connection.password">123123</property> <property name="connection.driver_class">com.mysql.jdbc.Driver</property>  <property name="dialect">org.hibernate.dialect.MySQLDialect</property>  <property name="show_sql">true</property>  <property name="hbm2ddl.auto">update</property>  <property name="hibernate.c3p0.min_size">1</property> <property name="hibernate.c3p0.max_size">20</property>  <property name="hibernate.c3p0.timeout">5000</property>  <property name="hibernate.c3p0.max_statements">100</property> <property name="hibernate.c3p0.idle_test_period">3000</property> <property name="hibernate.c3p0.acquire_increment">2</property> <property name="hibernate.c3p0.validate">true</property>  <mapping resource="com/pakko/bus/domain/User.cfg.xml" /> </session-factory> </hibernate-configuration>

applicationContext.xml详解

想必用过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" "http://www.spri /dtd/spring-beans.dtd"><beans><bean id="dataSource" class="mons.dbcp.BasicDataSourc e"><property name="driverClassName"><value>com.mysql.jdbc.Driver</value></property><property name="url"><value>jdbc:mysql://localhost:3306/tie?useUnicode=true&characterEnco ding=utf-8</value></property><property name="username"><value>root</value></property><property name="password"><value>123</value></property></bean><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><!-- 解释一下hibernateTemplate：hibernateTemplate提供了很多方便的方法，在执行时自动建立HibernateCallback 对象，例如：load()、get()、save、delete()等方法。

spring成神之路第三篇：Spring容器基本使用及原理（ApplicationCont。。。

spring成神之路第三篇：Spring容器基本使⽤及原理（ApplicationCont。

1. jdk1.82. idea3. maven-3.6.14. spring-5.2.3.RELEASEIOC容器是具有依赖注⼊功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个⽣命周期都是由容器来控制。

我们需要使⽤的对象都由ioc容器进⾏管理，不需要我们再去⼿动通过new的⽅式去创建对象，由ioc 容器直接帮我们组装好，当我们需要使⽤的时候直接从ioc容器中直接获取就可以了。

那么spring ioc容器是如何知道需要管理哪些对象呢？需要我们给ioc容器提供⼀个配置清单，这个配置⽀持xml格式和java注解的⽅式，在配置⽂件中列出需要让ioc容器管理的对象，以及可以指定让ioc容器如何构建这些对象，当spring容器启动的时候，就会去加载这个配置⽂件，然后将这些对象给组装好以供外部访问者使⽤。

这⾥所说的IOC容器也叫spring容器。

由spring容器管理的对象统称为Bean对象。

Bean就是普通的java对象，和我们⾃⼰new的对象其实是⼀样的，只是这些对象是由spring去创建和管理的，我们需要在配置⽂件中告诉spring容器需要创建哪些bean对象，所以需要先在配置⽂件中定义好需要创建的bean对象，这些配置统称为bean定义配置元数据信息，spring容器通过读取这些bean配置元数据信息来构建和组装我们需要的对象。

1. 引⼊spring相关的maven配置2. 创建bean配置⽂件，⽐如bean xml配置⽂件3. 在bean xml⽂件中定义好需要spring容器管理的bean对象4. 创建spring容器，并给容器指定需要装载的bean配置⽂件，当spring容器启动之后，会加载这些配置⽂件，然后创建好配置⽂件中定义好的bean对象，将这些对象放在容器中以供使⽤5. 通过容器提供的⽅法获取容器中的对象，然后使⽤spring内部提供了很多表⽰spring容器的接⼝和对象，我们来看看⽐较常见的⼏个容器接⼝和具体的实现类。

BeanFactory和ApplicationContext的区别总结

BeanFactory和ApplicationContext的区别总结BeanFactory：是Spring⾥⾯最底层的接⼝，提供了最简单的容器的功能，只提供了实例化对象和拿对象的功能；ApplicationContext：应⽤上下⽂，继承BeanFactory接⼝，它是Spring的⼀各更⾼级的容器，提供了更多的有⽤的功能；1) 国际化（MessageSource）2) 访问资源，如URL和⽂件（ResourceLoader）3) 载⼊多个（有继承关系）上下⽂，使得每⼀个上下⽂都专注于⼀个特定的层次，⽐如应⽤的web层4) 消息发送、响应机制（ApplicationEventPublisher）5) AOP（拦截器）两者装载bean的区别BeanFactory：BeanFactory在启动的时候不会去实例化Bean，中有从容器中拿Bean的时候才会去实例化；ApplicationContext：ApplicationContext在启动的时候就把所有的Bean全部实例化了。

它还可以为Bean配置lazy-init=true来让Bean延迟实例化；我们该⽤BeanFactory还是ApplicationContent延迟实例化的优点：（BeanFactory）应⽤启动的时候占⽤资源很少；对资源要求较⾼的应⽤，⽐较有优势；不延迟实例化的优点：（ApplicationContext）1. 所有的Bean在启动的时候都加载，系统运⾏的速度快；2. 在启动的时候所有的Bean都加载了，我们就能在系统启动的时候，尽早的发现系统中的配置问题3. 建议web应⽤，在启动的时候就把所有的Bean都加载了。

（把费时的操作放到系统启动中完成）BeanFactory类关系继承图1. BeanFactory类结构体系：BeanFactory接⼝及其⼦类定义了Spring IoC容器体系结构，由于BeanFactory体系⾮常的庞⼤和复杂，因此要理解Spring IoC，需要先理清BeanFactory的继承机构。

Spring考试

• 1.(单选题)下列关于Spring配置文件的说法不正确的是o A.Spring默认是读取/WEB-INF/applicationContext.xml配置文件o B.Spring的配置文件可以配置在类路径下，并可以重命名，但是需要在web.xml 文件中指定o C.把applicationContext.xml文件放到src目录下，Spring也可以读到o D.可以通过在web.xml中的<context-param><param-name>和<param-value>进行指定Spring配置文件Dlgtq。

正确答案：C把applicationContext.xml文件放到src目录下，需要在web。

xml里设置<context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/classes/applicationContext.xml</param-value>0jpk 7。

</context-param>可以让spring读到• 2.(单选题)下列关于Spring特性中IoC描述错误的是o A.IoC就是指程序之间的关系由程序代码直接操控o B.所谓“控制反转”是指控制权由应用代码转到外部容器，即控制权的转移o C.IoC将控制创建的职责搬进了框架中，从应用代码脱离开来o D.使用Spring的IoC容器时只需指出组件需要的对象，在运行时Spring的IoC 容器会根据XML配置数据提供给它7Jtg8。

正确答案：AIOC是来完成相互依赖的对象的创建、协调工作。

• 3.(单选题)下列关于Spring的装配模式（default-autowire）描述不正确的是o A.Spring中，至少有两种装配模式，按“类型”和“名字”o B.Spring中默认是按名字进行装配的o C.可以用default-autowire=”byType”配置按类型装配o D.一旦在一个Spring配置文件中配置了default-autowire=”byType”，其它的配置文件也是按此种装配方式进行装配ADtbu。

tomcat context.xml resource 参数

tomcat context.xml resource 参数Tomcat 的context.xml文件是用于配置每个Web应用程序的上下文配置文件。

在该文件中，可以定义和配置各种资源，其中包括数据库连接池、JMS 连接工厂、邮件会话等。

在context.xml文件中，资源的配置参数被用来定义和配置这些资源。

以下是一个关于Tomcat context.xml文件中资源参数配置的简要说明：1. 数据库连接池配置在context.xml文件中，可以配置数据库连接池，以提高对数据库的访问效率。

以下是一个简单的数据库连接池的配置示例：<Context><Resource name="jdbc/MyDB"auth="Container"type="javax.sql.DataSource"maxTotal="100"maxIdle="30"maxWaitMillis="10000"username="db_user"password="db_password"driverClassName="com.mysql.cj.jdbc.Driver"url="jdbc:mysql://localhost:3306/mydatabase"/></Context>在这个示例中，<Resource>元素定义了一个名为“jdbc/MyDB” 的数据库连接池资源。

各种参数包括：•type：指定资源的类型，这里是javax.sql.DataSource表示数据源。

•maxTotal：连接池中允许的最大连接数。

•maxIdle：连接池中允许的最大空闲连接数。

•maxWaitMillis：在连接池耗尽时，客户端等待连接的最大毫秒数。

web.xml配置文件超详细说明！！！

web.xml配置⽂件超详细说明！！！⼀、web.xml是什么？⾸先 web.xml 是java web 项⽬的⼀个重要的配置⽂件，但是web.xml⽂件并不是Java web⼯程必须的。

web.xml⽂件是⽤来配置：欢迎页、servlet、filter等的。

当你的web⼯程没⽤到这些时，你可以不⽤web.xml⽂件来配置你的web⼯程。

所在位置项⽬名/web/WEB-INFO/web.xml，如下图所⽰web.xml能做的事情：其实，web.xml的模式(Schema)⽂件中定义了多少种标签元素，web.xml中就可以出现它的模式⽂件所定义的标签元素，它就能拥有定义出来的那些功能。

web.xml的模式⽂件是由Sun公司定义的，每个web.xml⽂件的根元素<web-app>中，都必须标明这个web.xml使⽤的是哪个模式⽂件。

如：web.xml 配置⽂件具体的内容⼆、Web.xml详解：1.web.xml加载过程（步骤）⾸先简单讲⼀下，web.xml的加载过程。

当启动⼀个WEB项⽬时，容器包括（JBoss、Tomcat等）⾸先会读取项⽬web.xml配置⽂件⾥的配置，当这⼀步骤没有出错并且完成之后，项⽬才能正常地被启动起来。

1. 启动WEB项⽬的时候，容器⾸先会去它的配置⽂件web.xml读取两个节点: <listener></listener>和<context-param></context-param>。

2. 紧接着，容器创建⼀个ServletContext（application），这个WEB项⽬所有部分都将共享这个上下⽂。

3. 容器以<context-param></context-param>的name作为键，value作为值，将其转化为键值对，存⼊ServletContext。

4. 容器创建<listener></listener>中的类实例，根据配置的class类路径<listener-class>来创建监听，在监听中会有contextInitialized(ServletContextEvent args)初始化⽅法，启动Web应⽤时，系统调⽤Listener的该⽅法，在这个⽅法中获得：[html]1. <span style="font-family:Times New Roman;">ServletContextapplication=ServletContextEvent.getServletContext();</span>context-param的值就是application.getInitParameter("context-param的键");得到这个context-param的值之后，你就可以做⼀些操作了。

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配置文件，将在后面讨论。

将 Shiro 作为应用的权限基础五：SpringMVC+Apache Shiro+JPA(hibernate)整合配置

实现了首页隐藏的目的,详见spring-mvc.xml
-->

</web-app>
applicationContext.xml
<?xmlversion="1.0"encoding="UTF-8"?>
</listener>


<listener>
<listener-class>
er
xmlns:cache="/schema/cache"
xmlns:jaxws="/jaxws"
xsi:schemaLocation=" /schema/beans /schema/beans/spring-beans-3.1.xsd
<param-value>classpath*:applicationContext*.xml</param-value>
</context-param>

Spring考试

36.0• 1.(单选题)下列关于Spring配置文件的说法不正确的是o A.Spring默认是读取/WEB-INF/applicationContext.xml配置文件o B.Spring的配置文件可以配置在类路径下，并可以重命名，但是需要在web.xml 文件中指定o C.把applicationContext.xml文件放到src目录下，Spring也可以读到o D.可以通过在web.xml中的<context-param><param-name>和<param-value>进行指定Spring配置文件正确答案：C把applicationContext.xml文件放到src目录下，需要在web。

xml里设置<context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/classes/applicationContext.xml</param-value> </context-param>可以让spring读到• 2.(单选题)下列关于Spring特性中IoC描述错误的是o A.IoC就是指程序之间的关系由程序代码直接操控o B.所谓“控制反转”是指控制权由应用代码转到外部容器，即控制权的转移o C.IoC将控制创建的职责搬进了框架中，从应用代码脱离开来o D.使用Spring的IoC容器时只需指出组件需要的对象，在运行时Spring的IoC 容器会根据XML配置数据提供给它正确答案：AIOC是来完成相互依赖的对象的创建、协调工作。

• 3.(单选题)下列关于Spring的装配模式（default-autowire）描述不正确的是o A.Spring中，至少有两种装配模式，按“类型”和“名字”o B.Spring中默认是按名字进行装配的o C.可以用default-autowire=”byType”配置按类型装配o D.一旦在一个Spring配置文件中配置了default-autowire=”byType”，其它的配置文件也是按此种装配方式进行装配正确答案：D在<beans></beans>标签中指定default-autowire属性，那么对于子标签<bean></bean>如果没有单独的设置autowire属性，那么将采用父标签<beans></beans>的default-autowire属性的模式，如果单独设置了autowire 属性，则采用自己的模式• 4.(单选题)下列选项关于Spring的核心机制——依赖注入的描述正确的是o A.所谓依赖注入就是明确地定义组件接口，独立开发各个组件，然后根据组件间的依赖关系组装运行的设计开发模式o B.Spring不负责管理bean之间的关系o C.<bean>节点有可选的<property>子节点，用于注入bean的属性o D.在Spring的配置文件中，使用<bean>来创建Bean的实例正确答案：BSpring通过一个配置文件描述Bean及Bean之间的依赖关系，利用java语言的反射功能实例化Bean并建立Bean之间的依赖关系。

applicationContext.xml 配置文件的存放位置

applicationContext.xml 配置文件的存放位置web.xml中classpath:和classpath*: 有什么区别?classpath：只会到你的class路径中查找找文件;classpath*：不仅包含class路径，还包括jar文件中(class路径)进行查找.存放位置：1：src下面需要在web.xml中定义如下：<context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value>< /context-param>2：WEB-INF下面需要在web.xml中定义如下：<context-param><param-name>contextConfigLocation</param-name><param-value>WEB-INF/applicationContext*.xml</param-value>< /context-param>web.xml 通过contextConfigLocation配置spring 的方式SSI框架配置文件路径问题：struts2的 1个+N个路径：src+src(可配置) 名称： struts.xml + N spring 的 1个路径： src 名称： applicationContext.xml ibatis 的 1个+N个路径：src+src(可配置) 名称： SqlMapConfig.xml + N部署到应用服务器(tomcat)后，src目录下的配置文件会和class文件一样，自动copy到应用的 classes目录下spring的配置文件在启动时，加载的是web-info目录下的applicationContext.xml,运行时使用的是web-info/classes目录下的applicationContext.xml。

SpringBoot配置文件application.properties配置参数替换或者注。。。

SpringBoot配置⽂件application.properties配置参数替换或者注。

想要忽略properties中的某些属性，引发的对SpringBoot中的application.properties外部注⼊覆盖，以及properties⽂件使⽤的思考。

SpringBoot 配置⽂件application.properties配置参数替换或者注⼊的⼏种⽅式之所以研究这个问题，原因是因为，我的项⽬如果通过git备份到码云上之后，mysql以及redis的密码也保存上去了，这样肯定是不⾏的，但是我如果忽略application.properties的话，就缺失了关键的配置信息；该怎么办呢？我开始的想法是能不能把这些密码参数放到另⼀个properties中，然后通过注⼊（类似把properties中的常量注⼊到java⽂件中，或者是properties⽂件，同⼀个⽂件内引⽤${}的⽅式），所以按照这种注⼊的思维百度了很久，但是都没有找到解决办法…加载顺序引⼊后来师兄告诉我，你可以通过SpringBoot加载⽬录顺序来进⾏配置⽂件优先级覆盖，不⽤注⼊，在另⼀个地⽅写⼀个application.properties，利⽤SpringBoot加载顺序不同，优先级不同，在resources⽬录下新建⼀个config⽬录，在config⽬录下新建⼀个application.properties，在resources/config/application.properties下的配置加上密码之类的，⽽resources/application.properties中放上配置信息，所有的密码地址，等隐私信息给成默认的值就⾏了，⽐如localhost或者root注意：这⾥的加载顺序是越往后越优先，后⾯覆盖前⾯的，和SpringBoot静态资源的顺序不同顺便补充静态资源的加载顺序：/META-INF/resources/ > /resources/ > /static/ > /public/，这种顺序不同，当然如果你在application.properties中重写了spring.resources.static-locations，那另当别论，重写之后按照定义的顺序进⾏加载spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/,classpath:/mzywucai/师兄说了之后，我就去了解了⼀下SpringBoot的加载顺序：学习了SpringBoot配置⽂件的加载顺序SpringBoot的配置⽂件可以放在四个地⽅，读取顺序不同(以下yml和properties均是如此)：读取顺序分别是（越靠前越优先，优先越⾼的地⽅读取到了就不会读取后⾯的了）1.项⽬根⽬录中的config/application.properties2.项⽬根⽬录下的application.properties3.项⽬src/main/resources/config/下的appliacation.properties4.项⽬src/main/resources/下的application.properties（我们最常见的那个application.properties）java -jar 时参数注⼊application.properties核⼼参数但是我⼜出现了⼀个问题，在做完学院的设备管理之后，⽼师要求系统要改改占⽤的端⼝，⽅便管理，但是我每次只改⼀个server.port就要重新打包，岂不是很不划算？所以看到了，读了博主的⽂章，还额外解除了许多疑惑！1.参数通过properties注⼊类的时候，如果是在application.properties中不⽤加上@PropertySource({“classpath:application.properties”})// 博主在⽂中写到，如果是在application.properties中的常量，// 那么忘类中注⼊常量的时候，就不⽤在类上⾯声明// @PropertySource({"classpath:application.properties"})// 只有在名字为其它的properties配置⽂件的时候，才需要声明@PropertySource({"xxx.properties"})// 例如：// @PropertySource({"classpath:resource.properties"})// 然后在类中的成员变量上加上注解：@Value("${配置⽂件的全名称}") 就⾏了// 可以看到这⾥的@PropertySource({"xxx.properties", "xxx", "yyy"})⾥⾯是个对象，可以加载多个properties⽂件// 有时候我们注⼊的参数过多，并且前缀相同的时候// 就可以使⽤ @ConfigurationProperties(prefix = "test")// 但是此时切记不要写@Value("${}")，加了前缀之后，就是⾃动注⼊了，不能再加@Value("${}")注解了// 案例如下：案例：# resource.properties中的内容# 测试配置⽂件注⼊实体类=mzywucaitest.domain=192.168.60.179,192.168.60.180,192.168.60.181# 利⽤值注⼊还可以做很多有趣⼉的事情，⽐如随机值的⽣成，可以简化代码# 那啥快看的博客园# ---------------------------------dudu.secret=${random.value}dudu.number=${random.int}dudu.bignumber=${random.long}dudu.uuid=${random.uuid}dudu.number.less.than.ten=${random.int(10)}dudu.number.in.range=${random.int[1024,65536]}# ---------------------------------package club.mzywcuai.springbootquickstart.pojo.domain;import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.context.annotation.PropertySource;import ponent;/*** @author mzywucai* @Description* @date 2018/10/21*/@Component // 加此注解是为了让SpringBoot扫描// 如果是application.properties就不⽤写了！@PropertySource({"classpath:resource.properties"})// @ConfigurationProperties // 此注解对应下⾯使⽤@Value⼿动分配的时候// 注意如果写了前缀了的话，就不⽤写@Value("${xxx...}")了// 就⾃动帮我们映射了！但是注意properties中出去前缀后的部分要和我们的实体类中的字段名要相同！@ConfigurationProperties(prefix = "test")public class ServerSettings {// 名称// @Value("${}")private String name;// 域名地址// @Value("${test.domain}")private String domain;public ServerSettings() {}public ServerSettings(String name, String domain) { = name;this.domain = domain;}public void setName(String name) { = name;}public void setDomain(String domain) {this.domain = domain;}public String getName() {return name;}public String getDomain() {return domain;}}补充：还有properties的key-value，在properties的参数间引⽤(我的⽂件服务器的案例)：server.port=10086# 主服务器的url，通信确认有资格上传：暂时不会使⽤server.main.url=http://localhost:8888/confirm-session# ⽂件的路径的base:## 此处的路径进的修改：ubuntu下可以在⽤户⽬录下 nohup java -jar xxx & 启动就好了## 如果是其它⽬录的话：加上sudo -> nohup sudo java -jar xxx &server.file.base=/home/ubuntu/upload# server.file.base=D:/upload# 浏览器访问的时候的URI前缀server.voice.uri=voiceserver.video.uri=videoserver.image.uri=image# 语⾳的路径server.file.voice=${server.file.base}/${server.voice.uri}# 视频的路径server.file.video=${server.file.base}/${server.video.uri}# 图⽚的路径server.file.image=${server.file.base}/${server.image.uri}spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/,file:${server.file.base} # 单个⽂件⼤⼩为20Mspring.servlet.multipart.max-file-size=20MB# 没有多⽂件上传，也设定为20Mspring.servlet.multipart.max-request-size=20MB# 语⾳的最⼤size B -> 10Mvoice.max-size=10485760# 视频的最⼤size B -> 20Mvideo.max-size=20971520# 图⽚的最⼤size B -> 10Mimage.max-size=10485760扯回正题：以上的种种application.properties的配置参数，其实都可以通过java -jar的时候，以–开头作为command的参数注⼊！(有些很长，当然如果你不嫌⿇烦的话)⼀般我们前台运⾏springboot的jar包的时候：java -jar xxx.jar加参数，例如修改server.port：java -jar xx.jar --server.port=8888设置运⾏的模式⽂件(dev等，这样就能两套⽂件外部运⾏的时候选择了，⽐如正式部署的和运⾏的区别：开不开页⾯缓存，设不设置sql打印输出…)java -jar xxx.jar --spring.profiles.active=dev作者还额外提到可以通过：SpringApplication.setAddCommandLineProperties(false)禁⽤command注⼊，来规避风险。

contextrefreshedevent event -回复

contextrefreshedevent event -回复什么是ContextRefreshedEvent（Spring的ContextRefreshedEvent 事件）？在Spring框架中，ContextRefreshedEvent是一个事件类，它表示ApplicationContext（应用程序上下文）已被初始化或刷新完成。

当ApplicationContext被启动并且所有的Bean都已经装配完成时，该事件将被触发。

这一事件是在整个Spring应用程序初始化的过程中非常重要的一个步骤。

为什么ContextRefreshedEvent事件很重要？对于大多数Spring应用程序而言，ContextRefreshedEvent事件被认为是一个重要的里程碑。

这是因为在这个阶段，Spring应用程序已经完成了所有的初始化工作，并且所有的Bean都已经被创建。

此外，它也代表着应用程序可以开始处理请求了。

ContextRefreshedEvent的触发时机是什么？当Spring应用程序启动时，它会初始化ApplicationContext并加载所有配置文件。

在加载完所有的Bean定义之后，Spring会触发ContextRefreshedEvent事件。

这个事件在Spring初始化的过程中只会触发一次。

ContextRefreshedEvent的触发顺序是怎样的？ContextRefreshedEvent事件的触发顺序是根据应用程序的Bean加载顺序来确定的。

Spring将按照配置文件中定义的顺序加载Bean，并按照这个顺序触发ContextRefreshedEvent事件。

ContextRefreshedEvent事件的处理方式是什么？在Spring应用程序中，我们可以通过实现ApplicationListener接口来监听并处理ContextRefreshedEvent事件。

当ContextRefreshedEvent被触发时，我们可以编写相关的代码来处理这个事件。

applicationContext配置

配置内容1. 需要用到AOP的话，配置<aop:aspectj-autoproxy />对AOP的支持：通过配置织入@Aspectj切面，虽然可以通过编程的方式织入切面，但是一般情况下，我们还是使用spring的配置自动完成创建代理织入切面的工作。

2. 加入外部属性文件PropertyPlaceholderConfigurerPropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。

PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java Properties文件中去。

在XML文件中用${key}替换指定的properties文件中的值。

这样的话，只需要对properties文件进行修改，而不用对xml配置文件进行修改。

3.Spring组件扫描（注解支持）<context:component-scan base-package=" "><context:component-scan/>具体用法如下：4.引入其它各种applicationContext-*.xml文件其实这些文件本来都应该配置在applicationContext.xml里面的，只是出于文件分工，后期维护性考虑才分开到各个xml配置文件里的<import resource=””/>标签额外补充一直不理解为什么要在applicationContext.xml里面配置一个ApplicationUtil的beanc om.framelib.utils.ApplicationUtil这个类是自己写的，源码：该类实现了ApplicationContextAware接口，百度了一下该接口的用法，如下：Spring中ApplicationContextAware接口用法加载Spring配置文件时，如果Spring配置文件中所定义的Bean类，如果该类实现了ApplicationContextAware接口，那么在加载Spring配置文件时，会自动调用ApplicationContextAware接口中的public void setApplicationContext(ApplicationContext context) throws BeansException方法，并且自动可获得ApplicationContext 对象。

Spring获取ApplicationContext方式，和读取配置文件获取bean的几种方式

Spring获取ApplicationContext⽅式，和读取配置⽂件获取bean的⼏种⽅式Spring获取ApplicationContext⽅式我⾃⼰常⽤的⽅法：读取⼀个⽂件1//创建Spring容器2 ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");3//获取chinese 实例4 Person p = ctx.getBean("chinese" , Person.class); //或者 Person p = （Person）ctx.getBean("chinese");5//调⽤useAxe()⽅法6 eAxe();读取多个⽂件ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[] {"bean1.xml","bean2.xml","bean3.xml"});Person p = （Person）ctx.getBean("chinese");eAxe();其它⽅法：⽅法⼀：在初始化时保存ApplicationContext对象代码：ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml");ac.getBean("beanId");说明：这种⽅式适⽤于采⽤Spring框架的独⽴应⽤程序（C/S结构应⽤），需要程序通过配置⽂件⼿⼯初始化Spring的情况。

⽅法⼆：通过Spring提供的⼯具类获取ApplicationContext对象代码：import org.springframework.web.context.support.WebApplicationContextUtils;ApplicationContext ac1 = WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext sc)ApplicationContext ac2 = WebApplicationContextUtils.getWebApplicationContext(ServletContext sc)ac1.getBean("beanId");ac2.getBean("beanId");说明：这种⽅式适合于采⽤Spring框架的B/S系统，通过ServletContext对象获取ApplicationContext对象，然后在通过它获取需要的类实例。

Spring初始化ApplicationContext为null

Spring初始化ApplicationContext为null1. ApplicationContextAware初始化通过它Spring容器会⾃动把上下⽂环境对象调⽤ApplicationContextAware接⼝中的setApplicationContext⽅法。

我们在ApplicationContextAware的实现类中，就可以通过这个上下⽂环境对象得到Spring容器中的Bean。

使⽤⽅法如下：1.实现ApplicationContextAware接⼝：package com.bis.majian.practice.module.spring.util;import org.springframework.beans.BeansException;import org.springframework.context.ApplicationContext;import org.springframework.context.ApplicationContextAware;public class SpringContextHelper implements ApplicationContextAware {private static ApplicationContext context = null;@Overridepublic void setApplicationContext(ApplicationContext applicationContext)throws BeansException {context = applicationContext;}public static Object getBean(String name){return context.getBean(name);}}　2.在Spring的配置⽂件中配置这个类，Spring容器会在加载完Spring容器后把上下⽂对象调⽤这个对象中的setApplicationContext⽅法：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:tx="/schema/tx"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd" default-autowire="byName"><bean id="springContextHelper" class="com.bis.majian.practice.module.spring.util.SpringContextHelper"></bean><context:component-scan base-package="com.bis.majian.practice.module.*" /></beans>　3.在web项⽬中的web.xml中配置加载Spring容器的Listener：<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>4.在项⽬中即可通过这个SpringContextHelper调⽤getBean()⽅法得到Spring容器中的对象了。

applicationContext配置文件

基于spring-mvc.xml和application-context.xml的配置与深入理解

Spring中加载xml配置文件的几种方式

Web.xml配置详解之context

jersey+spring+hibernate配置

applicationContext.xml详解

spring成神之路第三篇：Spring容器基本使用及原理（ApplicationCont。。。

BeanFactory和ApplicationContext的区别总结

Spring考试

tomcat context.xml resource 参数

web.xml配置文件超详细说明！！！

springMVC配置文件详解

将 Shiro 作为应用的权限基础 五：SpringMVC+Apache Shiro+JPA(hibernate)整合配置

Spring考试

applicationContext.xml 配置文件的存放位置

SpringBoot配置文件application.properties配置参数替换或者注。。。

contextrefreshedevent event -回复

applicationContext配置

Spring获取ApplicationContext方式，和读取配置文件获取bean的几种方式

Spring初始化ApplicationContext为null

将 Shiro 作为应用的权限基础五：SpringMVC+Apache Shiro+JPA(hibernate)整合配置