从零开始做：SSM分模块构建案例-显示所有订单

1.第一步：前期准备

1.1建数据库和表

CREATE DATABASE maven_adv;

-- 创建用户表 用户名
CREATE TABLE `user` (
     uid INT PRIMARY KEY AUTO_INCREMENT,
     `name` VARCHAR(20) NOT NULL,
     sex CHAR(1) DEFAULT '男',
     phone VARCHAR(20)
);

插入初始数据

INSERT INTO `user` (`name`,sex,phone) VALUES 
('张小敏','女','13923454567'), 
('李强','男','18712321234'),
('邹家俊','男','16233425678');

建订单表order

-- 订单表
CREATE TABLE `order` (
    oid INT PRIMARY KEY AUTO_INCREMENT,
    address VARCHAR(100) COMMENT '订单地址',
    total DOUBLE COMMENT '金额',
    uid INT,
    FOREIGN KEY(uid) REFERENCES `user`(uid)
);

插入初始数据

- 一个用户下多个订单
INSERT INTO `order` (address,total,uid) VALUES 
('广东省汕头市', 3200,1),
('湖南省株洲市', 250,1),
('广西省柳州市', 1200,2),
('广州市海珠区', 78,2),
('海南省海口市', 605,3);

2.建maven父子工程

 3.在父模块中导包，并约定包的版本号

<?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.itheima</groupId>
    <artifactId>day36-ssm-parent</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>ssm-entity</module>
        <module>ssm-dao</module>
        <module>ssm-service</module>
        <module>ssm-web</module>
    </modules>

    <!--统一管理依赖包版本-->
    <properties>
        <!-- 指定编码 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <!--spring 版本-->
        <spring.version>5.2.10.RELEASE</spring.version>
        <!-- log4j日志包版本 -->
        <slf4j.version>1.7.7</slf4j.version>
        <!--servlet版本-->
        <servlet.version>3.1.0</servlet.version>
        <!-- mybatis版本号 -->
        <mybatis.version>3.5.5</mybatis.version>
        <!--mysql驱动版本,这里5.几的版本和8.几的版本配置不一样-->
        <mysql.version>8.0.22</mysql.version>
        <!-- mybatis-spring整合包版本 -->
        <mybatis.spring.version>1.3.1</mybatis.spring.version>
        <!--druid版本-->
        <druid.version>1.0.29</druid.version>
        <!-- aspectj版本号 -->
        <aspectj.version>1.6.12</aspectj.version>
        <!--json-->
        <jackson.version>2.9.8</jackson.version>
        <!--lombok-->
        <lombok.version>1.18.6</lombok.version>
        <!-- junit -->
        <junit.version>4.13</junit.version>
    </properties>

    <dependencies>
        <!--spring依赖包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- spring mvc包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--spring jdbc包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--aspectj包-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectj.version}</version>
        </dependency>
        <!--servlet依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${servlet.version}</version>
        </dependency>
        <!-- mybatis核心包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
        <!-- mybatis-spring整合包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>${mybatis.spring.version}</version>
        </dependency>
        <!-- mysql数据库依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!--数据库连接池druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <!-- log4j包 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!--json包-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
        <!--spring-test测试包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

</project>

4.第四步：在实体类中建两个实体类

由于其不需要依赖谁，使用直接使用父模块里面的包即可，系统会自动建立关系

User类：

@Data
public class User {
    private Integer uid;
    private String name;
    private char sex;
    private String phone;
}

Order类：

@Data
public class Order {
    private Integer oid;
    private String address;
    private Double total;
    private User user;  //包含了用户对象，查询订单对象，可以获取到用户对象的属性
}

5.第五步：在dao模块中编写实体类以及对应的SQL语句方法，用于访问数据库。

public interface OrderDao {

    /**
     * 查询用户和订单
     * @param address 模糊查询地址
     * 1. 多个参数要加别名
     * 2. 如果在if等动态sql标签中引用了变量名字，也需要添加别名
     */
    List<Order> findUserAndOrder(@Param("address") String address);
}

用xml配置来写SQL语句(简单SQL用注解方式写就行，复杂SQL语句要用到xml配置来写)

 注意：此处建包是com/itheima/dao，不是用点隔开，否则建包不成功。

<?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.itheima.dao.OrderDao">

    <!-- 订单映射 -->
    <resultMap id="orderMap" type="com.itheima.entity.Order" autoMapping="true">
        <!-- 主键配置 -->
        <id column="oid" property="oid"/>
        <!-- 一对一关联映射 -->
        <association property="user" resultMap="userMap"/>
    </resultMap>

    <!-- 用户映射 -->
    <resultMap id="userMap" type="com.itheima.entity.User" autoMapping="true"/>

    <!-- 查询结果是订单映射，而不是实体类 -->
    <select id="findUserAndOrder" resultMap="orderMap">
        SELECT * FROM `user` u INNER JOIN `order` o ON u.uid = o.uid
        <if test="address!=null and address!=''">
            WHERE address LIKE "%"#{address}"%"
        </if>
    </select>
</mapper>

在依赖包里面添加其对实体类的依赖

<dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>ssm-entity</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

6.第六步：在service模块中编写相关配置

6.1建如下框架：

6.2导依赖包：

在pom.xml配置文件中添加：service对dao的依赖

 <!-- 导入dao -->
    <dependencies>
        <dependency>
            <groupId>com.itheima</groupId>
            <artifactId>ssm-dao</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

6.3编写comfig里面的三个配置类：jdbcConfig用于链接数据库，MybatisConfig用于Spring整合Mybatis,以及SpringConfig主配置类（以后这些都是固定不变的，因此在接下来的项目，这些都是直接拿来使用了。最多修改一下其上面的注解。）

jdbcConfig类：

@PropertySource("classpath:jdbc.properties")  //加载属性文件
public class JdbcConfig {

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.driverClassName}")
    private String driverClassName;

    /**
     * 创建数据源，放到容器中
     */
    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driverClassName);
        return dataSource;
    }

    /**
     * 创建事务管理器
     */
    @Bean
    public DataSourceTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

 MybatisConfig类：

/**
 * mybatis的配置文件
 */
public class MybatisConfig {

    /**
     * 创建会话工厂
     */
    @Bean
    public SqlSessionFactoryBean sessionFactoryBean(DataSource dataSource) {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        //注入数据源
        factoryBean.setDataSource(dataSource);
        //定义别名
        factoryBean.setTypeAliasesPackage("com.itheima.entity");
        //显示查询的SQL语句
        Configuration configuration = new Configuration();  //创建一个配置对象
        configuration.setLogImpl(StdOutImpl.class);  //在控制台显示SQL语句
        configuration.setMapUnderscoreToCamelCase(true);  //开启下划线列名映射成实体类中驼峰命名
        factoryBean.setConfiguration(configuration);
        return factoryBean;
    }

    /**
     * 创建映射扫描，扫描DAO基包
     */
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer configurer = new MapperScannerConfigurer();
        configurer.setBasePackage("com.itheima.dao");
        return configurer;
    }
}

SpringConfig主配置类：

/**
 * Spring的配置文件
 */
@Configuration
@ComponentScan("com.itheima.service")   //只扫描业务层
//整合mybatis，需要导入其它的两个配置文件
@Import({JdbcConfig.class, MybatisConfig.class})
@EnableTransactionManagement  //开启事务管理
public class SpringConfig {
}

6.4：在resources下导入两个源文件配置：（之前多次使用，其实复制粘贴进来就可以）

jdbc.properties

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql:///maven_adv?serverTimezone=UTC
jdbc.username=root
jdbc.password=root

log4j.properties（用以对log4j的日志的支持）

# 全局的日志级别，输出到控制台
log4j.rootLogger=info, stdout

# Spring框架中的日志级别为info
log4j.category.org.springframework=info
# dao包中的日志级别为debug
log4j.category.com.itheima.dao=debug

# 输出到控制台的日志格式
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c]-%m%n

6.5：编写service的接口以及实现类

public interface OrderService {

    /**
     * 查询用户和订单
     * @param address 查询地址
     */
    List<Order> findUserAndOrder(String address);
}

@Service//注意此处添加注解，将这个类添加到Spring容器中
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderDao orderDao;

    /**
     * 查询用户和订单
     * @param address 查询地址
     */
    @Override
    public List<Order> findUserAndOrder(String address) {
        return orderDao.findUserAndOrder(address);
    }
}

7.第七步编写web模块

7.1建如下框架

 7.2导入相关依赖

<dependencies>
    <dependency>
      <groupId>org.example</groupId>
      <artifactId>ssm-service</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>

7.3编写comfig里面的三个配置类：SpringMvcConfig（springMVC子容器，用于配置web相关支持）,ServletConfigInitializer（将Spring父容器和子容器建立联系，并初始化加载，建立拦截所有请求处理），SpringMvcSupport（用以放行前端的静态资源）（以后这些都是固定不变的，因此在接下来的项目，这些都是直接拿来使用了。最多修改一下其上面的注解。）

SpringMvcConfig类：

@Configuration
@ComponentScan({"com.itheima.controller", "com.itheima.config"})  //扫描控制器
@EnableWebMvc  //开启json转换
public class SpringMvcConfig {
}

ServletConfigInitializer类：

/**
 * tomcat启动的时候自动加载的配置类
 */
public class ServletConfigInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    /**
     * 加载Spring的配置类，父容器
     * @return
     */
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    /**
     * 加载SpringMVC的配置类，子容器
     * @return
     */
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

SpringMvcSupport类：

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {

    /**
     * 把静态资源放行
     */
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        System.out.println("静态资源放行");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/**").addResourceLocations("/");
    }
}

7.4编写OrderController类用以跟前端交互（这个类是与前端交互入口，处理请求与响应的相关操作均先通过此类）

@RestController
public class OrderController {

    @Autowired
    private OrderService orderService;

    /**
     * 查询用户和订单
     * @param address
     * @return
     */
    @GetMapping("order")
    public List<Order> findUserAndOrder(String address) {
        return orderService.findUserAndOrder(address);
    }
}

webapp里面的前端代码在我电脑里面，没有前端代码，可以使用postmen进行模拟交互。