DAY05_Spring—SpringAop&Aop案例-缓存控制

最新推荐文章于 2024-06-20 09:37:13 发布
最新推荐文章于 2024-06-20 09:37:13 发布
阅读量349 收藏 8
点赞数 8
分类专栏： 5.框架+vue+京淘购物 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57075290/article/details/135680103
版权

目录

1 Spring AOP

1.1 AOP介绍

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率

  • 知识扩展:
    • 面向过程编程 C语言
    • 半面向对象的程序设计 C++
    • 面向对象的编程技术 java
  • 编程方式:
    • 面向接口编程
    • 面向切面编程
  • 总结:
    • AOP(面向切面编程) 主要利用动态代理的模式 降低程序的耦合度,扩展业务功能方法.

1.2 关于AOP名词介绍

  • 连接点:
    • 用户可以被扩展的方法 joinPoint
  • 切入点:
    • 用户实际扩展的方法(判断方法能否进入切面) pointcut 切入点表达式
  • 通知:
    • 扩展方法的具体实现 @before
  • 切面:
    • 将通知应用到切入点的过程 方法功能得到扩展全部配置(切面=切入点表达式+通知方法)

在这里插入图片描述

1.3 通知类型

  • before:
    • 在目标方法执行之前执行
  • afterReturning:
    • 在目标方法执行之后返回时执行
  • afterThrowing:
    • 在目标方法执行之后,抛出异常时执行
  • after:
    • 无论程序是否执行成功,都要最后执行的通知
  • around:
    • 在目标方法执行前后 都要执行的通知(完美体现了动态代理模式)
    • 功能最为强大 只有环绕通知可以控制目标方法的执行
  • 关于通知方法总结:
    • 环绕通知是处理业务的首选. 可以修改程序的执行轨迹
    • 另外的四大通知一般用来做程序的监控(监控系统) 只做记录

1.4 切入点表达式

当程序满足切入点表达式,才能进入切面,执行通知方法

  1. bean(“bean的ID”) 根据beanId进行拦截 只能匹配一个
  2. within(“包名.类名”) 可以使用通配符*? 能匹配多个.
    粒度: 上述的切入点表达式 粒度是类级别的. 粗粒度.
  3. execution(返回值类型 包名.类名.方法名(参数列表…))
    粒度: 控制的是方法参数级别. 所以粒度较细. 最常用的.
  4. @annotation(包名.注解名) 只拦截注解.
    粒度: 注解是一种标记 根据规则标识某个方法/属性/类 细粒度

1.5 AOP入门案例

1.5.1 导入jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.jt</groupId>
    <artifactId>spring_demo_9_aop</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <!--Spring核心包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.22</version>
        </dependency>
        <!--引入SpringBean-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.22</version>
        </dependency>
        <!--引入context包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.22</version>
        </dependency>
        <!--引入表达式jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.3.22</version>
        </dependency>
        <!--引入日志依赖-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <!--引入测试包-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!--引入AOP包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>6.1.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>6.1.2</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.6</version>
        </dependency>
    </dependencies>
</project>

1.5.2 准备代码

public interface DeptService {
    void addDept();
    void updateDept();
}

import org.springframework.stereotype.Service;

@Service
public class DeptServiceImpl implements DeptService{
    @Override
    public void addDept() {
        System.out.println("添加部门的信息");
    }

    @Override
    public void updateDept() {
        System.out.println("更新部门信息");
    }
}

1.5.3 配置切面类

  • 切面 = 切入点表达式 + 通知方法
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

//1.AOP需要被Spring容器管理
@Component
//2.标识该类为AOP切面,Spring容器默认不能识别切面注解,需要手动配置
@Aspect
public class SpringAOP {
    //1.定义before通知
    @Before("bean(deptServiceImpl)")
    public void before() {
        System.out.println("我是before通知");
    }
}

1.5.4 编辑配置类

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.jt")
@EnableAspectJAutoProxy(proxyTargetClass=false) //启动AOP注解 创建代理对象
                                                //默认启用JDK动态代理,
                                                //目标对象没有实现接口时,则采用CGLIB
                                                //强制使用cglib proxyTargetClass=true
                                                //JDK代理创建速度快.运行时稍慢
                                                //CGLIB创建时速度较慢,运行时更快
public class SpringConfig {
}

1.5.5 编辑测试代码

在这里插入图片描述

1.6 关于表达式写法

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

//1.AOP需要被Spring容器管理
@Component
//2.标识该类为AOP切面,Spring容器默认不能识别切面注解,需要手动配置
@Aspect
public class SpringAOP {
    /*
     * 切入点
     * within:
     *      within(com.jt.*.DeptServiceImpl)   一级包下的类
     *      within(com.jt..*.DeptServiceImpl)  ..代表多级包下的类
     *      within(com.jt..*)                  包下的所有的类
     * execution(返回值类型 包名.类名.方法名(参数列表))
     *       execution(* com.jt..*.DeptServiceImpl.add*()) 返回值类型任意的, com.jt下的所有包中的DeptServiceImpl的类的add开头的方法 ,并且没有参数.
     *       execution(* com.jt..*.*(..)) 返回值类型任意,com.jt包下的所有包的所有类的所有方法 任意参数.
     *       execution(int com.jt..*.*(int))
     *       execution(Integer com.jt..*.*(Integer))
     *       注意: 在Spring表达式中没有自动拆装箱功能! 注意参数类型
     * @annotation(包名.注解名)
     *       @Before("@annotation(com.jt.anno.Cache)") 只拦截特定注解的内容.
     */

    //1.定义before通知
    @Before("bean(deptServiceImpl)")
    //@Before("within(com.jt.service.DeptServiceImpl)")
    //@Before("within(com.jt..*)")
    //@Before("execution(* com.jt..*.DeptServiceImpl.add*())")
    //@Before("@annotation(com.jt.anno.Cache)")
    public void before() {
        System.out.println("我是before通知");
    }
}

1.6.1 关于@annotation切入点相关代码

  • 在测试的时候只有被注解标识的方法才会有通知方法
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)//控制注解的生命周期
@Target({ElementType.METHOD,ElementType.TYPE})//注解的作用对象 注解对方法有效 对类有效
public @interface Cache {
}

@Override
@Cache //被注解标识
public void updateDept() {
    System.out.println("更新部门信息");
}

1.7 关于通知方法测试

1.7.1 抽取切入点表达式

如下代码，两个方法都相对注解进行拦截，这样显得代码很冗余

在这里插入图片描述
所以我们可以抽取切入点表达式，代码如下：

//定义切入点表达式
@Pointcut("@annotation(com.jt.anno.Cache)")
public void pointcut(){
}
@Before("pointcut()")
public void before() {
    System.out.println("我是before通知");
}
@AfterReturning("pointcut()")
public void afterReturning(){
    System.out.println("我是afterReturning通知");
}

1.7.2 @Before

  • 前置通知,在目标方法执行之前执行
    • 一般用来记录程序在方法执行前的状态
//1.定义before通知
/**
    * Spring为了AOP动态获取目标对象及方法中的数据,则通过joinPoint对象进行数据的传递.
    * getSignature : 方法签名  获取方法的参数
*/
@Before("pointcut()")
public void before(JoinPoint joinPoint) {
    System.out.println("获取目标对象的类型:" + joinPoint.getTarget().getClass());
    System.out.println("获取目标对象类名:" + joinPoint.getSignature().getDeclaringTypeName());
    System.out.println("获取目标对象方法名:" + joinPoint.getSignature().getName());
    System.out.println("获取方法参数:" + Arrays.toString(joinPoint.getArgs()));
    System.out.println("我是before通知");
}
  • 运行结果

在这里插入图片描述

1.7.3 @AfterReturning

  • 在目标方法执行之后执行
    • 一般用来监控方法的返回值,进行日志的记录
  1. 在DeptService和DeptServiceImpl中添加测试方法

在这里插入图片描述
在这里插入图片描述

  1. 编辑AOP配置类
//2.定义afterReturning通知
/**
    * pointcut：关联的切入点表达式
    * returning：将方法的返回值通过形参result进行传递
    *      如果参数中需要添加joinPoint对象时，参数必须位于第一位
    *      Spring在进行参数赋值时，采用index[0]下标的方式赋值
*/
@AfterReturning(pointcut = "pointcut()",returning = "result")
public void afterReturning(JoinPoint joinPoint,Object result) {
    System.out.println("我是afterReturning通知");
    System.out.println("用户的返回值结果："+result);
}
  • 运行结果

在这里插入图片描述

  • 如果参数反了则会报以下错误

在这里插入图片描述

1.7.4 @AfterThrowing

  • 当目标方法执行时,抛出异常时可以进行记录.
  1. 在DeptService和DeptServiceImpl中添加测试方法

在这里插入图片描述
在这里插入图片描述

  1. 编辑AOP配置类
//3.定义afterReturning通知
    /**
     * throwing = "e" 动态接受程序运行时的报错信息，利用异常通知进行记录
     */
    @AfterThrowing(pointcut = "pointcut()",throwing = "e")
    public void afterThrowing(Exception e) {
        System.out.println("我是afterReturning异常通知");
        System.out.println("获取异常信息"+e.getMessage());
        System.out.println("获取异常的类型"+e.getClass());
    }
  • 测试结果

在这里插入图片描述

1.7.5 @After

  • 方法执行之后执行

编辑AOP配置类

//4.定义after通知
@After("pointcut()")
public void after() {
    System.out.println("我是after通知");
}
  • 测试结果

在这里插入图片描述

1.7.6 @Around

  • 在目标方法执行前后都要执行
    • 实际作用可以控制目标方法是否执行.
  1. 在DeptService和DeptServiceImpl中添加测试方法

在这里插入图片描述
在这里插入图片描述

  1. 编辑AOP配置类
//5.定义afterReturning通知
/**
    * 关于环绕通知的说明
    * 作用: 可以控制目标方法是否执行.
    * 参数: ProceedingJoinPoint 通过proceed方法控制目标方法执行.
    * 注意事项: ProceedingJoinPoint is only supported for around advice
    * @return
*/
@Around("pointcut()")
public Object around(ProceedingJoinPoint joinPoint) {
    Object result = null;
    try {
        System.out.println("环绕通知开始");
        //1.执行下一个通知  2.执行目标方法 3.接收返回值
        Long start = System.currentTimeMillis();
        result = joinPoint.proceed();
        Long end = System.currentTimeMillis();
        System.out.println("耗时:" + (end - start));
    } catch (Throwable throwable) {
        throwable.printStackTrace();
    }
    System.out.println("环绕通知结束");
    return result;
}
  • 测试结果

在这里插入图片描述

1.8 关于通知方法的执行顺序

  1. 执行around开始
  2. 执行before
  3. 执行目标方法
  4. 执行afterReturning
  5. 执行afterThrowing
  6. 执行after
  7. 执行around通知结束

1.9 关于Order注解说明

  • 如果是多个切面,可以用于控制切面的执行顺序，该注解只可以添加在类上使用
  1. 在DeptService和DeptServiceImpl中添加测试方法

在这里插入图片描述
在这里插入图片描述

  1. 准备两个切面类
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class Before1 {
    @Before("@annotation(com.jt.anno.Cache)")
    public void before(){
        System.out.println("我是切面A");
    }
}

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class Before2 {
    @Before("@annotation(com.jt.anno.Cache)")
    public void before(){
        System.out.println("我是切面B");
    }
}
  1. 编辑切面配置类

在这里插入图片描述

  • 测试结果

在这里插入图片描述

2 Aop案例-缓存控制

2.1 业务说明

  • 用户有一个缓存的集合 static Map<k:v> key=id号 value=User对象 根据id将User对象进行了缓存
    • 当用户第二次根据Id查询用户时,如果缓存中有数据,则直接返回

2.2 业务分析

1).首选用AOP方式实现

2).通知方法: 使用环绕通知

3).切入点表达式: execution(…)

2.3 代码实现

  • User类
public class User {
    private Integer id;
    private String name;

    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;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}
  • UserService接口
import com.jt.pojo.User;

public interface UserService {
    //根据user对象查询有效信息
    void findUser(User user);
}
  • UserServiceImpl类
import com.jt.pojo.User;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService{
    @Override
    public void findUser(User user) {
        System.out.println("从数据库中查询数据"+user);
    }
}
  • SpringConfig配置类
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.jt")
@EnableAspectJAutoProxy//创建代理对象
public class SpringConfig {
}
  • SpringAOP配置类
import com.jt.pojo.User;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

@Component
@Aspect
public class SpringAOP {
    private static Map<Integer, User> map = new HashMap();

    /**
     * 需求: 用户第一次查询走目标方法
     * 用户第二次查询走缓存  不执行目标方法
     * 判断依据: 如何判断用户是否为第一次查询?
     * 通过map集合进行判断 有数据 证明不是第一次查询
     * 执行步骤:
     * 1.获取用户查询的参数
     * 2.判断map集合中是否有该数据.
     * true:  从map集合中get之后返回
     * false: 执行目标方法,之后将user对象保存到Map中
     */
    //切入点表达式: 拦截service包中的所有方法
    @Around("execution(* com.jt.service..*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        Object result = null;
        //1.获取目标对象的参数
        Object[] args = joinPoint.getArgs();
        //2.强制类型转化为对象
        User user = (User) args[0];
        //3.判断map集合中是否有该数据  user的Id是唯一标识
        int id = user.getId();
        if (map.containsKey(id)) {
            //map中有数据
            System.out.println("AOP缓存执行");
            //将获取的数据返回
            return map.get(id);
        } else {
            //map中没有数据 执行目标方法
            result = joinPoint.proceed();
            //将user对象保存到Map中
            map.put(id, user);
            System.out.println("AOP执行目标方法");
        }
        return result;
    }
}
  • 测试类
import com.jt.config.SpringConfig;
import com.jt.pojo.User;
import com.jt.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestSpring {
    @Test
    public void test01(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean(UserService.class);
        User user = new User();
        user.setId(100);
        user.setName("缓存");
        //1.第一次查询走数据库
        userService.findUser(user);
        //2.第二次查询走缓存
        userService.findUser(user);
    }
}
  • 运行结果

在这里插入图片描述

_-Mr-sun
关注
  • 8
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-aop.rar_aop1270_spring_spring aop
09-23
spring aop 源码用于spring 开源软件源码的获取
spring-nested-aop.zip_aop_spring aop
09-23
Spring AOP演示程序，实现Spring AOP的嵌套式事务处理。是个绝好的演示程序。
day38_springAOP2
CSDN_AF的博客
04-13 1061
spring spring的事务平台 缓存的存取
spring_day03_AOP
Jesson_study
08-15 156
一、AOP概述 1、概述 AOP，Aspect Oriented Programming的缩写，意为：面向切面编程 AOP是一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构AOP最早由AOP联盟的组织提出的,制定了一套规范 Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术 AOP是OOP（面向对象编程...
Spring专家课程Day01_Spring-IOC
u010655348的博客
06-27 1308
一、01_Spring概述_IOC_HelloWorld二、使用步骤1.引入库2.读入数据一、01_Spring概述_IOC_HelloWorld示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。二、使用步骤1.引入库2.读入数据代码如下（示例）：该处使用的url网络请求的数据。
day37_springAOP1
CSDN_AF的博客
04-13 953
aop的各个概念 aop的各个概念的截图aop的作业spring容器的启动流程 查看工资 匹配 切入点表达式 权限与缓存的通知
week15_day04_SpringAOP
shihao的博客
07-16 312
对昨天内容的总结： 注意： 类名首字母大写：Test1 包名小写：com.zgs IOC scope 作用域 singleton：单例 → 每一次取出都是同一个组件 prototype：原型 → 每一次取出都是全新的 scope也带来生命周期的变化 singleton：容器初始化的时候，开始生命周期 prototype：当你去获得这个组件的时候，才开始生命周期。生命周期没有destroy collectionBean（xml配置文件） 最重要整合其他框架的时候，注册一些组件，组件又包含了这些collecti
Day167.AOP功能实现和原理 -Spring注解驱动
阿昌爱Java
01-18 238
Spring注解驱动 AOP功能实现和原理 一、AOP功能测试 AOP： 指在 程序运行期间 动态的将某段代码切入到指定方法指定位置进行运行的编程方式【动态代理】 细节流程： 1、导入aop模块； Spring AOP:（spring-aspects） 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法运行之前、方法运行结束、方法出现异常…等） 3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div方法运
CGB3-day5-Spring AOP介绍
小憨憨的学习笔记
12-22 203
目录一、 Spring AOP介绍1.1 创建项目1.1.1 层级代码结构1.1.2 引入依赖1.2 AOP1.2.1 AOP介绍1.2.2 AOP入门案例1.2.2.1 编辑配置类1.2.2.2 编辑切面类1.2.2.3 编辑测试类1.3 常见通知类型1.3.1 正常运行结束展示1.3.2 异常运行结果展示1.4 切入点表达式1.4.1 bean表达式1.4.2 within表达式1.4.3 execution表达式1.4.4 @annotation表达式1.5 关于通知的讲解1.5.1 关于AOP
cgb2107-第二阶段-day18-springaop
qq_40151384的博客
09-22 80
一 Spring AOP 概述 是面向切面编程,拓展了面向对象的不足. 切面Aspect: 其实就是 一个类,要用@Aspect注解 通知Advice:就是类里的方法,分为:前置通知 后置通知 环绕通知 返回后通知 异常通知 切点Pointcut: 就是定义了方法的触发时间,切入点表达式 使用步骤 加入jar包 <dependencies> <!--添加aop依赖包--> <dependency> <groupId>org
Spring-day03 AOP
m0_46690280的博客
08-06 727
AOPAOP1)AOP简介1.1)OOP开发思路1.2)AOP开发思想1.3)AOP概念1.4)AOP作用1.5)AOP优势2)AOP入门案例2.1)AOP相关概念2.2)AOP开发过程2.2)AOP开发方式2.3)入门案例制作分析3)AOP配置（XML）3.1)AspectJ3.2)AOP配置3.2.1)aop:config3.2.2)aop:aspect3.2.3)aop:pointcut3.3)切入点3.4)切入点表达式的组成3.4.1)切入点表达式——关键字3.4.2)切入点表达式——通配符3.4.
spring-aop.rar_java aop_spring aop
09-23
SPRING AOP自主实现，还包括一些java基础，可以很快自主实现切面编程
springAop.rar_AOP java_cglib_spring aop
09-21
spring aop 编程，cglib ,切面编程
8_24_SpringAOP_springaop_
10-03
spring aop 的配置文件，新手可以用来学习学习
Vue + SpringBoot 实现文件的断点上传、秒传，存储到Minio
m0_73179389的博客
06-19 520
前端页面使用的elment-plus的el-upload组件。当上传文件后，会调用handleChange 方法，可以在这里进行文件相关的操作。计算文件的MD5值。
Spring 事务传播行为之Propagation.NESTED REQUIRES_NEW等探讨
chengmin123456789的博客
06-17 227
当一个事务方法（标记为@Transactional(propagation = Propagation.NESTED))被另一个活动事务调用时，它会创建一个“保存点”（Savepoint）作为新的事务开始点。这意味着，如果这个嵌套事务方法内部发生异常并导致回滚，事务会回滚到这个保存点，而不会影响到外部事务的其他操作。如果一切正常，嵌套事务会在外部事务结束时一起提交。
springboot“漫画之家”系统 LW+PPT+源码
u014445459的博客
06-17 872
链接：https://pan.baidu.com/s/1ihILTui-XEFdC15mcOB0vA?pwd=ewry提取码：ewry由于本系统是作为毕业设计系统，且系统本身存在一些技术层面的缺陷，并不能直接用于商业用途，只想要通过该系统的开发提高自身学术水平，不需要特定服务器等额外花费。所有创造及工作过程仅需在个人电脑上就能实现，使用到的软件大多为开源软件，所以经济成本并不高，可以轻易实现。
springboot大学生体质测试管理系统 LW+PPT+源码
最新发布
u014445459的博客
06-20 1184
操作的多样性也变高了。登录成功可以对自己的信息进行操作，不能对别人的账号的信息进行查看等操作，这样自然保证系统的安全性。测试成绩管理，在测试成绩管理页面可以对索引、测试编号、、测试名称、教师工号、教师姓名、测试评分、测试评级、评分时间、用户账号、用户姓名、班级等内容进行详情、修改或删除等详细的操作，如图5-11所示。测试报告管理，在测试报告管理页面可以对索引、测试编号、测试名称、教师工号、教师姓名、报告文件、提交日期、用户账号、用户姓名、班级等内容进行详情、修改或删除等详细的操作，如图5-10所示。
spring-aop与spring-boot-starter-aop的区别
09-22
spring-aop与spring-boot-starter-aop的区别在于配置的简化程度和依赖的引入方式。spring-aop是基于Spring框架的AOP实现方式，需要通过XML配置文件来定义切面和通知。而spring-boot-starter-aop是针对Spring Boot...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值