Java框架 —— Spring

卷积殉铁子
44 阅读13分钟

Spring

简介

  一般来说，Spring指的是SpringFramework，它提供了很多功能，例如：控制反转（IOC）、依赖注入

（DI）、切面编程（AOP）、事务管理（TX）

主要 jar 包

  • org.springframework.core： Spring的核心工具包，其他包依赖此包
  • org.springframework.beans： 所有应用都用到，包含访问配置文件，创建和管理bean等
  • org.springframework.aop： Spring的面向切面编程，提供AOP的实现
  • org.springframework.context： 提供在基础IOC功能上的扩展服务，此外还提供许多企业级服务的支持（邮件服务、任务调度、JNDI定位、EJB集成、远程访问、缓存等）
  • org.springframework.web.mvc： 包含SpringMVC应用开发时所需的核心类
  • org.springframework.transaction： 为JDBC、Hibernate、JPA提供一致的声明式和编程式事务管理
  • org.springframework.web： 包含web应用开发时，用到的Spring框架时所需的核心类
  • org.springframework.aspect： Spring提供的对Aspect框架的整合
  • org.springframework.test： 对JUNIT等测试框架的简单封装
  • org.springframework.context.support： Spring context的扩展支持，用于MVC方面
  • org.springframework.expression： Spring表达式语言
  • org.springframework.jdbc： 对JDBC的简单封装
  • org.springframework.web.servlet： 对J2EE6.0 servlet3.0的支持

IOC（控制反转）

组件和组件管理

 整个项目由各种组件搭建而成

在Spring中，组件交给Spring容器进行管理，代替程序员之前new对象的操作，控制对象的创建，管理对象的生命周期

优势

  • 降低了组件之间的耦合性： Spring IoC容器通过依赖注入机制，将组件之间的依赖关系削弱，减少了程序组件之间的耦合性
  • 提高了代码的可重用性和可维护性： 将组件的实例化过程、依赖关系的管理等功能交给Spring IoC容器处理，使得组件代码更加模块化、可重用、更易于维护。
  • 方便了配置和管理： Spring IoC容器通过XML文件或者注解，轻松的对组件进行配置和管理，使得组件的切换、替换等操作更加的方便和快捷

容器管理配置方式

  • XML配置文件： 在XML文件中定义Bean及其依赖关系、Bean的作用域等信息，让Spring IoC容器来管理Bean之间的依赖关系
  • 注解方式配置： 通过在Bean类上使用注解来代替XML配置文件中的配置信息。通过在Bean类上加上相应的注解（如@Component, @Service, @Autowired等），将Bean注册到Spring IoC容器中
  • Java配置类配置： 通过Java类来定义Bean、Bean之间的依赖关系和配置信息，通过@Configuration、@Bean等注解来实现Bean和依赖关系的配置

实例化方式

  • 构造器实例化

    在配置文件中定义bean（对应bean中要有空参构造）

<bean id="" class="">
    <property name="" value=""/>
</bean>
  • 编写构造器
  • 获取实例化对象
public void test1(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = context.getBean(UserService.class);
    }
  • 静态工厂实例化
<bean id="user4" class="com.sxny.pojo.User" factory-method="createInstance"/>
  • 实例化工厂实例化
<bean id="userFactory" class="com.sxny.pojo.UserFactory"></bean>
<bean id="user5" factory-bean="userFactory" factory-method="createUser"/>
<bean id="book2" name="book3,book4" class="com.sxny.pojo.Book">

Spring Bean

指被Spring容器管理的对象

将一个类声明为Bean的注解

  • @Component：通用的注解，可标记任何类为Spring组件

  • @Service：对应服务层，主要涉及一些复杂的逻辑

  • @Repository：对应持久层，主要用于数据库相关操作

  • @Controller：对应SpringMVC控制层，主要用于接收用户请求，并调用Service层，返回数据给前端

    @Component和@Bean

    @Component 作用于类，@Bean作用于方法

    @Bean 比 @Component 的自定义性更强，有些地方只能用 @Bean 注解来注册bean，如：当我们需要引用第三方库中的类，需要装配到Spring容器中时，只能通过 @Bean 注解实现

Bean 的作用域
  • singleton： 容器中只有唯一的bean实例，Spring中bean默认都是单例的 （默认）
  • prototype： 每次获取bean时都会创建一个新的bean实例
  • request（仅web应用可用）： 每次http请求都会产生一个新的bean，仅在该HTTP Request内生效
  • session（仅web应用可用）： 每一次来自新 session 的 HTTP 请求都会产生一个新的 bean，仅在当前 HTTP session 内有效
Bean 的生命周期

 实例化 -> 属性赋值 -> 初始化 -> 销毁

 在实例化阶段，Spring容器通过反射机制创建Bean，然后进行依赖注入，如果Bean实现了BeanNameAware等接口，容器会调用相应方法

 在初始化阶段，BeanPostProcessor会在前后进行拦截处理，最后调用初始化方法，例如@PostConstruct或afterPropertiesSet

 销毁时则会调用DisposeableBean.destory()或自定义的销毁方法

DI（依赖注入）

在组件之间传递依赖关系的过程中，将依赖关系放入容器内部进行处理，降低依赖关系，实现了对象间的解耦合

实现方式

1、通过构造器注入 （对应类中必须有对应的构造函数）

<bean id="user" class="com.pojo.User">
    <constructor-arg name="id" value="1"/>
    <constructor-arg name="name" value="张三"/>
    <constructor-arg name="sex" value="18"/>
</bean>

2、通过setter方法注入

<bean id="book" class="com.pojo.Book">
    <property name="name" value="1"/>
    <property name="bid" value="2"/>
</bean>

3、通过字段注入

通过字段注入，也就是通过注解进行注入（@Autowired、@Resource）

 @Autowired 和 @Resource 的区别

  • @Autowired是 Spring 提供的注解，默认的注入方式是按照类型进行匹配，也就是说会优先通过接口类型去匹配并注入bean，当接口存在多个实现类时，byType这种方式就无法正确注入对象了，可以通过结合@Qualifier注解来显式指定名称
  • @Resource是JDK提供的注解，默认注入方式是按照名称进行匹配，如果无法通过名称匹配到对应的bean，就会按照类型来匹配
  • @Autowired支持在构造方法、方法、字段、参数上使用，@Resource用于字段和方法上的使用，不支持在构造方法和参数使用

AOP（面向切面编程）

横向编程，在不改变核心业务逻辑的情况下，对一些功能进行增强（常用在日志管理、权限控制、事务处理、安全控制）

Spring AOP的底层原理

基于JDK的动态代理实现、基于cglib的字节码生成实现

 AOP 的底层是两种动态代理都有，默认情况下，如果目标类实现了一个或多个接口，AOP自动采用的是JDK动态代理进行增强，如果目标类没有实现接口，AOP采用cglib字节码生成的方式来增强，当然，也可用强制使用cglib字节码生成的方式进行增强，这样就不用考虑目标类是否实现了接口

基本概念

  • join point（连接点）： 目标类中的所有方法
  • pointcut（切点）： 对哪些方法进行拦截
  • advice（通知）： 拦截到方法要干什么
  • aspect（切面）： 通知和切点的结合
  • target（目标）： 被代理的目标对象

Spring AOP 和AspectJ AOP

 Spring AOP属于运行时增强，AspectJAOP属于编译时增强，SpringAOP是基于代理，AspectJAOP是基于字节码操作，切面比较少时，没有太大区别，切面较多时，建议使用AspectJAOP

通知类型

  • 前置通知： 在被代理的目标方法前执行
  • 后置通知： 在被代理的目标方法最终结束后执行
  • 环绕通知： 使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置
  • 异常通知： 在被代理的目标方法异常结束后执行
  • 返回通知： 在被代理的目标方法成功结束后执行

可以通过XML配置或者注解的方式实现

实现

1、导包（添加依赖）

2、通过注解或者XML配置

// 通过注解方式
// @Aspect表示这个类是一个切面类
@Aspect
// @Component注解保证这个切面类能够放入IOC容器
@Component
public class LogAspect {
 
    // @Before注解：声明当前方法是前置通知方法
    // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上
    @Before(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogBeforeCore() {
        System.out.println("[AOP前置通知] 方法开始了");
    }
    
    @AfterReturning(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogAfterSuccess() {
        System.out.println("[AOP返回通知] 方法成功返回了");
    }
    
    @AfterThrowing(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogAfterException() {
        System.out.println("[AOP异常通知] 方法抛异常了");
    }
    
    @After(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogFinallyEnd() {
        System.out.println("[AOP后置通知] 方法最终结束了");
    }
}

3、开启aspectj注解支持

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
 
    <!-- 进行包扫描-->
    <context:component-scan base-package="com.atguigu" />
    <!-- 开启aspectj框架注解支持-->
    <aop:aspectj-autoproxy />
</beans>

TX（事务）

一系列动作中，只要有一个出现问题，所有动作全部回滚到事务开始的状态，避免了数据不一致导致的错误

对应依赖

  • spring-tx： 包含声明式事务实现的基本规范（事务管理器规范接口和事务增强等等）
  • spring-jdbc： 包含DataSource方式事务管理器实现类DataSourceTransactionManager
  • spring-orm： 包含其他持久层框架的事务管理器实现类例如：Hibernate/Jpa等

底层原理

 对事务的操作本来是由数据库进行的，但是为了方便用户进行业务逻辑的控制，Spring对事务进行了扩展实现； 在Spring中，事务是通过AOP代理实现的，对被代理对象的每个方法进行拦截，在方法执行前启动事务，在方法执行完成后根据是否有异常及异常的类型进行提交或回滚。

核心接口： PlatFormTransactionManager

编程式事务和声明式事务

  • 编程式事务： 在代码中硬编码，通过TransactionTemplate或者TransactionManager手动管理事务
  • 声明式事务： 在XML文件中进行配置或通过注解实现

四个特性

  • 原子性： 事务包含的所有数据库操作，要么全部成功，要么失败全部回滚
  • 一致性： 事务必须使数据库从一个一致性状态转换为另一个一致性状态
  • 持久性： 事务一旦提交，对数据的改变是永久性的
  • 隔离性： 当多个用户并发访问数据库时，多个并发事务之间要相互隔离，不被其他事务操作所干扰

事务属性

只读（readonly）

对一个查询操作来说，如果我们把它设置成只读，就能够明确告诉数据库，这个操作不涉及写操作。

// readOnly = true把当前事务设置为只读 默认是false!
@Transactional(readOnly = true)
超时（timeout）

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。设置超时属性，超时回滚，释放资源

@Service
public class StudentService {
 
    @Autowired
    private StudentDao studentDao;
 
    /**
     * timeout设置事务超时时间,单位秒! 默认: -1 永不超时,不限制事务时间!
     */
    @Transactional(readOnly = false,timeout = 3)
    public void changeInfo(){
        studentDao.updateAgeById(100,1);
        //休眠4秒,等待方法超时!
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        studentDao.updateNameById("test1",1);
    }
}
事务异常（rollbackFor）

默认只针对运行时异常，编译时异常不回滚

  • 设置回滚异常（rollbackFor）
/**
 * timeout设置事务超时时间,单位秒! 默认: -1 永不超时,不限制事务时间!
 * rollbackFor = 指定哪些异常才会回滚,默认是 RuntimeException and Error 异常方可回滚!
 * noRollbackFor = 指定哪些异常不会回滚, 默认没有指定,如果指定,应该在rollbackFor的范围内!
 */
@Transactional(readOnly = false,timeout = 3,rollbackFor = Exception.class)
public void changeInfo() throws FileNotFoundException {
    studentDao.updateAgeById(100,1);
    //主动抛出一个检查异常,测试! 发现不会回滚,因为不在rollbackFor的默认范围内! 
    new FileInputStream("xxxx");
    studentDao.updateNameById("test1",1);
}
  • 设置不回滚的异常（norollbackFor）
@Service
public class StudentService {
 
    @Autowired
    private StudentDao studentDao;
 
    /**
     * timeout设置事务超时时间,单位秒! 默认: -1 永不超时,不限制事务时间!
     * rollbackFor = 指定哪些异常才会回滚,默认是 RuntimeException and Error 异常方可回滚!
     * noRollbackFor = 指定哪些异常不会回滚, 默认没有指定,如果指定,应该在rollbackFor的范围内!
     */
    @Transactional(readOnly = false,timeout = 3,rollbackFor = Exception.class,noRollbackFor = FileNotFoundException.class)
    public void changeInfo() throws FileNotFoundException {
        studentDao.updateAgeById(100,1);
        //主动抛出一个检查异常,测试! 发现不会回滚,因为不在rollbackFor的默认范围内!
        new FileInputStream("xxxx");
        studentDao.updateNameById("test1",1);
    }
}
事务隔离级别
  • 读未提交： 事务可以读取未被提交的数据，容易产生脏读、不可重复读和幻读等问题。实现简单但不太安全，一般不用。
  • 读已提交： 事务只能读取已经提交的数据，可以避免脏读问题，但可能引发不可重复读和幻读。
  • 可重复读： 在一个事务中，相同的查询将返回相同的结果集，不管其他事务对数据做了什么修改。可以避免脏读和不可重复读，但仍有幻读的问题。
  • 可串行化： 最高的隔离级别，完全禁止了并发，只允许一个事务执行完毕之后才能执行另一个事务。可以避免以上所有问题，但效率较低，不适用于高并发场景。

隔离级别的设置 （isolation）

@Service
public class StudentService {
 
    @Autowired
    private StudentDao studentDao;
 
    /**
     * timeout设置事务超时时间,单位秒! 默认: -1 永不超时,不限制事务时间!
     * rollbackFor = 指定哪些异常才会回滚,默认是 RuntimeException and Error 异常方可回滚!
     * noRollbackFor = 指定哪些异常不会回滚, 默认没有指定,如果指定,应该在rollbackFor的范围内!
     * isolation = 设置事务的隔离级别,mysql默认是repeatable read!
     */
    @Transactional(readOnly = false,
                   timeout = 3,
                   rollbackFor = Exception.class,
                   noRollbackFor = FileNotFoundException.class,
                   isolation = Isolation.REPEATABLE_READ)
    public void changeInfo() throws FileNotFoundException {
        studentDao.updateAgeById(100,1);
        //主动抛出一个检查异常,测试! 发现不会回滚,因为不在rollbackFor的默认范围内!
        new FileInputStream("xxxx");
        studentDao.updateNameById("test1",1);
    }
}
事务传播行为
  • REQUIRED： 如果存在一个事务，则支持当前事务，不存在，则创建一个新事务
  • REQUIRED_NEW： 开启一个新事务，如果已存在事务，则挂起当前事务
  • SUPPORTS： 如果当前存在事务，则支持当前事务，不存在，则以非事务的方式执行
  • NOT_SUPPORTED： 总是以非事务的方式执行，并挂起任何已存在的事务
  • NAVER： 总是以非事务的方式执行，若已存在事务，则抛出异常
  • NESTED： 如果一个事务已存在，则运行在一个嵌套事务中
  • MANDATORY： 如果已存在事务，则支持当前事务，如果不存在，则抛出异常

 通过XML进行配置

<!--    配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--    <tx:annotation-driven transaction-manager="transactionManager"/>-->
    <tx:advice id="interceptor" transaction-manager="transactionManager">
        <tx:attributes>
<!--            精确-->
            <tx:method name="addUser" propagation="MANDATORY"/>
<!--            半模糊-->
            <tx:method name="update" propagation="REQUIRES_NEW"/>
<!--            全模糊-->
            <tx:method name="*" read-only="true"/>
        </tx:attributes>
    </tx:advice>

 通过注解实现

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NESTED)
@Override
public void updateBook() {
    bookMapper.updateBook();
}

懒加载

  默认为false，Spring会在容器初始化时，解析XML或注解，创建配置为单例的Bean并放入map中，懒加载可以使bean在被调用时才被创建（只对单例的生效，因为多例的bean本来就是在被调用时才会创建）

1、通过XML配置

2、为单个 bean 设置懒加载，通过设置cart启动懒加载，配置lazy-init="true"

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
        
        <bean id="cart" class="cn.tedu.beans.Cart" lazy-init="true"></bean>
</beans>
  • 设置全局懒加载
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd"
        default-lazy-init="true">
        
        <bean id="cart" class="cn.tedu.beans.Cart"></bean>  
</beans>

2、通过注解进行配置（@Lazy）

这个注解可以直接应用@Component或@Bean注解的类或方法上

@Lazy
@Component
public class SomeService {
  //
}
 
@Configuration
public class AppConfig {
@Lazy
@Bean
  public SomeBean someBean() {
    return new SomeBean();
  }
}

注意事项：  在一个非懒加载的类中，注入一个懒加载的类，懒加载可能失效，因为在处理自动注入时，Spring会尝试立即初始化被注入的bean，从而导致懒加载设置被忽略。

文章转载自： 走进舒适圈

原文链接： www.cnblogs.com/codyxz/p/18…

体验地址： www.jnpfsoft.com/?from=001YH

avatar
文章
阅读
粉丝