`

maven2 形成一个模板框架

阅读更多
maven2:从现有工程中创建archetype
关键字: maven2 archetype ssh
http://eagle516.iteye.com/?show_full=true

最近用spring2.5.6+hibernate3.2+struts2.0.14做项目,用这些框架做项目最鬼麻烦的就是搭建工程的基本原型,为了在以后不用在这么麻烦,于是就有了创建一个自己的ssh的archetype的念头,说干就干,开始动手。



1.创建一个maven项目(在eclipse 中通过m2eclipse创建或者用mvn archetype:genetate命令创建)。

2.添加spring,hibernate,struts2的依赖包,我的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.eagle</groupId>
<artifactId>ssh-base</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.0.2</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
</plugin>
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>maven-jetty-plugin</artifactId>
<version>6.1.14</version>
</plugin>
</plugins>
</build>

<dependencies>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<type>jar</type>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring</artifactId>
<version>2.5.6</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.6.2</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.2</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-core</artifactId>
<version>2.0.14</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-spring-plugin</artifactId>
<version>2.0.14</version>
<type>jar</type>
<scope>compile</scope>
<exclusions>
<exclusion>
<artifactId>spring-beans</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
<exclusion>
<artifactId>spring-core</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
<exclusion>
<artifactId>spring-context</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
<exclusion>
<artifactId>spring-web</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate</artifactId>
<version>3.2.6.ga</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
<type>jar</type>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.14</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib-nodep</artifactId>
<version>2.1_3</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
</dependencies>
</project> 
3.添加基本的配置文件

src/main/resources/applicationContext.xml

<?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:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<context:property-placeholder location="WEB-INF/config/jdbc.properties" />

<!-- 定义数据源Bean,使用C3P0数据源实现 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="${jdbc.driverClassName}" />
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="${jdbc.url}" />
<!-- 指定连接数据库的用户名 -->
<property name="user" value="${jdbc.username}" />
<!-- 指定连接数据库的密码 -->
<property name="password" value="${jdbc.password}" />
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="20" />
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1" />
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1" />
<!-- 指定连接数据库连接池的连接的最大空闲时间 -->
<property name="maxIdleTime" value="20" />
</bean>

<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="mappingDirectoryLocations">
<list>
<value>classpath:org/eagle/orm</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect
</prop>
<prop key="show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.jdbc.batch_size">20</prop>
</props>
</property>
</bean>

<!-- 配置事务管理器 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>

<!-- 配置事务的传播性 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="del*" propagation="REQUIRED" />
<tx:method name="modify*" propagation="REQUIRED" />
<tx:method name="*" read-only="true" />
</tx:attributes>
</tx:advice>

<!-- 配置哪些类哪些方法使用事务 -->
<aop:config>
<!-- 配置切入点(定义哪些方法要进行事务处理) -->
<aop:pointcut id="allManager"
expression="execution(* org.eagle.services..*.*(..))" />
<!-- 定义advice -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="allManager" />
</aop:config>

</beans> 
src/main/resources/struts.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>

</struts>

src/main/webapp/WEB-INF/config/jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/shs2
jdbc.username=root
jdbc.password=ubuntu 
src/main/webapp/WEB-INF/config/log4j.properties

log4j.rootLogger=INFO, stdout, logfile

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n

log4j.appender.logfile=org.apache.log4j.RollingFileAppender
log4j.appender.logfile.File=${webapp.root}/WEB-INF/logs/pcdiy.log
log4j.appender.logfile.MaxFileSize=512KB
# Keep three backup files.
log4j.appender.logfile.MaxBackupIndex=3
# Pattern to output: date priority [category] - message
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

4.web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="WebApp_ID" version="2.5">

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>

<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>/WEB-INF/config/log4j.properties</param-value>
</context-param>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<listener>
<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>
</web-app> 


5.基本上可以,现在来生成archetype的目录结构(假设工程在/home/lingshangwen/project/ssh-base)

进入到工程的根目录ssh-base下

$cd ~/project/ssh-base

$mvn archetype:create-from-project

运行完该命令后,将会有如下的目录~/project/ssh-base/target/generated-sources/archetype



6.创建archetype

$cd ~/project/ssh-base/target/generated-sources/archetype

$mvn install



到现在为止,我想要的ssh的archetype创建出来了,如何通过该archetype创建项目呢,很简单,看看

$cd ~/project

$mvn archetype:generate

[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'archetype'.
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Default Project
[INFO]    task-segment: [archetype:generate] (aggregator-style)
[INFO] ------------------------------------------------------------------------
[INFO] Preparing archetype:generate
[INFO] No goals needed for project - skipping
[INFO] Setting property: classpath.resource.loader.class => 'org.codehaus.plexus.velocity.ContextClassLoaderResourceLoader'.
[INFO] Setting property: velocimacro.messages.on => 'false'.
[INFO] Setting property: resource.loader => 'classpath'.
[INFO] Setting property: resource.manager.logwhenfound => 'false'.
[INFO] [archetype:generate]
[INFO] Generating project in Interactive mode
[INFO] No archetype defined. Using maven-archetype-quickstart (org.apache.maven.archetypes:maven-archetype-quickstart:1.0)
Choose archetype:
1: local -> ssh (null)
2: local -> ssh-base-archetype (ssh-base-archetype)
3: internal -> appfuse-basic-jsf (AppFuse archetype for creating a web application with Hibernate, Spring and JSF)
4: internal -> appfuse-basic-spring (AppFuse archetype for creating a web application with Hibernate, Spring and Spring MVC)
5: internal -> appfuse-basic-struts (AppFuse archetype for creating a web application with Hibernate, Spring and Struts 2)
6: internal -> appfuse-basic-tapestry (AppFuse archetype for creating a web application with Hibernate, Spring and Tapestry 4)
7: internal -> appfuse-core (AppFuse archetype for creating a jar application with Hibernate and Spring and XFire)
8: internal -> appfuse-modular-jsf (AppFuse archetype for creating a modular application with Hibernate, Spring and JSF)
9: internal -> appfuse-modular-spring (AppFuse archetype for creating a modular application with Hibernate, Spring and Spring MVC)
10: internal -> appfuse-modular-struts (AppFuse archetype for creating a modular application with Hibernate, Spring and Struts 2)
11: internal -> appfuse-modular-tapestry (AppFuse archetype for creating a modular application with Hibernate, Spring and Tapestry 4)
12: internal -> maven-archetype-j2ee-simple (A simple J2EE Java application)
13: internal -> maven-archetype-marmalade-mojo (A Maven plugin development project using marmalade)
14: internal -> maven-archetype-mojo (A Maven Java plugin development project)
15: internal -> maven-archetype-portlet (A simple portlet application)
16: internal -> maven-archetype-profiles ()
17: internal -> maven-archetype-quickstart ()
18: internal -> maven-archetype-site-simple (A simple site generation project)
19: internal -> maven-archetype-site (A more complex site project)
20: internal -> maven-archetype-webapp (A simple Java web application)
21: internal -> jini-service-archetype (Archetype for Jini service project creation)
22: internal -> softeu-archetype-seam (JSF+Facelets+Seam Archetype)
23: internal -> softeu-archetype-seam-simple (JSF+Facelets+Seam (no persistence) Archetype)
24: internal -> softeu-archetype-jsf (JSF+Facelets Archetype)
25: internal -> jpa-maven-archetype (JPA application)
26: internal -> spring-osgi-bundle-archetype (Spring-OSGi archetype)
27: internal -> confluence-plugin-archetype (Atlassian Confluence plugin archetype)
28: internal -> jira-plugin-archetype (Atlassian JIRA plugin archetype)
29: internal -> maven-archetype-har (Hibernate Archive)
30: internal -> maven-archetype-sar (JBoss Service Archive)
31: internal -> wicket-archetype-quickstart (A simple Apache Wicket project)
32: internal -> scala-archetype-simple (A simple scala project)
33: internal -> lift-archetype-blank (A blank/empty liftweb project)
34: internal -> lift-archetype-basic (The basic (liftweb) project)
35: internal -> cocoon-22-archetype-block-plain ([http://cocoon.apache.org/2.2/maven-plugins/])
36: internal -> cocoon-22-archetype-block ([http://cocoon.apache.org/2.2/maven-plugins/])
37: internal -> cocoon-22-archetype-webapp ([http://cocoon.apache.org/2.2/maven-plugins/])
38: internal -> myfaces-archetype-helloworld (A simple archetype using MyFaces)
39: internal -> myfaces-archetype-helloworld-facelets (A simple archetype using MyFaces and facelets)
40: internal -> myfaces-archetype-trinidad (A simple archetype using Myfaces and Trinidad)
41: internal -> myfaces-archetype-jsfcomponents (A simple archetype for create custom JSF components using MyFaces)
42: internal -> gmaven-archetype-basic (Groovy basic archetype)
43: internal -> gmaven-archetype-mojo (Groovy mojo archetype)
Choose a number:  (1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34/35/36/37/38/39/40/41/42/43) 17: :



ssh-base的archetype为2,故选择2



~~有个这个archetype以后创建ssh项目就快多了





分享到:
评论

相关推荐

    Maven+SSM框架模板

    【Maven+SSM框架模板】是一个用于快速构建基于Java Web应用的开发模板,它整合了Spring、SpringMVC和Mybatis三个主流的开源框架,极大地简化了项目的配置和管理。Maven作为项目构建工具,提供了统一的依赖管理和构建...

    Spring Boot 2 Maven 模板

    总结来说,Spring Boot 2 Maven模板是一个学习和实践的起点,它让你快速上手Spring Boot 2应用的开发,同时利用Maven的强大功能进行项目管理。通过深入理解这些知识点,你将能够高效地构建和管理Spring Boot应用。

    Idea中maven项目ssm框架模板.rar

    利用Maven进行SSM框架开发的脚手架,项目通用,配置文件有详细注释,包含: 1.maven的settings文件模板(阿里云仓库) 2.maven的pom文件模板 3.spring核心配置文件模板 4.springmvc核心配置文件模板 5.Slf4j中log4j2...

    SSM框架+maven+jsp模板

    总的来说,这个"SSM框架+maven+jsp模板"是一个为快速启动SSM项目而准备的工程结构。开发者可以在此基础上添加自己的业务逻辑和页面设计,无需从零开始搭建环境。它体现了现代Java Web开发的标准实践,对于学习和实践...

    SSM框架_maven项目_通用项目模板

    **Spring框架**:Spring作为基础,它是一个全面的后端应用程序框架,提供了依赖注入(DI)和面向切面编程(AOP)等核心特性。依赖注入帮助解耦组件,使得代码更易于测试和维护。Spring还提供了大量的模块,如Spring ...

    一个SSH框架的maven archetype

    Archetype是Maven的一种模板机制,它定义了一种标准的目录结构和元数据,允许用户通过简单的命令创建一个新的项目结构。在SSH框架下,这个archetype会按照最佳实践生成项目骨架,包括必要的配置文件、目录结构以及...

    Maven搭建的SSM框架模板,通用任何类型的web项目

    这个“Maven搭建的SSM框架模板”为开发者提供了一个快速启动新项目的基础架构,使得开发者能够专注于业务逻辑的实现,而不是基础框架的搭建。以下是关于这个模板的详细知识点: 1. **Spring框架**:Spring是一个...

    maven+springboot+shiro框架框架开发源代码

    总的来说,这个"maven+springboot+shiro"的源代码示例为开发者提供了一个完整的用户管理和权限控制的模板,帮助理解如何在实际项目中整合这些工具,实现高效且安全的Web应用开发。学习并理解这个示例,开发者可以...

    maven模板javaspring

    Maven 是一个强大的项目管理工具,它在 Java 开发中扮演着核心角色,特别是在Spring框架的项目构建中。Maven通过提供标准化的构建过程、依赖管理和项目信息管理,极大地简化了开发流程。在本文中,我们将深入探讨 ...

    一个SSM框架的maven archetype

    这个maven archetype是一个用于快速搭建SSM项目的基础模板,旨在简化新项目的初始化工作,帮助开发者迅速进入编码阶段。下面将详细阐述SSM框架的核心组件以及如何利用maven archetype进行项目构建。 1. Spring框架...

    maven java 管理框架

    通过Maven CLI或IDE中的Maven插件,可以根据POM模板快速创建一个新的Maven项目。项目创建后,可以通过编辑POM文件来配置项目依赖、构建目标和其他元数据。 综上所述,Maven不仅简化了Java项目的构建和依赖管理,还...

    maven2 java项目管理 工具 测试 框架

    Maven 2 是一个广泛使用的Java项目管理工具,它极大地简化了构建、管理和部署Java应用程序的过程。Maven 使用一种标准化的方法来组织项目结构,并通过依赖管理和项目信息管理来自动化构建流程。这个工具的核心概念是...

    Maven整合SSM框架

    Spring是一个全面的后端开发框架,它提供IOC(Inversion of Control,控制反转)和AOP(Aspect Oriented Programming,面向切面编程)两大核心功能,以及事务管理、数据访问、Web支持等多个模块。在SSM框架中,...

    Maven下ssh项目框架搭建

    1. **创建Maven项目**:首先,使用Maven的archetype插件创建一个新的Maven项目,选择合适的 archetype 模板,如`maven-archetype-webapp`。 2. **添加SSH依赖**:在pom.xml文件中,添加Spring、Struts2和Hibernate...

    SSH集合好的模板框架,maven搭建

    这个模板框架采用Maven进行构建,大大简化了项目的管理和依赖管理过程。以下将详细介绍SSH框架以及如何使用Maven搭建SSH项目。 **Spring框架**: Spring是一个开源的应用框架,核心特性是对依赖注入(Dependency ...

    ssh、ssm、maven项目模板

    2. **MyBatis** 是一个SQL映射框架,它允许开发者编写自定义的SQL语句,避免了Hibernate的复杂性,同时提供了比JDBC更好的数据库操作体验。 在SSM项目模板中,SpringMVC替换Struts,处理前端请求,而MyBatis则替代...

    Maven搭建的SpringMVC框架

    搭建SpringMVC+Mybatis框架的第一步是创建一个新的Maven项目。在IDE如IntelliJ IDEA或Eclipse中,选择"New Project",然后选择"Maven"模板。在配置项目时,你需要提供groupId、artifactId和version,这些参数定义了...

    基于SpringMVC hibernate maven搭建的项目框架

    【标题】"基于SpringMVC Hibernate Maven搭建的项目框架"是一个经典的Java企业级应用开发架构,它整合了三个强大的开源框架,旨在简化开发流程、提高代码质量和可维护性。SpringMVC作为控制层,负责处理HTTP请求并...

    纯净的maven框架

    总结,这个“纯净的maven框架”是一个为初学者准备的基础Maven项目模板,包含了必要的配置和依赖,可以作为快速启动新Java项目的起点。同时,提供的博客资源也能在遇到问题时提供额外的帮助和支持。对于想要学习和...

Global site tag (gtag.js) - Google Analytics