[Maven-02]进阶使用

于 2020-03-15 13:58:59 发布
阅读量284 收藏
点赞数
分类专栏： 常用工具 文章标签： maven java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29051413/article/details/104848619
版权

文章目录

1、前言

  Maven是一个项目管理工具，依赖管理是它的核心功能之一，使得项目只用放置jar包的坐标，而无需放置到工程中，对于多工程而言能节省空间。
  仓库的种类包括：本地仓库、远程仓库【私服】和中央仓库。
  默认情况下，当我们启动一个Maven工程时，Maven工程会通过pom.xml文件中的jar包坐标去本地仓库找，若本地仓库没有，则去中央仓库找。中央仓库服务器在国外，国内访问不仅需要特殊处理，速度还慢。因此，基本上每家公司都会有自己专门的放置jar包的服务器，也叫做远程服务器或私服，通过配置私服的上传下载，当本地找不到jar包时，会去私服找，私服找不到才去中央仓库找。
  Maven自身集成了tomcat插件，可以对项目进行编译、打包、安装、发布等操作。
  Maven常用命令：clean、compile、test、package、install、deploy。
  Maven三套生命周期：清理、默认、站点。
  本章会通过一个Maven管理的SSM工程的例子来介绍Maven的分模块构建和私服搭建使用。

2、Maven创建SSM工程

2.1 数据库准备

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=9 DEFAULT CHARSET=utf8;

  随便放几条数据：
在这里插入图片描述

2.2 工程目录结构

在这里插入图片描述

2.2 源码

2.2.1 实体类

  Item：

package cn.klb.domain;

import java.util.Date;

/**
 * @Author: Konglibin
 * @Description:
 * @Date: Create in 2020/3/11 14:06
 * @Modified By:
 */
public class Item {
    private Integer id;
    private String name;
    private Float price;
    private String pic;
    private Date createtime;
    private String detail;

	// 省略set\get\toString的书写
}

2.2.2 持久层

  ItemDao：

package cn.klb.dao;

import cn.klb.domain.Item;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import org.springframework.stereotype.Repository;

/**
 * @Author: Konglibin
 * @Description:
 * @Date: Create in 2020/3/11 14:04
 * @Modified By:
 */
@Repository()
public interface ItemDao {
    /**
     * 根据用户名查找记录
     * @param name
     * @return
     */
    @Select("select * from items where name=#{name}")
    public Item findByName(String name);

    /**
     * 更新一条记录
     * @param item
     */
    @Update("update items set price = #{price} where name = #{name}")
    public void updateItem(Item item);
}

2.2.3 业务层

  ItemService：

package cn.klb.service;

import cn.klb.domain.Item;

/**
 * @Author: Konglibin
 * @Description:
 * @Date: Create in 2020/3/11 14:04
 * @Modified By:
 */
public interface ItemService {
    /**
     * 转账业务
     */
    public void transfer(String sourceName,String targetName,Float money);
}

  ItemServiceImpl：

package cn.klb.service.impl;

import cn.klb.dao.ItemDao;
import cn.klb.domain.Item;
import cn.klb.service.ItemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;


/**
 * @Author: Konglibin
 * @Description:
 * @Date: Create in 2020/3/11 14:04
 * @Modified By:
 */
@Service("itemService")
public class ItemServiceImpl implements ItemService {

    @Autowired
    private ItemDao itemDao;

    /**
     * 根据id查询一条记录
     *
     * @param id
     * @return
     */
    @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)//只读型事务的配置
    public Item findById(Integer id) {
        return itemDao.findById(id);
    }

    /**
     * 转账业务
     *
     * @param sourceName 发起方
     * @param targetName 接收方
     * @param money      转账金额
     * @return
     */
    //需要的是读写型事务配置
    @Override
    @Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = Exception.class)
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer...");
        //2.1根据名称查询转出账户
        Item source = itemDao.findByName(sourceName);
        //2.2根据名称查询转入账户
        Item target = itemDao.findByName(targetName);
        //2.3转出账户减钱
        source.setPrice(source.getPrice() - money);
        //2.4转入账户加钱
        target.setPrice(target.getPrice() + money);
        //2.5更新转出账户
        itemDao.updateItem(source);

		// 人为定义异常，测试事务是否配置成功
        //int i = 1 / 0;

        //2.6更新转入账户
        itemDao.updateItem(target);
    }
}

2.2.4 表现层

  ItemController：

package cn.klb.controller;

import cn.klb.domain.Item;
import cn.klb.service.ItemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;

/**
 * @Author: Konglibin
 * @Description:
 * @Date: Create in 2020/3/11 15:00
 * @Modified By:
 */
@Controller
@RequestMapping("/item")
public class ItemController {
    @Autowired
    private ItemService itemService;

    @RequestMapping("/transfer")
    public String transfer(HttpServletRequest request){
        String sourceName = request.getParameter("sourceName");
        String targetName = request.getParameter("targetName");
        String money = request.getParameter("money");
        itemService.transfer(sourceName,targetName,Float.parseFloat(money));
        return "success";
    }
}

  index.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
	<head>
	    <title>标题</title>
	</head>
	<body>
	    <form action="item/transfer" method="post">
	        甲方：<input type="text" name="sourceName"/>
	        乙方：<input type="text" name="targetName"/>
	        转账金额:<input type="text" name="money"/>
	        <input type="submit"/>
	    </form>
	</body>
</html>

  WEB-INF/pages/success.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
	<head>
	    <title>成功页面</title>
	</head>
	<body>
		<h3>转账成功！</h3>
	</body>
</html>

2.3 配置文件

2.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">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>ssm</artifactId>
  <version>1.0-SNAPSHOT</version>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
  <packaging>war</packaging>

  <!-- 统一管理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>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
  </dependencies>
</project>

2.3.2 springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
                        http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 扫描controller的注解，别的不扫描 -->
    <!--注意：若使用include-filter去定制扫描内容，要在use-default-filters="false"的情况下，不然会“失效”，被默认的过滤机制所覆盖-->
    <context:component-scan base-package="cn.klb" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 配置视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- JSP文件所在的目录 -->
        <property name="prefix" value="/WEB-INF/pages/"/>
        <!-- 文件的后缀名 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--开启SpringMVC注解的支持-->
    <mvc:annotation-driven/>
</beans>

2.3.3 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: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">

    <!-- spring框架配置 -->
    <!-- 开启注解扫描，要扫描的是service和dao层的注解，要忽略web层注解，因为web层让SpringMVC框架去管理 -->
    <context:component-scan base-package="cn.klb">
        <!-- 配置要忽略的注解 -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- mybatis框架配置 -->
    <!-- 配置扫描dao的包 -->
    <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="cn.klb.dao"/>
    </bean>

    <!-- 配置SqlSession的工厂 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 配置Spring JDBC的连接池对象 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///maven"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--配置Spring框架声明式事务管理-->
    <!-- spring中基于注解 的声明式事务控制配置步骤
        1、配置事务管理器
        2、开启spring对注解事务的支持
        3、在需要事务支持的地方使用@Transactional注解
     -->
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!-- 开启spring对注解事务的支持-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
</beans>

2.4 测试

  部署到Tomcat后，运行即可。
  可以在ItemServiceImpl.java文件中把transfer方法的人为异常加上，测试事务管理是否正常。

3、分模块构建工程

  上面的工程还能进一步拆分为多个模块开发：
在这里插入图片描述

3.1 继承和聚合

  继承是为了消除重复，如果将 dao、service、web 分开创建独立的工程则每个工程的 pom.xml文件中的内容存在重复，比如：设置编译版本、锁定 spring的版本的等，可以将这些重复的配置提取出来在父工程的 pom.xml 中定义。
  项目开发通常是分组分模块开发，每个模块开发完成要运行整个工程需要将每个模块聚合在一起运行，比如：dao、service、web 三个工程最终会打一个独立的war 运行。

3.2 案例实现

3.2.1 工程创建

  新建一个maven工程，删掉除了pom.xml的其他目录，然后新建3模块：ssm_dao、ssm_service、ssm_web。其中前面两个可以是普通java模块，ssm_web是web模块。
在这里插入图片描述
  至此，我们创建好了一个空工程，里面包含三个空模块。

3.2.2 填写父工程的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>org.example</groupId>
    <artifactId>ssm_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>ssm_dao</module>
        <module>ssm_service</module>
        <module>ssm_web</module>
    </modules>
    <packaging>pom</packaging>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <!-- 统一管理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>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

3.3.3 持久层模块

3.3.3.1 模块目录结构

  ItemDao.java：

3.3.3.2 源码

  Item.java和ItemDao.java内容复制即可。

3.3.3.3 配置文件

  首先是jar坐标的pom.xml，现在ssm_dao模块可以作为一个独立的模块，因此，导入的jar包只需要是这个模块必须的就行，去除掉业务层和表现层依赖jar包：

<?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>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ssm_dao</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <!--MySQL驱动jar包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <!--MyBatis框架jar包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>

        <!--MyBatis整合spring依赖jar包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>

        <!--阿里巴巴数据源jar包-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.9</version>
        </dependency>

        <!--Spring相关jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</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-aop</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-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</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-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>

</project>

  在Spring和Mybatis整合过程中，两者的配置文件合并成一个了，现在分模块构建，这两个配置文件又得分开，无需修改内容，只需要对上面案例的applicationContext.xml配置文件剪切即可，持久层配置文件为applicationContext-dao.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- mybatis框架配置 -->
    <!-- 配置扫描dao的包 -->
    <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="cn.klb.dao"/>
    </bean>

    <!-- 配置SqlSession的工厂 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 配置Spring JDBC的连接池对象 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///maven"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

</beans>

3.3.4 业务层模块

3.3.4.1 模块目录结构

在这里插入图片描述

3.3.4.2 源码

  赋值上面案例的ItemService.java和ItemServiceImpl.java即可。

3.3.4.3 配置文件

  现在业务层也是单独的一个模块，业务层直接依赖于持久层，根据业务的具体还直接依赖于其他的jar包，本案例是对上面案例的拆分，因此这里只直接依赖于持久层和spring框架。
  业务层的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>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ssm_service</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <!--dao层-->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>ssm_dao</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>

</project>

  业务层模块的Spring框架的配置文件也是从上面案例的合并配置文件进行剪切，得到applicationContext-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">

    <!-- spring框架配置 -->
    <!-- 开启注解扫描，要扫描的是service和dao层的注解，要忽略web层注解，因为web层让SpringMVC框架去管理 -->
    <context:component-scan base-package="cn.klb">
        <!-- 配置要忽略的注解 -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 配置Spring JDBC的连接池对象 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///maven"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--配置Spring框架声明式事务管理-->
    <!-- spring中基于注解 的声明式事务控制配置步骤
        1、配置事务管理器
        2、开启spring对注解事务的支持
        3、在需要事务支持的地方使用@Transactional注解
     -->
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!-- 开启spring对注解事务的支持-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

</beans>

3.3.5 表现层模块

3.3.5.1 模块目录结构

在这里插入图片描述

3.3.5.2 源码

  ItemController直接从上面案例复制即可。

3.3.5.3 配置文件

  很明显，这个案例中，表现层除了SpringMvc框架是直接依赖，就只剩下直接依赖于业务层，因此，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>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ssm_web</artifactId>
    <packaging>war</packaging>

    <build>
        <plugins>
            <!-- 设置编译版本为 1.8 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <path>/</path>
                    <port>8080</port>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <!--service层-->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>ssm_service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!--SpringMVC框架jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--Servlet-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

  上面的案例中，表现层的配置文件是单独存在，因此，直接复制：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
                        http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 扫描controller的注解，别的不扫描 -->
    <!--注意：若使用include-filter去定制扫描内容，要在use-default-filters="false"的情况下，不然会“失效”，被默认的过滤机制所覆盖-->
    <context:component-scan base-package="cn.klb" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 配置视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- JSP文件所在的目录 -->
        <property name="prefix" value="/WEB-INF/pages/"/>
        <!-- 文件的后缀名 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--开启SpringMVC注解的支持-->
    <mvc:annotation-driven/>

</beans>

3.3.6 测试

  测试有三种方式：
  1、从表现层的maven中配置tomcat插件启动；
  2、从父工程的maven中配置tomcat插件启动；
  3、单独配置tomcat，部署工程的war包进行启动。
  其中，第一种启动方式需要特别注意，表现层启动时，根据pom.xml依赖从本地仓库找对应的jar包，如果修改了表现层和持久层的代码，必须重新安装一次到本地仓库。
  推荐第二种和第三种，直接按照工程最新版本进行编译。

3.3 小结

  为什么要把第2节的工程重新构建成第3节的样子，有什么好处吗?
  好处很明显，当我们要构建一个工程的时候，往往不是一上来从0开始，即持久层+业务层+表现层。而是先看公司有没有做好的通用持久层jar包，我只需要依赖它，然后写业务层和表现层即可。第2节的案例除了复制代码别无其他复用的方法，第3节分模块构建，只需要依赖这个模块即可。

4、Maven私服

4.1 介绍

  公司在自己的局域网内搭建自己的远程仓库服务器，称为私服，私服服务器即是公司内部的 maven 远程仓库，每个员工的电脑上安装 maven 软件并且连接私服服务器，员工将自己开发的项目打成 jar 并发布到私服服务器，其它项目组从私服服务器下载所依赖的构件（jar）。
  私服还充当一个代理服务器，当私服上没有 jar 包会从互联网中央仓库自动下载，如下图：
在这里插入图片描述

4.2 搭建私服环境

4.2.1 下载nexus

  Nexus 是 Maven 仓库管理器，通过 nexus 可以搭建 maven 仓库，同时 nexus 还提供强大的仓库管理功能，构件搜索功能等。
  下载地址：https://pan.baidu.com/s/10ivJrvdMx0yChsBLwqa9DQ
  提取码：ahhw

4.2.2 安装并启动nexus

  下载后，解压到一个无中文无空格的路径下，进入bin目录，执行nexus.bat install命令，即可在服务中查看到nexus服务，选中服务右键启动即可。
在这里插入图片描述

4.2.3 配置文件

  在解压目录的nexus-2.12.0-01-bundle\nexus-2.12.0-01\conf文件夹有一个nexus.properties文件，是nexus的配置文件：

# Jetty section
application-port=8081		# nexus 的访问端口配置
application-host=0.0.0.0			# nexus 主机监听配置(不用修改)
nexus-webapp=${bundleBasedir}/nexus			# nexus 工程目录
nexus-webapp-context-path=/nexus			# nexus 的 web 访问路径

# Nexus section
nexus-work=${bundleBasedir}/../sonatype-work/nexus			# nexus 仓库目录
runtime=${bundleBasedir}/nexus/WEB-INF			# nexus 运行程序目录

  启动服务后，浏览器访问地址：http://localhost:8081/nexus/
在这里插入图片描述
  使用内置账户：admin/admin123 进行登陆.
在这里插入图片描述

4.3 仓库类型

  选择左侧的Repositories可以看到nexus的仓库：
在这里插入图片描述
  nexus仓库有4种类型：
  1、hosted：宿主仓库，部署自己的 jar 到这个类型的仓库，包括 releases 和 snapshot 两部分，Releases公司内部发布版本仓库、 Snapshots 公司内部测试版本仓库；
  2、proxy：代理仓库，用于代理远程的公共仓库，如 maven 中央仓库，用户连接私服，私服自动去中央仓库下载 jar 包或者插件；
  3、group：仓库组，用来合并多个 hosted/proxy 仓库，通常我们配置自己的 maven 连接仓库组；
  4、virtual：兼容 Maven1 版本的 jar 或者插件。
  nexus 仓库默认在 sonatype-work 目录中：
在这里插入图片描述

4.4 已有仓库

  1、Central：代理仓库，代理中央仓库。
在这里插入图片描述
  2、Apache-snapshots ：代理仓库，存储snapshots构件；
  3、Central-m1 ：virtual 类型仓库，兼容 Maven1 版本的 jar 或者插件；
  4、Releases ： 本地仓库，存储 releases 构件；
  5、Snapshots ： 本地仓库，存储 snapshots 构件；
  6、Thirdparty：第三方仓库；
  7、Public Repositories：仓库组。

5、将项目发布到私服

  企业中多个团队协作开发通常会将一些公用的组件、开发模块等发布到私服供其它团队或模块开发人员使用。
  本例子假设多团队分别开发 ssm_dao、ssm_service、ssm_web，某个团队开发完在ssm_dao会将 ssm_dao 发布到私服供 ssm_service团队使用，本例子会将 ssm_dao 工程打成jar 包发布到私服。
在这里插入图片描述

5.1 配置

  首先要理清楚这个流程，私服是在公司的服务器上，自己的maven工程在本地。于是，要配置maven上传的地址和下载的地址。
  打开自己本地的maven配置文件settings.xml，配置连接私服的用户和密码到servers标签中：

  <servers>
    <!-- server
     | Specifies the authentication information to use when connecting to a particular server, identified by
     | a unique name within the system (referred to by the 'id' attribute below).
     |
     | NOTE: You should either specify username/password OR privateKey/passphrase, since these pairings are
     |       used together.
     |
    <server>
      <id>deploymentRepo</id>
      <username>repouser</username>
      <password>repopwd</password>
    </server>
    -->

    <!-- Another sample, using keys to authenticate.
    <server>
      <id>siteServer</id>
      <privateKey>/path/to/private/key</privateKey>
      <passphrase>optional; leave empty if not used.</passphrase>
    </server>
    -->
	
	<server>
		<id>releases</id>
		<username>admin</username>
		<password>admin123</password>
	</server>
	
	<server>
		<id>snapshots</id>
		<username>admin</username>
		<password>admin123</password>
	</server>
	
  </servers>

  releases 连接发布版本项目仓库；
  snapshots 连接测试版本项目仓库。
在这里插入图片描述
  下一步是配置项目的pom.xml，project标签体中加入：

    <!--配置私服-->
    <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 这里<id> 和 settings.xml 配置 <id> 对应！
  maven的配置文件已经配置了私服的账号密码，pom.xml配置好了本项目要上传的私服地址。

5.2 测试

  将项目的dao模块打成jar包发布到私服。
  首先确认dao模块的打包方式为jar：
在这里插入图片描述
  选择maven的deploy指令，然后maven工程就会根据pom.xml配置的地址来决定把这个dao模块jar包发布到哪个仓库，如果dao模块的version定义为snapshot，就发布到snapshot仓库。本例程的version是1.0-SNAPSHOT。
在这里插入图片描述
  发布成功后，可以在私服仓库看到这个dao模块jar包。
在这里插入图片描述

6、从私服下载jar包

  默认情况下，maven编译项目时，先从本地仓库找jar包，如果没有，就去中央仓库。那么我们要把这个找jar包顺序改为：本地–>私服–>中央仓库，即私服找不到采取中央仓库。
  没有配置 nexus 之前，如果本地仓库没有，去中央仓库下载，通常在企业中会在局域网内部署一台私服服务器，有了私服本地项目首先去本地仓库找 jar，如果没有找到则连接私服从私服下载 jar 包，如果私服没有 jar 包私服同时作为代理服务器从中央仓库下载 jar 包，这样做的好处是一方面由私服对公司项目的依赖 jar 包统一管理，一方面提高下载速度，项目连接私服下载 jar 包的速度要比项目连接中央仓库的速度快的多。

6.1 配置

  还是修改maven的配置文件settings.xml，在prifiles标签体中加一个profile：

  <profiles>
	<!-- 下载jar包配置 -->
	<profile> 
		<!--profile的id -->
		<id>dev</id>
		<repositories>
			<!--仓库id，repositories可以配置多个仓库，保证id不重复 -->
			<repository> 
				<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>
		
		<!-- 插件仓库，maven的运行依赖插件，也需要从私服下载插件 -->
		<pluginRepositories> 
			<!-- 插件仓库的id不允许重复，如果重复后边配置会覆盖前边 -->
			<pluginRepository> 
				<id>public</id>
				<name>Public Repositories</name>
				<url>http://localhost:8081/nexus/content/groups/public/</url>
			</pluginRepository>
		</pluginRepositories>
	</profile>
	
  </profiles>

  案例的私服没有id为nexus的仓库，所以会去下面的仓库组找。
在这里插入图片描述

6.2 测试

  删除本地仓库的ssm_dao模块，然后运行ssm_web的tomcat插件。
在这里插入图片描述
  可见，配置成功，当本地仓库找不到ssm_dao，会去私服下载。

7、第三方jar安装和上传

  随便准备一个jar包，比如我准备一个fastjson-1.1.37.jar，放在了C盘根目录，我们要用这个jar包，可以直接复制到项目中，但如果交给maven管理，就不能这样了。

7.1 安装到本地仓库

  方式一：进入该jar包所在路径，运行以下命令：

mvn install:install-file -DgroupId=com.alibaba -DartifactId=fastjson -Dversion=1.1.37 -Dfile=fastjson-1.1.37.jar -Dpackaging=jar

  方式二：不进入jar包路径，运行以下命令:

mvn install:install-file -DgroupId=com.alibaba -DartifactId=fastjson -Dversion=1.1.37 -Dpackaging=jar -Dfile=C:\fastjson-1.1.37.jar

7.2 安装到私服

7.2.1 配置

  跟上面的案例很像，先在maven的配置文件settings.xml中的servers标签配置第三方登录信息：

  <servers>
	<server>
		<id>thirdparty</id>
		<username>admin</username>
		<password>admin123</password>
	</server>

	<!--省略其他server-->
  </servers>

7.2.2 上传

  配置好之后，运行以下命令即可上传到私服：
  方式一：进入jar包所在路径。

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

  方式二：不用进入jar包所在路径。

mvn deploy:deploy-file -DgroupId=com.alibaba -DartifactId=fastjson -Dversion=1.1.37 -Dpackaging=jar -Dfile=C:\fastjson-1.1.37.jar -Durl=http://localhost:8081/nexus/content/repositories/thirdparty/ -DrepositoryId=thirdparty

7.2.3 参数说明

  DgroupId 和 DartifactId 构成了该 jar 包在 pom.xml 的坐标，项目就是依靠这两个属性定位。自己起名字也行。
  Dfile 表示需要上传的 jar 包的绝对路径。
  Durl 私服上仓库的位置，打开 nexus——>repositories菜单，可以看到该路径。
  DrepositoryId 服务器的表示 id，在 nexus 的configuration 可以看到。
  Dversion 表示版本信息，

7.2.4 关于jar包准确的版本

  包的名字上一般会带版本号，如果没有那可以解压该包，会发现一个叫 MANIFEST.MF 的文件，这个文件就有描述该包的版本信息。
  比如 Specification-Version: 2.2 可以知道该包的版本了。
  上传成功后，在 nexus 界面点击3rd party 仓库可以看到这包。

学哥斌
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值