1、AOP是什么

  • AOP 为 Aspect Oriented Programming 的缩写，可以通过预编译方式和运行期动态代理，实现在不修改源代码的情况下给程序动态统一添加某种特定功能的一种技术
  • AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型

2、项目结构

  • 这里我们用到AOP的环绕切面技术

aop_project

  • aop：存放aop相关的类
  • common：存放模板
  • anno：存放自定义注解
  • controller：控制层，网页跳转服务相关
  • domain：存放实体类
  • mapper：DAO层，存放CRUD的接口
  • service：业务层，存放具体业务实现的逻辑代码
  • resource：存放资源和配置文件
  • view：受保护的视图层
  • test：进行单元测试

3、部分代码截图+运行效果

  • 项目启动
    run
  • 自定义注解
    Log
  • AOP编写
    LogAspect
  • 控制层，把@Log注解加到处理登录的方法，登录时触发AOP
    UserController
  • 登录成功页面
    success_1
  • 数据库添加成功
    success_2

4、完整代码实现

4.1、项目配置文件

  • pom.xml
<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <spring.version>5.1.5.RELEASE</spring.version>
    <druid.version>1.2.8</druid.version>
    <mysql.version>8.0.32</mysql.version>
    <junit-version>4.13.2</junit-version>
    <!-- aop使用 -->
    <aspectj-version>1.8.0</aspectj-version>
    <mybatis.version>3.4.2</mybatis.version>
    <mybatis.spring.version>1.3.0</mybatis.spring.version>
    <validator.version>6.0.10.Final</validator.version>
</properties>


<!--导入自定义的依赖 本地maven仓库-->
<dependency>
    <groupId>com.llh</groupId>
    <artifactId>login-utils</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>
<!--数据校验-->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>${validator.version}</version>
</dependency>
<!--切面-->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>${aspectj-version}</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>${aspectj-version}</version>
</dependency>
<!-- mybatis核心包 -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>${mybatis.version}</version>
</dependency>
<!-- mybatis-spring 整合jar -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>${mybatis.spring.version}</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>${lombok-version}</version>
</dependency>
<!--spring的相关依赖 根据依赖传递，自动依赖aop beans context..-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
</dependency>
<!--jdbc-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>${spring.version}</version>
</dependency>
<!--事务-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>${spring.version}</version>
</dependency>
<!-- druid数据源 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>${druid.version}</version>
</dependency>
<!-- Mysql数据库驱动包 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>${mysql.version}</version>
</dependency>
<!-- 单元测试 -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>${junit-version}</version>
    <scope>test</scope>
</dependency>
  • web.xml
<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
      <display-name>Archetype Created Web Application</display-name>
      <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>
                  classpath:spring-ioc.xml
            </param-value>
      </context-param>
      <!--  编码格式-->
      <filter>
            <filter-name>encodingFilter</filter-name>
            <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
            <init-param>
                  <param-name>encoding</param-name>
                  <param-value>UTF-8</param-value>
            </init-param>
      </filter>
      <filter-mapping>
            <filter-name>encodingFilter</filter-name>
            <url-pattern>/*</url-pattern>
      </filter-mapping>
      <!--  监听器-->
      <listener>
            <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
      </listener>
      <listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
      <!--  DispatcherServlet -->
      <servlet>
            <servlet-name>dispatcherServlet</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <init-param>
                  <param-name>contextConfigLocation</param-name>
                  <param-value>classpath:spring-mvc.xml</param-value>
            </init-param>
            <load-on-startup>1</load-on-startup>
      </servlet>
      <!--  DispatcherServlet 处理哪些请求-->
      <servlet-mapping>
            <servlet-name>dispatcherServlet</servlet-name>
            <url-pattern>*.do</url-pattern>
      </servlet-mapping>
</web-app>

4.2、spring核心文件

  • spring-ioc.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns: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/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"
>

      <!--    todo 包扫描-->
      <context:component-scan base-package="com.llh.service,com.llh.aop">
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
      </context:component-scan>

      <!--    todo 数据源：数据库，用户名，密码 druid-->
      <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>  <!--通过${}使用外部配置文件的值-->
            <property name="url"
                      value="jdbc:mysql://localhost:3306/ccc?useUnicode=true&amp;characterEncoding=utf-8"></property>
            <property name="username" value="root"></property>
            <property name="password" value="root"></property>
            <property name="maxWait" value="10000"></property>
      </bean>

      <!--    将sqlsession 托管给spring-->
      <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean" scope="singleton">
            <!-- 加载数据环境   -->
            <property name="dataSource" ref="dataSource"/>
            <!--  todo 绑定mybatis的配置文件     -->
            <property name="configLocation" value="classpath:mybatis-config.xml"/>

            <!-- todo 自动扫描mapping.xml文件，classpath后需要输入自己的mapper文件的路径 -->
            <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
            <!-- 配置mybatis分页插件PageHelper -->
            <property name="plugins">
                  <array>
                        <bean class="com.github.pagehelper.PageInterceptor">
                              <property name="properties">
                                    <!-- 什么都不配，使用默认的配置 -->
                                    <value></value>
                              </property>
                        </bean>
                  </array>
            </property>
      </bean>
      <!--Mapper接口代理扫描器 扫描mapper层的接口,给接口创建代理对象 -->
      <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <!--        todo 扫描mapper层的接口-->
            <property name="basePackage" value="com.llh.mapper"/>
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
      </bean>
      <!--    事务控制器-->
      <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"></property>
      </bean>
      <!--    开启注解声明式事务-->
      <tx:annotation-driven transaction-manager="transactionManager"/>
      <!--    开启spring aop-->
      <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
  • spring-mvc.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd
                           http://www.springframework.org/schema/mvc
                          http://www.springframework.org/schema/mvc/spring-mvc.xsd
                           http://www.springframework.org/schema/tx
                           http://www.springframework.org/schema/tx/spring-tx.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd">
      <!--    开启注解扫描-->
      <mvc:annotation-driven></mvc:annotation-driven>
      <!--    开启包扫描-->
      <context:component-scan base-package="com.llh.controller,com.llh.aop"></context:component-scan>
      <!--    视图解析器 返回jsp-->
      <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/view/"/>
            <property name="suffix" value=".jsp"/>
            <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
      </bean>
      <!--    开启aop-->
      <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
  • mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
      <settings>
            <setting name="logImpl" value="STDOUT_LOGGING"/>
            <setting name="mapUnderscoreToCamelCase" value="true"/>
      </settings>
</configuration>

4.3、自定义注解

  • Log.java
package com.llh.common.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * User: lilinhan
 * DateTime: 2023/5/29 18:59
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
}

4.4、AOP编写

  • LogAspect.java
package com.llh.aop;

import com.llh.domain.LogInfo;
import com.llh.domain.User;
import com.llh.service.UserService;
import com.llh.utils.TokenUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.util.Date;

/**
 * User: lilinhan
 * DateTime: 2023/5/29 19:01
 */
@Component
@Aspect
public class LogAspect {
      @Autowired
      HttpServletRequest request;

      @Autowired
      UserService userService;

      /**
       * 切入到加了@Log注解的方法里面去记录日志
       *
       * @param point
       * @return proceed
       */
      @Around("@annotation(com.llh.common.anno.Log)")
      public Object recordLog(ProceedingJoinPoint point) throws Throwable {
            Object[] args = point.getArgs();
            long begin = System.currentTimeMillis();
            Object proceed = point.proceed(args);
            long end = System.currentTimeMillis();
            //执行时间
            long executeTime = end - begin;
            // url
            String url = request.getRequestURI();
            // requestParam 请求参数
            String requestParam = request.getParameterMap().toString();
            // 当前时间
            Date date = new Date();
            // 构建一个LogInfo对象
            User user = TokenUtils.getLoginUserFromRequest(request, User.class);
            Integer userId = null;
            if (userId != null) {
                  userId = user.getId();
            }
            LogInfo logInfo = new LogInfo();
            logInfo.setUserId(userId);
            logInfo.setUrl(url);
            logInfo.setRequestParam(requestParam);
            logInfo.setExecuteTime((int) executeTime);
            logInfo.setCreateTime(date);

            userService.addLog(logInfo);
            return proceed;
      }
}

4.5、编写实体类

  • User.java
package com.llh.domain;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.format.annotation.DateTimeFormat;

import java.io.Serializable;
import java.util.Date;

/**
 * 
 * @TableName user
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    /**
     * 
     */
    private Integer id;

    /**
     * 
     */
//    @NotBlank(message = "用户名不能为空")
    private String name;

    /**
     * 
     */
//    @NotBlank(message = "密码不能为空")
    private String pwd;

    /**
     * 
     */
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date regdate;

//    @NotBlank(message = "验证码不能为空")
    private String yzm;

    private static final long serialVersionUID = 1L;
}
  • LogInfo.java
package com.llh.domain;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.util.Date;

/**
 * @TableName log_info
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class LogInfo implements Serializable {
      /**
       * 日志表id
       */
      private Integer id;

      /**
       * 用户id
       */
      private Integer userId;

      /**
       * 执行时间
       */
      private Integer executeTime;

      /**
       * 访问路径
       */
      private String url;

      /**
       * 请求参数
       */
      private String requestParam;

      /**
       * 创建时间
       */
      private Date createTime;

      private static final long serialVersionUID = 1L;

}

4.6、编写控制层

  • UserController.java
package com.llh.controller;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.llh.common.anno.Log;
import com.llh.domain.User;
import com.llh.mapper.UserMapper;
import com.llh.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;

/**
 * User: lilinhan
 * DateTime: 2023/5/27 10:37
 */
@Controller
public class UserController {
      @Autowired
      UserService userService;

      @Autowired
      UserMapper userMapper;

      @Autowired
      HttpServletRequest request;

      /**
       * 前往登录选项页面
       * @return
       */
      @RequestMapping("/login_test.do")
      public String gotoLogin(){
            return "login_test";
      }

      /**
       * 前往普通登录页面
       * @return
       */
      @RequestMapping("/gotoLogin_easy.do")
      public String gotoLogin_easy(){
            return "login_easy";
      }

      /**
       * 获取图形验证码
       * @return
       */
      @RequestMapping("/yzm.do")
      public String yzm(){
            return "yzm";
      }

      /**
       * 处理普通登录请求
       * @param user user
       * @param model model
       * @param request request
       * @return 重定向到list.do
       */
      @Log
      @PostMapping("/login.do")
      public String login(User user, Model model,HttpServletRequest request){
            // 获取浏览器请求头信息
            String header = request.getHeader("User-Agent");
            System.out.println(header);

            System.out.println("接收到的请求参数------"+ JSON.toJSONString(user));
            // 非空验证
            if(StrUtil.isBlank(user.getName())){
                  model.addAttribute("error","用户名不能为空");
                  model.addAttribute("name",user.getName());
                  return "login_easy";
            }
            if(StrUtil.isBlank(user.getPwd())){
                  model.addAttribute("error","密码不能为空");
                  model.addAttribute("name",user.getName());
                  return "login_easy";
            }
            if(StrUtil.isBlank(user.getYzm())){
                  model.addAttribute("error","验证码不能为空");
                  model.addAttribute("name",user.getName());
                  return "login_easy";
            }
            // 获取图片验证码的值
            String yzm = (String) request.getSession().getAttribute("yzm");
            // 检查验证码是否正确
            if(!StrUtil.equalsAnyIgnoreCase(yzm,user.getYzm())){
                  model.addAttribute("error","验证码错误");
                  model.addAttribute("name",user.getName());
                  return "login_easy";
            }
            // 验证用户不存在
            User dbUser = userService.getUserFindByName(user.getName());
            if(dbUser==null){
                  model.addAttribute("error","用户名不存在");
                  model.addAttribute("name",user.getName());
                  return "login_easy";
            }
            // 获取数据库里的密码
            String pwd = dbUser.getPwd();
            // 验证密码是否正确
            if(!user.getPwd().equals(pwd)){
                  model.addAttribute("error","密码错误");
                  model.addAttribute("name",user.getName());
                  return "login_easy";
            }
            // 将用户信息存入session
            request.getSession().setAttribute("LOGIN_USER",dbUser);

            return "redirect:list.do";
      }
}

4.7、编写DAO层

  • UserMapper.java
package com.llh.mapper;

import com.llh.domain.LogInfo;
import com.llh.domain.User;

/**
 * User: lilinhan
 * DateTime: 2023/5/27 10:39
 */
public interface UserMapper {
      void addLog(LogInfo logInfo);
}
  • UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.llh.mapper.UserMapper">
      <insert id="addLog">
            insert into log_info values (null,#{userId},#{executeTime},#{url},#{requestParam},#{createTime})
      </insert>
</mapper>

4.8、编写业务层

  • UserService.java
package com.llh.service;

import com.llh.domain.LogInfo;
import com.llh.domain.User;

/**
 * User: lilinhan
 * DateTime: 2023/5/27 10:40
 */
public interface UserService {
      void addLog(LogInfo logInfo);
}
  • UserServiceImpl.java
package com.llh.service.Impl;

import com.llh.domain.LogInfo;
import com.llh.domain.User;
import com.llh.mapper.UserMapper;
import com.llh.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * User: lilinhan
 * DateTime: 2023/5/27 10:40
 */
@Service
public class UserServiceImpl implements UserService {
      @Autowired
      UserMapper userMapper;

      @Override
      public void addLog(LogInfo logInfo) {
            userMapper.addLog(logInfo);
      }
}

4.9、编写视图层

  • login_easy.jsp
<%--
  Created by IntelliJ IDEA.
  User: lilinhan
  Date: 2023/5/27
  Time: 10:05
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" pageEncoding="UTF-8" %>
<html>
<head>
      <title>Title</title>
      <link href="css/bootstrap.min.css" rel="stylesheet">
      <script type="text/javascript" src="js/jquery-3.5.1.js"></script>
      <%--echart线图、柱状图、饼图等各种图型库 cdn--%>
      <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/echarts/dist/echarts.min.js"></script>
      <%--jquery cdn--%>
      <script type="text/javascript" src="https://cdn.bootcdn.net/ajax/libs/jquery/3.6.1/jquery.js"></script>
</head>
<body>
      ${error}
      <form action="login.do" method="post">
            用户名：<input type="text" name="name" ${name}><br>
            密码：<input type="text" name="pwd"><br>
            验证码：<input type="text" name="yzm"><img id="code" src="yzm.do" onclick="reload()"><br>
            <button type="submit">登录</button>
      </form>

<script type="text/javascript">
      function reload(){
          $("#code").prop("src","yzm.do")
      }
</script>
</body>
</html>
  • yzm.jsp
<%@ page import="java.awt.image.BufferedImage" %>
<%@ page import="java.awt.*" %>
<%@ page import="java.util.Random" %>
<%@ page import="java.io.OutputStream" %>
<%@ page import="javax.imageio.ImageIO" %><%
    int width = 60;
    int height = 30;
    //create the image
    BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
    Graphics g = image.getGraphics();
    // set the background color
    g.setColor(new Color(0xDCDCDC));
    g.fillRect(0, 0, width, height);
    // draw the border
    g.setColor(Color.black);
    g.drawRect(0, 0, width - 1, height - 1);
    // create a random instance to generate the codes
    Random rdm = new Random();
    String hash1 = Integer.toHexString(rdm.nextInt());
    System.out.print(hash1);
    // make some confusion
    for (int i = 0; i < 50; i++) {
        int x = rdm.nextInt(width);
        int y = rdm.nextInt(height);
        g.drawOval(x, y, 0, 0);
    }
    // generate a random code
    String capstr = hash1.substring(0, 4);
    //将生成的验证码存入session
    session.setAttribute("yzm", capstr);
    g.setColor(new Color(0, 100, 0));
    g.setFont(new Font("Candara", Font.BOLD, 24));
    g.drawString(capstr, 8, 24);
    g.dispose();
    //输出图片
    response.setContentType("image/jpeg");
    out.clear();
    out = pageContext.pushBody();
    OutputStream strm = response.getOutputStream();
    ImageIO.write(image, "jpeg", strm);
    strm.close();
%>

4.10、数据库表建设

  • log_info.sql
/*
 Navicat Premium Data Transfer

 Source Server         : MySQL
 Source Server Type    : MySQL
 Source Server Version : 80031 (8.0.31)
 Source Host           : localhost:3306
 Source Schema         : ccc

 Target Server Type    : MySQL
 Target Server Version : 80031 (8.0.31)
 File Encoding         : 65001

 Date: 04/06/2023 19:40:18
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for log_info
-- ----------------------------
DROP TABLE IF EXISTS `log_info`;
CREATE TABLE `log_info`  (
  `id` int NOT NULL AUTO_INCREMENT COMMENT '日志表id',
  `user_id` int NULL DEFAULT NULL COMMENT '用户id',
  `execute_time` int NULL DEFAULT NULL COMMENT '执行时间',
  `url` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '访问路径',
  `request_param` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '请求参数',
  `create_time` datetime NULL DEFAULT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of log_info
-- ----------------------------
INSERT INTO `log_info` VALUES (4, NULL, 79, '/login.do', '{name=[admin],pwd=[hgh],yzm=[hgfh]}', '2023-05-29 20:15:07');
INSERT INTO `log_info` VALUES (5, NULL, 18, '/login.do', '{name=[admin],pwd=[root],yzm=[1161]}', '2023-05-29 20:16:00');
INSERT INTO `log_info` VALUES (6, NULL, 666, '/login.do', '{name=[admin],pwd=[rewre],yzm=[f186]}', '2023-05-29 20:53:57');

SET FOREIGN_KEY_CHECKS = 1;
  • user.sql
/*
 Navicat Premium Data Transfer

 Source Server         : MySQL
 Source Server Type    : MySQL
 Source Server Version : 80031 (8.0.31)
 Source Host           : localhost:3306
 Source Schema         : ccc

 Target Server Type    : MySQL
 Target Server Version : 80031 (8.0.31)
 File Encoding         : 65001

 Date: 04/06/2023 19:41:07
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  `pwd` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  `regDate` date NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 19 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = DYNAMIC;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, 'admin', 'root', '2023-02-03');
INSERT INTO `user` VALUES (12, '人的', '565345', '2023-02-06');
INSERT INTO `user` VALUES (13, '张三', '356546', '2023-02-05');
INSERT INTO `user` VALUES (14, '如果', '645465', '2023-02-06');
INSERT INTO `user` VALUES (15, '哈哈哈', '435656', '2023-02-10');
INSERT INTO `user` VALUES (18, 'hhhhhh', '374fghb', '2020-12-23');

SET FOREIGN_KEY_CHECKS = 1;
标签：Spring，Java，Aop
本文到此就结束啦
Last modification：June 11, 2024
© Allow specification reprint
如果觉得我的文章对你有用，请随意赞赏