java 学习总结 Maven中profile和filtering实现多个环境下的属性过滤

1 cobertura-maven-plugin maven的测试覆盖率插件集成cobertura-maven-plugin
2 intelli J 配置VM参数

java 学习总结
Maven中profile和filtering实现多个环境下的属性过滤

3 配置显示行号

java 学习总结
Maven中profile和filtering实现多个环境下的属性过滤

 

mvn clean install 安装到本地的repo中

超级pom

默认的仓储为maven提供的,其id为central,可以覆盖,也可以用mirror覆盖

 

5、classifier:帮助定义构建输出的一些附属构件。
     附属构件与主构件对应,如上例中的主构件是pms-indexer-4.2.2.jar,该项目可能还会通过使用一些插件生成如pms-indexer-4.2.2-javadoc.jar,pms-indexer-4.2.2-sources.jar这样一些附属构件,其包含了Java文档和源代码。这时候,javadoc和sources就是这两个附属构件的classifier。
 
介绍了pom.xml文件的五个元素,其中,groupId / artifactId / version 是必须定义的,packaging是可选的(默认为jar),而classifier是不能直接定义的。
 
6 mvn 生命周期与插件的关系,
 
生命周期基本是固定的有init-->compile-->test-->package-->integrationTest-->deply
mvn只是定义了声明周期,其内部是和插件绑定的,如编译由maven-compiler-plugin完成,测试由maven-surefire-plugin完成。
需要时,可以将plugin绑定到某个生命周期上。
 

 

一、Maven的生命周期

Maven的生命周期就是对所有的构建过程进行抽象和统一。包含了项目的清理、初始化、编译、测试、打包、集成测试、验证、部署和站点生成等几乎所有的构建步骤。

Maven的生命周期是抽象的,即生命周期不做任何实际的工作,实际任务由插件完成,类似于设计模式中的模板方法。

java 学习总结
Maven中profile和filtering实现多个环境下的属性过滤

 

二、三套生命周期

Maven有三套相互独立的生命周期,分别是clean、default和site。每个生命周期包含一些阶段(phase),阶段是有顺序的,后面的阶段依赖于前面的阶段。

1、clean生命周期:清理项目,包含三个phase。

1)pre-clean:执行清理前需要完成的工作

2)clean:清理上一次构建生成的文件

3)post-clean:执行清理后需要完成的工作

2、default生命周期:构建项目,重要的phase如下。

1)validate:验证工程是否正确,所有需要的资源是否可用。
2)compile:编译项目的源代码。  
3)test:使用合适的单元测试框架来测试已编译的源代码。这些测试不需要已打包和布署。
4)Package:把已编译的代码打包成可发布的格式,比如jar。
5)integration-test:如有需要,将包处理和发布到一个能够进行集成测试的环境。
6)verify:运行所有检查,验证包是否有效且达到质量标准。
7)install:把包安装到maven本地仓库,可以被其他工程作为依赖来使用。
8)Deploy:在集成或者发布环境下执行,将最终版本的包拷贝到远程的repository,使得其他的开发者或者工程可以共享。

3、site生命周期:建立和发布项目站点,phase如下

1)pre-site:生成项目站点之前需要完成的工作

2)site:生成项目站点文档

3)post-site:生成项目站点之后需要完成的工作

4)site-deploy:将项目站点发布到服务器

 

三、命令行和生命周期

各个生命周期相互独立,一个生命周期的阶段前后依赖。

举例如下:

1、mvn clean

调用clean生命周期的clean阶段,实际执行pre-clean和clean阶段

2、mvn test

调用default生命周期的test阶段,实际执行test以及之前所有阶段

3、mvn clean install

调用clean生命周期的clean阶段和default的install阶段,实际执行pre-clean和clean,install以及之前所有阶段

 

mvn clean,删除target目录构建的东西,

mvn package 打包,如jar包,放在target目录下,

mvn install  将包安装到本地repo

mvn deploy 将包push到远程repo

 

 

maven 插件和目标(plugins  and  goals)

插件和目标(plugins and  goals )的大小关系:

java 学习总结
Maven中profile和filtering实现多个环境下的属性过滤

 

一个maven插件是由一个或者多个目标集合组成的。
 
一个目标是一个明确的任务,它可以作为单独的目标运行,或者作为一个大的构建的一部分和其它目标一起运行。一个目标是Maven中的一个“工作单元(unit of work)”。目标的例子包括Compiler插件中的compile目标,它用来编译项目中的所有源文件,或者Surefire插件中的test目标,用来运行单元测试。
 
 
 
注意:
当提到一个插件目标的时候,我们常常用速记符号:pluginId:goalId。例如,当提到Archetype插件的create目标的时候,我们写成archetype:create。
 
archetype 是插件
create 是目标
 
 
 
 
pom.xml中module标签中指的是聚合,parent标签以及dependencyManagment/pluginManagment指的是继承
 
1.继承
(1)标签:<parent>
(2)举例
[java] view plain copy
 
  1. <parent>    
  2.    <groupId>com.tiantian.mavenTest</groupId>    
  3.    <artifactId>projectA</artifactId>    
  4.    <version>1.0-SNAPSHOT</version>    
  5.  </parent>    
2. 聚合
(1)标签:<modules>
(2)举例
[java] view plain copy
 
  1. <modules>    
  2.        <module>../projectB</module>    
  3. </modules>    

 

 

 

在使用mvn package进行编译、打包时,Maven会执行src/test/java中的JUnit测试用例,有时为了跳过测试,会使用参数-DskipTests和-Dmaven.test.skip=true,这两个参数的主要区别是:

-DskipTests,不执行测试用例,但编译测试用例类生成相应的class文件至target/test-classes下。

-Dmaven.test.skip=true,不执行测试用例,也不编译测试用例类。

 

 mvn test -Dtest=ATest, BTest,CTest , 只执行ATest, BTest, CTest, 不执行其他测试用例。

 

 

 

 
 

背景

 项目构建的时候,需要根据不同的场景来改变项目中的属性资源,最为常见的莫过于数据库连接配置了,试想有生产环境、测试缓存、发布环境等,需要为不同的场景下来动态的改变数据库的连接配置。而使用maven就可以帮我们解决这些问题。下面就来分享一下maven中的profile和filtering的属性。

 

 为了便于测试一下功能,需要搭建maven的web项目,具体配置请详见如何用maven创建web项目

 

 filtering功能

 

 主要用来替换项目中的资源文件(*.xml、*.properties)当中的${...},比如${db.url},那么如果配置了db.url=aaa的话,在项目编译的时候,就会自动的把${db.url}替换为aaa,下面以实例来讲解一下

 

 采取参照博客中创建完maven的web项目后,会看到src/main/sources的目录,在此目录下面创建个“test.properties”,里面随便来上一行,例如Hello ${user.name},好了,接下来修改我们的pom文件,来启动filtering功能

 

 

[html] view plain copy
 
 print?
  1. <span style="font-family:Comic Sans MS;font-size:18px;"><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.     <modelVersion>4.0.0</modelVersion>  
  4.     <groupId>testwebProject</groupId>  
  5.     <artifactId>com.test.web.test</artifactId>  
  6.     <version>0.0.1-SNAPSHOT</version>  
  7.     <packaging>war</packaging>  
  8.     <build>  
  9.         <!--第一种方式,两种方式都需要指定需要编译的目录 -->  
  10.         <resources>  
  11.             <resource>  
  12.                 <directory>src/main/resources</directory>  
  13.                 <!--可以在此配置过滤文件  -->  
  14.                 <includes>  
  15.                     <include>**/*.xsd</include>  
  16.                     <include>**/*.properties</include>  
  17.                 </includes>  
  18.                 <!--开启filtering功能  -->  
  19.                 <filtering>true</filtering>  
  20.             </resource>  
  21.         </resources>  
  22.   
  23.       
  24.   
  25.   
  26.         <plugins>  
  27.             <plugin>  
  28.                 <artifactId>maven-war-plugin</artifactId>  
  29.                 <configuration>  
  30.                     <version>2.5</version>  
  31.                 </configuration>  
  32.             </plugin>  
  33.         </plugins>  
  34.     </build>  
  35. </project></span>  



 

 然后编译我们的maven项目

 $mvn clean compile -Duser.name=tom

 编译完后,查看输出文件 target/classes/test.properties 的内容,可见原先的 “Hello {user.name}” 已经变成 “Hello Tom”。

 

上面如果麻烦的话,也可以把filtering用到的变量写在项目得属性段里面,如下面的方式

 

[html] view plain copy
 
 print?
  1. <span style="font-family:Comic Sans MS;font-size:18px;"><!--也可以配置到外部属性里面 -->  
  2.     <properties>  
  3.         <user.name>Lucky</user.name>  
  4.         <user.age>50</user.age>  
  5.     </properties></span>  

 

 

 

进行编译,$mvn clean compile,在此查看的话,就会看到属性被替换的效果

当然了,如果属性比较多的话,那么此时可以把属性单独抽取出来一个*.properties文件来保存,例如我们在pom.xml的同级目录下面创建一个project.properties,里面指明我们的内容

user.name=Lucky

紧接着在修改我们的pom文件,如下

 

[html] view plain copy
 
 print?
  1. <span style="font-family:Comic Sans MS;font-size:18px;"><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.     <modelVersion>4.0.0</modelVersion>  
  4.     <groupId>testwebProject</groupId>  
  5.     <artifactId>com.test.web.test</artifactId>  
  6.     <version>0.0.1-SNAPSHOT</version>  
  7.     <packaging>war</packaging>  
  8.   
  9.   
  10.     <build>  
  11.         <!--第一种方式,两种方式都需要指定需要编译的目录 -->  
  12.         <resources>  
  13.             <resource>  
  14.                 <directory>src/main/resources</directory>  
  15.                 <!--可以在此配置过滤文件 -->  
  16.                 <includes>  
  17.                     <include>**/*.xsd</include>  
  18.                     <include>**/*.properties</include>  
  19.                 </includes>  
  20.                 <!--开启filtering功能 -->  
  21.                 <filtering>true</filtering>  
  22.             </resource>  
  23.         </resources>  
  24.   
  25.         <filters>  
  26.             <!-- 是以该pom文件路径作为参考 -->  
  27.             <filter>project.properties</filter>  
  28.         </filters>  
  29.   
  30.   
  31.         <plugins>  
  32.             <plugin>  
  33.                 <artifactId>maven-war-plugin</artifactId>  
  34.                 <configuration>  
  35.                     <version>2.5</version>  
  36.                 </configuration>  
  37.             </plugin>  
  38.         </plugins>  
  39.     </build>  
  40. </project></span>  

 

 

再次执行编译命令的话,就会看到效果



 profile功能

 允许在项目文件(pom.xml)里面定义若干个profile段,然后在编译时选择其中的一个用于覆盖项目文件原先的定义。接着上一个例子,如果我们需要为开发环境和生产环境定义不同的 user.name 属性值,则我们在项目目录里创建两个属性文件分别是pre.properties和dev.properties,然后再每个文件里分别写入user.name=lucky和user.name=wangwang,然后在此修改我们的pom文件,修改后如下所示

 

[html] view plain copy
 
 print?
  1. <span style="font-family:Comic Sans MS;font-size:18px;"><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.     <modelVersion>4.0.0</modelVersion>  
  4.     <groupId>testwebProject</groupId>  
  5.     <artifactId>com.test.web.test</artifactId>  
  6.     <version>0.0.1-SNAPSHOT</version>  
  7.     <packaging>war</packaging>  
  8.   
  9.   
  10.     <build>  
  11.         <!--第一种方式,两种方式都需要指定需要编译的目录 -->  
  12.         <resources>  
  13.             <resource>  
  14.                 <directory>src/main/resources</directory>  
  15.                 <!--可以在此配置过滤文件 -->  
  16.                 <includes>  
  17.                     <include>**/*.xsd</include>  
  18.                     <include>**/*.properties</include>  
  19.                 </includes>  
  20.                 <!--开启filtering功能 -->  
  21.                 <filtering>true</filtering>  
  22.             </resource>  
  23.         </resources>  
  24.   
  25.         <profiles>  
  26.             <profile>  
  27.                 <id>dev</id>  
  28.                 <activation>  
  29.                 <!--默认的编译选项  -->  
  30.                     <activeByDefault>true</activeByDefault>  
  31.                 </activation>  
  32.                 <build>  
  33.                     <filters>  
  34.                         <filter>pre.properties</filter>  
  35.                     </filters>  
  36.                 </build>  
  37.             </profile>  
  38.   
  39.             <profile>  
  40.                 <id>pre</id>  
  41.                 <build>  
  42.                     <filters>  
  43.                         <filter>dev.properties</filter>  
  44.                     </filters>  
  45.                 </build>  
  46.             </profile>  
  47.         </profiles>  
  48.   
  49.   
  50.         <plugins>  
  51.             <plugin>  
  52.                 <artifactId>maven-war-plugin</artifactId>  
  53.                 <configuration>  
  54.                     <version>2.5</version>  
  55.                 </configuration>  
  56.             </plugin>  
  57.         </plugins>  
  58.     </build>  
  59. </project></span>  


在编译项目时,可以使用 -P 参数指定需要使用的 profile 的 id,比如下面命令将会使用 dev profile

 

$mvn clean compile -Pdev

如果想使用pre,只需要改为以下即可

$mvn clean compile -Ppre

假如不指定 -P 参数的话,则会使用 activeByDefault=true 的一项(即 pre)。

 

 

spring bean 注解分为两类:

1、一类是使用Bean,即是把已经在xml文件中配置好的Bean拿来用,完成属性、方法的组装;比如@Autowired , @Resource,可以通过byTYPE(@Autowired)、byNAME(@Resource)的方式获取Bean;

 

2、一类是注册Bean,@Component , @Repository , @ Controller , @Service , @Configration这些注解都是把你要实例化的对象转化成一个Bean,放在IoC容器中,等你要用的时候,它会和上面的@Autowired , @Resource配合到一起,把对象、属性、方法完美组装。

 

 

 jar -tvf ABC-1.0.0-SNAPSHOT.jar  查看jar包的内容

tar -zvf ABC.jar 可以直接解压 

 

首先,来看下MAVENx项目标准的目录结构:

 

java 学习总结
Maven中profile和filtering实现多个环境下的属性过滤
 

 

一般情况下,我们用到的资源文件(各种xml,properites,xsd文件等)都放在src/main/resources下面,利用maven打包时,maven能把这些资源文件打包到相应的jar或者war里。

  • src/main/resources,负责管理项目主体的资源。在使用Maven2执行compile之后,这个目录中的所有文件及子目录,会复制到target/classes目录中,为以后的打包提供了方便。
  • src/test/resources,负责管理项目测试的资源。在使用Maven2执行test-compile之后,这个目录中的所有文件及子目录,会复制到target/test-classes目录中,为后续的测试做好了准备。

 流程: resouce路径copy到target/class中,然后打包,将resource总的文件打入到jar包中。

 

 

所有resource目录下的东西都会打入到jar包中,供jar包使用,这样jar可以读取到配置文件了。

 

 

ABC.jar 包含完整的class文件、配置文件、资源文件以及相关的依赖库(在lib目录中)。

ABC-source.jar 中包含的是源文(java文件),配置文件,资源文件,不包含依赖库。

 

logback 配置:

    1. 设置loger
      用来设置某一个包或者具体的某一个类的日志打印级别、以及指定<appender>。<loger>仅有一个name属性,一个可选的level和一个可选的addtivity属性。
      name:用来指定受此loger约束的某一个包或者具体的某一个类。
      level:用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF,还有一个特俗值INHERITED或者同义词NULL,代表强制执行上级的级别。如果未设置此属性,那么当前loger将会继承上级的级别。
      addtivity:是否向上级loger传递打印信息。默认是true。

      <loger>可以包含零个或多个<appender-ref>元素,标识这个appender将会添加到这个loger。
    2. 设置root
      也是<loger>元素,但是它是根loger。只有一个level属性,应为已经被命名为"root".
      level:用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF,不能设置为INHERITED或者同义词NULL。默认是DEBUG。

      <root>可以包含零个或多个<appender-ref>元素,标识这个appender将会添加到这个loger。
 
root logger是所有logger的parent。
对于某一个logger来说,name可以控制包或者类,一个logger可以添加多个appender
 
 
 

http://www.cnblogs.com/panxuejun/p/5847774.html

 

可以理解成tomcat和spring本身是解耦的,spring实现了一套自己的servelet,从而简化了web编程。

spring在从web.xml 中启动,注册了一大推bean,并 通过component-scan来扫描java程序的bean,从而实现注入(auto-wire,resource等。)

 

大牛请绕过,此文仅针对自己小白水平,对web程序的启动流程做个清晰的回顾。

一.使用spring等框架的web程序在Tomcat下的启动流程

1)Tomcat是根据web.xml来启动的。首先到web.xml

2)web.xml中负责启动spring和spring mvc。对应的启动配置文件分别是

启动spring mvc,并进行所有资源路径映射

java 学习总结
Maven中profile和filtering实现多个环境下的属性过滤
<servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/cfg/springmvc-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
java 学习总结
Maven中profile和filtering实现多个环境下的属性过滤

启动spring,通过ContextLoaderListener

1
2
3
4
5
6
7
 <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/cfg/spring.xml</param-value>
</context-param>

3)spring中对一些orm框架的启动,包括Mybatis/hibernate。orm框架的启动基本都是通过sqlsessionFactory bean来启动的。

    并配置各种bean到ioc容器中。包括datasource等。

 

4)web应用程序中,spring相当于程序运行的平台,spring对整个程序提高供ioc支持和aop支持。

spring提供注解如@service @repository @component将各种类注册到ioc容器中。通过设置scan package的方式,spring在启动时候会扫描包下的所有注解,并将它们注册到ioc容器中。并针对@autowired @resource,将一些bean从ioc容器中获取填充到bean的构造属性中。

spring会自动扫描如下包中的注解:

<context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>

以上可以看出spring所有的bean注入都是在spring.xml中配置的,所有的bean注入都在spring.xml中配置的。

@autowired @resource只针对于类的成员变量,不针对方法里的局部变量。

注:正是spring的ioc支持了controller层注入service,service注入dao。打通了各层之间的桥梁,省去了原来的new service(),new Dao()的方法。

 

问答

1.使用spring ioc有什么好处?

答:网上有很多介绍使用Spring IOC容器的好处的文章,我看到的主要有两点, 
1.方便测试,当需要测试的类依赖其他的类时,可以为依赖的类做个mock,然后注入进来。 
2.方便维护及升级,当某个类需要修改实现时,只要接口没变,则无需修改源代码,重写一个实现类,修改下配置即可。 

3.默认下,IOC容器管理的bean都是单例的,不会被gc掉。

4.spring提倡面向接口开发,因此在servcie里面的dao直接是接口就可以了。这样有助于解耦。(测试等等)。。 

如果不用spring,要么自己new daoimpl,就面向具体了,如果还想抽象,就必须自己写工厂——其实spring就是一个工厂IOC。实现类似的作用。 

其实,面向抽象是实现和接口分离,对于多数的项目,实现大量变化的机会不是很大,因此直接面向具体(省略掉dao接口等)是我个人推荐的做法。 

spring工厂对其中的对象的生命周期,作用范围都有很明确的定义,很容易使用,如果自己做这么一套,只怕没这么好。 

第三,spring对ioc管理的对象,可以做很多增强,比如aop,代理等等。 

5.感觉AOP最有用了。

 

2.spring是怎样支持面向接口编程的?

由于依赖于接口,可以通过依赖注入随时替换DAO接口的实现类,而应用程序完全不用了解接口与底层数据库操作细节。

应用程序----调用-----》DAO接口《---实现--DAO接口实现类----操作------》数据库