profile 订阅
Profile
信息
操作系统
未知
开发语言
开源协议
未知
Profile
Profiles calls to jQuery(selector) , so that you can see which calls to jQuery are taking time. This plugin is meant to complement tools such as the Firebug profiler, which profile all the function calls in your script, but don't (at present) allow you to drill down into the different arguments to a single call. Call $.profile.start() to start profiling calls to $(selector) , and then $.profile.done() to stop profiling and print out something like this: Selector                 Count  Total  Avg+/-stddev script, script, scri...  100    101ms  1.01ms+/-1.01 script                   200     58ms  0.29ms+/-0.53 html body #output        100     55ms  0.55ms+/-0.74 script, #output          100     54ms  0.54ms+/-0.73 #output                  100      6ms  0.06ms+/-0.24 You can also include the ?jquery.profile.start query parameter in your page URL to begin profiling automatically as soon as the plugin is loaded.
收起全文
精华内容
下载资源
问答
  • Maven profile整合Spring profile

    千次阅读 2019-03-05 16:52:00
    在Maven和Spring中,都有profile这个概念。profile是用于区分各种环境的,例如开发环境、测试环境、正式环境等。Maven的profile用于在打包时根据指定环境替换不同环境的配置文件配置,如数据库配置。Spring的Profile...

    在Maven和Spring中,都有profile这个概念。profile是用于区分各种环境的,例如开发环境、测试环境、正式环境等。Maven的profile用于在打包时根据指定环境替换不同环境的配置文件配置,如数据库配置。Spring的Profile可以用于在不同的环境下加载不同的bean,例如@Profile注解。两者一个是Maven编译和打包时生效,另一个是运行时生效,默认是没有关联的,本文会分别介绍非Spring Boot项目和Spring Boot项目整合Maven profile。

    Maven profile配置

    pom.xml中,可以配置testproduct两个profile,分别对应测试环境和正式环境。这里也可以根据具体情况自定义。

    <profiles>
      <profile>
        <id>test</id>
        ...
      </profile>
      <profile>
        <id>product</id>
        ...
      </profile>
    </profiles>
    

    此时,运行mvn package -Ptest就会使用id为test的profile内的配置打包,mvn package -Pproduct就是用来打正式环境包的命令。

    Spring Framework(非Spring Boot)整合Maven profile

    Spring Framework如何启用一个profile

    Spring启用某个profile有多种方式(摘自官方文档:https://docs.spring.io/spring/docs/5.1.5.RELEASE/spring-framework-reference/core.html#beans-definition-profiles-enable ):

    Activating a profile can be done in several ways, but the most straightforward is to do it programmatically against the Environment API which is available through an ApplicationContext.
    In addition, you can also declaratively activate profiles through the spring.profiles.active property, which may be specified through system environment variables, JVM system properties, servlet context parameters in web.xml, or even as an entry in JNDI.

    总结一下有以下几种方式:

    • 通过代码设置:ApplicationContext.getEnvironment().setActiveProfiles("yourProfile")
    • 通过系统环境变量spring.profiles.active值来设置
    • 通过JVM系统属性spring.profiles.active值来设置
    • 通过web.xml中的context-param来设置

    为了便于跟Maven整合,我们使用web.xml来设置Spring profile,如下:

    <context-param>
        <param-name>spring.profiles.active</param-name>
        <param-value>product</param-value>
    </context-param>
    

    以上配置会启用Spring的product profile,即正式环境。

    Spring Framework profile整合Maven profile

    如果想要整合Maven profile和Spring Framework profile,需要在Maven打包时对web.xml中的spring.profiles.active值进行替换,可以在web.xml中配置一个占位符${activeProfile}

    <context-param>
        <param-name>spring.profiles.active</param-name>
        <param-value>${activeProfile}</param-value>
    </context-param>
    

    pom.xml配置maven-war-plugin

    <!-- 打war包时替换占位符 -->
    <build>
      <plugin>
        <artifactId>maven-war-plugin</artifactId>
        <version>3.2.2</version>
        <configuration>
          <filteringDeploymentDescriptors>true</filteringDeploymentDescriptors>
        </configuration>
      </plugin>
    </build>
    
    <!-- 默认的maven profile -->
    <properties>
      <activeProfile>dev</activeProfile>
    </properties>
    
    <profiles>
      <profile>
        <id>test</id>
        <properties>
          <activeProfile>test</activeProfile>
        </properties>
      </profile>
      <profile>
        <id>product</id>
        <properties>
          <activeProfile>product</activeProfile>
        </properties>
      </profile>
    </profiles>
    

    <filteringDeploymentDescriptors>true表示过滤Deployment Descriptor并将文件中的占位符替换为pom.xml中对应的<properties>值,Deployment Descriptor即部署描述符,指的就是web.xml (参考维基百科:https://zh.wikipedia.org/wiki/部署描述符 )。

    以上配置完成后,再通过mvn package -Ptestmvn package -Pproduct打包后,再解压war包,可以看到web.xml中原有的

    <context-param>
        <param-name>spring.profiles.active</param-name>
        <param-value>${activeProfile}</param-value>
    </context-param>
    

    被替换为了Maven中对应的profile,例如mvn package -Pproduct打包后web.xml内容:

    <context-param>
        <param-name>spring.profiles.active</param-name>
        <param-value>product</param-value>
    </context-param>
    

    以上就完成了Maven profile和Spring profile的整合。

    兼容jetty-maven-plugin

    如果恰好在项目中使用到jetty-maven-plugin用于开发环境调试,那么在web.xml配置占位符${activeProfile}后,通过mvn jetty:run启动应用时会Spring框架会报错:

    Could not resolve placeholder 'activeProfile' in string value "${activeProfile}"
    

    这是因为运行mvn jetty:run命令时插件并没有打war包,而是直接使用源码中的web.xml,此时占位符${activeProfile}未被maven-war-plugin替换,所以Spring框架会报错。

    参考文档:https://www.eclipse.org/jetty/documentation/9.4.x/jetty-maven-plugin.html#jetty-run-goal

    解决方法一

    使用mvn jetty:run-warmvn jetty:run-exploded命令替代mvn jetty:run,这两个命令会先用maven-war-plugin打好war包后再运行,此时占位符${activeProfile}已被替换为Maven的profile。

    但是这种方案会带来一个问题:由于这种方式需要先打war包再运行,开发时项目中资源(例如html、jsp)修改后就不会实时生效,而是需要重新打包启动,不便于调试。

    解决方法二(推荐)

    这种方案还是使用mvn jetty:run命令,只需要给jetty-maven-plugin插件添加一个名为activeProfile的系统属性,让Spring框架来解析web.xml中的${activeProfile}

    <plugin>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-maven-plugin</artifactId>
      <version>9.2.10.v20150310</version>
      <configuration>
        <webApp>
          <contextPath>/</contextPath>
        </webApp>
        <systemProperties>
          <systemProperty>
            <name>activeProfile</name>
            <value>${activeProfile}</value>
          </systemProperty>
        </systemProperties>
      </configuration>
    </plugin>
    

    参考文档:https://www.eclipse.org/jetty/documentation/9.4.x/jetty-maven-plugin.html#setting-system-properties

    Spring Boot整合Maven profile

    如果项目采用的框架是Spring Boot而不是直接使用Spring Framework,那么Spring Boot的profile可以在resources目录下的application.propertiesapplication.yml文件中指定,以application.properties为例:

    spring.profiles.active=product
    

    要想整合Maven profile只需要改为@activeProfile@占位符即可:

    spring.profiles.active=@activeProfile@
    

    仅需要这一行配置就完成了Spring Boot profile整合Maven profile,非常方便。此时可以尝试mvn package -Ptestmvn package -Pproduct命令打包,安装包内的文件中@activeProfile@占位符已被替换。

    Spring Boot整合Maven profile原理

    Spring Boot项目中一般都会加上spring-boot-starter-parent

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>${spring.boot.version}</version>
    </parent>
    

    可以查看spring-boot-starter-parent的pom.xml文件,里面包含maven-resources-plugin

    <plugin>
        <artifactId>maven-resources-plugin</artifactId>
        <configuration>
            <delimiters>
                <delimiter>${resource.delimiter}</delimiter>
            </delimiters>
            <useDefaultDelimiters>false</useDefaultDelimiters>
        </configuration>
    </plugin>
    

    ${resource.delimiter}定义的值是@

    <resource.delimiter>@</resource.delimiter>
    

    这样maven-resources-plugin插件会将application.propertiesapplication.yml文件中的@activeProfile@替换为pom.xml中对应profile的值。

    至于为什么Spring Boot要使用@..@而不是Maven默认的${..}作为占位符的符号,官方文档也给出了解释,以下摘自:https://docs.spring.io/spring-boot/docs/2.0.4.RELEASE/reference/htmlsingle/#using-boot-maven

    Note that, since the application.properties and application.yml files accept Spring style placeholders (${…​}), the Maven filtering is changed to use @…@ placeholders. (You can override that by setting a Maven property called resource.delimiter.)

    因为Spring Boot框架本身也用${..}作为占位符,Maven插件maven-resources-plugin如果还使用相同的占位符,那么可能会导致一些冲突,所以spring-boot-starter-parentmaven-resources-plugin的占位符改为@..@

    参考文档

    原文链接

    https://xxgblog.com/2016/06/01/maven-spring-profile/

    展开全文
  • @Profile注解详解

    万次阅读 多人点赞 2019-06-12 22:52:35
    @Profile注解详解 @Profile: Spring为我们提供的可以根据当前环境,动态的激活和切换一系列组件的功能; 开发环境develop、测试环境test、生产环境master 数据源:(/dev) (/test) (/master) @Profile:指定组件...

    @Profile注解详解


     @Profile:
              Spring为我们提供的可以根据当前环境,动态的激活和切换一系列组件的功能;
      
      开发环境develop、测试环境test、生产环境master
      数据源:(/dev) (/test) (/master)
     
      @Profile:指定组件在哪个环境的情况下才能被注册到容器中,不指定,任何环境下都能注册这个组件
      
      1) 加了环境标识的bean,只有这个环境被激活的时候才能注册到容器中。默认是default环境
      2) 写在配置类上,只有是指定的环境的时候,整个配置类里面的所有配置才能开始生效
      


    package com.spring.config;
    
    import java.beans.PropertyVetoException;
    
    import javax.sql.DataSource;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.EmbeddedValueResolverAware;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Profile;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.util.StringValueResolver;
    
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    
    /**
     * Profile:
     * 		Spring为我们提供的可以根据当前环境,动态的激活和切换一系列组件的功能;
     * 
     * 开发环境develop、测试环境test、生产环境master
     * 数据源:(/dev) (/test) (/master)
     *
     * @Profile:指定组件在哪个环境的情况下才能被注册到容器中,不指定,任何环境下都能注册这个组件
     * 
     * 1) 加了环境标识的bean,只有这个环境被激活的时候才能注册到容器中。默认是default环境
     * 2) 写在配置类上,只有是指定的环境的时候,整个配置类里面的所有配置才能开始生效
     * 
     */
    @PropertySource("classpath:/dbconfig.properties")
    @Configuration
    public class MainConfigOfProfile implements EmbeddedValueResolverAware{
    	
    	@Value("${db.user}")
    	private String user;
    	
    	private String driverClass;
    	
    	@Profile("default")
    	@Bean("test")
    	public DataSource testDataSource(@Value("${db.password}")String password) throws PropertyVetoException {
    		ComboPooledDataSource dataSource = new ComboPooledDataSource();
    		dataSource.setUser(user);
    		dataSource.setPassword(password);
    		dataSource.setDriverClass(driverClass);
    		return dataSource;
    	}
    	
    	@Profile("dev")
    	@Bean("dev")
    	public DataSource devDataSource(@Value("${db.password}")String password) throws PropertyVetoException {
    		ComboPooledDataSource dataSource = new ComboPooledDataSource();
    		dataSource.setUser(user);
    		dataSource.setPassword(password);
    		dataSource.setDriverClass(driverClass);
    		return dataSource;
    	}
    	
    	@Profile("master")
    	@Bean("master")
    	public DataSource masterDataSource(@Value("${db.password}")String password) throws PropertyVetoException {
    		ComboPooledDataSource dataSource = new ComboPooledDataSource();
    		dataSource.setUser(user);
    		dataSource.setPassword(password);
    		dataSource.setDriverClass(driverClass);
    		return dataSource;
    	}
    
    	public void setEmbeddedValueResolver(StringValueResolver resolver) {
    		String driverClass = resolver.resolveStringValue("${db.driverClass}");
    		this.driverClass = driverClass;
    	}
    
    }
    package com.spring.test;
    
    import java.util.Arrays;
    
    import javax.sql.DataSource;
    
    import org.junit.Test;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    import com.spring.config.MainConfigOfProfile;
    
    
    public class IOCTestProfile {
    	//1. 使用命令行动态参数:在虚拟机参数位置加载 -Dspring.profiles.active=test
    	//2. 使用代码的方式激活某种环境;
    	@Test
    	public void test01() {
    		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfProfile.class);
    		//1. 创建一个applicationContext
    		//2. 设置需要激活的环境
    		applicationContext.getEnvironment().setActiveProfiles("dev","master");
    		//3. 注册主配置类
    		applicationContext.register(MainConfigOfProfile.class);
    		//4. 启动刷新容器
    		applicationContext.refresh();
    		
    		String[] beanNamesForType = applicationContext.getBeanNamesForType(DataSource.class);
    		System.out.println(Arrays.toString(beanNamesForType));
    		
    		applicationContext.close();
    	}
    
    
            @Test
    	public void test02() {
    		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfProfile.class);
    		
    		String[] beanNamesForType = applicationContext.getBeanNamesForType(DataSource.class);
    		System.out.println(Arrays.toString(beanNamesForType));
    		
    		applicationContext.close();
    	}
    }
    

     

    展开全文
  • SpringBoot之profile详解

    万次阅读 2019-11-27 10:35:34
    application.yml两种方式,在这两种方式下分别对应各自的profile配置方式,同时还存在命令行、虚拟机、Program arguments三种方式分别访问指定profile: 1、application.properties  创建配置文件application-dev....

    SpringBoot中使用配置文件application.properties&application.yml两种方式,在这两种方式下分别对应各自的profile配置方式,同时还存在命令行、虚拟机、Program arguments三种方式分别访问指定profile:

    1、application.properties
      创建配置文件application-dev.properties,此文件为开发环境的配置文件

    server.port=8091
    

    创建配置文件allpication-prod.properties,此文件为生产环境的配置文件

    server.port=8092
    

    在appliapplication.properties中添加使用的环境

    #默认配置文件的端口
    server.port=8090
    #使用的环境名称
    spring.profiles.active=dev
    

    2、application.yml
    在yml文件中,分为三个ducement,第一个ducument为默认的配置文件,第二个部分为dev的配置文件,第三个部分为prod的配置文件。在默认doucment中使用spring.profiles.active设置使用哪个ducument 的配置

    #默认的配置端口
    server:
      port: 8880
    #需要使用的配置文件
    spring:
      profiles:
        active: prod
    ---
    #dev的环境
    server:
      port: 8881
    spring:
      profiles: dev
    ---
    #prod的环境
    server:
      port: 8882
    spring:
      profiles: prod
    

    3、Program arguments
    在Program arguments中配置参数

    --spring.profiles.active=dev
    

    在这里插入图片描述
    4、命令行
    将项目打包成jar包,切换到命令行的界面下使用命令: java -jar .\spring-boot-01-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod进行打包。

    java -jar .\spring-boot-01-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod
    

    在这里插入图片描述
    5、虚拟机的方式
    在VM options下使用命令:-Dspring.profiles.active=prod

    -Dspring.profiles.active=prod
    

    在这里插入图片描述

    展开全文
  • spring Profile

    千次阅读 2019-05-22 11:32:23
    本文从如下3方面探讨Spring的Profile: Spring中的Profile是什么 为什么要使用Profile 如何使用Profile 1.Spring中的Profile 是什么? Spring中的Profile功能其实早在Spring 3.1的版本就已经出来,它可以理解为我们...

    前言

    本文从如下3方面探讨Spring的Profile:
    • Spring中的Profile是什么
    • 为什么要使用Profile
    • 如何使用Profile

    1.Spring中的Profile 是什么?

    Spring中的Profile功能其实早在Spring 3.1的版本就已经出来,它可以理解为我们在Spring容器中所定义的Bean的逻辑组名称,只有当这些Profile被激活的时候,才会将Profile中所对应的Bean注册到Spring容器中。举个更具体的例子,我们以前所定义的Bean,当Spring容器一启动的时候,就会一股脑的全部加载这些信息完成对Bean的创建;而使用了Profile之后,它会将Bean的定义进行更细粒度的划分,将这些定义的Bean划分为几个不同的组,当Spring容器加载配置信息的时候,首先查找激活的Profile,然后只会去加载被激活的组中所定义的Bean信息,而不被激活的Profile中所定义的Bean定义信息是不会加载用于创建Bean的。

    2.为什么要使用Profile

    由于我们平时在开发中,通常会出现在开发的时候使用一个开发数据库,测试的时候使用一个测试的数据库,而实际部署的时候需要一个数据库。以前的做法是将这些信息写在一个配置文件中,当我把代码部署到测试的环境中,将配置文件改成测试环境;当测试完成,项目需要部署到现网了,又要将配置信息改成现网的,真的好烦。。。而使用了Profile之后,我们就可以分别定义3个配置文件,一个用于开发、一个用户测试、一个用户生产,其分别对应于3个Profile。当在实际运行的时候,只需给定一个参数来激活对应的Profile即可,那么容器就会只加载激活后的配置文件,这样就可以大大省去我们修改配置信息而带来的烦恼。

    3.配置Spring profile

    在介绍完Profile以及为什么要使用它之后,下面让我们以一个例子来演示一下Profile的使用,这里还是使用传统的XML的方式来完成Bean的装配。

    3.1 例子需要的Maven依赖

    由于只是做一个简单演示,因此无需引入Spring其他模块中的内容,只需引入核心的4个模块+测试模块即可。

    <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <!--指定Spring版本,该版本必须等于3.1-->
            <spring.version>4.2.4.RELEASE</spring.version>
            <!--指定JDK编译环境-->
            <java.version>1.7</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-expression</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${spring.version}</version>
                <scope>test</scope>
            </dependency>
    
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>2.3.2</version>
                    <configuration>
                        <source>${java.version}</source>
                        <target>${java.version}</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    

    3.2 例子代码

    package com.panlingxiao.spring.profile.service;
    
    /**
     * 定义接口,在实际中可能是一个数据源
     * 在开发的时候与实际部署的时候分别使用不同的实现
     */
    public interface HelloService {
    
        public String sayHello();
    }
    

    定义生产环境使用的实现类

    package com.panlingxiao.spring.profile.service.produce;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    import com.panlingxiao.spring.profile.service.HelloService;
    
    /**
     * 模拟在生产环境下需要使用的类
     */
    @Component
    public class ProduceHelloService implements HelloService {
    
        //这个值读取生产环境下的配置注入
        @Value("#{config.name}")
        private String name;
    
        public String sayHello() {
            return String.format("hello,I'm %s,this is a produce environment!",
                    name);
        }
    }
    
    • 模拟在生产环境下需要使用的类
    package com.panlingxiao.spring.profile.service.dev;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    import com.panlingxiao.spring.profile.service.HelloService;
    
    /**
     * 模拟在开发环境下使用类
     */
    @Component
    public class DevHelloService implements HelloService{
    
        //这个值是读取开发环境下的配置文件注入
        @Value("#{config.name}")
        private String name;
    
        public String sayHello() {
            return String.format("hello,I'm %s,this is a development environment!", name);
        }
    }
    

    定义配置Spring配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
        xmlns:util="http://www.springframework.org/schema/util"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">
    
        <!-- 定义开发的profile -->
        <beans profile="development">
            <!-- 只扫描开发环境下使用的类 -->
            <context:component-scan base-package="com.panlingxiao.spring.profile.service.dev" />
            <!-- 加载开发使用的配置文件 -->
            <util:properties id="config" location="classpath:dev/config.properties"/>
        </beans>
    
        <!-- 定义生产使用的profile -->
        <beans profile="produce">
            <!-- 只扫描生产环境下使用的类 -->
            <context:component-scan
                base-package="com.panlingxiao.spring.profile.service.produce" />
            <!-- 加载生产使用的配置文件 -->    
            <util:properties id="config" location="classpath:produce/config.properties"/>
        </beans>
    </beans>
    

    开发使用的配置文件,dev/config.properties

        name=Tomcat

    生产使用的配置文件,produce/config.properties

    name=Jetty

    编写测试类

    package com.panlingxiao.spring.profile.test;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.test.context.ActiveProfiles;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    import com.panlingxiao.spring.profile.service.HelloService;
    
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations="classpath:spring-profile.xml")
    /*
     * 使用注册来完成对profile的激活,
     * 传入对应的profile名字即可,可以传入produce或者dev
     */
    @ActiveProfiles("produce")
    public class TestActiveProfile {
    
        @Autowired
        private HelloService hs;
    
        @Test
        public void testProfile() throws Exception {
            String value = hs.sayHello();
            System.out.println(value);
        }
    }
    


    激活dev运行结果.png

    激活produce运行结果.jpg

    4.激活Profile的其他几种方式

    上面介绍了如何使用Profile以及在单元测试的环境下激活指定的Profile,除了使用@ActiveProfiles注解来激活profile外,Spring还提供了其他的几种激活Profile,这些方式在实际的开发中使用的更多。
    Spring通过两个不同属性来决定哪些profile可以被激活(注意:profile是可以同时激活多个的),一个属性是spring.profiles.active和spring.profiles.default。这两个常量值在Spring的AbstractEnvironment中有定义,查看AbstractEnvironment源码:

        /**
         * Name of property to set to specify active profiles: {@value}. Value may be comma
         * delimited.
         * <p>Note that certain shell environments such as Bash disallow the use of the period
         * character in variable names. Assuming that Spring's {@link SystemEnvironmentPropertySource}
         * is in use, this property may be specified as an environment variable as
         * {@code SPRING_PROFILES_ACTIVE}.
         * @see ConfigurableEnvironment#setActiveProfiles
         */
        public static final String ACTIVE_PROFILES_PROPERTY_NAME = "spring.profiles.active";
    
    <span class="hljs-comment">/**
     * Name </span><span class="hljs-keyword"><span class="hljs-comment">of </span><span class="hljs-keyword"><span class="hljs-comment">property </span><span class="hljs-keyword"><span class="hljs-comment">to </span><span class="hljs-keyword"><span class="hljs-comment">set </span><span class="hljs-keyword"><span class="hljs-comment">to specify profiles active </span><span class="hljs-keyword"><span class="hljs-comment">by default: {<span class="hljs-doctag">@value</span>}. Value may
     * be comma delimited.
     * &lt;p&gt;Note </span><span class="hljs-keyword"><span class="hljs-comment">that certain shell environments such </span><span class="hljs-keyword"><span class="hljs-comment">as Bash disallow </span><span class="hljs-keyword"><span class="hljs-comment">the use </span><span class="hljs-keyword"><span class="hljs-comment">of </span><span class="hljs-keyword"><span class="hljs-comment">the period
     * </span><span class="hljs-built_in"><span class="hljs-comment">character </span><span class="hljs-keyword"><span class="hljs-comment">in variable names. Assuming </span><span class="hljs-keyword"><span class="hljs-comment">that Spring's {<span class="hljs-doctag">@link</span> SystemEnvironmentPropertySource}
     * </span><span class="hljs-keyword"><span class="hljs-comment">is </span><span class="hljs-keyword"><span class="hljs-comment">in use, this </span><span class="hljs-keyword"><span class="hljs-comment">property may be specified </span><span class="hljs-keyword"><span class="hljs-comment">as an environment variable </span><span class="hljs-keyword"><span class="hljs-comment">as
     * {<span class="hljs-doctag">@code</span> SPRING_PROFILES_DEFAULT}.
     * <span class="hljs-doctag">@see</span> ConfigurableEnvironment</span><span class="hljs-comment"><span class="hljs-comment">#setDefaultProfiles
     */</span>
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">final</span> String DEFAULT_PROFILES_PROPERTY_NAME = <span class="hljs-string"><span class="hljs-string">"spring.profiles.default"</span>;</span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></code></pre>
    

    如果当spring.profiles.active属性被设置时,那么Spring会优先使用该属性对应值来激活Profile。当spring.profiles.active没有被设置时,那么Spring会根据spring.profiles.default属性的对应值来进行Profile进行激活。如果上面的两个属性都没有被设置,那么就不会有任务Profile被激活,只有定义在Profile之外的Bean才会被创建。我们发现这两个属性值其实是Spring容器中定义的属性,而我们在实际的开发中很少会直接操作Spring容器本身,所以如果要设置这两个属性,其实是需要定义在特殊的位置,让Spring容器自动去这些位置读取然后自动设置,这些位置主要为如下定义的地方:

    • 作为SpringMVC中的DispatcherServlet的初始化参数
    • 作为Web 应用上下文中的初始化参数
    • 作为JNDI的入口
    • 作为环境变量
    • 作为虚拟机的系统参数
    • 使用@AtivceProfile来进行激活

    我们在实际的使用过程中,可以定义默认的profile为开发环境,当实际部署的时候,主需要在实际部署的环境服务器中将spring.profiles.active定义在环境变量中来让Spring自动读取当前环境下的配置信息,这样就可以很好的避免不同环境而频繁修改配置文件的麻烦。

    4.5 示例代码下载

    示例代码下载地址:Spring-profile-test

    参考:

    1. Spring Framework Reference Documentation 4.2.5.RELEASE-- 6.13. Environment abstraction
    2. Spring Framework Reference Documentation 3.2.3.RELEASE --3.2 Bean Definition Profiles
    3. <<Spring In Action Fourth Edition>>
    展开全文
  • Show Profile

    千次阅读 2018-06-20 17:00:55
    1.Show Profile默认是关闭的,试用前需要开启:查看是否开启:Show variables like 'profiling';设置开启:set profiling = on;2.使用:show profile cpu,block io for query 150;3.show profile 的参数:type是可...
  • 蓝牙profile

    千次阅读 2017-03-02 11:42:29
    蓝牙ProfileBluetooth的一个很重要特性,使用profile目的是所有的Bluetooth产品都无须实现全部的Bluetooth规范。为了更容易的保持Bluetooth设备之间的兼容,Bluetooth规范中定义了ProfileProfile定义了设备如何...
  • Android Work Profile

    千次阅读 2020-04-08 17:42:39
    本文基于 ... Work Profile(工作面)或称为managed profile(被管理面)。 一个work profile由IT admin控制 一个work profile的可用功能基于用户的primary profile分别设置 Work profile...
  • @Profile使用及SpringBoot获取profile

    万次阅读 2018-09-20 14:58:24
    之前开发用过 maven 的环境隔离,现在使用springboot的@Profile功能,发现spring体系真的大到我只是学习了皮毛。相比面试问的 IOC,bean的作用域等,突然觉得很可笑。 官方文档关于 Profile 的使用 ...
  • profileprofile.d区别

    千次阅读 2015-04-21 23:12:49
    /etc/profile /etc/profile.d/ 1这两个文件都是设置环境变量文件的,/etc/profile是永久性的环境变量,是全局变量,/etc/profile.d/设置所有用户生效。 2/etc/profile.d/更好维护,不想要什么变量直接删除/etc/...
  • MYSQL安全创建profile

    万次阅读 2019-01-07 13:32:10
    mysql中创建profile: 1、通过命令打开profile功能: set profiling=1; 2、使用select * from user \G;查看用户 3、查询消耗 4、查看某条指定命令的消耗 5、设置profile表的条数: 通过命令:set profiling_...
  • .profile 文件

    千次阅读 2018-08-13 16:05:04
    Unix/Linux有两个profile文件 1./etc/profile:是全局profile文件,设置后会影响到所有用户 2./home/username/.profile或.bash_profile是针对特定用户的,可以针对用户,来配置自己的环境变量。 注意:profile是unix...
  • profile之springboot

    千次阅读 2018-11-07 22:59:36
    什么是profile 想必大家都有这种用经历,我们开发项目的时候要有多个环境,如开发环境、测试环境、生产环境,他们的配置文件一般不同,如数据库地址。当我们要向各个环境发布程序时,需要人工处理这些配置文件,这...
  • iCCP: known incorrect sRGB profile

    万次阅读 2017-01-11 01:24:43
    关注公众号“码农帮派”,查看更多系列技术文章: ..."iccp known incorrect sRGB profile" 警告 (不同系统上的ImageMagic下载地址:http://www.imagemagick.org/script/binary-releases.php) 这不是错误,但...
  • 1.启动时no active profile set, falling back to default profiles: default 2.多profile文件形式: 3.多profile配置激活 3.1通过properties文件指定 3.2通过yml文档块指定 3.3通过configuration中的...
  • Spring Boot Profile 与Maven Profile 集成实践  2017-07-04  SPRING BOOT  MAVEN 文章目录 1. 摘要 2. 集成的意义 3. Maven Filter 3.1. Filtering 3.2. Spring Boot Resource 插件的默认...
  • 1、不接配置中心的情况下,启动的时候springboot默认会加载bootstrap.yml 以及 bootstrap-profileprofile。{profile}。 {profile}在bootstrap.yml中 spring.profiles.active: dev 指定。 另外说一下,加载顺序...
  • 1. 为什么要用Main Profile &amp;amp;amp;amp; High Profile 在Android上硬编码视频码率远远高于软编码,原因是Android只支持H264 Baseline。MP(Main Profile )&amp;amp;amp;amp; HP(High Profile)可以...
  • 4、Spring profile与Maven Profile 融合二者,取长补短 实现多环境打包 5、成果展现 6、总结 7、参考文章 1、使用场景 因为实际项目之中,经常使用到针对不同环境进行相关的打包。于是趁最近一段时间比较闲。...
  • ORACLE profile系列4 --CREATE PROFILE

    千次阅读 2014-11-07 14:53:57
    CREATE PROFILE
  • 在开发过程中,我们的软件会面对不同的运行环境,比如开发环境、测试环境、生产环境,而我们的软件在不同的环境中,有的配置可能会不...maven提供了一种方便的解决这种问题的方案,就是profile功能。 profile可以让...
  • 08-Springboot中Profile

    万次阅读 2020-11-15 18:37:16
    Profile的主要作用是把配置按不同的场景进行区分,不同的场景使用不同的配置文件。这样说有点模糊。比如我们的配置文件可以分为测试环境test,开发环境dev,生产环境pro。那么我们就准备着三个环境的配置文件,如果...
  • /etc/profile 和~/.bash_profile区别

    千次阅读 2019-05-27 11:06:30
    /etc/profile 和~/.bash_profile区别 /etc/profile 为系统的每个用户设置环境信息和启动程序,当用户第一次登录时,该文件被执行,其配置对所有登录的用户都有效。当被修改时,必须重启才会生效。英文描述:”System...
  • ~/.profile和/etc/profile的区别

    万次阅读 2018-11-15 18:36:28
    1.首先读入的是全局环境变量设定档/etc/profile,然后根据其内容读取额外的设定的文档,如 /etc/profile.d和/etc/inputrc 2.然后根据不同使用者帐号,去其家目录读取~/.bash_profile,如果这读取不了就读取~/.bash_...
  • PROFILE文件

    千次阅读 2012-11-10 18:15:42
    这里要说的PROFILE文件,只针对利用于网格运动定义之用的瞬态profile文件。其它类型的profile文件,可参阅FLUENT用户文档,里头有详细的描述。 在ANSYS FLUENT中,有两种方式用于指定瞬态网格区域及边界条件: (1...
  • Onvif Profile 规范

    千次阅读 2018-02-05 12:35:34
    描述一组固定的功能集合通过ONVIF标准服务提供,针对每一种类型profile 一些功能性服务是强制性的。一个onvif设备和客户端可能支持几种组合的profile。 1、用于流媒体音视频的profile S 设备端主要需要完成RTSP ...
  • matlab profile

    千次阅读 2014-06-03 21:59:45
    matlab中可以用profile工具来分析各个文件的运行时间
  • 一、什么是Profile Owner 因为Profile Owner在体验上与Device Owner和Device admin有很大的差别,所以额外添加了一段讲解什么是Profile Owner。 google为了Android在企业中运用推出的安全方案,即android for work,...
  • Onvif Profile简介

    千次阅读 2019-09-10 20:11:12
    OnvifProfile简介 https://www.onvif.org/profiles/ ONVIF Profiles是什么? ONVIF提供很多的profile概要文件,用于规范ONVIF设备端与ONVIF客户端的通信标准。目前已发布的profile文件主要包括profile S、G、C、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 154,224
精华内容 61,689
关键字:

profile