maven 聚合模块之间的依赖

转载

mob6454cc6328d1 2024-09-15 16:56:48

文章标签 maven 聚合模块之间的依赖 spring cloud User spring java 文章分类 架构后端开发

Maven聚合工程的搭建

前言
准备工作
搭建步骤

demo_parent
demo_commons

1.新建module
2.新建User.java

demo_model

1.新建module
2.修改pom.xml
3.新建Dao和Service(impl)
4.新建mapper

demo_web

1.新建module
2.新建application.properties
3.修改pom.xml
4.新建Controller
5.新建jsp

user_list.jsp
user_add.jsp
user_detail.jsp

6.DemoWebApplication
7.Working directory

启动

前言

今天简要讲一下maven聚合工程的搭建。我们将文章01.springboot集成mybatis与jsp中所写的代码进行拆分，改造成一个聚合工程来进行演示操作

准备工作

为了演示的方便我们将之前的项目规整一下，放到同一个项目空间去，如下图

maven 聚合模块之间的依赖_spring cloud

搭建步骤

按照计划，我们首先要新建一个父项目demo_parent管理依赖，然后根据之前的项目，我们拆分出demo_commons、demo_model、demo_web三个Module

demo_commons：主要存放实体类相关代码和一些工具类

demo_model：主要存放业务相关代码，比如Dao、Service以及mapper等

demo_web：这个就和视图有关了，主要存放Controller以及jsp页面

demo_parent

由于我们之前我们已经新建了一个Empty Project作为一个工作空间，所以我们这里的父项目demo_parent其实是一个Module

maven 聚合模块之间的依赖_maven 聚合模块之间的依赖_02

父项目主要用来管理依赖，所以除了pom.xml文件，其余的一律删除，具体的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.christy</groupId>
    <artifactId>demo_parent</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--properties标签 自定义属性-->
    <properties>
        <mybatis.springboot.version>2.1.4</mybatis.springboot.version>
        <mysql.version>5.1.40</mysql.version>
        <druid.version>1.2.5</druid.version>
        <jstl.version>1.2</jstl.version>
        <java.version>1.8</java.version>
    </properties>

    <!--继承springboot父项目-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
    </parent>

    <!--维护依赖版本号  注意:并不会导入依赖-->
    <dependencyManagement>
        <dependencies>
            <!--mybatis-springboot-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.springboot.version}</version>
            </dependency>

            <!--引入数据源-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>

            <!--引入mysql-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>

            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>jstl</artifactId>
                <version>${jstl.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

demo_commons

1.新建module

父项目创建好以后，我们新建module，填写信息如下

maven 聚合模块之间的依赖_User_03

父项目记得选择demo_parent，将demo_commons放在父项目的目录下面，最后点击finish即可

2.新建User.java

上面们说了demo_commons作为公共模块主要放一些工具类和实体类，我们这里就只有一个实体类User.java，代码如下：

package com.christy.entity;

/**
 * @Author Christy
 * @Date 2021/5/20 11:42
 **/
public class User {
    private Integer id;
    private String name;
    private Integer age;
    private Double salary;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public User() {
    }

    public User(Integer id, String name, Integer age, Double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
}

demo_model

1.新建module

maven 聚合模块之间的依赖_maven 聚合模块之间的依赖_04

2.修改pom.xml

上面我们说过demo_module主要放业务相关的代码，诸如Dao，Service和Mapper等，并且依赖于demo_commons中的实体类，所以我们的model模块的依赖应该像下面这样

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

    <groupId>com.christy</groupId>
    <artifactId>demo_model</artifactId>

    <dependencies>
        <!--引入commons-->
        <dependency>
            <groupId>com.christy</groupId>
            <artifactId>demo_commons</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>


        <!--引入web依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--引入mybatis和springboot整合-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>

        <!--引入数据源-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>

        <!--引入mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>
</project>

3.新建Dao和Service(impl)

这里我们直接将springboot_mybatis_jsp项目中的代码拿过来用就行了

package com.christy.dao;

import com.christy.entity.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * @Author Christy
 * @Date 2021/5/13 9:27
 **/
@Mapper
public interface UserDao {

    /**
     * 查询所有
     * @author Christy
     * @date 2021/5/13 9:38
     * @param 
     * @return java.util.List<com.christy.model.entity.User>
     */
    List<User> findAll();

    /**
     * 添加用户信息
     * @author Christy
     * @date 2021/5/13 9:38
     * @param user
     * @return 
     */
    void save(User user);

    /**
     * 根据id查询用户
     * @author Christy
     * @date 2021/5/13 9:39
     * @param id
     * @return com.christy.model.entity.User
     */
    User findById(Integer id);

    /**
     * 修改用户信息
     * @author Christy
     * @date 2021/5/13 9:39
     * @param user
     * @return void
     */
    void update(User user);

    /**
     * 根据id删除用户
     * @author Christy
     * @date 2021/5/13 9:39
     * @param id
     * @return void
     */
    void deleteById(Integer id);
}

package com.christy.service;

import com.christy.entity.User;
import java.util.List;

/**
 * @Author Christy
 * @Date 2021/5/13 9:40
 **/
public interface UserService {
    
    /**
     * 查询所有用户
     * @author Christy
     * @date 2021/5/13 9:41
     * @param 
     * @return java.util.List<com.christy.model.entity.User>
     */
    List<User> findAll();

    /**
     * 保存用户信息
     * @author Christy
     * @date 2021/5/13 9:42
     * @param user
     * @return void
     */
    void save(User user);

    /**
     * 根据id查询用户
     * @author Christy
     * @date 2021/5/13 9:42
     * @param id
     * @return com.christy.model.entity.User
     */
    User findById(Integer id);

    /**
     * 修改用户信息
     * @author Christy
     * @date 2021/5/13 9:42
     * @param user
     * @return void
     */
    void update(User user);
    
    /**
     * 根据id删除用户
     * @author Christy
     * @date 2021/5/13 9:42
     * @param id
     * @return void
     */
    void deleteById(Integer id);
}

package com.christy.service.impl;

import com.christy.dao.UserDao;
import com.christy.entity.User;
import com.christy.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @Component注解 在工厂中创建对象
 * @Controller @Service @Repository都继承自@Component注解，
 * 该三个注解将三层Controller,Service,Dao区别开来，其余地方如需要创建对象需要用Component
 *
 * @Transactional
 * 修饰范围：
 *      类：代表类中所有方法加入事务
 *      方法： 代表当前方法加入事务
 * propagation： 事务的传播属性 是指发生在多个业务层之间的事务传递
 *      默认值：REQUIRED 需要事务，如果外部存在事务则融入事务，没有则开启事务
 *      REQUIRED_NEW：需要新事物 外部存在事务则事务挂起，自己创建新的事务 内部事务运行结束外部事物恢复（该传播属性常用于记录业务操作日志）
 *      SUPPORTS：支持事务，外部存在事务则融入事务，没有也不开启
 *          那么问题来了，查询方法上有必要加@Transactional(propagation = Propagation.SUPPORTS)?
 *          答：有必要。
 *          举例：A.save(){ B.find*(){ C.update() }},这是个典型的A调用B,B调用C。对于A和C都是需要事务的，事务的传播属性都是默认值REQUIRED，
 *          如果此时B没有加事务，则A的事务无法传递到C，此时C的传播属性因为是默认的REQUIRED，所以C会开启一个新的事务。这时A和C分别处于不同的事务中
 *
 * @author Christy
 * @date 2021/5/13 10:04
 **/
@Service // 通知springboot扫描该注解 用来在工厂中创建对象
@Transactional  // 控制事务 修饰范围： 类 方法
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;

    @Override
    @Transactional(propagation = Propagation.SUPPORTS)  // propagation: 事务的传播属性
    public List<User> findAll() {
        return userDao.findAll();
    }

    @Override
    public void save(User user) {
        userDao.save(user);
    }

    @Override
    public User findById(Integer id) {
        return userDao.findById(id);
    }

    @Override
    public void update(User user) {
        userDao.update(user);
    }

    @Override
    public void deleteById(Integer id) {
        userDao.deleteById(id);
    }
}

4.新建mapper

<?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.christy.dao.UserDao">


    <!--findAll-->
    <select id="findAll" resultType="com.christy.entity.User">
        select id,name,age,salary from t_user
    </select>

    <!--save 采用数据库自动生成(useGeneratedKeys="true")并返回主键的值(keyProperty保存主键的属性名)-->
    <insert id="save" parameterType="com.christy.entity.User" useGeneratedKeys="true" keyProperty="id" >
        insert into t_user values(#{id},#{name},#{age},#{salary})
    </insert>

    <!--findById-->
    <select id="findById" parameterType="Integer" resultType="com.christy.entity.User">
        select id,name,age,salary from t_user where id = #{id}
    </select>

    <!--update-->
    <update id="update" parameterType="com.christy.entity.User">
        update t_user
        set
            name=#{name},
            age=#{age},
            salary=#{salary}
        where id = #{id}
    </update>

    <!--deleteById-->
    <select id="deleteById" parameterType="Integer" >
        delete from t_user where id = #{id}
    </select>
</mapper>

上面的工作做完之后就是下面这个熊样子，不报错就可以了

maven 聚合模块之间的依赖_spring_05

demo_web

1.新建module

maven 聚合模块之间的依赖_spring cloud_06

2.新建application.properties

server.port=8899
# 开启jso的自动编译
server.servlet.jsp.init-parameters.development=true

# 配置视图解析器
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

# 编写mybatis相关配置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/christy?characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=123456


# 创建这个目录一定要使用 "/"
mybatis.mapper-locations=classpath:com/christy/mapper/*.xml
# 指定别名
mybatis.type-aliases-package=com.christy.entity

# 开启日志 日志级别: off > error > warn > info > debug > all 级别越高日志越少
# springboot默认日志级别info
logging.level.com.christy=debug

3.修改pom.xml

demo_web同样要依赖demo_commons模块，除此之外该需要通过该模块访问jsp页面，所以要加上jstl和tomcat解析jsp的jar包jasper，完整的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>demo_parent</artifactId>
        <groupId>com.christy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>demo_web</artifactId>

    <dependencies>
        <!--依赖model-->
        <dependency>
            <groupId>com.christy</groupId>
            <artifactId>demo_model</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!--jstl-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>

        <!--tomcat解析jsp-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
    </dependencies>
</project>

4.新建Controller

我们直接将springboot_mybatis_jsp项目中的UserController拿过来用

import com.christy.entity.User;
import com.christy.service.UserService;
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 javax.servlet.http.HttpServletRequest;
import java.util.List;

/**
 * @Author Christy
 * @Date 2021/5/13 9:41
 **/
@Controller
@RequestMapping("user")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 查询所有
     * @author Christy
     * @date 2021/5/13 10:48
     * @param request
     * @param model
     * @return java.lang.String
     */
    @RequestMapping("findAll")
    public String findAll(HttpServletRequest request, Model model){
        List<User> users = userService.findAll();
        //保存到作用域
        model.addAttribute("users",users);
        return "user_list";
    }

    /**
     * 添加用户
     * @author Christy
     * @date 2021/5/13 10:49
     * @param name
     * @param user
     * @return java.lang.String
     */
    @RequestMapping("save")
    public String save(String name,User user){
        userService.save(user);
        return "redirect:/user/findAll";
    }

    /**
     * 查询用户
     * @author Christy
     * @date 2021/5/13 10:49
     * @param id
     * @param model
     * @return java.lang.String
     */
    @RequestMapping("findById")
    public String findById(Integer id,Model model){
        User user = userService.findById(id);
        model.addAttribute("user",user);
        return "user_detail";
    }

    /**
     * 修改用户信息
     * @author Christy
     * @date 2021/5/13 10:50
     * @param user
     * @return java.lang.String
     */
    @RequestMapping("update")
    public String update(User user){
        userService.update(user);
        return "redirect:/user/findAll";
    }

    /**
     * 删除一个用户
     * @author Christy
     * @date 2021/5/13 10:50
     * @param id
     * @return java.lang.String
     */
    @RequestMapping("deleteById")
    public String deleteById(Integer id){
        userService.deleteById(id);
        return "redirect:/user/findAll";
    }
}

5.新建jsp

user_list.jsp

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@page pageEncoding="UTF-8" contentType="text/html; UTF-8" isELIgnored="false"  %>
<!doctype html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport"
              content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>用户列表</title>
    </head>

    <body>
        <c:forEach items="${requestScope.users}" var="user" >
            id:${user.id} name:${user.name} age:${user.age} salary:${user.salary}
            <a href="${pageContext.request.contextPath}/user/deleteById?id=${user.id}">删除</a>
            <a href="${pageContext.request.contextPath}/user/findById?id=${user.id}">修改</a> <br>
        </c:forEach>

        <a href="${pageContext.request.contextPath}/user_add.jsp">添加</a>
    </body>
</html>

user_add.jsp

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@page pageEncoding="UTF-8" contentType="text/html; UTF-8" isELIgnored="false"  %>
<!doctype html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport"
              content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>保存用户信息</title>
    </head>

    <body>
        <form action="${pageContext.request.contextPath}/user/save" enctype="application/x-www-form-urlencoded" method="post">
            姓名: <input type="text" name="name"> <br>
            年龄: <input type="text" name="age"> <br>
            工资: <input type="text" name="salary"> <br>

            <input type="submit" value="保存用户信息">
        </form>
    </body>
</html>

user_detail.jsp

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@page pageEncoding="UTF-8" contentType="text/html; UTF-8" isELIgnored="false"  %>
<!doctype html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport"
              content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>修改用户信息</title>
    </head>

    <body>
        <form action="${pageContext.request.contextPath}/user/update" method="post">
            Id : <input type="text" readonly name="id" value="${requestScope.user.id}"> <br>
            姓名: <input type="text" name="name" value="${requestScope.user.name}"> <br>
            年龄: <input type="text" name="age" value="${requestScope.user.age}"> <br>
            工资: <input type="text" name="salary" value="${requestScope.user.salary}"> <br>

            <input type="submit" value="修改用户信息">
        </form>
    </body>
</html>

6.DemoWebApplication

启动类不要忘了

package com.christy;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @Author Christy
 * @Date 2021/5/20 14:27
 **/
@SpringBootApplication
public class DemoWebApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoWebApplication.class,args);
    }
}

7.Working directory

由于我们使用的是jsp，最后别忘记配置工作目录为当前目录，否则无法访问到jsp页面

maven 聚合模块之间的依赖_User_07

启动

以上工作都做完以后就可以启动我们的聚合项目了，浏览器输入http://localhost:8899/user/findAll，结果如下

maven 聚合模块之间的依赖_spring_08

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：session有必要用redis吗

下一篇：java list lamada分组求和

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯