前言:目前大部分的 Java 互联网项目,都是用 Spring MVC + Spring + MyBatis 搭建平台的。毫无疑问,SSM框架已经成了 Java 互联网技术主流框架组合,它们经受住了大数据量和大批量请求的考验,完全可以构建高性能的大型网站。这篇文章主要讲讲我在IDEA下利用Maven如何快速搭建一个整合SSM框架的Web项目,包括服务端和前端 。
使用 Maven 构建 SSM 项目,如果对于 Maven 不熟悉的童鞋可以去我这篇博客简单学习一下 Maven 的使用:
技术体系和开发环境说明:
SSM框架:Spring 4.3.5.RELEASE+Mybatis3.4.1
Mysql数据库:Mysql 5.7
Web应用服务器Tomcat:Tomcat 7.0.69
JSP+JSON格式传输
IntelliJ IDEA
Maven项目管理工具
Log4j日志系统工具
Junit4单元测试工具
Alibaba Java Coding Guidelines 代码规范检查工具
下面是我配置好Maven本地仓库和使用阿里云公共仓后 的 IDEA 环境下的构建过程:
第一步:创建 Maven webapp 项目
1.1 首先新建工程,选择 Maven 标签,然后勾选上【Create from archetype】选择maven-archetype-webapp
一个最简单的Maven war项目模板,当需要快速创建一个Web应用的时候可以使用它
1.2 Next,填写项目坐标
1.3 这一步可以看到 Maven 配置中的参数,不需要做改动,直接Next就可以(图中的路径是我配置的本地 Maven 仓库的地址)
1.4 确认项目名称,点击【Finish】即可完成创建
1.5 创建完毕后如下, 下面就是 Maven 风格的 webapp 的默认目录结构
其中pom.xml为工程的项目对象模型,可以理解为工程的说明文件,主要描述工程信息、依赖对象、构建方式等等信息。
我们还可以看到新建完成的项目有src/main/webapp的文件夹,但是还少三个root文件夹,分别是:src/main/java 、 src/main/resources 和src/main/test文件夹。
第二步:SSM框架工程目录结构创建
接着我们将按下述步骤创建SSM框架的基本工程结构:
1、在main文件下创建java文件夹,并右键点击java文件夹,选择Mark Directory As选项为Sources Root
2、在java文件夹下依次创建dao、service、controller三个包,分别表示dao层、业务层、控制层
3、在dao包下创建entity包,存放实体类
4、在service包下创建impl包,存放业务实现类
5、在main文件下创建resources文件夹,并右键点击java文件夹,选择Mark Directory As选项为Resources Root
6、在resources文件夹下创建mappers文件夹,用于存放dao层的映射文件
7、在resources文件夹下创建jdbc.properties、log4j.properties、spring-mvc.xml、spring-mybatis.xml四个空文件
8、在main文件下创建test文件夹,并右键点击java文件夹,选择Mark Directory As选项为Test Sources Root
注意:因为新建好的src/main/java 和 src/main/resources 只是一个简单的文件夹,而通常这两个文件夹都是用来放我们的java文件和资源文件的,所以需要将他们标记为root,以便让IDEA 识别不同的目录作用。
遵循 Maven 的统一项目结构,我们搭建出项目的完整目录结构如下图:
第三步、配置SSM项目的文件内容
3.1、在【pom.xml】文件中声明SSM项目所有依赖的 jar 包
pom.xml为工程的项目对象模型,可以理解为工程的说明文件,主要描述工程信息、依赖对象、构建方式等等信息。
想用什么jar包,直接填写在pom.xml配置文件中,Maven就会自动帮我们下载jar依赖包到工程中,我们还能通过配置让jar包时刻保持最新版本。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.hs</groupId>
<artifactId>SSMTest</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<name>SSMTest Maven Webapp</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
<!-- 设置项目编码 -->
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!-- spring版本号 -->
<spring.version>4.3.5.RELEASE</spring.version>
<!-- mybatis版本号 -->
<mybatis.version>3.4.1</mybatis.version>
<!-- mysql驱动版本号 -->
<mysql-driver.version>5.1.33</mysql-driver.version>
<!--slf4j-log4j12日志包版本号 -->
<slf4j-log4j12.version>1.7.28</slf4j-log4j12.version>
</properties>
<dependencies>
<!--pom.xml默认就会配置的Junit单元测试,这里我修改了版本-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<!-- 指定范围,在测试时才会加载 -->
<scope>test</scope>
</dependency>
<!-- java ee -->
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-api</artifactId>
<version>7.0</version>
</dependency>
<!--不添加会报500访问jsp网页错误,找不到此类-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
<scope>runtime</scope>
</dependency>
<!-- 添加日志jar包 ,建议通过slf4j设计日志系统,方便扩展:slf4j-log4j12这个包
依赖了slf4j和log4j,所以使用slf4j+log4j的组合只要配置上面这一个依赖就够了-->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j-log4j12.version}</version>
</dependency>
<!-- 添加jackson,用于SpringMVC默认就支持的json转换器MappingJackson2HttpMessageConverter(基于Jackson的JSON转换器,能够将对象转换成JSON格式的数据)-->
<!--对于系统中默认包含的json转换器,只要我们在项目中加入转换器所依赖的JAR包,相关转换器就会被自动加载。-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.8.7</version>
</dependency>
<!-- 添加fastjson,效率更好并且适应场景更多,可以用来代替SpringMVC默认的jackson或Gson数据转换器-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.41</version>
</dependency>
<!-- 数据库 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql-driver.version}</version>
<scope>runtime</scope>
</dependency>
<!-- 数据库连接池 -->
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.2</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.3.1</version>
</dependency>
<!-- Spring核心依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</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-tx</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-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- 以下是 SpringAOP所需要的包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.9.1</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.1</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>4.3.7.RELEASE</version>
</dependency>
<!--CGLIB是一个功能强大,高性能的代码生成包。它为没有实现接口的类提供代理,为JDK的动态代理提供了很好的补充。-->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
<!-- 以上是 SpringAOP 所需要的包 -->
</dependencies>
<build>
<finalName>SSMTest</finalName>
<pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
<plugins>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.1.0</version>
</plugin>
<!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.1</version>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>3.2.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
3.2 添加SSM框架相关配置文件的内容
a、在【web.xml】中声明编码过滤器并配置 DispatcherServlet
<?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_3_1.xsd"
version="3.1">
<display-name>ssm-test</display-name>
<!-- 1、让Web项目知道这些配置文件的存在并让它们起作用,web项目的所有部分都将共享的上下文 ServletContext 对象,会以键值对的形式保存<context-param> 信息-->
<!--配置Spring IoC-->
<!--ContextLoaderListener的作用就是启动Web容器时自动装配ApplicationContext的配置信息:默认Web容器会自动加载/WEB-INF/applicationContext.xml初始化ApplicationContext实例-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--如果需要指定配置文件位置,可通过context-param加以指定-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mybatis.xml</param-value>
</context-param>
<!-- 配置LOG4J -->
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>classpath:log4j.properties</param-value>
</context-param>
<!-- 2、编码过滤器 -->
<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>
<!-- 3、配置DispatcherServlet -->
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--配置SpringMVC需要加载的配置文件,spring-mvc.xml因为被配置在DispatcherServlet的初始化过程中,所以如果不初始化servlet,那么spring-servlet.xml是不会被发现的-->
<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>
<!--匹配所有请求 -->
<url-pattern>/</url-pattern>
</servlet-mapping>
<!--总结:Spring框架在加载web.xml配置文件的时候。首先加载的是context-param配置的内容,而并不会去初始化servlet。
只有进行了网站的跳转,经过了DispatcherServlet的导航的时候,才会初始化servlet,从而加载init-param中的内容。-->
</web-app>
b、在【spring-mvc.xml】中完成 Spring MVC 的相关配置
<?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-3.0.xsd">
<!-- 启用包自动扫描功能,找到使用注解@Controller相关的bean注入IOC容器管理-->
<context:component-scan base-package="com.hs.controller"/>
<!-- 开启SpringMVC注解模式 -->
<mvc:annotation-driven/>
<!-- 静态资源(js、image等)的访问,默认servlet配置 -->
<mvc:default-servlet-handler/>
<!--DispatcherServlet 将会使用视图解析器(ViewResolver)来将逻辑视图名匹配为一个特定的视图实现,它可能是也可能不是 JSP-->
<!--【WEB-INF】是 Java Web 中默认的安全目录,是不允许用户直接访问的(也就是你说你通过 localhost/WEB-INF/ 这样的方式访问不到-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
<property name="prefix" value="/WEB-INF/views/"/>
<property name="suffix" value=".jsp"/>
</bean>
</beans>
c、在【spring-mybatis.xml】中完成 spring 和 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: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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 自动扫描service.service包下所有使用注解的类型,base-package为需要扫描的包(含子包)。-->
<context:component-scan base-package="com.hs.service"/>
<!-- 加载一个properties文件 ,配置数据库相关参数properties的属性:${url} -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 数据库连接池 -->
<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}"/>
<property name="minPoolSize" value="${c3p0.minPoolSize}"/>
<!-- 这个必须写在minPoolSize和maxPoolSize之间,表示初始化时获取的连接数,这个值一般设警告置为minPoolSize,缺省时默认为3。不设置Logj4会发出[Warn]警告-->
<property name="initialPoolSize" value="10"/>
<property name="maxPoolSize" value="${c3p0.maxPoolSize}"/>
<property name="autoCommitOnClose" value="${c3p0.autoCommitOnClose}"/>
<property name="checkoutTimeout" value="${c3p0.checkoutTimeout}"/>
<property name="acquireRetryAttempts" value="${c3p0.acquireRetryAttempts}"/>
</bean>
<!-- mybatis和spring完美整合,不需要mybatis的配置映射文件 -->
<!-- 配置SqlSessionFactory对象-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 注入数据库连接池 -->
<property name="dataSource" ref="dataSource"/>
<!-- 扫描entity包 使用别名 -->
<property name="typeAliasesPackage" value="com.hs.dao.entity"/>
<!-- 扫描sql配置文件:mapper需要的xml文件 -->
<property name="mapperLocations" value="classpath:mappers/UserDapMapper.xml"/>
</bean>
<!--Mapper批量扫描器:会扫描Dao接口包,动态实现Dao接口,自动创建代理对象并注入到spring IOC容器中 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- 注入sqlSessionFactory -->
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
<!-- 给出需要扫描Dao接口包 -->
<property name="basePackage" value="com.hs.dao"/>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据库连接池 -->
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置基于注解的声明式事务 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
d、在【jdbc.properties】中配置 c3p0 数据库连接池
#配置 c3p0 数据库连接池:
jdbc.driver=com.mysql.jdbc.Driver
#数据库地址
jdbc.url=jdbc:mysql://localhost:3306/mengtu?useUnicode=true&characterEncoding=utf8
#用户名
jdbc.username=root
#密码
jdbc.password= your password
#最小连接数
c3p0.minPoolSize=10
#最大连接数
c3p0.maxPoolSize=30
#关闭连接后不自动commit
c3p0.autoCommitOnClose=false
#获取连接超时时间
c3p0.checkoutTimeout=10000
#当获取连接失败重试次数
c3p0.acquireRetryAttempts=2
f、在【log4j.properties】中配置logj日志系统
#Log4j日志系统框架在运行的时候会加载项目路径下的 log4j.properties 配置文件,可以提供方便的日志记录,我们通过查看日志文件可以方便项目的Bug调试。
#log4j.rootLogger = [level] , appenderName1 , appenderName2 , … 这里表示默认输出Info级别以上的日志到控制台和文件中
log4j.rootLogger=INFO,Console,File,D
#控制台日志:输出Info级别以上的日志信息到控制台
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=[%p][%t][%d{yyyy-MM-dd HH\:mm\:ss}][%C] - %m%n
#普通文件日志:输出Info级别以上的日志到src同级目录logs中的ssm.log文件中
log4j.appender.File=org.apache.log4j.RollingFileAppender
log4j.appender.File.File=logs/ssm.log
log4j.appender.File.MaxFileSize=10MB
#Threshold是个全局的过滤器,它将把低于当前所设置的level的信息过滤不显示出来,但是要注意Threshold指定的日志级别必须得比最上面rootLogger设置的level更高才有效
log4j.appender.File.Threshold=ALL
log4j.appender.File.layout=org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern=[%p][%t][%d{yyyy-MM-dd HH\:mm\:ss}][%C] - %m%n
### 输出error级别以上的日志到硬盘中 = D://Maven/error.log ###
log4j.appender.D= org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File =D://Maven/error.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = ERROR
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
#插件技巧提示:
# 1、配置IDEA控制台的多颜色log日志输出功能:由于idea不支持显示ascii颜色,grep-console插件能很好的解决这个问题。打开Setting,选中Plugins,输入框里搜索Grep-Console插件安装使用
# 2、配置log文件的多颜色日志查看功能:查看ssm.log日志文件idea会弹出下载Ideolog插件,这插件可以让我们更加直观的查看log日志,根据等级显示不同颜色
到这里第三步为止,创建Maven Web工程、SSM框架的工程目录结构的创建和SSM框架所需的基本配置文件都已经完成了。
第四步:编写代码,整合SSM 框架
经过前三步处理步骤,下面的第四步终于可以正式敲代码啦,感觉这些目录结构的创建和配置SSM的XML文件都是特别繁琐毫无意义的工作,希望过几天我学会约定大于配置的SpringBoot 可以摆脱这个困局。
4.1、首先准备好用来测试的Mysql数据库,就一张user表
4.2、接下来编写Dao层代码、Service层和Controller层代码
a、Dao层
在【com.hs.dao.entity】包下创建好对应的实体类 User :
package com.hs.dao.entity;
/**
* 用户实体类
*/
public class UserEntity {
//属性名必须与数据库表的字段名一致,以便Mybatis直接把实体类映射成数据库记录
private Integer uid; //用户id
private String username;//用户名
private String password;//用户密码
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
在【com.hs.dao】包下创建好Dao接口:
package com.hs.dao;
import com.hs.dao.entity.UserEntity;
/**
* 用户Dao类:从数据库存取数据的逻辑会放置在 DAO 层(Date Access Object,数据访问对象),接口中的方法与Mapper映射文件中的SQL语句的ID一一对应
*/
public interface UserDao
{
/**
* 根据用户id查找用户
*
* @param uid
* @return
*/
UserEntity selectById(Integer uid);
/**
* 更新用户记录
*
* @param userEntity
* @return
*/
Integer update(UserEntity userEntity);
/**
* 删除用户记录
*
* @param uid
* @return
*/
Integer delete(Integer uid);
/**
* 插入用户记录
*
* @param userEntity
* @return
*/
Integer insert(UserEntity userEntity);
}
在【resources/mappers】下编写 UserDao.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动态代理方式:直接设置命名空间为UserDao接口的方法提供sql语句映射 (不需要使用@Mapper注解),mybatis可以自动生成dao(本来是mapper)接口实现类代理对象。
在代码中可以直接使用DAO接口而不需要再编写实现类,面向接口编程-->
<mapper namespace="com.hs.dao.UserDao">
<select id="selectById" parameterType="java.lang.Integer" resultType="com.hs.dao.entity.UserEntity">
SELECT *
FROM user
WHERE uid=#{uid};
</select>
<update id="update" parameterType="com.hs.dao.entity.UserEntity">
UPDATE user
SET uid=#{uid},username=#{username},password=#{password}
WHERE uid=#{uid}
</update>
<delete id="delete" parameterType="java.lang.Integer">
DELETE FROM user
WHERE uid=#{uid}
</delete>
<insert id="insert" parameterType="com.hs.dao.entity.UserEntity">
<selectKey keyProperty="id" resultType="java.lang.Integer"
order="AFTER">
SELECT
LAST_INSERT_ID()
</selectKey>
INSERT INTO
user(uid,username,password)
VALUES(#{uid},#{username},#{password});
</insert>
</mapper>
在编写好每一个 Dao 的时候,我们都需要对它进行单元测试:
不熟悉Junit4单元测试可以看我这篇文章:Junit单元测试工具使用总结
package com.hs.dao;
import com.hs.dao.entity.UserEntity;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.junit.Assert.*;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring-mybatis.xml"})
public class UserDaoTest {
@Autowired
UserDao userDao;
@Test
public void selectById() {
UserEntity user = userDao.selectById(1);
System.out.println(user.getId()+":"+user.getPassword()+":"+user.getUsername());
}
@Test
public void update() {
}
@Test
public void delete() {
}
@Test
public void insert() {
}
}
b、Service层
在【com.hs.service】包下编写好对应的 UserService 接口
package com.hs.service;
import com.hs.dao.entity.UserEntity;
/**
* 用户服务类
*
*/
public interface UserService {
/**
* 创建用户
*
* @param userEntity
* @return
*/
Integer createUser(UserEntity userEntity);
/**
* 更新用户
*
* @param userEntity
* @return
*/
Integer updateUser(UserEntity userEntity);
/**
* 删除用户
*
* @param uid
* @return
*/
Integer deleteUser(Integer uid);
/**
* 根据用户id查询用户
*
* @param uid
* @return
*/
UserEntity getUserById(Integer uid);
}
在【com.hs.service.impl】包下编写好对应的 UserService 接口对应的实现类UserServiceImpl
package com.hs.service.impl;
import com.hs.dao.UserDao;
import com.hs.dao.entity.UserEntity;
import com.hs.service.UserService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* 用户服务实现类
*
*/
@Service
public class UserServiceImpl implements UserService
{
@Resource//@Resource的作用相当于@Autowired,都可以用来自动装配bean
private UserDao userDao;
@Override
public Integer createUser(UserEntity userEntity) {
return userDao.insert(userEntity);
}
@Override
public Integer updateUser(UserEntity userEntity) {
return userDao.update(userEntity);
}
@Override
public Integer deleteUser(Integer uid) {
return userDao.delete(uid);
}
@Override
public UserEntity getUserById(Integer uid) {
return userDao.selectById(uid);
}
}
c、Controller层
在【com.hs.controller】下创建【UserController】控制类
package com.hs.controller;
import com.alibaba.fastjson.JSON;
import com.hs.dao.entity.UserEntity;
import com.hs.service.UserService;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import javax.annotation.Resource;
/**
*采用@Contoller注解的方式,将@Controller标记在某个类上,配合@RequestMapping注解,可以在一个类中定义多个接口(URL请求和Controller方法之间的映射),这样的Controller
* 就能被外界访问到,@RequestMapping标记的方法会被分发处理器扫描识别,将不同的请求分发到对应的接口上。
* 相比自定义Controller类实现Controller接口并在Spring MVC的映射配置文件将某个接口与自定义Controller类做映射这种只能处理一个单一请求的方式来说更灵活方便。
*/
@Controller
public class UserController {
private static Logger logger = Logger.getLogger(UserController.class);//Logj4日志系统工具
@Resource
private UserService userService;
/**
*1、使用 Spring MVC 所提供的 ModelAndView 对象来绑定数据和视图的形式
*/
@RequestMapping(value = "/user")
public ModelAndView user ()
{
logger.info("user()方法被调用");
logger.error("666666666666只是测试用");//记录error级别的信息
ModelAndView mv = new ModelAndView();//Spring MVC 通过 ModelAndView 对象把模型和视图结合在一起,即它里面包含了Model和View的对象
//通过SpringMVC和Mybatis
UserEntity userEntity = userService.getUserById(1);
mv.addObject("user",userEntity);
String str = JSON.toJSONString(userEntity);
logger.info(str);
mv.addObject("message", "测试能不能通过Controller层返回jsp!");
mv.setViewName("user");//也可以在new ModelAndView("user")构造函数中的参数指出试图逻辑名
return mv;
}
/*
//2、使用 Model 对象来绑定数据的形式
@RequestMapping("/user")
public String user (Model model)
{
System.out.println("user()方法被调用");
model.addAttribute("message","999999999999");
return "user";
}
*/
}
Controller层用到了Logj4日志系统,这里的View层我使用了返回JSP网页的方式。
不熟悉Logj4日志系统工具的用法,还有SpringMVC如何返回JSON格式的数据的同学可以看看我的另外两篇博客:
d、View层
最后在【WEB-INF/views】下创建 user.jsp 用于接收并显示数据
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<html>
<body>
<h1>${message}</h1>
<h2>${user.uid}: ${user.username} ${user.password}</h2>
</body>
</html>
第五步:配置好 Tomcat 服务器,部署SSM项目运行即可
5.1、在IDEA中选择EAdd Configurationsn,然后左上角点击 +号,找到Tomcat Server选择local进入本地Tomcat配置界面
5.2、设置好Tomcat后,IDEA右上角点击运行SSM项目,并在浏览器中输入:localhost/SSM_war/user
就这么简单的五个步骤,我们就实现了Maven构建SSM项目!!!
SSM 框架架构图
为了更加能理解 SSM 处理用户请求的整个过程,下面给出一张 SSM 系统架构图:
SSM学习总结:
通过这个简单的Demo,我学会了Spring+SpringMVC+Mybatis三大框架,学会了使用Maven项目管理工具、Loj4日志系统和Junit4单元测试,后面两个工具真的是用着用着就会了,我会在下面博客会系统地写出来的。对了,还有SSM如何返回JSON格式的数据我也会单独提出来讲一讲。
此篇博客我已经把代码和配置文件注释得很详细了,希望大家能快速入门!
最后的最后,对下面两位博主致以敬意,谢谢你们写的如此仔细认真,谢谢你们的分享!
参考资料: