如何使用Gradle快速搭建SSM框架

介绍

SSM

何谓SSM？即Spring + Spring MVC + Mybatis，是较为流行的同步堵塞后端框架，基于Servlet构建。一般在Spring后端项目中，该框架为必选。而随着Spring Boot的发布，可以直接实现集成各类框架，就包含了SSM中3个框架，故如今手动搭建SSM的方式更多用于学习。

流程

如果不想看，直接嫖完整代码：github.com/Littleor/SS…

工欲善其事必先利其器，这里选用IDEA来搭建，使用Gradle 7.1来构建，JDK16来运行。

创建Gradle工程

这里建议新手通过IDEA创建，也可以通过gradle命令行创建。

选择Gradle，记得勾选Java和Web。

然后等待初始化完成就行。

添加必备依赖

将下面的依赖添加到dependencies中，注意为了避免后面出现问题，下面的依赖包含了本文所有依赖。

    implementation 'org.springframework:spring-webmvc:5.3.9'
    implementation 'org.springframework:spring-beans:5.3.9'
    implementation 'org.springframework:spring-context:5.3.9'
    implementation 'org.springframework:spring-context-support:5.3.9'
    implementation 'org.springframework:spring-web:5.3.9'
    implementation 'org.springframework:spring-tx:5.3.9'
    implementation 'org.springframework:spring-jdbc:5.3.9'
    implementation 'org.springframework:spring-test:5.3.9'
    implementation 'org.mybatis:mybatis:3.5.7'
    implementation 'mysql:mysql-connector-java:8.0.25'
    implementation 'org.mybatis:mybatis-spring:2.0.6'
    implementation 'org.mybatis:mybatis-spring:2.0.6'
    implementation 'com.alibaba:druid-spring-boot-starter:1.2.6'
    implementation 'org.slf4j:slf4j-log4j12:1.7.32'
    implementation 'log4j:log4j:1.2.17'
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.12.4'
    implementation 'com.fasterxml.jackson.core:jackson-annotations:2.12.4'

然后保存安装依赖即可。

添加Mybatis逆向task

Mybatis逆向即从数据库中的库表结构生成对应的实体类和Mapper。

首先配置好Mybatis的连接信息，在resources下创建jdbc_config.properties文件后输入：

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://ip:3306/database?useUnicode=true&characterEncoding=UTF-8
jdbc.username=username
jdbc.password=password
package.model=org.mybatis.entity
package.mapper=org.mybatis.mapper
package.xml=mybatis/mapping

注意替换成你的数据库地址、账号和密码等信息。

再在resources下创建spring-mybatis.xml来配置Mybatis:

<?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-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/mvc
 http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
    <!-- 自动扫描 -->
    <context:component-scan base-package="org.mybatis.mapper"/>
    <!-- 引入配置文件 -->
    <bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc_config.properties"/>
    </bean>

    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.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>

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

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

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

</beans>

再在resources下创建generatorConfig.xml来配置生成器:

<?xml version="1.0" encoding="UTF-8"?>
<!--配置文件详解https://www.cnblogs.com/ygjlch/p/6471924.html-->
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--
    context:生成一组对象的环境
    id:必选，上下文id，用于在生成错误时提示
    defaultModelType:指定生成对象的样式
        1，conditional：类似hierarchical；
        2，flat：所有内容（主键，blob）等全部生成在一个对象中；
        3，hierarchical：主键生成一个XXKey对象(key class)，Blob等单独生成一个对象，其他简单属性在一个对象中(record class)
    targetRuntime:
        1，MyBatis3：默认的值，生成基于MyBatis3.x以上版本的内容，包括XXXBySample；
        2，MyBatis3Simple：类似MyBatis3，只是不生成XXXBySample；
    introspectedColumnImpl：类全限定名，用于扩展MBG
-->
    <context id="default" targetRuntime="MyBatis3Simple" defaultModelType="flat">
        <!-- 生成的pojo，将implements Serializable -->
        <plugin type="org.mybatis.generator.plugins.SerializablePlugin"/>
        <commentGenerator>
            <!-- 注释生成器（false 开启默认 true关闭） -->
            <property name="suppressAllComments" value="true"/>
            <!-- 注释生成器时间显示（false 开启默认 true关闭） -->
            <property name="suppressDate" value="true"/>
            <!-- java 文件编码格式  -->
            <property name="javaFileEncoding" value="utf-8"/>
            <!--格式化java代码-->
            <property name="javaFormatter" value="org.mybatis.generator.api.dom.DefaultJavaFormatter"/>
            <!-- 格式化XML代码 -->
            <property name="xmlFormatter" value="org.mybatis.generator.api.dom.DefaultXmlFormatter"/>
        </commentGenerator>

        <!-- jdbc 连接信息  -->
        <jdbcConnection driverClass="${driverClass}"
                        connectionURL="${connectionURL}"
                        userId="${userId}"
                        password="${password}">
            <property name="nullCatalogMeansCurrent" value="true"/>
        </jdbcConnection>
        <!-- 定义java类型解析器的属性 -->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>

        <!-- 实体类所在包名 -->
        <javaModelGenerator targetPackage="${modelPackage}" targetProject="${src_main_java}">
            <property name="enableSubPackages" value="true"/>
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>

        <!-- 生成映射文件配置 xml 所在包名 -->
        <sqlMapGenerator targetPackage="${sqlMapperPackage}" targetProject="${src_main_resources}">
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>
        <!--
               type= ANNOTATEDMAPPER 表示不生成xml文件
               这里我用 XMLMAPPER
               -->
        <!-- org.mapper 所在包名 -->
        <javaClientGenerator targetPackage="${mapperPackage}" targetProject="${src_main_java}" type="XMLMAPPER">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>

        <!-- 要生成的表 -->
        <!-- 这里的百分号代表对该数据库中所有的表进行生成 -->
        <table tableName="%">
            <generatedKey column="id" sqlStatement="Mysql" identity="true"/>
        </table>
    </context>
</generatorConfiguration>

到此配置就好了，现在在build.gradle配置task，在最后添加下述代码：

configurations {
    mybatisGenerator
}
dependencies {
    //  mybatis-generator mybatis逆向
    mybatisGenerator 'org.mybatis.generator:mybatis-generator-core:1.4.0'
    mybatisGenerator 'mysql:mysql-connector-java:8.0.25'
    mybatisGenerator 'tk.mybatis:mapper:4.1.5'
}

def getDbProperties = {
    def properties = new Properties()
    file("src/main/resources/jdbc_config.properties").withInputStream { inputStream ->
        properties.load(inputStream)
    }
    properties
} as Object

task mybatisGenerator {
    def properties = getDbProperties()
    ant.properties['targetProject'] = projectDir.path
    ant.properties['driverClass'] = properties.getProperty("jdbc.driverClassName")
    ant.properties['connectionURL'] = properties.getProperty("jdbc.url")
    ant.properties['userId'] = properties.getProperty("jdbc.username")
    ant.properties['password'] = properties.getProperty("jdbc.password")
    ant.properties['src_main_java'] = sourceSets.main.java.srcDirs[0].path
    ant.properties['src_main_resources'] = sourceSets.main.resources.srcDirs[0].path
    ant.properties['modelPackage'] = properties.getProperty("package.model")
    ant.properties['mapperPackage'] = properties.getProperty("package.mapper")
    ant.properties['sqlMapperPackage'] = properties.getProperty("package.xml")
    ant.taskdef(
            name: 'mbgenerator',
            classname: 'org.mybatis.generator.ant.GeneratorAntTask',
            classpath: configurations.mybatisGenerator.asPath
    )
    ant.mbgenerator(overwrite: true,
            configfile: 'src/main/resources/generatorConfig.xml', verbose: true) {
        propertyset {
            propertyref(name: 'targetProject')
            propertyref(name: 'userId')
            propertyref(name: 'driverClass')
            propertyref(name: 'connectionURL')
            propertyref(name: 'password')
            propertyref(name: 'src_main_java')
            propertyref(name: 'src_main_resources')
            propertyref(name: 'modelPackage')
            propertyref(name: 'mapperPackage')
            propertyref(name: 'sqlMapperPackage')
        }
    }
}

在resources下创建对应的文件夹:Mybatis/entity和Mybatis/Mapper然后运行下mybatisGenerator即可实现生成。

到此逆向完成。

Spring配置

接下来我们要把我们的项目跑在Tomcat中了，那就得现配置好Spring，在resource下创建applicationContext.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:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--Spring会去自动扫描base-package的值所表示的包的位置中的java文件，如果扫描到有@Component、@Controller、@Service、@Repository等类似注解的类，会将这个类注册为Bean-->
    <context:component-scan base-package="org.controller"/>

    <!-- 开启SpringMVC注解模式 -->
    <mvc:annotation-driven/>
    <!-- 静态资源默认servlet配置 -->
    <mvc:default-servlet-handler/>

    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>


</beans>

然后配置好Web，在web目录下的WEB-INF的web.xml配置如下（没有就创建）：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!-- 编码过滤器 -->
    <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>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- web容器启动/停止监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
    </listener>

    <!-- web容器与spring上下文整合的监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- Spring和mybatis的配置文件 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mybatis.xml</param-value>
    </context-param>

    <!-- 配置springmvc的前端控制器：dispatcherServlet -->
    <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:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <async-supported>true</async-supported>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <!-- 此处可以可以配置成*.do，对应struts的后缀习惯 -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

到此所有Spring相关配置完成。

控制器编写

为了测试，我们这里在java目录下添加个包org.controller，创建UserController文件

/**
 * @author Littleor <me@littleor.cn>
 * @createTime 2021/8/20 17:32
 */
package org.controller;

import org.mybatis.entity.User;
import org.mybatis.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;
import java.util.List;

@RestController
public class UserController {
    @Autowired
    private UserMapper userMapper;

    @RequestMapping(value = "/insert", produces = {"application/json; charset=UTF-8"})
    @ResponseBody
    public String insertUser() {
        User user = new User();
        user.setName("小明");
        user.setPassword("44555");
        user.setCreateTime(new Date());
        userMapper.insert(user);
        return user.toString();
    }

    @RequestMapping(value = "/findAll", produces = {"application/json; charset=UTF-8"})
    public List<User> findAll() {
        return userMapper.selectAll();
    }
}

然后就可以愉快的开始进行测试了。

Tomcat配置

上述应该问题不大，从这里开始就都是坑了，首先去下载安装Tomcat，这里我用的版本对应的Tomacat为9.x版本。这里默认你安装好了，那就直接在IDEA中配置：

点击编辑配置，然后创建一个Tomcat服务：

然后配置好Tomcat相关的内容：端口和Tomcat的路径。

然后再去配置好部署的war包：

配置好对应的构建物，然后选择好context即可完成配置。

到此完成了所有配置了，坑要开始了。

启动Tomcat

选中刚刚的配置，然后点击右边的运行按钮就行了，是不是很简单？

等待其构建完成，然后部署到Tomcat即可，然后访问http://localhost:8080/ssm/insert就可以插入用户了。

到此一个简单的SSM框架搭建完成，恭喜你完成了所有配置，但是别高兴的太早运行的时候你可能会遇到以下问题。

坑！！！

Tomcat的log问题

在运行的时候你可能会遇到这样的错误：

log4j:WARN No appenders could be found for logger (org.springframework.web.context.ContextLoader).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.

虽然只是个warn，但是看起来很不爽，这里安装对应的依赖（见开头的依赖配置）后，再在resources下添加log4j.properties文件，配置：

log4j.rootLogger=WARN, console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.conversionPattern=%5p [%t] (%F:%L) - %m%n

即可去掉该WARN。

Mybatis Mapper重复问题

去掉WARN后你再运行就可能会遇到ERROR了：

Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'sqlSessionFactory' defined in class path resource [spring-mybatis.xml]: Invocation of init method failed; nested exception is org.springframework.core

这里一看是同名了，打开resources下的mybatis/mapping下的文件一看，会有id重复的内容，故直接删除mybatis/mapping目录再运行就解决了。

玄学问题

当然你还更有可能遇到玄学：

java.lang.NoClassDefFoundError: javax/servlet/ServletRequestListener

这个一般就是玄学/版本问题，如果检查Tomcat版本没有问题的话，就直接重启一遍解决。

MVC返回对象无法解析为JSON问题

这个就是个优化问题了，一般我们的后端返回对象，框架都会帮我们解析为JSON返回，但是呢，Spring MVC需要自己配置...（上述的配置已经帮你配置啦！）

首先安装好依赖:

    implementation 'com.fasterxml.jackson.core:jackson-databind:2.12.4'
    implementation 'com.fasterxml.jackson.core:jackson-annotations:2.12.4'

然后在applicationContext.xml添加配置：

    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>

后记

到此，基于Gradle的SSM框架搭建完成。如果有任何疑问可以参考Github上的完整代码： 原文地址