Spring 知识点

Spring

Spring 是什么？

Spring为了解决企业级应用的复杂性而创建，简化开发。
如下简化：
- 基于POJO的轻量级和最小侵入性编程；
- 以IoC（控制反转）、DI（依赖注入）和面向接口实现松耦合；
- 基于AOP（切面编程）和惯性进行声明式编程；
- 以切面和模版减少样式代码；

Spring IoC（控制反转）

IoC 负责创建、维护、并管理对象之间依赖关系的容器。
什么叫控制反转：控制权的转移——应用程序本身负责依赖对象的创建和维护的控制权转移给IoC容器管理。
什么控制被反转：获取依赖对象的过程被反转了——获取依赖对象的过程由自身变为IoC容器主动注入。
为什么要使用IoC：实现对象之间的解耦、复用；
实现方式：DI（依赖注入）、工厂模式。

Spring DI（依赖注入）

什么叫依赖注入：程序在运行时依赖IOC容器来动态注入对象所需的资源；（Java DI官方标准是JSR-330，Guice是一个轻量级的DI框架。）
DI是IoC的一种实现方式。
为什么使用DI：松耦合、易测试、强内聚、可重用。
方式一：Field 注入

@Autowired
private OrderWorkApplicationService orderWorkApplicationService;

方式二：Setter 方法注入

public class OrderWorkApi {
	
    private OrderWorkApplicationService orderWorkApplicationService;
    
    @Autowired
    public void setOrderWorkApplicationService(OrderWorkApplicationService orderWorkApplicationService){
        this.orderWorkApplicationService = orderWorkApplicationService;
    }
}

方式二：Constructor 注入

public class OrderWorkApi {
	
    private final OrderWorkApplicationService orderWorkApplicationService;
    
    public OrderWorkApi(final OrderWorkApplicationService orderWorkApplicationService){
        this.orderWorkApplicationService = orderWorkApplicationService;
    }
}

方式三：Lombok + Constructor 注入
- 保证依赖的对象不为Null。
- 避免 Field 注入的循环依赖问题。

@RequiredArgsConstructor
public class OrderWorkApi {
	
    private final OrderWorkApplicationService orderWorkApplicationService;
}

Spring AOP（切面编程）

什么是AOP：通过“预编译”或“运行期动态代理”以垂直维护实现程序功能的一种技术。
用途：提供了声明式的企业服务、替代了EJB的服务声明，允许自定义，以完成OOP（面向对象编程）与AOP的互补使用。
实现：不是为了提供最完整的AOP实现、而是侧重于提供一种AOP实现与Spring IoC容器之间的整合，用于解决常见的问题（日志、事务、异常）。
- 预编译：AspectJ
- 运行期动态代理（jdk动态代理、CGLib动态代理）：Spring AOP、Jboss AOP
  - 区别：CGLib动态代理无接口、jdk动态代理有接口。
例子

package com.gdbyway.bpg.ip.nis.aop;

import com.gdbyway.bpg.ip.nis.annotations.TestSoul;
import com.gdbyway.bpg.ip.nis.application.service.diagnosis.DiagnosisApplicationService;
import com.gdbyway.bpg.ip.nis.types.diagnosis.representation.PatHistoryDiagRepresentation;
import com.gdbyway.bpg.ip.nis.types.discharge.query.CommonPatHistoryDiagQuery;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import java.util.List;

@Aspect
@Configuration
public class TestSoulAspect {

    @Autowired
    private DiagnosisApplicationService applicationService;

    //对使用@TestSoul注解作为切入点
    @Pointcut("@annotation(com.gdbyway.bpg.ip.nis.annotations.TestSoul)")
    public void pointcut() {
    }

    //对使用@TestSoul注解作为切入点
    @Before("pointcut()")
    public void before(JoinPoint joinPoint) {

        TestSoul testSoul = ((MethodSignature) joinPoint.getSignature()).getMethod().getAnnotation(TestSoul.class);
        System.out.println("----------------------myAsp-------------------------------------------------");
        CommonPatHistoryDiagQuery query = new CommonPatHistoryDiagQuery();
        query.setPatId("96187");
        List<PatHistoryDiagRepresentation> ss = applicationService.findByPatId(query);
        System.out.println(ss);
    }
	//返回时处理
    @AfterReturning(value = "pointcut()")
    public void afterReturning() {
    }
	//异常时处理
    @AfterThrowing(pointcut = "pointcut()",throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Throwable ex) {
    }
}

Spring MVC

什么是MVC： 一种架构模式、思考方式——程序分层、分工合作、既相互独立又协同工作。
M（模型层）：展示信息
V（视图层）：界面布局
C（控制层）：处理业务逻辑

Spring @Async（异步）

@Async 可标记在方法上，以便异步调用该方法。调用者将在调用时立即返回，方法的实际执行将提交给SringTaskExecutor的任务中，由指定的线程池中的线程执行！
实际应用中：推荐使用自定义线程池模式（自定义线程池常用方案：重新实现接口AsyncConfigurer）
应用场景
- 同步：整个操作流程依次执行，每个过程执行完毕、并返回结果！
- 异步：异步调用只是发送调用的指令，调用者无需等待被调用的方法完全执行完毕，而是继续执行之后的流程！
  
  注意：Java一般基于创建独立的线程完相应的异步调用逻辑，通过主线程和业务子线程之间执行流程，从而在启动独立的线程之后，主线程继续执行而不会产生停滞等待的情况。
Spring 的线程池
- SimpleAsyncTaskExecutor：默认每次调用都创建新的线程，不重用线程、并非真正的线程池！
- SyncTaskExecutor：同步操作，没有实现异步调用，适用于不需要多线程的地方！
- ConcurrentTaskExecutor：ThreadPoolTaskExecutor不被满足时，可以考虑使用！
- SimpleThreadPoolTaskExecutor：线程池同时被Quartz和非Quartz使用，才需要使用此类！
- ThreadPoolTaskExecutor：最常用。
@Async默认：SimpleAsyncTaskExecutor
自定义线程池方式
- 实现接口AsyncConfigurer
- 继承AsyncConfigurerSupport
- 配置自定义的TaskExecutor

Spring @Transactional（事务）

Spring提供了两种事务管理机制：编程式事务和声明式事务。
编程式事务：是指在代码中手动的管理事务的提交、回滚等操作，代码侵入性比较强。

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.jdbc.core.JdbcTemplate;  
import org.springframework.transaction.PlatformTransactionManager;  
import org.springframework.transaction.TransactionStatus;  
import org.springframework.transaction.support.DefaultTransactionDefinition;  
  
public class MyService {  
  
    private final JdbcTemplate jdbcTemplate;  
    private final PlatformTransactionManager transactionManager;  
  
    @Autowired  
    public MyService(JdbcTemplate jdbcTemplate, PlatformTransactionManager transactionManager) {  
        this.jdbcTemplate = jdbcTemplate;  
        this.transactionManager = transactionManager;  
    }  
  
    public void performTransactionalOperation() {  
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();  
        TransactionStatus status = transactionManager.getTransaction(def);  
  
        try {  
            // 执行数据库操作，例如：  
            jdbcTemplate.update("INSERT INTO my_table (name) VALUES ('John Doe')");  
            jdbcTemplate.update("UPDATE another_table SET count = count + 1 WHERE id = ?", 1);  
  
            // 如果没有异常，提交事务  
            transactionManager.commit(status);  
        } catch (Exception ex) {  
            // 如果发生异常，回滚事务  
            transactionManager.rollback(status);  
            throw ex; // 可以选择重新抛出异常或进行其他处理  
        }  
    }  
}

声明式事务：基于AOP面向切面使业务和事务解耦，代码侵入性比较低。

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.jdbc.core.JdbcTemplate;  
import org.springframework.stereotype.Service;  
import org.springframework.transaction.annotation.Transactional;  
  
@Service  
public class MyService {  
    
    private final JdbcTemplate jdbcTemplate;  
  
    @Autowired  
    public MyService(JdbcTemplate jdbcTemplate) {  
        this.jdbcTemplate = jdbcTemplate;  
    }  
  
    @Transactional(rollbackFor = Exception.class)
    public void performTransactionalOperation() {  
        // 执行数据库操作，例如：  
        jdbcTemplate.update("INSERT INTO my_table (name) VALUES ('John Doe')");  
        jdbcTemplate.update("UPDATE another_table SET count = count + 1 WHERE id = ?", 1);  
        // 如果以上操作成功，事务将自动提交；如果发生异常，事务将自动回滚  
        // 也可以手动设置回滚
        // TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();  
    }  
}

常见@Transactional声明式事务的失效场景
- 事务方法内部捕捉了异常，但没有抛出：如果事务方法内部捕获了异常且没有重新抛出，那么Spring事务管理器不会感知到异常，因此不会触发事务回滚。为了确保事务能够正常回滚，应该让异常冒泡到方法外部。
- 同一个类中方法调用/this调用：如果在一个类中，一个方法调用了同一个类的另一个被 @Transactional 注解的方法，那么被调用的方法的事务注解将不会生效。这是因为 Spring 的 AOP 代理通常只会在不同类的方法调用时生效。this 引用的是当前类的实例，而不是 Spring 代理的实例，因此事务增强不会应用。如下为其中一种解决方案：
```
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

// 
@Service
@EnableAspectJAutoProxy(exposeProxy = true)
public class MyService {

    private final JdbcTemplate jdbcTemplate;

    @Autowired
    public MyService(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
	
    // 改为动态代理调用，而非直接调用
    public void insertBusiness(){
        MyService impl = (MyService) AopContext.currentProxy();
        impl.insert();
    }


    @Transactional(rollbackFor = Exception.class)
    public void insert(){
        jdbcTemplate.update("INSERT INTO my_table (name) VALUES ('John Doe')");
        jdbcTemplate.update("UPDATE another_table SET count = count + 1 WHERE id = ?", 1);
    }
}
```
- 方法可见性：如果 @Transactional 注解被应用于一个非 public 方法（如 protected、private 或默认包可见性），虽然不会报错，但事务设置将不会起作用。@Transactional 注解应该只应用于 public 方法，因为 Spring AOP 代理通常是通过代理对象来调用目标方法的，而代理对象只能调用 public 方法。
- 数据库引擎不支持事务：如果使用的数据库引擎不支持事务（例如，MyISAM 存储引擎在 MySQL 中不支持事务），那么即使使用了 @Transactional 注解，事务也不会生效。
- 异常类型：Spring 默认只会对运行时异常（RuntimeException 及其子类）进行事务回滚。如果方法抛出了检查异常（即非运行时异常），并且没有被捕获处理，事务也不会回滚。可以通过在 @Transactional 注解中设置 rollbackFor 属性来指定需要回滚的异常类型。
- 事务传播行为设置不当：@Transactional 注解中的 propagation 属性用于设置事务的传播行为。如果传播行为设置不当，可能会导致事务不按照预期工作。例如，TransactionDefinition.PROPAGATION_NEVER 表示以非事务方式运行，如果当前存在事务，则抛出异常。

获取Spring Bean

特殊场景获取Bean方式（定时任务）：ApplicationContextAware

@Component
public class ApplicationServiceFactory implements ApplicationContextAware {
    
    private static ApplicationContext applicationContext;
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ApplicationServiceFactory.applicationContext = applicationContext;
    }
    
    public static <T> T getBean(Class<T> clazz) {
        if (Objects.isNull(applicationContext)) {
            throw new NullPointerException("Spring ApplicationContext is Null");
        }
        return applicationContext.getBean(clazz);
    }

    public static ApplicationContext getApplicationContext(){
        return applicationContext;
    }
    
}

获取接口的所有实现类

InitializingBean

@Component
public class ApplicationServiceFactory implements InitializingBean {
     @Override
    public void afterPropertiesSet() {
        
    }
}

posted @ 2024-03-12 15:22 Soul-Q 阅读(38) 评论(0) 编辑收藏举报

刷新页面返回顶部

Soul-Q

Spring 知识点

Spring

Spring 是什么？

Spring IoC（控制反转）

Spring DI（依赖注入）

Spring AOP（切面编程）

Spring MVC

Spring @Async（异步）

Spring @Transactional（事务）

获取Spring Bean

获取接口的所有实现类

公告