ssm-day03 aop&tx

AOP

AOP指的是面向对象思想编程问题的一些补充和完善

soutp、soutv

解耦通俗理解就是把非核心代码剥出来，减少对业务功能代码的影响

设计模式是解决某些特定问题的最佳解决方案，后面一点要记得学这个！！！

cxk唱跳哈哈哈哈好损

相当于两家不同的中介公司

ProxyFactory factory = new ProxyFactory(new CalculatorLogImpl()); 详解这行代码

这行代码使用了Spring框架中的org.springframework.aop.framework.ProxyFactory类来创建一个代理对象。代理模式是面向切面编程（AOP, Aspect-Oriented Programming）中常用的一种设计模式，它允许在不修改目标对象代码的情况下，向其添加额外的行为或逻辑。

让我们详细分解一下这行代码：

ProxyFactory factory = new ProxyFactory(new CalculatorLogImpl());

• ProxyFactory：这是Spring AOP包提供的一个工厂类，用于创建代理实例。它简化了代理的创建过程，并且提供了对JDK动态代理和CGLIB代理的支持。选择哪种代理方式取决于传递给ProxyFactory构造函数的对象类型。如果这个对象实现了接口，那么通常会使用JDK动态代理；如果没有实现任何接口，则会使用CGLIB代理。

• new CalculatorLogImpl()：这里创建了一个CalculatorLogImpl类型的实例，并将其作为参数传递给了ProxyFactory的构造函数。CalculatorLogImpl应该是你定义的一个实现了某些业务逻辑的类，可能还实现了某个接口（比如Calculator）。通过将这个实例传递给ProxyFactory，你可以为这个具体的业务逻辑类创建一个代理对象。

当你创建了ProxyFactory实例后，你可以进一步配置代理的行为，例如添加拦截器（advisors、interceptors）来定义横切关注点（如日志记录、事务管理等），然后调用getProxy()方法来获取最终的代理对象。下面是一个完整的例子，展示了如何为CalculatorLogImpl添加日志记录功能：

import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.NameMatchMethodPointcutAdvisor;
import org.springframework.aop.MethodBeforeAdvice;

// 假设Calculator是一个接口，而CalculatorLogImpl实现了这个接口
public class Example {
    public static void main(String[] args) {
        // 创建目标对象
        CalculatorLogImpl target = new CalculatorLogImpl();

        // 创建代理工厂
        ProxyFactory factory = new ProxyFactory(target);

        // 定义一个前置通知（Before Advice），用于在方法执行前打印日志
        MethodBeforeAdvice loggingAdvice = (method, args1, target1) -> {
            System.out.println("Executing method: " + method.getName());
        };

        // 创建一个Advisor，它将loggingAdvice应用到特定的方法上
        NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor();
        advisor.setAdvice(loggingAdvice);
        advisor.setMappedNames("add", "subtract");  // 只对"add"和"subtract"方法生效

        // 将Advisor添加到代理工厂
        factory.addAdvisor(advisor);

        // 获取代理对象
        Calculator proxy = (Calculator) factory.getProxy();

        // 使用代理对象调用方法
        proxy.add(5, 3);  // 输出: Executing method: add
        proxy.subtract(10, 4);  // 输出: Executing method: subtract
    }
}

在这个例子中，我们做了以下几件事：

1. 创建了CalculatorLogImpl的目标对象。
2. 使用ProxyFactory为该目标对象创建了一个代理工厂。
3. 定义了一个简单的MethodBeforeAdvice，它会在目标方法执行之前打印一条消息。
4. 创建了一个NameMatchMethodPointcutAdvisor，它将上述的MethodBeforeAdvice应用到名为add和subtract的方法上。
5. 将Advisor添加到ProxyFactory中。
6. 通过factory.getProxy()方法获取代理对象。
7. 使用代理对象调用add和subtract方法，触发前置通知的日志记录行为。

通过这种方式，你可以在不改变CalculatorLogImpl原有代码的基础上，为其方法调用添加额外的行为，如日志记录、性能监控、安全性检查等。这种做法使得代码更加模块化和易于维护。

匿名内部类

OOP面向对象编程不能做到方法的局部修改，AOP可以完善

将多个不同类的相同点交叉起来

AOP就是解决非核心代码冗余问题

很吓人的比 喻

框架是一个技术的集合体

又一个很搞笑的比喻

aop功能也是基于ioc容器中的对象才能进行代理

在取值的时候直接用接口去取，因为后面在ioc容器中的就是实现类的“兄弟”代理类了，而不是实现类

几个插入位置 几个方法

增强也要放在ioc容器里面 @Component

@Aspect 说明它是一个切面

配置类形式 两种方式都行

导包的时候记得是到aspectj下的包

切点表达式作用:选中目标方法，所以它就是字符串的一个格式，通过这个格式匹配方法

统一为部分模糊、字打错了

这种不推荐

只要是跟spring功能有关系的类都要加IOC容器注解@Component

推荐用这种，方便维护

之前的JoinPoint joinPoint可以获取目标方法的信息，但是不能执行目标方法

环绕通知中的两个都可以

环绕通知一定要抛异常，方便拿到异常信息

切点+增强=切面

主要还是使用注解进行AOP的配置

场景一解决：根据id值指定获取

tx

所谓的声明式事务就是对编程式事务的一个封装

spring的事务管理就是对AOP的继承封装

类似游戏机插卡式

事务管理器:存放了事务的实现代码，最后交给spring的tx

 

比较 jdbc, dbutils, jdbcTemplate, mybatis, 和 hibernate，我们可以从以下几个方面进行对比：功能、使用场景、复杂度、性能、学习曲线等。

功能

1. JDBC:

   • 功能: JDBC（Java Database Connectivity）是Java平台的标准数据库访问接口，提供了基本的数据库连接和操作功能。
   • 使用场景: 适用于直接操作数据库的简单应用。

2. DBUtils:

   • 功能: Apache Commons DBUtils 是一个简化JDBC操作的工具包，提供了更简洁的数据库操作方法。
   • 使用场景: 适用于需要简化JDBC操作的场景，减少代码量。

3. JdbcTemplate:

   • 功能: Spring框架中的JdbcTemplate是Spring提供的一个简化JDBC操作的类，提供了更高级的错误处理和资源管理。
   • 使用场景: 适用于使用Spring框架的应用，提供更高级的数据库操作支持。

4. MyBatis:

   • 功能: MyBatis 是一个半自动化的持久层框架，支持SQL语句的编写，提供了对象关系映射（ORM）功能。
   • 使用场景: 适用于需要高性能且灵活控制SQL语句的应用。

5. Hibernate:

   • 功能: Hibernate 是一个全自动化的持久层框架，提供了完整的ORM功能，可以将Java对象直接映射到数据库表。
   • 使用场景: 适用于需要高度抽象和简化数据库操作的复杂应用。

使用场景

• JDBC: 直接操作数据库，适用于简单的数据库操作。
• DBUtils: 简化JDBC操作，适用于需要减少代码量的场景。
• JdbcTemplate: 适用于使用Spring框架的应用，提供更高级的数据库操作支持。
• MyBatis: 适用于需要高性能且灵活控制SQL语句的应用。
• Hibernate: 适用于需要高度抽象和简化数据库操作的复杂应用。

复杂度

• JDBC: 相对简单，但需要手动管理资源和错误处理。
• DBUtils: 简化了JDBC操作，但仍然需要手动编写SQL。
• JdbcTemplate: 提供了更高级的错误处理和资源管理，但需要学习Spring框架。
• MyBatis: 提供了ORM功能，但需要手动编写SQL，复杂度适中。
• Hibernate: 提供了全自动化的ORM功能，复杂度较高，但可以大大简化数据库操作。

性能

• JDBC: 性能直接取决于SQL语句的优化。
• DBUtils: 性能与JDBC类似，但减少了代码量。
• JdbcTemplate: 性能与JDBC类似，但提供了更好的资源管理。
• MyBatis: 性能较高，因为可以手动优化SQL语句。
• Hibernate: 性能取决于ORM映射的效率，通常比手动SQL略低。

学习曲线

• JDBC: 学习曲线较低，但需要了解数据库操作的基本知识。
• DBUtils: 学习曲线较低，但需要了解DBUtils的API。
• JdbcTemplate: 学习曲线适中，需要了解Spring框架。
• MyBatis: 学习曲线适中，需要了解SQL语句和MyBatis的配置。
• Hibernate: 学习曲线较高，需要了解ORM概念和Hibernate的配置。

总结

• JDBC: 最基础的数据库操作接口，适用于简单的应用。
• DBUtils: 简化了JDBC操作，适用于需要减少代码量的场景。
• JdbcTemplate: 适用于使用Spring框架的应用，提供更高级的数据库操作支持。
• MyBatis: 提供了高性能且灵活控制SQL语句的功能，适用于需要高性能的应用。
• Hibernate: 提供了全自动化的ORM功能，适用于需要高度抽象和简化数据库操作的复杂应用。

这段代码定义了一个 Spring 配置类 JavaConfig，它使用了 Java 配置（基于注解）来配置Spring容器中的Bean。具体来说，这段代码实现了数据库连接池（Druid）和 JdbcTemplate 的实例化，并且通过 @PropertySource 注解加载外部的属性文件来设置数据库连接信息。让我们逐行解析这段代码：

1. 包声明与导入

package com.atguigu.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;

• package com.atguigu.config;：指定了这个类所在的包。
• import 语句：导入了必要的类和接口，包括 Druid 数据源、Spring 的配置注解以及 JdbcTemplate。

2. 类声明与注解

@Configuration
@ComponentScan("com.atguigu")
@PropertySource("classpath:jdbc.properties")
public class JavaConfig {

• @Configuration：标记这个类为一个配置类，表示它可以包含用于创建Spring应用上下文的@Bean方法。
• @ComponentScan("com.atguigu")：告诉Spring在com.atguigu包及其子包中自动扫描并注册组件（如带有@Component, @Service, @Repository, @Controller等注解的类）。这使得你可以无需显式地用@Bean注解来定义这些组件。
• @PropertySource("classpath:jdbc.properties")：指示Spring从类路径下的jdbc.properties文件中加载属性值，这样就可以在代码中通过@Value注解来引用这些属性。

3. 属性注入

    @Value("${atguigu.driver}")
    private String driver;
    @Value("${atguigu.url}")
    private String url;
    @Value("${atguigu.username}")
    private String username;
    @Value("${atguigu.password}")
    private String password;

• @Value("${...}")：用于将@PropertySource加载的属性值注入到字段中。这里的${}语法允许你引用jdbc.properties文件中的键值对。例如，${atguigu.driver}会替换为jdbc.properties文件中atguigu.driver对应的值。

4. 定义 DataSource Bean

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

• @Bean：标记这是一个Bean定义方法，Spring将会调用这个方法来创建并管理返回的对象作为Spring容器中的一个Bean。
• DruidDataSource：这是阿里云提供的高性能连接池实现。在这个方法中，我们创建了一个DruidDataSource实例，并设置了它的基本属性，如驱动类名、URL、用户名和密码，这些都是从前面注入的属性中获取的。
• return dataSource;：最后返回配置好的数据源对象，它会被Spring容器管理，并可以在其他地方通过依赖注入的方式获得。

5. 定义 JdbcTemplate Bean

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

• @Bean：同样标记这是一个Bean定义方法。
• JdbcTemplate：这是Spring框架提供的一个简化JDBC操作的类。在这里，我们创建了一个JdbcTemplate实例，并通过构造函数参数注入了之前定义的DataSource Bean。然后我们设置了JdbcTemplate的数据源，并返回这个对象。
• jdbcTemplate.setDataSource(dataSource);：将数据源设置给JdbcTemplate，以便它可以使用这个数据源来执行SQL查询和更新操作。

总结

这段代码的主要作用是配置Spring应用程序的两个核心Bean：一个是DataSource，负责管理数据库连接；另一个是JdbcTemplate，提供了一种更简便的方式来执行JDBC操作。通过这种方式，开发者可以避免编写大量的重复代码，并且能够更加方便地管理和操作数据库。此外，通过使用@PropertySource和@Value注解，数据库连接信息被外部化到了jdbc.properties文件中，这不仅提高了代码的可维护性，也便于在不同环境中进行配置管理。

真没听懂！！

回滚就代表事务不修改

隔离级别越高、影响程度越低、数据越安全

脏读：一个事务读取另外一个事务未提交的数据

不可重复读：一个事务读取另外一个事务提交的修改的数据

幻读:一个事务读取另外一个事务提交的插入的数据

mysql默认是第三个

截图软件Snipaste

记注解！！！

原文地址：https://blog.csdn.net/wujiao__11/article/details/144380933

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！