权限管理、旅游系统后篇

SSM权限操作

1.数据库与表结构

1.1 用户表

1.1.1 用户表信息描述users

序号	字段名称	字段类型	字段描述
1	id	varchar2	无意义，主键uuid
2	email	varchar2	非空，唯一
3	username	varchar2	用户名
5	password	varchar2	密码（加密）
6	phoneNum	varchar2	电话
7	status	int	状态0 未开启 1 开启

1.1.2 sql语句

CREATE TABLE users(
	id varchar2(32) default SYS_GUID() PRIMARY KEY, 
    email VARCHAR2(50) UNIQUE NOT NULL,
    username VARCHAR2(50), 
    PASSWORD VARCHAR2(50), 
    phoneNum VARCHAR2(20), 
    STATUS INT
)

1.1.3 实体类

/**
 * @outhor Mr.JK
 * @create 2020-05-02  15:32
 * 与数据库中的users对应
 */
public class UserInfo {
    private String id;
    private String username;
    private String email;
    private String password;
    private String phoneNum;
    private int status;
    private String statusStr;
    private List<Role> roles;
}

1.2 角色表

1.2.1 角色表信息描述role

序号	字段名称	字段类型	字段描述
1	id	varchar2	无意义，主键uuid
2	roleName	varchar2	角色名
3	roleDesc	varchar2	角色描述

1.2.2 sql语句

CREATE TABLE role(
	id varchar2(32) default SYS_GUID() PRIMARY KEY, 
    roleName VARCHAR2(50) ,
	roleDesc VARCHAR2(50)
)

1.2.3 实体类

public class Role {
	private String id; 
    private String roleName; 
    private String roleDesc;
	private List<Permission> permissions; 
    private List<User> users;
}

1.2.4 用户与角色关联关系

用户与角色之间是多对多关系，我们通过user_role表来描述其关联，在实体类中User中存在List，在Role中有List.而角色与权限之间也存在关系，我们会在后面介绍。

CREATE TABLE users_role( 
    userId varchar2(32), 
    roleId varchar2(32),
	PRIMARY KEY(userId,roleId),
	FOREIGN KEY (userId) REFERENCES users(id), 
    FOREIGN KEY (roleId) REFERENCES role(id)
)

1.3 资源权限表

1.3.1 权限资源表描述permission

序号	字段名称	字段类型	字段描述
1	id	varchar2	无意义，主键uuid
2	permissionName	varchar2	权限名
3	url	varchar2	资源路径

1.3.2 sql语句

CREATE TABLE permission(
	id varchar2(32) default SYS_GUID() PRIMARY KEY, 
    permissionName VARCHAR2(50) ,
	url VARCHAR2(50)
)

1.3.3 实体类

public class Permission {
    private String id;
    private String permissionName; private String url;
    private List<Role> roles;
}

1.3.4.权限资源与角色关联关系

权限资源与角色是多对多关系，我们使用role_permission表来描述。在实体类Permission中存在List,在Role类中有List

CREATE TABLE role_permission( 
    permissionId varchar2(32), 
    roleId varchar2(32),
	PRIMARY KEY(permissionId,roleId),
	FOREIGN KEY (permissionId) REFERENCES permission(id), 
    FOREIGN KEY (roleId) REFERENCES role(id)
)

2.用户管理

2.1 用户登录

spring security的配置

<security:authentication-manager>
    <security:authentication-provider user-service-ref="userService">
        <!-- 配置加密的方式

        <security:password-encoder ref="passwordEncoder"/> -->
    </security:authentication-provider>
</security:authentication-manager>

2.1.1.登录页面login.jsp

详细页面请查看资料

2.1.2.Service

public interface IUserService extends UserDetailsService{

}

@Service("userService")
@Transactional
public class UserServiceImpl implements IUserService {

    @Autowired
    private IUserDao userDao;
    
    @Autowired
    private BCryptPasswordEncoder bCryptPasswordEncoder;

    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        UserInfo userInfo = null;
        try {
            userInfo = userDao.findByUsername(username);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //处理自己的用户对象封装成UserDetails
        User user = new User(userInfo.getUsername(),userInfo.getPassword(),userInfo.getStatus()== 0?false:true,true,true,true, getAuthority(userInfo.getRoles()));
        return user;
    }
    //作用就是返回一个List集合，集合中装入的是角色描述
    public List<SimpleGrantedAuthority> getAuthority(List<Role> roles){
        List<SimpleGrantedAuthority> list = new ArrayList<SimpleGrantedAuthority>();
        for (Role role : roles){
            list.add(new SimpleGrantedAuthority("ROLE_" + role.getRoleName()));
        }

        return list;
    }
}

2.1.3.IUserDao

/**
 * @outhor Mr.JK
 * @create 2020-05-02  15:32
 */
public interface IUserDao {

    @Select("select * from users where username=#{username}")
    @Results({
            @Result(id = true,property = "id",column = "id"),
            @Result(property = "username",column = "username"),
            @Result(property = "email",column = "email"),
            @Result(property = "password",column = "password"),
            @Result(property = "phoneNum",column = "phoneNum"),
            @Result(property = "status",column = "status"),
            @Result(property = "roles",column = "id",javaType = java.util.List.class,many = @Many(select = "com.jk.ssm.dao.IRoleDao.findRoleByUserId"))
    })
    UserInfo findByUsername(String username) throws Exception;
}

2.2 用户退出

使用spring security完成用户退出，非常简单

配置

<security:logout invalidate-session="true" logout-url="/logout.do" logout-success- url="/login.jsp" />

页面中

<a href="${pageContext.request.contextPath}/logout.do"
class="btn btn-default btn-flat">注销</a>

2.3 用户查询

2.3.1.用户查询页面 user-list.jsp

请在资料中查看具体代码

2.3.2.UserController

@Controller @RequestMapping("/user") 
public class UserControlller {

    @RequestMapping("/findAll.do")
    public ModelAndView findAll() throws Exception { 
        List<UserInfo> users = userService.findAll(); 
        ModelAndView mv = new ModelAndView(); 
        mv.addObject("userlist", users); 
        mv.setViewName("user-list");
    	return mv;
    }
}

2.3.3.Dao

@Select("select * from user") 
public List<UserInfo> findAll();

2.4 用户添加

2.4.1.用户添加页面 user-add.jsp

请在资料中查看具体页面码

2.4.2.UserController

@Controller @RequestMapping("/user") 
public class UserControlller {
    @Autowired
    private IUserService userService;

    @RequestMapping("/save.do")
    public String save(UserInfo user) throws Exception {
        userService.save(user);
        return "redirect:findAll.do";
    }
}

2.4.3.Service

@Service("userService")
@Transactional
public class UserServiceImpl implements IUserService {

    @Autowired
    private IUserDao userDao;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public void save(UserInfo user) throws Exception { user.setPassword(passwordEncoder.encode(user.getPassword())); userDao.save(user);
    }
}

前期我们的用户密码没有加密，现在添加用户时，我们需要对用户密码进行加密

<!-- 配置加密类 -->

<bean id="passwordEncoder"
class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder"/>

2.4.4.Dao

@Insert("insert into user(email,username,password,phoneNum,status) value(#{email},#
{username},#{password},#{phoneNum},#{status})")
public void save(UserInfo user) throws Exception;

2.5 用户详情

3.5.1.用户详情页面user-show.jsp

请在资料中查看页面详细代码

注意：需要添加js

$("#collapse-table").treetable({ 
    expandable : true
});

3.5.2.UserController

@Controller @RequestMapping("/user") 
public class UserControlller {

    @Autowired
    private IUserService userService; @RequestMapping("/findById.do")
    public ModelAndView findById(@RequestParam(name = "id", required = true) Long id) throws
    Exception {
    	UserInfo user = userService.findById(id); 
        ModelAndView mv = new ModelAndView(); 
        mv.addObject("user", user); 
        mv.setViewName("user-show");
    	return mv;
    }
}

3.5.3.Dao

@Select("select * from user where id=#{id}")
@Results({ @Result(id = true, property = "id", column = "id"), @Result(column = "username", property = "username"),
@Result(column = "email", property = "email"), @Result(column =
"password", property = "password"),
@Result(column = "phoneNum", property = "phoneNum"), @Result(column =
"status", property = "status"),
@Result(column = "id", property = "roles", javaType = List.class, many =
@Many(select = "com.itheima.ssm.dao.IRoleDao.findRoleByUserId")) })
public UserInfo findById(Long id) throws Exception;

@Select("select * from role where id in( select roleId from user_role where userId=#{userId})")
@Results(
{
@Result(id=true,column="id",property="id"), @Result(column="roleName",property="roleName"), @Result(column="roleDesc",property="roleDesc"),

@Result(column="id",property="permissions",javaType=List.class,many=@Many(select="com.itheima.ssm
.dao.IPermissionDao.findByRoleId"))
})
public List<Role> findRoleByUserId(Long userId);

我们需要将用户的所有角色及权限查询出来所以需要调用IRoleDao中的findRoleByUserId,而在IRoleDao中需要调用IPermissionDao的findByRoleId

@Select("select * from permission where id in (select permissionId from role_permission where
roleId=#{roleId})")
public List<Permission> findByRoleId(Long roleId);

3.角色管理

3.1 角色查询

3.1.1.角色页面role-list.jsp

请在资料中查看页面详细代码

3.1.2.RoleControlller

@RequestMapping("/role")
@Controller
public class RoleController {

    @Autowired
    private IRoleService roleService;

    @RequestMapping("/findAll.do")
    public ModelAndView findAll() throws Exception { 
        List<Role> roleList = roleService.findAll(); 
        ModelAndView mv = new ModelAndView(); 
        mv.addObject("roleList", roleList); 
        mv.setViewName("role-list");
   	 	return mv;
    }
}

3.1.3.Dao

@Select("select * from role") 
public List<Role> findAll();

3.2 角色添加

3.2.1.角色添加页面role-add.jsp

请在页面中查看详细代码

3.2.2.RoleControlller

@RequestMapping("/role")
@Controller
public class RoleController {

    @Autowired
    private IRoleService roleService;

    @RequestMapping("/save.do")
    public String save(Role role) {
    roleService.save(role);

    return "redirect:findAll.do";
    }
}

3.2.3.Dao

@Insert("insert into role(roleName,roleDesc) value(#{roleName},#{roleDesc})")
public void save(Role role);

4.资源权限管理

4.1 资源权限查询

4.1.1.权限资源页面permission-list.jsp

请在资料中查看详细代码

4.1.2.PermissionController

@RequestMapping("/permission")
@Controller
public class PermissionController {
    @Autowired
    private IPermissionService permissionService;

    @RequestMapping("/findAll.do")
    public ModelAndView findAll() throws Exception {
    	List<Permission> permissionList = permissionService.findAll(); 
        ModelAndView mv = new ModelAndView(); 
        mv.addObject("permissionList", permissionList); 
        mv.setViewName("permission-list");
    	return mv;
    }
 
}

4.1.3.Dao

@Select("select * from permission") 
public List<Permission> findAll();

4.2 资源权限添加

4.2.1.权限资源添加页面permission-add.jsp

请在资料中查看页面详细代码

4.2.2.PermissionController

@RequestMapping("/permission")
@Controller
public class PermissionController {

    @Autowired
    private IPermissionService permissionService;

    @RequestMapping("/save.do")
    public String save(Permission p) throws Exception {
    permissionService.save(p);
    return "redirect:findAll.do";
    }
}

4.2.3.Dao

@Insert("insert into permission(permissionName,url) value(#{permissionName},#{url})") 
public void save(Permission p);

5.权限关联与控制

5.1 用户角色关联

用户与角色之间是多对多关系，我们要建立它们之间的关系，只需要在中间表user_role插入数据即可。

5.1.1. 用户角色关联相关页面

在user-list.jsp页面上添加链接

<a href="${pageContext.request.contextPath}/user/findUserByIdAndAllRole.do?id=${user.id}" class="btn bg-olive btn-xs">添加角色</a>

展示可以添加角色的页面user-roe-add.jsp

请在资料中查看页面详细代码

5.1.2.UserController

findUserByIdAndAllRole(Long id)方法

此方法用于查找要操作的用户及可以添加的角色，参数是要操作的用户id

@RequestMapping("/findUserByIdAndAllRole.do")
public ModelAndView findUserByIdAndAllRole(Long id) throws Exception {
	UserInfo user = userService.findById(id);
	List<Role> roleList = roleService.findOtherRole(id); 
    ModelAndView mv = new ModelAndView(); 
    mv.addObject("user", user);
	mv.addObject("roleList", roleList); 
    mv.setViewName("user-role-add"); 
    return mv;
}

调用IUserService的findById方法获取要操作的User

调用IRoleService的findOtherRole方法用于获取可以添加的角色信息

addRoleToUser(Long userId,Long[] ids)方法

些方法用于在用户与角色之间建立关系，参数userId代表要操作的用户id,参数ids代表的是角色id数组

@RequestMapping("/addRoleToUser.do")
public String addRoleToUser(Long userId, Long[] ids) throws Exception {
    userService.addRoleToUser(userId,ids);
    return "redirect:findAll.do";
}

5.1.3.Dao

IRoleDao

@Select("select * from role where id not in( select roleId from user_role where userId=# {id})")
public List<Role> findOtherRole(Long id);

用于查找可以添加的角色

IUserDao

@Insert("insert into user_role(userId,roleId) value(#{userId},#{roleId})")
public void addRoleToUser(@Param("userId") Long userId, @Param("roleId") Long roleId);

用于添加用户与角色关系

5.2 角色权限关联

角色权限之间是多对多关系，我们要建立它们之间的关系，只需要在中间表role_permission插入数据即可。

5.2.1. 角色权限关联相关页面

在role-list.jsp页面上添加链接

a href="${pageContext.request.contextPath}/role/findRoleByIdAndAllPermission.do?
id=${role.id}" class="btn bg-olive btn-xs">添加权限</a>

展示可以添加权限的页面roe-permission-add.jsp

请在资料中查看页面详细代码

5.2.2.RoleController

findRoleByIdAndAllPermission(Long roleId)方法

此方法用于查找要操作的角色及可以添加的权限，参数是要操作的角色id

@RequestMapping("/findRoleByIdAndAllPermission.do")
public ModelAndView findRoleByIdAndAllPermission(@RequestParam(name = "id", required = true) Long roleid) throws Exception {
	ModelAndView mv = new ModelAndView();
	Role role = roleService.findById(roleid); 
    mv.addObject("role", role); 
    List<Permission> permissionList =permissionService.findOtherPermission(roleid); 			mv.addObject("permissionList", permissionList); 
    mv.setViewName("role-permission-add");
	return mv;
}

调用IRoleService的findById方法获取要操作的Role

调用IPermissionService的findOtherPermission方法用于获取可以添加的权限信息

addPermissionToRole(Long roleId,Long[] ids)方法

些方法用于在角色与权限之间建立关系，参数roleId代表要操作的角色id,参数permissionIds代表的是权限id数组

@RequestMapping("/addPermissionToRole.do")
public String addPermissionToRole(@RequestParam(name = "roleId") Long roleId, @RequestParam(name = "ids") Long[] permissionIds) throws Exception { 
    roleService.addPermissionToRole(roleId, permissionIds);
return "redirect:findAll.do";
}

5.2.3.Dao

IPermissionDao

@Select("select * from permission where id not in (select permissionId from role_permission where roleId=#{roleId})")
public List<Permission> findOtherPermission(Long roleid);

用于查找可以添加的权限

IRoleDao

@Insert("insert into role_permission (roleId,permissionId) value (#{roleId},# {permissionId})")
public void addPermissionToRole(@Param("roleId") Long roleId, @Param("permissionId") Long permissionId);

用于绑定角色与权限的关系

5.3 服务器端方法级权限控制

在服务器端我们可以通过Spring security提供的注解对方法来进行权限控制。Spring Security在方法的权限控制上支持三种类型的注解，JSR-250注解、@Secured注解和支持表达式的注解，这三种注解默认都是没有启用的，需要单独通过global-method-security元素的对应属性进行启用

5.3.1.开启注解使用

配置文件

<security:global-method-security jsr250-annotations="enabled"/>

<security:global-method-security secured-annotations="enabled"/> <security:global-method-security pre-post-annotations="disabled"/>

注解开启

@EnableGlobalMethodSecurity ：Spring Security默认是禁用注解的，要想开启注解，需要在继承WebSecurityConfigurerAdapter的类上加@EnableGlobalMethodSecurity注解，并在该类中将AuthenticationManager定义为Bean。

5.3.2.JSR-250注解

@RolesAllowed表示访问对应方法时所应该具有的角色

示例：
@RolesAllowed({"USER", "ADMIN"}) 该方法只要具有"USER", "ADMIN"任意一种权限就可以访问。这里可以省略前缀ROLE_，实际的权限可能是ROLE_ADMIN

@PermitAll表示允许所有的角色进行访问，也就是说不进行权限控制@DenyAll是和PermitAll相反的，表示无论什么角色都不能访问

5.3.3.支持表达式的注解

@PreAuthorize 在方法调用之前,基于表达式的计算结果来限制对方法的访问

示例：

@PreAuthorize("#userId == authentication.principal.userId or hasAuthority(‘ADMIN’)")
void changePassword(@P("userId") long userId ){ }
这里表示在changePassword方法执行之前，判断方法参数userId的值是否等于principal中保存的当前用户的userId，或者当前用户是否具有ROLE_ADMIN权限，两种符合其一，就可以访问该方法。

@PostAuthorize 允许方法调用,但是如果表达式计算结果为false,将抛出一个安全性异常

示例：

@PostAuthorize
User getUser("returnObject.userId == authentication.principal.userId or hasPermission(returnObject, 'ADMIN')");

@PostFilter 允许方法调用,但必须按照表达式来过滤方法的结果

@PreFilter 允许方法调用,但必须在进入方法之前过滤输入值

5.3.4.@Secured注解

@Secured注解标注的方法进行权限控制的支持，其值默认为disabled。

示例：@Secured("IS_AUTHENTICATED_ANONYMOUSLY") public Account readAccount(Long id); @Secured("ROLE_TELLER")

5.4 页面端标签控制权限

在jsp页面中我们可以使用spring security提供的权限标签来进行权限控制

5.4.1.导入

maven导入

<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-taglibs</artifactId>
    <version>version</version>
</dependency>

页面导入

<%@taglib uri="http://www.springframework.org/security/tags" prefix="security"%>

5.4.2.常用标签

在jsp中我们可以使用以下三种标签，其中authentication代表的是当前认证对象，可以获取当前认证对象信息，例如用户名。其它两个标签我们可以用于权限控制

5.4.2.1 authentication

<security:authentication property="" htmlEscape="" scope="" var=""/>

property：只允许指定Authentication所拥有的属性，可以进行属性的级联获取，如“principle.username”，不允许直接通过方法进行调用

htmlEscape：表示是否需要将html进行转义。默认为true。

scope：与var属性一起使用，用于指定存放获取的结果的属性名的作用范围，默认我pageContext。Jsp中拥有的作用范围都进行进行指定

var：用于指定一个属性名，这样当获取到了authentication的相关信息后会将其以var指定的属性名进行存放，默认是存放在pageConext中

5.4.2.2 authorize

authorize是用来判断普通权限的，通过判断用户是否具有对应的权限而控制其所包含内容的显示

<security:authorize access="" method="" url="" var=""></security:authorize>

access： 需要使用表达式来判断权限，当表达式的返回结果为true时表示拥有对应的权限

method：method属性是配合url属性一起使用的，表示用户应当具有指定url指定method访问的权限，method的默认值为GET，可选值为http请求的7种方法

url：url表示如果用户拥有访问指定url的权限即表示可以显示authorize标签包含的内容var：用于指定将权限鉴定的结果存放在pageContext的哪个属性中

5.4.2.3 accesscontrollist

accesscontrollist标签是用于鉴定ACL权限的。其一共定义了三个属性：hasPermission、domainObject和var，其中前两个是必须指定的

<security:accesscontrollist hasPermission="" domainObject="" var=""></security:accesscontrollist>

hasPermission：hasPermission属性用于指定以逗号分隔的权限列表

domainObject：domainObject用于指定对应的域对象

var：var则是用以将鉴定的结果以指定的属性名存入pageContext中，以供同一页面的其它地方使用

SSMAOP日志

1.数据库与表结构

1.1.日志表信息描述sysLog

序号	字段名称	字段类型	字段描述
1	id	VARCHAR2	主键 无意义uuid
2	visitTime	timestamp	访问时间
3	username	VARCHAR2	操作者用户名
4	ip	VARCHAR2	访问ip
5	url	VARCHAR2	访问资源url
6	executionTime	int	执行时长
7	method	VARCHAR	访问方法

1.2.sql语句

CREATE TABLE sysLog(
	id VARCHAR2(32) default SYS_GUID() PRIMARY KEY, 
    visitTime timestamp,
	username VARCHAR2(50), ip VARCHAR2(30),
	url VARCHAR2(50), executionTime int, 
    method VARCHAR2(200)
)

1.3.实体类

public class SysLog {

    private String id; 
    private Date visitTime;
    private String visitTimeStr; 
    private String username; 
    private String ip;
    private String url;
    private Long executionTime;
    private String method;
｝

2.基于AOP日志处理

2.1.页面syslog-list.jsp

详细内容请查看资源中页面信息

2.2.创建切面类处理日志

/**
 * @outhor Mr.JK
 * @create 2020-05-05  9:19
 */
@Controller
@Aspect
public class LogAop {

    @Autowired
    private HttpServletRequest request;

    @Autowired
    private ISysLogService sysLogService;

    private Date visitTime;//开始的时间
    private Class clazz;//访问的类
    private Method method;//访问的方法



    //前置通知  主要是获取开始时间，执行的类是哪一个，执行的是哪个方法
    @Before("execution(* com.jk.ssm.controller.*.*(..))")
    public void doBefore(JoinPoint jp) throws NoSuchMethodException {
        visitTime = new Date();//当前时间就是开始访问的时间
        clazz = jp.getTarget().getClass();//具体要访问的类
        String methodName = jp.getSignature().getName();//获取访问方法的名称
        Object[] args = jp.getArgs();//获取访问的方法的参数
        if (args == null || args.length == 0){
            method = clazz.getMethod(methodName); //只能获取无参数的方法
        }else {
            Class[] classArgs = new Class[args.length];
            for (int i = 0; i < args.length; i++) {
                classArgs[i] = args[i].getClass();
            }
            clazz.getMethod(methodName,classArgs);
        }


    }

    //后置通知
    @After("execution(* com.jk.ssm.controller.*.*(..))")
    public void doAfter(JoinPoint jp) throws Exception {
        Long time = new Date().getTime() - visitTime.getTime();

        String url = "";
        if (clazz.getName() == "com.jk.ssm.controller.SysLogController"){
            return;
        }

        //获取url
        if (clazz != null && method != null && clazz != LogAop.class){

            //获取类上的注解
            RequestMapping classAnnotation = (RequestMapping) clazz.getAnnotation(RequestMapping.class);

            if (classAnnotation != null){
                String[] classValue = classAnnotation.value();

                //2.获取方法上的注解
                RequestMapping methodAnnotation = method.getAnnotation(RequestMapping.class);
                if (methodAnnotation != null){
                    String[] methodValue = methodAnnotation.value();
                    url = classValue[0] + methodValue[0];


                    //获取访问的ip
                    String ip = request.getRemoteAddr();

                    //获取当前操作的用户
                    SecurityContext context = SecurityContextHolder.getContext();//从上下文中获取当前的用户
                    User user = (User) context.getAuthentication().getPrincipal();
                    String username = user.getUsername();

                    SysLog sysLog = new SysLog();
                    sysLog.setExecutionTime(time);
                    sysLog.setIp(ip);
                    sysLog.setMethod("[类名]" + clazz.getName() + "[方法名]" + method.getName());
                    sysLog.setUrl(url);
                    sysLog.setUsername(username);
                    sysLog.setVisitTime(visitTime);

                    //调用
                    sysLogService.save(sysLog);
                }
            }
        }

    }

}

在切面类中我们需要获取登录用户的username，还需要获取ip地址，我们怎么处理？

username获取SecurityContextHolder获取ip地址获取

ip地址的获取我们可以通过request.getRemoteAddr()方法获取到。

在Spring中可以通过RequestContextListener来获取request或session对象。

2.3.SysLogController

@Controller
@RequestMapping("/sysLog")
public class SysLogController {

    @Autowired
    private ISysLogService sysLogService;

    @RequestMapping("/findAll.do")
    public ModelAndView findAll() throws Exception {
        ModelAndView mv = new ModelAndView();
        List<SysLog> sysLogList =  sysLogService.findAll();
        mv.addObject("sysLogs",sysLogList);
        mv.setViewName("syslog-list");

        return mv;
    }

}

2.4.Service

/**
 * @outhor Mr.JK
 * @create 2020-05-05  10:13
 */
@Service
@Transactional
public class SysLogServiceImpl implements ISysLogService {

    @Autowired
    private ISysLogDao sysLogDao;


    public void save(SysLog sysLog) throws Exception {
        sysLogDao.save(sysLog);
    }

    public List<SysLog> findAll() throws Exception {
        return sysLogDao.findAll();
    }
}

2.5.Dao

/**
 * @outhor Mr.JK
 * @create 2020-05-05  10:14
 */

public interface ISysLogDao {

    @Insert("insert into sysLog(visitTime,username,ip,url,executionTime,method) values(#{visitTime},#{username},#{ip},#{url},#{executionTime},#{method})")
    void save(SysLog sysLog) throws Exception;

    @Select("select * from sysLog")
    List<SysLog> findAll() throws Exception;
}