Spring概述10

https://blog.csdn.net/zhang150114/article/details/90478753

什么是spring?

Spring是一个轻量级JavaEE开发框架最早有Rod Johnson创建目的是为了解决企业级应用开发的**业务逻辑层和其他各层的耦合问题。**它是一个分层的JavaSE/JavaEE full-stack一站式轻量级开源框架为开发Java应用程序提供全面的基础架构支持。Spring负责基础架构因此Java开发者可以专注于应用程序的开发。

Spring最根本的使命是解决企业级应用开发的复杂性即简化Java开发。

Spring可以做很多事情它为企业级开发提供给了丰富的功能但是这些功能的底层都依赖于它的两个核心特性也就是依赖注入dependency injectionDI和面向切面编程aspect-oriented programmingAOP。

为了降低Java开发的复杂性Spring采取了以下4种关键策略

• 基于POJO的轻量级和最小侵入性编程
• 通过依赖注入和面向接口实现松耦合
• 基于切面和惯例进行声明式编程
• 通过切面和模板减少样板式代码。
• Spring提供了AOP技术支持将一些通用任务如安全、事务、日志、权限等进行集中式管理从而提供更好的复用。
• spring对于主流的应用框架提供了集成支持。

Spring框架的设计目标设计理念和核心是什么

Spring设计目标Spring为开发者提供一个一站式轻量级应用开发平台

Spring设计理念在JavaEE开发中支持POJO和JavaBean开发方式使应用面向接口开发充分支持OO面向对象设计方法Spring通过IoC容器实现对象耦合关系的管理并实现依赖反转将对象之间的依赖关系交给IoC容器实现解耦

Spring框架的核心IoC容器和AOP模块。通过IoC容器管理POJO对象以及他们之间的耦合关系通过AOP以动态非侵入的方式增强服务。

IoC让相互协作的组件保持松散的耦合而AOP编程允许你把遍布于应用各层的功能分离出来形成可重用的功能组件。

Spring的优缺点是什么

优点

• 方便解耦简化开发

  Spring就是一个大工厂可以将所有对象的创建和依赖关系的维护交给Spring管理。

• AOP编程的支持

  Spring提供面向切面编程可以方便的实现对程序进行权限拦截、运行监控等功能。

• 声明式事务的支持

  只需要通过配置就可以完成对事务的管理而无需手动编程。

• 方便程序的测试

  Spring对Junit4支持可以通过注解方便的测试Spring程序。

• 方便集成各种优秀框架

  Spring不排斥各种优秀的开源框架其内部提供了对各种优秀框架的直接支持如Struts、Hibernate、MyBatis等。

• 降低JavaEE API的使用难度

  Spring对JavaEE开发中非常难用的一些APIJDBC、JavaMail、远程调用等都提供了封装使这些API应用难度大大降低。

缺点

• Spring明明一个很轻量级的框架却给人感觉大而全
• Spring依赖反射反射影响性能
• 使用门槛升高入门Spring需要较长时间

Spring有哪些应用场景

应用场景JavaEE企业应用开发包括SSH、SSM等

Spring价值

• Spring是非侵入式的框架目标是使应用程序代码对框架依赖最小化
• Spring提供一个一致的编程模型使应用直接使用POJO开发与运行环境隔离开来
• Spring推动应用设计风格向面向对象和面向接口开发转变提高了代码的重用性和可测试性

Spring由哪些模块组成

Spring 总共大约有 20 个模块 由 1300 多个不同的文件构成。 而这些组件被分别整合在核心容器Core Container 、 AOPAspect Oriented Programming和设备支持Instrmentation 、数据访问与集成Data Access/Integeration 、 Web、 消息Messaging 、 Test等 6 个模块中。 以下是 Spring 5 的模块结构图

• spring core提供了框架的基本组成部分包括控制反转Inversion of ControlIOC和依赖注入Dependency InjectionDI功能。核心类库提供IOC服务
• spring beans提供了BeanFactory是工厂模式的一个经典实现Spring将管理对象称为Bean。
• spring context构建于 core 封装包基础上的 context 封装包提供了一种框架式的对象访问方法。 提供框架式的Bean访问方式以及企业级功能JNDI、定时任务等
• spring jdbc提供了一个JDBC的抽象层消除了烦琐的JDBC编码和数据库厂商特有的错误代码解析 用于简化JDBC。
• spring aop提供了面向切面的编程实现让你可以自定义拦截器、切点等。AOP服务
• spring Web提供了针对 Web 开发的集成特性例如文件上传利用 servlet listeners 进行 ioc 容器初始化和针对 Web 的 ApplicationContext。 提供了基本的面向Web的综合特性例如多方文件上传
• spring test主要为测试提供支持的支持使用JUnit或TestNG对Spring组件进行单元测试和集成测试。
• Spring DAO对JDBC的抽象简化了数据访问异常的处理
• Spring ORM对现有的ORM框架的支持
• Spring MVC提供面向Web应用的Model-View-Controller实现。

Spring 框架中都用到了哪些设计模式

1. 工厂模式BeanFactory就是简单工厂模式的体现用来创建对象的实例
2. 单例模式Bean默认为单例模式。
3. 代理模式Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术
4. 模板方法用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。
5. 观察者模式定义对象键一种一对多的依赖关系当一个对象的状态发生改变时所有依赖于它的对象都会得到通知被制动更新如Spring中listener的实现–ApplicationListener。

详细讲解一下核心容器spring context应用上下文) 模块

这是基本的Spring模块提供spring 框架的基础功能BeanFactory 是 任何以spring为基础的应用的核心。Spring 框架建立在此模块之上它使Spring成为一个容器。

Bean 工厂是工厂模式的一个实现提供了控制反转功能用来把应用的配置和依赖从真正的应用代码中分离。最常用的就是org.springframework.beans.factory.xml.XmlBeanFactory 它根据XML文件中的定义加载beans。该容器从XML 文件读取配置元数据并用它去创建一个完全配置的系统或应用。

Spring框架中有哪些不同类型的事件

Spring 提供了以下5种标准的事件

1. 上下文更新事件ContextRefreshedEvent在调用ConfigurableApplicationContext 接口中的refresh()方法时被触发。
2. 上下文开始事件ContextStartedEvent当容器调用ConfigurableApplicationContext的Start()方法开始/重新开始容器时触发该事件。
3. 上下文停止事件ContextStoppedEvent当容器调用ConfigurableApplicationContext的Stop()方法停止容器时触发该事件。
4. 上下文关闭事件ContextClosedEvent当ApplicationContext被关闭时触发该事件。容器被关闭时其管理的所有单例Bean都被销毁。
5. 请求处理事件RequestHandledEvent在Web应用中当一个http请求request结束触发该事件。如果一个bean实现了ApplicationListener接口当一个ApplicationEvent 被发布以后bean会自动被通知。

Spring 应用程序有哪些不同组件

Spring 应用一般有以下组件

• 接口 - 定义功能。
• Bean 类 - 它包含属性setter 和 getter 方法函数等。
• Bean 配置文件 - 包含类的信息以及如何配置它们。
• Spring 面向切面编程AOP - 提供面向切面编程的功能。
• 用户程序 - 它使用接口。

使用 Spring 有哪些方式

使用 Spring 有以下方式

• 作为一个成熟的 Spring Web 应用程序。
• 作为第三方 Web 框架使用 Spring Frameworks 中间层。
• 作为企业级 Java Bean它可以包装现有的 POJOPlain Old Java Objects。
• 用于远程使用。

Spring控制反转(IOC)13

什么是Spring IOC 容器

https://www.cnblogs.com/xdp-gacl/p/4249939.html

https://blog.csdn.net/dage_188/article/details/19620345?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-0&spm=1001.2101.3001.4242

控制反转即IoC (Inversion of Control)它把传统上由程序代码直接操控的对象的调用权交给容器通过容器来实现对象组件的装配和管理。所谓的“控制反转”概念就是对组件对象控制权的转移从程序代码本身转移到了外部容器。 降低代码的耦合度

Spring IOC 负责创建对象管理对象通过依赖注入DI装配对象配置对象并且管理这些对象的整个生命周期。

控制反转(IoC)有什么作用

• 管理对象的创建和依赖关系的维护。对象的创建并不是一件简单的事在对象关系比较复杂时如果依赖关系需要程序猿来维护的话那是相当头疼的
• 解耦由容器去维护具体的对象
• 托管了类的产生过程比如我们需要在类的产生过程中做一些处理最直接的例子就是代理如果有容器程序可以把这部分处理交给容器应用程序则无需去关心类是如何完成代理的

底层IOC原理

1. xml解析
2. 工厂模式
3. 反射

IOC的优点是什么

• IOC 或 依赖注入把应用的代码量降到最低。
• 它使应用容易测试单元测试不再需要单例和JNDI查找机制。
• 最小的代价和最小的侵入性使松散耦合得以实现。
• IOC容器支持加载服务时的饿汉式初始化和懒加载。

Spring IoC 的实现机制

Spring 中的 IoC 的实现原理就是工厂模式加反射机制。 IOC容器的底层就是对象工厂

示例

interface Fruit {
   public abstract void eat();
 }

class Apple implements Fruit {
    public void eat(){
        System.out.println("Apple");
    }
}

class Orange implements Fruit {
    public void eat(){
        System.out.println("Orange");
    }
}

class Factory {
    public static Fruit getInstance(String ClassName) {
        Fruit f=null;
        try {
            f=(Fruit)Class.forName(ClassName).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
}

class Client {
    public static void main(String[] a) {
        Fruit f=Factory.getInstance("io.github.dunwu.spring.Apple");
        if(f!=null){
            f.eat();
        }
    }
}

Spring 的 IoC支持哪些功能

Spring 的 IoC 设计支持以下功能

• 依赖注入
• 依赖检查
• 自动装配
• 支持集合
• 指定初始化方法和销毁方法
• 支持回调某些方法但是需要实现 Spring 接口略有侵入

其中最重要的就是依赖注入从 XML 的配置上说即 ref 标签。对应 Spring RuntimeBeanReference 对象。

对于 IoC 来说最重要的就是容器。容器管理着 Bean 的生命周期控制着 Bean 的依赖注入。

BeanFactory 和 ApplicationContext有什么区别

BeanFactory和ApplicationContext是Spring的两大核心接口都可以当做Spring的容器。其中ApplicationContext是BeanFactory的子接口。

依赖关系

BeanFactory是Spring里面最底层的接口包含了各种Bean的定义读取bean配置文档管理bean的加载、实例化控制bean的生命周期维护bean之间的依赖关系。

ApplicationContext接口作为BeanFactory的派生除了提供BeanFactory所具有的功能外还提供了更完整的框架功能

• 继承MessageSource因此支持国际化。
• 统一的资源文件访问方式。
• 提供在监听器中注册bean的事件。
• 同时加载多个配置文件。
• 载入多个有继承关系上下文 使得每一个上下文都专注于一个特定的层次比如应用的web层。

加载方式

BeanFactroy采用的是延迟加载形式来注入Bean的即只有在使用到某个Bean时(调用getBean())才对该Bean进行加载实例化。这样我们就不能发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入BeanFacotry加载后直至第一次使用调用getBean方法才会抛出异常。

ApplicationContext它是在容器启动时一次性创建了所有的Bean。这样在容器启动时我们就可以发现Spring中存在的配置错误这样有利于检查所依赖属性是否注入。 ApplicationContext启动后预载入所有的单实例Bean通过预载入单实例bean ,确保当你需要的时候你就不用等待因为它们已经创建好了。

相对于基本的BeanFactoryApplicationContext 唯一的不足是占用内存空间。当应用程序配置Bean较多时程序启动较慢。

*BeanFactory*********应用启动的时候占用资源很少系统运行速度会相对来说慢一些。而且有可能会出现空指针异常的错误

*ApplicationContext*********应用启动的时候占用资源较多系统运行速度会相对来说快一些。可以尽早发现系统的配置问题

创建方式

BeanFactory通常以编程的方式被创建ApplicationContext还能以声明的方式创建如使用ContextLoader。

注册方式

BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用但两者之间的区别是BeanFactory需要手动注册而ApplicationContext则是自动注册。

补充BeanFactory和factoryBean的区别

· ****BeanFactory****是个Factory也就是IOC容器或对象工厂在Spring中所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的提供了实例化对象和拿对象的功能。

· ****FactoryBean****是个Bean既****FactoryBean*****接口实现这个接口可以自定义实例化bean的逻辑*

Spring 如何设计容器的BeanFactory和ApplicationContext的关系详解

Spring 作者 Rod Johnson 设计了两个接口用以表示容器。

• BeanFactory
• ApplicationContext

BeanFactory 简单粗暴可以理解为就是个 HashMapKey 是 BeanNameValue 是 Bean 实例。通常只提供注册put获取get这两个功能。我们可以称之为 “低级容器”。

ApplicationContext 可以称之为 “高级容器”。因为他比 BeanFactory 多了更多的功能。他继承了多个接口。因此具备了更多的功能。例如资源的获取支持多种消息例如 JSP tag 的支持对 BeanFactory 多了工具级别的支持等待。所以你看他的名字已经不是 BeanFactory 之类的工厂了而是 “应用上下文” 代表着整个大容器的所有功能。该接口定义了一个 refresh 方法此方法是所有阅读 Spring 源码的人的最熟悉的方法用于刷新整个容器即重新加载/刷新所有的 bean。

当然除了这两个大接口还有其他的辅助接口这里就不介绍他们了。

BeanFactory和ApplicationContext的关系

为了更直观的展示 “低级容器” 和 “高级容器” 的关系这里通过常用的 ClassPathXmlApplicationContext 类来展示整个容器的层级 UML 关系。

有点复杂 先不要慌我来解释一下。

最上面的是 BeanFactory下面的 3 个绿色的都是功能扩展接口这里就不展开讲。

看下面的隶属 ApplicationContext 粉红色的 “高级容器”依赖着 “低级容器”这里说的是依赖不是继承哦。他依赖着 “低级容器” 的 getBean 功能。而高级容器有更多的功能支持不同的信息源头可以访问文件资源支持应用事件Observer 模式。

通常用户看到的就是 “高级容器”。 但 BeanFactory 也非常够用啦

左边灰色区域的是 “低级容器” 只负载加载 Bean获取 Bean。容器其他的高级功能是没有的。例如上图画的 refresh 刷新 Bean 工厂所有配置生命周期事件回调等。

小结

说了这么多不知道你有没有理解Spring IoC 这里小结一下IoC 在 Spring 里只需要低级容器就可以实现2 个步骤

1. 加载配置文件解析成 BeanDefinition 放在 Map 里。
2. 调用 getBean 的时候从 BeanDefinition 所属的 Map 里拿出 Class 对象进行实例化同时如果有依赖关系将递归调用 getBean 方法 —— 完成依赖注入。

上面就是 Spring 低级容器BeanFactory的 IoC。

至于高级容器 ApplicationContext他包含了低级容器的功能当他执行 refresh 模板方法的时候将刷新整个容器的 Bean。同时其作为高级容器包含了太多的功能。一句话他不仅仅是 IoC。他支持不同信息源头支持 BeanFactory 工具类支持层级容器支持访问文件资源支持事件发布通知支持接口回调等等。

ApplicationContext通常的实现是什么

FileSystemXmlApplicationContext 此容器从一个XML文件中加载beans的定义XML Bean 配置文件的全路径名必须提供给它的构造函数。硬盘路径

ClassPathXmlApplicationContext此容器也从一个XML文件中加载beans的定义这里你需要正确设置classpath因为这个容器将在classpath里找bean配置。src classpath

WebXmlApplicationContext此容器加载一个XML文件此文件定义了一个WEB应用的所有bean。

什么是Spring的依赖注入

控制反转IoC是一个很大的概念可以用不同的方式来实现。其主要实现方式有两种依赖注入和依赖查找

依赖注入相对于IoC而言依赖注入(DI)更加准确地描述了IoC的设计理念。所谓依赖注入Dependency Injection即组件之间的依赖关系由容器在应用系统运行期来决定也就是由容器动态地将某种依赖关系的目标对象实例注入到应用系统中的各个关联的组件之中。组件不做定位查询只提供普通的Java方法让容器去决定依赖关系。

提升组件重用的频率并为系统搭建一个灵活、可扩展的平台。

IoC 和 DI 的关系
  IoC 是 Spring 中一个极为重要的概念而 DI 则是实现 IoC 的方法和手段。

依赖注入的基本原则

依赖注入的基本原则是应用组件不应该负责查找资源或者其他依赖的协作对象。配置对象的工作应该由IoC容器负责“查找资源”的逻辑应该从应用组件的代码中抽取出来交给IoC容器负责。容器全权负责组件的装配它会把符合依赖关系的对象通过属性JavaBean中的setter或者是构造器传递给需要的对象。

依赖注入有什么优势

依赖注入之所以更流行是因为它是一种更可取的方式让容器全权负责依赖查询受管组件只需要暴露JavaBean的setter方法或者带参数的构造器或者接口使容器可以在初始化时组装对象的依赖关系。其与依赖查找方式相比主要优势为

• 查找定位操作与应用代码完全无关。
• 不依赖于容器的API可以很容易地在任何容器以外使用应用对象。
• 不需要特殊的接口绝大多数对象可以做到完全不必依赖容器。

有哪些不同类型的依赖注入实现方式

依赖注入是时下最流行的IoC实现方式依赖注入分为接口注入Interface InjectionSetter方法注入Setter Injection和构造器注入Constructor Injection三种方式。其中接口注入由于在灵活性和易用性比较差现在从Spring4开始已被废弃。

构造器依赖注入构造器依赖注入通过容器触发一个类的构造器来实现的该类有一系列参数每个参数代表一个对其他类的依赖。

2.构造方法注入

Java 代码

public class UserController {
    private UserService userService;
    public UserController(UserService userService){
        this.userService = userService;
    }
}

XML 配置

<bean name="userController" class="com.learning.controller.UserController">  
    <!-- 依赖注入 -->  
    <constructor-arg ref="userService"></constructor-arg>  
</bean>  
<bean name="userService" class="com.learning.dao.impl.UserServiceImpl"></bean>  

3.注解注入

@Controller
public class UserController {
    // 使用注解自动注入
    @Autowired()
    private UserService userService;
    // do something
}
// 创建依赖对象
@Service
public class UserService {
   // do something 
}

Setter方法注入Setter方法注入是容器通过调用无参构造器或无参static工厂 方法实例化bean之后调用该bean的setter方法即实现了基于setter的依赖注入。

Java 代码

public class UserController {
    // 注入 UserService 对象
    private UserService userService;
    public void setUserService(UserService userService){
        this.userService = userService;
    }
}

XML 配置

<bean name="userController" class="com.learning.controller.UserController">  
    <!-- 依赖注入 -->  
    <property name="userService" ref="userService"></property>  
</bean>  
<bean name="userService" class="com.learning.dao.impl.UserServiceImpl"></bean>

Bean 标签的常用属性说明

• id为实例化对象起名称根据 id 值可以得到我们配置的实例化对象id 属性的名称原则上可以任意命名但是能包含任何特殊符号
• class创建对象所在类的全路径
• name功能和 id 属性一样但是现在一般不用与 id 的区别在于name 属性值里可以包含特殊符号但是 id 不可以
• scope一般最常用的有两个值 Singleton单例模式整个应用程序只创建 bean 的一个实例Prototype原型模式每次注入都会创建一个新的 bean 实例Spring 默认的是单例模式。

cp名称空间注入了解即可

<!--1、添加p名称空间在配置文件头部-->
<?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:p="http://www.springframework.org/schema/p"		<!--在这里添加一行p-->

<!--2、在bean标签进行属性注入算是set方式注入的简化操作-->
    <bean id="book" class="com.atguigu.spring5.Book" p:bname="very" p:bauthor="good">
    </bean>

4、注入空值和特殊符号

<bean id="book" class="com.atguigu.spring5.Book">
    <!--1null值-->
    <property name="address">
        <null/><!--属性里边添加一个null标签-->
    </property>
    
    <!--2特殊符号赋值-->
     <!--属性值包含特殊符号
       a 把<>进行转义 &lt; &gt;
       b 把带特殊符号内容写到CDATA
      -->
        <property name="address">
            <value><![CDATA[<<南京>>]]></value>
        </property>
</bean>

<!--第一步在 spring 配置文件中引入名称空间 util-->
<?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:util="http://www.springframework.org/schema/util" <!--添加util名称空间-->
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">  <!--添加util名称空间-->
    
<!--第二步使用 util 标签完成 list 集合注入提取-->
<!--把集合注入部分提取出来-->
 <!--1 提取list集合类型属性注入-->
    <util:list id="bookList">
        <value>易筋经</value>
        <value>九阴真经</value>
        <value>九阳神功</value>
    </util:list>

 <!--2 提取list集合类型属性注入使用-->
    <bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype">
        <property name="list" ref="bookList"></property>
    </bean>

构造器依赖注入和 Setter方法注入的区别

两种依赖方式都可以使用构造器注入和Setter方法注入。最好的解决方案是用构造器参数实现强制依赖setter方法实现可选依赖。

Spring Beans19

什么是Spring beans

Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC容器初始化装配和管理。这些beans通过容器中配置的元数据创建。比如以XML文件中 的形式定义。

一个 Spring Bean 定义 包含什么

一个Spring Bean 的定义包含容器必须的所有配置元数据包括如何创建一个bean它的生命周期详情及它的依赖。

如何给Spring 容器提供配置元数据Spring有几种配置方式

这里有三种重要的方法给Spring 容器提供配置元数据。

• XML配置文件。
• 基于注解的配置。
• 基于java的配置。

Spring配置文件包含了哪些信息

Spring配置文件是个XML 文件这个文件包含了类信息描述了如何配置它们以及如何相互调用。

Spring基于xml注入bean的几种方式

1. Set方法注入
2. 构造器注入①通过index设置参数的位置②通过type设置参数类型
3. 静态工厂注入
4. 实例工厂

IOC操作Bean 管理

什么是Bean管理

1. Spring创建对象
2. Spring注入属性

1、Spring 有两种类型 bean一种普通 bean另外一种工厂 beanFactoryBean

2、普通 bean在配置文件中定义 bean 类型就是返回类型

3、工厂 bean在配置文件定义 bean 类型可以和返回类型不一样 第一步 创建类让这个类作为工厂 bean实现接口 FactoryBean 第二步 实现接口里面的方法在实现的方法中定义返回的 bean 类型

你怎样定义类的作用域

当定义一个 在Spring里我们还能给这个bean声明一个作用域。它可以通过bean 定义中的scope属性来定义。如当Spring要在需要的时候每次生产一个新的bean实例bean的scope属性被指定为prototype。另一方面一个bean每次使用的时候必须返回同一个实例这个bean的scope 属性 必须设为 singleton。

解释Spring支持的几种bean的作用域

Spring框架支持以下五种bean的作用域

• singleton : bean在每个Spring ioc 容器中只有一个实例。单例的模式由BeanFactory自身来维护。
• prototype一个bean的定义可以有多个实例。
• request每次http请求都会创建一个bean该作用域仅在基于web的Spring ApplicationContext情形下有效。在请求完成以后bean会失效并被垃圾回收器回收。
• session在一个HTTP Session中一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。在session过期后bean会随之失效。
• global-session在一个全局的HTTP Session中一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。

注意 缺省的Spring bean 的作用域是Singleton。使用 prototype 作用域需要慎重的思考因为频繁创建和销毁 bean 会带来很大的性能开销。

Spring框架中的单例bean是线程安全的吗

不是Spring框架中的单例bean不是线程安全的。

spring 中的 bean 默认是单例模式spring 框架并没有对单例 bean 进行多线程的封装处理。

实际上大部分时候 spring bean 无状态的比如 dao 类所有某种程度上来说 bean 也是安全的但如果 bean 有状态的话比如 view model 对象那就要开发者自己去保证线程安全了最简单的就是改变 bean 的作用域把“singleton”变更为“prototype”这样请求 bean 相当于 new Bean()了所以就可以保证线程安全了。

• 有状态就是有数据存储功能。
• 无状态就是不会保存数据。

spring的controller是单例还是多例的怎么保证并发的线程安全

单例

解决方案

不要在controller中定义成员变量

将controller通过@Scope“prototype”变为多例

在controller中使用ThreadLocal变量

Spring如何处理线程并发问题

在一般情况下只有无状态的Bean才可以在多线程环境下共享在Spring中绝大部分Bean都可以声明为singleton作用域因为Spring对一些Bean中非线程安全状态采用ThreadLocal进行处理解决线程安全问题。

ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。同步机制采用了“时间换空间”的方式仅提供一份变量不同的线程在访问前需要获取锁没获得锁的线程则需要排队。而ThreadLocal采用了“空间换时间”的方式。

ThreadLocal会为每一个线程提供一个独立的变量副本从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象在编写多线程代码时可以把不安全的变量封装进ThreadLocal。

解释Spring框架中bean的生命周期

在传统的Java应用中bean的生命周期很简单。使用Java关键字new进行bean实例化然后该bean就可以使用了。一旦该bean不再被使用则由Java自动进行垃圾回收。相比之下Spring容器中的bean的生命周期就显得相对复杂多了。正确理解Spring bean的生命周期非常重要因为你或许要利用Spring提供的扩展点来自定义bean的创建过程。下图展示了bean装载到Spring应用上下文中的一个典型的生命周期过程。

bean在Spring容器中从创建到销毁经历了若干阶段每一阶段都可以针对Spring如何管理bean进行个性化定制。

正如你所见在bean准备就绪之前bean工厂执行了若干启动步骤。

我们对上图进行详细描述

Spring对bean进行实例化

Spring将值和bean的引用注入到bean对应的属性中

如果bean实现了BeanNameAware接口Spring将**bean的ID传递给setBean-Name()**方法

如果bean实现了BeanFactoryAware接口Spring将调用setBeanFactory()方法将BeanFactory容器实例传入

如果bean实现了ApplicationContextAware接口Spring将调用setApplicationContext()方法将bean所在的应用上下文的引用传入进来

如果bean实现了BeanPostProcessor接口Spring将调用它们的**post-ProcessBeforeInitialization()**方法

如果bean实现了InitializingBean接口Spring将调用它们的**after-PropertiesSet()**方法。类似地如果bean使用initmethod声明了初始化方法该方法也会被调用

如果bean实现了BeanPostProcessor接口Spring将调用它们的post-ProcessAfterInitialization()方法

此时bean已经准备就绪可以被应用程序使用了它们将一直驻留在应用上下文中直到该应用上下文被销毁

如果bean实现了DisposableBean接口Spring将调用它的destroy()接口方法。同样如果bean使用destroy-method声明了销毁方法该方法也会被调用。

现在你已经了解了如何创建和加载一个Spring容器。但是一个空的容器并没有太大的价值在你把东西放进去之前它里面什么都没有。为了从Spring的DI(依赖注入)中受益我们必须将应用对象装配进Spring容器中。

哪些是重要的bean生命周期方法 你能重载它们吗

有两个重要的bean 生命周期方法第一个是setup 它是在容器加载bean的时候被调用。第二个方法是 teardown 它是在容器卸载类的时候被调用。

bean 标签有两个重要的属性init-method和destroy-method。用它们你可以自己定制初始化和注销方法。它们也有相应的注解@PostConstruct和@PreDestroy。

3、IOC 操作 Bean 管理bean 生命周期

1、生命周期 从对象创建到对象销毁的过程

2、bean 生命周期

1通过构造器创建 bean 实例无参数构造

2为 bean 的属性设置值和对其他 bean 引用调用 set 方法

3调用 bean 的初始化的方法需要进行配置初始化的方法

4bean 可以使用了对象获取到了

5当容器关闭时候调用 bean 的销毁的方法需要进行配置销毁的方法

1. 实例化Bean Instantiation

2. 属性赋值 Populate

3. 初始化 Initialization

4. 销毁 Destruction

5. https://www.jianshu.com/p/1dec08d290c1

   https://www.zhihu.com/question/38597960

        public class Orders {
         //无参数构造
         public Orders() {
         System.out.println("第一步 执行无参数构造创建 bean 实例");
         }
         private String oname;
         public void setOname(String oname) {
         this.oname = oname;
         System.out.println("第二步 调用 set 方法设置属性值");
         }
         //创建执行的初始化的方法
         public void initMethod() {
         System.out.println("第三步 执行初始化的方法");
         }
         //创建执行的销毁的方法
         public void destroyMethod() {
         System.out.println("第五步 执行销毁的方法");
         }
        }

public class MyBeanPost implements BeanPostProcessor {//创建后置处理器实现类
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return bean;
    }
}
123456789101112
<!--配置文件的bean参数配置-->
<bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">	<!--配置初始化方法和销毁方法-->
    <property name="oname" value="手机"></property><!--这里就是通过set方式注入属性赋值-->
</bean>

<!--配置后置处理器 对xml中的所有bean 都有效-->
<bean id="myBeanPost" class="com.atguigu.spring5.bean.MyBeanPost"></bean>

 @Test
 public void testBean3() {
// ApplicationContext context =
// new ClassPathXmlApplicationContext("bean4.xml");
 ClassPathXmlApplicationContext context =
 new ClassPathXmlApplicationContext("bean4.xml");
 Orders orders = context.getBean("orders", Orders.class);
 System.out.println("第四步 获取创建 bean 实例对象");
 System.out.println(orders);
 //手动让 bean 实例销毁
 context.close();
 }

4、bean 的后置处理器bean 生命周期有七步 正常生命周期为五步而配置后置处理器后为七步

1通过构造器创建 bean 实例无参数构造

2为 bean 的属性设置值和对其他 bean 引用调用 set 方法

3把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization

4调用 bean 的初始化的方法需要进行配置初始化的方法

5把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization

6bean 可以使用了对象获取到了

7当容器关闭时候调用 bean 的销毁的方法需要进行配置销毁的方法

在 Spring中如何注入一个java集合

Spring提供以下几种集合的配置元素

类型用于注入一列值允许有相同的值。

类型用于注入一组值不允许有相同的值。

类型用于注入一组键值对键和值都可以为任意类型。

类型用于注入一组键值对键和值都只能为String类型。

什么是bean装配

装配或bean 装配是指在Spring 容器中把bean组装到一起前提是容器需要知道bean的依赖关系如何通过依赖注入来把它们装配到一起。

什么是bean的自动装配

在Spring框架中在配置文件中设定bean的依赖关系是一个很好的机制Spring 容器能够自动装配相互合作的bean这意味着容器不需要和配置能通过Bean工厂自动处理bean之间的协作。这意味着 Spring可以通过向Bean Factory中注入的方式自动搞定bean之间的依赖关系。自动装配可以设置在每个bean上也可以设定在特定的bean上。

解释不同方式的自动装配spring 自动装配 bean 有哪些方式

在spring中对象无需自己查找或创建与其关联的其他对象由容器负责把需要相互协作的对象引用赋予各个对象使用autowire来配置自动装载模式。

在Spring框架xml配置中共有5种自动装配

• no默认的方式是不进行自动装配的通过手工设置ref属性来进行装配bean。
• byName通过bean的名称进行自动装配如果一个bean的 property 与另一bean 的name 相同就进行自动装配。
• byType通过参数的数据类型进行自动装配。
• constructor利用构造函数进行装配并且构造函数的参数通过byType进行装配。
• autodetect自动探测如果有构造方法通过 construct的方式自动装配否则使用 byType的方式自动装配。

使用@Autowired注解自动装配的过程是怎样的

使用@Autowired注解来自动装配指定的bean。在使用@Autowired注解之前需要在Spring配置文件进行配置

<context:annotation-config />。

在启动spring IoC时容器自动装载了一个AutowiredAnnotationBeanPostProcessor后置处理器当容器扫描到@Autowied、@Resource或@Inject时就会在IoC容器自动查找需要的bean并装配给该对象的属性。在使用@Autowired时首先在容器中查询对应类型的bean

• 如果查询结果刚好为一个就将该bean装配给@Autowired指定的数据
• 如果查询的结果不止一个那么@Autowired会根据名称来查找
• 如果上述查找的结果为空那么会抛出异常。解决方法时使用required=false。

自动装配有哪些局限性

自动装配的局限性是

重写你仍需用 和 配置来定义依赖意味着总要重写自动装配。

基本数据类型你不能自动装配简单的属性如基本数据类型String字符串和类。

模糊特性自动装配不如显式装配精确如果有可能建议使用显式装配。

Spring注解8

什么是基于Java的Spring注解配置? 给一些注解的例子

基于Java的配置允许你在少量的Java注解的帮助下进行你的大部分Spring配置而非通过XML文件。

以@Configuration 注解为例它用来标记类可以当做一个bean的定义被Spring IOC容器使用。

另一个例子是@Bean注解它表示此方法将要返回一个对象作为一个bean注册进Spring应用上下文。

@Configuration
public class StudentConfig {
    @Bean
    public StudentBean myStudent() {
        return new StudentBean();
    }
}

怎样开启注解装配

注解装配在默认情况下是不开启的为了使用注解装配我们必须在Spring配置文件中配置 <context:annotation-config/>元素。

@Component, @Controller, @Repository, @Service 有何区别

@Component这将 java 类标记为 bean。它是任何 Spring 管理组件的通用构造类型。spring 的组件扫描机制现在可以将其拾取并将其拉入应用程序环境中。

@Controller这将一个类标记为 Spring Web MVC 控制器。标有它的 Bean 会自动导入到 IoC 容器中。

@Service此注解是组件注解的特化。它不会对 @Component 注解提供任何其他行为。您可以在服务层类中使用 @Service 而不是 @Component因为它以更好的方式指定了意图。

@Repository这个注解是具有类似用途和功能的 @Component 注解的特化。它为 DAO 提供了额外的好处。它将 DAO 导入 IoC 容器并使未经检查的异常有资格转换为 Spring DataAccessException。

@Required 注解有什么作用

这个注解表明bean的属性必须在配置的时候设置通过一个bean定义的显式的属性值或通过自动装配若@Required注解的bean属性未被设置容器将抛出BeanInitializationException。示例

public class Employee {
    private String name;
    @Required
    public void setName(String name){
        this.name=name;
    }
    public string getName(){
        return name;
    }
}

@Autowired 注解有什么作用

@Autowired默认是按照类型装配注入的默认情况下它要求依赖对象必须存在可以设置它required属性为false。@Autowired 注解提供了更细粒度的控制包括在何处以及如何完成自动装配。它的用法和@Required一样修饰setter方法、构造器、属性或者具有任意名称和/或多个参数的PN方法。

public class Employee {
    private String name;
    @Autowired
    public void setName(String name) {
        this.name=name;
    }
    public string getName(){
        return name;
    }
}

@Autowired和@Resource之间的区别

@Autowired可用于构造函数、成员变量、Setter方法

@Autowired和@Resource之间的区别

• @Autowired默认是按照类型装配注入的默认情况下它要求依赖对象必须存在可以设置它required属性为false。 Spring的
• @Resource默认是按照名称来装配注入的只有当找不到与名称匹配的bean才会按照类型来装配注入。java扩展包中

@Qualifier 注解有什么作用

当您创建多个相同类型的 bean 并希望仅使用属性装配其中一个 bean 时您可以使用@Qualifier 注解和 @Autowired 通过指定应该装配哪个确切的 bean 来消除歧义。

@RequestMapping 注解有什么用

@RequestMapping 注解用于将特定 HTTP 请求方法映射到将处理相应请求的控制器中的特定类/方法。此注释可应用于两个级别

• 类级别映射请求的 URL
• 方法级别映射 URL 以及 HTTP 请求方法

Spring数据访问14

解释对象/关系映射集成模块

Spring 通过提供ORM模块支持我们在直接JDBC之上使用一个对象/关系映射映射(ORM)工具Spring 支持集成主流的ORM框架如HiberateJDO和 iBATISJPATopLinkJDOOJB 。Spring的事务管理同样支持以上所有ORM框架及JDBC。

在Spring框架中如何更有效地使用JDBC

使用Spring JDBC 框架资源管理和错误处理的代价都会被减轻。所以开发者只需写statements 和 queries从数据存取数据JDBC也可以在Spring框架提供的模板类的帮助下更有效地被使用这个模板叫JdbcTemplate

解释JDBC抽象和DAO模块

通过使用JDBC抽象和DAO模块保证数据库代码的简洁并能避免数据库资源错误关闭导致的问题它在各种不同的数据库的错误信息之上提供了一个统一的异常访问层。它还利用Spring的AOP 模块给Spring应用中的对象提供事务管理服务。

spring DAO 有什么用

Spring DAO数据访问对象 使得 JDBCHibernate 或 JDO 这样的数据访问技术更容易以一种统一的方式工作。这使得用户容易在持久性技术之间切换。它还允许您在编写代码时无需考虑捕获每种技术不同的异常。

spring JDBC API 中存在哪些类

JdbcTemplate

SimpleJdbcTemplate

NamedParameterJdbcTemplate

SimpleJdbcInsert

SimpleJdbcCall

JdbcTemplate是什么

JdbcTemplate 类提供了很多便利的方法解决诸如把数据库数据转变成基本数据类型或对象执行写好的或可调用的数据库操作语句提供自定义的数据错误处理。

Spring支持的事务管理类型 spring 事务实现方式有哪些

Spring支持两种类型的事务管理

编程式事务管理这意味你通过编程的方式管理事务给你带来极大的灵活性但是难维护。TransactionTemplate。

声明式事务管理这意味着你可以将业务代码和事务管理分离你只需用注解和XML配置来管理事务。其本质是通过AOP功能对方法前后进行拦截将事务处理的功能编织到拦截的方法中也就是在目标方法开始之前加入一个事务在执行完目标方法之后根据执行情况提交或者回滚事务。

声明式事务最大的优点就是不需要在业务逻辑代码中掺杂事务管理的代码只需在配置文件中做相关的事务规则声明或通过@Transactional注解的方式便可以将事务规则应用到业务逻辑中。

声明式事务管理要优于编程式事务管理这正是spring倡导的非侵入式的开发方式使业务代码不受污染只要加上注解就可以获得完全的事务支持。唯一不足地方是最细粒度只能作用到方法级别无法做到像编程式事务那样可以作用到代码块级别。

Spring事务的实现方式和实现原理

Spring事务的本质其实就是数据库对事务的支持没有数据库的事务支持spring是无法提供事务功能的。真正的数据库层的事务提交和回滚是通过binlog或者undo log实现的。

*声明式事务管理使用了AOP面向切面编程实现的本质就是在目标方法执行前后进行拦截。在目标方法执行前加入或创建一个事务在执行方法执行后根据实际情况选择提交或是回滚事务*。

Spring事务管理具体是由****PlatformTransactionManagerTransactionDefinitionTransactionStatus****三个接口共同完成的

*1. PlatformTransactionManager*事务管理器–主要用于平台相关事务的管理

主要有三个方法

· commit 事务提交

· rollback 事务回滚

· getTransaction 获取事务状态。

*2. TransactionDefinition*事务定义信息–用来定义事务相关的属性给事务管理器PlatformTransactionManager使用

这个接口有下面四个主要方法

· getIsolationLevel获取隔离级别

· getPropagationBehavior获取传播行为

· getTimeout获取超时时间

· isReadOnly是否只读保存、更新、删除时属性变为false–可读写查询时为true–只读

事务管理器能够根据这个返回值进行优化这些事务的配置信息都可以通过配置文件进行配置。

*3. TransactionStatus*事务具体运行状态–事务管理过程中每个时间点事务的状态信息。

例如它的几个方法

· hasSavepoint()返回这个事务内部是否包含一个保存点

· isCompleted()返回该事务是否已完成也就是说是否已经提交或回滚

· isNewTransaction()判断当前事务是否是一个新事务

说一下Spring的事务传播行为

spring事务的传播行为说的是当多个事务同时存在的时候spring如何处理这些事务的行为。

当事务方法被另一个事务方法调用时, 必须指定事务应该如何传播. 例如: 方法可能继续在现有事务中运行, 也可能开启一个新事务, 并在自己的事务中运行.
事务的传播行为可以由传播属性指定.

① PROPAGATION_REQUIRED如果当前没有事务就创建一个新事务如果当前存在事务就加入该事务该设置是最常用的设置。

② PROPAGATION_SUPPORTS支持当前事务如果当前存在事务就加入该事务如果当前不存在事务就以非事务执行。

③ PROPAGATION_MANDATORY支持当前事务如果当前存在事务就加入该事务如果当前不存在事务就抛出异常。

④ PROPAGATION_REQUIRES_NEW创建新事务无论当前存不存在事务都创建新事务。

⑤ PROPAGATION_NOT_SUPPORTED以非事务方式执行操作如果当前存在事务就把当前事务挂起。

⑥ PROPAGATION_NEVER以非事务方式执行如果当前存在事务则抛出异常。

⑦ PROPAGATION_NESTED如果当前存在事务则在嵌套事务内执行。如果当前没有事务则按REQUIRED属性执行。

说一下 spring 的事务隔离

spring 有五大隔离级别默认值为 ISOLATION_DEFAULT使用数据库的设置其他四个隔离级别和数据库的隔离级别一致

1. ISOLATION_DEFAULT用底层数据库的设置隔离级别数据库设置的是什么我就用什么
2. ISOLATION_READ_UNCOMMITTED未提交读最低隔离级别、事务未提交前就可被其他事务读取会出现幻读、脏读、不可重复读
3. ISOLATION_READ_COMMITTED提交读一个事务提交后才能被其他事务读取到会造成幻读、不可重复读SQL server 的默认级别
4. ISOLATION_REPEATABLE_READ可重复读保证多次读取同一个数据时其值都和事务开始时候的内容是一致禁止读取到别的事务未提交的数据会造成幻读MySQL 的默认级别
5. ISOLATION_SERIALIZABLE序列化代价最高最可靠的隔离级别该隔离级别能防止脏读、不可重复读、幻读。

脏读 表示一个事务能够读取另一个事务中还未提交的数据。比如某个事务尝试插入记录 A此时该事务还未提交然后另一个事务尝试读取到了记录 A。

不可重复读 是指在一个事务内多次读同一数据。

幻读 指同一个事务内多次查询返回的结果集不一样。比如同一个事务 A 第一次查询时候有 n 条记录但是第二次同等条件下查询却有 n+1 条记录这就好像产生了幻觉。发生幻读的原因也是另外一个事务新增或者删除或者修改了第一个事务结果集里面的数据同一个记录的数据内容被修改了所有数据行的记录就变多或者变少了。

*事务回滚属性*

· 默认情况下只有未检查异常(RuntimeException和Error类型的异常)会导致事务回滚. 而受检查异常不会.

· 事务的回滚规则可以通过@Transactional 注解的 rollbackFor 和 noRollbackFor 属性来定义这两个属性被声明为 Class[] 类型的, 因此可以为这两个属性指定多个异常类。

· rollbackFor: 遇到时必须进行回滚

· noRollbackFor: 一组异常类遇到时必须不回滚

Spring框架的事务管理有哪些优点

• 为不同的事务API 如 JTAJDBCHibernateJPA 和JDO提供一个不变的编程模式。
• 为编程式事务管理提供了一套简单的API而不是一些复杂的事务API
• 支持声明式事务管理。
• 和Spring各种数据访问抽象层很好得集成。

你更倾向用那种事务管理类型

大多数Spring框架的用户选择声明式事务管理因为它对应用代码的影响最小因此更符合一个无侵入的轻量级容器的思想。声明式事务管理要优于编程式事务管理虽然比编程式事务管理这种方式允许你通过代码控制事务少了一点灵活性。唯一不足地方是最细粒度只能作用到方法级别无法做到像编程式事务那样可以作用到代码块级别。

Spring面向切面编程(AOP)13

什么是AOP

\1. 连接点Joinpoint
连接点描述的是程序执行的某个特定位置。如一个类的初始化前、初始化后或者类的某个方法调用前、调用后、方法抛出异常后等等。一个类或一段程序代码拥有一些具有边界性质的特定点这些特定点就称为连接点。连接点用来定义在目标程序的哪里通过AOP加入新的逻辑。

Spring仅支持方法的连接点即仅能在方法调用前、方法调用后、方法抛出异常时以及方法调用前后这些程序执行点织入增强。
连接点由两个信息确定第一是用方法表示的程序执行点第二是用相对点表示的方位。
执行点即程序执行流程中的某个点。如执行某个语句或者语句块、执行某个方法、装载某个类、抛出某个异常……

\2. 切入点Pointcut
切入点是一个连接点的过滤条件AOP 通过切点定位到特定的连接点。每个类都拥有多个连接点例如 UserService类中的所有方法实际上都是连接点即连接点是程序类中客观存在的事物。类比连接点相当于数据库中的记录切点相当于查询条件。切点和连接点不是一对一的关系一个切点匹配多个连接点切点通过 org.springframework.aop.Pointcut 接口进行描述它使用类和方法作为连接点的查询条件。

\3. 通知Advice
切面在某个具体的连接点采取的行为或行动称为通知。切面的核心逻辑代码都写在通知中有人也称之为增强或者横切关注点。通知是切面功能的具体实现通常是业务代码以外的需求如日志、验证等这些被模块化的特殊对象。
常用的通知接口有

前置通知org.springframework.aop.MethodBeforeAdvice
后置通知org.springframework.aop.AfterReturningAdvice
异常通知org.springframework.aop.ThrowsAdvice
该接口没有要实现的方法需要自定义一个afterThrowing()方法。
环绕通知org.aopalliance.intercept.MethodInterceptor

\4. 通知器Advisor
通知器由一个切入点pointcut和一个通知Advice组成。通知就是增强的那部分功能代码如记录日志代码、控制权限代码。

\5. 切面Aspect
与通知器advisor类似都是通知+切入点。区别在于切面中的类无需实现通知接口但需要在配置文件中指定类中的方法名而通知器仅需指定类名即可因为通知器中的类都实现了通知接口很明确的知道通知方法是哪个。

\6. 目标(Target)
被通知的对象方法

\7. 代理(Proxy)

向目标对象应用通知之后创建的对象

OOP(Object-Oriented Programming)面向对象编程允许开发者定义纵向的关系但并适用于定义横向的关系导致了大量代码的重复而不利于各个模块的重用。

AOP(Aspect-Oriented Programming)一般称为面向切面编程作为面向对象的一种补充用于将那些与业务无关但却对多个对象产生影响的公共行为和逻辑抽取并封装为一个可重用的模块这个模块被命名为“切面”Aspect减少系统中的重复代码**降低了模块间的耦合度同时提高了系统的可维护性。**可用于权限认证、日志、事务处理等。

面向切面编程方面利用 AOP 可以对业务逻辑的各个部分进行隔离从而使得 业务逻辑各部分之间的耦合度降低提高程序的可重用性同时提高了开发的效率。

2通俗描述不通过修改源代码方式在主干功能里面添加新功能

Spring AOP and AspectJ AOP 有什么区别AOP 有哪些实现方式

SpringAop借助Aspecj实现Aop的语法来实现Aop

③静态代理和动态代理区别

AOP代理对象的时机不同相对来说AspectJ的静态代理方式具有更好的性能但是AspectJ需要特定的编译器进行处理而Spring AOP则无需特定的编译器处理。

④SpringAop的动态代理主要有两个种方式

JDK动态代理和CGLIB动态代理

切入点表达式如下

1切入点表达式作用知道对哪个类里面的哪个方法进行增强 
2语法结构 execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
3例子如下
    例 1对 com.atguigu.dao.BookDao 类里面的 add 进行增强
		execution(* com.atguigu.dao.BookDao.add(..))
 	例 2对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强
		execution(* com.atguigu.dao.BookDao.* (..))
    例 3对 com.atguigu.dao 包里面所有类类里面所有方法进行增强
		execution(* com.atguigu.dao.*.* (..))

AOP实现的关键在于 代理模式AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ动态代理则以Spring AOP为代表。

1AspectJ是静态代理的增强所谓静态代理就是AOP框架会在编译阶段生成AOP代理类因此也称为编译时增强他会在编译阶段将AspectJ(切面)织入到Java字节码中运行的时候就是增强之后的AOP对象。

2Spring AOP使用的动态代理所谓的动态代理就是说AOP框架不会去修改字节码而是每次运行时在内存中临时为方法生成一个AOP对象这个AOP对象包含了目标对象的全部方法并且在特定的切点做了增强处理并回调原对象的方法。

第一种 有接口情况使用 JDK 动态代理 创建接口实现类代理对象增强类的方法

第二种 没有接口情况使用 CGLIB 动态代理创建子类的代理对象增强类的方法

//3使用 Proxy 类创建接口代理对象
public class JDKProxy {
 public static void main(String[] args) {
 //创建接口实现类代理对象
 Class[] interfaces = {UserDao.class};
 UserDaoImpl userDao = new UserDaoImpl(); 
/** 第一参数类加载器 
	第二参数增强方法所在的类这个类实现的接口(支持多个接口)
	第三参数实现这个接口 InvocationHandler创建代理对象写增强的部分  */
 UserDao dao =(UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,
					new UserDaoProxy(userDao));
 int result = dao.add(1, 2);
 System.out.println("result:"+result);
 }
}

//创建代理对象代码
class UserDaoProxy implements InvocationHandler {
 //1 把创建的是谁的代理对象把谁传递过来
 //有参数构造传递
 private Object obj;
 public UserDaoProxy(Object obj) {
 this.obj = obj;
 }
 //增强的逻辑
 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 //方法之前
 System.out.println("方法之前执行...."+method.getName()+" :传递的参数..."+ Arrays.toString(args));
 //被增强的方法执行
 Object res = method.invoke(obj, args);
 //方法之后
 System.out.println("方法之后执行...."+obj);
 return res;
 }
}

JDK动态代理和CGLIB动态代理的区别

Spring AOP中的动态代理主要有两种方式JDK动态代理和CGLIB动态代理

• JDK动态代理只提供接口的代理不支持类的代理。核心InvocationHandler接口和Proxy类InvocationHandler 通过invoke()方法反射来调用目标类中的代码动态地将横切逻辑和业务编织在一起接着Proxy利用 InvocationHandler动态创建一个符合某一接口的的实例, 生成目标类的代理对象。
• 如果代理类没有实现 InvocationHandler 接口那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIBCode Generation Library是一个代码生成的类库可以在运行时动态的生成指定类的一个子类对象并覆盖其中特定方法并添加增强代码从而实现AOP。CGLIB是通过继承的方式做的动态代理因此如果某个类被标记为final那么它是无法使用CGLIB做动态代理的。
• Java动态代理只能够对接口进行代理不能对普通的类进行代理因为所有生成的代理类的父类为ProxyJava类继承机制不允许多重继承CGLIB能够代理普通类
• Java动态代理使用Java原生的反射API进行操作在生成类上比较高效CGLIB使用ASM框架直接对字节码进行操作在类的执行过程中比较高效

静态代理与动态代理区别在于生成AOP代理对象的时机不同相对来说AspectJ的静态代理方式具有更好的性能但是AspectJ需要特定的编译器进行处理而Spring AOP则无需特定的编译器处理。

InvocationHandler 的 invoke(Object proxy,Method method,Object[] args)proxy是最终生成的代理实例; method 是被代理目标实例的某个具体方法; args 是被代理目标实例某个方法的具体入参, 在方法反射调用时使用。

CGLIB底层使用了ASM一个短小精悍的字节码操作框架来操作字节码生成新的类。除了CGLIB库外脚本语言如Groovy何BeanShell也使用ASM生成字节码。ASM使用类似SAX的解析器来实现高性能。我们不鼓励直接使用ASM因为它需要对Java字节码的格式足够的了解

1JDK动态代理只能对实现了接口的类生成代理而不能针对类。

2CGLIB是针对类实现代理主要是对指定的类生成一个子类覆盖其中的方法

并覆盖其中方法实现增强但是因为采用的是继承所以该类或方法最好不要声明成final

对于final类或方法是无法继承的。

https://blog.csdn.net/yhl_jxy/article/details/80635012

如何理解 Spring 中的代理

将 Advice 应用于目标对象后创建的对象称为代理。在客户端对象的情况下目标对象和代理对象是相同的。

Advice + Target Object = Proxy

解释一下Spring AOP里面的几个名词

1切面Aspect切面是通知和切点的结合。通知和切点共同定义了切面的全部内容。 在Spring AOP中切面可以使用通用类基于模式的风格 或者在普通类中以 @AspectJ 注解来实现。也就是需要对需要拦截的那些方法进行定义。 通知应用到切入点的过程。

2连接点Join point指方法在Spring AOP中一个连接点 总是 代表一个方法的执行。 **应用可能有数以千计的时机应用通知。这些时机被称为连接点。**连接点是在应用执行过程中能够插入切面的一个点。这个点可以是调用方法时、抛出异常时、甚至修改一个字段时。切面代码可以利用这些点插入到应用的正常流程之中并添加新的行为。类中的那些方法可以被增强这些方法称为连接点

3通知Advice在AOP术语中切面的工作被称为通知。 实际增强的逻辑部分称为通知增强。

4切入点Pointcut**切点的定义会匹配通知所要织入的一个或多个连接点。**我们通常使用明确的类和方法名称或是利用正则表达式定义所匹配的类和方法名称来指定这些切点。是 AOP 的核心并且 Spring 默认使用 AspectJ 作为切入点表达式语言。实际被真正增强的方法称为切入点。

5引入Introduction引入允许我们向现有类添加新方法或属性。也被称为内部类型声明inter-type declaration。声明额外的方法或者某个类型的字段。Spring允许引入新的接口以及一个对应的实现到任何被代理的对象。例如你可以使用一个引入来使bean实现 IsModified 接口以便简化缓存机制。

6目标对象Target Object 被一个或者多个切面aspect所通知advise的对象。它通常是一个代理对象。也有人把它叫做 被通知adviced 对象。 既然Spring AOP是通过运行时代理实现的这个对象永远是一个 被代理proxied 对象。

7织入Weaving**织入是把切面应用到目标对象并创建新的代理对象的过程。**在目标对象的生命周期里有多少个点可以进行织入Spring是在运行时完成织入。

• 编译期切面在目标类编译时被织入。AspectJ的织入编译器是以这种方式织入切面的。
• 类加载期切面在目标类加载到JVM时被织入。需要特殊的类加载器它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ5的加载时织入就支持以这种方式织入切面。
• 运行期切面在应用运行的某个时刻被织入。一般情况下在织入切面时AOP容器会为目标对象动态地创建一个代理对象。SpringAOP就是以这种方式织入切面。

Spring在运行时通知对象

通过在代理类中包裹切面**Spring在运行期把切面织入到Spring管理的bean中。**代理封装了目标类并拦截被通知方法的调用再把调用转发给真正的目标bean。当代理拦截到方法调用时在调用目标bean方法之前会执行切面逻辑。

直到应用需要被代理的bean时Spring才创建代理对象。如果使用的是ApplicationContext的话在ApplicationContext从BeanFactory中加载所有bean的时候Spring才会创建被代理的对象。因为Spring运行时才创建代理对象所以我们不需要特殊的编译器来织入SpringAOP的切面。

Spring只支持方法级别的连接点

因为Spring基于动态代理所以Spring只支持方法连接点。Spring缺少对字段连接点的支持而且它不支持构造器连接点。方法之外的连接点拦截功能我们可以利用Aspect来补充。

在Spring AOP 中关注点和横切关注的区别是什么在 spring aop 中 concern 和 cross-cutting concern 的不同之处

关注点concern是应用中一个模块的行为一个关注点可能会被定义成一个我们想实现的一个功能。

横切关注点cross-cutting concern是一个关注点此关注点是整个应用都会使用的功能并影响整个应用比如日志安全和数据传输几乎应用的每个模块都需要的功能。因此这些都属于横切关注点。

Spring通知有哪些类型

在AOP术语中切面的工作被称为通知实际上是程序执行时要通过SpringAOP框架触发的代码段。

Spring切面可以应用5种类型的通知

1. 前置通知Before在目标方法被调用之前调用通知功能

   在目标方法执行之前执行执行的通知。

   前置通知方法可以没有参数也可以额外接收一个JoinPointSpring会自动将该对象传入代表当前的连接点通过该对象可以获取目标对象 和 目标方法相关的信息。

   注意如果接收JoinPoint必须保证其为方法的第一个参数否则报错。

2. 最终通知After在目标方法完成之后调用通知此时不会关心方法的输出是什么

   是在目标方法执行之后执行的通知。

   和后置通知不同之处在于后置通知是在方法正常返回后执行的通知如果方法没有正常返回例如抛出异常则后置通知不会执行。

   而最终通知无论如何都会在目标方法调用过后执行即使目标方法没有正常的执行完成。

   另外后置通知可以通过配置得到返回值而最终通知无法得到。

   最终通知也可以额外接收一个JoinPoint参数来获取目标对象和目标方法相关信息但一定要保证必须是第一个参数。

3. 后置通知After-returning 在目标方法成功执行之后调用通知

在目标方法执行之后执行的通知。

在后置通知中也可以选择性的接收一个JoinPoint来获取连接点的额外信息但是这个参数必须处在参数列表的第一个。

在后置通知中还可以通过配置获取返回值

一定要保证JoinPoint处在参数列表的第一位否则抛异常

1. 异常通知After-throwing在目标方法抛出异常后调用通知

在目标方法抛出异常时执行的通知

可以配置传入JoinPoint获取目标对象和目标方法相关信息但必须处在参数列表第一位

另外还可以配置参数让异常通知可以接收到目标方法抛出的异常对象。

1. 环绕通知Around通知包裹了被通知的方法在被通知的方法调用之前和调用之后执行自定义的行为。

在目标方法执行之前和之后都可以执行额外代码的通知。

在环绕通知中必须显式的调用目标方法目标方法才会执行这个显式调用时通过ProceedingJoinPoint来实现的可以在环绕通知中接收一个此类型的形参spring容器会自动将该对象传入注意这个参数必须处在环绕通知的第一个形参位置。

要注意只有环绕通知可以接收ProceedingJoinPoint而其他通知只能接收JoinPoint。

环绕通知需要返回返回值否则真正调用者将拿不到返回值只能得到一个null。

环绕通知有控制目标方法是否执行、有控制是否返回值、有改变返回值的能力。

环绕通知虽然有这样的能力但一定要慎用不是技术上不可行而是要小心不要破坏了软件分层的“高内聚 低耦合”的目标。

同一个aspect不同advice的执行顺序

①没有异常情况下的执行顺序

around before advice
before advice
target method 执行
around after advice

after advice

afterReturning

1.在目标方法没有抛出异常的情况

环绕通知的调用目标方法之前的代码

前置通知

目标方法

环绕通知的调用目标方法之后的代码

最终通知

后置通知

②有异常情况下的执行顺序

around before advice
before advice
target method 执行
after advice
afterThrowing:异常发生
java.lang.RuntimeException: 异常发生

在目标方法抛出异常的情况下

环绕通知的调用目标方法之前的代码

前置通知

目标方法

环绕通知的调用目标方法之后的代码

最终通知

抛出异常 异常通知

around before advice
before advice
target method 执行
around after advice
after advice
afterReturning
===============分割线==============
around before advice
before advice
target method 执行
after advice
afterThrowing:异常发生
java.lang.RuntimeException: 异常发生

public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值
Object rtValue = null;
try {
//获取方法执行所需的参数
Object[] args = pjp.getArgs();
//前置通知开启事务
beginTransaction();
//执行方法
rtValue = pjp.proceed(args);
//后置通知提交事务
commit();
}catch(Throwable e) {
//异常通知回滚事务
rollback();
e.printStackTrace();
}finally {
//最终通知释放资源
release();
}
return rtValue; }

有多个增强类对同一个方法进行增强设置增强类优先级

//1在增强类上面添加注解 @Order(数字类型值)数字类型值越小优先级越高
@Component
@Aspect
@Order(1)
public class PersonProxy{ }

什么是切面 Aspect

aspect 由 pointcount 和 advice 组成切面是通知和切点的结合。 它既包含了横切逻辑的定义, 也包括了连接点的定义. Spring AOP 就是负责实施切面的框架, 它将切面所定义的横切逻辑编织到切面所指定的连接点中.
AOP 的工作重心在于如何将增强编织目标对象的连接点上, 这里包含两个工作:

• 如何通过 pointcut 和 advice 定位到特定的 joinpoint 上
• 如何在 advice 中编写切面代码.

可以简单地认为, 使用 @Aspect 注解的类就是切面.

解释基于XML Schema方式的切面实现

在这种情况下切面由常规类以及基于XML的配置实现。

解释基于注解的切面实现

在这种情况下(基于@AspectJ的实现)涉及到的切面声明的风格与带有java5标注的普通java类一致。

有几种不同类型的自动代理

BeanNameAutoProxyCreator

DefaultAdvisorAutoProxyCreator

Metadata autoproxying

AOP 使用场景

• 日志系统
• 安全统一效验

AOP 优点

• 集中处理某一类问题方便维护
• 逻辑更加清晰
• 降低模块间的耦合度

AOP 代码实现

AOP 的示例就以开车为例开车的完成流程是这样的巡视车体及周围情况 → 发动 → 开车 → 熄火 → 锁车。当然我们的主要目的是“开车”但在开车之前和开完车之后我们要做一些其他的工作这些“其他”的工作可以理解为 AOP 编程。

1.创建类和方法

package com.learning.aop;
import org.springframework.stereotype.Component;

@Component("person")
public class Person {
    public void drive() {
        System.out.println("开车");
    }
}

2.创建 AOP 拦截

package com.learning.aop;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class CarAop {
    @Before("execution(* com.learning.aop.Person.drive())")
    public void before() {
        System.out.println("巡视车体及周围情况");
        System.out.println("发动");
    }
    @After("execution(* com.learning.aop.Person.drive())")
    public void after() {
        System.out.println("熄火");
        System.out.println("锁车");
    }
}

为什么不把测试类配到 xml 中

在解释这个问题之前先解除大家的疑虑配到 XML 中能不能用呢

答案是肯定的没问题可以使用。

那么为什么不采用配置到 xml 中的方式呢

这个原因是这样的

第一当我们在 xml 中配置了一个 beanspring 加载配置文件创建容器时就会创建对象。

第二测试类只是我们在测试功能时使用而在项目中它并不参与程序逻辑也不会解决需求上的问

题所以创建完了并没有使用。那么存在容器中就会造成资源的浪费。

所以基于以上两点我们不应该把测试配置到 xml 文件中

Spring 框架中都用到了哪些设计模式

1工厂模式BeanFactory就是简单工厂模式的体现用来创建对象的实例

2单例模式Bean默认为单例模式。

3代理模式Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术

Spring如何解决循环依耐

例子A依耐 BB依耐CC又依耐A形成了一个环

一构造器循环依耐解决不了

Spring实例化A的过程中会调用有参构造器由于那个参数B在ioc容器中找不到所以会创建B调用B的构造器由于B构造器那个参数C在ioc容器中也找不到所以又会创建CC又创建A这个时候就会报异常

二setter循环依赖单例可以解决多例由于不知道获取那个对象所以不能解决

Spring先用无参构造器实例化Bean对象----->将实例化结束的对象放到一个Map中并且Spring提供获取这个未设置属性的实例化对象的引用方法。实例来看当Spring实例化了A、B、C后紧接着会去设置对象的属性此时A依赖B就会去Map中取出存在里面的单例B对象以此类推不会出来循环的问题

1.什么是循坏依赖
 即循环引用两个或多个bean相互引用最终形成一个环。如图

2.什么是循环调用
 循环调用是方法之间的环调用。循环调用无法解决除非有终结条件否则就是死循环最终导致内存溢出错误。

3.构造器循环依赖
3.1 循环依赖过程
定义类依赖

  Class A{
        private B b;
        A(B b){
              this.b = b;
         }
   }

   Class B{
          private C c;
          B(C c){
              this.c = c;
          }
   }

   Class C{
          private A a;
          C(A a){
                this.a = a;
           }
    }

JVM创建对象过程 如下图所示

3.2 Spring解决构造器循环依赖
无法解决通过构造器注入构成的循环依赖只能抛出BeanCurrentylyInCreationException异常表示循环依赖。
Spring容器将每一个正在创建的bean标识符放在一个“当前创建bean池”中bean表示符在创建过程中将一直保持在这个池中因此如果在创建bean过程中发现自己已经在“当前创建bean池”中将抛出BeanCurrentylyInCreationException异常表示循环依赖对于创建完毕的bean将从“当前创建bean池”中清除掉。

4.setter循环依赖
通过Spring容器提前暴露刚完成构造器注入但未完成其他步骤如setter注入的bean来完成的。通过提前暴露一个单例工厂方法从而使其他bean能够引用到该bean。
注只能解决单例作用域的bean循环依赖。
具体步骤
1Spring容器创建单例 a bean首先根据无参构造器创建bean并暴露一个“ObjectFactory”用于返回一个提前暴露一个创建中的bean并将 “a”标识符放到“当前创建bean池”然后进行setter注入b;
2Spring容器创建单例 b bean首先根据无参构造器创建bean并暴露一个“ObjectFactory”用于返回一个提前暴露一个创建中的bean并将 “b”标识符放到“当前创建bean池”然后进行setter注入c;
3Spring容器创建单例 c bean首先根据无参构造器创建bean并暴露一个“ObjectFactory”用于返回一个提前暴露一个创建中的bean并将 “c”标识符放到“当前创建bean池”然后进行setter注入a;

进行注入"a"时由于提前暴露了“ObjectFactory”工厂从而使用它返回提前暴露一个创建中的bean。
4最后在依赖注入“b”和“a”完成setter注入。

@Component和@Bean的区别

①.使用位置不同@Component一般标准类上而@Bean一般标注在方法上

②. @Component@Controller、@Service、@Repository通常是通过类路径扫描来自动侦测以及自动装配到Spring容器中。

而@Bean注解通常是我们在标有该注解的方法中定义产生这个bean的逻辑。

③. 引用第三方库中的类需要装配到Spring容器时只能通过@Bean来实现

项目启动时候spring是如何加载和实例化各类的

1. 对于注解为默认的也就是@score不写的默认是单例的类这些类在项目启动的时候会依次被加载并被实例化。默认调用的是无参数的构造器。

2. 而对于注解是prototype类型的即@Scope(“prototype”)在首次被用到的时候加载。

Spring中使用了什么设计模式

https://www.cnblogs.com/chinaifae/p/10393930.html

Sping中bean的生命周期代码展示、循环依赖

https://blog.csdn.net/weixin_41231928/article/details/107039437

为什么jdk动态代理必须基于接口

1、生成的代理类继承了Proxy由于java是单继承所以只能实现接口通过接口实现
2、从代理模式的设计来说充分利用了java的多态特性也符合基于接口编码的规范

CGLIB代理
CGLIB底层使用字节码处理框架ASM来转换字节码并生成新的类。
CGLIBCODE GENERLIZE LIBRARY代理是针对类实现代理主要是对指定的类生成一个子类覆盖其中的所有方法所以该类或方法不能声明称final的。

如果目标对象没有实现接口则默认会采用CGLIB代理
如果目标对象实现了接口可以强制使用CGLIB实现代理。

CGLIB(Code Generation Library)详解

https://blog.csdn.net/danchu/article/details/70238002

Spring事务的失效

https://zhuanlan.zhihu.com/p/334766548

https://blog.csdn.net/u013815546/article/details/55101708

\1. 连接点Joinpoint
连接点描述的是程序执行的某个特定位置。如一个类的初始化前、初始化后或者类的某个方法调用前、调用后、方法抛出异常后等等。一个类或一段程序代码拥有一些具有边界性质的特定点这些特定点就称为连接点。连接点用来定义在目标程序的哪里通过AOP加入新的逻辑。

Spring仅支持方法的连接点即仅能在方法调用前、方法调用后、方法抛出异常时以及方法调用前后这些程序执行点织入增强。
连接点由两个信息确定第一是用方法表示的程序执行点第二是用相对点表示的方位。
执行点即程序执行流程中的某个点。如执行某个语句或者语句块、执行某个方法、装载某个类、抛出某个异常……

\2. 切入点Pointcut
切入点是一个连接点的过滤条件AOP 通过切点定位到特定的连接点。每个类都拥有多个连接点例如 UserService类中的所有方法实际上都是连接点即连接点是程序类中客观存在的事物。类比连接点相当于数据库中的记录切点相当于查询条件。切点和连接点不是一对一的关系一个切点匹配多个连接点切点通过 org.springframework.aop.Pointcut 接口进行描述它使用类和方法作为连接点的查询条件。

\3. 通知Advice
切面在某个具体的连接点采取的行为或行动称为通知。切面的核心逻辑代码都写在通知中有人也称之为增强或者横切关注点。通知是切面功能的具体实现通常是业务代码以外的需求如日志、验证等这些被模块化的特殊对象。
常用的通知接口有

前置通知org.springframework.aop.MethodBeforeAdvice
后置通知org.springframework.aop.AfterReturningAdvice
异常通知org.springframework.aop.ThrowsAdvice
该接口没有要实现的方法需要自定义一个afterThrowing()方法。
环绕通知org.aopalliance.intercept.MethodInterceptor

\4. 通知器Advisor
通知器由一个切入点pointcut和一个通知Advice组成。通知就是增强的那部分功能代码如记录日志代码、控制权限代码。

\5. 切面Aspect
与通知器advisor类似都是通知+切入点。区别在于切面中的类无需实现通知接口但需要在配置文件中指定类中的方法名而通知器仅需指定类名即可因为通知器中的类都实现了通知接口很明确的知道通知方法是哪个。

\6. 目标(Target)
被通知的对象方法

\7. 代理(Proxy)

向目标对象应用通知之后创建的对象