风靡商城项目搭建

一、风靡商城项目搭建

基于maven的聚合工程完成项目搭建

• 前端采用vue+axios
• 后端采用springboot整合SSM

1.1技术储备

• springboot：实现无配置的SSM整合
• Maven聚合工程：实现模块的复用

1.2项目搭建

• 创建聚合工程
• 基于springboot整合SSM

1.3Maven聚合工程

1.3.1构建父工程

• common——进行公共类的定义（Vo返还给前端）
• beans——实体类
• mapper——对数据库进行操作，创建dao
• service——对业务进行处理
• api——相当于controller对外提供的接口，应用程序接口 在父工程中添加代码 <packaging>pom</packaging>

1.3.2构建子工程

创建springboot子项目

将创建的springboot的api换成子工程 pom.xml（api）

<modelVersion>4.0.0</modelVersion>
<parent>
    <groupId>com.qfedu</groupId>
    <artifactId>fmmall</artifactId>
    <version>2.0.1</version>
</parent>
<artifactId>api</artifactId>

父工程中引入子工程的依赖

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.7.10</version>
  <relativePath/> <!-- lookup parent from repository -->
</parent>

<module>api</module>

api继承fmmall，fmmall继承springboot

1.3.3创建步骤总结

• 创建父工程（fmmall）创建一个maven工程、packing设置为pom，父工程继承spring-boot-starter-parent

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.10</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.qfedu</groupId>
    <artifactId>fmall</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
        <module>common</module>
        <module>beans</module>
        <module>mapper</module>
        <module>service</module>
        <module>api</module>
    </modules>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

</project>

• 创建common子工程（beans、mapper、service等同）
  • 选择fmmall，右键——New——Moudle（Maven工程）
  • 修改common的pom.xml文件，设置packing=jar

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.qfedu</groupId>
        <artifactId>fmmall</artifactId>
        <version>2.0.1</version>
    </parent>
    <artifactId>common</artifactId>
    <packaging>jar</packaging>
    <name>Archetype - common</name>
    <url>http://maven.apache.org</url>
</project>

• 创建beans子工程（beans、mapper、service等同）
  • 选择fmmall，右键——New——Moudle（Maven工程）
  • 修改beans的pom.xml文件，设置packing=jar
• 创建mapper子工程（beans、mapper、service等同）
  • 选择fmmall，右键——New——Moudle（Maven工程）
  • 修改mapper的pom.xml文件，设置packing=jar
  • 在mapper的pom.xml，依赖beans

<dependencies>
    <dependency>
        <groupId>com.qfedu</groupId>
        <artifactId>beans</artifactId>
        <version>2.0.1</version>
    </dependency>
</dependencies>

• 创建servicen子工程（beans、mapper、service等同）
  • 选择fmmall，右键——New——Moudle（Maven工程）
  • 修改service的pom.xml文件，设置packing=jar
  • 在service的pom.xml，依赖mapper、common（用户加密）

<dependencies>
   <dependency>
       <groupId>com.qfedu</groupId>
       <artifactId>beans</artifactId>
       <version>2.0.1</version>
   </dependency>
   <dependency>
       <groupId>com.qfedu</groupId>
       <artifactId>common</artifactId>
       <version>2.0.1</version>
   </dependency>
</dependencies>

• 创建api工程
  • 选择fmmall，右键——New——Moudle（SpringBoot工程）
  • 修改api的pom.xml，继承fmmall，删除自己的groupId和version
  • 将springboot的依赖配置到父工程（fmmall）pom.xml中
  • 在父工程fmmall的pom.xml的moudles中添加api moudle
  • 在api中依赖service 修改api的pom.xml

<parent>
    <groupId>com.qfedu</groupId>
    <artifactId>fmmall</artifactId>
    <version>2.0.1</version>
</parent>

修改api的pom.xml，继承fmmall，删除自己的groupId和version

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
<!--  api中需要依赖的条件-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.10</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <groupId>com.qfedu</groupId>
  <artifactId>fmmall</artifactId>
  <version>2.0.1</version>
  <packaging>pom</packaging>
  <name>Archetype - fmmall</name>
  <url>http://maven.apache.org</url>
  <modules>
    <module>common</module>
    <module>beans</module>
    <module>mapper</module>
    <module>service</module>
    <module>api</module>
  </modules>
</project>

将springboot的依赖配置到父工程（fmmall）pom.xml中，添加api

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
<!--  api中需要依赖的条件-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.10</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <groupId>com.qfedu</groupId>
  <artifactId>fmmall</artifactId>
  <version>2.0.1</version>
  <packaging>pom</packaging>
  <name>Archetype - fmmall</name>
  <url>http://maven.apache.org</url>
  <modules>
    <module>common</module>
    <module>beans</module>
    <module>mapper</module>
    <module>service</module>
    <module>api</module>
  </modules>
  <properties>
    <java.version>1.8</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <excludes>
            <exclude>
              <groupId>org.projectlombok</groupId>
              <artifactId>lombok</artifactId>
            </exclude>
          </excludes>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

在api中依赖service

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.qfedu</groupId>
        <artifactId>fmmall</artifactId>
        <version>2.0.1</version>
    </parent>
    <artifactId>api</artifactId>
    <dependencies>
        <dependency>
            <groupId>com.qfedu</groupId>
            <artifactId>service</artifactId>
            <version>2.0.1</version>
        </dependency>
    </dependencies>
</project>

1.3.4聚合工程的依赖分析

如果将依赖添加到父工程的pom中，根据依赖的继承关系，所有的子工程都会继承父工程的依赖：

• 好处：当有多个子工程都需要相同的依赖时，无需在子工程中重复添加依赖
• 缺点：如果某些子工程不需要这些依赖时，还是会被强行继承

如果在父工程中没有添加统一的依赖，则需要在每个子工程的pom中自行添加所需要的依赖 如果存在多个子工程需要添加相同的依赖，则需要在父工程pom中进行依赖版本管理

<!--  在父工程中定义版本，以使子工程中的依赖版本保持一致-->
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.16</version>
        <optional>true</optional>
      </dependency>
    </dependencies>
  </dependencyManagement>

说明： 方案一：我们可以在父工程的pom文件中一次性添加各个工程所需的所有依赖

方案二：在各个子工程中单独添加当前子工程的依赖

1.3.5Maven依赖配置

1.3.5.1common子工程

• lombok

1.3.5.2bean子工程

• lombok

1.3.5.1mapper子工程-MyBatis整合

• 在mapper子工程的pom文件新增mybatis所需的依赖

 <dependencies>
       <!--  beans-->
        <dependency>
            <groupId>com.qfedu</groupId>
            <artifactId>beans</artifactId>
            <version>2.0.1</version>
        </dependency>
<!--        mysql-->
        <!-- https://mvnrepository.com/artifact/com.mysql/mysql-connector-j -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>8.0.32</version>

        </dependency>

        <!--        spring-boot-starter-->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>3.0.4</version>
        </dependency>

        <!--        mybatis-spring-boot-starter-->
        <!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>
    </dependencies>

• 在mapper子工程的resources目录创建application.yml

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db_2010_mybatis?characterEncoding=utf-8
    username: root
    password: root
mybatis:
  mapper-locations: classpath:mappers/*Mapper.xml
  type-aliases-package: com.qfedu.fmmall.entity
#    以上配置数据库,配置别名和mapper文件和别名类（）写在beans中

• 在api子工程的启动类ApiApplication通过@MapperScan声明dao包的路径，dao写在mapper项目中

package com.qfedu;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.qfedu.fmmall.dao")
public class ApiApplication {
    public static void main(String[] args) {
        SpringApplication.run( ApiApplication.class, args );
    }
}

注意命名规则：扫描的时候一定要包括entity和dao包；启动启动类会扫描到com.qfedu以及其下的所有子包

1.3.6SpringBoot单元测试

以通过用户名查找用户为例

• 在beans中创建user实体类

package com.qfedu.fmmall.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int userId;
    private String userName;
    private String userRealname;
    private String userImg;
}

• 在mapper中创建UserDAO

package com.qfedu.fmmall.dao;

import com.qfedu.fmmall.entity.User;

public interface UserDAO {
//    根据用户名字查询用户
    public User queryUserByName(String name);

}

• 在mapper中的resources中新建mappers包，创建UserMapper.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.qfedu.fmmall.dao.UserDAO">
    <!--namespace根据自己需要创建的的mapper的路径和名称填写-->
<!--   mapper映射用户信息-->
   <resultMap id="userMap" type="com.qfedu.fmmall.entity.User">
      <id column="user_id" property="userId"></id>
      <result column="user_name" property="userName"></result>
      <result column="user_realname" property="userRealname"></result>
      <result column="user_img" property="userImg"></result>

   </resultMap>
<!--   根据用户姓名查询用户，注意需要同时包含数据库和user中的成员名-->
   <select id="queryUserByName" resultType="com.qfedu.fmmall.entity.User">
      select user_id AS userId,user_name AS userName,user_realname AS userRealname,user_img AS userImg
      from users
      where user_name=#{name}
   </select>
</mapper>

• 在api的test中创建com.qfedu.fmmall.dao包，在包中创建UserDAOTest
  • Alt+Insert选择test再选择JUnit4，进行Junit测试
  • 导入JUnit的包，创建测试类

package com.qfedu.fmmall.dao;

import com.qfedu.ApiApplication;
import com.qfedu.fmmall.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;


@RunWith( SpringRunner.class )
@SpringBootTest(classes = ApiApplication.class)
public class UserDAOTest {
    @Resource//注入dao对象
    private UserDAO userDAO;

    @Test//引入Junit测试，导入其包
    public void queryUserByName() {
        User user = userDAO.queryUserByName("Lucy");
        System.out.println(user);
    }
}

• 添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <scope>test</scope>
</dependency>

为了使其初始化成功，则需要将UserDAOTest放在api中，因为该项目需要通过启动类加载配置（启动类在api中），因此单元测试统一放到API中，依赖也放到API中

1.4整合Druid

• 在mapper子工程添加druid-starter 放到mapper的pom.xml中

<!-- https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.8</version>
</dependency>

• 在application.yml中修改druid配置

spring:
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/db_2010_mybatis?characterEncoding=utf-8
      username: root
      password: root
mybatis:
  mapper-locations: classpath:mappers/*Mapper.xml
  type-aliases-package: com.qfedu.fmmall.entity
#    以上配置数据库,配置别名和mapper文件和别名类（）写在beans中

1.5项目整合测试

1.5.1 在beans中创建User

package com.qfedu.fmall.entity;


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@AllArgsConstructor
@NoArgsConstructor
@Data

public class User {
    private int userId;
    private String userName;
    private String userPwd;
    private String userRealname;
    private String userImg;


}

1.5.2 在mapper中创建UserDAO

package com.qfedu.fmall.dao;

import com.qfedu.fmall.entity.User;

public interface UserDAO {

    public User queryUserByName(String name);
}

在mapper中的resources下创建mappers，在mappers中创建UserMapper.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.qfedu.fmall.dao.UserDAO">
   <!--namespace根据自己需要创建的的mapper的路径和名称填写-->
   <!--   mapper映射用户信息-->
   <resultMap id="userMap" type="com.qfedu.fmall.entity.User">
      <id column="user_id" property="userId"></id>
      <result column="user_name" property="userName"></result>
      <result column="user_pwd" property="userPwd"></result>
      <result column="user_realname" property="userRealname"></result>
      <result column="user_img" property="userImg"></result>

   </resultMap>


   <!--   根据用户姓名查询用户-->
   <select id="queryUserByName" resultType="com.qfedu.fmall.entity.User">
      select user_id AS userId,user_name AS userName,user_pwd AS userPwd,user_realname AS userRealname,user_img AS userImg
      from users
      where user_name=#{name}
   </select>
</mapper>

1.5.3 在service中创建UserService

package com.qfedu.fmall.service;

import com.qfedu.fmall.entity.User;
import com.qfedu.fmall.vo.ResultVO;

public interface UserService {
    public ResultVO checkLogin(String name, String pwd);
}

在service中创建impl包，创建UserServiceImpl

package com.qfedu.fmall.service.impl;

import com.qfedu.fmall.dao.UserDAO;
import com.qfedu.fmall.entity.User;
import com.qfedu.fmall.service.UserService;
import com.qfedu.fmall.vo.ResultVO;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class UserServiceImpl implements UserService {
    //注入userDAo
    @Resource
    private UserDAO userDAO;
    @Override
    public ResultVO checkLogin(String name, String pwd) {
        //根据账号查询用户信息
        User user = userDAO.queryUserByName( name );
        //判断
        if(user == null ){
            //用户名不存在
            return new ResultVO(10001,"用户不存在",null);
        }else{
            //对输入的密码pwd进行加密
            //使用加密后的密码和user中的密码进行匹配
            if (user.getUserPwd().equals( pwd )){
                //验证成功
                return new ResultVO(10000,"登录成功",null);
            }else {
                //密码错误
                return new ResultVO(10001,"密码错误",null);
            }
        }

    }
}

1.5.4 在common中创建ResultVO

package com.qfedu.fmall.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@AllArgsConstructor
@NoArgsConstructor
@Data
public class ResultVO {
    //响应给前端的状态码
    private int code;
    //响应给前端的提示信息
    private String msg;
    //响应给前端的数据
    private Object data;
}

1.5.5 在api中创建UserController

package com.qfedu.controller;

import com.qfedu.fmall.service.UserService;
import com.qfedu.fmall.vo.ResultVO;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;

@Controller
@ResponseBody
@RequestMapping("/user")

public class UserController {
    @Resource
    private UserService userService;
    @RequestMapping("/login")
    public ResultVO login(String name,String pwd){
        return userService.checkLogin( name,pwd );

    }

}

在api的启动类中添加如下信息

package com.qfedu;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@MapperScan("com.qfedu.fmall.dao")
@SpringBootApplication
public class ApiApplication {

    public static void main(String[] args) {
        SpringApplication.run( ApiApplication.class, args );
    }

}