SSM框架介绍与搭建

1.ssm简介ssm实际上是三种框架的集成，它们分别是Spring，SpringMVC以及mybatis。笔者的个人见解更愿意认为ssm是一个优秀的平台，在这个平台上开发者可以更有效率的实现CRUD，制定诸多事务以及进行成本更小的维护等操作。Spring是非常经典的java bean容器，它可以非常有效率的实现对java bean（也包括分离出的DAO和Service）的管理。以往笔者...

至尊小宝宝

16013人浏览 · 2018-08-14 13:03:59

至尊小宝宝 · 2018-08-14 13:03:59 发布

1.ssm简介

ssm实际上是三种框架的集成，它们分别是Spring，SpringMVC以及mybatis。笔者的个人见解更愿意认为ssm是一个优秀的平台，在这个平台上开发者可以更有效率的实现CRUD，制定诸多事务以及进行成本更小的维护等操作。

Spring是非常经典的java bean容器，它可以非常有效率的实现对java bean（也包括分离出的DAO和Service）的管理。

以往笔者在开发的过程中，比方在Student类中要用到Teacher类中的checkName方法，而checkName方法中用到NameBook类中的showName方法（假设上述方法均不为静态，则需要非静态调用），笔者的第一反应肯定是在Student类中通过关键字new创建一个Teacher实例，在teacher类中new出NameBook实例，再通过teacher.checkName和nameBook.showName来实现对其他类中非静态方法的调用。

上述过程中，其实Student类对Teacher类和NameBook类产生了依赖，这种依赖关系通常被称为耦合，通常耦合对后期的维护是非常不利的，比如NameBook类中的showName方法发生了改变，会影响到student类的运作，对预想的业务逻辑会产生不良干扰，所以这里笔者个人认为Spring的诞生很大一部分功能是为了解耦，使用了Spring之后不再通过new关键字创建实例的方式来调用，而是管理bean的权限移交给Spring容器，bean会以被动的形式在需要的时候被注入到相应的类中去，从而实现相应的逻辑。这一过程实际也叫作IOC（控制反转），是Spring的核心内容之一。

Springmvc作为控制层的web框架，全方面替代了Struts2，在action层面进行拦截，使用注解的方式来定义controller中的antion，在xml中配置自动扫描即可实现业务的跳转。并且由于是spring大家族的产品，对spring的兼容性几乎到达百分之百兼容。

mybatis是当下较为流行的持久层框架，相比于hibernate，我个人觉得mybatis更加轻量级，它抛弃了传统的硬编码编写sql语句的方式（硬编码指的是sql语句往往被写死在类文件中，不利于扩展）。mybatis采用xml配置sql语句的方式，sql形式多样，便于扩展和后期维护。

本文讲解搭建上述三大框架集成的maven工程项目。

IDE：myeclipse，JDK版本：1.7，启动方式：tomcat。

2.创建maven工程并导入依赖

首先在myeclipse中创建maven工程并转换成maven WebApp，具体步骤参考我之前的博文maven安装配置与创建工程，这里不再赘述。

下面是需要在pom.xml文件中添加的依赖，可能部分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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>ssm1</groupId>
  <artifactId>ssm1</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>ssm1</name>
  <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>  
  
    <!-- 添加fastjson -->  
    <dependency>  
      <groupId>com.alibaba</groupId>  
      <artifactId>fastjson</artifactId>  
      <version>1.1.41</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 -->  
    <!-- 映入JSON -->  
    <dependency>  
      <groupId>org.codehaus.jackson</groupId>  
      <artifactId>jackson-mapper-asl</artifactId>  
      <version>1.9.13</version>  
    </dependency>  
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->  
    <dependency>  
      <groupId>com.fasterxml.jackson.core</groupId>  
      <artifactId>jackson-core</artifactId>  
      <version>2.8.0</version>  
    </dependency>  
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->  
    <dependency>  
      <groupId>com.fasterxml.jackson.core</groupId>  
      <artifactId>jackson-databind</artifactId>  
      <version>2.8.0</version>  
    </dependency>  
  
    <!-- 文件上传相关依赖 -->
    <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>  
  
    <!-- https://mvnrepository.com/artifact/com.github.abel533/ECharts -->  
    <dependency>  
      <groupId>com.github.abel533</groupId>  
      <artifactId>ECharts</artifactId>  
      <version>3.0.0</version>  
    </dependency>  
  
    <dependency>  
      <groupId>com.google.code.gson</groupId>  
      <artifactId>gson</artifactId>  
      <version>2.5</version>  
      <scope>compile</scope>  
      <optional>true</optional>  
    </dependency>  
  
    <dependency>  
      <groupId>net.sf.jxls</groupId>  
      <artifactId>jxls-core</artifactId>  
      <version>1.0.5</version>  
    </dependency>  
  </dependencies>  
  
  <build>
    <finalName>ssm1</finalName>
    <pluginManagement>
      <plugins>
        <plugin>
          <groupId>org.eclipse.m2e</groupId>
          <artifactId>lifecycle-mapping</artifactId>
          <version>1.0.0</version>
          <configuration>
            <lifecycleMappingMetadata>
              <pluginExecutions>
                <pluginExecution>
                  <pluginExecutionFilter>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-resources-plugin</artifactId>
                    <versionRange>[2.5,)</versionRange>
                    <goals>
                      <goal>resources</goal>
                    </goals>
                  </pluginExecutionFilter>
                  <action>
                    <ignore/>
                  </action>
                </pluginExecution>
              </pluginExecutions>
            </lifecycleMappingMetadata>
          </configuration>
        </plugin>
      </plugins>
    </pluginManagement>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

上述依赖成功添加后，进入正式开发步骤，先贴上我的项目完整目录。

总共有六个包。

controller：放置控制器，控制器即在控制层控制逻辑业务跳转的类文件。
dao：dao层的接口及其实现类都放在这个包下，其中包含BaseDao，BaseDao抽象出了基本的增删改查，其他各Dao均需要继承此BaseDao来获得增删改查方法。
entity：根据数据库中的表创建的实体类放在这个包下。
interceptor：拦截器类文件放在这个包下，此包非必需创建，有业务需求可根据自身情况创建拦截器。
mapper：mybatis根据这个包下的xml文件对持久层进行操作，一个Dao对应一个Mapper.xml文件（BaseDao除外）。
service：业务层的接口与实现类放在这个包下，包含具体业务逻辑。

上述分层的目的其实就是让控制层去调用业务层，业务层调用dao层。这么调用的目的其实就是要做到解耦，抽离出公共的业务，将各层代码之间的耦合度降到最低。而Spring会帮助我们管理这些层的接口和实现类，在有依赖需求的时候将其注入，减少了代码中new关键字的出现，大大降低耦合度。

3.基本配置文件

首先在src/main/resources下新建如下几个文件：

jdbc.properties是我的数据库配置文件，具体内容如下，要根据你们自己的数据库做修改：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/你的数据库名
username=你的数据库登录账号
password=你的数据库登录密码
c3p0.pool.maxPoolSize=400
c3p0.pool.minPoolSize=50
c3p0.pool.initialPoolSize=50
c3p0.pool.acquireIncrement=100

log4j.properties是我的日志信息配置，可以不设置这个文件，具体内容如下：

log4j.rootLogger=INFO,Console,File
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.Target=System.out
log4j.appender.Console.layout = org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n
log4j.appender.File = org.apache.log4j.RollingFileAppender
log4j.appender.File.File = logs/ssm.log
log4j.appender.File.MaxFileSize = 10MB
log4j.appender.File.Threshold = ALL
log4j.appender.File.layout = org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n

applicationContenxt.xml是Spring的配置文件，其中各标签的功能都已经详尽注释，内容如下：

<?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:jdbc.properties"/>
		
		<!-- 2.包扫描:dao,service -->
		<context:component-scan base-package="com.huang.dao,com.huang.service"/>
	
		<!-- 3,dataSource数据源 -->
		<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
			<property name="driverClass" value="${driver}"/>
			<property name="jdbcUrl" value="${url}"/>
			<property name="user" value="${username}"/>
			<property name="password" value="${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/huang/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.huang.service.*.*(..))" id="txPointcut"/>
			<aop:advisor advice-ref="txAdivce" pointcut-ref="txPointcut"/>
		</aop:config>
		
		<!-- 开启事务注解驱动 -->
	    <!-- <tx:annotation-driven transaction-manager="txManager" /> -->
	
</beans>

SpringMVC.xml是Springmvc的配置文件，根据这个文件对配置了注解controller进行扫描，内容如下：

<?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.huang.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=".jsp"/>
	</bean>
	
	<!-- 3.注解驱动 -->
	<mvc:annotation-driven/>
	
	<!-- 4.拦截器配置，根据自身业务配置，若无需求可不配置 -->
<!-- 	<mvc:interceptors>
		<mvc:interceptor>
			<mvc:mapping path="/**"/>
			<bean class="com.huang.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>

sqlMapConfig.xml是mybatis的配置文件，但是由于我搭建的是集成框架，这个文件可以不用配置，数据库管理权转交给Spring，相关配置已在applicationContext.xml中配置过了。

最后在web.xml中配置Spring的过滤器，springmvc的前端控制分发器以及编码过滤器，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	version="3.0">
	<display-name>Archetype Created Web Application</display-name>
	
	<welcome-file-list>
		<welcome-file>/index.jsp</welcome-file>
	</welcome-file-list>
	
	<!-- 加载spring bean -->
    <context-param>
         <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
	<!-- 编码过滤器 -->
	<filter>
		<filter-name>encodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<async-supported>true</async-supported>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>encodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	
	<!-- Spring MVC servlet -->
	<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.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
		<async-supported>true</async-supported>
	</servlet>
	<servlet-mapping>
		<servlet-name>SpringMVC</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
	
</web-app>

至此，配置文件均已配置完毕，下面进入各层类文件编写。

4.实体层编写

实体层可以单独开发，根据你自己数据库里的表创建对应的实体类，下面是我的一个实体类具体代码：

package com.huang.entity;

import java.util.Date;

/**
 * @author 黄政豪
 * @date 2018年7月20日 下午2:44:46
 * @description:实体类
 *
 */
public class Retailer {

	private String retailerid;
	private String name;
	private String telphone;
	private String address;
	private Date createtime;
	public String getRetailerid() {
		return retailerid;
	}
	public void setRetailerid(String retailerid) {
		this.retailerid = retailerid;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getTelphone() {
		return telphone;
	}
	public void setTelphone(String telphone) {
		this.telphone = telphone;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public Date getCreatetime() {
		return createtime;
	}
	public void setCreatetime(Date createtime) {
		this.createtime = createtime;
	}
	
}

5.Dao层编写

接下来进行Dao层编写，由于dao层是三层之中的最底层，也就是最基本的一层，所以需要抽象出一个接口，接口中应该包含上层所有业务接口都能调用的增删改查方法。这里我把这个基本接口命名为BaseDao，具体代码如下：

package com.huang.dao;

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

import org.apache.poi.ss.formula.functions.T;

import com.huang.entity.User;

public interface BaseDao<T> {
	public T get(Serializable id);

	public List<T> find(Map map);

	public void insert(T entity);

	public boolean update(T entity);

	public void deleteById(Serializable id);

	public void delete(Serializable[] ids);

}

其中参数都指定为泛型或者是序列化接口（Serializeble）。java中大多包装类（String，Integer，Double等）基本都实现了serializable接口，因此上面这个实体中参数类型可为所有实现了序列化接口的类型。

这么做的好处就是实现类和业务层在调用时不用担心由于业务不同而导致传入参数不同的问题，我个人认为这就是软件架构设计中抽象的核心概念，实现复用。

BaseDao实现类代码如下：

package com.huang.dao.impl;

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

import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.poi.ss.formula.functions.T;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import org.springframework.beans.factory.annotation.Autowired;

import com.huang.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);  
    }  
	
	public String ns;
	
	public String getNs() {
		return ns;
	}

	public void setNs(String ns) {
		this.ns = ns;
	}

	@Override
	public T get(Serializable id) {
		// TODO Auto-generated method stub
		return this.getSqlSession().selectOne(ns+".get", id);
	}

	@Override
	public List<T> find(Map map) {
		// TODO Auto-generated method stub
		List<T> list = this.getSqlSession().selectList(ns+".find", map);
		return list;
	}

	@Override
	public void insert(T entity) {
		// TODO Auto-generated method stub
		this.getSqlSession().insert(ns+".insert", entity);
	}

	@Override
	public boolean update(T entity) {
		// TODO Auto-generated method stub
		this.getSqlSession().update(ns+".update", entity);
		return true;
	}

	@Override
	public void deleteById(Serializable id) {
		// TODO Auto-generated method stub
		this.getSqlSession().delete(ns+".deleteById", id);
		
	}

	@Override
	public void delete(Serializable[] ids) {
		// TODO Auto-generated method stub
		this.getSqlSession().delete(ns+".delete", ids);
	}

	

}

实现类中设定了ns参数和它的get，set方法，这么做的目的是让dao层其他实现类继承basedao实现类后能通过设置命名空间的方式让每一个dao去正确匹配自己的Mapper.xml文件。

ns+".method"，ns会在每个entityDao中通过setNs设置，method务必要和后面配置的Mapper.xml中的方法id一致。

由于我使用的mybatis-spring的jar包版本是1.2，所以在实现类中必须通过注解注入setSqlSessionFactory方法，这样spring才能在其配置文件中成功加载datasource数据源。

接下来编写实体类对应的Dao，代码如下：

package com.huang.dao;

import java.io.Serializable;

import com.huang.entity.Retailer;

/**
 * @author 黄政豪
 * @date 2018年7月20日 下午2:46:31
 * @description:
 *
 */
public interface RetailerDao extends BaseDao<Retailer>{

	public void deleteByName(Serializable name);

}

这里我在dao中还定义了额外的方法，这是根据Retailer这个实体的业务需求增加的，需要在其实现类中添加具体逻辑。RetailerDao通过继承了BaseDao后能调用父类中的方法对Retailer表进行增删改查操作。这里个人建议将基本操作抽象到basedao中，每个实体额外的业务逻辑方法定义在具体的entityDao中。

RetailerDao实现类代码如下：

package com.huang.dao.impl;

import java.io.Serializable;

import org.springframework.stereotype.Repository;

import com.huang.dao.RetailerDao;
import com.huang.entity.Retailer;

/**
 * @author 黄政豪
 * @date 2018年7月20日 下午2:47:09
 * @description:Dao实现类
 *
 */
@Repository
public class RetailerDaoImpl extends BaseDaoImpl<Retailer> implements RetailerDao{

	public RetailerDaoImpl() {
		// TODO Auto-generated constructor stub
		super.setNs("com.huang.mapper.RetailerMapper");
	}

	@Override
	public void deleteByName(Serializable name) {
		// TODO Auto-generated method stub
		this.getSqlSession().delete(this.getNs()+".deleteByName", name);
	}
	
	
}

这里设置了命名空间，并重写了额外添加的方法。

@repository这个注解的功能是能让Spring扫描到加了该注解的Dao层组件，必须加上。

至此，Dao层编写结束。

6.业务层编写

接下来进行业务层的编写。

RetailerService代码如下：

package com.huang.service;

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

import com.huang.entity.Retailer;
import com.huang.entity.User;

/**
 * @author 黄政豪
 * @date 2018年7月20日 下午2:50:32
 * @description:业务层接口
 *
 */
public interface RetailerService {
	
	public Retailer get(Serializable name);
	public List<Retailer> find(Map map);
	public void insert(Retailer retailer);
	public void update(Retailer retailer);
	public void deleteByName(Serializable name);
	public void delete(Serializable[] names);

}

其实这里传入的参数可以具体设置为对应的基本类型或者是实体，这里我将原来的泛型改成了Retailer实体，其它还是使用serializable接口，不影响系统功能。

实现类代码如下：

package com.huang.service.impl;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.huang.dao.RetailerDao;
import com.huang.entity.Retailer;
import com.huang.service.RetailerService;

/**
 * @author 黄政豪
 * @date 2018年7月20日 下午2:56:10
 * @description:service实现类
 *
 */
@Service
public class RetailerServiceImpl implements RetailerService{

	@Autowired
	RetailerDao retailerDao;
	
	@Override
	public Retailer get(Serializable name) {
		// TODO Auto-generated method stub
		return retailerDao.get(name);
	}

	@Override
	public List<Retailer> find(Map map) {
		// TODO Auto-generated method stub
		return retailerDao.find(map);
	}

	@Override
	public void insert(Retailer retailer) {
		// TODO Auto-generated method stub
		retailerDao.insert(retailer);
	}

	@Override
	public void update(Retailer retailer) {
		// TODO Auto-generated method stub
		retailerDao.update(retailer);
	}

	@Override
	public void deleteByName(Serializable name) {
		// TODO Auto-generated method stub
		retailerDao.deleteByName(name);
	}

	@Override
	public void delete(Serializable[] names) {
		// TODO Auto-generated method stub
		retailerDao.delete(names);
	}

}

@service注解功能是让Spring扫描到加了该注解的service层组件，@AutoWired是将dao层组件注入到service层，从而service层不再需要new关键字就可以调用dao层组件。

@service注解在service层接口实现类中必须加上，service在调用dao层组件时必须用@AutoWired或者是@Resource注解让spring为service层注入dao层组件。

7.Mapper.xml编写

接下来编写映射文件Mapper.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.huang.mapper.RetailerMapper">
	<!-- resultMap映射 -->
	<resultMap type="com.huang.entity.Retailer" id="retailer">
		<!-- 主键 -->
		<id property="retailerid" column="retailerid" jdbcType="VARCHAR" />
		<!-- 一般属性 -->
		<result property="name" column="name" />
		<result property="telphone" column="telphone" />
		<result property="address" column="address" />
		<result property="createtime" column="createtime" />
	</resultMap>

	<!-- 查询一个 -->
	<select id="get" parameterType="java.lang.String" resultMap="retailer">
		select * from retailer
		where name=#{name}
	</select>

	<!-- 查询 -->
	<select id="find" parameterType="java.util.HashMap" resultMap="retailer">
		select * from retailer
		where 1=1
		<if test="name != null"> and name=#{name}</if>
		<if test="telphone != null"> and telphone=#{telphone}</if>
		<if test="address != null"> and address like #{address}</if>
	</select>

	<insert id="insert" parameterType="com.huang.entity.Retailer">
		insert into retailer
		(retailerid,name,telphone,address,createtime)
		values
		(
		#{retailerid,jdbcType=VARCHAR},
		#{name,jdbcType=VARCHAR},
		#{telphone,jdbcType=VARCHAR},
		#{address,jdbcType=VARCHAR},
		#{createtime,jdbcType=DATE}
		)
	</insert>

	<!-- 修改语句 -->
	<update id="update" parameterType="com.huang.entity.Retailer">
		update retailer
		<trim prefix="set" suffixOverrides=",">
		<if test="telphone != null"> telphone=#{telphone},</if>
		<if test="address != null">  address=#{address}</if>
		</trim>
		where name = #{name}
	</update>

	<!-- 删除一条 -->
	<delete id="deleteByName" parameterType="java.lang.String">
		delete from retailer
		where
		name=#{name}
	</delete>

	<!-- 删除多条(一维字符串数组的形式) -->
	<delete id="delete" parameterType="java.lang.String">
		delete from retailer
		where name in
		<foreach collection="array" item="name" open="(" close=")"
			separator=",">
			#{name}
		</foreach>
	</delete>
</mapper>

xml各标签中id的值必须和service以及Dao层定义的接口名一样，否则mybatis会找不到对应的方法。

另外jdbcType后面跟的类型务必大写。

Mapper namespace的值和Dao层实现类中setNs的值务必保持一致。

8.控制层编写

控制层控制页面的跳转，在Springmvc里提供了注解的方式配置页面跳转的路由。

我的控制器代码如下：

package com.huang.controller;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.huang.entity.Retailer;
import com.huang.service.RetailerService;

/**
 * @author 黄政豪
 * @date 2018年7月20日 下午3:01:56
 * @description:retailer控制器
 *
 */
@Controller
@ResponseBody
@RequestMapping("/retailer")
public class RetailerController {

	@Autowired
	RetailerService service;

	@RequestMapping("/findOne")
	public Retailer findOne(HttpServletRequest request){
		String name = request.getParameter("name");
		return service.get(name);
	}

	@RequestMapping("/find")
	public List<Retailer> find(Retailer retailer){
		Map<String,String> map = new HashMap<String,String>();
		if(retailer.getName()!=null){
			map.put("name", retailer.getName());
		}
		if(retailer.getTelphone()!=null){
			map.put("telphone", retailer.getTelphone());
		}
		if(retailer.getAddress()!=null){
			map.put("address", retailer.getAddress());
		}
		return service.find(map);
		
	}

	@RequestMapping("/addRetailer")
	public String addRetailer(HttpServletRequest request){
		Retailer retailer = new Retailer();
		String name = request.getParameter("name");
		Date date = new Date(System.currentTimeMillis());
		retailer.setCreatetime(date);
		if(name!=null){
			String retailerid = (UUID.randomUUID().toString());
			retailer.setRetailerid(retailerid);
			retailer.setName(name);
			if(request.getParameter("telphone")!=null){
				retailer.setTelphone(request.getParameter("telphone"));
			}
			if(request.getParameter("address")!=null){
				retailer.setAddress(request.getParameter("address"));
			}
			service.insert(retailer);
			return " insert success";
		}else {
			return "name must not be null";
		}
	}
	
	@RequestMapping("/update")
	public String update(Retailer retailer){
		if(retailer.getTelphone().equals("")&&retailer.getAddress().equals("")){
			return "no data should be updated.";
		}
		System.out.println(retailer.getName());
		service.update(retailer);
		return "update success.";
	}
	
	
	@RequestMapping("/deleteByName")
	public String delete(Retailer retailer,HttpServletRequest request){
		String name = retailer.getName();
		service.deleteByName(name);
		return "data of "+name+" has been deleted.";
	}
}

一个controller需要在类名上方配置@controller才能被spring正确的扫描。

@RequestMapping就是控制路由跳转的注解，可以只配置在方法名上方，也可以方法名和类名上方都配置，比如上面我两个地方都配置了，通过tomcat部署并启动项目，那么如果我要请求find方法内部的业务，那么需要输入的url应该是：http://localhost:8080/ssm1/retailer/find，其中ssm1是我的项目名。

如果访问的方法要求某些参数，由于这里我在RequestMapping中没有定义method的种类，所以最简单的携参形式就是用get方法在url里直接附上需要的参数，比如我访问findOne方法，要求要带有key值为name的参数，我可以通过http://localhost:8080/ssm1/retailer/findOne?name=黄政豪这样的形式成功访问。

@ResponseBody注解能够把返回的对象（object）统统转化为JSON格式输出在页面，比如上面我访问findOne方法，最后的页面上会显示如下结果：

至此，Spring+SpringMVC+mybatis的maven工程已经搭建完毕。

其中我认为尤其重要的是将Controller层和Service层进行抽象，将基础业务全部封装在Dao层。事实上抽象也是软件设计中核心的概念之一，它最终会达到解耦的目的，表现为上述项目中三层的分离。

另外Spring的控制反转和SpringMVC的注解也对上述项目起到了至关重要的作用，回顾此次搭建的过程，我认为面向接口编程的理念真的妙不可言。

上述项目的源码我已经上传到我自己的github上了，有需要参考的朋友可以去下载。传送门：至尊小宝宝的github

需要说明的是，数据库脚本我还是和以往一样没有给出，因为我觉得数据库完全是根据自己的意愿想怎么建就怎么建，只是实体类也需要对应而已，完全没必要生搬硬套我的数据库，我们的业务需求肯定是天差地别的，所以数据库还是要自己为自己的项目量身定做。如果数据库都要照样画葫芦，那我觉得真的非常可悲了。。。

最后，有不足之处还望大家补充和指正。

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...