使用Maven创建项目--详解

最新推荐文章于 2024-06-27 10:42:31 发布

chunhun1383

最新推荐文章于 2024-06-27 10:42:31 发布

阅读量529

点赞数

文章标签： java web.xml 数据库

原文链接：https://my.oschina.net/u/4117394/blog/3038199

版权

Maven概述：

Maven是什么？

Maven是一个由Apache 基金会维护的项目构建工具。

项目构建是什么？

我们将项目的代码从源代码到具体程序文件的过程称为项目构建。行为包括：编译、测试、运行、打包、部署的过程。

Eclipse项目构建

Eclipse项目构建的图示：

构建过程如下：

1.创建一个web项目

2.在项目中编写好源代码和配置文件

3.对源代码编译生成class文件

4.通过junit对代码单元测试

5.将项目通过Eclipse工具放在Tomcat运行

6.将项目导出war,放在Tomcat运行

Maven项目构建：

通过 Maven 构建工具可以一条命令完成上面所有的操作：

1. *clean，清除命令，作用清除已经编译的 class 文件和 war 文件

2. *compile，编译命令,作用是将 java 文件编译成 class 文件

3. *package，打包命令，作用将 class 文件打成 war 包

4. test，测试命令，作用执行 Junit 工具（可以忽略）

5. deploy，部署命令，将 war 包放在指定的 tomcat（可以忽略）

6. *运行 Tomcat，通过命令 tomcat7:run （要加入 Maven 工具的 Tomcat7 插件）

7. *install，安装命令，一条命令包括了,cleancompilepackagetest ，将打好的包放在本地仓库里面

使用Maven的好处：

1.使用命令，一键快速编译部署

2.对项目的构建更加精细化，适合大型项目的构建（层层打包）

3.Maven支持通过配置文件（Pom）的配置下载依赖的包（90%）

4.各大开源社区强制使用Maven导包，意味着，如果不学习Maven，有很多的开源项目不好入门。（基于这一点，导致学习java的人不得不学习Maven）

--根据介绍，我们知道，学习 Maven 就两个东西 :

1. 构建项目（命令，插件）

2. 下载依赖 jar 包（坐标，仓库）

Maven的安装：

Maven的说明：

下载路径：http://maven.apache.org/download.cgi

目录说明：

环境配置

第一步：确定 JAVA_HOME 配置

前提：如果要在 CMD 命令行运行 Maven，必须要配置 JAVA_HOME 环境变量通过 set 命令

如果没有配置 JAVA_HOME 环境会导致运行获得 Java运行环境，异常如下：

第二步：配置 MAVEN_HOME 环境变量

表示是 Maven 软件的根目录

第三步：指定 Maven 执行命令到当前目录

配置执行目录到 PATH 环境变量，让命令可以在当前目录可以执行 --变量 Path 变量

--成功增加结果变量：%MAVEN_HOME%\bin

第四步：测试配置，在 CMD 下键入 mvn-h

如果返回参数提示如下图，说明配置成功！

第五步：配置 Maven 国内源

由于默认 Maven 使用国外的源，会导致下载 jar 比较慢。配置 Maven 下 conf 文件夹的 settings.xml 文件

<!--mirror

| Specifies a repository mirror site to use instead of a given repository. The repository that |thismirrorserveshasanIDthatmatchesthemirrorOfelementofthismirror.IDsare used

| for inheritance and direct lookup purposes, and must be unique across the set of mirrors.

| <mirror>

<id>mirrorId</id>

<mirrorOf>repositoryId</mirrorOf>

<name>HumanReadableNameforthisMirror.</name>

<url>http://my.repository.com/repo/path</url>

</mirror>

-->

<id>alimaven</id>

<name>aliyunmaven</name>

<url>http://maven.aliyun.com/nexus/content/groups/public/</url>

<mirrorOf>central</mirrorOf>

</mirror>
</mirrors>

入门配置

需求：通过命令行，使用 Maven 项目创建一个 Java 项目，并且打包。

第一步：创建项目

使用 mvnarchetype:generate命令创建 java 项目

如果没有提示输入的组织 ID，项目名，包名信息一直回车。

第二步：设置坐标信息
设置坐标信息，通过以下三个信息确定坐标。标记全球 Maven 项目的唯一性。

groupId:组织 ID（可以随便写，一般情况与包名一致）

artifactId:项目名

package:包名

--提示，创建成功

第三步：编译项目
注意事项：编译必须要进入项目文件夹

使用命令 mvncompile

--编译成功，生成 target 文件夹

第四步：打包
通过命令 mvnpackage

--打包成功，在 target 文件夹下会生成 jar 包

第五步：将项目转成一个 Eclipse 项目
使用 mvneclipse:eclipse

--通过该入门示例，可以发现，使用 Maven 创建构建项目，是可以不依赖任何开发工具的。

问题：有什么办法了解更多的 mvn 的命令呢？
答：mvn 下的命令都是一个 Maven 的插件，Maven 工具内置的命令可以使用的插件都在其官方帮助文档找到说明。

https://maven.apache.org/plugins/index.html

Maven 的命令格式：mvn 命名名:goals-构建参数

POM.xml

POM （ProjectObjectModel）。其实就是一个构建文件。

这是 Maven 的项目构建文件。功能就是用于描述 Maven 项目的构建信息。所以 Maven 必须至少有一个 POM 文件

问题：为什么 Maven 的构建文件叫 POM 文件。

答：历史原因，在 Maven 之前曾经有过一个很出名的构建工具，叫 Ant. 但是 Ant 有给缺陷，配置文件只能过程构建(每个构建文件都需要重新编写大量的重复代码)，所以导致，需要编写大量重复构建信息。

Maven 作者就是非常不满 Ant 这种构建大量重复代码才可以完成构建工具的工具，所以提出了新理念，让构建文件也可以先面向对象语言一样，可以继承。从而减少构建信息的编写。
POM 就是这么牛，就是我们配置都是支持面向对象的！！！

Eclipse 使用 Maven

配置 Mave

第一步：打开 Eclipse首选项

第二步：配置外部 Maven
配置指定外部的 Maven

--选择使用配置的外部的 Maven

第三步：配置自定义的配置文件
--配置自定义的配置文件

--在该页面可以看到默认的库文件夹再个人文件的.m2 下面

通过 Maven 创建普通项目

第一步：创建一个 Maven 项目

第二步：创建一个自定义的 Maven 项目

第三步：设置项目构建信

GroupId：组编号

ArtifactId：项目标识符（项目的项目名）

注意：Maven 是通过 GroupId 和 ArtifactId 来确定项目的唯一性，我们称为坐标。任何项目要发布到 Maven 的库中，必须要有一个全球唯一的坐标。

Version：发布的版本号

Packaging：打包方式。

（1）jar：以 jar 包方式打包，普通 java 项目

（2）war：以 war 包方式打包，是 web 项目

（3）pom：不打包，表示该项目是一个聚合项目。在多子项目的项目中，用于管理公用 Maven 构建属性。

Name：【可以忽略】就是一个项目的一个名称，实际实战中，一般跟 ArtifactID 一致。

Description：【可以忽略】就是项目的描述

--创建成功

第四步：创建一个简单的 HelloWorld 类

public class HelloWorld {
public static void main(String[] args) {

System.out.println("HelloWorld");

}
}

第五步：构建项目

注意：

1. Mavenbuild：用于执行 Maven 的命令

2. MavenClean：等同执行 mvnclean

3. Mavengenerate-source：等同 mvnbuild

4. MavenIntall:等同 mvninstall 。同时执行，清除、编译、测试、打包、并将包安装到 maven 仓库

--构建成功

通过 Maven 创建 Web 项目

注意事项，创建 Maven 项目是报异常，可以强制更新项目 --右击项目-->选择 Maven-->UpdateProject

--强制更新

第一步：创建一个 Maven 项目

--创建项目后，报错信息。提示没有 web.xml

解决方案：

（1）.通过<failOnMissingWebXml>标签忽略 web.xml

（2）.创建一个 web.xml 文件

第二步：创建 web.xml

1. 创建一个在 src/main/webapp 下创建 WEB-INF 文件夹

2. 在 WEB-INF 文件下创建一个 web.xml 文件

--创建成功后，报错消失。！！！！

第三步：创建一个 index.jsp

发现，报错。原因是没有加入 JSP 依赖的 ServletAPI 以及 JSP 的类库

第四步：通过 POM.xml 加入依赖的类库

--依赖的类库的 jar 的坐标取哪里找？

答：可以在以下的公有仓库找。http://mvnrepository.com/ http://search.maven.org/

注意：以后我们开发出来的功能组件希望让别人通过 Maven 使用，也可以提交到这两个用于库

第五步：通过 Maven 运行 Tomcat启动项目

-1.安装 tomcat7 的 Maven 插件
所有的Maven工具内置插件都是有在https://maven.apache.org/plugins/index.html找到。

--安装 2.2 版本

注意事项

问题：默认 Maven 仓库在哪里？

答：C:\Users\ranger\.m2 ，在登录用户的个人文件夹里面的.m2 文件夹就是仓库

问题：如果网络比较慢，导致下载的 jar 不完整，如何解决？

答：删除仓库对应的包，重新下载

通过 Maven 创建多个工程组成的项目

需求：使用 Maven 项目创建一个 SpringMVC 整合 Mybatis 的项目。项目的每一层为一个工程（模块）。从而实现项目的层层打包

第一步：创建 Maven 项目

注意： 1. 表示层是 WEB 项目，其他的都是功能组件，所以使用普通的 Jar 项目

2. Parent 项目是一个聚合项目，主要用于维护统一的包依赖，统一的插件，统一构建项目（测试、编译、打包）

第二步：聚合所有的项目

--聚合所有需要构建的工程，可以实现统一构建项目。所谓的统一构建项目，就是统一的执行清除、测试、编译、打包等操作

--在聚合项目 ssm-parent 通过 <modules>实现聚合所有的需要统一构建的项目

第三步：项目的继承

注意：所谓的项目继承，就是一个项目已经在 pom.xml 声明的各种元素，继承的子工程的 pom.xml 也获得该父工程的 pom.xml 所有声明的元素

前提：以前如果每个工程需要使用 Log4J 和 Junit，都要在各自的项目的 pom.xml 加入依赖。这样做他麻烦了。

在 ssm-parent 声明一次依赖 Log4J 和 Junit，其他所有的子工程都可以使用。

（1）在父包加入了依赖

（2）在子项目继承父工程。也获得了父工程声明的元素

第四步：依赖包的版本统一管理

可以通过属性的设置与版本锁定，使用依赖包的统一管理。

（1）父项目，设置属性与版本锁定

<project xmlns="http://maven.apache.org/POM/4.0.0"
28
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>cn.gzsxt.parent</groupId> <artifactId>ssm-parent</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>pom</packaging> <description>这是一个聚合项目，本身至于维护其它子项目的包关系插件等</description>
  <properties>  <log4j.version>1.2.17</log4j.version> <junit.version>4.12</junit.version> <springmvc.version>4.3.16.RELEASE</springmvc.version> </properties>

<dependencies> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>${log4j.version}</version>  <scope>compile</scope> </dependency>
<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>${junit.version}</version>  <scope>test</scope> </dependency>
</dependencies>
  <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${springmvc.version}</version> </dependency> </dependencies> </dependencyManagement>

<modules> <module>../ssm-web</module> <module>../ssm-service</module> <module>../ssm-mapper</module> <module>../ssm-pojo</module> <module>../ssm-utils</module>
</modules> </project>

（2）子项目，不需要再指定版本锁定的类库的版本

第五步：在 ssm-web 工程配置 SpringMVC 框架

导入包依赖

<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>cn.gzsxt.parent</groupId> <artifactId>ssm-parent</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>pom</packaging> <description>这是一个聚合项目，本身至于维护其它子项目的包关系插件等</description>
  <properties>  <log4j.version>1.2.17</log4j.version> <junit.version>4.12</junit.version> <springmvc.version>4.3.16.RELEASE</springmvc.version> <servlet-api.version>3.0.1</servlet-api.version> <jsp.version>2.2.1</jsp.version>
</properties>

<dependencies> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>${log4j.version}</version>  <scope>compile</scope> </dependency>
<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>${junit.version}</version>  <scope>test</scope> </dependency>
</dependencies>
  <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${springmvc.version}</version> </dependency>
<dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>${servlet-api.version}</version> <scope>provided</scope> </dependency>
<dependency> <groupId>javax.servlet.jsp</groupId> <artifactId>javax.servlet.jsp-api</artifactId> <version>${jsp.version}</version> <scope>provided</scope> </dependency>
</dependencies>
</dependencyManagement>
 <build>  <plugins>  <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.5</version>  <configuration>  <source>1.8</source>  <target>1.8</target> </configuration> </plugin> </plugins> </build>

<modules> <module>../ssm-web</module> <module>../ssm-service</module> <module>../ssm-mapper</module> <module>../ssm-pojo</module> <module>../ssm-utils</module>
</modules> </project>

--在 ssm-web 的 pom.xml 导入依赖包

创建一个请求页面

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

</body>

</html>

编写 web.xml

<?xml version="1.0" encoding="UTF-8"?> <web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_0.xsd ">
 <servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  <init-param> <param-name>contextConfigLocation</param-name> <param-value>cn.gzsxt.config.SpringMvcConfig</param-value> </init-param>  <init-param> <param-name>contextClass</param-name>
<param-value>org.springframework.web.context.support.AnnotationConfigWebApplication Context</param-value> </init-param> </servlet> <servlet-mapping> <servlet-name>dispatcherServlet</servlet-name> <url-pattern>*.mvc</url-pattern> </servlet-mapping> </web-app>

编写配置类

package cn.gzsxt.config;
import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.EnableWebMvc;
@Configuration @ComponentScan(basePackages="cn.gzsxt") @EnableWebMvc public class SpringMvcConfig {
}

编写 Controller 组件类

package cn.gzsxt.controller;
36
import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping;
@Controller @Scope(value="request") @RequestMapping(value="/student") public class StudentController {
@RequestMapping(value="/add") public void add(){ System.out.println("-增加学生-"); }
}

第六步：在 ssm-mapper 工程配置 Mybatis 框架

导入包依赖

--ssm-mapper 项目导入依赖

创建操作映射注解

--创建一个操作接口，编写一个插入数据的 SQL 语句

package cn.gzsxt.mapper;
import org.apache.ibatis.annotations.Insert; import org.apache.ibatis.annotations.Options;
import cn.gzsxt.pojo.Student;
public interface StudentMapper {
@Insert(value="INSERT INTO tb_student (stu_name, stu_age, stu_password) VALUES (#{stuName}, #{stuAge}, #{stuPassword})") //操作后，实体对象需要ID，使用ID回填 @Options(useGeneratedKeys=true,keyProperty="stuId",keyColumn="stu_id") int insert(Student student);
}

编写 mybatis-config.xml 配置文件

在 test/resources 创建 mybatis-config.xml 配置文件

--配置文件代码

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "mybatis-3-config.dtd" > <configuration>
<environments default="mysql"> <environment id="mysql"> <transactionManager type="JDBC"></transactionManager> <dataSource type="POOLED"> <property name="driver" value="org.gjt.mm.mysql.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/sms"/> <property name="username" value="root"/> <property name="password" value="123456"/> </dataSource> </environment> </environments>  <mappers> <mapper class="cn.gzsxt.mapper.StudentMapper"/> </mappers> </configuration>

测试代码

package cn.gzsxt.test; import java.io.IOException; import java.io.Reader;
import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import org.junit.Test;
import cn.gzsxt.mapper.StudentMapper; import cn.gzsxt.pojo.Student;
public class StudentMapperTest {
@Test public void insert(){
try { //1.获得配置文件 Reader reader = Resources.getResourceAsReader("mybaits-config.xml"); //2.通过SqlSessionFactoryBuilder获得SqlSessionFactory对象 SqlSessionFactoryBuilder build=new SqlSessionFactoryBuilder(); //获得会话工厂 SqlSessionFactory sessionFactory = build.build(reader); //获得会话 SqlSession session = sessionFactory.openSession(); //获得操作接口的动态对象 StudentMapper mapper = session.getMapper(StudentMapper.class); Student student=new Student(); student.setStuName("王五"); int count = mapper.insert(student); System.out.println(count); //提交 session.commit(); session.close(); System.out.println(student.getStuId()); } catch (IOException e) {
// TODO Auto-generated catch block e.printStackTrace();
}
}
}

第七步：整合 SpringMVC 与 Mybatis

根据业务类型创建三个配置类

SpringMvcConfig：存放表示层（SpringMVC）的配置

SpringDataConfig：存放持久层的配置

SpringContextConfig：存放于 Spring 容器有关的配置
注意事项：在没有使用到 SpringMVC 时，先注释掉@EnableWebMvc注解，因为会影响非 WEB 的单元测试

配置支持支持${key}获得 Properties 文件值

package cn.gzsxt.config;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.PropertySource; import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
@Configuration @ComponentScan(basePackages="cn.gzsxt")
@PropertySource("classpath:sys.properties") public class SpringContextConfig {
//在Configuration的对象没有创建之前就要有PropertySourcesPlaceholderConfigurer //所以必须给方法加上静态 @Bean public static PropertySourcesPlaceholderConfigurer configurer(){ return new PropertySourcesPlaceholderConfigurer(); }
}

整合 Mybatis

package cn.gzsxt.config;
import javax.sql.DataSource;
import org.apache.commons.dbcp2.BasicDataSource; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.log4j.LogManager; import org.apache.log4j.Logger; import org.mybatis.spring.SqlSessionFactoryBean; import org.mybatis.spring.mapper.MapperScannerConfigurer; import org.springframework.beans.factory.annotation.Value; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Scope; import org.springframework.jdbc.datasource.DataSourceTransactionManager; import org.springframework.stereotype.Repository; import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration @EnableTransactionManagement public class SpringDataConfig {
private static final Logger LOGGER = LogManager.getLogger(SpringDataConfig.class.getName());
@Value(value = "${db.driver}") private String driverName; @Value(value = "${db.url}")
private String url; @Value(value = "${db.username}") private String username; @Value(value = "${db.password}") private String password; @Value(value = "${db.maxIdle}") private int maxIdle; @Value(value = "${db.maxTotal}") private int maxTotal; @Value(value = "${db.maxWaitMillis}") private int maxWaitMillis; @Value(value = "${db.minIdle}") private int minIdle;
// 1.获得数据源 @Bean(name = "dataSource") // 2.创建的对象是单例 @Scope(value = BeanDefinition.SCOPE_SINGLETON) public DataSource dataSource() { LOGGER.debug("driverName:" + driverName + ",url：" + url); BasicDataSource dataSource = new BasicDataSource(); dataSource.setDriverClassName(driverName); dataSource.setUrl(url); dataSource.setUsername(username); dataSource.setPassword(password); dataSource.setMaxIdle(maxIdle); dataSource.setMaxTotal(maxTotal); dataSource.setMaxWaitMillis(maxWaitMillis); dataSource.setMinIdle(minIdle); return dataSource; }
// 2.获得SqlSessionFactory对象 @Bean(name = "sessionFactory") public SqlSessionFactory sessionFactory() { SqlSessionFactory sessionFactory = null; try { SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(this.dataSource()); bean.setTypeAliasesPackage("cn.gzsxt.pojo"); // 使用属性 bean.afterPropertiesSet();
sessionFactory = bean.getObject();
} catch (Exception e) {
e.printStackTrace();
} return sessionFactory;
}
//通过Mybatis的配置器，将对象加入到Spring容器里面 @Bean public static MapperScannerConfigurer mapperScannerConfigurer(){ MapperScannerConfigurer configurer=new MapperScannerConfigurer(); //1.设置使用的会话工厂 configurer.setSqlSessionFactoryBeanName("sessionFactory"); //2.配置扫描的映射接口 configurer.setBasePackage("cn.gzsxt.mapper"); //3.指定组件类型 configurer.setAnnotationClass(Repository.class); return configurer; }
//创建事务代理对象 @Bean public DataSourceTransactionManager transactionManager(){ DataSourceTransactionManager tm=new DataSourceTransactionManager(); tm.setDataSource(this.dataSource()); return tm; }
}

个人习惯，谢谢支持！

转载于:https://my.oschina.net/u/4117394/blog/3038199

chunhun1383

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
使用Maven创建项目--详解

Maven概述： Maven是什么？ Maven是一个由Apache 基金会维护的项目构建工具。项目构建是什么？我们将项目的代码从源代码到具体程序文件的过程称为项目构建。行为包括：编译、测试、运行、打包、部署的过程。 Eclipse项目构建 Eclipse项目构建的图示： ...
复制链接

扫一扫