深圳幻海软件技术有限公司 欢迎您！
更多

快速切入：Spring框架核心概念总览

2023-02-28

应用程序 bean org
1、Spring是什么?简而言之，Spring是企业级Java的开源开发框架。Spring框架的核心功能可用于开发任何java应用程序。Spring框架的核心模块如下：üSpringContext(Spring上下文):用于依赖注入(DI);üSpringDAO(数据库访问对象):使用DAP模式进行

1、Spring是什么?

简而言之，Spring是企业级Java的开源开发框架。Spring框架的核心功能可用于开发任何java应用程序。Spring框架的核心模块如下：

  • ü Spring Context(Spring上下文):用于依赖注入(DI);
  • ü Spring DAO(数据库访问对象): 使用DAP模式进行数据库操作;
  • ü Spring JDBC: 用于JDBC和数据源的支持 ;
  • ü Spring ORM: 用于ORM工具支持，如Hibernate;
  • ü Spring AOP: 用于面向方面的编程;
  • ü Spring Web module: 用于创建Web应用。

2、Spring框架的优点是什么

  • ü 轻量级：Spring时轻量级应用框架。 Spring框架的基本版本在2MB左右;
  • ü 依赖注入/控制反转 (DI/IoC)：这有助于通过连接独立的组件/对象来实现松散耦合;
  • ü Spring容器：包含和管理应用程序对象的生命周期;
  • ü 事务管理：Spring支持事务管理，即JDBC操作、文件上传、异常处理等，通过spring注解或bean配置来完成;
  • ü Spring MVC：Spring MVC 可用于创建 Web 应用程序以及能够返回 XML 或 JSON 响应的restful Web 服务;
  • ü 异常处理：Spring 提供了一个方便的 API 来将特定的技术异常(由 JDBC、Hibernate 等抛出)转换为一致的未经检查的异常;
  • ü 面向切面编程(AOP)：AOP 将程序逻辑分解为不同的部分(称为关注点)。它用于通过横切关注点来增加模块化。横切关注点是可以影响整个应用程序的关注点，应尽可能集中在代码中的一个位置，例如事务管理、身份验证、日志记录、安全性等。

3、什么是Spring Bean?

任何由 Spring IoC 容器初始化的普通 Java 类都称为 Spring Bean。我们使用 spring 应用程序上下文来获取 Spring Bean 实例。 Spring IoC Container 管理 Spring Bean 范围/作用域的生命周期并在 bean 中注入任何所需的依赖项。

Spring bean的不同作用域：

当我们声明 时，我们可以指定 bean 的作用域来通知 IoC 容器关于 bean 的创建以及它将存活多长时间。

对于任何 Java 应用程序，都有两个不同的作用域，称为单例(Singleton)和原型(Prototype)

主要有三种不同的作用域(或范围)，即请求(request)、会话(session)和全局会话(global-session)，专门针对基于 Spring 的 Java Web 应用程序。

Singleton 是任何 bean 的默认作用域。这意味着每个 IoC 容器将创建单个 bean 实例。因此，单例 bean 不是线程安全的。

  • 在原型范围内，每次请求 bean 时都会创建一个新实例。
  • 在请求范围内，单个 bean 被定义到一个 HTTP 请求内。此范围仅在支持 Web 的 spring ApplicationContext 中有效。
  • 在会话范围内，单个 bean 被定义到一个 HTTP 会话内。此范围仅在支持 Web 的 spring ApplicationContext 中有效。
  • 在 global-session 范围内，bean 被定义为全局 HTTP 会话内有效。此范围仅在支持 Web 的 spring ApplicationContext 中有效。

要设置 spring bean 的范围，我们可以在 标签中使用scope属性。 @scope 用于基于注释的 DI。

4、Spring IoC 容器

Spring 容器是 Spring 框架的核心。容器将创建对象，把它们连接在一起，配置它们，并管理它们从创建到销毁的完整生命周期。 Spring 容器使用依赖注入 (DI) 来管理组成应用程序的组件。

有两种不同类型的容器：

BeanFactory 容器：这是 Spring 容器的核心。

org.springframework.beans.factory.BeanFactory 是一个接口，充当 IoC 容器，它实例化、配置和管理许多 bean。应用示例如下：

Beans.xml:
<?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.0.xsd">

<bean id="helloWorld" class="com.newday.bean.HelloWorld">
<property name="message" value="Hello World!"/>
</bean>

</beans>

package com.newday.bean;

public class HelloWorld {
private String message;

public String getMessage() {
return message;
}

public void setMessage(String message) {
this.message = message;
}

}

MainApp.java:
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import com.newday.bean.HelloWorld;

public class MainApp {
public static void main(String args[]) {
Resource resource = new ClassPathResource("beans.xml");
BeanFactory beanFactory = new XmlBeanFactory(resource);

HelloWorld helloWorld = (HelloWorld) beanFactory.getBean("helloWorld");

System.out.println(helloWorld.getMessage());
}
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.

ApplicationContext 容器：

org.springframework.context.ApplicationContext 接口也充当 IoC 容器，但 ApplicationContext 接口建立在 BeanFactory 接口之上，以提供一些BeanFactory 额外的功能，例如与 Spring 的 AOP 的简单集成、消息资源处理(对于 I18N )、事件传播、Web 应用程序的应用层特定上下文(例如 WebApplicationContext)。所以使用 ApplicationContext 比使用 BeanFactory更好些。示例代码如下：

<?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.0.xsd">

<bean id="helloWorld" class="com.newday.bean.HelloWorld">
<property name="message" value="Hello World!"/>
</bean>

</beans>

package com.newday.bean;

public class HelloWorld {
private String message;

public String getMessage() {
return message;
}

public void setMessage(String message) {
this.message = message;
}

}

package com.newday.applicationcontext;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.newday.bean.HelloWorld;

public class MainApp {
public static void main(String args[]) {
ApplicationContext appContext = new ClassPathXmlApplicationContext("beans.xml");

HelloWorld helloWorld = (HelloWorld) appContext.getBean("helloWorld");

System.out.println(helloWorld.getMessage());

}
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.

5、@Autowired

对于基于注解的依赖注入，使用@Autowired 注解。标有@Component/@Service/@Repository 等的类可以注入到标有@Autowired 的属性中

@Autowired 应用于:

  • ü 字段域：用于基于字段的依赖注入;
  • ü setter：用于setter依赖注入 。与基于字段的依赖注入相同;
  • ü 构造器：基于构造函数的依赖注入。

1)基于构造器和setter的区别

  • ü 依赖项的注入可以是可选的，也可以是强制性的。对于强制注入，我们使用基于构造函数的 DI。对于可选的依赖项，我们可以使用基于 setter 的 DI。但是，我们可以使用 @Required 注释标记基于 setter 的 DI。
  • ü 在循环依赖的情况下，基于构造器的 DI 将无法注入，但基于 setter 的 DI 将能够注入
  • ü 如果要注入更多数量的参数，则建议使用基于构造函数的 DI。

2)context:annotation-config 和 context:component-scan 的区别

  • ü context:annotation-config 用于激活已在应用程序上下文中注册的 bean 中的注释;
  • ü context:component-scan 也可以执行 context:annotation-config 所做的工作，但也可以扫描包以在应用程序上下文中查找和注册 bean。

3)@Component、@Controller、@Repository & @Service 注解的区别

如果一个类用@Component/@Controller/@Service/@Repository 注解标记，那么Spring DI 容器可以在组件扫描机制期间识别该类。但是，对于服务层类使用@Service 是个好主意，并且@Controller 应该在spring mvc web 控制器中使用。 @Repository 用于将 DAO 导入 DI 容器。此外，任何未经检查的异常都将被转换为 Spring DataAccessException。

4)ViewResolver 与 MultipartResolver

ViewResolver 用于按名称解析视图。该接口由

InternalResourceViewResolver 实现 ;

MultipartResolver 用于处理 web 应用程序中的文件上传。

5)Spring MVC 中的验证

org.springframework.validation.Validator 接口支持 spring MVC 验证。验证表单的一些实用方法是 ValidationUtils 类中的 rejectIfEmptyOrWhitespace() 和 rejectIfEmpty()。示例如下：

@Component
public class EmployeeValidator implements Validator{
public boolean supports(Class clazz) {
return EmployeeVO.class.isAssignableFrom(clazz);
}

public void validate(Object target, Errors errors){
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "firstName", "error.firstName", "First name is required.");
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "lastName", "error.lastName", "Last name is required.");
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "email", "error.email", "Email is required.");
}
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.

Spring MVC 中验证表单的另一种方法是:

对模型 bean 的属性使用Hibernate验证(例如 @NotNull、@Size 等)

在控制器的方法签名中使用@Valid、BindingResult。

BindingResult.hasErrors() 方法来验证模型 bean。

6、Spring MVC 拦截器

HandlerInterceptor 接口充当 spring MVC 拦截器。它在服务请求之前和之后拦截。如果您实现了 HandlerInterceptor 接口，则 preHandle()、postHandle() 和 afterCompletion() 是要覆盖的方法。但是，为了避免覆盖，您可以使用 HandlerInterceptorAdapter 类。

7、Spring MVC 框架中的异常处理

Spring 中的异常是使用

SimpleMappingExceptionResolver 类以声明方式处理的。您要处理的异常列表是针对 exceptionMapping 属性配置的。如果有异常发生在流程中的任何地方，都将被捕获并显示相应的视图。对于所有其他异常，您可以针对 defaultErrorView 属性捕获它们。示例配置如下：

快速切入：Spring框架核心概念总览
原创2021-12-31 12:08·牛旦视界
编者按：
这篇内容将帮助你总体认识有关Spring框架相关的核心知识。我尽量在这里涵盖 Spring 框架的一些非常重要的概念。希望这可帮助你更好的总体把握Spring框架，促使你积极探索Spring的有趣的技术栈生态世界。


快速切入：Spring框架核心概念总览
Spring框架
1、Spring是什么?

简而言之，Spring是企业级Java的开源开发框架。Spring框架的核心功能可用于开发任何java应用程序。Spring框架的核心模块如下：

ü Spring Context（Spring上下文）:用于依赖注入（DI）；
ü Spring DAO（数据库访问对象）: 使用DAP模式进行数据库操作；
ü Spring JDBC: 用于JDBC和数据源的支持 ；
ü Spring ORM: 用于ORM工具支持，如Hibernate；
ü Spring AOP: 用于面向方面的编程；
ü Spring Web module: 用于创建Web应用。
快速切入：Spring框架核心概念总览
2、Spring框架的优点是什么

ü 轻量级：Spring时轻量级应用框架。 Spring框架的基本版本在2MB左右；
ü 依赖注入/控制反转 (DI/IoC)：这有助于通过连接独立的组件/对象来实现松散耦合；
ü Spring容器：包含和管理应用程序对象的生命周期；
ü 事务管理：Spring支持事务管理，即JDBC操作、文件上传、异常处理等，通过spring注解或bean配置来完成；
ü Spring MVC：Spring MVC 可用于创建 Web 应用程序以及能够返回 XML 或 JSON 响应的restful Web 服务；
ü 异常处理：Spring 提供了一个方便的 API 来将特定的技术异常（由 JDBC、Hibernate 等抛出）转换为一致的未经检查的异常；
ü 面向切面编程（AOP）：AOP 将程序逻辑分解为不同的部分（称为关注点）。它用于通过横切关注点来增加模块化。横切关注点是可以影响整个应用程序的关注点，应尽可能集中在代码中的一个位置，例如事务管理、身份验证、日志记录、安全性等。


3、什么是Spring Bean？

任何由 Spring IoC 容器初始化的普通 Java 类都称为 Spring Bean。我们使用 spring 应用程序上下文来获取 Spring Bean 实例。 Spring IoC Container 管理 Spring Bean 范围/作用域的生命周期并在 bean 中注入任何所需的依赖项。

Spring bean的不同作用域：

当我们声明 <bean> 时，我们可以指定 bean 的作用域来通知 IoC 容器关于 bean 的创建以及它将存活多长时间。

对于任何 Java 应用程序，都有两个不同的作用域，称为单例（Singleton）和原型（Prototype）

主要有三种不同的作用域（或范围），即请求（request）、会话（session）和全局会话（global-session），专门针对基于 Spring 的 Java Web 应用程序。

Singleton 是任何 bean 的默认作用域。这意味着每个 IoC 容器将创建单个 bean 实例。因此，单例 bean 不是线程安全的。

在原型范围内，每次请求 bean 时都会创建一个新实例。
在请求范围内，单个 bean 被定义到一个 HTTP 请求内。此范围仅在支持 Web 的 spring ApplicationContext 中有效。
在会话范围内，单个 bean 被定义到一个 HTTP 会话内。此范围仅在支持 Web 的 spring ApplicationContext 中有效。
在 global-session 范围内，bean 被定义为全局 HTTP 会话内有效。此范围仅在支持 Web 的 spring ApplicationContext 中有效。
要设置 spring bean 的范围，我们可以在 <bean> 标签中使用scope属性。 @scope 用于基于注释的 DI。



4、Spring IoC 容器

Spring 容器是 Spring 框架的核心。容器将创建对象，把它们连接在一起，配置它们，并管理它们从创建到销毁的完整生命周期。 Spring 容器使用依赖注入 (DI) 来管理组成应用程序的组件。

有两种不同类型的容器：

BeanFactory 容器：这是 Spring 容器的核心。 
org.springframework.beans.factory.BeanFactory 是一个接口，充当 IoC 容器，它实例化、配置和管理许多 bean。应用示例如下：

Beans.xml:
<?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.0.xsd">

<bean id="helloWorld" class="com.newday.bean.HelloWorld">
<property name="message" value="Hello World!"/>
</bean>

</beans>

package com.newday.bean;

public class HelloWorld {
private String message;

public String getMessage() {
return message;
}

public void setMessage(String message) {
this.message = message;
}

}

MainApp.java:
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import com.newday.bean.HelloWorld;

public class MainApp {
public static void main(String args[]) {
Resource resource = new ClassPathResource("beans.xml");
BeanFactory beanFactory = new XmlBeanFactory(resource);

HelloWorld helloWorld = (HelloWorld) beanFactory.getBean("helloWorld");

System.out.println(helloWorld.getMessage());
}
}


ApplicationContext 容器：
org.springframework.context.ApplicationContext 接口也充当 IoC 容器，但 ApplicationContext 接口建立在 BeanFactory 接口之上，以提供一些BeanFactory 额外的功能，例如与 Spring 的 AOP 的简单集成、消息资源处理（对于 I18N )、事件传播、Web 应用程序的应用层特定上下文（例如 WebApplicationContext）。所以使用 ApplicationContext 比使用 BeanFactory更好些。示例代码如下：

<?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.0.xsd">

<bean id="helloWorld" class="com.newday.bean.HelloWorld">
<property name="message" value="Hello World!"/>
</bean>

</beans>

package com.newday.bean;

public class HelloWorld {
private String message;

public String getMessage() {
return message;
}

public void setMessage(String message) {
this.message = message;
}

}

package com.newday.applicationcontext;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.newday.bean.HelloWorld;

public class MainApp {
public static void main(String args[]) {
ApplicationContext appContext = new ClassPathXmlApplicationContext("beans.xml");

HelloWorld helloWorld = (HelloWorld) appContext.getBean("helloWorld");

System.out.println(helloWorld.getMessage());

}
}
5、@Autowired

对于基于注解的依赖注入，使用@Autowired 注解。标有@Component/@Service/@Repository 等的类可以注入到标有@Autowired 的属性中

@Autowired 应用于:

ü 字段域：用于基于字段的依赖注入；
ü setter：用于setter依赖注入 。与基于字段的依赖注入相同；
ü 构造器：基于构造函数的依赖注入。


1）基于构造器和setter的区别

ü 依赖项的注入可以是可选的，也可以是强制性的。对于强制注入，我们使用基于构造函数的 DI。对于可选的依赖项，我们可以使用基于 setter 的 DI。但是，我们可以使用 @Required 注释标记基于 setter 的 DI。
ü 在循环依赖的情况下，基于构造器的 DI 将无法注入，但基于 setter 的 DI 将能够注入
ü 如果要注入更多数量的参数，则建议使用基于构造函数的 DI。


2）context:annotation-config 和 context:component-scan 的区别

ü context:annotation-config 用于激活已在应用程序上下文中注册的 bean 中的注释;
ü context:component-scan 也可以执行 context:annotation-config 所做的工作，但也可以扫描包以在应用程序上下文中查找和注册 bean。
3）@Component、@Controller、@Repository & @Service 注解的区别

如果一个类用@Component/@Controller/@Service/@Repository 注解标记，那么Spring DI 容器可以在组件扫描机制期间识别该类。但是，对于服务层类使用@Service 是个好主意，并且@Controller 应该在spring mvc web 控制器中使用。 @Repository 用于将 DAO 导入 DI 容器。此外，任何未经检查的异常都将被转换为 Spring DataAccessException。

4）ViewResolver 与 MultipartResolver

ViewResolver 用于按名称解析视图。该接口由 
InternalResourceViewResolver 实现 ;

MultipartResolver 用于处理 web 应用程序中的文件上传。

5）Spring MVC 中的验证


org.springframework.validation.Validator 接口支持 spring MVC 验证。验证表单的一些实用方法是 ValidationUtils 类中的 rejectIfEmptyOrWhitespace() 和 rejectIfEmpty()。示例如下：

@Component
public class EmployeeValidator implements Validator{
public boolean supports(Class clazz) {
return EmployeeVO.class.isAssignableFrom(clazz);
}

public void validate(Object target, Errors errors){
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "firstName", "error.firstName", "First name is required.");
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "lastName", "error.lastName", "Last name is required.");
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "email", "error.email", "Email is required.");
}
}
Spring MVC 中验证表单的另一种方法是:

对模型 bean 的属性使用Hibernate验证（例如 @NotNull、@Size 等）
在控制器的方法签名中使用@Valid、BindingResult。
BindingResult.hasErrors() 方法来验证模型 bean。
6、Spring MVC 拦截器

HandlerInterceptor 接口充当 spring MVC 拦截器。它在服务请求之前和之后拦截。如果您实现了 HandlerInterceptor 接口，则 preHandle()、postHandle() 和 afterCompletion() 是要覆盖的方法。但是，为了避免覆盖，您可以使用 HandlerInterceptorAdapter 类。

7、Spring MVC 框架中的异常处理

Spring 中的异常是使用 
SimpleMappingExceptionResolver 类以声明方式处理的。您要处理的异常列表是针对 exceptionMapping 属性配置的。如果有异常发生在流程中的任何地方，都将被捕获并显示相应的视图。对于所有其他异常，您可以针对 defaultErrorView 属性捕获它们。示例配置如下：

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<property name="exceptionMappings">
<props>
<prop key="com.newday.exception.XYZException">
error/xyzExceptionView
</prop>
</props>
</property>
<property name="defaultErrorView" value="error/genericExceptionView"/>
</bean>
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
  • 61.
  • 62.
  • 63.
  • 64.
  • 65.
  • 66.
  • 67.
  • 68.
  • 69.
  • 70.
  • 71.
  • 72.
  • 73.
  • 74.
  • 75.
  • 76.
  • 77.
  • 78.
  • 79.
  • 80.
  • 81.
  • 82.
  • 83.
  • 84.
  • 85.
  • 86.
  • 87.
  • 88.
  • 89.
  • 90.
  • 91.
  • 92.
  • 93.
  • 94.
  • 95.
  • 96.
  • 97.
  • 98.
  • 99.
  • 100.
  • 101.
  • 102.
  • 103.
  • 104.
  • 105.
  • 106.
  • 107.
  • 108.
  • 109.
  • 110.
  • 111.
  • 112.
  • 113.
  • 114.
  • 115.
  • 116.
  • 117.
  • 118.
  • 119.
  • 120.
  • 121.
  • 122.
  • 123.
  • 124.
  • 125.
  • 126.
  • 127.
  • 128.
  • 129.
  • 130.
  • 131.
  • 132.
  • 133.
  • 134.
  • 135.
  • 136.
  • 137.
  • 138.
  • 139.
  • 140.
  • 141.
  • 142.
  • 143.
  • 144.
  • 145.
  • 146.
  • 147.
  • 148.
  • 149.
  • 150.
  • 151.
  • 152.
  • 153.
  • 154.
  • 155.
  • 156.
  • 157.
  • 158.
  • 159.
  • 160.
  • 161.
  • 162.
  • 163.
  • 164.
  • 165.
  • 166.
  • 167.
  • 168.
  • 169.
  • 170.
  • 171.
  • 172.
  • 173.
  • 174.
  • 175.
  • 176.
  • 177.
  • 178.
  • 179.
  • 180.
  • 181.
  • 182.
  • 183.
  • 184.
  • 185.
  • 186.
  • 187.
  • 188.
  • 189.
  • 190.
  • 191.
  • 192.
  • 193.
  • 194.
  • 195.
  • 196.
  • 197.
  • 198.
  • 199.
  • 200.
  • 201.
  • 202.
  • 203.
  • 204.
  • 205.
  • 206.
  • 207.
  • 208.
  • 209.
  • 210.
  • 211.
  • 212.
  • 213.
  • 214.
  • 215.
  • 216.
  • 217.
  • 218.
  • 219.
  • 220.
  • 221.
  • 222.
  • 223.
  • 224.
  • 225.
  • 226.
  • 227.
  • 228.
  • 229.
  • 230.
  • 231.
  • 232.

8、如何在 Spring Bean 中获取 ServletContext 和 ServletConfig 对象?

实现 ServletContextAware 和 ServletConfigAware 接口并覆盖以下方法：

@Controller
@RequestMapping(value = "/magic")
public class SimpleController implements ServletContextAware, ServletConfigAware {

private ServletContext context;
private ServletConfig config;

@Override
public void setServletConfig(final ServletConfig servletConfig) {
this.config = servletConfig;

}

@Override
public void setServletContext(final ServletContext servletContext) {
this.context = servletContext;
}

//other code
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.

9、Spring中的事务管理

数据库事务是一组被视为关联工作单元的操作。事务的主要原则是提交所有操作或在失败的情况下回滚所有操作。在交易中提交数据时，我们需要确保交易协议/称为 ACID(原子性-一致性-隔离-持久性)的属性：

  • ü 原子性(Atomicty)：事务中的所有操作都被视为一个工作单元。因此，事务将被提交或回滚。
  • ü 一致性(Consistency)：这通过维护数据库的引用完整性来确保事务将数据库从一个有效状态带到另一个有效状态。
  • ü 隔离性(Isolation)：每个事务都应该与其他事务隔离，即使它们处理的是同一组数据。
  • ü 持久性(Durability)：这确保一旦事务完成，数据将永久存在于数据库中。即使断电或系统崩溃，数据也不会丢失。

Spring 支持编程式和声明式两种事务管理。它还支持全局和本地事务。

全局事务 vs 本地事务：

  • ü 本地事务处理集中式系统中的单个数据源(例如 JDBC);
  • ü 全局事务处理分布式系统中的多个数据源(例如 JDBC、JMS)。一个全局事务是多个本地事务的集合;

编程式事务与声明式事务：

Spring 支持两种不同类型的事务管理，称为 编程式(Programatic) 和声明式(Declarative) 事务管理：

  • ü 编程式事务：这意味着，您需要在代码中管理事务。很难维护;
  • ü 声明式事务：这意味着要将事务管理代码与业务逻辑分开。因此需要使用 XML 或基于注释的配置来管理事务。 Spring AOP 模块支持声明式事务管理。

脏读、幻读和不可重复读：

  • ü 脏读：当一个事务正在更改记录/元组并且第二个事务在原始更改被提交或回滚之前尝试读取此元组/记录时，就会发生脏读。这被称为脏读场景，因为第一个事务总是有可能回滚更改，导致第二个事务读取无效值。
  • ü 幻读：幻读发生在同一查询在事务中执行两次，并且第二个结果集包含在第一个结果集中不可见的行。这种情况是由另一个事务在两个查询的执行之间插入新行引起的
  • ü 不可重复读：当在同一个事务中相同的查询产生不同的结果时，就会发生不可重复读取。这因为当另一个事务更新其他事务返回的数据时，就会发生这种情况。

隔离与传播：

  • ü 隔离度(Isolation)：此事务与其他事务的工作隔离的程度。例如，这个事务可以看到来自其他事务的未提交的写入吗?
  • ü 传播(Propagation)：在传播的情况下，代码将始终在事务范围内运行。创建一个新事务或重用一个(如果可用)。

10、HibernateDAOSupport 和 HibernateTemplate

在旧版本的 spring 和 hibernate 集成中，需要 HibernateDAOSupport 和 HibernateTemplate。但是，较新版本的 Spring 不建议使用这两个类(这里仅做了解)。

通常我们从 HibernateDAOSupport 扩展我们的 DAO 类，并且 getHibernateTemplate() 方法将可用于Hibernate会话中的 CRUD 操作。由于这不是推荐的方法，所以我们在 DAO 中注入会话工厂(SessionFactory)。下面的代码片段会给你一些关于 HibernateDAOSupport 和 HibernateTemplate 的想法:

public class EmployeeHibernateDao extends HibernateDaoSupport implements EmployeeDao {
@Transactional(readOnly=false)
public void saveEmployee(Employee emp){
System.out.println("Create new employee " + emp);
getHibernateTemplate().save(emp);
System.out.println("Employee created " + emp);
}
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.

11、Spring DAO 和 Spring ORM 的区别

DAO 是一种设计模式，以最大限度地减少应用程序和后端之间的耦合;

ORM 处理如何将对象映射到对象关系数据库中，从而减少数据库和应用程序之间的耦合。

如果您在没有 DAO 的情况下使用 ORM，那么您的应用程序将变得依赖于 ORM，因此很难从一个 ORM(例如Hibernate)移动到另一个 ORM(例如 NoSQL)。

Spring DAO 是使用@Repository 注解实现的。 Spring 存储库扩展 JPARepository 并传递 JPA 实体及其主键。

@Repository
public interface PersonRepository extends JPARepository<Person, PersonPK> {
public List findByFirstName(String firstName);
@Query("Your SQL query")
public List findByAddress(String firstName);
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.

最后，关于Spring框架相关的概念就简要介绍到这里，希望这能给你进入并深入Spring技术栈一个简单入口，而不会被Spring技术生态所惊吓(Spring现在都成软件开发技术的全家桶了，啥都有)——日进一步，锲而不舍，终将大成!


如何两天时间上线一款AI应用？
用自己的编程语言实现了一个网站（增强版）