2. 程式人生 > >【RabbitMQ訊息中介軟體】12.RabbitMQ結合SSM框架-編寫倉儲系統

【RabbitMQ訊息中介軟體】12.RabbitMQ結合SSM框架-編寫倉儲系統

阿新 • • 發佈：2019-01-15
瞭解了RabbitMQ的基本知識和幾大佇列模式，以及Spring-Rabbit開源工程的基本原理後，我們動手來實現在實際工作開發中需要與SSM框架結合使用的工程場景。

該場景模擬以下活動：

貨倉管理系統用於對貨物的管理，它的每一次進貨(insert)和修改(update)、刪除(delete)都會向訊息中介軟體推送訊息，而銷售系統會從訊息中介軟體中獲取貨物的資訊，同步至銷售系統的資料庫。

首先我們建立貨倉管理系統，在Eclipse中建立一個名為“Warehouse_Management”的Maven工程：




然後在pom.xml檔案中加入Spring/Spring MVC以及MyBatis框架環境需要的依賴：
<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>cn.com.jack.rabbit_test</groupId>
  <artifactId>Warehouse_Management</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  
  <properties>  
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>  
    <!-- spring版本號 -->  
    <spring.version>4.2.5.RELEASE</spring.version>  
    <!-- mybatis版本號 -->  
    <mybatis.version>3.2.8</mybatis.version>  
    <!-- mysql驅動版本號 -->  
    <mysql-driver.version>5.1.29</mysql-driver.version>  
    <!-- log4j日誌包版本號 -->  
    <slf4j.version>1.7.18</slf4j.version>  
    <log4j.version>1.2.17</log4j.version>  
  </properties> 
  
  <dependencies>  
    <!-- 新增jstl依賴 -->  
    <dependency>  
      <groupId>jstl</groupId>  
      <artifactId>jstl</artifactId>  
      <version>1.2</version>  
    </dependency>  
  
    <dependency>  
      <groupId>javax</groupId>  
      <artifactId>javaee-api</artifactId>  
      <version>7.0</version>  
    </dependency>  
  
    <!-- 新增junit4依賴 -->  
    <dependency>  
      <groupId>junit</groupId>  
      <artifactId>junit</artifactId>  
      <version>4.11</version>  
      <!-- 指定範圍，在測試時才會載入 -->  
      <scope>test</scope>  
    </dependency>  
  
    <!-- 新增spring核心依賴 -->  
    <dependency>  
      <groupId>org.springframework</groupId>  
      <artifactId>spring-core</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-oxm</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>  
    <dependency>  
      <groupId>org.springframework</groupId>  
      <artifactId>spring-webmvc</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-aop</artifactId>  
      <version>${spring.version}</version>  
    </dependency>  
  
    <dependency>  
      <groupId>org.springframework</groupId>  
      <artifactId>spring-test</artifactId>  
      <version>${spring.version}</version>  
    </dependency>  
    <dependency>
	    <groupId>org.aspectj</groupId>
	    <artifactId>aspectjweaver</artifactId>
	    <version>1.8.10</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>1.2.2</version>  
    </dependency>  
  
    <!-- 新增mysql驅動依賴 -->  
    <dependency>  
      <groupId>mysql</groupId>  
      <artifactId>mysql-connector-java</artifactId>  
      <version>${mysql-driver.version}</version>  
    </dependency>    
    <!-- 引入c3p0資料庫連線池 -->
	<dependency>
		<groupId>c3p0</groupId>
		<artifactId>c3p0</artifactId>
		<version>0.9.1.2</version>
	</dependency>  
  
    <!-- 新增日誌相關jar包 -->  
    <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>commons-fileupload</groupId>  
      <artifactId>commons-fileupload</artifactId>  
      <version>1.3.1</version>  
    </dependency>  
  
    <dependency>  
      <groupId>commons-io</groupId>  
      <artifactId>commons-io</artifactId>  
      <version>2.4</version>  
    </dependency>  
  
    <dependency>  
      <groupId>commons-codec</groupId>  
      <artifactId>commons-codec</artifactId>  
      <version>1.9</version>  
    </dependency>  
  </dependencies>  
  
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.6</source>
          <target>1.6</target>
        </configuration>
      </plugin>
      <plugin>
      	<artifactId>maven-war-plugin</artifactId>
      	<configuration>
      		<version>3.0</version>
      	</configuration>
      </plugin>
    </plugins>
  </build>
</project>
工程目錄如下：


接下來先建立資料庫，我使用的是Mysql資料庫，操作資料時使用的是sqlyog的圖形化工具。我們在sqlyog中建立一個數據庫名稱叫“warehouse_management”，是貨倉管理的資料庫：

其中建立一個名為product的表，儲存貨物資訊：

建表語句為：
CREATE TABLE `product` (
   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主鍵',
   `pname` varchar(200) COLLATE utf8_bin NOT NULL COMMENT '貨物名稱',
   `price` double NOT NULL COMMENT '價格',
   `pdesc` text COLLATE utf8_bin COMMENT '貨物描述',
   `weight` int(11) DEFAULT NULL COMMENT '重量',
   `model` varchar(100) COLLATE utf8_bin DEFAULT NULL COMMENT '型號規格',
   PRIMARY KEY (`id`)
 ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COLLATE=utf8_bin

然後在src/mian/resource下建立資料庫連線資訊配置檔案“db.properties”:
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/warehouse_management
jdbc.username=root
jdbc.password=1234
c3p0.pool.maxPoolSize=400
c3p0.pool.minPoolSize=50
c3p0.pool.initialPoolSize=50
c3p0.pool.acquireIncrement=100

然後是MyBtais的配置檔案“sqlMapConfig.xml”，因為MyBatis交給了Spring託管，所以這裡僅配置了一個別名：
<?xml version="1.0" encoding="UTF-8"?>  
<!DOCTYPE configuration  
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
"http://mybatis.org/dtd/mybatis-3-config.dtd">  
<configuration>  
      
    <!-- 全域性setting配置，根據需要新增 -->  
      
    <!-- 配置別名 -->  
    <typeAliases>  
        <!-- 批量掃描別名 -->  
        <package name="com.warehouse_management.po"/>  
    </typeAliases>  
    
    <!-- 配置mapper   
       由於使用spring和mybatis的整合包進行mapper掃描，這裡不需要配置了。  
       但必須遵循:mapper.xml和mapper.java檔案同名且在一個目錄-->  
    <!-- <mappers></mappers> -->  
</configuration>

然後在src/mian/resource下建立spring的配置檔案“beans.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:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
			http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
			http://www.springframework.org/schema/mvc 
			http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 
			http://www.springframework.org/schema/context 
			http://www.springframework.org/schema/context/spring-context-3.0.xsd 
			http://www.springframework.org/schema/aop 
			http://www.springframework.org/schema/aop/spring-aop-3.0.xsd 
			http://www.springframework.org/schema/tx 
			http://www.springframework.org/schema/tx/spring-tx-3.0.xsd ">
			
		<!-- 1.載入資料庫配置的屬性檔案 -->	
		<context:property-placeholder location="classpath:db.properties"/>
		
		<!-- 2.包掃描:dao,service -->
		<context:component-scan base-package="com.warehouse_management.dao,com.warehouse_management.service"/>
		
		<!-- 3,dataSource資料來源 -->
		<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
			<property name="driverClass" value="${jdbc.driver}"/>
			<property name="jdbcUrl" value="${jdbc.url}"/>
			<property name="user" value="${jdbc.username}"/>
			<property name="password" value="${jdbc.password}"/>
			
			<!-- 連線池中保留的最大連線數。預設為15 -->
			<property name="maxPoolSize" value="${c3p0.pool.maxPoolSize}"/>
			<!-- 連線池中保留的最小連線數。預設為15 -->
			<property name="minPoolSize" value="${c3p0.pool.minPoolSize}" />
			<!-- 初始化時建立的連線數，應在minPoolSize與maxPoolSize之間取值。預設為3 -->
			<property name="initialPoolSize" value="${c3p0.pool.initialPoolSize}"/>
			<!-- 定義在從資料庫獲取新連線失敗後重復嘗試獲取的次數，預設為30 -->
			<property name="acquireIncrement" value="${c3p0.pool.acquireIncrement}"/>
		</bean>
		
		<!-- 4.SessionFactory -->
		<bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
			<property name="dataSource" ref="dataSource"/>
			<!-- 整合mybatis，包掃描mapper檔案 -->
			<property name="configLocation" value="classpath:sqlMapConfig.xml"></property>
			<property name="mapperLocations" value="classpath:com/warehouse_management/mapper/*.xml"></property>
		</bean>
		
		<!-- 5.事務管理 -->
		<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
			<property name="dataSource" ref="dataSource"/>
		</bean>
		
		<!-- 事務通知 -->
		<tx:advice id="txAdivce" transaction-manager="txManager">
			<tx:attributes>
				<tx:method name="insert*" propagation="REQUIRED"/>
				<tx:method name="update*" propagation="REQUIRED"/>
				<tx:method name="delete*" propagation="REQUIRED"/>
				<tx:method name="save*" propagation="REQUIRED"/>
				
				<tx:method name="find*" read-only="false"/>
				<tx:method name="get*" read-only="false"/>
				<tx:method name="view*" read-only="false"/>
			</tx:attributes>
		</tx:advice>
		
		<aop:config>
			<aop:pointcut expression="execution(* com.warehouse_managementservice.*.*(..))" id="txPointcut"/>
			<aop:advisor advice-ref="txAdivce" pointcut-ref="txPointcut"/>
		</aop:config>
		
		<!-- 開啟事務註解驅動 -->
	    <!-- <tx:annotation-driven transaction-manager="txManager" /> -->
	
</beans>

其中首先載入資料庫配置的屬性檔案“db.properties”，然後設定包掃描的路徑，用於掃描DAO或者Service的暴露以及注入註解 ，之後設定DataSource資料來源，將“db.properties”中的引數動態設定進去。然後設定MyBatis的SessionFactory會話工廠，用與處理系統與資料庫之間的互動。下面是事務管理和事務通知的配置，事務通知以切面的方式切入Service層中。

然後建立spring mvc的配置檔案“springmvc-action.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:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
	http://www.springframework.org/schema/mvc 
	http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-3.0.xsd 
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd 
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx-3.0.xsd ">
	
	<!-- 1.掃描controller包 -->
	<context:component-scan base-package="com.warehouse_management.controller"/>
	
	<!-- 2.內部資源檢視解析器，suffix為空，方便跟引數 url?id=xxx -->
	<bean id="jspViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/pages"/>
		<property name="suffix" value=""/>
	</bean>
	
	<!-- 3.註解驅動 -->
	<mvc:annotation-driven/>
	
	<!-- 4.攔截器配置 -->
	<!-- <mvc:interceptors>
		<mvc:interceptor>
			<mvc:mapping path="/**"/>
			<bean class="com.warehouse_management.interceptor.LoginInterceptor"/>
		</mvc:interceptor>
	</mvc:interceptors> -->


	<!-- 5.檔案上傳解析器，最大能上傳10M檔案（1024*1024*10）-->
	<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<property name="maxUploadSize" value="10485760"/>
	</bean>
	
	<mvc:resources location="/js/" mapping="/js/**"/>  
	<mvc:resources location="/images/" mapping="/images/**"/>  
	<mvc:resources location="/css/" mapping="/css/**"/>  
</beans>
在springmvc配置檔案中，我們配置了掃描controller包註解的配置、檢視解析器、註解驅動、檔案上傳解析器(其實沒用到)。因為我們做的小例項，不做登入系統，也不做許可權控制，所以這裡攔截器配置註釋掉，忽略。

最後配置的是日誌的配置檔案“log4j.properties”：
# Global logging configuration  
log4j.rootLogger=DEBUG, stdout  
# Console output...  
log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

因為我們是Web工程，要把Maven改為Web結構。郵件工程點選properties，進入“project Facets”中設定Web屬性：


可以看到maven生成了Web相關結構目錄：

我們在WEB-INF下建立“page”資料夾，用於放置jsp檢視(上面配置檔案配置的就是這個目錄)。

然後我們在src/main/java下建立一些包，用於放置各種型別的類：


下面在“com.warehouse_management.mapper”包下編寫一個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.warehouse_management.mapper.ProductMapper">  
    <!-- resultMap對映 -->
	<resultMap type="com.warehouse_management.po.Product" id="productRM">
		<!-- 主鍵 -->
		<id property="id" column="id" jdbcType="INTEGER" />
		<!-- 一般屬性 -->
		<result property="name" column="pname" jdbcType="VARCHAR"/>
		<result property="price" column="price" jdbcType="DOUBLE"/>
		<result property="desc" column="pdesc"/>
		<result property="weight" column="weight" jdbcType="INTEGER"/>
		<result property="model" column="model" jdbcType="VARCHAR"/>
	</resultMap>
	
	<!-- 查詢一個 -->
	<select id="selectById" parameterType="int" resultMap="productRM">
		select * from product
		where id=#{id}
	</select>
	
	<!-- 查詢 -->
	<select id="selectAll" resultMap="productRM">
		select * from product
	</select>
	
	<insert id="insert" parameterType="com.warehouse_management.po.Product">
		insert into product
		(PNAME,PRICE,PDESC,WEIGHT,MODEL)
		values
		(
			#{name,jdbcType=VARCHAR},
			#{price,jdbcType=DOUBLE},
			#{desc},
			#{weight,jdbcType=INTEGER},
			#{model,jdbcType=VARCHAR}
		)
	</insert>
	
	<!-- 修改語句 -->
	<update id="update" parameterType="com.warehouse_management.po.Product">
		update product
		<set>
	 	   <if test="name != null">pname=#{name},</if>
		   <if test="price != null">price=#{price},</if>
		   <if test="desc != null">pdesc = #{desc},</if>
		   <if test="weight != null">weight=#{weight},</if>
		   <if test="model != null">model=#{model}</if>
		</set>
		where id=#{id}
	</update>
	
	<!-- 刪除一條 -->
	<delete id="deleteById" parameterType="int">
		delete from product
		where id=#{id}
	</delete>
</mapper>

然後在com.warehouse_management.po包下建立名為“Product”的實體類：
package com.warehouse_management.po;

public class Product {
	private int id;
	private String name;
	private Double price;
	private String desc;
	private Integer weight;
	private String model;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Double getPrice() {
		return price;
	}
	public void setPrice(Double price) {
		this.price = price;
	}
	public String getDesc() {
		return desc;
	}
	public void setDesc(String desc) {
		this.desc = desc;
	}
	public Integer getWeight() {
		return weight;
	}
	public void setWeight(Integer weight) {
		this.weight = weight;
	}
	public String getModel() {
		return model;
	}
	public void setModel(String model) {
		this.model = model;
	}
}

然後我們分別在Dao包下編寫Dao的基礎類，使用SqlSession呼叫相關的SQL配置的公用封裝：
介面：
package com.warehouse_management.dao;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

//泛型類，基礎的DAO介面  
public interface BaseDao<T> {  
  public T selectById(int id);//只查詢一個，常用於修改  
  public List<T> selectAll(Map map);//根據條件查詢多個結果
  public void insert(T entity);//插入，用實體作為引數  
  public void update(T entity);//修改，用實體作為引數  
  public void deleteById(int id);//按id刪除，刪除一條
}
實現類：
package com.warehouse_management.dao.impl;

import java.util.List;
import java.util.Map;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import org.springframework.beans.factory.annotation.Autowired;
import com.warehouse_management.dao.BaseDao;

public abstract class BaseDaoImpl<T> extends SqlSessionDaoSupport implements BaseDao<T>{  
    @Autowired  
    //mybatis-spring 1.0無需此方法；mybatis-spring1.2必須注入。  
    public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory){  
        super.setSqlSessionFactory(sqlSessionFactory);  
    }  
      
    private String ns;      //名稱空間  
    public String getNs() {  
        return ns;  
    }  
    public void setNs(String ns) {  
        this.ns = ns;  
    }  
  
    public List<T> selectAll(Map map) {  
        List<T> oList = this.getSqlSession().selectList(ns + ".selectAll", map);  
        return oList;  
    }  
    public T selectById(int id) {  
        return this.getSqlSession().selectOne(ns + ".selectById", id);  
    }  
  
    public void insert(T entity) {  
        this.getSqlSession().insert(ns + ".insert", entity);  
    }  
  
    public void update(T entity) {  
        this.getSqlSession().update(ns + ".update", entity);  
    }  
  
    public void deleteById(int id) {  
        this.getSqlSession().delete(ns + ".deleteById", id);  
    } 
}

然後在Dao與Service下建立Product相關的增刪改查類：
Dao層介面：
package com.warehouse_management.dao;

import java.util.List;
import java.util.Map;
import com.warehouse_management.po.Product;

public interface ProductDao extends BaseDao<Product>{  
	public Product selectById(int id);//只查詢一個，常用於修改  
    public List<Product> selectAll(Map map);//根據條件查詢多個結果
    public void insert(Product commodties);//插入，用實體作為引數  
    public void update(Product commodties);//修改，用實體作為引數  
    public void deleteById(int id);//按id刪除，刪除一條
}

Dao層實現：
package com.warehouse_management.dao.impl;

import org.springframework.stereotype.Repository;
import com.warehouse_management.dao.ProductDao;
import com.warehouse_management.po.Product;

@Repository //為了包掃描的時候這個Dao被掃描到  
public class ProductDaoImpl extends BaseDaoImpl<Product> implements ProductDao{  
    public ProductDaoImpl(){  
        //設定名稱空間  
        super.setNs("com.warehouse_management.mapper.ProductMapper");  
    }
    //在下面可以實現自己的查詢方法
}
Service層介面：
package com.warehouse_management.service;

import java.util.List;
import java.util.Map;
import com.warehouse_management.po.Product;

public interface ProductService{  
	public Product selectById(int id);//只查詢一個，常用於修改  
    public List<Product> selectAll(Map map);//根據條件查詢多個結果
    public void insert(Product commodties);//插入，用實體作為引數  
    public void update(Product commodties);//修改，用實體作為引數  
    public void deleteById(int id);//按id刪除，刪除一條
}
Service層實現：
package com.warehouse_management.service.impl;

import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.warehouse_management.dao.ProductDao;
import com.warehouse_management.po.Product;
import com.warehouse_management.service.ProductService;

@Service  //為了包掃描的時候這個Service被掃描到  
public class ProductServiceImpl implements ProductService{

    @Autowired  
    private ProductDao productDao;
	
	@Override
	public Product selectById(int id) {
		return productDao.selectById(id);
	}


	@Override
	public List<Product> selectAll(Map map) {
		return productDao.selectAll(map);
	}


	@Override
	public void insert(Product product) {
		productDao.insert(product);
	}


	@Override
	public void update(Product product) {
		productDao.update(product);
	}


	@Override
	public void deleteById(int id) {
		productDao.deleteById(id);
	}


}
然後在Controller建立相關服務響應：
package com.warehouse_management.controller;

import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import com.warehouse_management.po.Product;
import com.warehouse_management.service.ProductService;

@Controller
public class ProductController { 
	
	@Autowired
	private ProductService productService;
	//建立該類的日誌物件
	Log log = LogFactory.getLog(this.getClass());  
	
	
	//跳轉至列表頁面
	@RequestMapping("/product/home.action")  
    public String list(Model model){ 
		List<Product> productList = productService.selectAll(null);
		model.addAttribute("productList",productList);//貨物列表
		return "/product/home.jsp";//轉向首頁
	}
	
	@RequestMapping("/product/toAdd.action")  
    public String toAdd(Model model){   
		return "/product/add.jsp";//轉向新增頁
    } 
	
	@RequestMapping("/product/add.action")  
    public String add(Model model,Product product){   
		productService.insert(product);
		//重新重新整理至分頁列表頁首頁
		return list(model);
    }  
	
	@RequestMapping("/product/toEdit.action")  
    public String toEdit(Model model,Integer id){   
		if(id!=null){
			model.addAttribute("product", productService.selectById(id));
		}
		return "/product/edit.jsp";//轉向編輯頁
    } 
	
	@RequestMapping("/product/edit.action")  
    public String edit(Model model,Product product){   
		productService.update(product);
		//重新重新整理至分頁列表頁首頁
		return list(model);
    } 


    	@RequestMapping("/product/delete.action")  
    public String delete(Model model,Integer id){   
		productService.deleteById(id);
		//重新重新整理至分頁列表頁首頁
		return list(model);
    } 
}
分別是載入所有商品、新增跳轉、執行新增、編輯跳轉、進行編輯的服務

然後在WEB-INF下建立一個“pages”資料夾，在下面建立“product”資料夾，在下面放置商品列表、新增、編輯的Jsp檔案：
home.jsp:
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>倉儲管理系統首頁</title>
  </head>
  
  <body>
    <h1>倉儲管理系統</h1>
    <hr/>
    <a href="toAdd.action">
    <button style="background-color:#173e65;color:#ffffff;width:70px;">新增</button>
    </a>
  	<c:if test="${productList!=null}">
	  <table style="margin-top: 10px;width:700px;text-align:center;" border=1>  
	    <tr>  
	      <td>序號</td><td>貨物名稱</td><td>價格</td><td>貨物描述</td>
	      <td>重量</td><td>型號規格</td><td>操作</td>
	   </tr>  
      	 <c:forEach items="${productList}" var="item" varStatus="status">  
		     <tr>  
		       <td>${status.index+1}</td><td>${item.name }</td>
		       <td>${item.price}</td><td>${item.desc }</td>  
		       <td>${item.weight}</td><td>${item.model}</td>
		       <td>
		       		<a href="toEdit.action?id=${item.id}">編輯</a>|
		       		<a href="delete.action?id=${item.id}">刪除</a>
		       </td>
		     </tr>  
	     </c:forEach>  
	    </table> 
   </c:if>
   <c:if test="${productList==null}">
       <b>搜尋結果為空！</b>
   </c:if>
  </body>
</html>
add.jsp:
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>新增</title>
    <script type="text/javascript">
    	function checkAdd(){
    	   var addName = document.getElementById("addName").value;
    	   var addPrice = document.getElementById("addPrice").value;
    	   var addWeight = document.getElementById("addWeight").value;
           if(addName==null||addName==""){
               alert("使用者名稱不能為空！");
               return false;
           }
           if(addPrice==null||addPrice==""){
               alert("手機號不能為空！");
               return false;
           }
           var myreg = /^[-\+]?\d+(\.\d+)?$/;
           if(!myreg.test(addPrice)||!myreg.test(addWeight)) 
           { 
               alert("價格或重量請輸入數字！"); 
               return false; 
           }
           return true;
	   }
    </script>
  </head>
  
  <body>
    <form id="addForm" action="add.action" method="post" onsubmit="checkAdd()">
	        商品名稱：<input type="text" id="addName" name="name" style="width:120px"/> <br/>
	        價格：<input type="text" id="addPrice" name="price" style="width:120px"/><br/>
	        描述：<input type="text" name="desc" style="width:120px"/><br/>
	        重量：<input type="text" id="addWeight" name="weight" style="width:120px"/><br/>
	        型號規格：<input type="text" name="model" style="width:120px"/><br/>
	   <input type="submit" value="新增" style="background-color:#173e65;color:#ffffff;width:70px;"/>
    </form>
  </body>
</html>

edit.jsp:
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>新增</title>
    <script type="text/javascript">
    	function checkAdd(){
    	   var addName = document.getElementById("addName").value;
    	   var addPrice = document.getElementById("addPrice").value;
    	   var addWeight = document.getElementById("addWeight").value;
           if(addName==null||addName==""){
               alert("使用者名稱不能為空！");
               return false;
           }
           if(addPrice==null||addPrice==""){
               alert("手機號不能為空！");
               return false;
           }
           var myreg = /^[-\+]?\d+(\.\d+)?$/;
           if(!myreg.test(addPrice)||!myreg.test(addWeight)) 
           { 
               alert("價格或重量請輸入數字！"); 
               return false; 
           }
           return true;
	   }
    </script>
  </head>
  
  <body>
    <form id="addForm" action="edit.action" method="post" onsubmit="checkAdd()">
	        商品名稱：<input type="text" id="addName" name="name" value="${product.name }" style="width:120px"/> <br/>
	        價格：<input type="text" id="addPrice" name="price" value="${product.price }" style="width:120px"/><br/>
	        描述：<input type="text" name="desc" value="${product.desc }" style="width:120px"/><br/>
	        重量：<input type="text" id="addWeight" name="weight" value="${product.weight }" style="width:120px"/><br/>
	        型號規格：<input type="text" name="model" value="${product.model }" style="width:120px"/><br/>
	        <input type="hidden" name="id" style="width:120px" value="${product.id }"/>
	   <input type="submit" value="修改" style="background-color:#173e65;color:#ffffff;width:70px;"/>
    </form>
  </body>
</html>

最後在預設的index.jsp新增一個跳轉路徑，預設執行home服務，這樣進入系統直接可以看到列表介面：
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>index</title>
  </head>
  <body>
    <script language="JavaScript">
	 window.location.href = "product/home.action";
	</script>
  </body>
</html>
最後在WEB-INF下建立web.xml，配置spring mvc的攔截器：
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" 
	xmlns="http://java.sun.com/xml/ns/j2ee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
	http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
	<!-- 載入spring容器 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>/WEB-INF/classes/beans.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	
	<!-- SpringMvc前端控制器 -->
	<servlet>
		<servlet-name>springmvc</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:springmvc-action.xml</param-value>
		</init-param>
	</servlet>
	
	<servlet-mapping>
		<servlet-name>springmvc</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
	
	<!-- post亂碼過慮器 -->
	<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>
	
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

最後，別忘記在編譯路徑中新增Maven依賴的編譯路徑：


為了測試資料讀取，我們在資料庫中預先新增一些資料：

將應用部署至Tomcat：

然後啟動Tomcat，我這裡埠是80，所以不用輸入埠號，在瀏覽器中訪問“http://localhost/Warehouse_Management/”：

可以看到，我們的倉儲系統已經完全建立完畢。

下一篇我們在該工程的基礎上整合RabbitMQ，然後實現在新增和編輯、刪除的時候向訊息佇列推送資訊。

相關推薦

【RabbitMQ訊息中介軟體】12.RabbitMQ結合SSM框架-編寫倉儲系統

瞭解了RabbitMQ的基本知識和幾大佇列模式，以及Spring-Rabbit開源工程的基本原理後，我們動手來實現在實際工作開發中需要與SSM框架結合使用的工程場景。該場景模擬以下活動：貨倉管理系統用於對貨物的管理，它的每一次進貨(insert)和修改(update)、刪除(

【RabbitMQ訊息中介軟體】13.RabbitMQ結合SSM框架-與銷售系統互動

接上一篇：https://blog.csdn.net/acmman/article/details/79778241為了方便大家學習，我將部落格中編寫的倉儲系統和銷售系統的最終原始碼分享出來，希望能幫助到大家學習：-------------------------------

【中介軟體】MQ Rabbitmq 和spring整合

例一、Xml配置檔案 定義連線、定義了佇列或交換機、可以設定Key、定義了消費者及路徑 <beans xmlns="http://www.springframework.org/schema/

RabbitMQ訊息中介軟體技術精講無密完結版

第1章 課程介紹 本章首先讓大家徹底明白為什麼學習RabbitMQ，通過本課程的學習具體收穫有哪些？課程內容具體安排與學習建議，然後為大家簡單介紹下業界主流訊息中介軟體有哪些，各自適用場景等。 1-1 課程導學 1-2 業界主流訊息中介軟體介紹 第2章 低門檻，入門RabbitMQ核心概念 本

訊息中介軟體（ActiveMQ RabbitMQ KafKa對比）

轉摘自：https://blog.csdn.net/vtopqx/article/details/76382934 1)TPS比較： Kafka最高，RabbitMq 次之， ActiveMq 最差。2)吞吐量對比： kafka具有高的吞吐量，內部採用訊息的批量處理，zero-copy機制，資料

RabbitMQ訊息中介軟體技術精講（完整版）

點選下載 第1章 課程介紹 本章首先讓大家徹底明白為什麼學習RabbitMQ，通過本課程的學習具體收穫有哪些？課程內容具體安排與學習建議，然後為大家簡單介紹下業界主流訊息中介軟體有哪些，各自適用場景

某課實戰RabbitMQ訊息中介軟體技術精講

第1章 課程介紹 本章首先讓大家徹底明白為什麼學習RabbitMQ，通過本課程的學習具體收穫有哪些？課程內容具體安排與學習建議，然後為大家簡單介紹下業界主流訊息中介軟體有哪些，各自適用場景等。 1-1 課程導學 1-2 業界主流訊息中介軟體介紹 第2章 低門檻，入門Rab

RabbitMQ訊息中介軟體技術精講（已完結）

第1章 課程介紹 本章首先讓大家徹底明白為什麼學習RabbitMQ，通過本課程的學習具體收穫有哪些？課程內容具體安排與學習建議，然後為大家簡單介紹下業界主流訊息中介軟體有哪些，各自適用場景等。 1-1 課程導學 1-2 業界主流訊息中介軟體介紹 第2章 低門檻，入門Rab

SpringBoot中使用RabbitMQ訊息中介軟體

一、建立SpringBoot工程並配置RabbitMQ 1、建立SpringBoot工程，選擇RabbitMQ 2、在application.properties檔案中配置RabbitMQ //RabbitMQ的url spring.rabbitmq.addresse

更多免費初級中級高階大資料java視訊教程下載 加(微***信((號keepper,請備註java或掃下面2二3維4碼rabbitmq訊息中介軟體視訊

更多免費初級中級高階大資料java視訊教程下載 加(微***信((號keepper,請備註java或掃下面2二3維4碼rabbitmq訊息中介軟體視訊java視訊教程01-訊息中介軟體介紹及特點講解_rec.mp4java視訊教程02-訊息服務傳遞模型及各自的特點詳解_rec.mp4java視訊教程03-訊息

2018目前最新RabbitMQ訊息中介軟體技術精講（已完結）

第1章 課程介紹 本章首先讓大家徹底明白為什麼學習RabbitMQ，通過本課程的學習具體收穫有哪些？課程內容具體安排與學習建議，然後為大家簡單介紹下業界主流訊息中介軟體有哪些，各自適用場景等。 1-1 課程導學 1-2 業界主流訊息中介軟體介紹 第2章 低門檻，入門RabbitMQ核心概念 本

2019最新RabbitMQ訊息中介軟體技術精講（已完結）

第1章 課程介紹 本章首先讓大家徹底明白為什麼學習RabbitMQ，通過本課程的學習具體收穫有哪些？課程內容具體安排與學習建議，然後為大家簡單介紹下業界主流訊息中介軟體有哪些，各自適用場景等。 1-1 課程導學 1-2 業界主流訊息中介軟體介紹 第2章 低門檻，入門RabbitMQ核心概念 本

最新RabbitMQ訊息中介軟體技術精講

第1章 課程介紹 本章首先讓大家徹底明白為什麼學習RabbitMQ，通過本課程的學習具體收穫有哪些？課程內容具體安排與學習建議，然後為大家簡單介紹下業界主流訊息中介軟體有哪些，各自適用場景等。 1-1 課程導學 1-2 業界主流訊息中介軟體介紹 第2章 低門檻，入門Rabbi

rabbitMQ訊息中介軟體

訊息中介軟體 訊息中介軟體一般兩個功能,解耦和非同步處理 非同步處理: 有的時候,我們一個操作可能會耗時比較久,所以,並不會在主要業務流程裡進行處理 比如,我們在刪除一個使用者的時候,可能會有很多關聯資料的操作,為了儘快的響應以及解耦合,我們會將這個訊息傳送給其他系統,讓它

使用rabbitmq訊息中介軟體

###rabbitmq介紹: RabbitMQ是一個在AMQP基礎上完整的，可複用的企業訊息系統。它可以用於大型軟體系統各個模組之間的高效通訊，支援高併發，支援可擴充套件。 ###amqp介紹: 即Advanced Message Queuing Protocol,一

RabbitMQ訊息中介軟體技術精講實戰(百度網)

第1章 課程介紹 本章首先讓大家徹底明白為什麼學習RabbitMQ，通過本課程的學習具體收穫有哪些？課程內容具體安排與學習建議，然後為大家簡單介紹下業界主流訊息中介軟體有哪些，各自適用場景等。 1-1 課程導學 1-2 業界主流訊息中介軟體介紹 第2章 低門檻，入門Rab

RabbitMQ 訊息中介軟體如何保證消費者customer能夠成功處理訊息?

一、確保消費者customer處理訊息成功 預設情況下消費者C1接收到訊息1無論是否正常接受和處理都會立即應答rabbit伺服器，

【直播預告】：Java Spring Boot開發實戰系列課程【第11講】：訊息中介軟體 RabbitMQ 與api原始碼解析

內容概要：mq訊息中介軟體在高併發系統架構中扮演關鍵角色，阿里雙11高併發使用了mq技術。本次課程一起學習最新Java Spring Boot 2.0、RabbitMQ中介軟體的最新特性與實戰應用，同樣會分析核心api原始碼。主講人：徐雷（阿里雲棲特邀Java專家）直播時間：2019年1月8日 週二 今晚20

訊息中介軟體--RabbitMQ學習（一）

Activemq介紹 Activemq是 Apache出品,最流行的能力強勁的開源訊息匯流排,並且它個完全支援MS規範的訊息中介軟體。 其豐富的AP、多種叢集構建模式使得他成為業界老牌訊息中介軟體,在中小型企業中應用廣泛。 MQ衡量指標:服務效能、資料儲存、叢集架構

【轉】【選型】【MQ】訊息中介軟體對比

https://blog.csdn.net/huayushuangfei/article/details/80866642    訊息中介軟體對比 為什麼選擇RocketMQ 價效比，社群活躍度  價效比之“性”：  效能：阿里支撐，經受住淘寶，