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:同步操作,没有实现异步调用,适用于不需要多线程的地方!
    • ConcurrentTaskExecutorThreadPoolTaskExecutor不被满足时,可以考虑使用!
    • 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 方法(如 protectedprivate 或默认包可见性),虽然不会报错,但事务设置将不会起作用。@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() {
        
    }
}
声明:本站所有文章,如无特殊说明或标注,均为本站原创发布。任何个人或组织,在未征得本站同意时,禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益,可联系我们进行处理。