Spring 面试题

TARGET DECK: Spring

1.6 Spring 不同的事件类型

Spring 的 ApplicationContext 提供了支持事件和代码中监听器的功能，可以创建 bean 来监听 ApplicationContext 中发布的事件。Spring 提供了 5 种标准的事件：

上下文更新事件-在容器调用 ConfigurableApplicationContext 的 refresh()方法时被触发。
上下文开始事件-当容器调用 ConfigurableApplicationContext 的 Start()方法开始/重新开始容器时触发该事件。
上下文停止事件-当容器调用 ConfigurableApplicationContext 的 Stop()方法停止容器时触发该事件。
上下文关闭事件-当 ApplicationContext 被关闭时触发该事件。容器被关闭时，其管理的所有单例 Bean 都被销毁。
请求处理事件-在 Web 应用中，当一个 http 请求（request）结束触发该事件。

如果一个 bean 实现了 ApplicationListener 接口，当一个 ApplicationEvent 被发布以后，bean 会自动被通知。

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

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

2.3 IOC 功能支持

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

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

2.6 Spring IoC 的实现机制

工厂模式+反射机制。

2.7 Spring 是如何设计 IOC 容器

Spring IoC 容器的设计主要是基于两个接口，一是 BeanFactory 接口的简单容器，另一个是 ApplicationContext 接口的高级容器。

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

ApplicationContext 接口作为 BeanFactory 的子接口，除了提供 BeanFactory 所具有的功能外，还继承了其他多个功能接口，为 BeanFactory 赋予了更高级的 IOC 容器特性。这些功能接口有：MessageSource 支持国际化，ResourcePatternResolver 统一的资源文件访问方式，ApplicationEventPublisher 提供在监听器中注册 Bean 的事件，同时加载多个配置文件，载入多个（有继承关系）上下文，使得每一个上下文都专注于一个特定的层次，比如应用的 web 层。

2.8 BeanFactory 和 ApplicationContext 的区别

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

一是，提供的功能不同。
BeanFactory：是 Spring 里面最底层的接口，包含了各种 Bean 的定义，读取 bean 配置文档，管理 bean 的加载、实例化，控制 bean 的生命周期，维护 bean 之间的依赖关系。
ApplicationContext 接口作为 BeanFactory 的子接口，除了提供 BeanFactory 所具有的功能外，还继承了其他多个功能接口，为 BeanFactory 赋予了更高级的 IOC 容器特性。这些功能接口有：MessageSource 支持国际化，ResourcePatternResolver 统一的资源文件访问方式，ApplicationEventPublisher 提供在监听器中注册 Bean 的事件，同时加载多个配置文件，载入多个（有继承关系）上下文，使得每一个上下文都专注于一个特定的层次，比如应用的 web 层。

二是，加载方式不同。
BeanFactory 采用 延迟加载 的形式来注入 Bean，只有使用到某个 Bean 时，才会对该 Bean 进行实例化。缺点是，不能提早发现配置依赖错误问题，只有在加载该错误 Bean 抛出异常时，才能发现错误。
ApplicationContext 采用一次洗创建所有 Bean 的形式。优点是，一次加载，后续直接调用省时间，顺便有利于检查配置依赖的正确性。缺点是，占内存，并且 Bean 较多时启动慢。

三是，注册方式不同。
BeanFactory 和 ApplicationContext 都支持 BeanPostProcessor、BeanFactoryPostProcessor 的使用。
BeanFactory 需要手动注册，而 ApplicationContext 则是自动注册。

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

一般来说直接使用 ApplicationContext 接口。

2.9 ApplicationContext 的实现类

ClassPathXmlApplicationContext：从系统类路径 classpath 下加载一个或多个 xml 配置文件，适用于 xml 配置的方式
FileSystemXmlApplicationContext：从系统磁盘下加载一个或多个 xml 配置文件（必须有访问权限）
XmlWebApplicationContext：从 web 应用下加载一个或多个 xml 配置文件，适用于 web 应用的 xml 配置方式
AnnotationConfigApplicationContext：从 Java 注解的配置类中 Spring 的 ApplicationContext 容器。使用注解避免使用 application. Xml 进行配置。相比 XML 配置，更加便捷。
AnnotationConfigWebApplicationContext：专门为 web 应用准备的用于读取注解创建容器的类。

3 Spring Bean

3.1 Spring Bean 概念

Spring Bean 就是被 Spring IOC 容器初始化、装配和管理的对象。这些 Beans 通过容器中配置的元数据创建。

Spring Bean 的定义包含了容器所需要的元数据，包括如何创建一个 Bean，生命周期，依赖等等。

3.2 Spring Bean 配置方式/提供配置元数据

(将 Bean 注入到 SpringIOC 容器的方式)
XML 配置文件、注解的配置、Java 的配置。

3.3 注入 Bean 的方式 —— XML

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

通过 set 方法注入；
通过构造器注入(通过 index 或 type 设置参数)；
静态工厂注入；
实例工厂注入。

3.7 Spring 内部 Bean 概念(Spring Inner Bean)

当一个 Bean 仅被用作另一个 Bean 的属性时，它能被声明为一个内部 Bean。
内部 Bean 可以用 setter 注入和构造方法注入的方式来实现；通常是匿名的；作用域一般是 prototype。

3.11 Bean 的生命周期

详细可见：Spring-42 Bean 生命周期

Bean 生命周期主要包含四个部分：实例化、填充属性、初始化、销毁。
实例化，实例化一个 Bean 对象。

实例化：

Bean 容器找到配置文件中 Spring Bean 的定义。
Bean 容器利用 Java Reflection API 创建一个 Bean 的实例。

填充属性：

如果涉及到一些属性值利用 set() 方法设置一些属性值。

初始化：

如果 Bean 实现了 BeanNameAware 接口，调用 setBeanName() 方法，传入 Bean 的名字。
如果 Bean 实现了 BeanClassLoaderAware 接口，调用 setBeanClassLoader() 方法，传入 ClassLoader 对象的实例。
如果 Bean 实现了 BeanFactoryAware 接口，调用 setBeanFactory() 方法，传入 BeanFactory 对象的实例。
与上面的类似，如果实现了其他 *.Aware 接口，就调用相应的方法。
如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcessor 对象，执行 postProcessBeforeInitialization() 方法
如果 Bean 实现了 InitializingBean 接口，执行 afterPropertiesSet() 方法。
如果 Bean 在配置文件中的定义包含 init-method 属性，执行指定的方法。
如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcessor 对象，执行 postProcessAfterInitialization() 方法

销毁：

当要销毁 Bean 的时候，如果 Bean 实现了 DisposableBean 接口，执行 destroy() 方法。
当要销毁 Bean 的时候，如果 Bean 在配置文件中的定义包含 destroy-method 属性，执行指定的方法。

其他参考：Spring Bean 的生命周期（非常详细） - Chandler Qian - 博客园

3.13 Bean 装配的概念

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

3.14 Bean 自动装配的概念

Spring 容器可以在不使用 <constructor-arg> 和 <property> 元素的情况下自动装配相互协作的 bean 之间的关系，这有助于减少编写一个大的基于 Spring 的应用程序的 XML 配置的数量。

3.15 Bean 自动装配的依据

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

no：默认不进行自动装配，只通过手动设置 ref 属性进行装配。
byName：通过 Bean 的名称进行装配，名称相同，自动装配。
byType：通过 Bean 的类型进行装配，类型相同，自动装配。
constructor：利用构造函数进行装配，并且构造函数的参数通过 byType 进行装配。
autodetect：自动探测，如果有构造方法，通过 construct 的方式自动装配，否则使用 byType 的方式自动装配。

3.16 Bean 自动装配的局限性

自动装配的局限性是：

覆盖的可能性：仍然可以使用 <constructor-arg> 和 <property> 设置指定依赖项，从而覆盖自动装配。
基本数据类型：你不能自动装配简单的属性，如基本数据类型，String 字符串，和类。
模糊特性：自动装配不如显式装配精确，如果有可能，建议使用显式装配。

3.18 Spring 如何解决出现同名的 bean

同一个配置文件内同名的 Bean，以最上面定义的为准。
不同配置文件中存在同名 Bean，后解析的配置文件会覆盖先解析的配置文件。
同文件中 ComponentScan 和 @Bean 出现同名 Bean。同文件下 @Bean 的会生效，@ComponentScan 扫描进来不会生效。通过@ComponentScan 扫描进来的优先级是最低的，原因就是它扫描进来的 Bean 定义是最先被注册的。

3.19 Spring 如何解决循环依赖问题

构造器的循环依赖: 这种依赖 spring 是处理不了的，直接抛出 BeanCurrentlyIncreationException 异常。
单例模式下的 setter 循环依赖: 通过“三级缓存”处理循环依赖。
非单例循环依赖: 无法处理。

3.20 Spring 中可以注入一个 null 和一个空字符串？

可以。

4 Spring AOP

4.1 AOP 概念、好处、应用场景

有两种编程方式，OOP 和 AOP。
OOP 是面向对象编程，Object-Oriented Programming。这种编程方式容易造成大量代码的重复，不利于各个模块的重用。
AOP 是面向切面编程，Aspect-Oriented Programming。这种编程方式将业务无关但是对多个对象产生影响的公共行为和逻辑抽取出来，并封装为一个可重用的模块，这个模块被命名为“切面”。这种编程方式可以减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。可用于权限认证、日志、事务处理等。

4.2 AOP 的两种实现方式

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

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

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

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

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

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

JDK 动态代理只提供接口的代理，不支持类的代理。核心 InvocationHandler 接口和 Proxy 类，InvocationHandler 通过 invoke()方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起；接着，Proxy 利用 InvocationHandler 动态创建一个符合某一接口的的实例, 生成目标类的代理对象。

如果代理类没有实现 InvocationHandler 接口，那么 Spring AOP 会选择使用 CGLIB 来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成指定类的一个子类对象，并覆盖其中特定方法并添加增强代码，从而实现 AOP。CGLIB 是通过继承的方式做的动态代理，因此如果某个类被标记为 final，那么它是无法使用 CGLIB 做动态代理的。

4.4 AOP 涉及的专业术语

切面（Aspect）
切面泛指交叉业务逻辑。常用的切面是通知（Advice）。实际就是对主业务逻辑的一种增强。

连接点（JoinPoint）
连接点指可以被切面植入的具体方法。通常业务接口中的方法均为连接点。

切入点（Pointcut）
切入点指声明的一个或多个连接点的集合。通过切入点指定一组方法。
被标记为 final 的方法是不能作为连接点与切入点的。因为最终的是不能被修改的，不能被增强的。

目标对象（Target）
目标对象指将要被增强的对象，即包含主业务逻辑的类的对象。

通知（Advice）
通知表示切面的执行时间，Advice 也叫增强。通知定义了增强代码切入到目标代码的时间点，是目标方法执行之前执行，还是之后执行等。通知类型不同，切入时间不同。切入点定义切入的位置，通知定义切入的时间。

4.5 AspectJ 的通知类型

AspectJ 中常用的通知有五种类型：
（1）前置通知 @Before 方法调用前通知
（2）最终通知 @After 方法完成后通知
（3）后置通知 @AfterReturning 方法成功执行后通知
（4）异常通知 @AfterThrowing 方法抛出异常后通知
（5）环绕通知 @Around 包裹方法

无异常：around before method around after afterReturning
有异常：around before method around after afterThrowing

4.6 切面的优先级

@Order(优先级)` 来控制切面内外的嵌套顺序。

优先级高的切面在外层，优先级低的切面在内层。数字越小，优先级越高。

外部缓存，内部事务。命中缓存就不需要事务。

4.7 其他问题

解释基于 XML Schema 方式的切面实现
在这种情况下，切面由常规类以及基于 XML 的配置实现。

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

有几种不同类型的自动代理？
BeanNameAutoProxyCreator
DefaultAdvisorAutoProxyCreator
Metadata autoproxying

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）是一个关注点，此关注点是整个应用都会使用的功能，并影响整个应用，比如日志，安全和数据传输，几乎应用的每个模块都需要的功能。因此这些都属于横切关注点。

5 Spring 事务

5.1 Spring 事务的实现方式

有两种实现方式，分别是编程式事务和声明式事务。
编程式事务，是在代码中硬编码，通过 TransactionTemplate 或者 TransactionManager 手动管理事务。
声明式事务，通过 XML 配置或 @Transactional 注解方式，即通过 AOP 实现。声明式事务可以将事务处理与业务代码解耦，代码侵入性低，实际使用较多。

5.2 Spring 事务的接口

PlatformTransactionManager：事务管理器，为不同的数据访问技术的事务提供不同的接口实现
TransactionDefinition：事务定义信息(事务隔离级别、传播行为、超时、只读、回滚规则)
TransactionStatus：事务的运行状态(是否新事务、有恢复点、是否只回滚、是否已完成)

5.3 Spring 事务的优点

它支持声明式事务管理。
提供了跨不同事务 api（如 JTA、JDBC、Hibernate、JPA 和 JDO）的一致编程模型。
它为编程事务管理提供了比 JTA 等许多复杂事务 API 更简单的 API。
它很好地集成了 Spring 的各种数据访问抽象。

5.4 Spring 事务的属性

传播行为
隔离级别
只读属性
超时属性
回滚规则

因为只读数据，所以传播被隔离了，触发超时，只能回滚。

5.5 Spring 事务的传播行为

事务的传播行为定义了事务嵌套时，事务该如何传播的行为。

PROPAGATION_REQUIRED

这是 Spring 默认的传播机制，能满足绝大部分业务需求。
如果外层有事务，则当前事务加入到外层事务，一块提交，一块回滚。
如果外层没有事务，则创建一个新的事务。

PROPAGATION_REQUIRES_NEW

每次开启新的事务。
外层有事务，把外层事务挂起，当前事务执行完毕，恢复上层事务的执行。
如果外层没有事务，执行当前新开启的事务即可。

PROPAGATION_SUPPORTS

如果外层有事务，则加入外层事务；
如果外层没有事务，则直接使用非事务方式执行。

PROPAGATION_NOT_SUPPORTED

该传播机制不支持事务。
如果外层存在事务则挂起，执行完当前代码，则恢复外层事务，无论是否异常都不会回滚当前的代码。

PROPAGATION_NEVER

不支持外层事务。该传播机制不支持外层事务，即如果外层有事务就抛出异常。

PROPAGATION_MANDATORY

与 NEVER 相反，如果外层没有事务，则抛出异常。MANDATORY 强制的。

PROPAGATION_NESTED

Spring 所特有的。
该传播机制的特点是可以保存状态保存点，当前事务回滚到某一个点，从而避免所有的嵌套事务都回滚，即各自回滚各自的，如果子事务没有把异常吃掉，基本还是会引起全部回滚，等价于 TransactionDefinition.PROPAGATION_REQUIRED。

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

Spring 事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring 是无法提供事务功能的。

真正的数据库层的事务提交和回滚是通过 binlog 或者 redo log 实现的。

5.7 Spring 事务的隔离级别

ISOLATION_DEFAULT，使用数据库默认的隔离级别。
ISOLATION_READ_UNCOMMITTED。
ISOLATION_READ_COMMITTED。
ISOLATION_REPEATABLE_READ。
ISOLATION_SERIALIZABLE。

5.8 Spring 事务的只读属性

readOnly 属性表明查询操作为只读，如果当前连接使用了增删改方法会抛出异常。

没必要加锁
一条查询语句没必要使用事务，多条需要使用。

5.9 Spring 事务的回滚异常

不配置 rollbackFor 属性，那么事物只会在遇到 RuntimeException 和 Error 的时候才会回滚，遇到检查型 (checked) 不会回滚。

通过设置 rollbackFor 属性可以根据特定异常进行回滚。

5.10 Spring 事务的超时属性

一个事务最长执行时间，超时自动回滚事务。

6 Spring 注解

6.1 什么是基于 Java 的 Spring 注解配置

利用 Java 的注解特性，在少量的 Java 注解的帮助下，进行大部分 Spring 配置。

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

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

6.2 怎样开启注解装配？

注解装配在默认情况下是不开启的。

Spring 配置文件中配置 <context:annotation-config/> 元素。

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

@Component：这将 java 类标记为 bean。它是任何 Spring 管理组件的通用构造型。spring 的组件扫描机制现在可以将其拾取并将其拉入应用程序环境中。
@Controller：这将一个类标记为 Spring Web MVC 控制器。标有它的 Bean 会自动导入到 IoC 容器中。
@Service：这个注解是具有类似用途和功能的 @Component 注解的特化。相较于@Component 没有多余行为，仅仅表明是服务层类。
@Repository：这个注解是具有类似用途和功能的 @Component 注解的特化。它将 DAO 导入 IoC 容器，并使未经检查的异常有资格转换为 Spring DataAccessException。

6.4 @Required 注解有什么作用

表明 bean 的属性必须在配置 bean 的时候设置。通过显示或自动装配。

若@Required 注解的 bean 属性未被设置，容器将抛出 BeanInitializationException。

6.5 @Autowired 和 @Resource 之间的区别

@Autowired 和@Resource 都可用于：构造函数、Setter 方法、成员变量，都可以用来装配 bean。

@Autowired 和 @Resource 之间的区别

@Autowired 默认按类型装配，属于 Spring 注解；@Resource 默认按照名称装配，属于 Java 注解。
@Autowired 默认按类型装配；实现按名称装配需要@Autowired + @Qualifier 注解；默认对象必须存在，若可以为 null，required 属性为 false。
@Resource 根据 name 和 type 属性的有无，四种不同的装配方式。

6.6 @Qualifier 注解有什么作用

和@Autowired 注解一起使用，来对修饰的对象使用按名称装配。常用于对多个相同类型 bean 中只装配其中一个 bean 的场景。

7 Spring 数据访问

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

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

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

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

7.3 解释 JDBC 抽象和 DAO 模块

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

7.4 spring DAO 有什么用？

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

7.5 spring JDBC API 中存在哪些类？

JdbcTemplate
SimpleJdbcTemplate
NamedParameterJdbcTemplate
SimpleJdbcInsert
SimpleJdbcCall

7.6 JdbcTemplate 是什么

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

7.7 其他问题

使用 Spring 通过什么方式访问 Hibernate？使用 Spring 访问 Hibernate 的方法有哪些？
在 Spring 中有两种方式访问 Hibernate：

使用 Hibernate 模板和回调进行控制反转
扩展 HibernateDAOSupport 并应用 AOP 拦截器节点

如何通过 HibernateDaoSupport 将 Spring 和 Hibernate 结合起来？
用 Spring 的 SessionFactory 调用 LocalSessionFactory。集成过程分三步：

配置 the Hibernate SessionFactory
继承 HibernateDaoSupport 实现一个 DAO
在 AOP 支持的事务中装配

如何使用 JPA 在数据库中非持久化一个字段？

假如我们有下面一个类：

@Entity(name="USER")
public class User {
 
 @Id
 @GeneratedValue(strategy = GenerationType.AUTO)
 @Column(name = "ID")
 private Long id;
 
 @Column(name="USER_NAME")
 private String userName;
 
 @Column(name="PASSWORD")
 private String password;
 
 private String secrect;
 
}

如果我们想让 secrect 这个字段不被持久化，也就是不被数据库存储怎么办？我们可以采用下面几种方法：

static String transient1; // not persistent because of static
final String transient2 = “Satish”; // not persistent because of final
transient String transient3; // not persistent because of transient
@Transient
String transient4; // not persistent because of @Transient

一般使用后面两种方式比较多，我个人使用注解的方式比较多。

🪴 Obsidian Publish

探索