AOP切面试编程

最新推荐文章于 2024-07-20 19:18:51 发布
最新推荐文章于 2024-07-20 19:18:51 发布
阅读量1.6k 收藏 31
点赞数 40
文章标签： sql 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62736267/article/details/137056390
版权

1. AOP基础

1.1 AOP概述

什么是AOP？

  • AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。

  • AOP面向方法编程，可以做到在不改动这些原始方法的基础上，针对特定的方法进行功能的增强。

AOP的作用：在程序运行期间在不修改源代码的基础上对已有方法进行增强（无侵入性: 解耦）

AOP的优势：

  1. 减少重复代码

  2. 提高开发效率

  3. 维护方便

1.2 AOP快速入门

实现步骤：

  1. 导入依赖：在pom.xml中导入AOP的依赖

  2. 编写AOP程序：针对于特定方法根据业务需要进行编程

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

AOP程序：TimeAspect

@Component
@Aspect //当前类为切面类
@Slf4j
public class TimeAspect {
​
    @Around("execution(* com.itheima.service.*.*(..))") 
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        //记录方法执行开始时间
        long begin = System.currentTimeMillis();
​
        //执行原始方法
        Object result = pjp.proceed();
​
        //记录方法执行结束时间
        long end = System.currentTimeMillis();
​
        //计算方法执行耗时
        log.info(pjp.getSignature()+"执行耗时: {}毫秒",end-begin);
​
        return result;
    }
}

我们通过AOP入门程序完成了业务方法执行耗时的统计，那其实AOP的功能远不止于此，常见的应用场景如下：

  • 记录系统的操作日志

  • 权限控制

  • 事务管理：我们前面所讲解的Spring事务管理，底层其实也是通过AOP来实现的，只要添加@Transactional注解之后，AOP程序自动会在原始方法运行前先来开启事务，在原始方法运行完毕之后提交或回滚事务这些都是AOP应用的典型场景。

我们也应该感受到了AOP面向切面编程的一些优势：

  • 代码无侵入：没有修改原始的业务方法，就已经对原始的业务方法进行了功能的增强或者是功能的改变

  • 减少了重复代码

  • 提高开发效率

  • 维护方便

1.3 AOP核心概念

1. 连接点：JoinPoint，可以被AOP控制的方法（暗含方法执行时的相关信息）

连接点指的是可以被aop控制的方法。例如：入门程序当中所有的业务方法都是可以被aop控制的方法。在SpringAOP提供的JoinPoint当中，封装了连接点方法在执行时的相关信息。

2. 通知：Advice，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法），在AOP面向切面编程当中，我们只需要将这部分重复的代码逻辑抽取出来单独定义。抽取出来的这一部分重复的逻辑，也就是共性的功能。

3. 切入点：PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用

在aop的开发当中，我们通常会通过一个切入点表达式来描述切入点(后面会有详解)。

假如：切入点表达式改为DeptServiceImpl.list()，此时就代表仅仅只有list这一个方法是切入点。只有list()方法在运行的时候才会应用通知。

4. 切面：Aspect，描述通知与切入点的对应关系（通知+切入点）

当通知和切入点结合在一起，就形成了一个切面。通过切面就能够描述当前aop程序需要针对于哪个原始方法，在什么时候执行什么样的操作。

切面所在的类，我们一般称为切面类（被@Aspect注解标识的类）

5. 目标对象：Target，通知所应用的对象

目标对象指的就是通知所应用的对象，我们就称之为目标对象。

Spring的AOP底层是基于动态代理技术来实现的，也就是说在程序运行的时候，会自动的基于动态代理技术为目标对象生成一个对应的代理对象。在代理对象当中就会对目标对象当中的原始方法进行功能的增强。

2. AOP进阶

AOP的基础知识学习完之后，下面我们对AOP当中的各个细节进行详细的学习。主要分为4个部分：

  1. 通知类型

  2. 通知顺序

  3. 切入点表达式

  4. 连接点

2.1 通知类型

在入门程序当中，我们已经使用了一种功能最为强大的通知类型：Around环绕通知。

@Around("execution(* com.itheima.service.*.*(..))")
public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
    //记录方法执行开始时间
    long begin = System.currentTimeMillis();
    //执行原始方法
    Object result = pjp.proceed();
    //记录方法执行结束时间
    long end = System.currentTimeMillis();
    //计算方法执行耗时
    log.info(pjp.getSignature()+"执行耗时: {}毫秒",end-begin);
    return result;
}

只要我们在通知方法上加上了@Around注解，就代表当前通知是一个环绕通知。

Spring中AOP的通知类型：

  • @Around：环绕通知，此注解标注的通知方法在目标方法前、后都被执行

  • @Before：前置通知，此注解标注的通知方法在目标方法前被执行

  • @After ：后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行

  • @AfterReturning ： 返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行

  • @AfterThrowing ： 异常后通知，此注解标注的通知方法发生异常后执行

下面我们通过代码演示，来加深对于不同通知类型的理解：

@Slf4j
@Component
@Aspect
public class MyAspect1 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(JoinPoint joinPoint){
        log.info("before ...");
​
    }
​
    //环绕通知
    @Around("execution(* com.itheima.service.*.*(..))")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        log.info("around before ...");
​
        //调用目标对象的原始方法执行
        Object result = proceedingJoinPoint.proceed();
        
        //原始方法如果执行时有异常，环绕通知中的后置代码不会在执行了
        
        log.info("around after ...");
        return result;
    }
​
    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(JoinPoint joinPoint){
        log.info("after ...");
    }
​
    //返回后通知（程序在正常执行的情况下，会执行的后置通知）
    @AfterReturning("execution(* com.itheima.service.*.*(..))")
    public void afterReturning(JoinPoint joinPoint){
        log.info("afterReturning ...");
    }
​
    //异常通知（程序在出现异常的情况下，执行的后置通知）
    @AfterThrowing("execution(* com.itheima.service.*.*(..))")
    public void afterThrowing(JoinPoint joinPoint){
        log.info("afterThrowing ...");
    }
}
​

重新启动SpringBoot服务，进行测试：

程序发生异常的情况下：

  • @AfterReturning标识的通知方法不会执行，@AfterThrowing标识的通知方法执行了

  • @Around环绕通知中原始方法调用时有异常，通知中的环绕后的代码逻辑也不会在执行了 （因为原始方法调用已经出异常了）

在使用通知时的注意事项：

  • @Around环绕通知需要自己调用 ProceedingJoinPoint.proceed() 来让原始方法执行，其他通知不需要考虑目标方法执行

  • @Around环绕通知方法的返回值，必须指定为Object，来接收原始方法的返回值，否则原始方法执行完毕，是获取不到返回值的。

2.2 通知顺序

这多个通知方法到底哪个先运行，哪个后运行？ 下面我们通过程序来验证（这里呢，我们就定义两种类型的通知进行测试，一种是前置通知@Before，一种是后置通知@After）

定义多个切面类：

@Slf4j
@Component
@Aspect
public class MyAspect2 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }
​
    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect2 -> after ...");
    }
}
​
@Slf4j
@Component
@Aspect
public class MyAspect3 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect3 -> before ...");
    }
​
    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect3 ->  after ...");
    }
}
@Slf4j
@Component
@Aspect
public class MyAspect4 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect4 -> before ...");
    }
​
    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect4 -> after ...");
    }
}
​

重新启动SpringBoot服务，测试通知的执行顺序：

备注：

  1. 把DeptServiceImpl实现类中模拟异常的代码删除或注释掉。

  2. 注释掉其他切面类(把@Aspect注释即可)，仅保留MyAspect2、MyAspect3、MyAspect4 ，这样就可以清晰看到执行的结果，而不被其他切面类干扰。

通过以上程序运行可以看出在不同切面类中，默认按照切面类的类名字母排序：

  • 目标方法前的通知方法：字母排名靠前的先执行

  • 目标方法后的通知方法：字母排名靠前的后执行

如果我们想控制通知的执行顺序有两种方式：

  1. 修改切面类的类名（这种方式非常繁琐、而且不便管理）

  2. 使用Spring提供的@Order注解

使用@Order注解，控制通知的执行顺序：

@Slf4j
@Component
@Aspect
@Order(2)  //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect2 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }
​
    //后置通知 
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect2 -> after ...");
    }
}
@Slf4j
@Component
@Aspect
@Order(3)  //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect3 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect3 -> before ...");
    }
​
    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect3 ->  after ...");
    }
}
@Slf4j
@Component
@Aspect
@Order(1) //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect4 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect4 -> before ...");
    }
​
    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect4 -> after ...");
    }
}

重新启动SpringBoot服务，测试通知执行顺序

通知的执行顺序大家主要知道两点即可：

  1. 不同的切面类当中，默认情况下通知的执行顺序是与切面类的类名字母排序是有关系的

  2. 可以在切面类上面加上@Order注解，来控制不同的切面类通知的执行顺序

2.3 切入点表达式

切入点表达式：

  • 描述切入点方法的一种表达式

  • 作用：主要用来决定项目中的哪些方法需要加入通知

  • 常见形式：

    1. execution(……)：根据方法的签名来匹配

    1. @annotation(……) ：根据注解匹配

首先我们先学习第一种最为常见的execution切入点表达式。

2.3.1 execution

execution主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配，语法为：

execution(访问修饰符?  返回值  包名.类名.?方法名(方法参数) throws 异常?)

其中带?的表示可以省略的部分

  • 访问修饰符：可省略（比如: public、protected）

  • 包名.类名： 可省略

  • throws 异常：可省略（注意是方法上声明抛出的异常，不是实际抛出的异常）

示例：

@Before("execution(void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))")

可以使用通配符描述切入点

  • * ：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分

  • .. ：多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数

切入点表达式的语法规则：

  1. 方法的访问修饰符可以省略

  2. 返回值可以使用*号代替（任意返回值类型）

  3. 包名可以使用*号代替，代表任意包（一层包使用一个*）

  4. 使用..配置包名，标识此包以及此包下的所有子包

  5. 类名可以使用*号代替，标识任意类

  6. 方法名可以使用*号代替，表示任意方法

  7. 可以使用 * 配置参数，一个任意类型的参数

  8. 可以使用.. 配置参数，任意个任意类型的参数

切入点表达式示例

  • 省略方法的修饰符号

    execution(void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))

  • 使用*代替返回值类型

    execution(* com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))

  • 使用*代替包名（一层包使用一个*）

    execution(* com.itheima.*.*.DeptServiceImpl.delete(java.lang.Integer))

  • 使用..省略包名

    execution(* com..DeptServiceImpl.delete(java.lang.Integer))    

  • 使用*代替类名

    execution(* com..*.delete(java.lang.Integer))  

  • 使用*代替方法名

    execution(* com..*.*(java.lang.Integer))  

  • 使用 * 代替参数

    execution(* com.itheima.service.impl.DeptServiceImpl.delete(*))

  • 使用..省略参数

    execution(* com..*.*(..))

注意事项：

  • 根据业务需要，可以使用 且（&&）、或（||）、非（!） 来组合比较复杂的切入点表达式。

    execution(* com.itheima.service.DeptService.list(..)) || execution(* com.itheima.service.DeptService.delete(..))

切入点表达式的书写建议：

  • 所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。如：查询类方法都是 find 开头，更新类方法都是update开头

    //业务类
@Service
public class DeptServiceImpl implements DeptService {
    
    public List<Dept> findAllDept() {
       //省略代码...
    }
    
    public Dept findDeptById(Integer id) {
       //省略代码...
    }
    
    public void updateDeptById(Integer id) {
       //省略代码...
    }
    
    public void updateDeptByMoreCondition(Dept dept) {
       //省略代码...
    }
    //其他代码...
}
//匹配DeptServiceImpl类中以find开头的方法
execution(* com.itheima.service.impl.DeptServiceImpl.find*(..))
描述切入点方法通常基于接口描述，而不是直接描述实现类，增强拓展性

execution(* com.itheima.service.DeptService.*(..))
在满足业务需要的前提下，尽量缩小切入点的匹配范围。如：包名匹配尽量不使用 ..，使用 * 匹配单个包

execution(* com.itheima.*.*.DeptServiceImpl.find*(..))

3.3.2 @annotation

已经学习了execution切入点表达式的语法。那么如果我们要匹配多个无规则的方法，比如：list()和 delete()这两个方法。这个时候我们基于execution这种切入点表达式来描述就不是很方便了。而在之前我们是将两个切入点表达式组合在了一起完成的需求，这个是比较繁琐的。

我们可以借助于另一种切入点表达式annotation来描述这一类的切入点，从而来简化切入点表达式的书写。

实现步骤：

  1. 编写自定义注解

  2. 在业务类要做为连接点的方法上添加自定义注解

自定义注解：MyLog

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
}

业务类：DeptServiceImpl

@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;
​
    @Override
    @MyLog //自定义注解（表示：当前方法属于目标方法）
    public List<Dept> list() {
        List<Dept> deptList = deptMapper.list();
        //模拟异常
        //int num = 10/0;
        return deptList;
    }
​
    @Override
    @MyLog  //自定义注解（表示：当前方法属于目标方法）
    public void delete(Integer id) {
        //1. 删除部门
        deptMapper.delete(id);
    }
​
​
    @Override
    public void save(Dept dept) {
        dept.setCreateTime(LocalDateTime.now());
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.save(dept);
    }
​
    @Override
    public Dept getById(Integer id) {
        return deptMapper.getById(id);
    }
​
    @Override
    public void update(Dept dept) {
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.update(dept);
    }
}

切面类

@Slf4j
@Component
@Aspect
public class MyAspect6 {
    //针对list方法、delete方法进行前置通知和后置通知
​
    //前置通知
    @Before("@annotation(com.itheima.anno.MyLog)")
    public void before(){
        log.info("MyAspect6 -> before ...");
    }
​
    //后置通知
    @After("@annotation(com.itheima.anno.MyLog)")
    public void after(){
        log.info("MyAspect6 -> after ...");
    }
}

重启SpringBoot服务，测试查询所有部门数据，查看控制台日志.

到此我们两种常见的切入点表达式我已经介绍完了。

  • execution切入点表达式

    • 根据我们所指定的方法的描述信息来匹配切入点方法，这种方式也是最为常用的一种方式

    • 如果我们要匹配的切入点方法的方法名不规则，或者有一些比较特殊的需求，通过execution切入点表达式描述比较繁琐

  • annotation 切入点表达式

    • 基于注解的方式来匹配切入点方法。这种方式虽然多一步操作，我们需要自定义一个注解，但是相对来比较灵活。我们需要匹配哪个方法，就在方法上加上对应的注解就可以了

2.4 连接点

在Spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法名、方法参数等。

  • 对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint类型

  • 对于其他四种通知，获取连接点信息只能使用JoinPoint，它是ProceedingJoinPoint的父类型

示例代码：

@Slf4j
@Component
@Aspect
public class MyAspect7 {
​
    @Pointcut("@annotation(com.itheima.anno.MyLog)")
    private void pt(){}
   
    //前置通知
    @Before("pt()")
    public void before(JoinPoint joinPoint){
        log.info(joinPoint.getSignature().getName() + " MyAspect7 -> before ...");
    }
    
    //后置通知
    @Before("pt()")
    public void after(JoinPoint joinPoint){
        log.info(joinPoint.getSignature().getName() + " MyAspect7 -> after ...");
    }
​
    //环绕通知
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        //获取目标类名
        String name = pjp.getTarget().getClass().getName();
        log.info("目标类名：{}",name);
​
        //目标方法名
        String methodName = pjp.getSignature().getName();
        log.info("目标方法名：{}",methodName);
​
        //获取方法执行时需要的参数
        Object[] args = pjp.getArgs();
        log.info("目标方法参数：{}", Arrays.toString(args));
​
        //执行原始方法
        Object returnValue = pjp.proceed();
​
        return returnValue;
    }
}
​

重新启动SpringBoot服务，执行查询部门数据的功能。

爱编程的猫猫
关注
  • 40
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
并发编程面试题以及答案.docx
07-30
并发编程面试题以及答案 本文档提供了一份并发编程面试题集，涵盖了数据结构与算法基础、Java 基础、JVM、多线程/并发、Linux 使用与问题分析排查、框架使用等多个方面的知识点。同时，本文档还提供了面试真题和...
aop-study:面试切面变成总结
05-13
在Java开发领域，AOP（Aspect Oriented Programming，面向切面编程）是一种强大的设计模式，它允许程序员将关注点从核心业务逻辑中分离出来，如日志、事务管理、性能监控等。`aop-study`项目显然是一个专门用于学习...
拿捏面试官-Spring AOP IOC源码笔记
01-30
Spring的核心特性是控制反转（IOC）和面向切面编程（AOP）。它提供了一个全面的编程和配置模型，可以用于构建各种类型的Java应用程序，包括Web应用。 1. **Spring介绍** - **侵入式概念**：传统Java EE应用中，...
Interview:面试编程问题
06-11
以下是一些基于Java的面试编程问题，这些问题旨在考察候选人的逻辑思维、代码实现以及对Java核心概念的理解。 1. **数组与集合** - **数组与ArrayList的区别**：数组是固定大小的，而ArrayList是动态数组，可以...
PostgreSQL 中如何解决因大量并发删除和插入操作导致的索引抖动？
技术笔记
07-17 839
索引抖动是 PostgreSQL 中一个常见的问题，它会对数据库的性能产生严重的影响。通过采用批量操作、分区表、索引优化和调整数据库参数等方法，我们可以有效地解决索引抖动问题，提高数据库的性能和稳定性。在实际应用中，我们应该根据具体情况选择合适的解决方案，并不断地进行优化和调整，以满足业务的需求。解决索引抖动问题就像是一场战斗，我们需要根据敌人（问题）的特点和弱点，选择合适的武器（解决方案），并灵活运用战术（优化方法），才能取得最终的胜利。
多租户架构的艺术：在SQL Server中实现数据库的多租户
2401_85762266的博客
07-20 305
多租户架构允许多个租户共享相同的应用程序和数据库架构，每个租户的数据被逻辑上隔离。这种架构的优势在于成本效益和可扩展性，但同时也带来了数据隔离、性能和安全性的挑战。
接口开发：Orcal数据库的批量新增sql
qq_65032048的博客
07-17 767
场景：在日常的CURD中一定会用到批量新增。在我们的项目中，使用的数据库是Orcal，由于之前基本都是使用Mysql的，使用的sql语句也基本都是用mysql的。但是在这次的接口编写时用mysql的批量新增出了问题，刚开始我还以为是写的动态sql有问题，在后续的问题修改也主要是对动态sql修改，因此也浪费了大量的时间，在后续把sql搬到数据库运行一下后才发现是sql的问题，同时也了解到了mysql和orcal 也是有很多地方是不同的。
SQL执行流程、SQL执行计划、SQL优化
风中的默默
07-19 204
返回两个表中的匹配行。返回左表中的所有记录以及右表中的匹配记录。返回右表中的所有记录以及左表中的匹配记录。返回左侧或右侧表中有匹配的所有记录。
SQL每日一题：查找重复的电子邮箱
xiongxiaoxuan的博客
07-17 352
编写解决方案来报告所有重复的电子邮件。请注意，可以保证电子邮件字段不为 NULL。以 任意顺序 返回结果表。按照email分组计数，筛选出数量>1的email。(需注意分组计数时一定要记得用group by)此表的每一行都包含一封电子邮件。电子邮件不包含大写字母。id 是该表的主键（具有唯一值的列）。
SQL Server详细使用教程(包含启动SQL server服务、建立数据库、建表的详细操作) 非常适合初学者
hackeroink的博客
07-15 1099
本文主要详细介绍SQL server2019的简单使用，以《数据库系统概论（第5版）》的第79页—第80页为例，详细介绍如何使用SQL server2019这款数据库软件，包括启动SQL server服务，建立数据库（学生—课程模式S-T）,建立课程表等，内容比较简单，容易理解，适合广大初学者了解SQL server的简单使用。不会涉及到复杂的语法知识，如果有也会详细解释的！下文标红的字请重点关注一下！本文的需要建表的数据如下：2.Course课程号Cno课程名Cname先行课Cpno学分。
SQL Server报告服务的艺术：在SSRS中打造专业报告
2401_85760095的博客
07-20 551
SQL Server Reporting Services是一个全面的报告解决方案，它允许从各种数据源生成复杂的交互式和移动友好的报告。SSRS包括一个集成的开发环境，用于设计报告，以及一个部署环境，用于发布和共享报告。
怎样在 PostgreSQL 中实现数据的异地备份？
技术笔记
07-19 883
总而言之，在 PostgreSQL 中实现数据的异地备份不是一件难事，但也需要我们认真对待，精心规划。选择合适的备份方法和异地存储方式，制定合理的备份策略，定期进行测试和恢复演练，才能确保我们的数据在任何情况下都能“安然无恙”。🎉相关推荐🍅关注博主🎗️带你畅游技术世界，不错过每一次成长机会！📚领书：PostgreSQL 入门到精通.pdf📙PostgreSQL 中文手册📘PostgreSQL 技术专栏🍅CSDN社区-墨松科技。
【PostgreSQL】Windows 上安装 PostgreSQL 16版本
No8g攻城狮的博客
07-17 1068
✌全网粉丝20W+，CSDN博客专家、Java领域优质创作者，掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域✌。
SQL Server的视图
weixin_49668551的博客
07-16 1018
SQL 视图（Views）是一种虚拟表，是基于 SQL 查询结果生成的。这些虚拟表可以包含来自一个或多个表的数据，并且可以像表一样查询；视图是一个表中的数据经过某种筛选后的显示方式，或者多个表中的数据经过连接筛选后的显示方式。使用视图可以简化复杂查询，提高查询的可读性和可维护性，并提供数据的不同视图。视图由一个预定义的查询（SELECT语句）组成，可以像基本表一样用于SELECT语句中；
在 PostgreSQL 里如何实现数据的分布式事务的事务传播和协调？
技术笔记
07-18 863
在分布式系统中，一个事务可能涉及到多个不同的节点或数据库。分布式事务就是要确保在这些多个操作中，要么所有的操作都成功提交，要么所有的操作都回滚，以保持数据的一致性。打个比方，这就好比一个团队合作完成一个项目，如果其中一个环节出了问题，整个项目都可能受到影响，所以需要确保每个环节都能顺利完成，或者在出现问题时能够及时回滚，避免出现部分完成、部分失败的情况。在本文中，我们深入探讨了在 PostgreSQL 中如何实现数据的分布式事务的事务传播和协调。
如何处理 PostgreSQL 中死锁的情况？
技术笔记
07-19 925
处理 PostgreSQL 中的死锁情况需要我们综合运用预防、检测、解决和优化等多种手段。就像在一场复杂的交通拥堵中，需要交警的指挥、道路的规划、司机的配合以及交通规则的完善，才能保证道路的畅通无阻。对于数据库管理员和开发者来说，要时刻保持警惕，不断优化数据库的设计和操作，以确保系统的稳定和高效运行。只有这样，才能在遇到死锁这个“拦路虎”时，从容应对，顺利解决问题。🎉相关推荐🍅关注博主🎗️带你畅游技术世界，不错过每一次成长机会！📚领书：PostgreSQL 入门到精通.pdf。
SQL Server中的数据加速器：实现数据库的自定义索引
最新发布
2402_85758349的博客
07-20 578
在数据库管理的世界里，索引是提升查询性能的关键。SQL Server作为强大的关系型数据库管理系统，支持创建自定义索引来优化数据访问。本文将深入探讨如何在SQL Server中实现数据库的自定义索引，并提供实际的代码示例。索引是数据库表中一个或多个列的数据结构，可以加快数据检索速度。索引可以是聚集索引（Clustered Index）或非聚集索引（Non-Clustered Index）。聚集索引：按照索引键的顺序重新排列表中的数据。非聚集索引：索引结构和数据存储是分开的，索引包含指向数据的指针。
在 PostgreSQL 中如何实现数据的加密存储？
技术笔记
07-19 778
总的来说，在 PostgreSQL 中实现数据的加密存储是一项重要而又具有挑战性的任务。我们需要根据实际需求选择合适的加密方式，认真管理好加密密钥，充分考虑性能影响，并在实际应用中注意各种细节。这就像是建造一座坚固的城堡，每一块石头、每一道防线都要精心设计和建造。只有这样，我们才能真正保护好数据库中的宝贵数据，让它们在数字世界里安然无恙。🎉相关推荐🍅关注博主🎗️带你畅游技术世界，不错过每一次成长机会！📚领书：PostgreSQL 入门到精通.pdf📙PostgreSQL 中文手册。
aop面向切面编程面试题
09-03
当谈到AOP（面向切面编程）时，以下是一些常见的面试问题： 1. 什么是AOP？它的用途是什么？ 2. AOP和OOP（面向对象编程）之间有什么区别？ 3. 在Java中，AOP的实现方式有哪些？请举例说明。 4. 什么是切面（Aspect...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值