maven

最新推荐文章于 2023-06-08 19:52:10 发布

beita学Java

最新推荐文章于 2023-06-08 19:52:10 发布

阅读量245

点赞数

文章标签： java maven

本文链接：https://blog.csdn.net/weixin_51146806/article/details/113388917

版权

文章目录

maven 的安装
maven的基础内容
maven的使用
案例：

maven 的安装

首先在官网下载安装软件
http://mirrors.advancedhosters.com/apache/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.zip
在这里插入图片描述
然后将下载的文件解压缩到没有中文和没有空格的路径下面
maven目录解释

环境变量配置，配置MAVEN_HOME ,变量值就是mavend的安装路径，如下图，然后配置path.

过mvn -v 命令可以检测maven是否安装成功,如图
idea的maven配置
打开→File→Settings配置maven,如下图
在这里插入图片描述

maven的基础内容

1、maven的两个重要属性

依赖管理：maven对项目中的jar包的管理过程。传统过程中我们直接把jar包放在项目中maven工程真正的把jar包放在在仓库中。项目中只放置jar包的坐标

仓库的种类本地仓库，远程仓库，中央仓库。
仓库之间的关系，当我们启动一个maven工程的时候，maven工程会通过pom文件的jar包坐标去本地仓库找对应的jar包。
默认情况下，如果本地仓库没有对应的jar包，maven工程会自动去中央仓库下载jar包到本地仓库在公司中如果本地没有对应的jar包，会先从私服下载jar包，如果私服没有jar包，可以从中央仓库下载，也可以从本地上传

一键构建：maven自身集成了tomcat插件，可以对项目进行编译测试，打包，安装，发布等操作

2、maven的主要功能

在这里插入图片描述

3、Maven的依赖管理

在这里插入图片描述
maven的依赖传递
在maven中，依赖传递是可以传递的，假设存在三个项目，分别是项目A，项目B，项目C。假设C依赖B,B依赖A,那么根据maven项目依赖的特征不难推出项目C也依赖于项目A.

通过上图也可以看出，在项目中直接依赖了spring-webmvc，而spring-webmvc依赖了Spring-aop,spring-beans等，也就是在项目中有依赖了spring-aop和spring-beans等等。
在这里插入图片描述

在这里插入图片描述

maven的使用

在这里插入图片描述

1、使用骨架创建web的maven工程

先创建带有骨架的maven的web工程
在这里插入图片描述

先导入项目运行时所依赖的jar包

 <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
     <!--表示只在测试的时候起作用-->
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <!--      表示只在写代码时候起作用-->
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>

编写servlet包下的代码

public class MyServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws javax.servlet.ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws javax.servlet.ServletException, IOException {
        request.getRequestDispatcher("/hello.jsp").forward(request,response);
    }
}

导入使用Tomcat8要使用的插件和jdk1.8

<build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
        <!--更改端口号-->
          <port>8888</port>
        </configuration>
      </plugin>
<!--      编译时环境 jdk1.8-->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <target>1.8</target>
          <source>1.8</source>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
    </plugins>
  </build>

在webapp下创建index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
hello
</body>
</html>

然后点击M 输入tomcat8:run运行程序把生成的地址复制到浏览器打开
在这里插入图片描述

创建快捷输入的方式

在设置里找到这个
在这里插入图片描述
然后点加号里的创建组custom

然后点刚才创建的组
再点加号里的创建模板

点changne可以选则让哪些文件可以使用这个模板
在pro.xml文件里输入tomcat8就可以使用模板了

2、数据库的操作

先创建一个普通的maven工程，不使用架构!
先导入mysql包和测试包

<dependencies>
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>5.1.6</version>
           <scope>runtime</scope>
       </dependency>
         <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.12</version>
       </dependency>
   </dependencies>

创建Book类

public class Book {
    private Integer id;
    private String name;

创建BookDao接口

public interface BookDao {
    public List<Book> findAll() throws Exception;
}

创建BookDaoImpl类

/*
要想从数据库中取出数据
必须有四个属性：数据库驱动，连接数据库的地址，数据库用户名称，数据库密码
* */
public class BookDaoImpl implements BookDao {
    @Override
    public List<Book> findAll() throws Exception {
        ArrayList<Book> list = null;
        //先获取connection对象
        Connection connection = null;
        //获取真正操作数据库的对象
        PreparedStatement pst = null;
        //执行数据库查询操作
        ResultSet rs = null;
        try {
            //加载驱动类
            Class.forName("com.mysql.jdbc.Driver");
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/book", "root", "123456");
             pst = connection.prepareCall("select * from t_book");
            //执行数据库查询操作
            rs = pst.executeQuery();
            //把数据库结果集转成Java的List集合
            list = new ArrayList<>();
            while (rs.next()) {
                Book book = new Book();
                book.setId(rs.getInt("id"));
                book.setName(rs.getString("name"));
                list.add(book);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            connection.close();
            pst.close();
            rs.close();
        }
        return list;
    }
}

最后创建测试类

public class BookTest {
    @Test
    public void findAll() throws Exception {
        BookDaoImpl bookDao = new BookDaoImpl();
        List<Book> all = bookDao.findAll();
        for (Book book : all) {
            System.out.println(book.getName());
        }
    }
}

3、maven高级应用

3.1解决jar包冲突

在这里插入图片描述

maven工程要导入jar包的坐标就必须要考虑解决jar包
解决jar包冲突的方式一：
第一声明优先原则：哪个jar包的坐标在靠上的位置，这个jar包就是先声明的
先声明的jar包下的依赖包，可以优先进入项目中

maven导入jar包中的一些概念：
直接依赖：项目中直接导入的jar包，就是该项目的直接依赖包
传递依赖：项目中没有直接导入的jar包，可以通过项目直接依赖jar包传递到项目中去

解决jar包冲突的方式二：
路径优先原则。直接依赖比传递依赖路径近，那么最终项目注入的jar包会是路径近的直接依赖
解决jar包冲突的方式三：直接排除法(推荐使用)
当我们要排除某个Jar包下依赖包，在配置exclusions标签的时候内部可以不用写版本号
因为此时依赖包使用的版本和默认的本jar包一样
解决jar包冲突的方式一

    <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>

在这里插入图片描述
方式二

dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.2.4.RELEASE</version>

    </dependency>
      方式二 直接依赖会进入项目
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-core</artifactId>
          <version>4.2.8.RELEASE</version>
      </dependency>

在这里插入图片描述

解决jar包冲突的方式三：

<!-- 方式三：把4.2.4里面的核心包给排除了就会调用5.0.2里面的core核心包了-->
  <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>

在这里插入图片描述

3.2锁定jar包

在这里插入图片描述
dependencyManagement 只是起一个锁定jar包的作用并不会导入jar包
maven是一个项目管理工具

${spring.varsion}是EL表达式引入上面统一管理的版本号

案例：

项目的一键构建
Maven项目的生命周期
使用maven完成项目的构建，项目的构建包括：清理，编译，测试，部署等过程，maven将这些过程规范为一个生命周期，如下是生命周期的各各阶段。
maven管理项目是通过插件完成的。
1、创建webapp骨架的web的maven工程
2、补全目录结构
在这里插入图片描述
3、编写pro.xml文件导入项目使用的包
解决冲突的ssm框架的导包pro.xml文件

	<!-- 统一管理jar包版本 -->
	<properties>
		<spring.version>5.0.2.RELEASE</spring.version>
		<slf4j.version>1.6.6</slf4j.version>
		<log4j.version>1.2.12</log4j.version>
		<shiro.version>1.2.3</shiro.version>
		<mysql.version>5.1.6</mysql.version>
		<mybatis.version>3.4.5</mybatis.version>
		<spring.security.version>5.0.1.RELEASE</spring.security.version>
	</properties>

	<!-- 锁定jar包版本 -->
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-context</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-web</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-webmvc</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-tx</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-test</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.mybatis</groupId>
				<artifactId>mybatis</artifactId>
				<version>${mybatis.version}</version>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<!-- 项目依赖jar包 -->
	<dependencies>
		<!-- spring -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.6.8</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.version}</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.0</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>
		<!-- log start -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>${log4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<!-- log end -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>${mybatis.version}</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.3.0</version>
		</dependency>
		<dependency>
			<groupId>c3p0</groupId>
			<artifactId>c3p0</artifactId>
			<version>0.9.1.2</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>com.github.pagehelper</groupId>
			<artifactId>pagehelper</artifactId>
			<version>5.1.2</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-web</artifactId>
			<version>${spring.security.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-config</artifactId>
			<version>${spring.security.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-core</artifactId>
			<version>${spring.security.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-taglibs</artifactId>
			<version>${spring.security.version}</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.0.9</version>
		</dependency>
	</dependencies>
	<!-- 添加tomcat7插件 -->
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.tomcat.maven</groupId>
				<artifactId>tomcat7-maven-plugin</artifactId>
				<version>2.2</version>
			</plugin>
		</plugins>
	</build>

4、补全web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
          version="4.0">
</web-app>

编写dao层

com.yhn.domain

public class Items {
    private Integer id;
    private String name;
    private Double price;
    private String detail;

com.yhn.dao

public interface ItemsDao {
    public Items findById(Integer id) ;
}

在resources里添加文件com/yhn/dao会变成com.yhn.dao和jave里的com.yhn.dao对应，在里面编写ItemsDao.xml,只是mybatis持久层的配置

<?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.yhn.dao.ItemsDao">
    <select id="findById" parameterType="int" resultType="items">
        select * from items where id=#{id}
    </select>
</mapper>

在applicationContext.xml里进行spring的配置

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/aop
			    http://www.springframework.org/schema/aop/spring-aop.xsd
			    http://www.springframework.org/schema/tx
			    http://www.springframework.org/schema/tx/spring-tx.xsd
			    http://www.springframework.org/schema/mvc
			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--    dao层配置文件开始-->

    <!--    配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/maven"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <!--    配置生产SqlSession对象的工厂-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
<!--        扫描pojo包给包下所有的pojo对象起别名-->
        <property name="typeAliasesPackage" value="com.yhn.domain"/>
     </bean>
<!--    扫描接口包路径，生成索引接口的代理对象，并且放入spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.yhn.dao"/>
    </bean>
    <!--    dao层配置文件结束-->

</beans>

为了看清执行细节把日志文件log4j.properties放到resources里

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

进行test测试

public class ItemsTest {
    @Test
    public void findById() {
        //获取spring容器
       ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
//       dao测试
        //从容器中拿到所需要的dao代理对象
        ItemsDao itemsDao = ac.getBean(ItemsDao.class);
        //调用方法
        Items items = itemsDao.findById(1);
        System.out.println(items.getName());

编写service层

com.yhn.service

public interface ItemsService {
    public Items findById(Integer id);
}

com.yhn.service.impl

@Service
public class ItemsServiceImpl implements ItemsService {
    @Autowired
    private ItemsDao itemsDao;
    @Override
    public Items findById(Integer id) {
        return itemsDao.findById(id);
    }
}

进行applicationContext.xml里的配置

 <!--    service层配置文件开始-->

    <!--    组件扫描配置-->
    <context:component-scan base-package="com.yhn.service"/>
    <!--   aop面向切面编程，切面就是切入点和通知的组合 -->
    <!--    配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--    事务的通知-->
    <tx:advice id="advice">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
<!--  配置切面-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.yhn.service.impl.*.*(..))"/>
        <aop:advisor advice-ref="advice" pointcut-ref="pointcut"/>
    </aop:config>
    <!--    service层配置文件结束-->

进行service测试

public class ItemsTest {
    @Test
    public void findById() {
        //获取spring容器
       ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
//        service测试
        ItemsService itemsService = ac.getBean(ItemsService.class);
        //调用方法
        Items items = itemsService.findById(1);
        System.out.println(items.getName());
    }

}

编写web层代码

在这里插入图片描述
在WEB-INf下新建pages包，创建itemDetail.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
</head>
<body>
<form>
    <table width="100%" border=1>
        <tr>
            <td>商品名称</td>
            <td> ${item.name } </td>
        </tr>
        <tr>
            <td>商品价格</td>
            <td> ${item.price } </td>
        </tr>
        <tr>
            <td>生成日期</td>
            <td> <fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/> </td>
        </tr>
        <tr>
            <td>商品简介</td>
            <td>${item.detail} </td>
        </tr>
    </table>
</form>
</body>
</html>

在com.yhn.controller下建ItemsController类

@Controller
@RequestMapping("/items")
public class ItemsController {
    @Autowired
    private ItemsService itemsService;
  @RequestMapping("/findDetail")
    public String findDetail(Model model) {
        Items items = itemsService.findById(1);
        model.addAttribute("item", items);
        return "itemDetail";
    }
}

在resources包下创建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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/aop
			    http://www.springframework.org/schema/aop/spring-aop.xsd
			    http://www.springframework.org/schema/tx
			    http://www.springframework.org/schema/tx/spring-tx.xsd
			    http://www.springframework.org/schema/mvc
			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!--  组件扫描-->
    <context:component-scan base-package="com.yhn.controller"/>
<!--    处理映射器，处理器适配器-->
    <mvc:annotation-driven/>
<!--    视图解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

<!--    释放静态资源-->
    <mvc:default-servlet-handler/>
</beans>

想把所有配置文件中的资源一启动都交给servlet容器中,在web.xml中配置

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
          version="4.0">
<!--    想把所有配置文件中的资源一启动都交给servlet容器中,在web.xml中配置-->
    
<!--    编码过滤器-->
    <filter>
        <filter-name>encoding</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>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
<!--    配置spring核心监听器-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
<!--    重新指定spring配置文件的路径-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    
<!--    配置springmvc的核心servlet-->
    <servlet>
        <servlet-name>springmvc</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>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

项目完成使用maven内置的tomcat7 点run执行
访问 http://localhost:8080/day_02_1/items/findDetail

拆分与聚合

1、maven解决代码可重用和便于维护问题上这么解决：
maven把完整的项目，分成不同的独立模块，这些模块都有各自的独立d坐标，哪个地方需要其中某个模块，就直接引用该模块的坐标即可
今后如果公司开发一个新项目我们要先考虑的是，ao,service,utils,domain这些模块是否已经存在，如果存在就直接引用，
以上就是maven拆分的思想
我们可以把拆分零散的模块聚合到一起编写一个完整的项目这就是maven聚合思想

2、工程和模块的区别
工程和模块都不等于完整的项目，一个完整的项目看的是代码，代码完整就可以说是一个完整的项目
和此工程和模块无关
工程只能使用自己内部资源，工程是独立的。后天可以和其他工程和模块建立关联关系
模块天生不是独立的，天生是属于父工程的，模块一旦创建，所有父工程的资源都可以使用

父子工程，子模块天生继承父工程，可以使用父工程使用父工程所有资源
子模块之间天生没有任何关系

父子工程之间不用建立关系，继承关系是先天的，不需要手动创建
平级之间的引用叫依赖，依赖是后天创建的
3、项目的拆分与聚合
1、新创建一个maven的父工程，不用骨架，把里面的src删除
然后在父工程里面创建一个maven的moudle，dao,service层不用骨架
在这里插入图片描述

2、、创建maven的module,web层使用骨架
在这里插入图片描述
然后把web模块里面的pro.xml里面的乱七八糟的内容删除了

3、在service的pro文件里引入dao模块，让二者建立连接
在这里插入图片描述
4、在web工程的pom文件中引入service模块，这样web层就可以引用service层

5、然后在父工程pom中加入ssm框架所需要的依赖
在这里插入图片描述
maven_day02_dao直接依赖maven_day02_parent，作用域默认是compile，直接依赖的继承的广义，作用域默认是compile

在这里插入图片描述
6、移动dao层代码，applicationContext.xml改名为applicationContext-dao.xml放到spring包内，这个文件里只放dao层的配置文件

7、把service层的代码复制过来，applicationContext-service.xml里面只留配置service层的代码，因为service的pom中引入了dao 的依赖所以dao层的配置文件也已经在applicationContext-service.xml这个文件中了
在这里插入图片描述
8、把web层的代码复制过来

web.xml里面的复制过来后报错了
在这里插入图片描述
在resuorces创建一个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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/aop
			    http://www.springframework.org/schema/aop/spring-aop.xsd
			    http://www.springframework.org/schema/tx
			    http://www.springframework.org/schema/tx/spring-tx.xsd
			    http://www.springframework.org/schema/mvc
			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!--    引入这两个文件夹就行，谁使用谁整合-->
<import resource="classpath:spring/applicationContext-dao.xml"/>
<import resource="classpath:spring/applicationContext-service.xml"/>
</beans>

三种启动方式

启动方式一通过自己的tomcat8启动服务器
在这里插入图片描述
第一个是打包启动
第二个是热启动（选择使用的）

斜杠是启动路径后面不加项目名就直接用 http://localhost:8080/启动了

bug处理
部署项目时,报了这样的异常:
HTTP Status 500 - Unable to convert string “${item.createtime}” to class “java.util.Date” for attribute “value”: Property Editor not registered with the PropertyEditorManager
主要原因是EL表达式无法被解析到.
其实从后台取值并传值到前台来根本就没有错，而前台JSP页面EL表达式无效，解析不到EL表达式，引起的原因是web.xml中：

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">

注意里面的web-app_3_0.xsd，就是这个引起的，在web-app_2_4.xsd中就不会出现这种问题(这个版本的isELIgnored默认设置为false)。

在不改变web.xml3.0版本的情况下解决办法是：在jsp页面头加:<%@page isELIgnored=“false”%> 问题得以解决。

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

启动方式二在maven父工程里面tomcat7的插件点run
在这里插入图片描述
方式三、用web下的tomcat7启动会报错
Could not find artifact com.yhn:maven_day02_service:pom:1.0-SNAPSHOT

是因为启动maven会先到pom文件中找文件，而本地仓库中没有maven_day02_service这个文件


  <dependencies>
    <dependency>
      <groupId>com.yhn</groupId>
      <artifactId>maven_day02_service</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>