分模块开发

今日内容

• 分模块开发
• 私服
• 软件服务模式]
• 软件开发流程

第一章 maven基础知识

1. maven的作用
	依赖管理: 对jar包的管理
	一键构建: 一个命令来搞定项目构建过程
	
2. maven的常用命令
	清理: clean     删除上一次项目构建产生的文件, 也就是target文件
	编译: compile   将正式的java文件(src/main/java)编译class文件  
	测试: test      将测试文件(src/test)进行编译并运行
	打包: package   将正式的文件(src/main)进行打包(jar  war)
	安装: install   将包发布到本地仓库
	部署: deploy    将包发布到私服

3. maven的生命周期
	清理: clean
	默认: compile  test  package  install  deploy
	站点: site
	同一个生命周期中的命令, 运行后面的命令,前面的会自动执行

4. maven仓库的种类
	本地仓库          开发者电脑
	远程仓库(私服)     公司内网   
	中央仓库           公网   

5. maven的主要标签
	groupId      公司 
	artifactId   项目
	version      版本
		SNAPSHOT    快照   测试版
		RELEASE     发布   稳定版
	packing     打包方式
		jar---java工程  
		war---web工程
		pom---父工程

第二章 分模块开发

1. 拆分与聚合的思想

拆分 将原来的一个项目拆分成一个个小的模块, 每个模块都有自己的坐标, 当其它项目需要本模块的功能时, 只需要按照坐标引入本模块就可以了

聚合 通过坐标的形式，将各个模块组装在一起,完成一个项目的功能

2.父子工程搭建

2.1 创建父工程

<?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>ssm_parent</artifactId>
    <!--自动生成,代表当前是一个父工程-->
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <!--自动生成,代表当前父工程下的子工程-->
    <modules>
        <module>ssm_dao</module>
        <module>ssm_service</module>
        <module>ssm_web</module>
    </modules>
</project>

2.2 创建dao模块

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

    <artifactId>ssm_dao</artifactId>


</project>

2.3 创建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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>ssm_parent</artifactId>
        <groupId>com.itheima</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ssm_service</artifactId>


</project>

2.4 创建web模块

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

    <artifactId>ssm_web</artifactId>


</project>

2.5 建立模块之间关系

ssm_web/pom.xml

<dependencies>
    <!--web层引入service层-->
    <dependency>
        <groupId>com.itheima</groupId>
        <artifactId>ssm_service</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

ssm_service/pom.xml

<dependencies>
    <!--service层引入dao层-->
    <dependency>
        <groupId>com.itheima</groupId>
        <artifactId>ssm_dao</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

在进行依赖的时候, maven规定:

​ 编译阶段, 可以使用源代码进行依赖

​ 运行阶段,必须使用jar包进行依赖

3. 两套关系梳理

在上面的工程中, 存在两套关系

• 父子工程之间: 继承关系, 子工程可以使用父工程中的jar包

• 模块工程之间: 默认是没有任何关系的，但是可以通过依赖建立两者之间的关系，而且这个依赖关系是可以传递的

  A-->B   B-->C         A-->C  
  我们把A和B之间  或者  B和C 之间称为  直接依赖
  我们把    A和C   之间称为   间接依赖
  

第三章 依赖冲突(面试)

1.什么是依赖冲突

在依赖的传递过程中，很容易出现同一jar包的版本冲突问题，这个就称为依赖冲突

2.依赖冲突解决

2.1 第一声明优先原则

在pom文件定义依赖，先声明的依赖为准。

<dependencies>
    <!--第一声明优先原则: 谁先导入,就用谁-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.6.RELEASE</version>       
    </dependency>   
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.1.7.RELEASE</version>
    </dependency>
    <!--则spring-code引入的是5.1.6.RELEASE-->
</dependencies>

2.2 路径近者优先原则

从依赖程序开始算起，到被依赖的程序，以路径短的为准。

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.6.RELEASE</version>      
    </dependency>
    <!--路径近者优先原则: 就近原则(直接依赖高于简介依赖)-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.1.7.RELEASE</version>
    </dependency>
    <!--则spring-beans5.1.7-->
</dependencies>

2.3 依赖排除

依赖排除就是在依赖引入的过程中，通过exclusions标签排掉指定的跟随依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.6.RELEASE</version>
        <!--依赖排除: 在导入依赖的时候,通过手动排除的方式去掉它的一些跟随依赖-->
        <exclusions>
            <exclusion>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
            </exclusion>
        </exclusions>
    </dependency>   
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.1.7.RELEASE</version>
    </dependency>
    <!--则spring-core5.1.7-->

</dependencies>

2.4 版本锁定

面对众多的依赖，有一种方法不用考虑依赖路径、声明优先等因素，可以采用直接锁定版本的方法确定依赖构件的版本

版本锁定后，系统会以锁定的版本的为准添加到工程中，此方法在企业开发中常用。

<!--依赖管理: 只用于锁定要带入的依赖的版本-->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.6.RELEASE</version>
        </dependency>        
</dependencyManagement>

<!--依赖导入: 此时才真正的引入依赖, 但是不需要再声明版本了-->
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
    </dependency>
</dependencies>

2.5 优化: 提取版本信息

<!--提取依赖版本变量-->
<properties>
    <spring.version>5.1.6.RELEASE</spring.version>
</properties>

<!--依赖管理: 只用于锁定要带入的依赖的版本-->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</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>
    </dependencies>
</dependencyManagement>

<!--依赖导入: 此时才真正的引入依赖, 但是不需要再声明版本了-->
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
    </dependency>
</dependencies>

第四章 分模块版本的SSM环境搭建(重点)

1. 环境准备

准备数据环境(spring库 account表)

准备项目环境(就使用现在的环境, 但是要把坐标加入到父工程中的pom文件)

2. 修改dao模块

2.1 创建实体类

import lombok.Data;

/**
 * 创建实体对象
 */
@Data
public class Account {
   private Integer aid;
   private String name;
   private Float balance;
}

2.2 创建dao接口

import com.itheima.domain.Account;

import java.util.List;

/**
 * 创建dao接口
 */
public interface AccountDao {
   
   List<Account> findAll();
}

2.3 创建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.AccountDao">

    <select id="findAll" resultType="com.itheima.domain.Account">
        select * from account
    </select>
</mapper>

2.4 加入spring配置文件

<!--数据源-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql:///spring"/>
    <property name="username" value="root"/>
    <property name="password" value="root"/>
</bean>

<!--sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
</bean>

<!--Mapper扫描器-->
<bean id="mapperScannerConfigurer"
      class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.itheima.dao"/>
</bean>

2.5 测试

/**
 * dao模块测试文件
 * 采用spring的测试
 * 引入了spring配置文件
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring/applicationContext-dao.xml")
public class DaoTest {

   @Autowired
   private AccountDao accountDao;

   @Test
   public void testFindAll(){
      List<Account> accounts = accountDao.findAll();
      for (Account account : accounts) {
         System.out.println(account);
      }
   }
}

3. 修改service模块

3.1 创建service接口

import com.itheima.domain.Account;

import java.util.List;

public interface AccountService {
   
   List<Account> findAll();
}

3.2 创建service实现类

package com.itheima.service.impl;

import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class AccountServiceImpl implements AccountService {
   
   @Autowired
   private AccountDao accountDao;
   
   public List<Account> findAll() {
      return accountDao.findAll();
   }
}

3.3 加入spring的配置文件

<!--组件扫描-->
<context:component-scan base-package="com.itheima">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!--引入dao的配置文件-->
<!--<import resource="classpath:spring/applicationContext-dao.xml"></import>-->

<!--事务管理-->
<bean id="transactionManager"
      class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="*"/>
    </tx:attributes>
</tx:advice>
<aop:config>
    <aop:pointcut id="pt" expression="execution(* com.itheima.service.impl.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
</aop:config>

3.4 测试

//classpath   代表的是当前工程类路径
//classpath*  代表的是当前工程以及子工程路径
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath*:spring/applicationContext-*.xml")
public class ServiceTest {


   @Autowired
   private AccountService accountService;

   @Test
   public void testFindAll() {
      List<Account> accounts = accountService.findAll();
      for (Account account : accounts) {
         System.out.println(account);
      }
   }
}

4. 修改web模块

4.1 加入SpringMVC的配置文件

<!--组件扫描-->
<context:component-scan base-package="com.itheima.web"/>

<!--三大组件-->
<mvc:annotation-driven/>
<bean id="viewResolver"
      class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/"/>
    <property name="suffix" value=".jsp"/>
</bean>

4.2 加入web.xml

<!--spring监听器-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:spring/applicationContext-*.xml</param-value>
</context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--springmvc前端控制器-->
<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/spring-mvc.xml</param-value>
    </init-param>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>
<!--中文乱码过滤器-->
<filter>
    <filter-name>characterEncodingFilter</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>
</filter>
<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

4.3 开发请求页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <a href="${pageContext.request.contextPath}/accountController/list">列表</a>
</body>
</html>

4.4 开发后台控制器

import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import java.util.List;

@Controller
public class AccountController {
   
   @Autowired
   private HttpServletRequest request;
   @Autowired
   private AccountService accountService;

   @RequestMapping("/accountController/list")
   public String list(){
      List<Account> accounts = accountService.findAll();
      request.setAttribute("accounts",accounts);

      return "list";
   }
}

4.5 开发响应页面

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

    ${accounts}

</body>
</html>

第五章 私服(了解)

1.私服简介

​ 公司在自己的局域网内搭建自己的远程仓库服务器，称为私服，私服服务器即是公司内部的maven远程仓库，每个员工的电脑上安装maven软件并且连接私服服务器，员工将自己开发的项目打成jar并发布到私服服务器，其它项目组从私服服务器下载所依赖的构件(jar)。

2. 搭建私服环境

2.1 下载nexus

Nexus是Maven仓库管理器，通过nexus可以搭建maven仓库, 软件已经提供在资料中nexus-2.12.0-01-bundle.zip

2.2 安装nexus

第1步: 解压nexus-2.12.0-01-bundle.zip到一个没有中文没有空格的目录

第2步: 以管理员身份运行cmd命令, 然后进入软件的bin目录，通过命令安装并启动nexus软件

补充下停止和下载的命令
  停止 nexus.bat  stop
  卸载 nexus.bat  uninstall

第3步: 访问nexus

nexus默认监听端口为8081, 通过 http://localhost:8081/nexus 即可访问

第4步: 登录nexus

nexus默认的用户名是admin, 默认的密码是admin123

登录成功后,会看到下面的内容:

3.仓库类型

仓库有下面四类:

• proxy 代理仓库, 用于代理远程仓库(中央)
• virtual 废弃的代理仓库
• hosted 用于本地jar包上传的仓库
• group 就是上面仓库的综合, 用于jar包的下载

4. 将项目发布到私服

企业中多个团队协作开发通常会将一些公用的组件、开发模块等发布到私服供其它团队或模块开发人员使用。

第1步：在maven的settings.xml文件中, 添加下面配置

<!--
    此用户名和密码用于私服校验，因为私服需要知道上传的账号和密码是否和私服中的账号和密码一致。
    添加到servers节点下
-->
<server>
     <id>releases</id>
     <username>admin</username>
     <password>admin123</password>
</server>
<server>
     <id>snapshots</id>
     <username>admin</username>
     <password>admin123</password>
</server>

第2步： 在需要操作的模块(比如ssm_dao)的pom.xml文件中, 添加下面配置

<!--
	配置私服仓库的地址，如果版本为release则上传到私服的release仓库，如果版本为snapshot则上传到私服的snapshot仓库
-->
<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>

第3步： 选择需要操作的模块(比如ssm_dao), 执行deploy命令

第4步: 执行完毕后, 可以在私服的对应目录下观察到上传的文件

5. 从私服下载jar包

配置nexus之后，本地仓库没有jar包，就去私服下载，私服如果没有, 再由私服去中央下载。

第1步: 在maven的settings.xml文件中, 添加下面配置

<!--配置下载仓库-->
<profile>
  <id>dev</id>
  <repositories>
   <repository> 
    <id>nexus</id>
    <url>http://localhost:8081/nexus/content/groups/public/</url>
    <releases>  
       <enabled>true</enabled> 
    </releases>
    <snapshots>
       <enabled>true</enabled>
    </snapshots>
   </repository>
  </repositories>
  <pluginRepositories>
    <pluginRepository>
      <id>public</id>
      <name>Public Repositories</name>
      <url>http://localhost:8081/nexus/content/groups/public/</url>
    </pluginRepository>
  </pluginRepositories>
 </profile>

 <!--使用profile定义仓库需要激活才可生效-->
 <activeProfiles>
     <activeProfile>dev</activeProfile>
 </activeProfiles>

第2步: 测试

1) 首先在ssm_parent工程上执行install, 这样就可以将所有模块打包到本地仓库

2) 然后删除本地仓库中的ssm_dao的文件

3) 在ssm_service模块上执行compile命令

​ 注意: service 要编译成功必须依赖仓库中的ssm_dao,而现在本地仓库中没有, 他就会从私服下载

4) 通过控制台观察效果

第六章 软件的服务模式

目前, 软件服务主要有三种模式:

• IaaS(基础设施即服务) 提供给客户最基础的东西, 然后客户自己完成所有工作
• PaaS(平台即服务)提供给客户半成品的东西, 然后客户自己完成剩下的工作
• SaaS(软件即服务)提供给客户成品, 客户只需要使用

SaaS(Software-as-a-service)的意思是软件即服务。简单说就是在线系统模式，即软件服务商提供的软件在线服务。

SaaS软件就适用对象而言，可以划分为针对个人的与针对企业的

​ 面向个人的SaaS产品：在线文档，账务管理，文件管理，日程计划、照片管理、联系人管理，等等云类型的服务

​ 面向企业的SaaS产品：CRM(客户关系管理)、线上视频或者与群组通话会议、OA(办公系统)、外勤管理、财务管理、审批管理等。

第七章 软件开发流程(防面试)

- 货代平台开发周期6个月左右，团队需要10人左右...
	技术总监或架构师	产品经理或项目经理	java开发	前端和美工	测试    运维
		   1				1			  4         2		  1       1
		
1. 立项
	项目可实施性分析：(招商银行)100W项目，开发周期预计6个月，需要10人，运营(人力)成本2W/人
	产品经理入住银行，进行需求调研《需求设计说明书》
	需求研讨会：团队所有成员参加

2. 设计
	UI/UE工程师：《页面原型》
	架构师：统一开发环境，项目技术选项，项目架构设计，数据库设计等等《概要设计说明书》
	产品经理：接口规范、方法规范、参数规范、步骤要求等等《详细设计说明书》

3. 开发
	coding(编码)，码农

4. 测试
	白盒测试：代码逻辑和性能
	黑盒测试：用户体验
	灰盒测试：黑+白

5. 部署
	运维人员产品部署上传维护....