一步步教你使用maven搭建ssh框架

一，下载安装maven

http://maven.apache.org/download.cgi

解压后。将maven所在目录配置到MAVEN_HOME中，并将%MAVEN_HOME%\bin目录加入path

然后在输入mvn --version查看maven是否安装成功。

 

二，安装maven-eclipse插件

使用用link的方式安装，先下载插件http://download.csdn.net/download/qq185501667/7076183

然后将他解压，然后在eclipse安装目录下，新建一个文件夹命名为:links(名字无所谓)，然后在里面新建一个maven.link的文件，写入：path=E:/eclipsePlugins/maven(你的插件所在目录)，重启eclipse，如果看到welcome页面就说明安装成功了。

三，新建maven project

先新建父模块

选择maven project

下一步，然后再直接下一步，不要勾选create simple project，然后进入选archetype页面，也直接选默认的maven-archetype-quickstart。最后要填GroupId（填工作组id，例如org.zyx） ArtifactId (可以填项目名称，例如myapp)。包名就不说了。

然后完成。然后修改pom.xml文件，因为我们的目标是创建模块化的WEB应用，我们当前新建的是父模块，它并不需要真正的构建，只是负责组织子模块，所以要将packaging修改

[html]  view plain copy

1. <span style="font-size:14px;"><packaging>pom</packaging></span>    

四，新建entity

在父项目上右键新建，选择maven module，其余同上。

由于本项目使用的是注解的方式配置hibernate 实体，所以要添加注解包的相关依赖

修改pom.xml，加入

[html]  view plain copy

1. <span style="font-size:14px;">  <dependencies>    
2.         <dependency>    
3.             <groupId>org.hibernate.javax.persistence</groupId>    
4.             <artifactId>hibernate-jpa-2.0-api</artifactId>    
5.             <version>1.0.0.Final</version>    
6.         </dependency>    
7.     </dependencies></span>    

这样 maven就会帮我们导入相关jar包了，而且如果我们进入里面的class，maven还会自动帮我们下载源码。

下面新建实体类：

 在src/main/java目录下新建类

[java]  view plain copy

1. <span style="font-size:14px;">package com.zyx.model.entity;  
2.   
3. import java.util.List;  
4.   
5. import javax.persistence.CascadeType;  
6. import javax.persistence.Column;  
7. import javax.persistence.Entity;  
8. import javax.persistence.GeneratedValue;  
9. import javax.persistence.Id;  
10. import javax.persistence.OneToMany;  
11. import javax.persistence.Table;  
12.   
13. @Entity  
14. @Table(name = "T_USER")  
15. public class User {  
16.     private int id;  
17.     private String name;  
18.     private String password;  
19.       
20.     @Id  
21.     @GeneratedValue  
22.     public int getId() {  
23.         return id;  
24.     }  
25.   
26.     public void setId(int id) {  
27.         this.id = id;  
28.     }  
29.   
30.     @Column(unique = true)  
31.     public String getName() {  
32.         return name;  
33.     }  
34.   
35.     public void setName(String name) {  
36.         this.name = name;  
37.     }  
38.   
39.     public String getPassword() {  
40.         return password;  
41.     }  
42.   
43.     public void setPassword(String password) {  
44.         this.password = password;  
45.     }  
46. }  
47. </span>  

entity模块就完成了。

四，新建dao层

 创建 module 过程同上。

然后修改pom.xml，加入 必要的dependency，dao层需要hibernate和spring的相关jar包

添加以下依赖

[html]  view plain copy

1. <span style="font-size:14px;">        <!-- 引用实体模块 -->  
2.         <dependency>  
3.             <groupId>com.zyx</groupId>  
4.             <artifactId>entity</artifactId>  
5.             <version>${project.version}</version>  
6.         </dependency>  
7.           
8.         <!-- junit4 -->  
9.         <dependency>  
10.             <groupId>junit</groupId>  
11.             <artifactId>junit</artifactId>  
12.             <version>4.4</version>  
13.             <scope>test</scope>  
14.         </dependency>  
15.   
16.         <!-- c3p0数据源 -->  
17.         <dependency>  
18.             <groupId>c3p0</groupId>  
19.             <artifactId>c3p0</artifactId>  
20.             <version>0.9.1.2</version>  
21.         </dependency>  
22.   
23.         <!-- 依赖log4j slf4j -->  
24.         <dependency>  
25.             <groupId>log4j</groupId>  
26.             <artifactId>log4j</artifactId>  
27.             <version>1.2.14</version>  
28.         </dependency>  
29.         <dependency>  
30.             <groupId>org.slf4j</groupId>  
31.             <artifactId>slf4j-log4j12</artifactId>  
32.             <version>1.7.2</version>  
33.         </dependency>  
34.   
35.         <dependency>  
36.             <groupId>cglib</groupId>  
37.             <artifactId>cglib</artifactId>  
38.             <version>2.2.2</version>  
39.         </dependency>  
40.   
41.         <dependency>  
42.             <groupId>javassist</groupId>  
43.             <artifactId>javassist</artifactId>  
44.             <version>3.8.0.GA</version>  
45.             <type>jar</type>  
46.             <scope>compile</scope>  
47.         </dependency>   
48.   
49.         <!-- Hiberante -->   
50.         <dependency>  
51.             <groupId>org.hibernate</groupId>  
52.             <artifactId>hibernate-core</artifactId>  
53.             <version>3.3.2.GA</version>  
54.         </dependency>  
55.         <dependency>  
56.             <groupId>org.hibernate</groupId>  
57.             <artifactId>hibernate-annotations</artifactId>  
58.             <version>3.3.1.GA</version>  
59.         </dependency>  
60. </span>  

新建dao接口：

[java]  view plain copy

1. <span style="font-size:14px;">package com.zyx.model.dao;  
2.   
3. public interface GenericDao {  
4.     public <T> void save(T t);  
5.     public <T> void delete(T t);  
6.     public <T> void update(T t);  
7.     public <T> T findById(Class<T> clazz, int id);  
8. }  
9. </span>  

新建实现类：

[java]  view plain copy

1. <span style="font-size:14px;">package com.zyx.model.dao.impl;  
2.   
3. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
4. import org.springframework.stereotype.Service;  
5. import org.springframework.transaction.annotation.Transactional;  
6.   
7. import com.zyx.model.dao.GenericDao;  
8.   
9. @Service  
10. @Transactional  
11. public class GenericDaoImpl extends HibernateDaoSupport implements GenericDao {  
12.   
13.     public <T> void save(T t) {  
14.         getHibernateTemplate().save(t);  
15.     }  
16.   
17.     public <T> void delete(T t) {  
18.         getHibernateTemplate().delete(t);  
19.     }  
20.   
21.     public <T> void update(T t) {  
22.         getHibernateTemplate().update(t);  
23.     }  
24.   
25.     @SuppressWarnings("unchecked")  
26.     public <T> T findById(Class<T> clazz, int id) {  
27.         return (T) getHibernateTemplate().get(clazz, id);  
28.     }  
29.   
30. }  
31. </span>  

在src/main/resources里添加hibernate和spring的配置文件

1，applicationContext.xml

[html]  view plain copy

1. <span style="font-size:14px;"><?xml version="1.0" encoding="UTF-8"?>  
2. <!-- 
3.       - Middle tier application context definition for the image database. 
4.       -->  
5. <beans xmlns="http://www.springframework.org/schema/beans"  
6.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
7.     xmlns:context="http://www.springframework.org/schema/context"  
8.     xmlns:tx="http://www.springframework.org/schema/tx"  
9.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
10.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
11.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"  
12.     default-autowire="byName" default-lazy-init="false">  
13.     <!-- 不加default-autowire="byName" 会得不到hibernateTemplate -->  
14.       
15.     <!-- 配置spring扫描注解的范围 -->  
16.     <context:component-scan base-package="com.zyx.**"  />  
17.   
18.     <!-- 定义占位符所在的文件 -->  
19.     <context:property-placeholder location="classpath:jdbc.properties"/>  
20.       
21.     <!-- 配置数据源，使用了占位符 -->  
22.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  
23.         <property name="driverClass" value="${jdbc.driverClassName}"/>  
24.         <property name="jdbcUrl" value="${jdbc.url}"/>  
25.         <property name="user" value="${jdbc.username}"/>  
26.         <property name="password" value="${jdbc.password}"/>  
27.     </bean>  
28.   
29.   
30.     <!-- 配置sessionFactory，使用了占位符 -->  
31.     <bean id="sessionFactory"  
32.         class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
33.         <property name="dataSource">  
34.             <ref bean="dataSource" />           
35.         </property>  
36.         <!-- 全包扫描必须设置成实体类的上两层以上包！！！ -->  
37.         <property name="packagesToScan" value="com.zyx.model.*" />  
38.           
39.         <property name="hibernateProperties">  
40.             <props>  
41.                 <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl}</prop>  
42.                 <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>  
43.                 <prop key="hibernate.dialect">${hibernate.dialect}</prop>  
44.                 <prop key="hibernate.query.factory_class">org.hibernate.hql.ast.ASTQueryTranslatorFactory</prop>  
45.                 <prop key="connection.useUnicode">true</prop>  
46.                 <prop key="connection.characterEncoding">UTF-8</prop>  
47.             </props>  
48.         </property>  
49.     </bean>  
50.       
51.     <!-- 配置事务管理器 -->  
52.     <bean id="transactionManager"  
53.         class="org.springframework.orm.hibernate3.HibernateTransactionManager"  lazy-init="false" destroy-method="close">  
54.         <property name="sessionFactory" ref="sessionFactory" />  
55.         <property name="globalRollbackOnParticipationFailure" value="false" />          
56.     </bean>  
57.       
58.     <!-- Activates @Transactional for DefaultImageDatabase -->  
59.     <!-- <tx:annotation-driven transaction-manager="transactionManager"/>-->  
60. </beans>  
61. </span>  

2, jdbc.properties

[html]  view plain copy

1. <span style="font-size:14px;">jdbc.driverClassName=oracle.jdbc.driver.OracleDriver  
2. jdbc.url=jdbc:oracle:thin:@localhost:1521:ORCL  
3. jdbc.username=scott  
4. jdbc.password=tiger  
5. hibernate.hbm2ddl=update  
6. hibernate.show_sql=true  
7. hibernate.dialect=org.hibernate.dialect.OracleDialect</span>  

dao层基本完成了，现在来测试一下。

在 src/test/java里新建测试类

[java]  view plain copy

1. <span style="font-size:14px;">package com.zyx.model.dao.impl;  
2.   
3. import org.junit.Before;  
4. import org.junit.Test;  
5. import org.springframework.context.ApplicationContext;  
6. import org.springframework.context.support.FileSystemXmlApplicationContext;  
7.   
8. import com.zyx.model.dao.impl.GenericDao;  
9. import com.zyx.model.entity.User;  
10.   
11. public class UserDaoTest {  
12.     ApplicationContext ctx = null;  
13.     GenericDao dao = null;  
14.   
15.     @Before  
16.     public void beforeClass() {  
17.         ctx = new FileSystemXmlApplicationContext(  
18.                 "classpath*:applicationContext.xml");  
19.         dao = (UserDao) ctx.getBean("genericDaoImpl");  
20.     }  
21.       
22.     @Test  
23.     public void testSave() {  
24.         User user = new User();  
25.         user.setName("张文辉");  
26.         user.setPassword("23");  
27.         dao.save(user);  
28.     }     
29. }  
30. </span>  

我只写了一个测试方法，愿意的话可以写多个，然后在dao项目上右键run as maven test

测试通过就完成了。

 

四：service层

service层比较简单，只需要依赖dao层完成相关的业务逻辑就行了。

我贴出service层的pom.xml

[html]  view plain copy

1. <span style="font-size:14px;"><?xml version="1.0"?>  
2. <project  
3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"  
4.     xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">  
5.     <modelVersion>4.0.0</modelVersion>  
6.     <parent>  
7.         <artifactId>mr</artifactId>  
8.         <groupId>com.zyx</groupId>  
9.         <version>0.0.1-SNAPSHOT</version>  
10.     </parent>  
11.     <groupId>com.zyx</groupId>  
12.     <artifactId>service</artifactId>  
13.     <version>0.0.1-SNAPSHOT</version>  
14.     <name>service</name>  
15.     <url>http://maven.apache.org</url>   
16.     <properties>  
17.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
18.     </properties>  
19.     <dependencies>  
20.         <!-- 引用dao层，因为dao层已经引用了entity 所以不需要再引用 -->  
21.         <dependency>  
22.             <groupId>com.zyx</groupId>  
23.             <artifactId>dao</artifactId>  
24.             <version>${project.version}</version>  
25.         </dependency>       
26.         <dependency>  
27.             <groupId>junit</groupId>  
28.             <artifactId>junit</artifactId>  
29.             <version>4.4</version>  
30.             <scope>test</scope>  
31.         </dependency>  
32.     </dependencies>  
33. </project>  
34. </span>  

在这里需要提的是，依赖是有传递性的，dao层引用到的东西，一般service层都能引用到，除非你将scope配小，例如junit，我们将它的scope配置成了<scope>test</scope>这样引用该模块的模块是无法直接使用junit的。

 

六：web层

新建module的过程稍有不同，选择archetype的时候要选择maven-archetype-webapp，你可以在filter中输入maven-archetype-webapp，就直接过滤出maven-archetype-webapp了。

这样该模块的packagin属性就被设置成了war。构建出来就是一个war包，之前的都是jar。

web项目在src/main下会有一个webapp目标，相当于在eclipse下的webContent(MyEclipse是 web)

然后在pom.xml添加struts2依赖

[html]  view plain copy

1. <span style="font-size:14px;"><!-- 引用service层 -->  
2.         <dependency>  
3.             <groupId>com.zyx</groupId>  
4.             <artifactId>service</artifactId>  
5.             <version>${project.version}</version>  
6.         </dependency>  
7.   
8.         <dependency>  
9.             <groupId>junit</groupId>  
10.             <artifactId>junit</artifactId>  
11.             <version>4.4</version>  
12.             <scope>test</scope>  
13.         </dependency>  
14.   
15.         <dependency>  
16.             <groupId>org.apache.struts</groupId>  
17.             <artifactId>struts2-core</artifactId>  
18.             <version>2.2.1</version>  
19.         </dependency>  
20.   
21.         <dependency>  
22.             <groupId>org.apache.struts</groupId>  
23.             <artifactId>struts2-spring-plugin</artifactId>  
24.             <version>2.3.16.1</version>  
25.         </dependency></span>  

在src/main/resource下增加struts2的配置文件struts.xml

[html]  view plain copy

1. <span style="font-size:14px;"><?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE struts PUBLIC  
3.     "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"  
4.     "http://struts.apache.org/dtds/struts-2.3.dtd">  
5.   
6. <struts>  
7.   
8.     <constant name="struts.enable.DynamicMethodInvocation" value="false" />  
9.     <constant name="struts.devMode" value="true" />  
10.     <constant name="struts.objectFactory" value="spring" />  
11.   
12.     <package name="default" namespace="/" extends="struts-default">  
13.   
14.         <default-action-ref name="index" />  
15.   
16.         <global-results>  
17.             <result name="error">/error.jsp</result>  
18.         </global-results>  
19.   
20.         <global-exception-mappings>  
21.             <exception-mapping exception="java.lang.Exception"  
22.                 result="error" />  
23.         </global-exception-mappings>  
24.         <action name="regUser">  
25.             <result>/WEB-INF/page/registerUser.jsp</result>  
26.         </action>  
27.   
28.         <action name="*User" class="userAction" method="{1}">  
29.             <result>/WEB-INF/page/{1}User.jsp</result>  
30.         </action>  
31.     </package>  
32.   
33.     <include file="example.xml" />  
34.   
35.     <!-- Add packages here -->  
36.   
37. </struts>  
38. </span>  

配置src/main/webapp/WEB-INF/web.xml

[html]  view plain copy

1. <span style="font-size:14px;"><?xml version="1.0" encoding="UTF-8"?>  
2. <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">  
3.     <display-name>meeting</display-name>  
4.     <welcome-file-list>  
5.         <welcome-file>index.html</welcome-file>  
6.         <welcome-file>index.htm</welcome-file>  
7.         <welcome-file>index.jsp</welcome-file>  
8.         <welcome-file>default.html</welcome-file>  
9.         <welcome-file>default.htm</welcome-file>  
10.         <welcome-file>default.jsp</welcome-file>  
11.     </welcome-file-list>  
12.     
13.     <filter>  
14.         <filter-name>struts2</filter-name>  
15.         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>  
16.     </filter>  
17.   
18.     <filter-mapping>  
19.         <filter-name>struts2</filter-name>  
20.         <url-pattern>/*</url-pattern>  
21.     </filter-mapping>  
22.   
23.     
24.     <listener>  
25.         <listener-class>    
26.             org.springframework.web.context.ContextLoaderListener    
27.         </listener-class>   
28.     </listener>  
29.   
30.     <context-param>  
31.         <param-name>contextConfigLocation</param-name>  
32.         <param-value>classpath*:applicationContext.xml</param-value>  
33.     </context-param>  
34.   
35.     
36. </web-app></span>  

[html]  view plain copy

1. <span style="font-size:14px;"></span>    

然后在src/main/java目录（如果没有就自己建）里面写入相应的Action

写完之后，就可以发到服务器上了。

可以使用MAVEN的命令行，来部署。

在CMD下，进入最后一个模块也就是web的目录，输入:mvn install

安装完成后输入： mvn tomcat:run

就部署完成了，然后就可以进网页访问了。

使用MAVEN搭建的SSH框架就完成了！