送给入门maven的愤怒青年:archetype-cattalog内容详解

原创
2017/12/13 18:38
阅读数 4.8K

 

前几日在知乎提了一个问题:

maven中央仓库的archetype-catalog.xml为什么那么臃肿?难道没有人去维护吗?

可能是因为我太蠢,也可能是因为被人瞧不起,所以一般没有人回答我的问题.

这让我觉得很郁闷,心想有什么了不起的,没人愿意回答算了,我自己能解决.

接着买了一本<maven实战>,阅读了最后一章才算是对maven又有了进一步的认识.

求人不如求己!人丑就要多读书.当然像我这种长得帅的,多读点书也没坏处!

 --------------------------------------------cut line-----------------------------------------------

闲话不多说,今天的主题是maven的archetype-catalog相关的知识.在catalog使用深入了解之前,我们必须具备一些其它的知识和常识:

1.懂得maven的大致模样(非必要):

这就是maven的目录结构,下面三个文本文档就是伟大的开源许可声明,emm....其实大家都知道的!

bin目录:

    这里面包含的是maven的bat批处理文件和一些shell脚本文件,就是它控制调度maven的执行进程,当然bin里面并没有包含maven的核心代码(核心代码包括编译,打包,部署等等功能文件).

    

    在mvn.bat中就处理了很多信息,寻找各种配置文件,各种环境变量等等.

    依稀可见的配置java运行工具.(滑稽..)

boot目录:

    emm...这是maven的classloader,类加载器,jdk也有自己的类加载器,负责加载java类文件,当然,你也可以自己写一个,对吧?教程?好嘛,我待会儿就把<深入分析java web>的第4,5,6章仔细看一遍.

    maven使用自己的类加载器,是因为它在这里面有更多的功能,和更适配的方法.具体参考这里:

    http://classwords.codehaus.org/

conf目录:

    这个目录包含了maven的一些配置文件.

    其中日志配置先忽略掉.最重要的是settings.xml,maven的行为都是由它来指定的.toolchains.xml是用于指定其它所依赖的插件的.这两个文件都可以拷贝到 {user}/.m2/ 目录下,用于定义maven的行为.

    toolchains的详细说明在其xml的注释中有详细介绍.

    

预览

 

    settings也是,如果你不厌烦读english,真的该好好读读,这两个个xml的标签也就那么几个,很容易理解.

lib目录:

    这个目录是maven的模块目录,还包含一些第三方的依赖jar文件.(说好的超级pom在哪里呢?你看到了吗?)

 

2.了解maven的常用指令:

    1.mvn clean,clean用户删除maven打包生成的目标资源和文件.

    2.mvn compile,编译,用于编译源代码.

    3.mvn package,package之前会先compile,然后在将编译后的字节码文件和资源文件,配置文件进行相关格式的打包.

    4.mvn install,将jar安装到本地的仓库中.

    5....(deploy?发布命令,后面再理解.)

3.maven怎么生成我想要的项目?

    接着我们来学习,怎么使用maven,以具体案例来:

    小阮现在要帮朋友做一个ssm框架的网站,打算采用idea开发环境,使用maven管理项目.于是他直接在idea中创建了一个maven项目,并选择了internal的archetype:  maven-archetype-webapp,创建完成后,他心想我也会用maven管理项目了.可是,当他兴高采烈地添加各种依赖,并撰写了好几个个xml配置文件和属性配置文件后,将helloword部署至tomcat8.5.问题出现了:

    /vip/test   是的,前台404,后台no request mapping for.....

    查看日志文件,好像并没有看到springmvc容器初始化的过程,各种修改配置文件,各种spring版本尝试,一天后,他.....放弃了.

    于是他打算重修maven课程,接着他想到了:线上archetype-catalog.xml中有那么多maven项目模型的坐标,一定会有ssm的!

    好的,在磁盘中新建一个文件夹YTPetss,打开,空白处按住shift+鼠标右键,打开powershell(CMD)

    输入命令 mvn archetype:generate    后不接参数.(这是maven的交互式项目创建命令).

 

    注意:archetype-catalog.xml应该有三处:1.远程仓库里面的,2.用户自定义的.m2下,3.internal内置的.

    在maven3当中,优先顺序应该是远程-->本地-->内置.

    可以通过 -DarchetypeCatalog=internal/local/remote指定使用哪个地方的archetype-catalog.

    在有网络的情况下,会优先读取网络中的,这个步骤那是相当的漫长.有一种方法非常好用:在http://repo1.maven.org/maven2/这个ftp服务器中用下载器把xml下载下来丢在.m2中,断开网络在运行mvn archetype:generate  这样就会快很多.

    等待也是一种享受,等到列表后,现在中remote catalog大概有15W行代码,小阮利用搜索功能找到了ssm的框架:

    十五万行代码好像就找到这一个ssm的简单模板.感谢这位兄弟,果断选择它,接着输入各种groupid,artfactid,version

    接着确认输入Y:

    接着就生成了基础的ssm模型,还有pom和xml配置文件也准备妥当了,日志都配好了,还有示例的dao,service,controller,经过短暂的调试和修改,把项目导入idea,在idea中稍加配置(compiler版本,run的配置等)我迅速进入到了业务逻辑的开发.很好用.

    可是接着问题又来了,这激发了我对archetype-catalog浓厚的兴趣,于是乎去知乎提问,没人回答....然后接着就是学习之路了!

4.ArcheType

    骚年,你是否在使用maven的时候疑惑重重呢?你是否也想搞清楚archetype-catalog的运行原理呢?你是否也想自己做一个自己的archetype呢?

    没问题,接下来我就教会你怎么去做!耐心看下去,你就是下一个我,emm....(其实我很优秀的啦罒ω罒)

4.1ArcheType使用

    首先我们需要明白的一点是archetype并不是mvn的核心插件,它只是方便我们从模板创建项目.archetype的功能是由maven-archetype-plugin提供的!

    由上述指令调用我们就能清晰地看出,这个指令的来源是maven-archetype-plugin.

    在maven3中,我们从模板创建一个项目的指令是mvn archetype:generate  相比于maven2的命令,要简洁十分.调用这个指令后,就可以用交互式(需输入groupid,artfactid,version,package等信息)的方法生成项目雏形.

    当然,maven3支持全自动化地生成项目,我们只需要把需要手动输入的信息放到批处理脚本或者shell脚本中就可以了.用  '-B' 参数声明全自动化处理.

    如这样:mvn archetype:generate -B 

               -D -D -D [坐标信息]   -D -D -D -D自己的信息(groupid,artfactid,version,package等)

4.2最简单的archetype介绍

    在maven的中央仓库里,有数不清的archetype,目前整个archetype-catalog.xml文件共有15W行左右.而最简单的archetype莫过于maevn-archetype-quickstart.它能生成一个最简单的项目.我们来看一看:

    在powershell中输入 mvn archetype:generate -DarchetypeCatalog=internal

 

    接着选择maven-archetype-quickstart:

    输入各种信息,目录如下:

        ../src/main/java/org/panda,其中有App.java

        ../src/test/java/org/panda,其中有AppTest.java

        ../pom.xml

    pom.xml内容如下:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.panda</groupId>
  <artifactId>ytpetss</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>ytpetss</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

        一组项目描述信息,一个依赖坐标.

    这就是一个最简单的maven项目的组成,没有其它杂物.非常pure.

    了解完最简单,作为javaweb程序员,是时候在了解一下webapp吧?

    按照同样的执行方式在来一遍

    

配置信息

 

    我们得到了如下资源信息:

        ../src/main/resources,空目录

        ../src/main/webapp/index.jsp,包含简单的helloword文本.

        ../src/main/webapp/WEB-INF/web.xml, 一个简单的web部署描述符

        ../pom.xml  , 项目对象模型.

    其中,pom.xml中代码如下:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.panda</groupId>
  <artifactId>PandaFert</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>PandaFert Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <finalName>PandaFert</finalName>
  </build>
</project>

    依旧是一些简单的信息,其中重要的地方是打包方式是war.

    然后接着是web.xml部署描述符:

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
</web-app>

    总共的信息就这么多,那时候有很多同学就问,用eclipse生成maven项目修改部署描述符为3.0要报错,,,各种的,那就直接使用maven的cli生成一个,更改web.xml描述信息,在导入eclipse不就行了嘛,对不对呀,多简单!

4.3自己动手编写archetype,丰衣足食

    对于企业,无数个项目都交给开发人员去处理,一个一个重复配,他肯定也不愿意.而且还会出错,所以就有必要使用archetype来创建项目.

    对于个人,经常进行项目开发,先配好自己的archetype,到使用的时候就可以不慌不忙,专心业务逻辑了,在也不用担心环境还配不cengzan[四川话,意为妥当].

    当我们自己做好了archetype后,配合maven-archetype-plugin使用脚本部署项目,整个过程高效又高大上,何乐而不为呢?仅凭这一点,都要学会怎么自己做archetype.

    那么在自制一个archetype之前,我们必须了解一个archetype的结构:

  • pom.xml(这个pom.xml是archetype本身的pom,而不是从这个archetype创建项目时项目的pom)
  • src/main/resources/archetype-resources/pom.xml(这个xml是基于该模型创建的项目的pom)
  • arc/main/resources/META-INF/maven/archetype-metadata.xml(这是archetype的描述符文件,与webapp为web.xml有异曲同工之妙)
  • src/main/resources/archetype-resources/**(其它需要包含在骨架中的内容)

    创建好结构后,使用maven的打包工具可以将archetype打包成jar,并安装在本地仓库中,然后通过用户自定义的archetype-catalog.xml中的坐标信息就可以使用该archetype创建项目.

    创建一个archetype我分解为如下步骤:

  •     建立目录结构,按照以上的结构信息建立.
  •     创建archetype的pom内容
  •     创建archetype-resources下的pom的内容
  •     创建核心内容:archetype-metadata.xml
  •     将其它文件和资源拷贝到相应的位置

    接下来,我们通过一个创建实例(创建一个spring,springmvc,mybatis)来详细解释整个过程:

4.3.1创建archetype的骨架

  •     创建mrruan-archetype-ssm文件夹.
  •     打开文件夹,创建一个文本文件,改名为pom.xml
  •     在当前根目录下创建 src/main/resources/archetype-resources/pom.xml
  •     在当前根目录下创建 src/main/resources/META-INF/maven/archetype-metadata.xml
  •     还有一部分用户自定义的内容要放到archetype-resources下,待会再说

4.3.2创建archetype的pom的内容

    archetype其本质也是一个maven项目,因此其中pom.xml的结构也大同小异.在archetype的pom.xml键入如下内容:

<project xmlns="http://maven.apache.org/POM/4.0.0" 
		 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
							 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.mrruan.archetypes</groupId>
    <artifactId>mrruan-archetype-ssm</artifactId>
    <version>1.0-SNAPSHOT</version>
</project>

    其中仅仅包含了archetype的坐标信息.接着我们来编写archetype-resources/下的pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" 
		 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
							 http://maven.apache.org/maven-v4_0_0.xsd">

  <modelVersion>4.0.0</modelVersion>
  <groupId>${groupId}</groupId>
  <artifactId>${artifactId}</artifactId>
  <version>${version}</version>
  <name>${artifactId}</name>
  <url>http://maven.apache.org</url>

  <dependencies>

		<!-- aop specification -->
		<dependency>
			<groupId>aopalliance</groupId>
			<artifactId>aopalliance</artifactId>
			<version>${aopalliance.version}</version>
		</dependency>

		<!-- spring framework -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>


		<!-- httpclient -->
		<dependency>
			<groupId>commons-httpclient</groupId>
			<artifactId>commons-httpclient</artifactId>
			<version>3.1</version>
		</dependency>

		<!-- pinyin -->
		<dependency>
			<groupId>com.belerweb</groupId>
			<artifactId>pinyin4j</artifactId>
			<version>2.5.0</version>
		</dependency>

		<!-- json-lib -->
		<dependency>
			<groupId>net.sf.json-lib</groupId>
			<artifactId>json-lib</artifactId>
			<version>2.4</version>
			<classifier>jdk15</classifier>
		</dependency>

		<!-- poi -->
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi</artifactId>
			<version>3.9</version>
		</dependency>



		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-expression</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		
		<!-- mybatis -->
		 <dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>${mybatis.version}</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>${mybatis.spring.version}</version>
		</dependency>
		<!-- jsr303 validation -->
		<dependency>
			<groupId>javax.validation</groupId>
			<artifactId>validation-api</artifactId>
			<version>${javax.validation.version}</version>
		</dependency>

		<!-- jsr303 implementation -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-validator</artifactId>
			<version>${hibernate.validator.version}</version>
		</dependency>

		<!-- apache-commons libraries -->
		<dependency>
			<groupId>commons-beanutils</groupId>
			<artifactId>commons-beanutils</artifactId>
			<version>${apache.commons.beanutils.version}</version>
		</dependency>

		<dependency>
			<groupId>commons-fileupload</groupId>
			<artifactId>commons-fileupload</artifactId>
			<version>1.3.2</version>
		</dependency>

		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>1.3.2</version>
		</dependency>

		<!-- servlet api -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>${servlet.api.version}</version>
		</dependency>

		<!-- Joda-time -->
		<dependency>
			<groupId>joda-time</groupId>
			<artifactId>joda-time</artifactId>
			<version>${joda-time.version}</version>
		</dependency>

		<!-- JSTL -->
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>${jstl.version}</version>
		</dependency>

		<dependency>
			<groupId>taglibs</groupId>
			<artifactId>standard</artifactId>
			<version>${taglibs.version}</version>
		</dependency>


		<!-- slf4j dependency -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
		</dependency>

		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${slf4j.version}</version>
		</dependency>

		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jcl-over-slf4j</artifactId>
			<version>${slf4j.version}</version>
		</dependency>

		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>${log4j.version}</version>
		</dependency>

		<!-- Test -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit.version}</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.mockito</groupId>
			<artifactId>mockito-core</artifactId>
			<version>${mockito.version}</version>
			<scope>test</scope>
		</dependency>

		<!-- Mysql connectors -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.connector.version}</version>
		</dependency>

		<!-- postgresql -->
		<dependency>
			<groupId>postgresql</groupId>
			<artifactId>postgresql</artifactId>
			<version>${postgresql.version}</version>
		</dependency>

		<!-- Alibaba jdbc pool -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.0.9</version>
		</dependency>

		<!-- Jakson dependencies -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-core</artifactId>
			<version>2.4.2</version>
		</dependency>

		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-annotations</artifactId>
			<version>2.4.2</version>
		</dependency>

		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.4.2</version>
		</dependency>

		<!-- Cas Client -->
		<dependency>
			<groupId>org.jasig.cas</groupId>
			<artifactId>cas-client-core</artifactId>
			<version>3.1.10</version>
		</dependency>


	</dependencies>


	<properties>

		<!-- Dependency Versions -->
		<aopalliance.version>1.0</aopalliance.version>
		<org.springframework.version>4.1.1.RELEASE</org.springframework.version>
		<mybatis.version>3.4.3</mybatis.version>
		<mybatis.spring.version>1.3.0</mybatis.spring.version>
		<javax.validation.version>1.0.0.GA</javax.validation.version>
		<hibernate.validator.version>4.3.2.Final</hibernate.validator.version>
		<apache.commons.beanutils.version>1.9.1</apache.commons.beanutils.version>
		<servlet.api.version>3.0.1</servlet.api.version>
		<joda-time.version>2.4</joda-time.version>
		<jstl.version>1.2</jstl.version>
		<taglibs.version>1.1.2</taglibs.version>
		<slf4j.version>1.7.7</slf4j.version>
		<log4j.version>1.2.17</log4j.version>
		<junit.version>4.11</junit.version>
		<mockito.version>1.9.5</mockito.version>
		<mysql.connector.version>5.1.30</mysql.connector.version>
		<postgresql.version>9.1-901.jdbc4</postgresql.version>
		<!-- Plugin Versions -->
		<!-- <coveralls-maven-plugin.version>2.2.0</coveralls-maven-plugin.version> 
			<cobertura-maven-plugin.version>2.6</cobertura-maven-plugin.version> <maven-javadoc-
plugin.version>2.9</maven-javadoc-plugin.version> 
			<maven-versions-plugin.version>1.3.1</maven-versions-plugin.version> <maven-source-
plugin.version>2.2</maven-source-plugin.version> 
			<maven-pmd-plugin.version>2.7.1</maven-pmd-plugin.version> <maven-jxr-
plugin.version>2.3</maven-jxr-plugin.version> 
			<maven-projectinfo-reports-plugin.version>2.4</maven-projectinfo-reports-
plugin.version> 
			<maven-taglist-plugin.version>2.4</maven-taglist-plugin.version> <maven-surefire-
plugin.version>2.12.4</maven-surefire-plugin.version> 
			<maven-checkstyle-plugin.version>2.10</maven-checkstyle-plugin.version> <maven-
enforcer-plugin.version>1.2</maven-enforcer-plugin.version> 
			<maven-assembly-plugin.version>2.2.1</maven-assembly-plugin.version> <maven-aspectj-
plugin.version>1.5</maven-aspectj-plugin.version> 
			<maven-antrun-plugin.version>1.5</maven-antrun-plugin.version> Project configuration -->
		<project.build.sourceVersion>1.8</project.build.sourceVersion>
		<project.build.targetVersion>1.8</project.build.targetVersion>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
	</properties>

    <build>
		<finalName>${artifactId}</finalName>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.3.2</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-war-plugin</artifactId>
				<version>2.3</version>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				<version>2.7.2</version>
				<configuration>
					<parallel>methods</parallel>
					<threadCount>10</threadCount>
					<argLine>-Dfile.encoding=UTF-8</argLine>
					<!-- <skip>true</skip> -->
					<!-- <testFailureIgnore>true</testFailureIgnore> -->
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

    解析:

    上述配置文件中${xxx}此中的信息即从模型创建项目时在cli手动填写的值.

    pom文件中声明了项目所依赖的所有jar包信息.

    在build节点中定义了plugin,plugin中定义了编译器插件,源代码版本,war打包插件,测试用的surefire插件.

    紧接着,我们定义最重要的描述文件archetype-metadata.xml

<?xml version="1.0" encoding="UTF-8"?>
<archetype-descriptor name="sample">
	<fileSets>
		<fileSet filtered="true" packaged="true">
			<directory>src/main/java</directory>
			<includes>
				<include>**/*.java</include>
			</includes>
		</fileSet>
		<fileSet filtered="true" packaged="true">
			<directory>src/test/java</directory>
			<includes>
				<include>**/*.java</include>
			</includes>
		</fileSet>
		<fileSet filtered="true" packaged="false">
			<directory>src/main/resources</directory>
			<includes>
				<include>**/*.properties</include>
				<include>**/*.xml</include>
			</includes>
		</fileSet>
	</fileSets>
	<requiredProperties>
		<requiredProperty key="groupId">
			<defaultValue>org.mrruan</defaultValue>
		</requiredProperty>
	</requiredProperties>
</archetype-descriptor>

    代码如上,其中定义了两大类元素,fileSet和requiredProperty.配置文件中对应的内容我们都需要添加到相应目录,其中需要注意的是filtered="true"表示替换为命令行输入的值,${x}.这是因为.java文件中的包名是动态变化的.此处需要注意.

    另外,在项目配置过程中如果需要用到什么参数,用户可以再requiredProperty中指定.

    紧接着,描述文件撰写完毕后,我们创建ssm对应的结构:

  •     在archetype-resources下创建src/main/java,然后在其中创建三个文件(注意,根据此archetype创建的项目实际包路径之类的会存在一些问题,需要手动调整。)
  • 内容如下
  • package ${package}.web.controller
    
    @Controller
    @RequestMapping("/demo")
    public DemoController{
    	private static String RS_RESULT="{\result"\",\"true\"}";
    	
    	@RequestMapping("/test")
    	@ResponseBody
    	public String demo(){
    		return RS_RESULT;
    	}
    }
    
    
    package ${package}.core.dao
    
    @Repository
    public DemoDao{
    	
    }
    
    
    package ${package}.core.service
    
    @Service
    public DemoDao{
    	
    }

    最后是一些项目配置信息的添加了:

    • 在src/main/resource中添加log4j.properties内容如下:

                                                      # Output pattern : date [thread] priority category - message
      log4j.rootLogger=INFO, Console
      
      log4j.logger.file=WARN, Console, RollingFile
      log4j.additivity.file = false
      
      log4j.logger.console=WARN, ShortConsole, RollingFile
      log4j.additivity.console = false
      
      #Console
      log4j.appender.Console=org.apache.log4j.ConsoleAppender
      log4j.appender.Console.Encoding=UTF-8
      log4j.appender.Console.layout=org.apache.log4j.PatternLayout
      log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
      
      #ShortConsole
      log4j.appender.ShortConsole=org.apache.log4j.ConsoleAppender
      log4j.appender.ShortConsole.Encoding=UTF-8
      log4j.appender.ShortConsole.layout=org.apache.log4j.PatternLayout
      log4j.appender.ShortConsole.layout.ConversionPattern=%d - %m%n
      
      #RollingFile
      log4j.appender.RollingFile=org.apache.log4j.RollingFileAppender
      log4j.appender.RollingFile.Encoding=UTF-8
      log4j.appender.RollingFile.File= /tmp/dashboard.log
      log4j.appender.RollingFile.layout=org.apache.log4j.PatternLayout
      log4j.appender.RollingFile.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
      
      #hibernate sql
      log4j.logger.org.hibernate.SQL=info   
         
      log4j.logger.org.hibernate.type=warn 
      
      log4j.logger.org.hibernate.validator=error
      
      log4j.logger.org.springframework=warn  
      
      
      

       

    • 在src/main/resource中添加jdbc.properties:

      #Product dashboard mysql
      mysql.jdbc.url=jdbc:mysql://localhost:3306/ytpet
      mysql.jdbc.username=root
      mysql.jdbc.password=1314
      mysql.jdbc.driverClassName=com.mysql.jdbc.Driver
      
      mysql.jdbc.pool.initialSize=2
      mysql.jdbc.pool.minIdle=2
      mysql.jdbc.pool.maxActive=30
      
      mysql.jdbc.pool.maxWait=60000
      mysql.jdbc.pool.timeBetweenEvictionRunsMillis=60000
      mysql.jdbc.pool.minEvictableIdleTimeMillis=300000
      
      
      
      
      
      

       

    •  

      在src/main/resource中添加spring目录,并加入如下两个配置文件

      root-context.xml(没有配置SqlSessionFactory)

       

      <?xml version="1.0" encoding="UTF-8"?>
      <beans xmlns:mvc="http://www.springframework.org/schema/mvc"
      	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans"
      	xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
      	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
              http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
              http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
              http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
      
      	<context:property-placeholder location="classpath:jdbc.properties" />
      
      	<context:component-scan base-package="${package}">
      		<context:exclude-filter expression="org.springframework.stereotype.Controller"
      			type="annotation" />
      	</context:component-scan>
      
      	<!-- dashboard数据源配置 -->
      	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      		init-method="init" destroy-method="close">
      		<!-- 数据源驱动类可不写,Druid默认会自动根据URL识别DriverClass -->
      		<property name="driverClassName" value="${mysql.jdbc.driverClassName}" />
      
      		<!-- 基本属性 url、user、password -->
      		<property name="url" value="${mysql.jdbc.url}" />
      		<property name="username" value="${mysql.jdbc.username}" />
      		<property name="password" value="${mysql.jdbc.password}" />
      
      		<!-- 配置初始化大小、最小、最大 -->
      		<property name="initialSize" value="${mysql.jdbc.pool.initialSize}" />
      		<property name="minIdle" value="${mysql.jdbc.pool.minIdle}" />
      		<property name="maxActive" value="${mysql.jdbc.pool.maxActive}" />
      
      		<!-- 配置获取连接等待超时的时间 -->
      		<property name="maxWait" value="${mysql.jdbc.pool.maxWait}" />
      
      		<!-- 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒 -->
      		<property name="timeBetweenEvictionRunsMillis"
      			value="${mysql.jdbc.pool.timeBetweenEvictionRunsMillis}" />
      
      		<!-- 配置一个连接在池中最小生存的时间,单位是毫秒 -->
      		<property name="minEvictableIdleTimeMillis"
      			value="${mysql.jdbc.pool.minEvictableIdleTimeMillis}" />
      
      		<property name="validationQuery" value="SELECT 'x'" />
      		<property name="testWhileIdle" value="true" />
      		<property name="testOnBorrow" value="false" />
      		<property name="testOnReturn" value="false" />
      
      		<!-- 配置监控统计拦截的filters -->
      		<property name="filters" value="stat" />
      	</bean>
      
      	<!-- 配置jdbcTempate bean -->
      	<!--<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">-->
      		<!--<property name="dataSource" ref="dataSource" />-->
      	<!--</bean>-->
      
      	<bean id="transactionManagerMysql"
      		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      		<property name="dataSource" ref="dataSource" />
      		<property name="nestedTransactionAllowed" value="true"></property>
      	</bean>
      
      	<!-- 全注解方式 需加上@Transactional -->
      	<tx:annotation-driven transaction-manager="transactionManagerMysql" />
      </beans>
      

      servlet-context.xml

      <?xml version="1.0" encoding="UTF-8"?>
      <beans xmlns:mvc="http://www.springframework.org/schema/mvc"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans"
          xmlns:context="http://www.springframework.org/schema/context"
          xmlns:tx="http://www.springframework.org/schema/tx"
          xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
              http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
              http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
              http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
      
      
          <context:annotation-config />
          <!-- <mvc:default-servlet-handler /> -->
          
      
          <context:component-scan base-package="${package}"
              use-default-filters="false">
              <context:include-filter
                  expression="org.springframework.stereotype.Controller" type="annotation" />
          </context:component-scan>
      
      
          <mvc:annotation-driven>
      
              <!-- 防止ie下访问json请求变成下载弹框 -->
              <mvc:message-converters
                  register-defaults="true">
                  <bean id="jsonConverter"
                      class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                      <property name="prefixJson" value="false"/>
                      <property name="supportedMediaTypes" value="text/html;charset=UTF-8" />
                  </bean>
              </mvc:message-converters>
          </mvc:annotation-driven>
      
          <!--配置文件上传bean-->
      
          <bean id="commonsMultipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
              <property name="maxUploadSize" value="100000"/>
              <property name="maxInMemorySize" value="10240"/>
          </bean>
      
          <bean id="viewResolver"
              class="org.springframework.web.servlet.view.InternalResourceViewResolver">
              <property name="viewClass"
                  value="org.springframework.web.servlet.view.JstlView" />
              <property name="prefix" value="/WEB-INF/jsp/" />
              <property name="suffix" value=".jsp" />
          </bean>
      
          <bean
              class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" />
      
          <bean
              class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping" />
      
          <bean
              class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />    
      </beans>
      

       

    截止目前为止,你已经配置完成了所有需要配置的任务,注意在检查一下,以防止漏掉的信息.如果确认完毕后,我们就可以进行下一步了.

    我们使用mvn clean install将archetype打包安装到本地仓库:

部分调试信息

    安装完成后,下面我们来使用自己创建的archetype.

4.3.3 使用自己创建的archetype生成项目:

    如果需要通过查找方式寻找模型,我们可以在.m2文件夹下打开powershell,然后键入mvn archetype:crawl,就会在repository仓库根目录下生成一个catalog:

    

(生成坐标的时候遇到了一些问题,参考了此处:http://maven.40175.n5.nabble.com/archetype-catalog-xml-location-archetype-crawl-versus-archetype-generate-td113741.html)

    内容大致如下:

<?xml version="1.0" encoding="UTF-8"?>
<archetype-catalog xsi:schemaLocation="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-catalog/1.0.0 http://maven.apache.org/xsd/archetype-catalog-1.0.0.xsd"
    xmlns="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-catalog/1.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <archetypes>
    <archetype>
      <groupId>org.apache.maven.archetypes</groupId>
      <artifactId>maven-archetype-quickstart</artifactId>
      <version>1.1</version>
      <description>quickstart</description>
    </archetype>
    <archetype>
      <groupId>org.mrruan.archetypes</groupId>
      <artifactId>mrruan-archetype-ssm</artifactId>
      <version>1.0-SNAPSHOT</version>
      <description>sample</description>
    </archetype>
  </archetypes>
</archetype-catalog>

    接着我们在一个空白的目录中(../test4/)打开powershell,然后键入 

    mvn archetype:generate -DarchetypeCatalog=local

    然后输入部分信息:

    

        得到项目:

    目录一角:

    至此,我们就用自己的archetype-catalog生成了项目。

4.3.4 更简单的生成archetype的方案

    从当前已有的项目生成一个archetype无疑是最简便的。详细参考官方文档:

https://maven.apache.org/archetype/maven-archetype-plugin/create-from-project-mojo.html

    学好archetype后,接下来可以在学习一下nexus私服的建立,这里应该会比较容易学懂了。

                                                                                                        #以上

展开阅读全文
加载中

作者的其它热门文章

打赏
0
0 收藏
分享
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部