标签：name 示例 SpringMvc Spring springframework org import com public
前面已经发布了 Spring 系列、SpringMvc系列、Mybatis系列的博客，是时候将它们整合到一起，形成一个完整的可以在实际开发中使用的技术了。SSM 是一款非常优秀的整合开发框架，轻松解决了我们在实际开发过程中所遇到的各种问题，提高了开发效率，降低了开发成本。有关 SSM 框架的理论知识，这里就不详细介绍了，相信大家最关心的就是如何通过代码的方式进行搭建和实现，这个才是最重要的。
本篇博客通过一个非常简单的需求（用户必须登录后，才能查询员工信息），尽可能多的使用前面博客所发布的各种技术，来演示 SSM 的代码搭建和实现。如果相关的技术点看不懂的话，请回看我之前发布的博客。由于我个人非常喜欢纯注解的搭建方式，因此本篇博客的 Demo 采用纯注解方式进行搭建。当然在本篇博客的最后面，会提供 Demo 源代码的下载。
一、搭建工程
新建一个 maven 项目，导入相关 jar 包，我所导入的 jar 包都是最新的，内容如下：
有关具体的 jar 包地址，可以在 https://mvnrepository.com 上进行查询。
<dependencies>
<!--
导入 Spring 和 SpringMvc 的 jar 包
导入 jackson 相关的 jar 包
-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.18</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.18</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.13.1</version>
</dependency>
<!--
导入操作数据库所使用相关的 jar 包
导入查询数据分页助手的 jar 包
-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.17</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.8</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.28</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.9</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.7</version>
</dependency>
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.3.0</version>
</dependency>
<!--Apache 提供的实用的公共类工具 jar 包-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.9</version>
</dependency>
<!--导入 servlet 相关的 jar 包-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>
<!--操作 Redis 的相关 jar 包-->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>2.0.6.RELEASE</version>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
<!--
日志相关 jar 包，主要是上面的 Redis 相关的 jar 包，在运行时需要日志的 jar 包。
日志的 jar 包也可以不导入，只不过运行过程中控制台总是有红色提示，看着心烦。
-->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.21</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>
搭建后的最终工程如下图所示，有关具体包下的内容，一目了然，就不详细介绍了：
二、SSM 注解配置细节
在 resources 目录中，只有一些 properties 配置文件，配置的是数据库连接字符串，redis连接字符串，以及日志相关。
jdbc.properties 配置的是 mysql 数据库连接相关的信息，其中使用了 druid 数据库连接池：
mysql.driver=com.mysql.cj.jdbc.Driver
mysql.url=jdbc:mysql://localhost:3306/testdb?useSSL=false
mysql.username=root
mysql.password=123456
# 初始化连接的数量
druid.initialSize=3
# 最大连接的数量
druid.maxActive=20
# 获取连接的最大等待时间（毫秒）
druid.maxWait=3000
redis.properties 配置的是连接 redis 连接相关的信息，其中也使用了 redis 的连接池：
redis.host=localhost
redis.port=6379
# 如果你的 redis 设置了密码的话，可以使用密码配置
# redis.password=123456
redis.maxActive=10
redis.maxIdle=5
redis.minIdle=1
redis.maxWait=3000
log4j.properties 配置的是日志记录相关的信息，本 demo 中主要是因为 RedisTemplate 需要使用到 log4j ，如果我们不导入有关 log4j 的 jar 包和提供 log4j 的配置文件的话，也不会影响 SSM 的运行，但是控制台上总是有红色的缺包提示，看着让人心里很不爽，所以还是导入了吧。
log4j.rootLogger=WARN, stdout
# 如果你既要控制台打印日志，也要文件记录日志的话，可以使用下面这行配置
# log4j.rootLogger=WARN, stdout, logfile
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spring.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n
SSM 框架中 Spring 是底层基础核心，用来整合 Mybatis 和 SpringMvc 以及其它相关技术。有关 Spring 整合 Mybatis 的技术，前面的博客已经详细介绍过了。另外本博客 Demo 还需要使用 Redis ，用来保存已经登录的用户名，使用的 RedisTemplate ，前面的博客也已经介绍过了。因此这里仅仅列出具体代码细节。
JdbcConfig 的内容如下：
package com.jobs.config;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;
//加载 jdbc.properties 文件内容
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {
//获取数据库连接字符串内容
@Value("${mysql.driver}")
private String driver;
@Value("${mysql.url}")
private String url;
@Value("${mysql.username}")
private String userName;
@Value("${mysql.password}")
private String password;
//获取 druid 数据库连接池配置内容
@Value("${druid.initialSize}")
private Integer initialSize;
@Value("${druid.maxActive}")
private Integer maxActive;
@Value("${druid.maxWait}")
private Long maxWait;
//这里采用 @Bean 注解，表明该方法返回连接数据库的数据源对象
//由于我们只有这一个数据源，因此不需要使用 BeanId 进行标识
@Bean
public DataSource getDataSource() {
//采用阿里巴巴的 druid 数据库连接池的数据源
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(userName);
ds.setPassword(password);
ds.setInitialSize(initialSize);
ds.setMaxActive(maxActive);
ds.setMaxWait(maxWait);
return ds;
}
//让 Spring 装载 jdbc 的事务管理器
//注意：Spring 框架内，事务的 bean 的名称默认取 transactionManager
//因为这里使用 getTransactionManager 作为获取 bean 的方法名，所以系统会自动取 get 后的内容作为 bean 名称
//如果你取的名字不是 getTransactionManager 的话，那么就必须使用 @Bean("transactionManager") 注解
@Bean
public PlatformTransactionManager getTransactionManager(@Autowired DataSource dataSource){
return new DataSourceTransactionManager(dataSource);
}
}
MyBatisConfig 的具体内容：
package com.jobs.config;
import com.github.pagehelper.PageInterceptor;
import org.apache.ibatis.logging.stdout.StdOutImpl;
import org.apache.ibatis.session.Configuration;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
import java.util.Properties;
public class MyBatisConfig {
//这里的 Bean 由 Spring 根据类型自动调用，因此不需要指定 BeanId
//使用 @Autowired 注解，Spring 自动根据类型将上面的 druid 的数据源赋值到这里
@Bean
public SqlSessionFactoryBean getSqlSessionFactoryBean(
@Autowired DataSource dataSource,
@Autowired PageInterceptor pageInterceptor){
SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
//这里配置，将 com.jobs.domain 下的所有 JavaBean 实体类的名字作为别名
//这样 MyBatis 中可以直接使用类名，而不需要使用完全限定名
ssfb.setTypeAliasesPackage("com.jobs.domain");
ssfb.setDataSource(dataSource);
//这里配置，让 MyBatis 在运行时，控制台打印 sql 语句，方便排查问题
Configuration mybatisConfig = new Configuration();
mybatisConfig.setLogImpl(StdOutImpl.class);
ssfb.setConfiguration(mybatisConfig);
//这里配置分页助手拦截器插件
ssfb.setPlugins(pageInterceptor);
return ssfb;
}
//配置 MyBatis 使用 com.jobs.dao 下所有的接口，生成访问数据库的代理类
@Bean
public MapperScannerConfigurer getMapperScannerConfigurer(){
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("com.jobs.dao");
return msc;
}
//这里配置分页助手拦截器插件，详情请查看官网
//分页助手的官网地址为：https://github.com/pagehelper/Mybatis-PageHelper
@Bean
public PageInterceptor getPageInterceptor(){
PageInterceptor pi = new PageInterceptor();
Properties properties = new Properties();
//设置分页助手插件使用的是 mysql 数据库
properties.setProperty("helperDialect","mysql");
//reasonable 分页合理化参数，默认值为false。
//当该参数设置为 true 时，
//pageNum<=0 时会查询第一页，pageNum>总页数时，会查询最后一页。
properties.setProperty("reasonable","true");
pi.setProperties(properties);
return pi;
}
}
RedisConfig 的具体内容：
package com.jobs.config;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@PropertySource("classpath:redis.properties")
public class RedisConfig {
@Value("${redis.host}")
private String host;
@Value("${redis.port}")
private Integer port;
//@Value("${redis.password}")
//private String password;
@Value("${redis.maxActive}")
private Integer maxActive;
@Value("${redis.minIdle}")
private Integer minIdle;
@Value("${redis.maxIdle}")
private Integer maxIdle;
@Value("${redis.maxWait}")
private Integer maxWait;
//获取RedisTemplate
@Bean
public RedisTemplate getRedisTemplate(
@Autowired RedisConnectionFactory redisConnectionFactory) {
RedisTemplate redisTemplate = new RedisTemplate();
redisTemplate.setConnectionFactory(redisConnectionFactory);
//设置 Redis 生成的key的序列化器，这个很重要
//RedisTemplate 默认使用 jdk 序列化器，会出现 Redis 的 key 保存成乱码的情况
//一般情况下 Redis 的 key 都使用字符串，
//为了保障在任何情况下使用正常，最好使用 StringRedisSerializer 对 key 进行序列化
RedisSerializer stringSerializer = new StringRedisSerializer();
redisTemplate.setKeySerializer(stringSerializer);
redisTemplate.setHashKeySerializer(stringSerializer);
return redisTemplate;
}
//获取 Redis 连接工厂
@Bean
public RedisConnectionFactory getRedisConnectionFactory(
@Autowired RedisStandaloneConfiguration redisStandaloneConfiguration,
@Autowired GenericObjectPoolConfig genericObjectPoolConfig) {
JedisClientConfiguration.JedisPoolingClientConfigurationBuilder builder
= (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder)
JedisClientConfiguration.builder();
builder.poolConfig(genericObjectPoolConfig);
JedisConnectionFactory jedisConnectionFactory =
new JedisConnectionFactory(redisStandaloneConfiguration, builder.build());
return jedisConnectionFactory;
}
//获取 Spring 提供的 Redis 连接池信息
@Bean
public GenericObjectPoolConfig getGenericObjectPoolConfig() {
GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
genericObjectPoolConfig.setMaxTotal(maxActive);
genericObjectPoolConfig.setMinIdle(minIdle);
genericObjectPoolConfig.setMaxIdle(maxIdle);
genericObjectPoolConfig.setMaxWaitMillis(maxWait);
return genericObjectPoolConfig;
}
//获取 Redis 配置对象
@Bean
public RedisStandaloneConfiguration getRedisStandaloneConfiguration() {
RedisStandaloneConfiguration redisStandaloneConfiguration =
new RedisStandaloneConfiguration();
redisStandaloneConfiguration.setHostName(host);
redisStandaloneConfiguration.setPort(port);
//redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
return redisStandaloneConfiguration;
}
}
最后 SpringConfig 对它们进行导入，就算是整合了，很简单吧。
需要注意的是：为了防止 Spring 和 SpringMvc 重复进行包扫描，因此我们使用 Spring 扫描除 @Controller 之外的所有注解，让 SpringMvc 仅仅扫描 @Controller 注解。SpringConfig 内容如下：
package com.jobs.config;
import org.springframework.context.annotation.*;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration
//让 Spring 扫描除了 controller 之外的所有包
@ComponentScan(value = "com.jobs",
excludeFilters = @ComponentScan.Filter(
type = FilterType.ANNOTATION, classes = {Controller.class}))
//启用数据库事务
@EnableTransactionManagement
//导入其它配置文件
@Import({JdbcConfig.class, MyBatisConfig.class, RedisConfig.class})
public class SpringConfig {
}
SpringMvcConfig 内容如下，需要注解的是：我们需要将拦截器专门独立出一个方法，加上 @Bean 注解，让 Spring 容器装载它。这样才能保障在拦截器中使用 @Autowired 注解注入其它的 Bean 对象，如 Service 和 Dao 的 Bean 对象。
package com.jobs.config;
import com.jobs.interceptor.CheckLoginInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.config.annotation.*;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
@Configuration
//让 SpringMvc 仅仅扫描加载配置了 @Controller 注解的类
@ComponentScan("com.jobs.controller")
//启用 mvc 功能，配置了该注解之后，SpringMvc 拦截器放行相关资源的设置，才会生效
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer {
//配置 SpringMvc 连接器放行常用资源的格式（图片，js，css）
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
//配置响应数据格式所对应的数据处理转换器
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
//如果响应的是 application/json ，则使用 jackson 转换器进行自动处理
MappingJackson2HttpMessageConverter jsonConverter =
new MappingJackson2HttpMessageConverter();
jsonConverter.setDefaultCharset(Charset.forName("UTF-8"));
List<MediaType> typelist1 = new ArrayList<>();
typelist1.add(MediaType.APPLICATION_JSON);
jsonConverter.setSupportedMediaTypes(typelist1);
converters.add(jsonConverter);
//如果响应的是 text/html 和 text/plain ，则使用字符串文本转换器自动处理
StringHttpMessageConverter stringConverter = new StringHttpMessageConverter();
stringConverter.setDefaultCharset(Charset.forName("UTF-8"));
List<MediaType> typelist2 = new ArrayList<>();
typelist2.add(MediaType.TEXT_HTML);
typelist2.add(MediaType.TEXT_PLAIN);
stringConverter.setSupportedMediaTypes(typelist2);
converters.add(stringConverter);
}
//添加 SpringMvc 启动后默认访问的首页
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/").setViewName("login.html");
}
//这里需要注意，拦截器加载是在 Spring Context 创建之前完成的，
//所以在拦截器中使用 @Autowired 注解注入相关的 bean ，将为 null
//此时必须要创建拦截器的 bean ，让 spring 容器装载拦截器的 bean
//这样才可以在拦截器中，使用 @Autowired 注解
@Bean
public CheckLoginInterceptor getCheckLoginInterceptor() {
CheckLoginInterceptor interceptor = new CheckLoginInterceptor();
return interceptor;
}
//配置拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
//添加拦截器（可以添加多个拦截器，拦截器的执行顺序，就是添加顺序）
CheckLoginInterceptor interceptor = getCheckLoginInterceptor();
//设置拦截器拦截的请求路径
registry.addInterceptor(interceptor).addPathPatterns("/emp/**");
//设置拦截器排除的拦截路径
//registry.addInterceptor(interceptor).excludePathPatterns("/");
/*
设置拦截器的拦截路径，支持 * 和 ** 通配
配置值 /** 表示拦截所有映射
配置值 /* 表示拦截所有 / 开头的映射
配置值 /test/* 表示拦截所有 /test/ 开头的映射
配置值 /test/get* 表示拦截所有 /test/ 开头，且具体映射名称以 get 开头的映射
配置值 /test/*job 表示拦截所有 /test/ 开头，且具体映射名称以 job 结尾的映射
*/
}
}
最后在 ServletInitConfig 中，实现 Spring 和 SpringMvc 的整合，内容如下：
package com.jobs.config;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.filter.HiddenHttpMethodFilter;
import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;
import javax.servlet.*;
public class ServletInitConfig extends AbstractDispatcherServletInitializer {
//这个是首先执行的，加载 Spring 配置类，创建 Spring 容器
@Override
protected WebApplicationContext createRootApplicationContext() {
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
ctx.register(SpringConfig.class);
return ctx;
}
//这个是在 Spring 容器创建好之后，加载 SpringMvc 配置类，创建 SpringMvc 容器
@Override
protected WebApplicationContext createServletApplicationContext() {
AnnotationConfigWebApplicationContext cwa = new AnnotationConfigWebApplicationContext();
cwa.register(SpringMvcConfig.class);
return cwa;
}
//注解配置 SpringMvc 的 DispatcherServlet 拦截地址，拦截所有请求
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
//添加过滤器
@Override
protected Filter[] getServletFilters() {
//采用 utf-8 作为统一请求的编码
CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
characterEncodingFilter.setEncoding("UTF-8");
//该过滤器，能够让 web 页面通过 _method 参数将 Post 请求转换为 Put、Delete 等请求
HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
return new Filter[]{characterEncodingFilter, hiddenHttpMethodFilter};
}
}
在 createRootApplicationContext 中创建 Spring 的容器，在 createServletApplicationContext 中创建 SpringMvc 的容器。Spring 容器是根容器，需要先创建，SpringMvc 是在 Spring 容器的基础上进行创建，是小容器。
三、数据访问层和业务层
这个就非常简单了，就是 Spring 和 Mybatis 管理的，其中数据库脚本如下：
CREATE DATABASE IF NOT EXISTS `testdb`;
USE `testdb`;
CREATE TABLE IF NOT EXISTS `employee` (
`e_id` int(11) NOT NULL COMMENT '主键id',
`e_name` varchar(50) NOT NULL DEFAULT '' COMMENT '姓名',
`e_gender` tinyint(4) NOT NULL DEFAULT '0' COMMENT '性别',
`e_money` int(11) NOT NULL DEFAULT '0' COMMENT '薪水',
`e_birthday` date NOT NULL DEFAULT '0000-00-00' COMMENT '出生日期',
PRIMARY KEY (`e_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
INSERT INTO `employee` (`e_id`, `e_name`, `e_gender`, `e_money`, `e_birthday`) VALUES
(1, '任肥肥', 1, 2000, '1984-01-27'),(2, '候胖胖', 1, 2100, '1982-05-15'),
(3, '任小肥', 0, 1800, '1996-03-08'),(4, '候中胖', 1, 2300, '1992-12-26'),
(5, '李小吨', 0, 1900, '1996-01-08'),(6, '任少肥', 1, 2200, '1988-03-25'),
(7, '李吨吨', 0, 2100, '1993-11-15'),(8, '候小胖', 1, 2500, '1983-10-10'),
(9, '李少吨', 1, 1700, '1998-11-15'),(10, '任中肥', 0, 2400, '1981-12-12'),
(11, '候大胖', 1, 2150, '1982-06-18'),(12, '李中吨', 0, 2310, '1991-01-12'),
(13, '任大肥', 1, 2020, '1995-06-23'),(14, '李大吨', 0, 2150, '1982-06-18'),
(15, '候微胖', 1, 1950, '1998-07-12'),(16, '任巨肥', 1, 2200, '1984-06-20'),
(17, '任微肥', 0, 1850, '1994-03-21'),(18, '候巨胖', 1, 1900, '1995-06-11'),
(19, '李微吨', 1, 1750, '1998-02-15'),(20, '候少胖', 0, 2050, '1982-07-16'),
(21, '李巨吨', 1, 1800, '1986-08-23'),(22, '任超肥', 1, 1960, '1989-05-09'),
(23, '李超吨', 0, 1995, '1999-09-19'),(24, '候超胖', 1, 2198, '1982-03-18'),
(25, '任老肥', 1, 2056, '1983-10-21'),(26, '候老胖', 0, 2270, '1986-12-16'),
(27, '李老吨', 1, 2300, '1983-12-23'),(28, '李中吨', 1, 2068, '1990-02-26');
数据访问层细节为：
package com.jobs.dao;
import com.jobs.dao.sql.EmployeeDaoSQL;
import com.jobs.domain.Employee;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.SelectProvider;
import java.util.List;
public interface EmployeeDao {
//根据姓名和性别查询员工，按照id升序排列
//在 select 方法上定义 employee_map
//建立 Employee 实体类的属性与数据库表 employee 的字段对应关系
@Results(id = "employee_map", value = {
@Result(column = "e_id", property = "id"),
@Result(column = "e_name", property = "name"),
@Result(column = "e_gender", property = "gender"),
@Result(column = "e_money", property = "money"),
@Result(column = "e_birthday", property = "birthday")})
@SelectProvider(type = EmployeeDaoSQL.class, method = "getEmployeeListSQL")
List<Employee> GetEmployeeList(@Param("name") String n,@Param("gender") Short g);
}
package com.jobs.dao.sql;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.annotations.Param;
public class EmployeeDaoSQL {
//在传递参数时，形参可以随便写，尽量使用 @Parm 注解给形参取一个有意义的别名，
//比如给 nnn 这个形参，取个别名为 name，给 ggg 这个形参，取个别名为 gender
//在拼接 SQL 语句时，要使用 @Parm 注解中的参数名称，这样可以防止 SQL 注入攻击
public String getEmployeeListSQL(@Param("name") String nnn, @Param("gender") Short ggg) {
StringBuilder sql = new StringBuilder();
sql.append(" SELECT e_id,e_name,e_money,");
sql.append(" (case e_gender when 1 then '男' when 0 then '女' ELSE '未知' END) AS e_gender,");
sql.append(" DATE_FORMAT(e_birthday,'%Y-%m-%d') AS e_birthday FROM employee");
if (StringUtils.isNotBlank(nnn) || ggg != -1) {
sql.append(" where 1=1");
if (StringUtils.isNotBlank(nnn)) {
//在拼接 SQL 语句时，要使用 @Parm 注解中的参数名称，这样可以防止 SQL 注入攻击
sql.append(" and (e_name like CONCAT('%',#{name},'%'))");
}
if (ggg != -1) {
sql.append(" and e_gender=#{gender}");
}
}
sql.append(" order by e_id");
return sql.toString();
}
}
然后就是业务层的细节：
package com.jobs.service;
import com.github.pagehelper.PageInfo;
import com.jobs.domain.Employee;
import org.springframework.transaction.annotation.Transactional;
//最好在接口上添加事务，而不是在接口的实现类上添加事务
//因为在接口上添加事务的话，后续该接口的其它实现类自动也具有事务
//可以在接口上添加整体事务，比如只读事务。在接口内具体的需要进行写操作的方法上添加写事务
//@Transactional(readOnly = true)
public interface EmployeeService {
//开启只读事务
@Transactional(readOnly = true)
PageInfo<Employee> getEmployeeList
(Integer pageIndex, Integer pageSize, String name, Short gender);
//@Transactional(readOnly = false)
//Integer addEmployee(Employee emp);
//用户登录
boolean Login(String name, String pwd);
//用户退出
void Logout(String name);
//判断用户是否已经登录
boolean CheckLogin(String name);
}
package com.jobs.service.impl;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.jobs.dao.EmployeeDao;
import com.jobs.domain.Employee;
import com.jobs.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.concurrent.TimeUnit;
@Service
public class EmployeeImpl implements EmployeeService {
@Autowired
private EmployeeDao employeeDao;
@Autowired
private RedisTemplate redisTemplate;
//通过姓名和性别查询员工，传入页码和每页条数，页码从 1 开始
@Override
public PageInfo<Employee> getEmployeeList(
Integer pageIndex, Integer pageSize, String name, Short gender) {
PageHelper.startPage(pageIndex, pageSize);
List<Employee> list = employeeDao.GetEmployeeList(name, gender);
return new PageInfo<>(list);
}
//用户登录
@Override
public boolean Login(String name, String pwd) {
//实际业务中，需要从数据库中读取用户名和密码、
//这里的 demo 就直接懒省事，预置了一些用户，密码都是 123456
List<String> userlist = List.of("admin", "zhangsan", "lisi");
if (userlist.contains(name) && "123456".equals(pwd)) {
//登录成功后，将用户名记录到 Redis 中，并设置过期时间为 60 秒，便于测试
//因为这个是 demo ，所以把过期时间设置的短一些
redisTemplate.opsForValue().set(name,
"这里的 value 可以设置用户的角色或权限等额外信息", 60, TimeUnit.SECONDS);
return true;
} else {
return false;
}
}
//用户退出
@Override
public void Logout(String name) {
//从 Redis 中删除用户
redisTemplate.delete(name);
}
//判断用户是否已经登录了
@Override
public boolean CheckLogin(String name) {
//如果在 redis 中能够找了 name 的键值对，则表明已经登录了
Boolean b = redisTemplate.hasKey(name);
if (b) {
//再给已经登录的用户，延续 60 秒的时间
redisTemplate.opsForValue().set(name,
"这里的 value 可以设置用户的角色或权限等额外信息", 60, TimeUnit.SECONDS);
return true;
} else {
return false;
}
}
}
最后列出它们所使用的 Employee 实体类内容：
package com.jobs.domain;
import java.util.Date;
public class Employee {
private Integer id;
private String name;
private String gender;
private Integer money;
private String birthday;
public Employee() {
}
public Employee(Integer id, String name, String gender, Integer money, String birthday) {
this.id = id;
this.name = name;
this.gender = gender;
this.money = money;
this.birthday = birthday;
}
//此处省略 get 和 set 方法......
@Override
public String toString() {
return "Employee{" +
"id=" + id +
", name='" + name + '\'' +
", gender='" + gender + '\'' +
", money=" + money +
", birthday='" + birthday + '\'' +
'}';
}
}
四、SpringMvc 细节
SpringMvc 的后端只提供接口，因此不需要导入 jsp 相关的 jar 包，EmployeeController 和返回数据的 Result 内容为：
package com.jobs.controller;
import com.github.pagehelper.PageInfo;
import com.jobs.controller.Results.Result;
import com.jobs.domain.Employee;
import com.jobs.service.EmployeeService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
@RestController
@RequestMapping("/emp")
public class EmployeeController {
@Autowired
private EmployeeService employeeService;
//用户登录
@PostMapping("/login")
public Result Login(String name, String pwd) {
if (StringUtils.isNotBlank(name) && StringUtils.isNotBlank(pwd)) {
boolean b = employeeService.Login(name, pwd);
if (b) {
return new Result(true, "登录成功");
} else {
return new Result(false, "用户名或密码输入不正确");
}
} else {
return new Result(false, "用户名和密码不能为空");
}
}
//用户退出
@PostMapping("/logout")
public Result Logout(HttpServletRequest request) {
//从 cookie 中获取到用户名
Cookie[] cookies = request.getCookies();
if (cookies != null && cookies.length > 0) {
String username = "";
for (Cookie c : cookies) {
if (c.getName().equals("username")) {
username = c.getValue();
break;
}
}
if (StringUtils.isNotBlank(username)) {
employeeService.Logout(username);
}
}
return new Result(true, "退出成功");
}
//通过姓名和性别分页查询员工列表
@PostMapping("/list/{pageIndex}/{pageSize}")
public Result getEmployeeList(@PathVariable Integer pageIndex,
@PathVariable Integer pageSize,
String name, Short gender) {
PageInfo<Employee> emplist =
employeeService.getEmployeeList(pageIndex, pageSize, name, gender);
return new Result(true,"查询成功", emplist);
}
}
package com.jobs.controller.Results;
public class Result {
boolean flag;
String msg;
Object data;
public Result() {
}
public Result(boolean flag, String msg) {
this.flag = flag;
this.msg = msg;
}
public Result(boolean flag, String msg, Object data) {
this.flag = flag;
this.msg = msg;
this.data = data;
}
//此处省略的 get 和 set 方法....
@Override
public String toString() {
return "Result{" +
"flag=" + flag +
", msg='" + msg + '\'' +
", data=" + data +
'}';
}
}
有些接口必须在用户登录了之后才能方法，因此我们需要使用拦截器进行验证（当开发好拦截器之后，需要在 SpringMvcConfig 中进行了添加拦截器，并配置拦截的地址），对于验证是否登录的拦截器，我们只使用 preHandle 方法即可，因为其在请求到达 controller 方法前先执行，具体内容为：
package com.jobs.interceptor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jobs.controller.Results.Result;
import com.jobs.service.EmployeeService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
//验证用户是否登录的拦截器
public class CheckLoginInterceptor implements HandlerInterceptor {
@Autowired
private EmployeeService employeeService;
//在请求 controller 之前执行用户是否登录的验证
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response,
Object handler) throws Exception {
//获取用户请求的 uri 地址
String uri = request.getRequestURI().toLowerCase();
if (uri.contains("emp/login") || uri.contains("emp/logout")) {
//对于登录和退出的请求，不验证，直接放行
return true;
} else {
//从 cookie 中获取到用户名
Cookie[] cookies = request.getCookies();
if (cookies != null && cookies.length > 0) {
String username = "";
for (Cookie c : cookies) {
if (c.getName().equals("username")) {
username = c.getValue();
break;
}
}
if (StringUtils.isNotBlank(username)) {
//如果 redis 中存在该 username 的键值对，则表明已经登录了
if (employeeService.CheckLogin(username)) {
return true;
}
}
}
//如果
Result result = new Result(false, "用户没有登录");
//返回 json数据
ObjectMapper objectMapper = new ObjectMapper();
String json = objectMapper.writeValueAsString(result);
response.setContentType("application/json;charset=UTF-8");
response.getWriter().write(json);
//此处返回 false 后，将不会再执行 controller 中的方法
return false;
}
}
}
为了统一记录整个项目的异常日志，并且在发生异常时给用户提供友好的信息，我们使用全局捕获和处理类，具体内容如下：
package com.jobs.exception;
import com.jobs.controller.Results.Result;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
@Component
@ControllerAdvice
public class GlobalExceptionHandler {
//该方法捕获并处理所有的异常
@ExceptionHandler(Exception.class)
@ResponseBody
public Result doException(Exception ex) {
//实际项目中，会将异常信息记录下来，比如存储到数据库或文本文件中
System.out.println(ex);
//实际项目中，不会将异常信息返回到前端，而是提示给用户友好的信息
return new Result(false, "系统出现问题，请联系管理员");
}
}
五、前端页面验证搭建成果
我简单制作了 3 个页面，login.html 是登录页面，list.html 是查询员工页面，prompt.html 是未登录用户如果在地址栏上直接访问 list.html 页面时，会自动跳转到的提示页面。具体内容如下：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>登录页面</title>
</head>
<body>
<h1>这里是登录页面 login.html</h1>
<fieldset>
<legend>用户登录</legend>
用户名：<input type="text" id="name"/><br/>
密码：<input type="password" id="pwd"/><br/>
<input type="button" value="登录" id="btnlogin">
</fieldset>
<script src="./js/jquery-3.6.0.min.js"></script>
<script src="./js/jquery.cookie-1.4.1.js"></script>
<script>
$(function () {
$('#btnlogin').click(function () {
let nametext = $('#name').val();
let pwdtext = $('#pwd').val();
if ($.trim(nametext) == '' || $.trim(pwdtext) == '') {
alert('用户名和密码不能为空');
return false;
}
$.ajax({
type: "post",
url: "/emp/login",
data: {name: nametext, pwd: pwdtext},
dataType: "json",
success: function (data) {
if (data.flag) {
//写cookie，有效期为 1 天，然后跳转到 list.html 页面
$.cookie("username", nametext, {path: "/", expires: 1})
location.href = "list.html";
} else {
alert(data.msg);
}
}
});
});
})
</script>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>这里是 list.html 页面</h1>
<fieldset>
<legend>查询员工列表</legend>
员工姓名：<input type="text" id="name"/><br/>
员工性别：<select id="gender">
<option value="-1" selected>不限</option>
<option value="1">男</option>
<option value="0">女</option>
</select><br/>
当前页码：<input type="number" value="1" step="1" id="pageIndex"/><br/>
每页条数：<input type="number" value="10" step="1" id="pageSize"/><br/>
<input type="button" value="查询" id="btnSearch"/><br/>
<textarea rows="30" cols="100" id="txtResult"></textarea><br/>
如果想退出登录，请点击这里：<input type="button" value="退出登录" id="btnLogout"/>
</fieldset>
<script src="./js/jquery-3.6.0.min.js"></script>
<script>
$(function () {
$('#btnSearch').click(function () {
let name_val = $('#name').val();
let gender_val = $('#gender').val();
let pindex_val = $('#pageIndex').val();
let psize_val = $('#pageSize').val();
if (psize_val < 0) {
alert('每页条数必须大于0');
return false;
}
$.ajax({
type: "post",
url: "/emp/list/" + pindex_val + "/" + psize_val,
data: {name: name_val, gender: gender_val},
dataType: "json",
xhrFields: {
//允许 ajax 请求携带 cookie
withCredentials: true
},
success: function (data) {
if (data.flag) {
$('#txtResult').val(JSON.stringify(data.data, null, 2));
} else {
alert(data.msg);
if (data.msg == "用户没有登录") {
location.href = "login.html";
}
}
}
});
});
$('#btnLogout').click(function () {
$.ajax({
type: "post",
url: "/emp/logout",
dataType: "json",
xhrFields: {
//允许 ajax 请求携带 cookie
withCredentials: true
},
success: function (data) {
if (data.flag) {
alert("退出成功");
}
location.href = "login.html";
}
});
});
//页面加载完成后，自动查询一下数据
$('#btnSearch').trigger("click");
})
</script>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="refresh" content="5;url=login.html">
<title>未登录提示页面</title>
</head>
<body>
<h1 >这里是用户未登录提示页面 prompt.html</h1>
<h1 style="color:indigo">5秒钟将自动跳转到登录页面...</h1>
</body>
</html>
本博客 Demo 实现的具体细节为：
用户登录成功后，服务端会将用户名记录到 Redis 中，前端 jquery 会将用户名记录到 Cookie 中。前端后续每次请求服务端的接口时，都会携带 Cookie 提交给服务端的接口，SpringMvc 的拦截器会读取 Cookie 中的用户名，然后在 Redis 中查找是否存在，如果存在则认为已经登录了，如果不存在，则认为未登录。另外 Redis 中保存的用户名，设置了 1 分钟的有效期。如果一分钟内，前端有新的请求的话，拦截器中的代码会从请求时刻开始，为用户名在 Redis 中延长一分钟的有效期。
最后提供本 Demo 的源代码下载地址：https://files.cnblogs.com/files/blogs/699532/Spring_SpringMvc_MyBatis.zip
标签：name,示例,SpringMvc,Spring,springframework,org,import,com,public 来源： https://www.cnblogs.com/studyjobs/p/16219715.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。