任务驱动 搭建SSM开发环境

本篇主要阐述(IntelliJ IDEA + Maven + Spring + Spring MVC + Mybatis)搭建

为什么想要搭建ssm？

　　近期正好自己有一个小的点子要实现，恰好这学期开了java web的课，也算是略懂一些，所以技术方案采用java做后端，使用ssm框架。前几天把需求简单分析了一下，喏，仅仅纸上谈兵对程序员来说可不是一个好的习惯，所以准备整合一下ssm框架，供后期编码做地基。

遇到的问题：

　　不得不说，百度的东西鱼龙混杂，看了几篇博客，最终都没能搭建一个完整的ssm环境。不是这有问题就是那有问题。一想到这里就气，不过气归气，想到可能以后也会有好多人也会像我一样遇到类似的情况，但又得不到一个有效的指导，往严重了说，可能就此 一个梦想成为大牛的童鞋就此陨落🤨，所以，我决定自己再坚持搞一搞，然后出一篇文章，希望未来可以帮助到需要帮助的童鞋。

本教程思路：

　　本文采用任务驱动方式来搭建ssm开发环境，这样可以更加清晰的了解整个流程，且目标性更强，使得整个流程更为连贯，方便理解。

任务：

　　使用ssm框架实现简单的用户信息的增删查改(数据库采用Mysql)

纸上得来终觉浅，说干就干：

　　1.  首先，在本地创建一个数据库名为SSM，然后在库中建张user表，具体如下：

-- ----------------------------
--  Table structure for `user`
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

　　如图，

 

    那么，准备工作结束后，我们便开始正式的环境搭建。

　　2.  打开IDEA，点击创建新项目，如图

　　然后，按图中标注的序号选择Maven，并勾选“Create from  archetype”，选择“ ................22-archetype-webapp”，最后Next，如图

然后填写Groupid和artifactid，如图

名词解释：

然后下一步，这里引用另一位博主的说法，我没做测试，大家可以做个参考

引用：   这里需要注在Properties中添加一个参数 archetypeCatalog=internal，不加这个参数，在maven生成骨架的时候将会非常慢，有时候直接卡住。来自网上的解释：

archetypeCatalog表示插件使用的archetype元数据，不加这个参数时默认为remote，local，即中央仓库archetype元数据，由于中央

仓库的archetype太多了所以导致很慢，指定internal来表示仅使用内部元数据。

 

我直接下一步，这里会让你输入项目名词和存储路径，用默认的就OK。

点击Finish，完成创建。

　　3.  创建完成后，默认的目录结构如图：

  所以，我们需要重新编排一下项目的结构，更改后如下：

这里，各个文件夹及包的意义已经在图中做简要说明，若不理解，请自行学习。

至此，项目的基本框架已经搭建完成，接下来我们继续学习 使用maven来集成ssm框架。

　　4.  这里我们使用maven类管理jar包，和他们之间的依赖(自行了解maven相关知识)，下面我们来编辑项目下的pom.xml文件

<?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/maven-v4_0_0.xsd">  


  <modelVersion>4.0.0</modelVersion>
  <packaging>war</packaging>

  <name>SSMTest</name>
  <groupId>com.xykj</groupId>
  <artifactId>SSMTest</artifactId>
  <version>1.0-SNAPSHOT</version>

  <build>
    <plugins>
      <plugin>
        <groupId>org.mortbay.jetty</groupId>
        <artifactId>maven-jetty-plugin</artifactId>
        <version>6.1.7</version>
        <configuration>
          <connectors>
            <connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
              <port>8888</port>
              <maxIdleTime>30000</maxIdleTime>
            </connector>
          </connectors>
          <webAppSourceDirectory>${project.build.directory}/${pom.artifactId}-${pom.version}</webAppSourceDirectory>
          <contextPath>/</contextPath>
        </configuration>
      </plugin>
    </plugins>
  </build>


<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>
    <!--dependency>
      <groupId>com.xykj</groupId>
      <artifactId>[the artifact id of the block to be mounted]</artifactId>
      <version>1.0-SNAPSHOT</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>

    <!-- 添加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>
    <!-- 添加数据库连接池依赖 -->
    <dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>1.2.2</version>
    </dependency>

    <!--添加jackson-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.7.0</version>
    </dependency>

    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>1.3.2</version>
    </dependency>

    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.2.1</version>
    </dependency>



  </dependencies>

以上，就是我们项目中用到的组件，只需要在<dependency>标签中引入maven就会自动帮我们引入并管理。

　　5.  接下来，我们在resource文件夹下，新建新建jdbc.properties文件，具体如下：

模板如下，相关参数，请自行更改：

driverClasss=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql://localhost:3306/SSM?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull
username=root
password=admin

#定义初始连接数
initialSize=0
#定义最大连接数
maxActive=20
#定义最大空闲
maxIdle=20
#定义最小空闲
minIdle=1
#定义最长等待时间
maxWait=60000

　　6. 紧接着，在resource文件夹下，继续新建spring-mvc.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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-4.0.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

    <!-- 自动扫描  @Controller-->
    <context:component-scan base-package="com.xykj.controller"/>

    <!--避免IE执行AJAX时，返回JSON出现下载文件 -->
    <bean id="mappingJacksonHttpMessageConverter"
          class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
        <property name="supportedMediaTypes">
            <list>
                <value>text/html;charset=UTF-8</value>
            </list>
        </property>
    </bean>
    <!-- 启动SpringMVC的注解功能，完成请求和注解POJO的映射 -->
    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
            <list>
                <ref bean="mappingJacksonHttpMessageConverter"/> <!-- JSON转换器 -->
            </list>
        </property>
    </bean>


    <!-- 定义跳转的文件的前后缀 ，视图模式配置 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/" />
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 文件上传配置 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 默认编码 -->
        <property name="defaultEncoding" value="UTF-8"/>
        <!-- 上传文件大小限制为31M，31*1024*1024 -->
        <property name="maxUploadSize" value="32505856"/>
        <!-- 内存中的最大值 -->
        <property name="maxInMemorySize" value="4096"/>
    </bean>
</beans>

　　7.  继续在resource下，新建spring和mybatis整合所需的配置文件，名为spring-mybatis.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:context="http://www.springframework.org/schema/context" 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.1.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd
                        http://www.springframework.org/schema/tx
                        http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 开启组件扫描 -->
    <context:component-scan base-package="com.xykj.blog"/>

    <!-- 第一种方式：加载一个properties文件 -->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties"/>
    </bean>


    <!-- 第二种方式：加载多个properties文件
    <bean id="configProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
        <property name="locations">
            <list>
                <value>classpath:jdbc.properties</value>
                <value>classpath:common.properties</value>
            </list>
        </property>
        <property name="fileEncoding" value="UTF-8"/>
    </bean>
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer">
        <property name="properties" ref="configProperties"/>
    </bean>
    -->

    <!-- 配置数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close">
        <property name="driverClassName" value="${driverClasss}"/>
        <property name="url" value="${jdbcUrl}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
        <!-- 初始化连接大小 -->
        <property name="initialSize" value="${initialSize}"></property>
        <!-- 连接池最大数量 -->
        <property name="maxActive" value="${maxActive}"></property>
        <!-- 连接池最大空闲 -->
        <property name="maxIdle" value="${maxIdle}"></property>
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="${minIdle}"></property>
        <!-- 获取连接最大等待时间 -->
        <property name="maxWait" value="${maxWait}"></property>
    </bean>

    <!-- mybatis和spring完美整合，不需要mybatis的配置映射文件 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 自动扫描mapping.xml文件 -->
        <property name="mapperLocations" value="classpath:sql/*.xml"></property>
    </bean>

    <!-- DAO接口所在包名，Spring会自动查找其下的类 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.xykj.dao"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>


    <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

　　8.  web.xml配置，如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">

  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-mybatis.xml</param-value>
  </context-param>

 <!-- 编码过滤器 -->
  <filter>
    <filter-name>encodingFilter</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>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>


 <!-- spring监听器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <!-- 防止spring内存溢出监听器，比如quartz -->
  <!-- 话说这个我也不知道干嘛的 -->
  <listener>
    <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
  </listener>


  <!-- 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:spring-mvc.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>
    <!-- 此处也可以配置成 *.do 形式 -->
    <url-pattern>/</url-pattern>
  </servlet-mapping>


  <welcome-file-list>
    <welcome-file>/index.jsp</welcome-file>
  </welcome-file-list>

  <!-- session配置 -->
  <session-config>
    <session-timeout>15</session-timeout>
  </session-config>

</web-app>

忘记上这张图，进入File -> Project Structure，把对应文件夹，修改成，我这个样子：

 

　　9.  配置tomcat，步骤如下：

然后，点击窗口左上角➕，配置一个本地tomcat server

选择第一个，跳转到如下界面，点击OK。

　　10.  tomcat配置完成后,在entity包下新建一个User实体类，如下：

User类代码：

package com.xykj.entity;

import java.io.Serializable;

public class User implements Serializable{

    private int id;
    private String name;
    private String password;

    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 String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User [id= " + id + " ,name= " + name + " ,password= " + password + " ]";
    }
}

接着，我们在dao包下新增一个接口，名为：UserDao

UserDao代码如下：

package com.xykj.dao;

import com.xykj.entity.User;

public interface UserDao {
    public User findByUserId(int id);
}

然后，在resource下的sql包下新建一个UserMapper.xml文件，具体如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.xykj.dao.UserDao">
    <select id="findByUserId" parameterType="int" resultType="com.xykj.entity.User">
        SELECT * FROM user WHERE id = #{id}
    </select>
</mapper>

好嘞，到这里，我们就可以简单的测试一下我们的增删查改功能了，当然，我们的例子是findByUserId，按id查询，那么我们先在数据库中增加一条记录。

然后，在test文件夹下新建一个测试类，名为TestUserDao，如图：

TestUserDao代码如下：

import com.xykj.dao.UserDao;
import com.xykj.entity.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestUserDao {

    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-mybatis.xml");
    UserDao userDao = applicationContext.getBean(UserDao.class);

    @Test
    public void test1(){
        User user = userDao.findByUserId(1);
        System.out.println(user);
    }

}

这里，我们使用了Junit的单元测试，详情请自行了解。

运行test()，输出：

说明我们的mybatis和spring的整合已经完成。

　　11.  接下来我们继续测试spring及spring mvc

　　同样的方法，我们来编写service层及其单元测试

　　首先，在service包下，新建接口UserService，如下

代码为：

package com.xykj.service;

import com.xykj.entity.User;
import org.springframework.stereotype.Service;

@Service
public interface UserService {
    //查询User
    User queryUser(int id);
}

然后，继续在service包下，新建一个该接口的实现类UserServiceImp，如下：

代码为：

package com.xykj.service;

import com.xykj.dao.UserDao;
import com.xykj.entity.User;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class UserServiceImp implements UserService {

    @Resource
    private UserDao userDao;

    public User queryUser(int id) {
        User user = userDao.findByUserId(id);
        return user;
    }
}

到这里之后，我们在test目录下，新建测试类TestUserService，如下

代码为：

import com.xykj.entity.User;
import com.xykj.service.UserService;
import com.xykj.service.UserServiceImp;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestUserService {

    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-mybatis.xml");
    UserService userService = applicationContext.getBean(UserService.class);

    @Test
    public void test1(){
        User user = userService.queryUser(1);
        System.out.println(user);
    }

}

运行，得到如下结果，则成功，否则检查上述操作是否有误

👌，到了这步，其实我们的spring已经测试完成了。在这过程中，我们使用的注解和自动注入等spring功能都可正常使用。

　　12.  13

首先，我们在controller包下新建一个类，如图：

代码为：

package com.xykj.controller;

import com.xykj.entity.User;
import com.xykj.service.UserService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;

@Controller
@RequestMapping("/test")
public class UserController {

    @Resource
    private UserService userService;

    @ResponseBody
    @RequestMapping(method = RequestMethod.GET)
    public User func(){
        User user = userService.queryUser(1);
        return user;
    }

}

👌，接下来我们在webapp目录下新建一个index.jsp文件(默认启动该页面),编写该页面测试UserController，进而测试spring mvc.

不过在这之前，请先将UserController的func()方法添加一个参数，更改如下：

index.jsp如下：

　　13.  最后，我们启动tomcat服务器，进行最后的测试：

输入1，点击提交

见到改返回，那么一切大功告成。

希望大家遇到什么问题，可以在留言区留言，有时间的话会第一时间给予解答😁