Maven高级
知识点-依赖冲突
1. 目标
解决maven项目中的依赖冲突
2. 路径
- 第一声明优先原则
- 就近原则
- 直接排除法
3. 详解
- 什么是依赖的冲突？
当我们的多个jar包里面包含了同样，重复的jar包，那么此时maven会根据一系列的规则来选择使用某一个具体的jar包。
- 依赖传递
当我们使用A jar包的时候， A jar包的代码需要用到B jar包，那么此时maven也会把B jar包给弄进来。
3.1.1 第一声明优先原则
哪个jar包在靠上的位置，这个jar包就是先声明的，先声明的jar包下的依赖包，可以优先引入项目中。
如： 我们在pom.xml中引入如下坐标，分别是spring中不同的版本。
<?xml version="1.0" encoding="UTF-8"?>
<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>com.mingye</groupId>
<artifactId>maven_day01_demo</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<!--导入相关依赖包-->
<dependencies>
<!--引入spring-context，它所以来的包都会导入进来-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.2.4.RELEASE</version>
</dependency>
</dependencies>
</project>
我们在控制面板的maven面板，点击查看依赖关系按钮，看到了包和包之间的依赖关系存在冲突，都使用了spring-core包
把2个包的顺序调换后就变成了低版本的依赖导入。
3.1.2 就近原则
直接依赖比传递依赖路径近，那么最终进入项目的jar包会是路径近的直接依赖包。
直接依赖：项目中直接导入的jar包就是项目的直接依赖包。
传递依赖（间接依赖）：项目中没有直接导入的jar包，可以通过中直接依赖包传递到项目中去。
修改jar包，直接引入依赖spring-core
<!--导入相关依赖包-->
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.2.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<!--引入直接依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.2.8.RELEASE</version>
</dependency>
</dependencies>
此时优先引入的是直接依赖的引用
3.1.3 直接排除法
除了使用前面的两种办法来解决依赖冲突的问题，也可以直接使用排除的办法来解决。即直接忽略掉后续依赖中的某一个具体的jar包，选择排除它。
<!--导入相关依赖包-->
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.2.4.RELEASE</version>
<!--直接排除-->
<exclusions>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
</dependencies>
快捷操作：
依赖导入的jar包如下：
添加exclusion之后，因为排除了4.2.4的版本spring-core的jar包
4. 小结
真实项目中，出现1个项目存在多个同种jar包的时候，需要我们进行解决maven的jar包冲突问题（异常：Class not found， class not defined、Method not found, NoSuchField等） jdk版本过高
-
路径近者优先
-
节点路径相同时，使用第一声明优先（xml上下顺序有关）
-
无法通过依赖管理原则排除的，使用直接排除法
<exclusions>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</exclusion>
</exclusions>
知识点-继承和聚合
1. 目标
实现项目工程拆分合和继承的作用
2. 路径
- 继承和聚合
3. 详解
3.1 工程创建模式
-
以前创建工程
-
聚合模式创建工程
3.2 继承和聚合
- 继承
继承是为了消除重复，如果将 dao、 service、 web 分开创建独立的工程则每个工程的 pom.xml 文件中的内容存在重复，比如：设置编译版本、锁定 spring 的版本的等，可以将这些重复的 配置提取出来在父工程的 pom.xml 中定义。
- 聚合
项目开发通常是分组分模块开发， 每个模块开发完成要运行整个工程需要将每个模块聚合在 一起运行，比如： dao、 service、 web 三个工程最终会打一个独立的 war 运行。
对父亲操作，同时也会批量对孩子操作，父亲clean，所有孩子也都会clean。
- 继承聚合的特点
特点1（继承）：
ssm_parent父工程：存放项目的所有jar包。定义了所有的依赖
ssm_web和ssm_service和ssm_dao有选择的继承jar包，并在自己的工程中使用。这样可以消除jar包重复，并锁定版本
特点2（聚合）：
ssm_web依赖于ssm_service，ssm_service依赖于ssm_dao，我们启动ssm_web，便可以访问我们的程序。
执行安装的时候，执行ssm_parent，就可以将所有的子工程全部进行安装。
- 项目结构示例
4. 小结
案例 - 分模块构建工程【重点】
单体项目和分模块项目对比
1. 需求
能够使用分模块构建工程
2. 分析
- 创建ssm_parent ： 父工程
- 创建ssm_model ： 其实就是用来放javabean
- 创建ssm_dao
- 创建ssm_service
- 创建ssm_web
3. 实现
- 准备数据库环境
create database day36;
use day36;
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for `items`
-- ----------------------------
DROP TABLE IF EXISTS `items`;
CREATE TABLE `items` (
`id` int(10) NOT NULL auto_increment,
`name` varchar(20) default NULL,
`price` float(10,0) default NULL,
`pic` varchar(40) default NULL,
`createtime` datetime default NULL,
`detail` varchar(200) default NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of items
-- ----------------------------
INSERT INTO `items` VALUES ('1', '传智播客web课程', '1000', null, '2018-03-13 09:29:30', '带我走上人生巅峰');
INSERT INTO `items` VALUES ('2', '黑马之路', null, null, '2018-03-28 10:05:52', '插入测试');
INSERT INTO `items` VALUES ('3', '黑马之路二', '199', null, '2018-03-07 10:08:04', '插入测试');
INSERT INTO `items` VALUES ('4', '插入测试', null, null, null, null);
INSERT INTO `items` VALUES ('5', '插入测试', null, null, null, null);
3.1 创建ssm_parent
删除src文件夹
3.1.1 pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<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>com.mingye</groupId>
<artifactId>ssm_parent</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<!--
特殊属性定义，一般是版本号
-->
<properties>
<spring.version>5.0.2.RELEASE</spring.version>
<slf4j.version>1.6.6</slf4j.version>
<mysql.version>5.1.6</mysql.version>
<mybatis.version>3.4.5</mybatis.version>
<aspectjweaver.version>1.9.4</aspectjweaver.version>
<junit.version>4.12</junit.version>
<jsp-api.version>2.0</jsp-api.version>
<servlet-api.version>2.5</servlet-api.version>
<jstl.version>1.2</jstl.version>
<mybatis-spring.version>1.3.0</mybatis-spring.version>
<druid.version>1.0.9</druid.version>
<lombok.version>1.18.8</lombok.version>
<!--文件的编码格式-->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>
<!--
【注意】dependencyManagement:并非导入依赖，而只是管理依赖的版本
-->
<dependencyManagement>
<!--引入版本管理-->
<dependencies>
<!-- spring（切面） -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>${aspectjweaver.version}</version>
</dependency>
<!-- spring（aop） -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<!--spring包（核心）-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<!--用于SpringMVC-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<!--用于数据库源相关操作-->
<!-- spring（整合jdbc） -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring（事务） -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<!--Servlet相关API（可以使用Request、Response）-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>${servlet-api.version}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>${jsp-api.version}</version>
<scope>provided</scope>
</dependency>
<!--jstl标签-->
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>${jstl.version}</version>
</dependency>
<!--MySQL数据库驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
<scope>runtime</scope>
</dependency>
<!--spring测试-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<!-- log日志 start -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- log end -->
<!--mybatis-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency>
<!--MyBatis集成Spring-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>${mybatis-spring.version}</version>
</dependency>
<!--数据源-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>${druid.version}</version>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<!--真正的引入依赖的地方-->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</project>
3.2 创建ssm_model
3.2.1 pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<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">
<parent>
<artifactId>ssm_parent</artifactId>
<groupId>com.mingye</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>ssm_model</artifactId>
<packaging>jar</packaging>
<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
</project>
此时父工程的pom.xml显示
<modules>
<module>ssm_model</module>
</modules>
3.2.2 编写Items
package com.mingye.pojo;
import java.util.Date;
@Data
public class Items {
private Integer id;
private String name;
private Float price;
private String pic;
private Date createtime;
private String detail;
}
3.2.3 打包安装ssm_model 到本地仓库
3.3 创建ssm_dao
3.3.1 pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<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">
<parent>
<artifactId>ssm_parent</artifactId>
<groupId>com.mingye</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>ssm_dao</artifactId>
<!--jar包-->
<packaging>jar</packaging>
<!--引入依赖-->
<dependencies>
<!--model的依赖-->
<dependency>
<groupId>com.mingye</groupId>
<artifactId>ssm_model</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<!--mybatis-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
</dependency>
<!--MyBatis集成Spring-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
</dependency>
<!--数据源-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
</dependency>
<!--MySQL数据库驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!--SpringJdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
</dependency>
<!-- log start -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</dependency>
<!-- log end -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
</dependencies>
</project>
此时查看父工程pom.xml
<modules>
<module>ssm_model</module>
<module>ssm_dao</module>
</modules>
3.3.2 spring-mybatis.xml
在resources下创建db.properties
db.driverClassName=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/day36
db.username=root
db.password=root
在resources下创建spring-mybatis.xml , 这个配置文件用于整合MyBatis
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!--这是用来配置整合MyBatis-->
<!--1. 数据库连接池-->
<context:property-placeholder location="classpath:db.properties"/>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${db.driverClassName}"/>
<property name="url" value="${db.url}"/>
<property name="username" value="${db.username}"/>
<property name="password" value="${db.password}"/>
</bean>
<!--2. SqlSessionFactoryBean-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean">
<!--1. 注入dataSource-->
<property name="dataSource" ref="dataSource"/>
<!--2. 起别名-->
<property name="typeAliasesPackage" value="com.mingye.pojo"/>
</bean>
<!--3. MapperScannerConfigurer-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.mingye.dao"/>
</bean>
</beans>
3.3.3 ItemsDao.java
package com.mingye.dao;
import com.mingye.pojo.Items;
import java.util.List;
public interface ItemsDao {
/***
* 查询所有
* @return
*/
List<Items> findAll();
/***
* 保存操作
* @param items
* @return
*/
int save(Items items);
}
3.3.4 ItemsDao.xml
在resource下面，创建这样的文件：com/itheima/dao/ItemsDao.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mingye.dao.ItemsDao">
<!--查询所有-->
<select id="findAll" resultType="items">
select * from items
</select>
<!--保存操作-->
<insert id="save" parameterType="items">
insert into items values (null , #{name} , #{price} , #{pic} , #{createtime} , #{detail})
</insert>
</mapper>
3.3.5 dao测试
在test下创建DaoTest
package com.mingye.test;
import com.mingye.bean.Items;
import com.mingye.dao.ItemsDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestItemsDao {
@Test
public void testFindAll(){
//1. 创建工厂
ApplicationContext context = new ClassPathXmlApplicationContext("spring-mybatis.xml");
//2. 问工厂要对象
ItemsDao dao = context.getBean(ItemsDao.class);
//3.调用方法
System.out.println(dao.findAll());
}
}
3.4 创建ssm_service
3.4.1 pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<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">
<parent>
<artifactId>ssm_parent</artifactId>
<groupId>com.mingye</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>ssm_service</artifactId>
<!--jar包-->
<packaging>jar</packaging>
<!--依赖-->
<dependencies>
<!--依赖dao-->
<dependency>
<groupId>com.mingye</groupId>
<artifactId>ssm_dao</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<!-- spring -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
</dependency>
</dependencies>
</project>
此时父工程的pom.xml显示
<modules>
<module>ssm_model</module>
<module>ssm_dao</module>
<module>ssm_service</module>
</modules>
3.4.2 spring-service.xml
在resource文件夹里面，创建一个文件：spring-service.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!--1. 扫描包-->
<context:component-scan base-package="com.mingye"/>
<!--2. 事务管理-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!--2.1 打开事务的注解开关-->
<tx:annotation-driven transaction-manager="transactionManager"/>
<!--3. 导入dao的配置文件-->
<import resource="spring-mybatis.xml"/>
</beans>
3.4.3 ItemsService接口
package com.mingye.service;
import com.mingye.pojo.Items;
import java.util.List;
public interface ItemsService {
/***
* 列表查询
* @return
*/
List<Items> findAll();
/***
* 增加商品
* @param items
* @return
*/
int save(Items items);
}
3.4.4 ItemsServiceImpl
package com.mingye.service.impl;
import com.mingye.dao.ItemsDao;
import com.mingye.pojo.Items;
import com.mingye.service.ItemsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Transactional
@Service
public class ItemsServiceImpl implements ItemsService {
@Autowired
private ItemsDao dao;
public List<Items> findAll() {
return dao.findAll();
}
public int save(Items items) {
return dao.save(items);
}
}
3.4.5 service测试
package com.mingye.test;
import com.mingye.bean.Items;
import com.mingye.service.ItemsService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestItemsService {
@Test
public void testFindAll(){
ApplicationContext context = new ClassPathXmlApplicationContext("spring-service.xml");
ItemsService is = context.getBean(ItemsService.class);
System.out.println(is.findAll());
}
@Test
public void testSave(){
ApplicationContext context = new ClassPathXmlApplicationContext("spring-service.xml");
ItemsService is = context.getBean(ItemsService.class);
Items item = new Items();
item.setName("人工智能");
is.save(item);
}
}
3.5 创建ssm_web
3.5.1 pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<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">
<parent>
<artifactId>ssm_parent</artifactId>
<groupId>com.mingye</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>ssm_web</artifactId>
<!--war包-->
<packaging>war</packaging>
<!--依赖引入-->
<dependencies>
<!--依赖service-->
<dependency>
<groupId>com.mingye</groupId>
<artifactId>ssm_service</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<!--导入springmvc-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
</dependency>
<!--servletAPI -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<scope>provided</scope>
</dependency>
<!--jstl表达式 -->
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
</dependency>
</dependencies>
<build>
<!--插件-->
<plugins>
<!--tomcat插件-->
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<!--插件使用的相关配置-->
<configuration>
<!--端口号-->
<port>82</port>
<!--写当前项目的名字(虚拟路径),如果写/，那么每次访问项目就不需要加项目名字了-->
<path>/</path>
<!--解决get请求乱码-->
<uriEncoding>UTF-8</uriEncoding>
</configuration>
</plugin>
</plugins>
</build>
</project>
此时查看父工程pom.xml
<modules>
<module>ssm_model</module>
<module>ssm_dao</module>
<module>ssm_service</module>
<module>ssm_web</module>
</modules>
3.5.2 ItemsController
package com.mingye.controller;
import com.mingye.pojo.Items;
import com.mingye.service.ItemsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.List;
@Controller
@RequestMapping("/items")
public class ItemsController {
@Autowired
private ItemsService service;
//查询所有的
@RequestMapping("/list")
public String list(Model model){
List<Items> list = service.findAll();
//装到model里面
model.addAttribute("items" , list);
//返回页面
return "items";
}
/**
* 添加 ，添加完成之后，跳转到list方法去，查询出来所有的内容，然后再到items页面去显示。
* @param items
* @return
*/
@RequestMapping("/save")
public String save(Items items){
service.save(items);
return "redirect:/items/list";
}
}
3.5.3 springmvc.xml
在resource下面，新建一个文件： springmvc.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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!--1. 扫描包: 由于导入的spring-service.xml里面已经包含了扫描包的动作，所以这里就不需要写了！ -->
<!--<context:component-scan base-package="com.mingye"/>-->
<!--2. 注解驱动-->
<mvc:annotation-driven/>
<!--3. 视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/"/>
<property name="suffix" value=".jsp"/>
</bean>
<!--4. 静态资源处理-->
<mvc:default-servlet-handler/>
<!--5. 导入service层的配置文件：spring-service.xml-->
<import resource="spring-service.xml"/>
</beans>
3.5.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"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
version="2.5">
<!--配置前端控制器 DispatcherServlet-->
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!--springmvc已经定义好了过滤器，可以帮助我们解决post请求，中文乱码的问题，我们只需要配置即可-->
<filter>
<filter-name>char</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<!--设置编码，通过初始化参数来设置编码-->
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>char</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
3.5.5 items.jsp
在webapp的下面创建 items.jsp页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>新增/查询</title>
</head>
<body>
<table>
<form action="/items/save" method="post">
<table>
<tr>
<td>名称</td>
<td><input type="text" name="name"/></td>
</tr>
<tr>
<td>价格</td>
<td><input type="text" name="price"/></td>
</tr>
<tr>
<td>图片</td>
<td><input type="text" name="pic"/></td>
</tr>
<tr>
<td>创建日期</td>
<td><input type="text" name="createtime"/></td>
</tr>
<tr>
<td>详情</td>
<td><input type="text" name="detail"/></td>
</tr>
<tr>
<td colspan="2">
<input type="submit" value="提交"/>
</td>
</tr>
</table>
</form>
</table>
<hr>
<table border="1">
<tr>
<td>ID</td>
<td>name</td>
<td>price</td>
<td>pic</td>
<td>createTime</td>
<td>detail</td>
<td></td>
</tr>
<c:forEach items="${items}" var="item">
<tr>
<td>${item.id}</td>
<td>${item.name}</td>
<td>${item.price}</td>
<td>${item.pic}</td>
<td>${item.createtime}</td>
<td>${item.detail}</td>
</tr>
</c:forEach>
</table>
</body>
</html>
3.6 测试
3.6.1 方式一：tomcat插件发布（配置父工程）【单web工程使用】
把tomcat插件配置到父工程里面去。
使用http://localhost:82/items/list测试
3.6.2 方式二：tomcat插件发布（配置web工程）【不推荐】
把tomcat插件，配置在web项目里面，启动web项目
在父工程打包
所有的子工程都会被打包（package）。这就是“聚合”的作用。
也可以同时安装（install），同时部署（deploy）
【小结】
使用maven内置的tomcat插件的时候 ：
第一种：配置D:\ideaProjects\ssm_parent：parent是有聚合的功能，不需要将ssm_parent，ssm_model，ssm_dao，ssm_service安装到本地仓库。
第二种：配置D:\ideaProjects\ssm_parent\ssm_web：需要将ssm_parent，ssm_model，ssm_dao，ssm_service安装到本地仓库。
3.6.3 方式三：发布到外部tomcat
【注意】：要选择xxx_web:war exploded的，不要选择错了 映射路径一定要写成 / 否则报错
使用http://localhost:8080/items/list测试
3.7 maven依赖报错处理
当下载jar的时候，如果断网，或者连接超时的时候，会自动在文件夹中创建一个名为*lastupdate的文件，当有了这个文件之后，当你再次联网的时候，那么该文件不会再自动联网，必须手动删除jar包的文件夹，才能正常下载使用。如何删除呢？
使用工具
如何使用？打开工具
双击运行
Maven项目，如果正在下载一个jar，但是突然断网，此时，就会产生一个m2e-lastUpdated.，别指望下次上网就会自动下载，必须手动删除该文件，然后再进行下载。
4.小结
1：拆分与聚合和继承
拆分：解耦，代码最大程度的重复使用，维护方便
聚合：靠父工程来聚合，单一工程是没法完成工作。
继承：父工程引入依赖，子工程就不需要再引了, 父式程依赖的版本管理
2: Maven的jar包冲突解决
- 路径近者优先
- 路径相同，第一声明优先
- 路径相同，使用强制排除exclusions
3：准备数据库环境
-
ssm_parent（父工程）聚合，引入依赖管理
-
ssm_model（子工程） 实体类
-
ssm_dao（子工程） mybatis, dataSource, sqlSessionFactorybean, MapperScannerConfigurer
注：映射文件的路径必须与包名路径一样
-
ssm_service（子工程）
扫service包，事务管理器，通知、切面, 导入dao的配置。
-
ssm_web（子工程）
- SpringMVC.xml 扫controller, 视图解析器，注解驱动，静态资源过滤，导入service配置
- web.xml 编码过滤器，前端核心控制器(load-on-startup)
8：测试（工程发布tomcat）
- 推荐使用本地tomcat
知识点- 私服搭建
1.目标
- 了解Maven私服搭建
2.路径
- Maven私服概述
- 搭建私服环境
3.详解
3.1Maven私服概述
公司在自己的局域网内搭建自己的远程仓库服务器，称为私服， 私服服务器即是公司内部的 maven 远程仓库， 每个员工的电脑上安装 maven 软件并且连接私服服务器，员工将自己开发的项目打成 jar 并发布到私服服务器，其它项目组从私服服务器下载所依赖的构件（jar）。私服还充当一个代理服务器，当私服上没有 jar 包会从互联网*仓库自动下载
3.2.搭建私服环境
3.2.1下载 nexus
Nexus 是 Maven 仓库管理器， 通过 nexus 可以搭建 maven 仓库，同时 nexus 还提供强大的仓库管理功能，构件搜索功能等。
下载地址： http://www.sonatype.org/nexus/archived/
下载： nexus-2.12.0-01-bundle.zip
3.2.2安装 nexus
解压 nexus-2.12.0-01-bundle.zip，进入 bin 目录：
**以管理员权限运行命令行,进入 bin 目录，执行 nexus.bat install **
cmd 跨盘符跳转，需要先跳到盘符，再跳具体路径；也可以换顺序
安装成功在服务中查看有 nexus 服务：
3.2.3卸载nexus
cmd 进入 nexus 的 bin 目录，执行： nexus.bat uninstall
3.2.4启动 nexus
-
方式一
cmd 进入 bin 目录，执行nexus.bat start
-
方式二
直接启动 nexus 服务
3.2.5登录
-
访问: http://localhost:8081/nexus/
查看 nexus 的配置文件 conf/nexus.properties ,里面有端口号
-
点击右上角的 Log in，输入账号和密码 登陆 (账号admin,密码admin123 )
-
登录成功
3.2.6仓库类型
nexus 的仓库有 4 种类型：
- hosted，宿主仓库， 部署自己的 jar 到这个类型的仓库，包括 releases 和 snapshot 两部
分， Releases 公司内部发布版本仓库、 Snapshots 公司内部测试版本仓库 - proxy，代理仓库， 用于代理远程的公共仓库，如 maven *仓库，用户连接私服，私
服自动去*仓库下载 jar 包或者插件。 - group，仓库组，用来合并多个 hosted/proxy 仓库，通常我们配置自己的 maven 连接仓
库组。 - virtual(虚拟)：兼容 Maven1 版本的 jar 或者插件
4.小结
-
对着文档搭建一下就OK
-
安装的时候需要以
管理员身份 -
路径不要有中文
知识点-Maven私服的使用
1.目标
- 了解Maven私服的使用
2.路径
- 将项目发布到私服
- 从私服下载 jar 包
3.详解
3.1.将项目发布到私服
3.1.1需求
企业中多个团队协作开发通常会将一些公用的组件、开发模块等发布到私服供其它团队或模块开发人员使用。
本例子假设多团队分别开发 . 某个团队开发完在common_utils, 将 common_utils发布到私服供 其它团队使用.
3.1.2配置
第一步： 需要在客户端即部署 common_utils工程的电脑上配置 maven环境，并修改 settings.xml文件(Maven配置文件)， 配置连接私服的用户和密码 。此用户名和密码用于私服校验，因为私服需要知道上传的账号和密码是否和私服中的账号和密码一致 (配置到标签下)
<server>
<id>releases</id>
<username>admin</username>
<password>admin123</password>
</server>
<server>
<id>snapshots</id>
<username>admin</username>
<password>admin123</password>
</server>
releases: 连接发布版本项目仓库
snapshots: 连接测试版本项目仓库
第二步： 在需要发布配置项目 pom.xml . 配置私服仓库的地址，本公司的自己的 jar 包会上传到私服的宿主仓库，根据工程的版本号决定上传到哪个宿主仓库，如果版本为 release 则上传到私服的 release 仓库，如果版本为snapshot 则上传到私服的 snapshot 仓库 .
<distributionManagement>
<repository>
<id>releases</id>
<url>http://localhost:8081/nexus/content/repositories/releases/</url>
</repository>
<snapshotRepository>
<id>snapshots</id>
<url>http://localhost:8081/nexus/content/repositories/snapshots/</url>
</snapshotRepository>
</distributionManagement>
- 注意： pom.xml 这里 和 settings.xml 配置 对应！
3.1.3测试
1、 首先启动 nexus ，启动私服
2、 对 common_utils工程执行 deploy 命令
根据本项目pom.xml中version定义决定发布到哪个仓库，如果version定义为snapshot，执行 deploy后查看 nexus 的 snapshot仓库， 如果 version定义为 release则项目将发布到 nexus的 release 仓库，本项目将发布到 snapshot 仓库：
3.2从私服下载 jar 包
3.2.1需求
没有配置 nexus 之前（没有搭建私服），如果本地仓库没有，去*仓库下载，通常在企业中会在局域网内部署一台私服服务器， 有了私服本地项目首先去本地仓库找 jar，如果没有找到则连接私服从私服下载 jar 包，如果私服没有 jar 包私服同时作为代理服务器从*仓库下载 jar 包，这样做的好处是一方面由私服对公司项目的依赖 jar 包统一管理，一方面提高下载速度， 项目连接私服下载 jar 包的速度要比项目连接*仓库的速度快的多。
本例子测试从私服下载 common_utils工程 jar 包。
3.2.2在 setting.xml 中配置仓库
在客户端的 maven里面的setting.xml 中配置私服的仓库, 因为我们现在要通过maven去私服里面下载jar包了，所以必须要告诉maven，私服在哪里？，由于 setting.xml 中没有 repositories 的配置标签需要使用 profile 定义仓库。(配置在<profiles>标签下)
<profile>
<!--profile 的 id-->
<id>dev</id>
<repositories>
<repository>
<!--仓库 id， repositories 可以配置多个仓库，保证 id 不重复-->
<id>nexus</id>
<!--仓库地址，即 nexus 仓库组的地址-->
<url>http://localhost:8081/nexus/content/groups/public/</url>
<!--是否下载 releases 构件-->
<releases>
<enabled>true</enabled>
</releases>
<!--是否下载 snapshots 构件-->
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
<pluginRepositories>
<!-- 插件仓库， maven 的运行依赖插件，也需要从私服下载插件 -->
<pluginRepository>
<!-- 插件仓库的 id 不允许重复，如果重复后边配置会覆盖前边 -->
<id>public</id>
<name>Public Repositories</name>
<url>http://localhost:8081/nexus/content/groups/public/</url>
</pluginRepository>
</pluginRepositories>
</profile>
使用 profile 定义仓库之后需要激活才可生效。
<activeProfiles>
<activeProfile>dev</activeProfile>
</activeProfiles>
3.2.3测试从私服下载 jar 包
- 删掉本地仓库的common_utils
在前面把项目发布到私服的时候，maven也会先把jar包安装到本地仓库里面。这里为了测试一会的jar包真的是来自于私服，所以要先去把本地仓库的jar包给删除掉。
- 创建test_common_utils工程 ， 添加依赖
4.小结
- 对着文档操作
知识点-导入第三方jar包
1.目标
- 掌握把第三方 jar 包放入本地仓库和私服
2.路径
- 导入本地库
- 导入私服
- 参数说明
3.详解
我们有一些jar包，但是这些jar包不存在于*仓库，也不存在私服仓库，它就是一个jar包的文件。maven项目现在想用这样的jar包，怎么办？此时就可以把这个单独|独立的jar包给安装到本地仓库或者到私服的仓库
3.1.导入本地库
- 随便找一个 jar 包测试， 可以先 CMD进入到 jar 包所在位置，运行
mvn install:install-file -DgroupId=com.alibaba -DartifactId=fastjson -Dversion=1.1.37 -Dfile=fastjson-1.1.37.jar -Dpackaging=jar
3.2.导入私服
需要在 maven 软件的核心配置文件 settings.xml 中配置第三方仓库的 server 信息 ， 在标签里面配置
<server>
<id>thirdparty</id>
<username>admin</username>
<password>admin123</password>
</server>
才能执行一下命令
mvn deploy:deploy-file -DgroupId=com.alibaba -DartifactId=fastjson -Dversion=1.1.37 -Dpackaging=jar -Dfile=fastjson-1.1.37.jar -Durl=http://localhost:8081/nexus/content/repositories/thirdparty/ -DrepositoryId=thirdparty
3.3.参数说明
-DgroupId 和 -DartifactId 构成了该 jar 包在 pom.xml 的坐标，项目就是依靠这两个属性定位。自己起名字也行。
Dfile 表示需要上传的 jar 包的绝对路径。
Durl 私服上仓库的位置，打开 nexus——>repositories 菜单，可以看到该路径。
DrepositoryId 服务器的表示 id，在 nexus 的 configuration 可以看到。
Dversion 表示版本信息。
关于 jar 包准确的版本：
包的名字上一般会带版本号，如果没有那可以解压该包，会发现一个叫 MANIFEST.MF 的文件
这个文件就有描述该包的版本信息。
比如 Specification-Version: 2.2 可以知道该包的版本了。
上传成功后，在 nexus 界面点击 3rd party 仓库可以看到这包。
4.小结
- 有些jar*仓库没有(eg:oracle驱动), 从官网/网络上下载下来, 安装到本地仓库. 我们的Maven项目就可以使用了
- 具体操作参考文档
知识点 - 多环境配置应用
1. 目标
掌握多环境配置应用
2. 路径
- 配置环境
- 使用环境
3. 详解
-
maven提供配置多种环境的设定，帮助开发者使用过程中快速切换环境
-
配置环境
<!--定义多环境-->
<profiles>
<!--定义具体的环境：生产环境-->
<profile>
<!--定义环境对应的唯一名称-->
<id>env_dep</id>
<!--定义环境中专用的属性值-->
<properties>
<jdbc.url>jdbc:mysql://127.0.0.1:3306/ssm_db</jdbc.url>
</properties>
<!--设置默认启动-->
<activation>
<activeByDefault>true</activeByDefault>
</activation>
</profile>
<!--定义具体的环境：开发环境-->
<profile>
<id>env_pro</id>
……
</profile>
</profiles>
- 使用环境
【命令】：
mvn 指令 –P 环境定义id
【范例】：
mvn install –P pro_env
4. 小结
- 要先配置多环境
- 在使用的时候需要使用参数 P 才能用上指定id的环境