超十万字_超详细SSM整合实践_手动实现权限管理
SSM整合_基础配置
SSM框架中包含Spring，SpringMVC，Mybatis。而Spring与SpringMVC都是Spring Framework的模块，无需整合。只需将Mybatis与Spring整合即可。
一、整合关注点
1、Spring在web项目中的应用。
在web项目启动时，读取applicationContext.xml配置文件，创建IOC容器。
2、使用连接池作为数据源。
直连数据源或Spring中的数据源（DriverManagerDataSource），连接效率太低。使用阿里旗下的德鲁伊连接池（druid）作为连接数据源。
3、Mybatis与Spring的结合。
通过Spring的IOC容器管理SqlSessionFactory、mapper接口的代理对象。
二、导入依赖
2.1 Spring依赖
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-coreartifactId>
<version>4.3.18.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-beansartifactId>
<version>4.3.18.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>4.3.18.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-expressionartifactId>
<version>4.3.18.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-aopartifactId>
<version>4.3.18.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-aspectsartifactId>
<version>4.3.18.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-jdbcartifactId>
<version>4.3.18.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-txartifactId>
<version>4.3.18.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webartifactId>
<version>4.3.18.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>4.3.18.RELEASEversion>
dependency>
2.2 Mybatis依赖
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.4.6version>
dependency>
<dependency>
<groupId>com.github.pagehelpergroupId>
<artifactId>pagehelperartifactId>
<version>5.1.2version>
dependency>
2.3 Mybatis与Spring整合依赖
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatis-springartifactId>
<version>1.3.2version>
dependency>
2.4 连接池与数据库驱动依赖
<dependency>
<groupId>com.oraclegroupId>
<artifactId>ojdbc6artifactId>
<version>11.2.0version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.49version>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>druidartifactId>
<version>1.1.10version>
dependency>
2.5 JavaWeb环境依赖
<dependency>
<groupId>javax.servletgroupId>
<artifactId>javax.servlet-apiartifactId>
<version>3.1.0version>
<scope>providedscope>
dependency>
<dependency>
<groupId>javax.servlet.jspgroupId>
<artifactId>jsp-apiartifactId>
<version>2.1version>
<scope>providedscope>
dependency>
<dependency>
<groupId>javax.servletgroupId>
<artifactId>jstlartifactId>
<version>1.2version>
dependency>
2.6 可选插件依赖
<dependency>
<groupId>commons-fileuploadgroupId>
<artifactId>commons-fileuploadartifactId>
<version>1.3.1version>
dependency>
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-coreartifactId>
<version>2.9.5version>
dependency>
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
<version>2.9.5version>
dependency>
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-annotationsartifactId>
<version>2.9.5version>
dependency>
<dependency>
<groupId>org.hibernategroupId>
<artifactId>hibernate-validatorartifactId>
<version>5.4.1.Finalversion>
dependency>
<dependency>
<groupId>log4jgroupId>
<artifactId>log4jartifactId>
<version>1.2.17version>
dependency>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.12version>
<scope>testscope>
dependency>
三、目录结构
src/main/java目录下建立Java软件包结构。
src/main/resources目录下存放各种配置文件和资源文件。
webapp目录下存放web项目静态资源和WEB-INF目录，其中jsp页面都存放在WEB-INF下。
四、配置文件
4.1 web.xml
<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">
web-app>
4.1.1 字符编码过滤器
采用Spring中提供的字符编码过滤器CharacterEncodingFilter。
<filter>
<filter-name>CharacterEncodingFilterfilter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
<init-param>
<param-name>encodingparam-name>
<param-value>utf-8param-value>
init-param>
filter>
<filter-mapping>
<filter-name>CharacterEncodingFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
4.1.2 IOC容器的监听器
在web项目启动时，上下文对象ServletContext对象初始化后，读取Spring的配置文件并创建IOC容器对象，最后将其放入到上下文作用域中。
采用Spring中提供的ContextLoaderListener监听器。
<context-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath:applicationContext*.xmlparam-value>
context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
listener>
4.1.3 前端控制器
<servlet>
<servlet-name>springmvcservlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
<init-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath:springmvc.xmlparam-value>
init-param>
<load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
<servlet-name>springmvcservlet-name>
<url-pattern>/url-pattern>
servlet-mapping>
4.1.4 欢迎页面
<welcome-file-list>
<welcome-file>/WEB-INF/views/index.jspwelcome-file>
welcome-file-list>
4.1.5 其他配置
<filter>
<filter-name>HiddenHttpMethodFilterfilter-name>
<filter-class>org.springframework.web.filter.HiddenHttpMethodFilterfilter-class>
filter>
<filter-mapping>
<filter-name>HiddenHttpMethodFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
<filter>
<filter-name>HttpPutFormContentFilterfilter-name>
<filter-class>org.springframework.web.filter.HttpPutFormContentFilterfilter-class>
filter>
<filter-mapping>
<filter-name>HttpPutFormContentFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
4.2 Mybatis配置文件
以前在mybatis-config.xml中需要加载资源、全局参数、类型别名、分页插件、连接数据库环境、加载映射文件等配置。但与Spring整合后，加载资源、连接数据库环境必须移入Spring中配置，加载映射文件建议移入Spring中（可使用通配符），其他的两者都可。如果将所有内容移入Spring中配置，那么此文件可消失。
DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"/>
<setting name="logImpl" value="org.apache.ibatis.logging.stdout.StdOutImpl"/>
settings>
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor">
<property name="reasonable" value="true"/>
plugin>
plugins>
configuration>
db.properties：
#mysql
jdbc.mysql.driver=com.mysql.jdbc.Driver
jdbc.mysql.url=jdbc:mysql://localhost:3306/ssm?characterEncoding=utf8&useSSL=false
jdbc.mysql.username=root
jdbc.mysql.password=root
#oracle
jdbc.oracle.driver=oracle.jdbc.driver.OracleDriver
jdbc.oracle.url=jdbc:oracle:thin:@localhost:1521:orcl
jdbc.oracle.username=system
jdbc.oracle.password=123456
log4j.properties：
#井号表示注释，配置内容为键值对格式，每行只能有一个键值对，键值对之间以=连接
#指定logger
#设定log4j的日志级别和输出的目的地
#INFO日志级别 ,Console和logfile输出的目的地
#等级 OFF,ERROR,WARN,INFO,DEBUG,TRACE,ALL
log4j.rootLogger=DEBUG,Console
#指定appender
#设定Logger的Console,其中Console为自定义名称,类型为控制台输出
log4j.appender.Console=org.apache.log4j.ConsoleAppender
#设定Logger的logfile,其中logfile为自定义名称,类型为文件
#org.apache.log4j.FileAppender文件
#org.apache.log4j.RollingFileAppender文件大小到达指定尺寸后产生一个新的文件
#org.apache.log4j.DailyRollingFileAppender每天产生一个日志文件
log4j.appender.logfile=org.apache.log4j.RollingFileAppender
#设定文件的输出路径
log4j.appender.logfile.File=d:/log/test.log
#设定文件最大尺寸 单位可以使KB,MB,GB
log4j.appender.logfile.MaxFileSize=2048KB
#输出格式
#设定appender布局Layout
# %d 输出日志的日期和时间,指定格式:%d{yyyy-MM-dd HH:mm:ss SSS}
# %p 输出的日志级别
# %c 输出所属类的全类名
# %M 方法名
# %m 输出代码中指定消息
# %n 一个换行符
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d %p %c.%M() --%m%n
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p %c.%M() --%m%n
4.3 Spring配置文件
因Spring中配置过多，可将Spring分成多个文件来进行分别配置。
在web.xml中通过通配符一起加载即可（classpath:spring/applicationContext*.xml）。
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:p="http://www.springframework.org/schema/p"
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.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
beans>
4.3.1 applicationContext.xml
- 注解扫描：
配置：基础包为公共包（com.newcapec），并过滤掉@Controller注解。
思路：Spring与SpringMVC分开扫描各自的内容，SpingMVC扫描表现层的类（Controller），而Spring扫描其他。
<context:component-scan base-package="com.newcapec">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
context:component-scan>
- 数据源：
配置：读取db.properties文件，数据源对象采用阿里旗下的德鲁伊连接池，并配置连接数据库的基础信息和连接池的关键信息。
<context:property-placeholder location="classpath:db.properties"/>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.mysql.driver}"/>
<property name="url" value="${jdbc.mysql.url}"/>
<property name="username" value="${jdbc.mysql.username}"/>
<property name="password" value="${jdbc.mysql.password}"/>
<property name="initialSize" value="${druid.initialSize}" />
<property name="minIdle" value="${druid.minIdle}" />
<property name="maxActive" value="${druid.maxActive}" />
<property name="maxWait" value="${druid.maxWait}" />
bean>
#mysql
jdbc.mysql.driver=com.mysql.jdbc.Driver
jdbc.mysql.url=jdbc:mysql://localhost:3306/ssm?characterEncoding=utf8&useSSL=false
jdbc.mysql.username=root
jdbc.mysql.password=root
#oracle
jdbc.oracle.driver=oracle.jdbc.driver.OracleDriver
jdbc.oracle.url=jdbc:oracle:thin:@localhost:1521:orcl
jdbc.oracle.username=system
jdbc.oracle.password=123456
#druid
druid.initialSize=5
druid.minIdle=5
druid.maxActive=15
druid.maxWait=10000
- Mybatis
配置：SqlSessionFactory对象bean和mapper接口的代理对象bean。
思路：
1、SqlSessionFactory的最佳使用范围是整个应用运行期间，一旦创建后可以重复使用，通常以单例模式管理。通过mybatis-spring整合包中的SqlSessionFactoryBean来创建一个单例的SqlSessionFactory。
2、SqlSessionFactoryBean的属性必须配置数据源，可选配加载Mybatis的全局配置文件（如果部分内容仍然留在其中），加载mapper映射文件（建议在此配置，可使用统配符批量加载），类型别名，插件等信息。
3、Mybatis中的mapper代理对象可针对每个接口通过MapperFactoryBean来进行单独配置，仅需告知Dao接口的全限定名即可。缺点：中大型项目中Dao接口过多时，配置量过大，不建议使用。
4、通过MapperScannerConfigurer配置mapper代理扫描器可批量配置mapper代理对象，仅需告知Dao接口的存放包名和SqlSessionFactory即可。
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:mapper/*Mapper.xml"/>
bean>
<bean id="empDao" class="org.mybatis.spring.mapper.MapperFactoryBean">
<property name="mapperInterface" value="com.newcapec.dao.EmpDao"/>
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
bean>
<bean id="deptDao" class="org.mybatis.spring.mapper.MapperFactoryBean">
<property name="mapperInterface" value="com.newcapec.dao.DeptDao"/>
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.newcapec.dao"/>
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
bean>
mapper文件模板：
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="">
mapper>
4.3.2 applicationContext-tx.xml
- 事务管理配置文件
配置：事务管理器对象，事务，事务属性，事务切入点。
思路：
1、事务相关配置放在此文件中，与其他配置分离，减少配置文件臃肿的情况，便于后期维护。
2、持久层使用Mybatis框架，事务管理器采用JDBC的事务管理器即可（DataSourceTransactionManager），并注入数据源对象。
3、事务属性根据不同的需求选择更佳合理的配置。
4、事务切入点将事务通过AOP的方式应用在指定的切点表达式中。
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
bean>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="add*" isolation="READ_COMMITTED" rollback-for="java.lang.Exception"/>
<tx:method name="edit*" isolation="READ_COMMITTED" rollback-for="java.lang.Exception"/>
<tx:method name="remove*" isolation="READ_COMMITTED" rollback-for="java.lang.Exception"/>
<tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
<tx:method name="query*" propagation="SUPPORTS" read-only="true"/>
<tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
<tx:method name="*"/>
tx:attributes>
tx:advice>
<aop:config>
<aop:pointcut id="exp" expression="execution(* com.newcapec.service..*Impl.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="exp"/>
aop:config>
4.4 SpringMVC配置文件
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
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.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util.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">
beans>
- 注解扫描
配置：基础包为表现层的软件包。
思路：SpingMVC仅负责扫描表现层的类（Controller）。
解析：
SpingMVC中的注解扫描也是将扫描到的对象放入到IOC容器中。当web项目启动后首先配置的是Spring容器的初始化，然后是SpringMVC的前端控制器（DispatchServlet），当配置完DispatchServlet后会在Spring容器中创建一个新的容器。其实这是两个容器，Spring作为父容器，SpringMVC作为子容器（如下图），SpringMVC子容器中的对象是可以访问Spring父容器中的对象，但父容器中的对象无法访问子容器中的对象。
通常在Service中注入Dao，接着在Controller里注入Service，这就意味这作为SpringMVC的子容器是可以访问父容器Spring对象的，如果把Controller注入到Service中肯定是不行的。假设将Dao，Serive，Controller都放入同一个容器中，那么对象之间的依赖注入是没有问题了，但必须都在SpringMVC的子容器（在SpringMVC中扫描全部）。如果Dao，Serive，Controller都放在Spring的父容器中（在Spring中扫描全部），而这时的SpringMVC容器中没有Controller对象，所以加载处理器适配器的时候就会找不到映射的Controller对象，因此在页面上就会出现404的错误。
<context:component-scan base-package="com.newcapec.controller"/>
- 注解驱动
<mvc:annotation-driven conversion-service="conversionService"/>
- 视图解析器
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/"/>
<property name="suffix" value=".jsp"/>
bean>
- 格式化与类型转换服务
<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
<property name="converters">
<set>
<bean class="com.newcapec.util.DateConverter"/>
set>
property>
bean>
- 静态资源处理
<mvc:default-servlet-handler/>
<mvc:resources mapping="/static/**" location="/WEB-INF/static/"/>
- 其他配置
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="maxUploadSize" value="104857600"/>
<property name="defaultEncoding" value="utf-8"/>
<property name="maxInMemorySize" value="10240"/>
bean>
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<mvc:exclude-mapping path="/login"/>
<bean class="com.newcapec.intercepor.LoginInterceptor"/>
mvc:interceptor>
mvc:interceptors>
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<mvc:exclude-mapping path="/page/**"/>
<mvc:exclude-mapping path="/static/**"/>
<mvc:exclude-mapping path="/auth/login"/>
<bean class="com.newcapec.interceptor.LoginInterceptor"/>
mvc:interceptor>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<mvc:exclude-mapping path="/page/login"/>
<mvc:exclude-mapping path="/page/index"/>
<mvc:exclude-mapping path="/static/**"/>
<mvc:exclude-mapping path="/auth/**"/>
<mvc:exclude-mapping path="/permission/findMenu"/>
<bean class="com.newcapec.interceptor.PermissionInterceptor"/>
mvc:interceptor>
mvc:interceptors>
SSM整合_同步案例
该案例仅仅作为验证配置是否正确，后期所有的案例和项目，全部采用异步实现。
一、表结构
-- 学生表
CREATE TABLE `student` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(20) DEFAULT NULL,
`gender` varchar(20) DEFAULT NULL,
`major` varchar(20) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
-- 数据
INSERT INTO `student` VALUES (1, '小明', '1', '软件工程');
INSERT INTO `student` VALUES (2, '小红', '0', '网络工程');
INSERT INTO `student` VALUES (3, '小黑', '1', '信息安全');
INSERT INTO `student` VALUES (4, '小白', '0', '网络工程');
INSERT INTO `student` VALUES (5, '张三', '1', '软件工程');
INSERT INTO `student` VALUES (6, '李四', '0', '艺术设计');
INSERT INTO `student` VALUES (7, '王五', '1', '游戏设计');
INSERT INTO `student` VALUES (8, '马六', '1', '移动互联网');
二、实体类
实体类所在的包名为entity/domain。表名作为实体类名称，表中的字段作为实体类中的成员变量名称。
注：根据实际的命名规范命名。
/**
* 学生实体类
*/
public class Student {
private Integer id;
private String name;
private String gender;
private String major;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
}
三、持久层
持久层包名为dao。持久层接口名称命名规范：实体类名+Dao。
持久层中方法命名规范：
insert新增
update修改
delete单删
deleteBatch批量删除
select批量查询
selectById单查
注：企业中都有一套命名规范，不绝对。
3.1 接口
public interface StudentDao {
/*
* 新增学生的方法
* @param student 新增学生的数据
*/
void insert(Student student);
/*
* 修改学生的方法
* @param student 修改学生的数据
*/
void update(Student student);
/*
* 根据id单个删除的方法
* @param id 删除学生的id
*/
void delete(Integer id);
/*
* 根据id批量删除的方法
* @param ids 删除学生的id
*/
void deleteBatch(Integer[] ids);
/*
* 批量查询学生的方法
* @param student 包含查询学生的条件数据的实体
* @return List 查询到的学生数据
*/
List<Student> select(Student student);
/*
* 根据id查询学生的方法
* @param id 学生id
* @return Student 查询到的学生数据
*/
Student selectById(Integer id);
}
3.2 Mapper文件
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.newcapec.dao.StudentDao">
<insert id="insert" parameterType="com.newcapec.entity.Student" useGeneratedKeys="true" keyProperty="id">
insert into student(name, gender, major)
values (#{name}, #{gender}, #{major})
insert>
<update id="update" parameterType="com.newcapec.entity.Student">
update student
<set>
<if test="name != null">
name = #{name},
if>
<if test="gender != null">
gender = #{gender},
if>
<if test="major != null">
major = #{major}
if>
set>
where id = #{id}
update>
<delete id="delete" parameterType="java.lang.Integer">
delete
from student
where id = #{id}
delete>
<delete id="deleteBatch" parameterType="java.lang.Integer">
delete from student where id in
<foreach collection="array" open="(" close=")" separator="," item="id">
#{id}
foreach>
delete>
<select id="select" parameterType="com.newcapec.entity.Student" resultType="com.newcapec.entity.Student">
select id, name, gender, major from student
<where>
<if test="name != null and name != ''">
name like concat('%', #{name}, '%')
if>
<if test="gender != null and gender != ''">
gender = #{gender}
if>
<if test="major != null and major != ''">
major like concat('%', #{major}, '%')
if>
where>
select>
<select id="selectById" parameterType="java.lang.Integer" resultType="com.newcapec.entity.Student">
select id, name, gender, major
from student
where id = #{id}
select>
mapper>
四、业务层
业务层包名为service。业务层接口名称命名规范：实体类+Service。
业务层中方法命名规范：
add新增
edit编辑
remove删除
remove批量删除
find批量查询
findById单条查询
service层命名和dao层命名进行区分：
1、后期业务越来越复杂，通过方法名便于区分。
2、对标Spring事务的配置。
4.1 接口
public interface StudentService {
void add(Student student);
void edit(Student student);
void remove(Integer id);
void removeBatch(Integer[] ids);
List<Student> find(Student student);
PageInfo findPage(Integer pageNum, Integer pageSize, Student student);
Student findById(Integer id);
}
4.2 实现类
@Service
public class StudentServiceImpl implements StudentService {
@Autowired
private StudentDao studentDao;
@Override
public void add(Student student) {
studentDao.insert(student);
}
@Override
public void edit(Student student) {
studentDao.update(student);
}
@Override
public void remove(Integer id) {
studentDao.delete(id);
}
@Override
public void removeBatch(Integer[] ids) {
studentDao.deleteBatch(ids);
}
@Override
public List<Student> find(Student student) {
return studentDao.select(student);
}
@Override
public PageInfo findPage(Integer pageNum, Integer pageSize, Student student) {
//分页业务实现
PageHelper.startPage(pageNum, pageSize);
List<Student> list = studentDao.select(student);
PageInfo<Student> pageInfo = new PageInfo<>(list);
return pageInfo;
}
@Override
public Student findById(Integer id) {
return studentDao.selectById(id);
}
}
五、web层
web层包名为controller。类的命名规范：实体类名+Controller。
同步请求处理：对HTTP限制GET（查询和删除）和POST（新增和修改）。
@Controller
@RequestMapping("/student")
public class StudentController {
@Autowired
private StudentService studentService;
/*
* 新增
*/
@PostMapping("/add")
public String add(Student student) {
studentService.add(student);
return "redirect:/student/find";
}
/*
* 修改
*/
@PostMapping("/edit")
public String edit(Student student) {
studentService.edit(student);
return "redirect:/student/find";
}
/*
* 删除
*/
@GetMapping("/remove/{id}")
public String remove(@PathVariable Integer id) {
studentService.remove(id);
return "redirect:/student/find";
}
/*
* 批量删除
*/
@GetMapping("/remove")
public String removeBatch(Integer[] ids) {
studentService.removeBatch(ids);
return "redirect:/student/find";
}
/*
* 单条查询
*/
@GetMapping("/find/{id}")
public String findById(@PathVariable Integer id, Model model) {
Student student = studentService.findById(id);
model.addAttribute("student", student);
//跳转修改学生的视图
return "stu/edit";
}
/*
* 分页查询
* @param pageNum 页码
* @param pageSize 每页条目数
* @param student 包含查询条件的实体
* @param model 用来向request域存储数据的ui
* @return java.lang.String 跳转学生列表页的视图
*
* 接收到的请求没有pageNum，默认值1
* 接收到的请求没有pageSize，默认值5
*/
@GetMapping("/find")
public String findPage(@RequestParam(value = "pageNum", required = false, defaultValue = "1") Integer pageNum,
@RequestParam(value = "pageSize", required = false, defaultValue = "5") Integer pageSize,
Student student, Model model) {
PageInfo pageInfo = studentService.findPage(pageNum, pageSize, student);
model.addAttribute("pageInfo", pageInfo);
return "stu/list";
}
}
六、前端页面实现
6.1 首页
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
这里是首页
学生信息管理
6.2 学生列表页
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
SystemController.java：
/**
* 用来实现页面跳转的处理器
*/
@Controller
@RequestMapping("/page")
public class SystemController {
@GetMapping("/stu/add")
public String stuAdd() {
return "stu/add";
}
}
6.3 新增页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
新增学生页面
6.4 修改页面
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
修改学生页面
SSM整合_异步案例
一、表结构
-- ----------------------------
-- 权限表
-- ----------------------------
DROP TABLE IF EXISTS `t_sys_permission`;
CREATE TABLE `t_sys_permission` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id',
`name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '权限名称',
`type` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限类型：1目录 2菜单 3按钮',
`url` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '#' COMMENT '访问地址',
`percode` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限代码',
`parent_id` int(11) NULL DEFAULT 0 COMMENT '父节点ID',
`sort` int(11) NULL DEFAULT NULL COMMENT '显示顺序',
`del` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '0' COMMENT '是否删除：0正常1删除',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 14 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '权限信息表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- 权限表数据
-- ----------------------------
INSERT INTO `t_sys_permission` VALUES (1, '系统管理', '1', '', 'system', 0, 1, '0');
INSERT INTO `t_sys_permission` VALUES (2, '用户列表', '2', '', 'user', 1, 11, '0');
INSERT INTO `t_sys_permission` VALUES (3, '用户查询', '3', '', 'user:query', 2, 111, '0');
INSERT INTO `t_sys_permission` VALUES (4, '用户新增', '3', '', 'user:add', 2, 112, '0');
INSERT INTO `t_sys_permission` VALUES (5, '用户编辑', '3', '', 'user:edit', 2, 113, '0');
INSERT INTO `t_sys_permission` VALUES (6, '用户删除', '3', '', 'user:remove', 2, 114, '0');
INSERT INTO `t_sys_permission` VALUES (7, '角色列表', '2', '', 'role', 1, 12, '0');
INSERT INTO `t_sys_permission` VALUES (8, '角色查询', '3', '', 'role:query', 7, 121, '0');
INSERT INTO `t_sys_permission` VALUES (9, '角色新增', '3', '', 'role:add', 7, 122, '0');
INSERT INTO `t_sys_permission` VALUES (10, '角色编辑', '3', '', 'role:edit', 7, 123, '0');
INSERT INTO `t_sys_permission` VALUES (11, '角色删除', '3', '', 'role:remove', 7, 124, '0');
INSERT INTO `t_sys_permission` VALUES (12, '权限列表', '2', '', 'permission', 1, 13, '0');
INSERT INTO `t_sys_permission` VALUES (13, '权限查询', '3', '', 'permission:query', 12, 131, '0');
INSERT INTO `t_sys_permission` VALUES (14, '权限新增', '3', '', 'permission:add', 12, 132, '0');
INSERT INTO `t_sys_permission` VALUES (15, '权限编辑', '3', '', 'permission:edit', 12, 133, '0');
INSERT INTO `t_sys_permission` VALUES (16, '权限删除', '3', '', 'permission:remove', 12, 134, '0');
-- ----------------------------
-- 角色表
-- ----------------------------
DROP TABLE IF EXISTS `t_sys_role`;
CREATE TABLE `t_sys_role` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id',
`role_code` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '角色编码',
`role_name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '角色名称',
`description` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '描述',
`del` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '0' COMMENT '是否删除：0正常1删除',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '角色信息表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- 角色表数据
-- ----------------------------
INSERT INTO `t_sys_role` VALUES (1, 'admin', '管理员', '管理员', '0');
INSERT INTO `t_sys_role` VALUES (2, 'user', '普通用户', '普通用户', '0');
-- ----------------------------
-- 角色权限中间表
-- ----------------------------
DROP TABLE IF EXISTS `t_sys_role_permission`;
CREATE TABLE `t_sys_role_permission` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
`role_id` int(11) NOT NULL COMMENT '角色ID',
`permission_id` int(11) NOT NULL COMMENT '权限ID',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 18 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '角色和权限关联表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- 角色权限中间表数据
-- ----------------------------
INSERT INTO `t_sys_role_permission` VALUES (1, 1, 1);
INSERT INTO `t_sys_role_permission` VALUES (2, 1, 2);
INSERT INTO `t_sys_role_permission` VALUES (3, 1, 3);
INSERT INTO `t_sys_role_permission` VALUES (4, 1, 4);
INSERT INTO `t_sys_role_permission` VALUES (5, 1, 5);
INSERT INTO `t_sys_role_permission` VALUES (6, 1, 6);
INSERT INTO `t_sys_role_permission` VALUES (7, 1, 7);
INSERT INTO `t_sys_role_permission` VALUES (8, 1, 8);
INSERT INTO `t_sys_role_permission` VALUES (9, 1, 9);
INSERT INTO `t_sys_role_permission` VALUES (10, 1, 10);
INSERT INTO `t_sys_role_permission` VALUES (11, 1, 11);
INSERT INTO `t_sys_role_permission` VALUES (12, 1, 12);
INSERT INTO `t_sys_role_permission` VALUES (13, 1, 13);
INSERT INTO `t_sys_role_permission` VALUES (14, 2, 1);
INSERT INTO `t_sys_role_permission` VALUES (15, 2, 2);
INSERT INTO `t_sys_role_permission` VALUES (16, 2, 6);
INSERT INTO `t_sys_role_permission` VALUES (17, 2, 10);
-- ----------------------------
-- 用户表
-- ----------------------------
DROP TABLE IF EXISTS `t_sys_user`;
CREATE TABLE `t_sys_user` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
`username` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '登录账号',
`mobile` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '手机号码',
`nickname` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户昵称',
`email` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户邮箱',
`userpwd` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '密码',
`salt` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT 'newedu' COMMENT '加密盐',
`status` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '1' COMMENT '状态：1可用2不可用',
`del` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '0' COMMENT '是否删除：0正常1删除',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '用户信息表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- 用户表数据
-- ----------------------------
INSERT INTO `t_sys_user` VALUES (1, 'admin', '13612345678', '管理员', '[email protected]', '8f32e9f68d6886d095b230b93e7a2c86', 'newedu', '1', '0');
INSERT INTO `t_sys_user` VALUES (2, 'tom', '12345678901', '汤姆', '[email protected]', '8f32e9f68d6886d095b230b93e7a2c86', 'newedu', '1', '0');
-- ----------------------------
-- 用户角色中间表
-- ----------------------------
DROP TABLE IF EXISTS `t_sys_user_role`;
CREATE TABLE `t_sys_user_role` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
`user_id` int(11) NOT NULL COMMENT '用户ID',
`role_id` int(11) NOT NULL COMMENT '角色ID',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '用户和角色关联表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- 用户角色中间表数据
-- ----------------------------
INSERT INTO `t_sys_user_role` VALUES (1, 1, 1);
INSERT INTO `t_sys_user_role` VALUES (2, 1, 2);
INSERT INTO `t_sys_user_role` VALUES (3, 2, 2);
二、基础封装
2.1 系统编码
package com.newcapec.constant;
/*
* 系统编码：不是Http协议的响应码，是我们自定义的用来针对某些情况给与的响应码
* 作用：当后台向前端响应的时候，除了响应数据以外，还要响应一些编码，前端通过这些编码可以判断操作是成功，还是失败，以及失败的原因等。
* 比如用户名和密码不是代码错误，只是没有匹配到对应的数据，但是在业务角度来看就是错误，我们可以响应指定的编码来告知前端问题所在。
*
*/
public enum SystemCode {
OK(200, "成功"),
USERNAME_EXISTS(401, "用户名已存在"),
USERNAME_ERROR(402, "用户名或密码错误"),
NO_USER(403, "用户不存在"),
NOT_LOGIN(404, "用户未登录"),
NO_PERMISSION(405, "权限不足，禁止访问"),
ERROR(500, "失败");
int code;
String message;
SystemCode(int code, String message) {
this.code = code;
this.message = message;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
2.2 公共常量
package com.newcapec.constant;
/**
* 公共常量，在系统中尽量避免常量值的出现，造成后期维护困难。
* 比如：之前Controller中定义的pageNum，pageSize都是常量值，如果后续想要变更名称，必须全部修改，不利于维护。
*/
public class CommonConstant {
/*
* 页码名称
*/
public static final String PAGE_NUM = "pageNum";
/*
* 每页条目数名称
*/
public static final String PAGE_SIZE = "pageSize";
/*
* 总记录数名称
*/
public static final String PAGE_TOTAL = "total";
/*
* 每页数据名称
*/
public static final String PAGE_LIST = "list";
/*
* 页码默认值
*/
public static final String PAGE_NUM_DEFAULT = "1";
/*
* 每页条目数默认值
*/
public static final String PAGE_SIZE_DEFAULT = "10";
/*
* 默认密码
*/
public static final String PASSWORD_DEFAULT = "123456";
}
2.3 响应格式类
package com.newcapec.utils;
import com.newcapec.constant.SystemCode;
/**
* 响应格式类
* 作用：统一服务端的响应数据格式
*/
public class Result<T> {
/**
* 响应代码
*/
private int code;
/**
* 响应信息
*/
private String message;
/**
* 响应数据
*/
private T data;
public Result(int code, String message, T data) {
this.code = code;
this.message = message;
this.data = data;
}
/**
* 成功的响应：不传递数据到页面
*/
public static Result success() {
return new Result(SystemCode.OK.getCode(), SystemCode.OK.getMessage(), null);
}
/**
* 成功的响应：传递数据到页面
*/
public static <T> Result success(T data) {
return new Result(SystemCode.OK.getCode(), SystemCode.OK.getMessage(), data);
}
/**
* 失败的响应：不传递数据到页面
*/
public static Result error() {
return new Result(SystemCode.ERROR.getCode(), SystemCode.ERROR.getMessage(), null);
}
/**
* 失败的响应：传递数据到页面
*/
public static <T> Result error(T data) {
return new Result(SystemCode.ERROR.getCode(), SystemCode.ERROR.getMessage(), data);
}
/**
* 失败的响应：传递数据到页面，并且传递响应码和响应信息
*/
public static <T> Result error(int code, String message, T data) {
return new Result(code, message, data);
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
2.4 持久层公共接口
package com.newcapec.utils;
import java.util.List;
/*
* 持久层公共接口
*/
public interface BaseDao<T> {
/*
* 新增方法
*/
void insert(T entity);
/*
* 修改方法
*/
void update(T entity);
/*
* 根据id单个删除的方法
*/
void delete(Integer id);
/*
* 根据id批量删除的方法
*/
void deleteBatch(Integer[] ids);
/*
* 批量查询的方法
*/
List<T> select(T entity);
/*
* 根据id查询的方法
*/
T selectById(Integer id);
}
2.5 业务层公共接口
package com.newcapec.utils;
import java.util.List;
import java.util.Map;
/*
* 业务层公共接口
*/
public interface BaseService<T> {
void add(T entity);
void edit(T entity);
void remove(Integer id);
void removeBatch(Integer[] ids);
List<T> find(T entity);
/*
* 同步案例中：分页条件查询，我们反馈的是PageInfo对象
* 但是PageHelper建议尽量不要跨层，以便后期维护。
* 比如：后期我们通过Mybatis-plus替换mybatis，那么如果跨层，就需要多个地方更改。
*/
Map<String, Object> findPage(Integer pageNum, Integer pageSize, T entity);
T findById(Integer id);
}
三、系统用户模块
3.1 实体类
package com.newcapec.entity;
/**
* 系统用户实体类: 用于用户表的基础功能CURD操作的实现
*/
public class SysUser {
private Integer id;
private String username;
private String mobile;
private String nickname;
private String email;
private String userpwd;
private String salt;
private String status;
private String del;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getMobile() {
return mobile;
}
public void setMobile(String mobile) {
this.mobile = mobile;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getUserpwd() {
return userpwd;
}
public void setUserpwd(String userpwd) {
this.userpwd = userpwd;
}
public String getSalt() {
return salt;
}
public void setSalt(String salt) {
this.salt = salt;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getDel() {
return del;
}
public void setDel(String del) {
this.del = del;
}
}
3.2 持久层
Dao接口：
package com.newcapec.dao;
import com.newcapec.entity.SysUser;
import com.newcapec.utils.BaseDao;
/*
* 继承BaseDao中定义的方法，还可以扩展。
*/
public interface SysUserDao extends BaseDao<SysUser> {
/*
* 根据用户名查询
* 1、注册：用户名查重
* 2、用户登录（精细化提示使用，先判断用户名，再判断密码）
*/
SysUser selectByUsername(String username);
}
Mapper文件：
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.newcapec.dao.SysUserDao">
<insert id="insert" parameterType="com.newcapec.entity.SysUser" useGeneratedKeys="true" keyProperty="id">
insert into t_sys_user(username, mobile, nickname, email, userpwd, salt)
values (#{username}, #{mobile}, #{nickname}, #{email}, #{userpwd}, #{salt})
insert>
<update id="update" parameterType="com.newcapec.entity.SysUser">
update t_sys_user
<set>
<if test="username != null">
username = #{username},
if>
<if test="mobile != null">
mobile = #{mobile},
if>
<if test="nickname != null">
nickname = #{nickname},
if>
<if test="email != null">
email = #{email},
if>
<if test="userpwd != null">
userpwd = #{userpwd},
if>
<if test="salt != null">
salt = #{salt},
if>
<if test="status != null">
status = #{status}
if>
set>
where id = #{id}
update>
<delete id="delete" parameterType="java.lang.Integer">
update t_sys_user
set del = 1
where id = #{id}
delete>
<delete id="deleteBatch" parameterType="java.lang.Integer">
update t_sys_user set del = 1 where id in
<foreach collection="array" open="(" close=")" separator="," item="id">
#{id}
foreach>
delete>
<resultMap id="BaseResultMap" type="com.newcapec.entity.SysUser">
<id column="id" property="id"/>
<result column="username" property="username"/>
<result column="mobile" property="mobile"/>
<result column="nickname" property="nickname"/>
<result column="email" property="email"/>
<result column="userpwd" property="userpwd"/>
<result column="salt" property="salt"/>
<result column="status" property="status"/>
resultMap>
<select id="select" parameterType="com.newcapec.entity.SysUser" resultMap="BaseResultMap">
select id, username, mobile, nickname, email, userpwd, salt, status from t_sys_user
<where>
<if test="username != null and username != ''">
username like concat('%',#{username},'%')
if>
<if test="nickname != null and nickname != ''">
and nickname like concat('%',#{nickname},'%')
if>
and del=0
where>
select>
<select id="selectById" parameterType="java.lang.Integer" resultType="com.newcapec.entity.SysUser">
select id, username, mobile, nickname, email, userpwd, salt, status from t_sys_user
where id = #{id} and del=0
select>
<select id="selectByUsername" parameterType="java.lang.String" resultType="com.newcapec.entity.SysUser">
select id, username, mobile, nickname, email, userpwd, salt from t_sys_user
where username = #{username} and del=0
select>
mapper>
3.3 业务层
Service接口：
package com.newcapec.service;
import com.newcapec.entity.SysUser;
import com.newcapec.utils.BaseService;
public interface SysUserService extends BaseService<SysUser> {
SysUser findByUsername(String username);
}
Service接口实现类：
package com.newcapec.service.impl;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.newcapec.constant.CommonConstant;
import com.newcapec.dao.SysUserDao;
import com.newcapec.entity.Student;
import com.newcapec.entity.SysUser;
import com.newcapec.service.SysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Service
public class SysUserServiceImpl implements SysUserService {
@Autowired
private SysUserDao sysUserDao;
@Override
public SysUser findByUsername(String username) {
return sysUserDao.selectByUsername(username);
}
@Override
public void add(SysUser entity) {
SysUser sysUser = findByUsername(entity.getUsername());
//后台校验，保证安全性，防止第三方工具注册（PostMan）
if (sysUser == null) {
entity.setUserpwd(CommonConstant.PASSWORD_DEFAULT);
sysUserDao.insert(entity);
}
}
@Override
public void edit(SysUser entity) {
SysUser sysUser = findByUsername(entity.getUsername());
if (sysUser != null) {
sysUserDao.update(entity);
}
}
@Override
public void remove(Integer id) {
sysUserDao.delete(id);
}
@Override
public void removeBatch(Integer[] ids) {
sysUserDao.deleteBatch(ids);
}
@Override
public List<SysUser> find(SysUser entity) {
return sysUserDao.select(entity);
}
@Override
public Map<String, Object> findPage(Integer pageNum, Integer pageSize, SysUser entity) {
//分页业务实现
PageHelper.startPage(pageNum, pageSize);
List<SysUser> list = sysUserDao.select(entity);
PageInfo<SysUser> pageInfo = new PageInfo<>(list);
/*
* 把前台需要的数据反馈
* 1、当前页面数据（数据列表）
* 2、此次查询的总记录数
*/
Map<String, Object> pageMap = new HashMap<>();
pageMap.put(CommonConstant.PAGE_LIST, list);
pageMap.put(CommonConstant.PAGE_TOTAL, pageInfo.getTotal());
return pageMap;
}
@Override
public SysUser findById(Integer id) {
return sysUserDao.selectById(id);
}
}
3.4 控制层
package com.newcapec.controller;
import com.newcapec.constant.CommonConstant;
import com.newcapec.constant.SystemCode;
import com.newcapec.entity.SysUser;
import com.newcapec.service.SysUserService;
import com.newcapec.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/user")
public class SysUserController {
@Autowired
private SysUserService sysUserService;
/**
* 新增
*/
@PostMapping("/add")
public Result add(@RequestBody SysUser sysUser) {
sysUserService.add(sysUser);
return Result.success();
}
/**
* 编辑
*/
@PutMapping("/edit")
public Result edit(@RequestBody SysUser sysUser) {
sysUserService.edit(sysUser);
return Result.success();
}
/**
* 删除
*/
@DeleteMapping("/remove/{id}")
public Result remove(@PathVariable Integer id) {
sysUserService.remove(id);
return Result.success();
}
/**
* 批量删除
*/
@DeleteMapping("/remove")
public Result removeBatch(Integer[] ids) {
sysUserService.removeBatch(ids);
return Result.success();
}
/**
* 单条查询
*/
@GetMapping("/find/{id}")
public Result findById(@PathVariable Integer id) {
return Result.success(sysUserService.findById(id));
}
/**
* 分页查询
*/
@GetMapping("/find")
public Result findPage(@RequestParam(value = CommonConstant.PAGE_NUM, required = false, defaultValue = CommonConstant.PAGE_NUM_DEFAULT) Integer pageNum,
@RequestParam(value = CommonConstant.PAGE_SIZE, required = false, defaultValue = CommonConstant.PAGE_SIZE_DEFAULT) Integer pageSize,
SysUser sysUser) {
return Result.success(sysUserService.findPage(pageNum, pageSize, sysUser));
}
/**
* 判断用户名是否重复
*/
@GetMapping("/findExists/{username}")
public Result findUsernameExists(@PathVariable String username) {
SysUser sysUser = sysUserService.findByUsername(username);
if (sysUser == null) {
return Result.success();
}
return Result.error(SystemCode.USERNAME_EXISTS.getCode(), SystemCode.USERNAME_EXISTS.getMessage(), null);
}
}
3.5 测试
查询全部都是Get请求，可以直接通过浏览器测试。
但是增、删、改，后台程序员测试可以通过Postman。
批量查询测试：
单条查询测试（路径参数）：
分页查询测试（路径参数拼接）：
新增测试：
修改测试：
单条删除测试：
批量删除测试：
3.6 前台页面
3.6.1 首页
基于Layui经典布局改版。
地址：https://www.layuion.com/doc/element/layout.html#admin
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
后台管理系统
管理员
结构：
welcome.jsp：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
欢迎使用后台管理系统
SystemController.java：
package com.newcapec.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* 用来实现页面跳转的处理器
*/
@Controller
@RequestMapping("/page")
public class SystemController {
@GetMapping("/stu/add")
public String stuAdd() {
return "stu/add";
}
@GetMapping("/welcome")
public String welcome() {
return "welcome";
}
@GetMapping("/sys/user")
public String sysUser() {
return "sys/user";
}
@GetMapping("/sys/role")
public String sysRole() {
return "sys/role";
}
@GetMapping("/sys/permission")
public String sysPermission() {
return "sys/permission";
}
@GetMapping("/emp")
public String emp() {
return "emp/find";
}
@GetMapping("/dept")
public String dept() {
return "dept/find";
}
@GetMapping("/index")
public String index() {
return "index";
}
@GetMapping("/login")
public String login() {
return "login";
}
}
3.6.2 用户管理页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
四、系统角色模块
4.1 实体类
package com.newcapec.entity;
public class SysRole {
private Integer id;
private String roleCode;
private String roleName;
private String description;
private String del;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getRoleCode() {
return roleCode;
}
public void setRoleCode(String roleCode) {
this.roleCode = roleCode;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getDel() {
return del;
}
public void setDel(String del) {
this.del = del;
}
}
4.2 持久层
Dao接口：
package com.newcapec.dao;
import com.newcapec.entity.SysRole;
import com.newcapec.utils.BaseDao;
public interface SysRoleDao extends BaseDao<SysRole> {
}
Mapper文件：
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.newcapec.dao.SysRoleDao">
<insert id="insert" parameterType="com.newcapec.entity.SysRole" useGeneratedKeys="true" keyProperty="id">
insert into t_sys_role(role_code, role_name, description)
values(#{roleCode}, #{roleName}, #{description})
insert>
<update id="update" parameterType="com.newcapec.entity.SysRole">
update t_sys_role
<set>
<if test="roleCode != null">
role_code = #{roleCode},
if>
<if test="roleName != null">
role_name = #{roleName},
if>
<if test="description != null">
description = #{description},
if>
set>
where id = #{id}
update>
<delete id="delete" parameterType="java.lang.Integer">
update t_sys_role set del=1 where id = #{id}
delete>
<delete id="deleteBatch" parameterType="java.lang.Integer">
update t_sys_role set del=1 where id in
<foreach collection="array" open="(" close=")" separator="," item="id">
#{id}
foreach>
delete>
<resultMap id="BaseResultMap" type="com.newcapec.entity.SysRole">
<id column="id" property="id"/>
<result column="role_code" property="roleCode"/>
<result column="role_name" property="roleName"/>
<result column="description" property="description"/>
resultMap>
<select id="select" parameterType="com.newcapec.entity.SysRole" resultMap="BaseResultMap">
select id, role_code, role_name, description from t_sys_role
<where>
<if test="roleCode != null and roleCode != ''">
role_code like concat('%',#{roleCode},'%')
if>
<if test="roleName != null and roleName != ''">
and role_name like concat('%',#{roleName},'%')
if>
and del=0
where>
select>
<select id="selectById" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select id, role_code, role_name, description from t_sys_role
where id = #{id} and del=0
select>
mapper>
4.3 业务层
Service接口：
package com.newcapec.service;
import com.newcapec.entity.SysRole;
import com.newcapec.utils.BaseService;
public interface SysRoleService extends BaseService<SysRole> {
}
Service接口实现类：
package com.newcapec.service.impl;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.newcapec.constant.CommonConstant;
import com.newcapec.dao.SysRoleDao;
import com.newcapec.entity.SysRole;
import com.newcapec.service.SysRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Service
public class SysRoleServiceImpl implements SysRoleService {
@Autowired
private SysRoleDao sysRoleDao;
@Override
public void add(SysRole entity) {
sysRoleDao.insert(entity);
}
@Override
public void edit(SysRole entity) {
sysRoleDao.update(entity);
}
@Override
public void remove(Integer id) {
sysRoleDao.delete(id);
}
@Override
public void removeBatch(Integer[] ids) {
sysRoleDao.deleteBatch(ids);
}
@Override
public List<SysRole> find(SysRole entity) {
return sysRoleDao.select(entity);
}
@Override
public Map<String, Object> findPage(Integer pageNum, Integer pageSize, SysRole entity) {
//分页业务
PageHelper.startPage(pageNum, pageSize);
List<SysRole> list = sysRoleDao.select(entity);
PageInfo<SysRole> pageInfo = new PageInfo<>(list);
//1.当前页面数据（数据列表）2.此次查询的总记录数
Map<String, Object> pageMap = new HashMap<>();
pageMap.put(CommonConstant.PAGE_LIST, list);
pageMap.put(CommonConstant.PAGE_TOTAL, pageInfo.getTotal());
return pageMap;
}
@Override
public SysRole findById(Integer id) {
return sysRoleDao.selectById(id);
}
}
4.4 控制层
package com.newcapec.controller;
import com.newcapec.constant.CommonConstant;
import com.newcapec.entity.SysRole;
import com.newcapec.service.SysRoleService;
import com.newcapec.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/role")
public class SysRoleController {
@Autowired
private SysRoleService sysRoleService;
/**
* 新增
*/
@PostMapping("/add")
public Result add(@RequestBody SysRole sysRole) {
sysRoleService.add(sysRole);
return Result.success();
}
/**
* 编辑
*/
@PutMapping("/edit")
public Result edit(@RequestBody SysRole sysRole) {
sysRoleService.edit(sysRole);
return Result.success();
}
/**
* 删除
*/
@DeleteMapping("/remove/{id}")
public Result remove(@PathVariable Integer id) {
sysRoleService.remove(id);
return Result.success();
}
/**
* 批量删除
*/
@DeleteMapping("/remove")
public Result removeBatch(Integer[] ids) {
sysRoleService.removeBatch(ids);
return Result.success();
}
/**
* 单条查询
*/
@GetMapping("/find/{id}")
public Result findById(@PathVariable Integer id) {
return Result.success(sysRoleService.findById(id));
}
/**
* 分页查询
*/
@GetMapping("/findPage")
public Result findPage(@RequestParam(value = CommonConstant.PAGE_NUM, required = false, defaultValue = CommonConstant.PAGE_NUM_DEFAULT) Integer pageNum,
@RequestParam(value = CommonConstant.PAGE_SIZE, required = false, defaultValue = CommonConstant.PAGE_SIZE_DEFAULT) Integer pageSize,
SysRole sysRole) {
return Result.success(sysRoleService.findPage(pageNum, pageSize, sysRole));
}
/**
* 查询
*/
@GetMapping("/find")
public Result find(SysRole sysRole) {
return Result.success(sysRoleService.find(sysRole));
}
}
4.5 前台页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
五、系统权限模块
5.1 实体类
package com.newcapec.entity;
public class SysPermission {
private Integer id;
private String name;
private String type;
private String url;
private String percode;
private Integer parentId;
private Integer sort;
private String del;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getPercode() {
return percode;
}
public void setPercode(String percode) {
this.percode = percode;
}
public Integer getParentId() {
return parentId;
}
public void setParentId(Integer parentId) {
this.parentId = parentId;
}
public Integer getSort() {
return sort;
}
public void setSort(Integer sort) {
this.sort = sort;
}
public String getDel() {
return del;
}
public void setDel(String del) {
this.del = del;
}
}
5.2 持久层
Dao接口：
package com.newcapec.dao;
import com.newcapec.entity.SysPermission;
import com.newcapec.utils.BaseDao;
public interface SysPermissionDao extends BaseDao<SysPermission> {
}
Mapper文件：
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.newcapec.dao.SysPermissionDao">
<insert id="insert" parameterType="com.newcapec.entity.SysPermission" useGeneratedKeys="true" keyProperty="id">
insert into t_sys_permission(name, type, url, percode, parent_id, sort)
values(#{name}, #{type}, #{url}, #{percode}, #{parentId}, #{sort})
insert>
<update id="update" parameterType="com.newcapec.entity.SysPermission">
update t_sys_permission
<set>
<if test="name != null">
name = #{name},
if>
<if test="type != null">
type = #{type},
if>
<if test="url != null">
url = #{url},
if>
<if test="percode != null">
percode = #{percode},
if>
<if test="parentId != null">
parent_id = #{parentId},
if>
<if test="sort != null">
sort = #{sort},
if>
set>
where id = #{id}
update>
<delete id="delete" parameterType="java.lang.Integer">
update t_sys_permission set del=1 where id = #{id}
delete>
<delete id="deleteBatch" parameterType="java.lang.Integer">
update t_sys_permission set del=1 where id in
<foreach collection="array" open="(" close=")" separator="," item="id">
#{id}
foreach>
delete>
<resultMap id="BaseResultMap" type="com.newcapec.entity.SysPermission">
<id column="id" property="id"/>
<result column="name" property="name"/>
<result column="type" property="type"/>
<result column="url" property="url"/>
<result column="percode" property="percode"/>
<result column="parent_id" property="parentId"/>
<result column="sort" property="sort"/>
resultMap>
<select id="select" parameterType="com.newcapec.entity.SysPermission" resultMap="BaseResultMap">
select id, name, type, url, percode, parent_id, sort from t_sys_permission
<where>
<if test="name != null and name != ''">
name like concat('%',#{name},'%')
if>
<if test="type != null and type != ''">
and type = #{type}
if>
and del=0
where>
select>
<select id="selectById" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select id, name, type, url, percode, parent_id, sort from t_sys_permission
where id = #{id} and del=0
select>
mapper>
5.3 业务层
Service接口：
package com.newcapec.service;
import com.newcapec.entity.SysPermission;
import com.newcapec.utils.BaseService;
public interface SysPermissionService extends BaseService<SysPermission> {
}
Service接口实现类：
package com.newcapec.service.impl;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.newcapec.constant.CommonConstant;
import com.newcapec.dao.SysPermissionDao;
import com.newcapec.entity.SysPermission;
import com.newcapec.service.SysPermissionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Service
public class SysPermissionServiceImpl implements SysPermissionService {
@Autowired
private SysPermissionDao sysPermissionDao;
@Override
public void add(SysPermission entity) {
sysPermissionDao.insert(entity);
}
@Override
public void edit(SysPermission entity) {
sysPermissionDao.update(entity);
}
@Override
public void remove(Integer id) {
sysPermissionDao.delete(id);
}
@Override
public void removeBatch(Integer[] ids) {
sysPermissionDao.deleteBatch(ids);
}
@Override
public List<SysPermission> find(SysPermission entity) {
return sysPermissionDao.select(entity);
}
@Override
public Map<String, Object> findPage(Integer pageNum, Integer pageSize, SysPermission entity) {
//分页业务
PageHelper.startPage(pageNum, pageSize);
List<SysPermission> list = sysPermissionDao.select(entity);
PageInfo<SysPermission> pageInfo = new PageInfo<>(list);
//1.当前页面数据（数据列表）2.此次查询的总记录数
Map<String, Object> pageMap = new HashMap<>();
pageMap.put(CommonConstant.PAGE_LIST, list);
pageMap.put(CommonConstant.PAGE_TOTAL, pageInfo.getTotal());
return pageMap;
}
@Override
public SysPermission findById(Integer id) {
return sysPermissionDao.selectById(id);
}
}
5.4 控制层
package com.newcapec.controller;
import com.newcapec.constant.CommonConstant;
import com.newcapec.entity.SysPermission;
import com.newcapec.service.SysPermissionService;
import com.newcapec.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/permission")
public class SysPermissionController {
@Autowired
private SysPermissionService sysPermissionService;
/**
* 新增
*/
@PostMapping("/add")
public Result add(@RequestBody SysPermission sysPermission) {
sysPermissionService.add(sysPermission);
return Result.success();
}
/**
* 编辑
*/
@PutMapping("/edit")
public Result edit(@RequestBody SysPermission sysPermission) {
sysPermissionService.edit(sysPermission);
return Result.success();
}
/**
* 删除
*/
@DeleteMapping("/remove/{id}")
public Result remove(@PathVariable Integer id) {
sysPermissionService.remove(id);
return Result.success();
}
/**
* 批量删除
*/
@DeleteMapping("/remove")
public Result removeBatch(Integer[] ids) {
sysPermissionService.removeBatch(ids);
return Result.success();
}
/**
* 单条查询
*/
@GetMapping("/find/{id}")
public Result findById(@PathVariable Integer id) {
return Result.success(sysPermissionService.findById(id));
}
/**
* 分页查询
*/
@GetMapping("/findPage")
public Result findPage(@RequestParam(value = CommonConstant.PAGE_NUM, required = false, defaultValue = CommonConstant.PAGE_NUM_DEFAULT) Integer pageNum,
@RequestParam(value = CommonConstant.PAGE_SIZE, required = false, defaultValue = CommonConstant.PAGE_SIZE_DEFAULT) Integer pageSize,
SysPermission sysPermission) {
return Result.success(sysPermissionService.findPage(pageNum, pageSize, sysPermission));
}
/**
* 查询
*/
@GetMapping("/find")
public Result find(SysPermission sysPermission) {
return Result.success(sysPermissionService.find(sysPermission));
}
}
5.5 前台页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
SSM整合_权限管理
一、权限管理系统分析
1.1 概述
权限管理，一般指根据系统设置的安全规则或者安全策略，用户可以访问而且只能访问自己被授权的资源，不多不少。权限管理几乎出现在任何系统里面，只要有用户和密码的系统。 很多人常将“用户身份认证”、“密码加密”、“系统管理”等概念与权限管理概念混淆。
用户身份认证，根本就不属于权限管理范畴。用户身份认证，是要解决这样的问题：用户告诉系统“我是谁”，系统就问用户凭什么证明你就是“谁”呢？对于采用用户名、密码验证的系统，那么就是出示密码。当用户名和密码匹配，则证明当前用户是谁；对于采用指纹等系统，则出示指纹；对于硬件Key等刷卡系统，则需要刷卡。
密码加密，是隶属用户身份认证领域，不属于权限管理范畴。
系统管理，一般是系统的一个模块。而且该模块一般还含有权限管理子模块。因此，很多人误认为权限管理系统只是系统的一个小小的子模块。系统管理里面的权限管理模块，只是一个操作界面，让企业IT管理员能够设置角色等安全策略。系统背后还有很多权限验证逻辑，这些都并不属于该模块。总体来说，该模块相当于给权限管理模块提供了一些数据。
目前主要是通过用户、角色、资源三方面来进行权限的分配。具体来说，就是赋予用户某个角色，角色能访问及操作不同范围的资源。通过建立角色系统，将用户和资源进行分离，来保证权限分配的实施。
一般指根据系统设置的安全规则或者安全策略，用户可以访问而且只能访问自己被授权的资源。
1.2 场景举例
企业IT管理员一般都能为系统定义角色，给用户分配角色。这就是最常见的基于角色访问控制。场景举例：
1、给张三赋予“人力资源经理”角色，“人力资源经理”具有“查询员工”、“添加员工”、“修改员工”和“删除员工”权限。此时张三能够进入系统，则可以进行这些操作。
2、去掉李四的“人力资源经理”角色，此时李四就不能够进入系统进行这些操作了。
以上举例，局限于功能访问权限。还有一些更加丰富、更加细腻的权限管理。比如：
1、因为张三是北京分公司的“人力资源经理”，所以他能够也只能够管理北京分公司员工和北京分公司下属的子公司（海淀子公司、朝阳子公司、西城子公司、东城子公司等）的员工。
2、因为王五是海淀子公司的“人力资源经理”，所以他能够也只能够管理海淀子公司的员工。
3、普通审查员审查财务数据的权限是：在零售行业审核最高限额是￥50万，在钢铁行业最高限额是￥1000万；高级审查员不受该限额限制。
4、ATM取款每次取款额不能超过￥5000元，每天取款总额不能超过￥20000元。
这些权限管理和数据（可以统称为资源）直接相关，又称为数据级权限管理、细粒度权限管理或者内容权限管理。
1.3 分类
从控制力度来看，可以将权限管理分为两大类：
- 功能级权限管理；
- 数据级权限管理。
从控制方向来看，也可以将权限管理分为两大类：
- 从系统获取数据，比如查询订单、查询客户资料；
- 向系统提交数据，比如删除订单、修改客户资料。
二、权限管理案例
2.1 权限涉及到5张表
用户表，角色表，权限表，用户角色关系表，角色权限关联表。
当用户登录时，根据用户名和密码去用户表中验证信息是否合法，如果合法就获取用户信息，然后根据用户的id去用户角色关系表中去得到相关联的角色id集合，再根据角色id再去角色权限关系表中获取该角色所拥有的权限id集合，然后再根基权限id集合到权限表中获取具体的菜单，展现给当前的登录用户，从而达到不用用户看到不用的菜单权限。
表功能介绍
- 用户表: 记录用户的基本信息。
-- ----------------------------
-- 用户表
-- ----------------------------
DROP TABLE IF EXISTS `t_sys_user`;
CREATE TABLE `t_sys_user` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
`username` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '登录账号',
`mobile` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '手机号码',
`nickname` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户昵称',
`email` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户邮箱',
`userpwd` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '密码',
`salt` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT 'newedu' COMMENT '加密盐',
`status` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '1' COMMENT '状态：1可用2不可用',
`del` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '0' COMMENT '是否删除：0正常1删除',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '用户信息表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- 用户表数据
-- ----------------------------
INSERT INTO `t_sys_user` VALUES (1, 'admin', '13612345678', '管理员', '[email protected]', '8f32e9f68d6886d095b230b93e7a2c86', 'newedu', '1', '0');
INSERT INTO `t_sys_user` VALUES (2, 'tom', '12345678901', '汤姆', '[email protected]', '8f32e9f68d6886d095b230b93e7a2c86', 'newedu', '1', '0');
- 角色表: 记录角色的基本信息。
-- ----------------------------
-- 角色表
-- ----------------------------
DROP TABLE IF EXISTS `t_sys_role`;
CREATE TABLE `t_sys_role` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id',
`role_code` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '角色编码',
`role_name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '角色名称',
`description` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '描述',
`del` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '0' COMMENT '是否删除：0正常1删除',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '角色信息表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- 角色表数据
-- ----------------------------
INSERT INTO `t_sys_role` VALUES (1, 'admin', '管理员', '管理员', '0');
INSERT INTO `t_sys_role` VALUES (2, 'user', '普通用户', '普通用户', '0');
INSERT INTO `t_sys_role` VALUES (3, 'other', '其他', '其他', '0');
- 权限表: 记录权限的基本信息。
-- ----------------------------
-- 权限表
-- ----------------------------
DROP TABLE IF EXISTS `t_sys_permission`;
CREATE TABLE `t_sys_permission` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id',
`name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '权限名称',
`type` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限类型：1目录 2菜单 3按钮',
`url` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '#' COMMENT '访问地址',
`percode` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限代码',
`parent_id` int(11) NULL DEFAULT 0 COMMENT '父节点ID',
`sort` int(11) NULL DEFAULT NULL COMMENT '显示顺序',
`del` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '0' COMMENT '是否删除：0正常1删除',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 14 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '权限信息表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- 权限表数据
-- ----------------------------
INSERT INTO `t_sys_permission` VALUES (1, '系统管理', '1', '', 'system', 0, 1, '0');
INSERT INTO `t_sys_permission` VALUES (2, '用户列表', '2', '', 'user', 1, 11, '0');
INSERT INTO `t_sys_permission` VALUES (3, '用户查询', '3', '', 'user:query', 2, 111, '0');
INSERT INTO `t_sys_permission` VALUES (4, '用户新增', '3', '', 'user:add', 2, 112, '0');
INSERT INTO `t_sys_permission` VALUES (5, '用户编辑', '3', '', 'user:edit', 2, 113, '0');
INSERT INTO `t_sys_permission` VALUES (6, '用户删除', '3', '', 'user:remove', 2, 114, '0');
INSERT INTO `t_sys_permission` VALUES (7, '角色列表', '2', '', 'role', 1, 12, '0');
INSERT INTO `t_sys_permission` VALUES (8, '角色查询', '3', '', 'role:query', 7, 121, '0');
INSERT INTO `t_sys_permission` VALUES (9, '角色新增', '3', '', 'role:add', 7, 122, '0');
INSERT INTO `t_sys_permission` VALUES (10, '角色编辑', '3', '', 'role:edit', 7, 123, '0');
INSERT INTO `t_sys_permission` VALUES (11, '角色删除', '3', '', 'role:remove', 7, 124, '0');
INSERT INTO `t_sys_permission` VALUES (12, '权限列表', '2', '', 'permission', 1, 13, '0');
INSERT INTO `t_sys_permission` VALUES (13, '权限查询', '3', '', 'permission:query', 12, 131, '0');
INSERT INTO `t_sys_permission` VALUES (14, '权限新增', '3', '', 'permission:add', 12, 132, '0');
INSERT INTO `t_sys_permission` VALUES (15, '权限编辑', '3', '', 'permission:edit', 12, 133, '0');
INSERT INTO `t_sys_permission` VALUES (16, '权限删除', '3', '', 'permission:remove', 12, 134, '0');
- 用户角色中间表: 记录用户所拥有的角色。
- 一个用户可以拥有多个角色，一对多关系。
- 一个角色可以包含在多个用户，一对多关系。
- 如果两张表是双向一对多关系，那么他们是多对多关系，并且必然存在一张关系描述表作为中间表。
-- ----------------------------
-- 用户角色中间表
-- ----------------------------
DROP TABLE IF EXISTS `t_sys_user_role`;
CREATE TABLE `t_sys_user_role` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
`user_id` int(11) NOT NULL COMMENT '用户ID',
`role_id` int(11) NOT NULL COMMENT '角色ID',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '用户和角色关联表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- 用户角色中间表数据
-- ----------------------------
INSERT INTO `t_sys_user_role` VALUES (1, 1, 1);
INSERT INTO `t_sys_user_role` VALUES (2, 1, 2);
INSERT INTO `t_sys_user_role` VALUES (3, 2, 2);
- 角色权限中间表：记录角色所拥有的权限。
- 一个角色可以多个权限，一对多关系。
- 一个权限可以包含在多个角色，一对多关系。
-- ----------------------------
-- 角色权限中间表
-- ----------------------------
DROP TABLE IF EXISTS `t_sys_role_permission`;
CREATE TABLE `t_sys_role_permission` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
`role_id` int(11) NOT NULL COMMENT '角色ID',
`permission_id` int(11) NOT NULL COMMENT '权限ID',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 18 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '角色和权限关联表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- 角色权限中间表数据
-- ----------------------------
INSERT INTO `t_sys_role_permission` VALUES (1, 1, 1);
INSERT INTO `t_sys_role_permission` VALUES (2, 1, 2);
INSERT INTO `t_sys_role_permission` VALUES (3, 1, 3);
INSERT INTO `t_sys_role_permission` VALUES (4, 1, 4);
INSERT INTO `t_sys_role_permission` VALUES (5, 1, 5);
INSERT INTO `t_sys_role_permission` VALUES (6, 1, 6);
INSERT INTO `t_sys_role_permission` VALUES (7, 1, 7);
INSERT INTO `t_sys_role_permission` VALUES (8, 1, 8);
INSERT INTO `t_sys_role_permission` VALUES (9, 1, 9);
INSERT INTO `t_sys_role_permission` VALUES (10, 1, 10);
INSERT INTO `t_sys_role_permission` VALUES (11, 1, 11);
INSERT INTO `t_sys_role_permission` VALUES (12, 1, 12);
INSERT INTO `t_sys_role_permission` VALUES (13, 1, 13);
INSERT INTO `t_sys_role_permission` VALUES (14, 2, 1);
INSERT INTO `t_sys_role_permission` VALUES (15, 2, 2);
INSERT INTO `t_sys_role_permission` VALUES (16, 2, 6);
INSERT INTO `t_sys_role_permission` VALUES (17, 2, 10);
2.2 权限数据中父节点名称展示
将权限表的父节点展示修改名称，能展示当前权限数据的父权限的名称。
实现思路：
1、在权限实体中，添加一个关联属性，属性类型SysPermission，并提供getter和setter方法。
注：仅仅展示父权限名称的话，定义String类型也行。
2、修改SysPermissionMapper.xml的查询SQL，并通过resultMap映射。
3、修改role.jsp页面数据表格的显示内容。
SysPermission.java：
package com.newcapec.entity;
public class SysPermission {
//其他略
/*
* 关联属性
*/
private SysPermission parent;
public SysPermission getParent() {
return parent;
}
public void setParent(SysPermission parent) {
this.parent = parent;
}
}
SysPermissionMapper.xml：
<resultMap id="selectResultMap" type="com.newcapec.entity.SysPermission" extends="BaseResultMap">
<association property="parent" javaType="com.newcapec.entity.SysPermission">
<id property="id" column="parent_id"/>
<result property="name" column="parent_name"/>
association>
resultMap>
<select id="select" parameterType="com.newcapec.entity.SysPermission" resultMap="selectResultMap">
select a.id, a.name, a.type, a.url, a.percode, a.parent_id, a.sort, b.name parent_name from t_sys_permission a
left join t_sys_permission b on a.parent_id = b.id
<where>
<if test="name != null and name != ''">
a.name like concat('%',#{name},'%')
if>
<if test="type != null and type != ''">
and a.type = #{type}
if>
and a.del=0
where>
select>
permission.jsp：
{field: 'parent', title: '父节点', align: 'center', templet:function (d){
return d.parent.name ? d.parent.name : '无'
}},
2.3 权限数据新增和编辑时关联查询父节点
在新增，编辑页面添加或修改父节点。
实现思路：
1、修改permission.jsp页面，新增和编辑表单中父节点的控件类型，从输入框改为下拉框。
2、在新增和修改操作的时候，加载所有已经存在的节点，这些节点默认作为父节点，动态加载到下拉框中。
3、修改操作，动态加载所有的父节点之后，再去渲染表单。
permission.jsp：
2.4 用户新增和编辑时关联角色
2.4.1 后台实现
用户在新增和编辑时，关联操作用户相关的角色。一个用户可以分配多个角色。
实现思路：
1、在SysUser实体类中添加关联属性，属性类型为List<Integer> roleIdList，记录当前用户相关的角色编号列表，并提供对应的getter和setter方法。
2、在SysUserDao接口中添加两个方法。
void insertUserRole(SysUser entity) 新增用户相关角色信息
void deleteUserRole(Integer id) 根据用户删除相关角色
3、在SysUserMapper.xml中定义对应的sql。
4、修改SysUserServiceImpl中，修改add()、edit()的实现，添加关联角色的相关业务。
新增用户之后，判断当前用户的相关角色编号列表是否为空，如果不为空，表示需要对相关角色信息进行新增操作。
修改用户之后，判断当前用户的角色是否为空，如果不为空，删除相关角色编号；再判断用户相关角色是否是空集合，如果集合中有角色编号，表示需要对角色信息进行新增操作。（简单来说：对于用户角色的修改，先全部删除，再新增）
总结：
用户新增时业务：
1.判断用户名是否重复
2.新增用户
3.判断用户是否有相关角色编号信息，如果有新增关系数据
用户编辑时业务：
1.编辑用户
2.判断用户相关角色是否为空，如果不为null，删除相关角色编号
3.再判断用户相关角色是否为空和空集合，如果集合中有角色编号，新增关系数据
SysUser.java：
/**
* 系统用户实体类: 用于用户表的基础功能CURD操作的实现
*/
public class SysUser {
//其他略
/*
* 关联属性：记录当前用户相关的角色编号列表
*/
private List<Integer> roleIdList;
public List<Integer> getRoleIdList() {
return roleIdList;
}
public void setRoleIdList(List<Integer> roleIdList) {
this.roleIdList = roleIdList;
}
}
SysUserDao接口：
public interface SysUserDao extends BaseDao<SysUser> {
/*
* 根据用户名查询
* 1、注册：用户名查重
* 2、用户登录（精细化提示使用，先判断用户名，再判断密码）
*/
SysUser selectByUsername(String username);
/*
* 新增用户相关角色信息
*/
void insertUserRole(SysUser sysUser);
/*
* 根据用户编号删除相关角色
*/
void deleteUserRole(Integer id);
}
SysUserMapper.xml：
<insert id="insertUserRole" parameterType="com.newcapec.entity.SysUser">
insert into t_sys_user_role(user_id, role_id)
<foreach collection="roleIdList" open=" values" separator="," item="item">
(#{id}, #{item})
foreach>
insert>
<delete id="deleteUserRole" parameterType="java.lang.Integer">
delete from t_sys_user_role where user_id = #{id}
delete>
SysUserServiceImpl.java：
/**
* 用户新增时业务：
* 1.判断用户名是否重复
* 2.新增用户
* 3.判断用户是否有相关角色编号信息，如果有新增关系数据
*/
@Override
public void add(SysUser entity) {
SysUser sysUser = findByUsername(entity.getUsername());
//后台校验，保证安全性，防止第三方工具注册（PostMan）
if (sysUser == null) {
entity.setUserpwd(CommonConstant.PASSWORD_DEFAULT);
sysUserDao.insert(entity);
//判断当前用户的相关角色列表是否为空，如果不为空，需要对相关角色信息进行新增
//CollectionUtils是Spring提供的，用来判断集合是否为空或空集合的方法
if(!CollectionUtils.isEmpty(entity.getRoleIdList())){
sysUserDao.insertUserRole(entity);
}
}
}
/**
* 用户编辑时业务
* 1.编辑用户
* 2.判断用户相关角色是否为空，如果不为null，删除相关角色编号
* 3.再判断用户相关角色是否为空和空集合，如果集合中有角色编号，新增关系数据
*/
@Override
public void edit(SysUser entity) {
SysUser sysUser = findByUsername(entity.getUsername());
if (sysUser != null) {
sysUserDao.update(entity);
//判断当前用户的角色是否为空，如果不为空，删除相关角色编号；
if(entity.getRoleIdList() != null){
sysUserDao.deleteUserRole(entity.getId());
//再判断用户相关角色是否是空集合，如果集合中有角色编号，表示需要对角色信息进行新增操作。
if(!CollectionUtils.isEmpty(entity.getRoleIdList())){
sysUserDao.insertUserRole(entity);
}
}
}
}
2.4.2 前端实现
在前端页面中，新增和修改用户的时候，展示角色复选框。
实现思路：
1、在user.jsp页面的新增和修改弹出框内容中，添加一项角色相关复选框，但是角色数据是动态的，那么复选框是需要动态加载的。
2、在user.jsp中查询所有的角色数据，动态渲染角色数据。
3、如果是修改操作，那么需要在动态渲染完角色数据之后，再去做数据回显。
4、当表单异步提交数据的时候，会把数据转换为json字符串进行提交，那么复选框提交的数据只会保留最后一个值，但是服务器需要的是数组，那么就需要我们手动处理，在提交数据之前，手动获取用户相关角色编号转换为数组进行提交。
5、如果是修改操作，其他数据正常回显，但是用户的角色数据无法回显，因为我们根据id查询用户的时候，没有关联查询角色数据，修改根据id查询用户的sql即可。
6、Layui表单回显的时候，无法把一个数组赋值给表单控件，需要我们手动赋值。
注：layui中的动态表单，必须渲染刷新。
user.jsp：
SysUserMapper.xml：
<resultMap id="BaseResultMap" type="com.newcapec.entity.SysUser">
<id column="id" property="id"/>
<result column="username" property="username"/>
<result column="mobile" property="mobile"/>
<result column="nickname" property="nickname"/>
<result column="email" property="email"/>
<result column="userpwd" property="userpwd"/>
<result column="salt" property="salt"/>
<result column="status" property="status"/>
resultMap>
<resultMap id="SelectByIdResultMap" type="com.newcapec.entity.SysUser" extends="BaseResultMap">
<collection property="roleIdList" ofType="java.lang.Integer">
<constructor>
<arg column="role_id"/>
constructor>
collection>
resultMap>
<select id="selectById" parameterType="java.lang.Integer" resultMap="SelectByIdResultMap">
select a.id, a.username, a.mobile, a.nickname, a.email, a.userpwd, a.salt, a.status, b.role_id from t_sys_user a
left join t_sys_user_role b on a.id = b.user_id
where a.id = #{id} and a.del=0
select>
2.5 角色新增和编辑时关联权限
2.5.1 后台实现
角色在新增和编辑时，关联操作角色相关的权限。一个角色可以分配多个权限。整体实现思路和2.4类似。
实现思路：
1、在SysRole实体类中添加关联属性，属性类型为List<Integer> permissionIdList，记录当前角色相关的权限编号列表，并提供对应的getter和setter方法。
2、在SysRoleDao接口中添加两个方法。
void insertRolePermission(SysRole entity) 新增角色相关权限信息
void deleteRolePermission(Integer id) 根据角色删除相关权限信息
3、在SysRoleMapper.xml中定义对应的sql。
4、修改根据id查询角色的sql，查询角色信息及角色相关的权限编号列表。
5、修改SysRoleServiceImpl中，修改add()、edit()的实现，添加关联权限的相关业务。
新增角色之后，判断当前角色的相关权限编号列表是否为空，如果不为空，表示需要对相关权限信息进行新增操作。
修改角色之后，判断当前角色的权限列表是否为空，如果不为空，删除相关权限编号；再判断角色相关权限是否是空集合，如果集合中有权限编号，表示需要对权限信息进行新增操作。（简单来说：对于角色权限的修改，先全部删除，再新增）
SysRole.java：
public class SysRole {
//其他略
/*
* 关联属性：记录当前角色的相关权限编号列表
*/
private List<Integer> permissionIdList;
public List<Integer> getPermissionIdList() {
return permissionIdList;
}
public void setPermissionIdList(List<Integer> permissionIdList) {
this.permissionIdList = permissionIdList;
}
}
SysRoleDao接口：
public interface SysRoleDao extends BaseDao<SysRole> {
/*
* 新增角色相关权限信息
*/
void insertRolePermission(SysRole sysRole);
/*
* 根根据角色删除相关权限信息
*/
void deleteRolePermission(Integer id);
}
SysRoleMapper.xml：
<resultMap id="selectByIdResultMap" type="com.newcapec.entity.SysRole" extends="BaseResultMap">
<collection property="permissionIdList" ofType="java.lang.Integer">
<constructor>
<arg column="permission_id"/>
constructor>
collection>
resultMap>
<select id="selectById" parameterType="java.lang.Integer" resultMap="selectByIdResultMap">
select a.id, a.role_code, a.role_name, a.description, b.permission_id from t_sys_role a
left join t_sys_role_permission b on a.id = b.role_id
where a.id = #{id} and a.del=0
select>
<insert id="insertRolePermission" parameterType="com.newcapec.entity.SysRole">
insert into t_sys_role_permission(role_id, permission_id)
<foreach collection="permissionIdList" open=" values" separator="," item="item">
(#{id}, #{item})
foreach>
insert>
<delete id="deleteRolePermission" parameterType="java.lang.Integer">
delete from t_sys_role_permission where role_id = #{id}
delete>
SysRoleServiceImpl.java：
@Override
public void add(SysRole entity) {
sysRoleDao.insert(entity);
if(!CollectionUtils.isEmpty(entity.getPermissionIdList())){
sysRoleDao.insertRolePermission(entity);
}
}
@Override
public void edit(SysRole entity) {
sysRoleDao.update(entity);
if(entity.getPermissionIdList() != null){
sysRoleDao.deleteRolePermission(entity.getId());
if(!CollectionUtils.isEmpty(entity.getPermissionIdList())){
sysRoleDao.insertRolePermission(entity);
}
}
}
2.5.2 前端实现
在前端页面中，新增和修改角色的时候，展示权限树形结构。
注意：角色在整个系统中，也就那么几个，用复选框问题不大。但是权限会很多，如果使用复选框，不太合适。
实现思路：
1、在role.jsp页面的新增和修改弹出框内容中，添加权限一项，但是权限数据是动态的。
2、在role.jsp中查询所有的权限列表数据，以树形结构展示（需要加载layui的tree模块）。
3、如果是修改操作，那么需要在动态渲染完权限树形结构数据之后，再去做数据回显。
4、从后台查询得到的数据不符合layui tree的数据结构，那么我们需要对数据进行处理。
4.1 将后台响应数据转换为layui中tree组件需要的数据结构，layui tree组件需要id、title、spread、children等，但是后台响应数据不包含这些数据。
4.2 将列表结构的数据转换为树形结构数据。
5、把解析得到的树形结构数据渲染到指定的元素。
6、提交表单的时候，需要手动添加角色相关权限编号数据（因为树形结构不是表单控件）。
7、修改操作，表单的数据回显不会回显树形结构，只需要调用树形节点的setChecked即可。
注意：因layui的树形组件的原因，只要选了父节点，那么所有的子节点都会默认勾选，那么我们需要数据过滤，只勾选按钮权限。
role.jsp：
2.6 用户登录
2.6.1 后台实现
1、SysUserDao中已经定义了SysUser selectByUsername(String username)方法，那么我们可以从service开始写。
2、在SysUserService接口中定义UserInfo login(String username,String userpwd);
注意：UserInfo实体类是用于存储用户登录信息的，SysUser是用于用户表的基础功能CURD操作的。
3、在SysUserServiceImpl实现类中实现具体登录业务。
1.根据用户提供用户名（用户标识），到数据库中查询相关记录
2.判断查询到的用户是否为null
3.如果为null，表示当前用户提供的用户名有误
4.如果不为null，根据用户提供的密码（用户凭证）比对数据库中存储的密码
5.如果不一致表示用户提供的密码有误
6.如果一致返回UserInfo对象
4、定义LoginController，登录相关的请求都定义在该控制器中。
UserInfo实体类：
package com.newcapec.entity;
import java.util.List;
/**
* 用户登录信息对象
*/
public class UserInfo {
private Integer id;
private String username;
private String mobile;
private String nickname;
private String email;
private String userpwd;
private String salt;
private String status;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getMobile() {
return mobile;
}
public void setMobile(String mobile) {
this.mobile = mobile;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getUserpwd() {
return userpwd;
}
public void setUserpwd(String userpwd) {
this.userpwd = userpwd;
}
public String getSalt() {
return salt;
}
public void setSalt(String salt) {
this.salt = salt;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
}
SysUserService接口：
public interface SysUserService extends BaseService<SysUser> {
SysUser findByUsername(String username);
UserInfo login(String username, String userpwd);
}
SysUserServiceImpl实现类：
/**
* 登录
* 1.根据用户提供用户名（用户标识），到数据库中查询相关记录
* 2.判断查询到的用户是否为null
* 3.如果为null，表示当前用户提供的用户名有误
* 4.如果不为null，根据用户提供的密码（用户凭证）比对数据库中存储的密码
* 5.如果不一致表示用户提供的密码有误
* 6.如果一致返回UserInfo对象
*/
@Override
public UserInfo login(String username, String userpwd) {
SysUser sysUser = sysUserDao.selectByUsername(username);
if(sysUser != null){
if(userpwd.equals(sysUser.getUserpwd())){
UserInfo userInfo = new UserInfo();
//spring中提供了一个工具类BeanUtils，提供属性值复制功能
//copyProperties(源对象, 目标对象)
//要求：属性名称保持一致
BeanUtils.copyProperties(sysUser, userInfo);
return userInfo;
}
}
return null;
}
LoginController.java：
package com.newcapec.controller;
import com.newcapec.constant.SystemCode;
import com.newcapec.entity.UserInfo;
import com.newcapec.service.SysUserService;
import com.newcapec.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpSession;
@RestController
@RequestMapping("/auth")
public class LoginController {
@Autowired
private SysUserService sysUserService;
/**
* 登录接口
* 调用Service中的login方法
* 如果返回值为null，表示用户的用户名或密码错误
* 如果返回值不为null
* 1.将用户信息UserInfo对象存放在HttpSession中
* 2.返回登陆成功的结果（可以将用户信息发送到前端）
*
* 注意：
* 登录通常为了密码的安全，采用post请求
*/
@PostMapping("/login")
public Result login(@RequestBody UserInfo userInfo, HttpSession session) {
UserInfo dbUserInfo = sysUserService.login(userInfo.getUsername(), userInfo.getUserpwd());
if (dbUserInfo != null) {
session.setAttribute("userInfo", dbUserInfo);
return Result.success(dbUserInfo);
}
return Result.error(SystemCode.USERNAME_ERROR.getCode(), SystemCode.USERNAME_ERROR.getMessage(), null);
}
/**
* 登出接口
*/
@GetMapping("/logout")
public Result logout(HttpSession session) {
session.removeAttribute("userInfo");
session.invalidate();
return Result.success();
}
}
2.6.2 前端实现
实现思路：
1、在views目录下创建login.jsp页面，并引入layui相关css和js文件。
2、正常后台管理系统的首页面，应该是登录页面，那么修改web.xml中的配置。
3、通过HTML/CSS编写静态页面效果。
4、发送异步登录请求。
1.如果用户名和密码正确，跳转到首页。
2.如果用户名或密码有误，则弹框提示。
5、登录之后，跳转首页，动态展示登录用户的昵称。
6、在index.jsp页面的退出系统链接绑定事件，当事件触发的时候，询问确定要退出系统吗? 如果点击确定，那么发送异步请求退出登录，退出之后跳转到登录页面。
注：如果前端页面不是jsp、模版引擎等动态页面，而是静态页面，那么我们可以使用sessionStoreage来实现。
login.jsp：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
后台管理系统
index.jsp：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
后台管理系统
2.6.3 身份认证拦截器
实现思路：
1、定义SpringMVC的拦截器LoginInterceptor（实现HandlerInterceptor接口），在拦截器的preHandle方法中进行用户身份认证业务。拦截器所在的包：interceptor。
2、从session域中获取用户登录信息。
1.如果不为null，则放行。
2.如果为null，则拦截。有两种方式：
方式一：页面跳转。通过响应对象重定向到登录页面。但是该方式存在一定的局限性，如果是前后端分离的开发模式，应该是前端控制页面的跳转，而不是后台决定页面的跳转。
方式二：响应json数据，提示未登录。
3、配置拦截器，设置拦截请求和放行请求。
4、在前台页面中，获取异步请求的返回数据，如果不是200，则进行相应的提示。
5、在前台页面中，判断是否登录，如果为登录，跳转到登录页面。
方式一：从session域中获取用户登录信息，如果未登录，则跳转到登录页面。
方式二：从前端缓存中获取用户登录信息，如果没有缓存数据，则跳转到登录页面。
LoginInterceptor.java：
package com.newcapec.interceptor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.newcapec.constant.SystemCode;
import com.newcapec.utils.Result;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
/**
* 用户身份认证（用户登录）拦截器
*/
public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
//获取HttpSession对象
HttpSession session = httpServletRequest.getSession();
//从session域中获取用户登录信息
Object userInfo = session.getAttribute("userInfo");
//判断用户登录信息是否存在
if (userInfo == null) {
//页面跳转
//httpServletResponse.sendRedirect(httpServletRequest.getContextPath() + "/page/login");
//设置响应内容类型
httpServletResponse.setContentType("application/json;charset=utf-8");
//给用户响应json数据，提示未登录
Result result = Result.error(SystemCode.NOT_LOGIN.getCode(), SystemCode.NOT_LOGIN.getMessage(), null);
//手动将自定义响应格式对象转换为json字符串: jackson
ObjectMapper objectMapper = new ObjectMapper();
String resultStr = objectMapper.writeValueAsString(result);
httpServletResponse.getWriter().write(resultStr);
return false;
}
return true;
}
@Override
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
}
@Override
public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
}
}
springmvc.xml：
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<mvc:exclude-mapping path="/page/**"/>
<mvc:exclude-mapping path="/static/**"/>
<mvc:exclude-mapping path="/auth/login"/>
<bean class="com.newcapec.interceptor.LoginInterceptor"/>
mvc:interceptor>
mvc:interceptors>
index.jsp：
sys相关页面：
//在当前页面中判断用户是否登录
var userInfo = sessionStorage.getItem('userInfo');
if(!userInfo){
location.href = 'page/login';
}
2.6.4 动态菜单的实现
实现思路：
1、权限列表数据和后台菜单数据保持一致，在权限中插入业务管理目录、学生列表/员工列表/部门列表菜单、每个列表下都有一个查询按钮权限。
2、配置测试数据。
配置角色权限数据：admin角色拥有所有的权限、user角色拥有所有的业务管理和用户查询权限。
配置用户角色数据：admin用户拥有管理员、普通用户角色、汤姆拥有普通用户角色。
3、完善员工菜单和部门菜单对应的页面，以及配置页面跳转路径。
在views下面创建emp/find.jsp、dept/find.jsp，页面内容无所谓。
在SystemController配置页面跳转路径。
4、配置权限的访问路径。
5、根据用户id查询所拥有的权限，那么涉及到权限表、角色权限中间表、用户角色中间表三表联查。
1.在SysPermissionDao中定义List<SysPermission> selectByUserId(@Param("userId") Integer userId, @Param("type") String type)方法，该方法是根据用户ID查询当前用户所拥有的权限列表。
如果传递的type为3，则要过滤按钮类型权限，动态菜单使用。
如果传递的type为null，则查询所有的权限类型。权限鉴定使用。
2.在SysPermissionMapper.xml里面定义对应的sql。
3.在SysPermissionService中定义List<SysPermission> findMenu(Integer userId)方法。
4.在SysPermissionServiceImpl中实现具体业务。
5.在SysPermissionController中定义请求映射，从session域中获取当前登录的用户，获取对应的权限菜单。
6、在index.jsp页面发送异步请求，获取当前登录用户的权限，动态生成菜单。
SystemController.java：
/**
* 用来实现页面跳转的处理器
*/
@Controller
@RequestMapping("/page")
public class SystemController {
@GetMapping("/stu/add")
public String stuAdd() {
return "stu/add";
}
@GetMapping("/welcome")
public String welcome() {
return "welcome";
}
@GetMapping("/sys/user")
public String sysUser() {
return "sys/user";
}
@GetMapping("/sys/role")
public String sysRole() {
return "sys/role";
}
@GetMapping("/sys/permission")
public String sysPermission() {
return "sys/permission";
}
@GetMapping("/emp")
public String emp() {
return "emp/find";
}
@GetMapping("/dept")
public String dept() {
return "dept/find";
}
@GetMapping("/index")
public String index() {
return "index";
}
@GetMapping("/login")
public String login() {
return "login";
}
}
index.jsp：
业务管理
权限的访问路径：
SysPermissionDao.java：
public interface SysPermissionDao extends BaseDao<SysPermission> {
/**
* 根据用户ID查询当前用户所拥有权限列表
* 参数userId,要查询的用户id
* 参数type，菜单的类型。
* 如果传递的type为3，则要过滤按钮类型权限，动态菜单使用
* 如果传递的type为null，则查询所有的权限类型。权限鉴定使用
*/
List<SysPermission> selectByUserId(@Param("userId") Integer userId, @Param("type") String type);
}
SysPermissionMapper.xml：
<select id="selectByUserId" parameterType="java.util.HashMap" resultMap="BaseResultMap">
select distinct a.id, a.name, a.type, a.url, a.percode, a.parent_id, a.sort from t_sys_permission a
join t_sys_role_permission b on a.id = b.permission_id
join t_sys_user_role c on b.role_id = c.role_id
<where>
c.user_id = #{userId} and a.del = 0
<if test="type != null">
and a.type != 3
if>
where>
order by a.sort
select>
SysPermissionService.java：
public interface SysPermissionService extends BaseService<SysPermission> {
List<SysPermission> findMenu(Integer userId);
}
SysPermissionServiceImpl.java：
@Override
public List<SysPermission> findMenu(Integer userId) {
return sysPermissionDao.selectByUserId(userId, "3");
}
SysPermissionController.java：
/**
* 查询当前登录用户的菜单
*/
@GetMapping("/findMenu")
public Result findMenu(HttpSession session){
//从session域中获取当前登录用户
UserInfo userInfo = (UserInfo) session.getAttribute("userInfo");
List<SysPermission> menus = sysPermissionService.findMenu(userInfo.getId());
return Result.success(menus);
}
index.jsp：
2.7 权限鉴定
动态菜单的实现，仅仅实现了用户登录后所展示的菜单，拥有权限的菜单展示出来，没有权限的菜单不展示。但是如果登录之后，知道其他页面的url，还是可以操作其他的非权限菜单。
比如tom用户，没有操作角色和权限的权限，但是完全可以在地址栏输入地址访问。
http://localhost:8080/ssm/page/sys/permission
http://localhost:8080/ssm/page/sys/role
实现思路：
1.在SysPermissionService中定义List<SysPermission> findByUserId(Integer userId)方法，用来查询用户所有的权限列表。
2.在SysPermissionServiceImpl中实现具体业务。
3.在SysUserServiceImpl的login方法中，当用户登录成功之后，查询当前用户所拥有的全部权限，并赋值给userInfo对象。
4.定义PermissionInterceptor权限鉴定拦截器，判断某次请求，当前用户是否有权限访问。
5.配置拦截器。
注意：一定要配置在登录拦截器之后。
SysPermissionService.java：
public interface SysPermissionService extends BaseService<SysPermission> {
List<SysPermission> findMenu(Integer userId);
List<SysPermission> findByUserId(Integer userId);
}
SysPermissionServiceImpl.java：
@Override
public List<SysPermission> findByUserId(Integer userId) {
return sysPermissionDao.selectByUserId(userId, null);
}
SysUserServiceImpl.java：
@Autowired
private SysPermissionService sysPermissionService;
@Override
public UserInfo login(String username, String userpwd) {
SysUser sysUser = sysUserDao.selectByUsername(username);
if(sysUser != null){
if(userpwd.equals(sysUser.getUserpwd())){
UserInfo userInfo = new UserInfo();
//spring中提供了一个工具类BeanUtils，提供属性值复制功能
//copyProperties(源对象, 目标对象)
//要求：属性名称保持一致
BeanUtils.copyProperties(sysUser, userInfo);
//查询当前用户所拥有的全部权限
List<SysPermission> permissionList = sysPermissionService.findByUserId(userInfo.getId());
userInfo.setPermissionList(permissionList);
return userInfo;
}
}
return null;
}
PermissionInterceptor.java：
package com.newcapec.interceptor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.newcapec.constant.SystemCode;
import com.newcapec.entity.SysPermission;
import com.newcapec.entity.UserInfo;
import com.newcapec.utils.Result;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.List;
/**
* 用户权限鉴定拦截器：判断某次请求，当前用户是否有权限访问
* 通过路径url拦截来鉴定权限
*/
public class PermissionInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
HttpSession session = httpServletRequest.getSession();
Object obj = session.getAttribute("userInfo");
//判断用户登录信息是否存在
if (obj instanceof UserInfo) {
UserInfo userInfo = (UserInfo) obj;
//获取当前登录用户的权限列表
List<SysPermission> permissionList = userInfo.getPermissionList();
//获取当前请求路径
String url = httpServletRequest.getServletPath();
System.out.println("此次请求的路径:" + url);
//在当前登录用户的权限列表中查询与当前请求路径匹配的数据
//如果查询到表示用户有权限访问
//如果没有查询到表示用户没有权限访问
for (SysPermission sysPermission : permissionList) {
System.out.println("权限路径:" + sysPermission.getUrl());
if (url.contains(sysPermission.getUrl()) && !sysPermission.getUrl().equals("")) {
return true;
}
}
httpServletResponse.setContentType("application/json;charset=utf-8");
//给用户响应json数据，提示未登录
Result result = Result.error(SystemCode.NO_PERMISSION.getCode(), SystemCode.NO_PERMISSION.getMessage(), null);
//手动将自定义响应格式对象转换为json字符串: jackson
ObjectMapper objectMapper = new ObjectMapper();
String resultStr = objectMapper.writeValueAsString(result);
httpServletResponse.getWriter().write(resultStr);
}
return false;
}
@Override
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
}
@Override
public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
}
}
springmvc.xml：
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<mvc:exclude-mapping path="/page/**"/>
<mvc:exclude-mapping path="/static/**"/>
<mvc:exclude-mapping path="/auth/login"/>
<bean class="com.newcapec.interceptor.LoginInterceptor"/>
mvc:interceptor>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<mvc:exclude-mapping path="/page/login"/>
<mvc:exclude-mapping path="/page/index"/>
<mvc:exclude-mapping path="/page/welcome"/>
<mvc:exclude-mapping path="/static/**"/>
<mvc:exclude-mapping path="/auth/**"/>
<mvc:exclude-mapping path="/permission/findMenu"/>
<bean class="com.newcapec.interceptor.PermissionInterceptor"/>
mvc:interceptor>
mvc:interceptors>