JDBC(Java DataBase Connectivity) Java数据库连接
其实就是 利用Java语言/程序连接并访问数据库的一门技术
之前我们可以通过CMD或者navicat等工具连接数据库
但在企业开发中，更多的是通过程序（Java程序）连接并访问数据库，通过Java程序访问数据库，就需要用到JDBC这门技术
2.1、导入jar包–mysql驱动包
2.2创建类并实现JDBC程序（六个步骤）
//1.注册数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取数据库连接
Connection conn = DriverManager.getConnection( "jdbc:mysql://localhost:3306/jt_db?characterEncoding=utf-8", "root", "root");
//3.获取传输器
Statement stat = conn.createStatement();
//4.发送SQL到服务器执行并返回执行结果
String sql = "select * from account";
ResultSet rs = stat.executeQuery( sql );
//5.处理结果
while( rs.next() ) {
int id = rs.getInt("id");
String name = rs.getString("name");
double money = rs.getDouble("money"); System.out.println(id+" : "+name+" : "+money);
}
//6.释放资源
rs.close();
stat.close();
conn.close();
1、注册数据库驱动
Class.forName(“com.mysql.jdbc.Driver”);
所谓的注册驱动，就是让JDBC程序加载mysql驱动程序，并管理驱动
驱动程序实现了JDBC API定义的接口以及和数据库服务器交互的功能，加载驱动是为了方便使用这些功能。
2、获取连接之数据库URL
Connection conn = DriverManager.getConnection( "jdbc:mysql://localhost:3306/jt_db?characterEncoding=utf-8", "root", "root" );
DriverManager.getConnection() 用于获取数据连接，返回的Connection连接对象是JDBC程序连接数据库至关重要的一个对象。
参数2和参数3分别是所连接数据库的用户名和密码。
参数1：“jdbc:mysql://localhost:3306/jt_db” 是连接数据库的URL，用于指定访问哪一个位置上的数据库服务器及服务器中的哪一个数据库，其写法为:
当连接本地数据库，并且端口为3306，可以简写为如下形式：jdbc:mysql:///jt_db
3、Statement传输器对象
Statement stat = conn.createStatement();
该方法返回用于向数据库服务器发送sql语句的Statement传输器对象
该对象上提供了发送sql的方法：
executeQuery(String sql) --用于向数据库发送查询类型的sql语句，返回一个ResultSet对象中
executeUpdate(String sql) --用于向数据库发送更新(增加、删除、修改)类型的sql语句，返回一个int值，表示影响 的记录行数
4、ResultSet结果集对象
ResultSet对象用于封装sql语句查询的结果，也是一个非常重要的对象。该对象上提供了遍历数据及获取数据的方法。
(1)遍历数据行的方法
next() – 使指向数据行的箭头向下移动一行，并返回一个布尔类型的结果，true表示箭头指向了一行数据，false表示箭头没有指向任何数据（后面也没有数据了）
(2)获取数据的方法
getInt(int columnIndex) 从1开始，1表示第一列
getInt(String columnLable)
getString(int columnIndex)
getString(String columnLable)
getDouble(int columnIndex)
getDouble(String columnLable)
getObject(int columnIndex)
getObject(String columnLable) …
5、释放资源
rs.close();
stat.close();
conn.close();
此处释放资源必须按照一定的顺序释放，越晚获取的越先关闭。所以先关闭rs对象，再关闭stat对象，最后关闭conn对象。
另，为了避免上面的程序抛出异常，释放资源的代码不会执行，应该把释放资源的代码放在finally块中.
try{... }catch(Exception e){
...
}finally{ if (rs != null) {
try { rs.close();
} catch (SQLException e) {
e.printStackTrace();
} finally { rs = null; }
}
if (stat != null) {
try { stat.close();
} catch (SQLException e) {
e.printStackTrace();
} finally { stat = null;
}
}
if (conn != null) {
try { conn.close();
} catch (SQLException e) {
e.printStackTrace();
} finally { conn = null;
} } }
//也可以通过JdbcUtil工具类中的close方法释放资源 JdbcUtil.close(conn, stat, rs);
单元测试补充
单元测试：不用创建新的类，也不用提供main函数，也不用创建类的实例，就可以直接执行一个方法
加了@Test注解的方法，可以通过单元测试（junit）框架测试该方法。底层会创建该方法所在类的实例，通过实例调用该方法。
@Test public void testInsert() { System.out.println(“TestPreparedStatement.testInsert()”); }
能够使用@Test单元测试测试的方法必须满足如下几个条件:
(1)方法必须是公共的
(2)方法必须是非静态的
(3)方法必须是无返回值的
(4)方法必须是无参数的
(5)进行单元测试的方法或类，命名时不要命名为 Test/test
在上面的增删改查的操作中，使用的是Statement传输器对象，而在开发中我们用的更多的传输器对象是PreparedStatement对象，PreparedStatement是Statement的子接口，比Statement更加安全，并且能够提高程序执行的效率。
Statement 父对象
PreparedStatement 子对象
4.1SQL注入攻击
SQL注入攻击产生的原因: 由于后台执行的SQL语句是拼接而来的：
select * from user where username=’"+user+"’ and password=’"+pwd+"’
其中的参数是用户提交过来的，如果用户在提交参数时，在参数中掺杂了一些
SQL关键字（比如or）或者特殊符号（#、-- 、’ 等），就可能会导致SQL语句语义的变化，从而执行一些意外的操作（用户名或密码不正确也能登录成功）！
4.2防止SQL注入攻击
如何防止SQL注入攻击？
(1)使用正则表达式对用户提交的参数进行校验。如果参数中有（# – ’ or等）这些符号就直接结束程序，通知用户输入的参数不合法
(2)使用PreparedStatement对象来替代Statement对象。
下面通过第二种方式解决SQL注入攻击：添加loginByPreparedSatement方法，在方法中，使用PreparedStatement来代替Statement作为传输器对象使用，代码示例：
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
//1.注册驱动并获取连接
conn = JdbcUtil.getConn();
//2.获取传输器，执行sql并返回执行结果
String sql = "select * from user where username=? and password=?";
ps = conn.prepareStatement( sql );
//设置SQL语句中的参数
ps.setString( 1 , user );
ps.setString( 2 , pwd );
//执行SQL语句
rs = ps.executeQuery();//这里不要再传输SQL语句 //3.处理结果
if( rs.next() ) { //有数据 -- 用户名密码都正确
System.out.println("恭喜您登录成功!");
}else { //没数据 -- 用户名或密码不正确
System.out.println("登录失败, 用户名或密码不正确!");
} } catch (Exception e) { e.printStackTrace(); } finally {
//4.释放资源
JdbcUtil.close(conn, ps, rs); }
PreparedStatement对象是如何防止SQL注入攻击的：
使用PreparedStatement对象是先将SQL语句的骨架发送给服务器编译并确定下来，编译之后，SQL语句的骨架和语义就不会再被改变了，再将SQL语句中的参数发送给服务器，即使参数中再包含SQL关键字或者特殊符号，也不会导致SQL语句的骨架或语义被改变，只会被当作普通的文本来处理！
使用PreparedStatement对象可以防止SQL注入攻击
而且通过方法设置参数更加的方便且不易出错!
还可以从某些方面提高程序执行的效率!
1.什么是连接池
常量池/线程池/连接池
池：指内存中的一片空间（容器，比如数组、集合）
连接池：就是将连接存放在容器中，供整个程序共享，可以实现连接的复用，减少连接创建和关闭的次数，从而提高程序执行的效率！
2. 为什么要使用连接池
传统方式操作数据库
Connection conn = DriverManager.getConnection( url, user, pwd ); // 创建连接对象 …
conn.close(); //关闭连接, 销毁连接
在传统方式中，每次用户需要连接访问数据库时，都是 创建一个连接 对象，基于这个连接对象访问数据库，用完连接后，会将 连接关闭 （conn.close()）。
由于每次创建连接和关闭连接非常的耗时间而且耗资源，因此会导致程序执行的效率低下
使用连接池操作数据库
可以在程序一启动时，就创建一批连接放在一个连接池中（容器），当用户需要连接时，就从连接池中获取一个连接对象，用完连接后，不要关闭，而是将连接再还
回连接池中，这样一来，用来用去都是池中的这一批连接，实现了连接的复用，减少了连接创建和关闭的次数，从而提高了程序执行的效率！
ComboPooledDataSource pool = new ComboPooledDataSource();
3、设置连接数据库的基本信息
(1)方式一：(不推荐) 直接将参数通过 pool.setXxx方法设置给c3p0程序
这种方式直接将参数写死在了程序中，后期一旦参数发生变化，就要修改程序，要重新编译项目、重新发布项目，非常麻烦
//设置连接数据库的基本信息
pool.setDriverClass( "com.mysql.jdbc.Driver" ); pool.setJdbcUrl( "jdbc:mysql:///jt_db?characterEncoding=utf-8" );
pool.setUser( "root" );
pool.setPassword( "root" );
(2)方式二：将连接参数提取到properties文件中(推荐)
文件必须放在src(源码根目录)目录下 !
文件名必须叫做 c3p0.properties !
在类目录下(开发时可以放在src或者类似的源码目录下)，添加一个c3p0.properties文件，配置内容如下：
c3p0.driverClass=com.mysql.jdbc.Driver c3p0.jdbcUrl=jdbc:mysql:///jt_db?characterEncoding=utf-8
c3p0.user=root
c3p0.password=root
这种方式由于是c3p0到指定的位置下寻找指定名称的properties文件，所以文件的位置必须是放在src或其他源码根目录下，文件名必须是c3p0.properties。
(3)方式三：将连接参数提取到xml文件中(推荐)
文件必须放在src(源码根目录)目录下 !
文件名必须叫做 c3p0-config.xml
在类目录下(开发时可以放在src或者类似的源码目录下)，添加一个c3p0- config.xml文件，配置内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
<default-config>
<property name="driverClass">com.mysql.jdbc.Driver</property> <property name="jdbcUrl">jdbc:mysql:///jt_db?
characterEncoding=utf-8</property>
<property name="user">root</property>
<property name="password">root</property>
</default-config>
</c3p0-config>
这种方式由于是c3p0到指定的位置下寻找指定名称的xml文件，所以文件的位置必须是放在src或其他源码根目录下，文件名必须是c3p0-config.xml。
方式2和方式3的配置目录
4、从连接池中获取一个连接对象并进行使用
Connection conn = pool.getConnection();
5、用完连接后将连接还回连接池中
JdbcUtil.close(conn, ps, rs);
//conn.close()
/* 如果是自己创建的连接对象，这个连接对象没有经过任何的改动，调用 conn.close方法，是将连接对象关闭 * 如果是从连接池中获取的连接对象，该连接对象在返回时就已经被连接池 * 改造了，将连接对象的close方法改为了还连接到连接池中 */
1.2. 事务的四大特性
事务的四大特性(ACID)是：
1）原子性（Atomicity）：一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。即使事务在执行过程中发生错误，也会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。
即：事务中所有操作是不可再分割的原子单位。事务中所有操作要么全部执行成功，要么全部执行失败。
2）一致性（Consistency）：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以自发性地完成预定的工作。
例如：转账业务，无论事务执行成功与否，参与转账的两个账户金额之和在事务前后应该是保持不变的。
张三：1000 1000-500=500 1000
李四：1000 1000+500=1500 1000
3）隔离性（Isolation）：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。
即：隔离性可以在事务并发时，让不同的事务隔离开来，一个事务看不到另一个事务正在进行中的状态。
例如：在A事务中，查看另一B事务(正在修改张三的账户金额)中张三的账户金额，要查看到B事务之前的张三的账户金额，要么查看到B事务之后张三的账户金额。
事务1: 查询A、B账户金额之和
事务2: A转账给B 500元
A - 500 = 500
B + 500 = 1500
4）持久性（Durability）：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。因为事务一旦提交，事务中所有的数据操作都必须被持久化到数据库中，即使事务提交后，数据库马上崩溃，在数据库重启时，也必须能保证通过某种机制恢复数据。
开启事务—A给B转账500元
A: 1000 - 500 = 500 (成功了) – 在日志中记录,事务成功,A账户金额更新为500
B: 1000 + 500 = 1500 (成功了) – 在日志中记录,事务成功,B账户金额更新为 1500
结束事务—回滚/提交
开启事务：begin / start transaction；
begin 或 start transaction 显式地开启一个事务；
提交事务：commit;
commit会提交事务，并使已对数据库进行的所有修改成为永久性的；
回滚事务：rollback;
rollback会回滚事务，即撤销正在进行的所有未提交的修改。数据也会恢复到事务开始前的状态，就像这个事务从来没有执行过一样。
quit中断操作：将rollback替换为quit，即中断操作
2.2. jdbc中操作事务 在JDBC中实现转账例子
提示：JDBC中默认是自动提交事务，所以需要关闭自动提交，改为手动提交事务
也就是说, 关闭了自动提交后, 事务就自动开启, 但是执行完后需要手动提交或者
回滚!!(1)执行下面的程序，程序执行没有异常，转账成功！A账户减去100元，B账户增加100元。
(2)将第4步、5步中间的代码放开，再次执行程序，在转账过程中抛异常，转账失败！由于事务回滚，所以A和B账户金额不变。
Connection conn = null;
Statement stat = null;
ResultSet rs = null;
try {
//1.获取连接
Class.forName("com.mysql.jdbc.Driver");
//2.获取数据库连接
Connection conn = DriverManager.getConnection( "jdbc:mysql://localhost:3306/jt_db? characterEncoding=utf-8", "root", "root");
//2.关闭JDBC自动提交事务（默认开启事务） conn.setAutoCommit(false);
//3.获取传输器
stat = conn.createStatement();
/* ***** A给B转账100元 ***** */
//4.A账户减去100元
String sql = "update acc set money=money-100 where name='A'";
stat.executeUpdate(sql);
//int i = 1/0; // 让程序抛出异常，中断转账操作
//5.B账户加上100元
sql = "update acc set money=money+100 where name='B'";
stat.executeUpdate(sql);
//6.手动提交事务
conn.commit();
System.out.println("执行成功！提交事务...");
} catch (Exception e) {
e.printStackTrace();
//一旦其中一个操作出错都将回滚，使两个操作都不成功
conn.rollback();
System.out.println("执行失败！回滚事务...");
} finally{
rs.close(); stat.close(); conn.close();
}
脏读
脏读又称无效数据读出（读出了脏数据）。一个事务读取另外一个事务还没有提交的数据叫脏读。
例如：事务T1修改了某个表中的一行数据，但是还没有提交，这时候事务T2读取了被事务T1修改后的数据，之后事务T1因为某种原因回滚（Rollback）了，那么事务T2读取的数据就是脏的（无效的）。
解决办法：把数据库的事务隔离级别调整到READ_COMMITTED（读提交/不可重复读）
不可重复读
不可重复读是指在同一个事务内，两次相同的查询返回了不同的结果。
例如：事务T1会读取两次数据，在第一次读取某一条数据后，事务T2修改了该数据并提交了事务，T1此时再次读取该数据，两次读取便得到了不同的结果
解决办法：把数据库的事务隔离级别调整到REPEATABLE_READ（可重复读）
幻读
幻读也是指当事务不独立执行时，插入或者删除另一个事务当前影响的数据而发生的一种类似幻觉的现象。
例如：系统事务A将数据库中所有数据都删除的时候，但是事务B就在这个时候新插入了一条记录，当事务A删除结束后发现还有一条数据，就好像发生了幻觉一样。这就叫幻读。
解决办法：把数据库的事务隔离级别调整到SERIALIZABLE_READ（序列化执行），或者数据库使用者自己进行加锁来保证。
Maven介绍
1.1. Maven是什么?
Maven: 翻译为"专家"、“内行”，是Apache下的一个纯Java开发的一个开源项目。
Maven是一个项目管理工具，使用Maven可以来管理企业级的Java项目开发及依赖的管理。
使用Maven开发，可以简化项目配置，统一项目结构。总之，Maven可以让开发者的工作变得更简单。
什么是依赖管理？要明白依赖管理，首先要知道什么是依赖？
一个Java项目中往往会依赖一些第三方的jar包。比如JDBC程序中要依赖数据库驱动包，或者在使用c3p0连接池时，要依赖c3p0的jar包等。这时我们称这些Java项目依赖第三方jar包。
而所谓的依赖管理，其实就是对项目中所有依赖的jar包进行规范化管理。
1.2. 为什么要使用Maven?
传统的项目（工程）中管理项目所依赖的jar包完全靠人工进行管理，而人工管理jar包可能会产生诸多问题。
1、不使用Maven，采用传统方式管理jar包的弊端：
(1)在一些大型项目中会使用一些框架，比如SSM或者SSH框架，而框架中所包含的jar包非常多（甚至还依赖其他第三方的jar包），如果这些jar包我们手动去网上寻找，有些jar包不容易找到，比较麻烦。
(2)传统方式会将jar包添加到工程中，比如Java工程中将jar包放在工程根目录或
者放在自建的lib目录下；JavaWeb工程会将jar包放在:/WEB-INF/lib目录下，这样会导致项目文件的体积暴增（例如，有些项目代码本身体积可能仅仅几兆，而加入jar包后，工程的体积可能会达到几十兆甚至百兆）。
(3)在传统的Java项目中是将所有的jar包统一拷贝的同一目录中，可能会存在jar
包文件名称冲突的问题！
(4)在进行项目整合时，可能会出现jar包版本冲突的问题。
(5)在传统java项目中通过编译（手动编译或者在eclipse保存自动编译）、测试（手动在main函数中测试、junit单元测试）、打包部署(手动打war包/手动发布)、运行(手动启动tomcat运行)，最终访问程序。
2、使用Maven来管理jar包的优势：
(1)Maven团队维护了一个非常全的Maven仓库(中央仓库)，其中几乎包含了所有的jar包，使用Maven创建的工程可以自动到Maven仓库中下载jar包，方便且不易出错。
另外，在Maven构建的项目中，如果要使用到一些框架，我们只需要引入框架的核心jar包，框架所依赖的其他第三方jar包，Maven也会一并去下载。
(2)在Maven构建的项目中，不会将项目所依赖的jar包拷贝到每一个项目中，而是
将jar包统一放在仓库中管理，在项目中只需要引入jar包的位置(坐标)即可。这样实现
了jar包的复用。
(3)Maven采用坐标来管理仓库中的jar包，其中的目录结构为【公司名称+项目/产品名称+版本号】，可以根据坐标定位到具体的jar包。即使使用不同公司中同名的jar包，坐标不同（目录结构不同），文件名也不会冲突。
(4)Maven构建的项目中，通过pom文件对项目中所依赖的jar包及版本进行统一管理，可避免版本冲突。
(5)在Maven项目中，通过一个命令或者一键就可以实现项目的编译（mvn complie）、测试（mvn test）、打包部署（mvn deploy）、运行（mvn install）等。
还有发布到tomcat服务器中运行: mvn tomcat7:run。如果想实现上面的所有过
程，只需要记住一个命令：mvn install
总之，使用Maven遵循规范开发有利于提高大型团队的开发效率，降低项目的维护成本，大公司都会优先使用Maven来构建项目.
Maven安装
2.1. 下载、安装Maven
1、官方下载地址：http://maven.apache.org/download.cgi
2、下载绿色版，解压之后就可以使用。
原则: 安装的路径中最好不要有中文和空格!!
3、若要下载旧版本Maven，可以访问：https://archive.apache.org/dist/maven/maven-3/
3. Maven的相关配置
在开发中更多是通过Eclipse+Maven来构建Maven项目，所以这里我们需要将Maven配置到Eclipse开发工具中。
在将安装好的Maven工具配置的Eclipse开发工具中之前，需要做一些相关的配置。
3.1. 配置本地仓库位置
本地仓库：其实就是本地硬盘上的某一目录，该目录中会包含maven项目中所需要的所有jar包及插件。当所需jar包在本地仓库没时，从网络上下载下来的jar包也会存放在本地仓库中。
因此本地仓库其实就是一个存放jar包的目录，我们可以指定Maven仓库的位置。
如果不指定，maven本地仓库的默认位置是在c盘，在：C:/Users/{当前用户}/.m2/repository ，例如:
可以保持默认，当然也可以修改本地仓库的位置到别的盘符路径。
修改方法：找到[MAVEN_HOME]/conf/目录中的配置文件settings.xml，修改maven
仓库的路径。
配置该目录后，以后通过maven下载的jar包将会保存在配置的目录下。
3.2. 配置远程仓库(私服)
当maven项目中需要依赖jar包时，如果本地仓库中没有，就会到远程仓库去下载jar包。
可以在settings.xml文件中配置连接远程仓库
需要做的是，在settings.xml文件中的 标签下的 标签内部添加如下配置，配置阿里云远程仓库：
<mirror>
<id>aliyun</id>
<name>aliyun for maven</name>
<mirrorOf>*</mirrorOf> <url>https://maven.aliyun.com/repository/public</url>
</mirror>
远程仓库配置总结：
4. 当所需jar包在本地仓库没有时，会从网络上下载。配置远程仓库其实就是配置，去网络中哪个位置下载jar包到本地。
5. 如果在公司，并且公司有搭建镜像服务器，推荐使用公司的镜像服务器下载jar包，速度会更快。（没有外网也连接不了中央仓库，下载jar包会失败！）
6. 如果在家里，使用的是外网，可以不配置远程仓库，默认连接中央仓库下载jar包，或者配置阿里云的远程仓库。连接阿里云服务器下载jar包。（注意，如果配置阿里云镜像服务器，不可使用手机热点网络！）
3.3. 配置JDK版本
通过 Maven创建的工程，JDK版本默认是JDK1.5，每次都需要手动改为更高的版
本。
这里可以通过修改maven的settings.xml文件, 达到一劳永逸的效果。
配置方式为：打开 {maven根目录}/conf/settings.xml 文件并编辑，在
settings.xml文件内部的 标签内部添加如下配置：
<profile>
<id>development</id>
<activation>
<jdk>1.8</jdk> <activeByDefault>true</activeByDefault> </activation>
<properties> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersio n>
</properties>
</profile>
3.4. 将Maven配置到Eclipse中
将Maven工具配置到Eclipse中，就可以通过Eclipse和自己安装的Maven创建Maven项目了。
1、window右键–> Preferences：
2、点击Maven选项，在右侧选项中勾选 “Download Artifact Sources”：
3、点击add将自己安装的Maven添加进来：
4、添加自己安装的Maven：
一定要注意:自己安装的Maven不要放在桌面上(容易丢失，并且路径中往往有空格)，maven的安装路径中也不要包含中文和空格!!
5、将默认的maven切换为自己配置的maven：
6、设置maven的settings文件的位置：
7、测试是否配置成功：window—> show view —> other中搜索"maven"，点击下
面的选框中的选项
在弹出的窗口中，查看自己配置的本地仓库和远程仓库镜像:
<dependencies>
<dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> <scope>provided</scope>
</dependency>
<dependency> <groupId>javax.servlet</groupId> <artifactId>jsp-api</artifactId> <version>2.0</version> <scope>provided</scope>
</dependency>
</dependencies>
添加后保存pom文件。若还报错，在项目上右键选择 “Maven” —> “UpdateProject…” 更新工程即可！
6、实现Servlet程序
7、测试访问：打开浏览器访问地址：
http://localhost/MavenSimpleProJavaweb/HelloServlet
4.3. Maven的目录结构
使用Maven创建的工程我们称它为Maven工程，Maven工程具有一定的目录规范，对目录结构有严格的要求，一个Maven工程要具有如下目录结构：
下面以Maven的Web项目为例，介绍Maven项目中的目录结构：
Maven项目名称(Web项目)
|-- src/main/java(源码目录)：用于存放程序/项目所需要的java源码文件
|-- src/main/resources(源码目录)：用于存放程序/项目所需要的配置文件
|-- src/test/java(源码目录)：用于存放测试程序的java源文件
|-- src/test/resources(源码目录)：用于存放测试程序所需要配置文件 |-- src/main/webapp：(Web应用的根目录，作用类似于WebContent)
|-- WEB-INF：(受保护的目录)
|-- web.xml：(Web应用的核心配置文件)
|-- target/classes(类目录)：源码目录中的资源经过编译后，会输出到类目录 下。
|-- pom.xml：Maven项目中非常重要的文件，将来项目需要任何jar包或插件，都 可以通过pom文件来导入这些jar包或插件。
在导入项目时我们通常会通过 “File” --> “Import…” 来导入项目，但是这样能会产生环境问题，例如：如果项目本身自带的环境和我们当前使用的开发环境不一致，就会产生问题。可以按照下面的方式来进行导入。
1、创建一个新的Maven工程（JavaWeb工程）
确保已经配置好Maven的环境后，在Eclipse中创建一个新的Maven工程（Javaweb工程），新工程的名字和所导入的工程的名字可以相同也可以不同
2、解压需要导入的maven项目压缩包
3、将解压后的目录中的src目录选中并复制。
4、点击新创建的Maven工程右键粘贴，将复制的src目录粘贴到新建的工程中
5、打开解压后的目录中的pom.xml文件, 复制其中的内容：
如果复制后项目或pom文件仍然报错, 可以更新Maven工程
更新Maven工程：在项目上右键选择 “Maven” —> “Update Project…”，在弹出的窗口中直接点击OK即可！
6、执行SQL脚本文件，导入数据
7、部署项目到服务器并启动服务器，访问测试
在pom.xml文件中，添加mysql驱动包的坐标如下：
mysql
mysql-connector-java 5.1.32
2、项目中引入的jar包存放在哪里？
那么问题来了，在pom文件中添加的servlet的jar包坐标，添加的仅仅是一个jar包对应的坐标，而这个jar包到底存放在哪里呢?
了解Maven管理jar包的规则之后，我们可以找到jar包的存放位置是在本地仓库（仓库默认是在：C:\Users{当前户}.m2\repository）的 /javax/servlet/servlet- api/2.5/目录下，例如：
总结：
在Maven中，所有的jar包全都存放在本地仓库的目录中，如果项目中需要使用某一个jar包，直接在项目的pom.xml文件中通过坐标(GroupID + ArtifactID + Version)引入指定位置的jar包即可。
这样可以将项目中所有使用的jar包集中在一个目录（本地仓库）中统一进行管理，需要时通过坐标直接引入即可，而不是在每个项目中都拷贝一份，减少了项目体积，也节省了磁盘空间。
将来如果别人需要导入你的项目，只需要将项目（当然包括pom.xml文件）代码整体传给对方，无需将jar包发送给对方，对方在配置Maven的环境后，Maven会自动根据项目中pom.xml文件里配置的坐标，引入（或下载后再引入）对应的jar包。
3、如果引入的jar包在本地仓库中没有呢？
如果是刚配置的Maven环境，本地仓库中还没有太多jar包，此时在pom文件中通过坐标引入jar包，而本地仓库中没有这个jar包，这时会怎么样呢？
若本地仓库没有所需要的jar包，则会到远程仓库（也叫私服）或者到中央仓库（也叫公服）中下载。下面我们就来介绍Maven的这三种仓库。
6.2. Maven三种仓库
在上面所提到的本地仓库、远程仓库、中央仓库是用来Maven用来更好的管理jar包的所采用的一种方式。下面来了解Maven的三种仓库，以及三种仓库之间的潜在联系。
通过maven构建的项目，会通过项目中的pom.xml文件从远程仓库下载，并保存到本地仓库
本地仓库：默认的本地仓库位置在： c:/
u
s
e
r
.
d
i
r
/
.
m
2
/
r
e
p
o
s
i
t
o
r
y
，
其
中
{user.dir}/.m2/repository ，其 中
user.dir/.m2/repository，其中{user.dir}表示windows下的用户目录。本地仓库的作用是，用于保存（存储）从私
服或者从中央仓库下载下来的jar包（或插件）。当项目中需要使用jar包和插件时，
优先从本地仓库查找。
如果本地仓库中没有所需的jar包，可以到私服或者到中央仓库中下载后再保存
到本地仓库。
远程仓库：远程仓库也叫做私服（Nexus），私服一般由公司搭建并维护（也可
以自己搭建）。比如达内有搭建自己的私服服务器（http://maven.tedu.cn/nexus/con tent/groups/public/），以及阿里云私服服务器（http://maven.aliyun.com/nexus/co ntent/groups/public/）。
如果项目中使用到的jar包或者插件本地仓库中没有，则可以到私服中下载，如
果私服中有就直接将jar包保存到本地仓库中；而如果私服中也没有所需的jar包，就
到中央仓库（公服）上下载所需要的jar包，下载之后先在私服上保存一份，最后再
保存到本地仓库。
中央仓库：中央仓库也叫做公服，在maven软件中内置了一个仓库地址（http:// repo1.maven.org/maven2）它就是中央仓库，服务于整个互联网，由Maven团队自己
搭建并维护，里面存储了非常全的jar包，它包含了世界上大部分流行的开源项目的
jar包。
那么我们在使用Maven构建的Java项目，项目中所使用的jar包会来自哪里呢？例
如，通过Maven先后构建项目A和项目B，在项目中都需要依赖第三方jar包：
如果项目A中需要依赖第三方jar包，只需要在项目下的pom文件中引入jar包 在本地仓库中的坐标即可使用。如果本地仓库没有所需要的jar包，则会连接私服（需要提前配置）下载所需jar包到本地仓库供项目使用。
如果私服上也没有所需的jar包，则会连接中央仓库下载所需要的jar包保存到私服，再将jar包从私服下载至本地仓库，供项目使用。
如果没有配置私服，则默认连接中央仓库下载所需要的jar包到本地仓库中供
项目使用
当项目B也需要依赖第三方jar包时，先到本地仓库中查找所需jar包，如果有则直接引用而无需再次下载，如果仍有部分jar包本地仓库中没有，则同上，即连接私服下载所需jar包到本地仓库。若私服中也没有所需jar包，则连接中央仓库下载jar包到私服，再从私服下载jar包到本地仓库中，供项目使用。
6.3. 添加依赖:方式一
使用maven插件的索引功能快速添加jar包
这种方式需要本地仓库中已经包含了该jar包，否则搜索不到!!!
1、如果本地仓库中有我们需要的jar包，可以在项目中的pom.xml文件中空白处
右键–> Maven --> Add Dependency在弹出的窗口中添加所需要的依赖(jar包)，如图：
2、添加依赖示例：添加spring的jar包的坐标到项目中
(1) 在项目中的pom.xml文件中右键 -> Maven -> Add Dependency，在弹出的窗口
中输入
“spring”:
选中要添加的jar包（坐标会自动填写），点击OK即可完成添加
(2)如果搜索不到jar包（保证本地仓库中已经下载了该jar包），可以尝试重建索
引。
在
“Maven Repositories” 视图窗口中可以看到如下内容：
在"Local Repositories"上右键选择 “Rebuild Index” 即可重建索引。
完成后，再尝试搜索jar包进行添加。
.6.4. 添加依赖:方式二 1、直接在pom.xml文件中的标签内部添加。例如：在pom.xml文件中添加如下
配置，就可以将junit单元测试的jar包引入到项目中来了。
添加依赖：
junit
junit
4.9
test
2、手动添加依赖需要指定所依赖jar包的坐标，但是在大部分情况下，我们是不
知道jar包的坐标的。可以通过访问如下网址，在互联网上搜索查询：
http://mvnrepository.com
3、示例：添加c3p0的jar包的坐标到项目中
访问上面的网址，在搜索框中搜索 “c3p0”
在搜索出来的内容中，选择所需要的版本并点击版本，查看该版本的c3p0 jar包所对应的坐标：
将坐标直接拷贝到项目的pom.xml文件中即可：
4、将上图中右侧选中的坐标拷贝到pom.xml文件中
7. 扩展:Maven常见问题
7.1. 拷贝Maven仓库
如果因为网络环境的问题（比如：电脑没有网络），导致jar包无法下载，也可
以将别人下载好的（完整的）Maven的本地仓库拷贝过来，放在自己配置的本地仓库
中。因为Maven可以支持拷贝别人的仓库。
7.2. 常见环境问题
问题描述1：
创建Maven项目时报如下错误：
或者创建Maven项目目录结构不全（比如只有src目录），如下图：
导入已有的Maven项目，项目运行不了（jar没有下载完全）
此时是因为maven的环境被破坏了，导致Maven基础运行环境不全，无法创建
Maven项目，或者无法下载所需要的jar包。解决方法：
(1)在项目的pom文件中敲一个空白行，再保存文件，目的是让maven检测到pom文件发生 了变化，再根据pom文件中的配置，到本地仓库中寻找对应的jar包，如果没有相应的 jar包，maven会重新下载。
(2)如果上面的方式不行，可以尝试在项目上，右键—> Maven —> Update Project…，强制更新项目，此时maven也会检查pom文件，在本地仓库中有没有相应 的jar包。
(3)如果上面的方式仍然没有解决问题，检查当前网络环境是否能连接上所配置的远程仓 库。（比如在家里使用外网，无法连接阿里云的远程仓库，或者使用手机热点网络无法连接 阿里云的远程仓库等）
a) 在公司，连接的是公司内网：在settings.xml文件中配置连接公司的远程仓 库
b) 在家里，用的是外网（但不是手机热点）：可以不配置，默认连接中央仓库，或者 在settings.xml文件中配置连接阿里云仓库
c) 用的是手机热点网络：不可以配置连接远程仓库或者阿里云仓库，连不上！！
(4)如果网络能够连接上所配置的远程仓库，到本地仓库的目录下，将本地仓库中所有的 目录都删除，删除时，eclipse正在使用本地仓库中的资源文件，所以会阻止删除，此时 将eclipse关闭，再将本地仓库中的所有目录删除，重启eclipse。
(5)启动eclipse后,再将上面的第(1)步和第(2)步再做一遍!
(6)如果还是不行,就使用复制的本地仓库替换你的本地仓库!
问题描述2：每天第一次打开Eclipse发现之前创建的Maven工程报错（比如项目
上有叉号或者叹号，但项目之前是OK的），解决方法：在菜单栏中找到 Project —> Clean…
或者是：在报错的项目上鼠标右键 --> Maven --> Update Project：
7.3. 找不到jar包问题
在项目中通过坐标引入了jar包（或者插件），并且本地仓库中也存在对应的jar
包，但是项目还是报错，提示内容说找不到。
解决方法：如果引入的jar包，在本地仓库中存在，但是还是提示找不到，可以
将本地仓库中jar包或插件的所在目录整个删除(如果删除时提示文件正在被占用，关
闭eclipse再删除即可)，重新保存pom.xml文件，并更新工程，让maven再次下载上面
的jar包即可！
未下载完全示例：
正常下载完全示例：
7.4. Maven的依赖范围
下面添加了一个 jsp-api 的依赖，maven就会去下载 jsp-api 的jar包及它依赖的一
些jar包
javax.servlet
jsp-api
2.0
provided
</dependency
依赖配置中有一个scope之前没讲过，它就是 依赖范围 。
1、什么是依赖范围：就是指定你这个jar包在哪个阶段时才有效。
compile - 编译依赖范围。默认的范围，可以不填，表示在所有过程中都有
效，如编译期、测试过程中、运行期间等。
provided - 已提供依赖范围。这个范围表示只提供编译和测试阶段有效，运
行期间不需要，像tomcat等容器本身已经提供的 servlet-api、jsp-api 等依
赖。
runtime - 运行时依赖范围。这个范围表示只有在运行和测试期间才有效，
编译期间不需要，像连接数据库的jdbc驱动程序等。
test - 测试依赖范围。这个范围只有测试阶段有效，编译和运行不需要，像
单元测试提供的junit包。
system - 系统依赖范围。这个范围表示不依赖本地仓库，jar在其他的目录，
需要通过systemPath指定路径，这个不建议使用。
import - 引用依赖范围。Maven2.0.9之后新增的范围，只能用在中，并且导
入的type为pom类型的父工程配置，一般用来解决多继承问题。
2、什么是依赖传递：
依赖的传递前面讲过通过继承和聚合的方式可以达到，通过继承的方式可以轻松
的从父项目继承过来，通过聚合的方式也可以间接的传递过来。
继承：A继承B，A就可以继承B的dependencies依赖。
聚合：A依赖C，C依赖D，那么A就要依赖D自然也就获取了D的依赖。
3、什么是依赖排除：
在依赖传递过程中，如 A 依赖 B、S2.0，B 依赖C、S1.0，这样A就有了S1.0和S2.0
两个依赖，这样某些情况下会造成冲突需要手动把B间接传递过来的依赖排除掉，就
是不依赖B带过来的S1.0的包。
或者直接设置 排除所有间接依赖：
