Spring

最新推荐文章于 2024-10-01 13:49:09 发布

MZR--JAVA

最新推荐文章于 2024-10-01 13:49:09 发布

阅读量71

点赞数

分类专栏：框架文章标签： spring java mvc

本文链接：https://blog.csdn.net/weixin_44761821/article/details/120571497

版权

框架专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Spring
在这里插入图片描述
Spring 的优点

轻量针对接口编程，解耦合 AOP编程的支持方便集成各种优秀框架
非侵入式容器

Spring体系结构
数据访问/集成（Data Access/Integration）、
Web、面向切面编程（AOP, Aspects）、
应用服务器设备管理（Instrumentation）、
消息发送（Messaging）、
核心容器（Core Container）
测试（Test）。

IOC
是控制反转，它是一种设计思想，而不是具体的技术实现。
IOC 的思想就是将原本在程序中手动创建对象的控制器交由 Spring 管理。

控制反转？
控制对象的创建（实例化管理）的权利
反转将控制权交由外部环境。

在这里插入图片描述
1.将对象之间的相互依赖关系交由 IOC 容器管理，并由 IOC 容器完成对象的注入。
可以很大程度上简化应用的开发，把应用从复杂的依赖关系解放出来。
IOC 容器就像一个大工厂，当我们需要创建一个对象的时候，只需要配置文件/注解就可以，无需关注对象是如何创建出来的。

2.在实际开发中 Service 类可能依赖了很多其他的类。
假如我们需要实例化这个 Service 所有底层类的构造方法，这会降低代码的耦合，如果使用 IOC 容器的话，只需要配置好，在需要的地方直接引用，大大降低了开发的难度。

IOC 容器是 Spring 用来实现 IOC 的载体，实际上是一个 Map， Map 存放了各种对象。
如果通过 XML 文件来配置 Bean 比较麻烦，可以使用注解的方式。

什么是SpringIOC容器？
IOC控制反转：SpringIOC负责创建对象，管理对象。通过依赖注入（DI），
装配对象，配置对象，并且管理这些对象的整个生命周期

有哪些不同类型的IOC（依赖注入）方式？
1.set注入 2. 构造器注入 3.静态工厂注入 4.实例工厂注入

** AOP **

AOP 是面向切面编程，是OOP（面向对象编程）的补充和扩展。

AOP利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为“Aspect”，即切面。
简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任（如：事务管理日志管理权限控制）封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

使用 “横切”技术将软件系统分为两部分：核心关注点和横切关注点。
业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。
横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。
AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。
AOP核心就是切面，它将多个类的通用行为封装成可重用的模块，该模块含有一组API提供横切功能。
（比如，一个日志模块可以被称作日志的AOP切面。根据需求的不同，一个应用程序可以有若干切面。在Spring AOP中，切面通过带有@Aspect注解的类实现。）

Spring AOP 和 AspectJ AOP 有什么区别？
Spring AOP 属于运行时增强，而 AspectJ 是编译时增强。
Spring AOP 基于代理(Proxying)，而 AspectJ 基于字节码操作(Bytecode Manipulation)。

Spring bean

bean：代指被 IOC 容器所管理的对象。

我们需要告诉 IoC 容器帮助我们管理哪些对象，
这个是通过配置元数据来定义的。
配置元数据可以是 XML 文件、注解或者 Java 配置类。

<!-- Constructor-arg with 'value' attribute -->
<bean id="..." class="...">
  <constructor-arg value="..."/>
</bean>

什么是bean的自动装配？
无须在Spring配置文件中描述javaBean之间的依赖关系
（如配置、）。
IOC容器会自动建立javabean之间的关联关系。

30、解释不同方式的自动装配？
有五种自动装配的方式，可以用来指导Spring容器用自动装配方式来进行依赖注入。

● no：默认的方式是不进行自动装配，通过显式设置ref属性来进行装配。

● byName：通过参数名自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byname，之后容器试图匹配、装配和该bean的属性具有相同名字的bean。

● byType:：通过参数类型自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byType，之后容器试图匹配、装配和该bean的属性具有相同类型的bean。如果有多个bean符合条件，则抛出错误。

● constructor：这个方式类似于byType，但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。

● autodetect：首先尝试使用constructor来自动装配，如果无法工作，则使用byType方式。

IoC 容器如何使用配置元数据来管理对象。
在这里插入图片描述

** bean 的作用域？ **

singleton : 唯一 bean 实例。 Spring中 bean 默认是单例的。
prototype：每次请求都会创建一个新的 bean 实例。
request ：每一次 HTTP 请求都会产生一个新的 bean 实例
（在http中的 requst 有效）
4.session ：每一次来自新 session 的 http 请求都会产生一个新的 bean
（只在 HTTP session 有效）
5.global -session ：
全局 session 作用域，仅仅在基于 portlet 的 web 应用中才有意义，Spring5 已经没有了。Portlet 是能够生成语义代码(例如：HTML)片段的小型 Java Web 插件。它们基于 portlet 容器，可以像 servlet 一样处理 HTTP 请求。但是，与 servlet 不同，每个 portlet 都有不同的会话。

** 如何配置 bean 作用域？ **
xml 方式

	<bean id="..." class="..." scope="singleton"></bean>

注解方式

@Bean
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public Person personPrototype() {
    return new Person();
}

** 单例 bean 的线程安全问题？ **
单例 bean 存在线程安全问题，主要是在多个线程操作同一对象是存在资源竞争。

两个办法：
1.在 bean 中尽量避免定义可变的成员变量。
2.在类中定义一个 ThreadLocal 成员变量，将需要的可变成员变量保存在 ThreadLocal 中（推荐的一种方式）。

不过，大部分 bean 实际都是无状态（没有实例变量）的
（比如 Dao、Service），这种情况下， bean 是线程安全的。

** 将一个类声明为 bean 的注解有哪些? **
@Autowried 注解自动装配 bean，要想把类标识成可用于 @Autowired 注解自动装配的 bean 的类
@Componment 通用的注解，可标注任意类为 Spring 组件。如果一个 Bean 不知道属于哪个层，可以使用@Component 注解标注。
@Service 对应服务层，主要涉及一些复杂的逻辑，需要用到 Dao 层。
@Controller 对应 Spring MVC 控制层，主要用户接受用户请求并调用 Service 层返回数据给前端页面。
@Repository 对应持久层即 Dao 层，主要用于数据库相关操作。

** Spring的常用注解？**

@Required：该注解应用于设值方法。

@Autowired：该注解应用于有值设值方法、非设值方法、构造方法和变量。

@Qualifier：该注解和@Autowired搭配使用，用于消除特定bean自动装配的歧义。

** bean 的生命周期？ **
在这里插入图片描述

**简单介绍一下spring bean的生命周期? **
● bean定义：在配置文件里面用来进行定义。

● bean初始化：有两种方式初始化：

1、在配置文件中通过指定init-method属性来完成。

2、实现org.springframwork.beans.factory.InitializingBean接口。

● bean调用：有三种方式可以得到bean实例，并进行调用
1.使用无参构造方法实例化(最常用)
2.工厂静态方法实例化
3.工厂实例方法实例化

● bean销毁：销毁有两种方式：

1、使用配置文件指定的destroy-method属性。

2、实现org.springframwork.bean.factory.DisposeableBean。

@Component 和 @Bean 的区别是什么？
在这里插入图片描述
@Bean

@Configuration
public class AppConfig {
    @Bean
    public TransferService transferService() {
        return new TransferServiceImpl();
    }

}


<beans>
    <bean id="transferService" class="com.acme.TransferServiceImpl"/>
</beans>

@Component

@Bean
public OneService getService(status) {
    case (status)  {
        when 1:
                return new serviceImpl1();
        when 2:
                return new serviceImpl2();
        when 3:
                return new serviceImpl3();
    }
}

** Spring 框架使用了哪些设计模式？ **
1.工厂设计模式
Spring 使用工厂模式通过 BeanFactory、ApplicationContext 创建 bean 对象。
2.代理设计模式
Spring AOP 功能的实现。
3.单例设计模式
Spring 中的 Bean 默认都是单例的。
4.模板方法模式
Spring 中 jdbcTemplate、hibernateTemplate 等以 Template 结尾的对数据库操作的类，它们就使用到了模板模式。
5.包装器设计模式
我们的项目需要连接多个数据库，而且不同的客户在每次访问中根据需要会去访问不同的数据库。这种模式让我们可以根据客户的需求能够动态切换不同的数据源。
6.观察者模式
Spring 事件驱动模型就是观察者模式很经典的一个应用。
7.适配器模式
Spring AOP 的增强或通知(Advice)使用到了适配器模式、spring MVC 中也是用到了适配器模式适配Controller。
8.····

** 工厂设计模式 **
Spring使用工厂模式
可以通过 BeanFactory 或 ApplicationContext 创建 bean 对象。

两者对比：

BeanFactory ：延迟注入(使用到某个 bean 的时候才会注入),
容器启动初期速度较快，所需资源有限。
相比于ApplicationContext 来说会占用更少的内存，程序启动速度更快。

ApplicationContext ：容器启动的时候，不管你用没用到，一次性创建所有 bean 。
(ApplicationContext管理的对象，在容器启动后默认全部初始化并且绑定完成。)

BeanFactory 仅提供了最基本的依赖注入支持，
ApplicationContext 扩展了 BeanFactory ,
除了BeanFactory的所有支持外，ApplicationContext还提供了事件发布、国际化支持等功能。

···
ApplicationContext的三个实现类：

ClassPathXmlApplication：把上下文文件当成类路径资源。
FileSystemXmlApplication：从文件系统中的 XML 文件载入上下文定义信息。
XmlWebApplicationContext：从Web系统中的XML文件载入上下文定义信息。

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
 
public class App {
    public static void main(String[] args) {
        ApplicationContext context = new FileSystemXmlApplicationContext(
                "C:/work/IOC Containers/springframework.applicationcontext/src/main/resources/bean-factory-config.xml");
 
        HelloApplicationContext obj = (HelloApplicationContext) context.getBean("helloApplicationContext");
        obj.getMsg();
    }
}

···
单例模式
https://snailclimb.gitee.io/javaguide/#/docs/system-design/framework/spring/Spring-Design-Patterns?id=%e5%8d%95%e4%be%8b%e8%ae%be%e8%ae%a1%e6%a8%a1%e5%bc%8f

···
代理模式
代理模式在 AOP 中的应用
AOP(面向切面编程)能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

Spring AOP 就是基于动态代理的，如果要代理的对象，实现了某个接口，那么Spring AOP会使用JDK Proxy，去创建代理对象，而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候Spring AOP会使用Cglib ，这时候Spring AOP会使用 Cglib 生成一个被代理对象的子类来作为代理，
如下图所示：
在这里插入图片描述
使用 AOP 之后我们可以把一些通用功能抽象出来，在需要用到的地方直接使用即可，这样大大简化了代码量。我们需要增加新功能时也方便，这样也提高了系统扩展性。日志功能、事务管理等等场景都用到了 AOP 。
···
模板方法
模板方法模式是一种行为设计模式，它定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤的实现方式

Spring 中 jdbcTemplate 等以 Template 结尾的对数据库操作的类，它们就使用到了模板模式。
一般情况下，我们都是使用继承的方式来实现模板模式，但是 Spring 并没有使用这种方式，而是使用Callback 模式与模板方法模式配合，既达到了代码复用的效果，同时增加了灵活性。

···

观察者模式

观察者模式是一种对象行为型模式。它表示的是一种对象与对象之间具有依赖关系，当一个对象发生改变的时候，这个对象所依赖的对象也会做出反应。
Spring 事件驱动模型就是观察者模式很经典的一个应用。
Spring 事件驱动模型非常有用，在很多场景都可以解耦我们的代码。比如我们每次添加商品的时候都需要重新更新商品索引，这个时候就可以利用观察者模式来解决这个问题。

···
Spring 事件驱动模型中的三种角色
···
spring AOP中的适配器模式

装饰者模式

Spring MVC

** SpringMVC 工作原理 **
在这里插入图片描述
流程说明（重要）：