# Spring 面试问答
> 原文: [https://howtodoinjava.com/interview-questions/top-spring-interview-questions-with-answers/](https://howtodoinjava.com/interview-questions/top-spring-interview-questions-with-answers/)
我已经尝试收集了这些**Spring 面试问题**,您可能会在下一次技术面试中面对这些问题。 对于其他 Spring 课程,我将分别分享面试问题和答案。 如果您能提出以前面试中遇到过的更多类似 Spring 面试问题,并考虑提出它们作为**专家级 Spring 面试问题**,我将不胜感激。 我将它们添加到此列表中。 这对于其他学习者也将有很大的帮助。
## Spring 面试题
[1.什么是 Spring Framework? 它的主要模块是什么?](#spring_framework)
[2.使用 Spring Framework 有什么好处?](#spring_benefits)
[3.什么是控制反转(IoC)和依赖注入?](#ioc_di)
[4.在 Spring Framework 中解释 IoC?](#ioc_in_spring)
[5\. `BeanFactory`和`ApplicationContext`之间的区别?](#beanfactory_vs_applicationcontext)
[6.您可以通过多种方式将 Spring 配置到我们的应用程序中?](#spring_configuration_types)
[7.什么是基于 Spring XML 的配置?](#xml_based_configuration)
[8.什么是基于 Spring Java 的配置?](#java_based_configuration)
[9.什么是基于 Spring 注解的配置?](#annotation_based_configuration)
[10.解释 Spring Bean 的生命周期吗?](#bean_lifecycle)
[11.什么是不同的 Spring Bean 范围?](#bean_scopes)
[12\. Spring 中的内部 bean 是什么?](#inner_beans)
[13\. 单例 bean 在 Spring Framework 中线程安全吗?](#singleton_bean_threadsafe)
[14.如何在 Spring 中注入 Java 集合? 举个例子?](#inject_collection)
[15.如何将`java.util.Properties`注入 Spring Bean?](#inject_properties)
[16.解释 Spring Bean 自动装配吗?](#bean_autowiring)
[17.解释 Bean 自动装配的不同模式吗?](#autowiring_modes)
[18.如何打开基于注解的自动装配?](#enable_autowiring)
[19.用示例解释`@Required`注解?](#required_annotation)
[20.用示例解释`@Autowired`注解?](#autowired_annotation)
[21.用示例解释`@Qualifier`注解?](#qualifier_annotation)
[22.构造函数注入和 setter 注入之间的区别?](#constructor_vs_setter_injection)
[23\. Spring 框架中不同类型的事件是什么?](#applicationcontext_events)
[24\. `FileSystemResource`和`ClassPathResource`之间的区别?](#filesystemresource_vs_classpathresource)
[25.列举一些 Spring 框架中使用的设计模式吗?](#design_patterns_used_in_spring)
## 1\. 什么是 Spring 框架? 它的主要模块是什么?
**Spring 框架**是一个 Java 平台,为开发 Java 应用程序提供全面的基础架构支持。 Spring 处理基础结构部分,因此您可以专注于应用程序部分。 在其内部,Spring 框架将形式化的设计模式编码为一流的对象,您可以将它们集成到自己的应用程序中,而不必担心它们在后端如何工作。
目前,Spring 框架由组织为约 20 个模块的功能组成。 这些模块分为核心容器,数据访问/集成,Web,AOP(面向切面的编程),规范,消息传递和测试,如图所示。 下图。
![spring modules](https://img.kancloud.cn/52/38/5238ead049ab1b070bf09605f1b03575_720x540.jpg)
> **阅读更多: [Spring 框架教程](https://howtodoinjava.com/java-spring-framework-tutorials/)**
## 2\. 使用 Spring 框架有什么好处?
以下是使用 Spring Framework 的一些主要好处的清单:
* 使用 [**依赖注入(DI)**](https://howtodoinjava.com/spring/spring-core/inversion-of-control-ioc-and-dependency-injection-di-patterns-in-spring-framework-and-related-interview-questions/) 方法,依赖在构造函数或 JavaBean 属性中是显式的且显而易见的。
* IoC 容器往往是轻量级的,特别是例如与 EJB 容器相比时。 这对于在内存和 CPU 资源有限的计算机上开发和部署应用程序很有用。
* Spring 并没有彻底改变这种状况,它确实利用了一些现有技术,例如几个 ORM 框架,日志记录框架,JEE,Quartz 和 JDK 计时器以及其他视图技术。
* Spring 以模块化的方式组织。 即使包和类的数量很多,您也只需要担心需要的包而忽略其余的包。
* [**测试用 Spring 编写的应用程序**](https://howtodoinjava.com/junit/how-to-unit-test-spring-security-authentication-with-junit/) 很简单,因为依赖于环境的代码已移入该框架。 此外,通过使用 JavaBean 风格的 POJO,使用依赖注入来注入测试数据变得更加容易。
* Spring 的 Web 框架是精心设计的 Web MVC 框架,它提供了 Struts 之类的 Web 框架或其他经过精心设计或不太受欢迎的 Web 框架的绝佳替代。
* Spring 提供了一个一致的事务管理接口,该接口可以按比例缩小到本地事务(例如,使用单个数据库),并可以扩大到全局事务(例如,使用 JTA)。
## 3\. 什么是控制反转(IoC)和依赖注入?
在软件工程中,控制反转(IoC)是一种编程技术,其中对象耦合在运行时由汇编程序对象绑定,并且通常在编译时使用静态分析是未知的。 在传统编程中,业务逻辑的流程由静态分配给彼此的对象确定。 在控制反转的情况下,流程依赖于由汇编程序实例化的对象图,并且通过抽象定义对象交互来使流程成为可能。 绑定过程是通过“依赖注入”实现的。
**控制反转**是一种设计示例,旨在为您的应用程序的目标组件(实际上是在工作的组件)提供更多控制。
**依赖注入**是一种模式,用于创建其他对象依赖的对象实例,而在编译时不知道将使用哪个类来提供该功能。 控制反转依赖于依赖项注入,因为需要一种机制来激活提供特定功能的组件。 否则,如果框架不再受控制,框架将如何知道要创建哪些组件?
在 Java 中,依赖项注入可能通过 3 种方式发生:
1. **构造函数注入**
2. **二传手注入**
3. **接口注入**
## 4\. 在 Spring Framework 中解释 IoC?
`org.springframework.beans`和`org.springframework.context`软件包为 Spring Framework 的 IoC 容器提供了基础。`BeanFactory`接口提供了一种高级配置机制,能够管理任何性质的对象。`ApplicationContext`接口建立在`BeanFactory`之上(它是一个子接口),并添加了其他功能,例如[**集成更容易**](https://howtodoinjava.com/category/frameworks/java-spring-tutorials/spring-aop/),[消息资源处理](https://howtodoinjava.com/spring/spring-mvc/spring-mvc-internationalization-i18n-and-localization-i10n-example/)(用于国际化),事件传播和特定于应用程序层的上下文,例如`WebApplicationContext`用于 Web 应用程序。
`org.springframework.beans.factory.BeanFactory`是 Spring IoC 容器的实际表示,该容器负责包含和管理上述 bean。`BeanFactory`接口是 Spring 中的中央 IoC 容器接口。
## 5\. `BeanFactory`和`ApplicationContext`之间的区别?
`BeanFactory`就像一个工厂类,其中包含一组 bean。 `BeanFactory` 在其内部保存多个 Bean 的 Bean 定义,然后在客户要求时实例化 Bean。 `BeanFactory`能够在实例化协作对象之间创建关联。 这消除了 bean 本身和 bean 客户端的配置负担。 `BeanFactory`也参与了 bean 的生命周期,调用了自定义的初始化和销毁方法。
从表面上看,应用程序上下文与 Bean 工厂相同。 两者都装入 bean 定义,将 bean 装在一起,并根据请求分配 bean。 但它也提供:
1. 解决文本消息的方法,包括对**国际化**的支持。
2. 加载文件资源的通用方法。
3. 注册为监听器的 bean 的事件。
`ApplicationContext`的三种常用实现是:
1. `ClassPathXmlApplicationContext`:它从位于类路径中的 XML 文件中加载上下文定义,将上下文定义视为类路径资源。 使用代码从应用程序的类路径中加载应用程序上下文。
```java
ApplicationContext context = new ClassPathXmlApplicationContext(“bean.xml”);
```
2. `FileSystemXmlApplicationContext`:它从文件系统中的 XML 文件加载上下文定义。 使用代码从文件系统中加载应用程序上下文。
```java
ApplicationContext context = new FileSystemXmlApplicationContext(“bean.xml”);
```
3. `XmlWebApplicationContext`:它从 Web 应用程序中包含的 XML 文件中加载上下文定义。
## 6\. 您可以通过多种方式将 Spring 配置到我们的应用程序中?
您可以通过 3 种方式在应用程序中配置 spring:
1. 基于 XML 的配置
2. 基于注解的配置
3. 基于 Java 的配置
## 7\. 什么是基于 Spring XML 的配置?
在 Spring 框架中,bean 需要的依赖项和服务在配置文件中指定,配置文件通常以 XML 格式。 这些配置文件通常以`<beans>`标记开头,并包含许多 bean 定义和特定于应用程序的配置选项。
Spring XML 配置的主要目标是使用 xml 文件配置所有 Spring 组件。
这意味着将不存在任何其他类型的 Spring 配置(例如注解或通过 Java 类进行的配置)。
**Spring XML 配置**使用 Spring 命名空间使配置中使用的 XML 标记集可用。 Spring 的主要名称空间包括:`context`,`bean`,`jdbc`,`tx`,`aop`,`mvc`和`aso`。
```java
<beans>
<!-- JSON Support -->
<bean name="viewResolver" class="org.springframework.web.servlet.view.BeanNameViewResolver"/>
<bean name="jsonTemplate" class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/>
<bean id="restTemplate" class="org.springframework.web.client.RestTemplate"/>
</beans>
```
在下面仅配置`DispatcherServlet`的最简单的`web.xml`文件将为您的应用程序加载配置文件并为您配置运行时组件。
```java
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>spring</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>spring</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
```
## 8\. 什么是基于 Spring Java 的配置?
Spring 的新 Java 配置支持中的主要工件是`@Configuration`注解的类和`@Bean`注解的方法。
`@Bean`注解用于指示方法实例化,配置和初始化要由 Spring IoC 容器管理的新对象。 `@Bean`注解与`<bean/>`元素具有相同的作用。
用`@Configuration`注解一个类表示该类的主要目的是作为 Bean 定义的来源。 此外,`@Configuration`类允许通过简单地调用同一类中的其他`@Bean`方法来定义 Bean 之间的依赖关系。 最简单的`@Configuration`类如下:
```java
@Configuration
public class AppConfig
{
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}
```
上面的 java 配置的等效 XML 配置为:
```java
<beans>
<bean id="myService" class="com.howtodoinjava.services.MyServiceImpl"/>
</beans>
```
要实例化此类配置,您将需要`AnnotationConfigApplicationContext`类的帮助。
```java
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
MyService myService = ctx.getBean(MyService.class);
myService.doStuff();
}
```
要启用组件扫描,只需注解您的`@Configuration`类,如下所示:
```java
@Configuration
@ComponentScan(basePackages = "com.howtodoinjava")
public class AppConfig {
...
}
```
在上面的示例中,将扫描`com.acme`包,查找任何带有`@Component`注解的类,并将这些类注册为容器内的 Spring bean 定义。
如果在 Web 应用程序中使用上述配置,则将使用`AnnotationConfigWebApplicationContext`类。 在配置 Spring `ContextLoaderListener` Servlet 监听器,Spring MVC `DispatcherServlet`等时,可以使用此实现。
```java
<web-app>
<!-- Configure ContextLoaderListener to use AnnotationConfigWebApplicationContext instead of the default XmlWebApplicationContext -->
<context-param>
<param-name>contextClass</param-name>
<param-value>
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
</param-value>
</context-param>
<!-- Configuration locations must consist of one or more comma- or space-delimited fully-qualified @Configuration classes. Fully-qualified packages may also be specified for component-scanning -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>com.howtodoinjava.AppConfig</param-value>
</context-param>
<!-- Bootstrap the root application context as usual using ContextLoaderListener -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- Declare a Spring MVC DispatcherServlet as usual -->
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- Configure DispatcherServlet to use AnnotationConfigWebApplicationContext instead of the default XmlWebApplicationContext -->
<init-param>
<param-name>contextClass</param-name>
<param-value>
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
</param-value>
</init-param>
<!-- Again, config locations must consist of one or more comma- or space-delimited and fully-qualified @Configuration classes -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>com.howtodoinjava.web.MvcConfig</param-value>
</init-param>
</servlet>
<!-- map all requests for /app/* to the dispatcher servlet -->
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/app/*</url-pattern>
</servlet-mapping>
</web-app>
```
## 9\. 什么是基于 Spring 注解的配置?
从 Spring 2.5 开始,可以使用注解配置依赖项注入。 因此,可以使用相关类,方法或字段声明上的注解,而不是使用 XML 来描述 bean 的连接,而可以将 bean 配置移入组件类本身。 注解注入在 XML 注入之前执行,因此对于通过两种方法连接的属性,后一种配置将覆盖前者。
默认情况下,Spring 容器中的注解装配未打开。 因此,在使用基于注解的连接之前,我们需要在 Spring 配置文件中启用它。 因此,如果您想在 Spring 应用程序中使用任何注解,请考虑使用以下配置文件。
```java
<beans>
<context:annotation-config/>
<!-- bean definitions go here -->
</beans>
```
一旦配置了`<context:annotation-config/>`,就可以开始注解代码,以指示 Spring 应该自动将值连接到属性,方法和构造函数中。
在这种类型的配置中,很少使用的重要注解是:
1. `@Required`:`@Required`注解适用于 bean 属性设置器方法。
2. `@Autowired`:`@Autowired`注解可以应用于 bean 属性设置器方法,非设置器方法,构造函数和属性。
3. `@Qualifier`:`@Qualifier`注解与`@Autowired`一起使用,可以通过指定要连接的确切 bean 来消除混淆。
4. **JSR-250 注解**:Spring 支持基于 JSR-250 的注解,包括`@Resource`,`@PostConstruct`和`@PreDestroy`注解。
## 10\. 解释 Spring Bean 的生命周期吗?
易于理解的是 Spring bean 的生命周期。 实例化 Bean 时,可能需要执行一些初始化以使其进入可用状态。 同样,当不再需要 bean 并将其从容器中删除时,可能需要进行一些清理。
Spring bean 工厂负责管理通过 spring 容器创建的 bean 的生命周期。 bean 的生命周期由**回调方法组成,这些方法可以大致分为两类**:
1. 发布初始化回调方法
2. 销毁前回调方法
Spring 框架提供了以下 **4 种方法来控制 bean 的生命周期事件**:
* `InitializingBean`和`DisposableBean`回调接口
* 其他用于特定行为的`Aware`接口
* Bean 配置文件中的自定义`init()`和`destroy()`方法
* `@PostConstruct`和`@PreDestroy`注解
例如,`customInit()`和`customDestroy()`方法是生命周期方法的示例。
```java
<beans>
<bean id="demoBean" class="com.howtodoinjava.task.DemoBean" init-method="customInit" destroy-method="customDestroy"></bean>
</beans>
```
> **阅读更多信息:[SpringBean 生命周期](https://howtodoinjava.com/spring/spring-core/spring-bean-life-cycle/)**
## 11\. Spring Bean 范围有哪些不同?
可以在五个 **bean 范围**中创建 spring 容器中的 bean。 所有作用域名称都是不言自明的,但请明确说明它们,以免产生任何疑问。
1. **单例**:此 bean 范围是默认值,它强制容器在每个 spring 容器中只有一个实例,而不管您请求实例的时间是多少。 这种单例行为由 bean 工厂本身维护。
2. **原型**:该 bean 作用域只是反转单例作用域的行为,每次每次请求 bean 都产生一个新实例。
3. **请求**:在此 bean 作用域内,将为客户端的每个 Web 请求创建一个新的 bean 实例。 请求完成后,bean 将超出范围并被垃圾回收。
4. **会话**:就像请求范围一样,这确保了每个用户会话一个 bean 实例。 用户结束会话后,bean 不在范围内。
5. **全局会话**:全局会话是连接到 Portlet 应用程序的东西。 当您的应用程序在 Portlet 容器中工作时,它是由一定数量的 Portlet 构建的。 每个 portlet 都有其自己的会话,但是如果要在应用程序中为所有 portlet 全局存储变量,则应将其存储在全局回话中。 此作用域与基于 Servlet 的应用程序中的会话作用域没有任何特殊作用。
> **阅读更多:[SpringBean 范围](https://howtodoinjava.com/spring/spring-core/spring-bean-scopes/)**
## 12\. 什么是 Spring Bean?
在 Spring 框架中,每当一个 bean 仅用于一个特定属性时,建议将其声明为一个内部 bean。 内部 bean 在 setter 注入`property`和构造函数注入`constructor-arg`中均受支持。
例如,假设我们引用了`Person`类的一个`Customer`类。 在我们的应用程序中,我们将只创建`Person`类的一个实例,并在`Customer`中使用它。
```java
public class Customer
{
private Person person;
//Setters and Getters
}
```
```java
public class Person
{
private String name;
private String address;
private int age;
//Setters and Getters
}
```
现在,内部 bean 声明将如下所示:
```java
<bean id="CustomerBean" class="com.howtodoinjava.common.Customer">
<property name="person">
<!-- This is inner bean -->
<bean class="com.howtodoinjava.common.Person">
<property name="name" value="adminis"></property>
<property name="address" value="India"></property>
<property name="age" value="34"></property>
</bean>
</property>
</bean>
```
## 13\. 在 Spring 框架中,单例 bean 线程安全吗?
对于[**单例**](https://howtodoinjava.com/design-patterns/singleton-design-pattern-in-java/) bean 的多线程行为,Spring 框架不做任何事情。 开发人员有责任处理单例 bean 的并发问题和 [**线程安全**](https://howtodoinjava.com/java/multi-threading/what-is-thread-safety/) 。
实际上,大多数 SpringBean 没有可变状态(例如服务和 DAO 锁类),因此线程安全性很小。 但是如果您的 bean 处于可变状态(例如,查看模型对象),那么您需要确保线程安全。 解决此问题的最简单,最明显的方法是将可变 Bean 的范围从`singleton`更改为`property`。
## 14\. 如何在 Spring 中注入 Java 集合? 举个例子?
Spring 提供了四种类型的集合配置元素,如下所示:
+ `<list>`:这有助于装配,即注入值列表,允许重复。
+ `<set>`:这有助于装配一组值,但没有重复项。
+ `<map>`:这可以用于注入名称-值对的集合,其中名称和值可以是任何类型。
+ `<prop>`:这可用于注入名称-值对的集合,其中名称和值均为字符串。
我们来看每种类型的示例。
```java
<beans>
<!-- Definition for javaCollection -->
<bean id="javaCollection" class="com.howtodoinjava.JavaCollection">
<!-- java.util.List -->
<property name="customList">
<list>
<value>INDIA</value>
<value>Pakistan</value>
<value>USA</value>
<value>UK</value>
</list>
</property>
<!-- java.util.Set -->
<property name="customSet">
<set>
<value>INDIA</value>
<value>Pakistan</value>
<value>USA</value>
<value>UK</value>
</set>
</property>
<!-- java.util.Map -->
<property name="customMap">
<map>
<entry key="1" value="INDIA"/>
<entry key="2" value="Pakistan"/>
<entry key="3" value="USA"/>
<entry key="4" value="UK"/>
</map>
</property>
<!-- java.util.Properties -->
<property name="customProperies">
<props>
<prop key="admin">admin@nospam.com</prop>
<prop key="support">support@nospam.com</prop>
</props>
</property>
</bean>
</beans>
```
## 15\. 如何将`java.util.Properties`注入 Spring Bean?
第一种方法是使用`<prop>`标签,如下所示。
```java
<bean id="adminUser" class="com.howtodoinjava.common.Customer">
<!-- java.util.Properties -->
<property name="emails">
<props>
<prop key="admin">admin@nospam.com</prop>
<prop key="support">support@nospam.com</prop>
</props>
</property>
</bean>
```
您也可以使用`util:`命名空间从属性文件创建属性 bean,并使用 bean 引用进行 setter 注入。
```java
<util:properties id="emails" location="classpath:com/foo/emails.properties" />
```
## 16\. 解释 Spring Bean 自动装配吗?
在 spring 框架中,遵循配置文件中的 bean 依赖关系是一个好的做法,但是 spring 容器也能够自动装配协作 bean 之间的关系。 这意味着可以通过检查`BeanFactory`的内容来自动让 Spring 为您的 bean 解决协作者(其他 bean)。 [**自动装配**](https://howtodoinjava.com/2013/05/08/spring-beans-autowiring-concepts/) 为每个 bean 指定,因此可以为某些 bean 启用,而其他 bean 将不会自动装配。
XML 配置文件的以下摘录显示了按名称自动装配的 Bean。
```java
<bean id="employeeDAO" class="com.howtodoinjava.EmployeeDAOImpl" autowire="byName" />
```
除了 bean 配置文件中提供的自动装配模式外,还可以使用`@Autowired`注解在 bean 类中指定自动装配。 要在 bean 类中使用`@Autowired`注解,必须首先使用以下配置在 spring 应用程序中启用注解。
```java
<context:annotation-config />
```
使用配置文件中的`AutowiredAnnotationBeanPostProcessor` bean 定义可以实现相同的目的。
```java
<bean class ="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
```
现在,启用注解配置后,您可以使用`@Autowired`随意地自动绑定 bean 依赖项。
```java
@Autowired
public EmployeeDAOImpl ( EmployeeManager manager ) {
this.manager = manager;
}
```
## 17\. 解释 Bean 自动装配的不同模式吗?
Spring 框架中有**五种自动装配模式**。 让我们一一讨论。
1. `off`:该选项是 spring 框架的默认选项,表示自动装配为 OFF。 您必须使用 bean 定义中的标签显式设置依赖项。
2. `byName`:此选项启用基于 bean 名称的依赖项注入。 在 Bean 中自动装配属性时,属性名称用于在配置文件中搜索匹配的 Bean 定义。 如果找到这样的 bean,则将其注入属性。 如果找不到这样的 bean,则会引发错误。
3. `byType`:此选项启用基于 bean 类型的依赖项注入。 在 bean 中自动装配属性时,属性的类类型用于在配置文件中搜索匹配的 bean 定义。 如果找到这样的 bean,则将其注入属性。 如果找不到这样的 bean,则会引发错误。
4. `constructor`:构造函数自动装配与`byType`相似,但适用于构造函数参数。 在启用自动装配的 bean 中,它将查找构造函数参数的类类型,然后按类型对所有构造函数参数进行自动装配。 请注意,如果容器中没有一个完全属于构造函数参数类型的 bean,则会引发致命错误。
5. `autodetect`:通过自动检测进行自动装配使用两种模式之一,即构造函数或`byType`模式。 首先它将尝试寻找带有参数的有效构造函数,如果找到,则选择构造函数模式。 如果在 bean 中没有定义构造函数,或者存在显式的默认 no-args 构造函数,则选择`byType`自动装配模式。
## 18\. 如何打开基于注解的自动装配?
要启用`@Autowired`,您必须注册`AutowiredAnnotationBeanPostProcessor`,并且可以通过两种方式进行。
1.在 bean 配置文件中包含`<context:annotation-config >`。
```java
<beans>
<context:annotation-config />
</beans>
```
2.将`AutowiredAnnotationBeanPostProcessor`直接包含在 bean 配置文件中。
```java
<beans>
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
</beans>
```
## 19\. 用示例解释`@Required`注解?
在生产规模的应用程序中,可能在 IoC 容器中声明了成百上千个 bean,并且它们之间的依赖关系通常非常复杂。 setter 注入的缺点之一是,您很难检查是否已设置所有必需的属性。 为了解决这个问题,您可以设置`<bean>`的`依赖项检查`属性,并设置四个属性之一,即无,简单,对象或全部(默认为无)。
在现实生活中的应用程序中,您将不需要检查上下文文件中配置的所有 Bean 属性。 相反,您只想检查是否仅在某些特定的 Bean 中设置了特定的属性集。 Spring 使用`依赖项检查`属性的依赖项检查功能在这种情况下将无法为您提供帮助。 因此,要解决此问题,可以使用`@Required`注解。
要在类文件中的 bean 属性的 setter 方法上使用`@Required`注解,如下所示:
```java
public class EmployeeFactoryBean extends AbstractFactoryBean<Object>
{
private String designation;
public String getDesignation() {
return designation;
}
@Required
public void setDesignation(String designation) {
this.designation = designation;
}
//more code here
}
```
`RequiredAnnotationBeanPostProcessor`是一个 Spring bean 后处理器,用于检查是否已设置所有带有`@Required`注解的 bean 属性。 要启用此 bean 后处理器进行属性检查,必须在 Spring IoC 容器中注册它。
```java
<bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor" />
```
如果尚未设置任何带有`@Required`的属性,则此 bean 后处理器将抛出`BeanInitializationException`。
## 20\. 用示例解释`@Autowired`注解?
`@Autowired`注解提供了在何处以及如何实现自动装配的更细粒度的控制。 `@Autowired`注解可用于在 setter 方法上自动装配 bean,就像`@Required`注解,构造函数,具有任意名称和/或多个参数的属性或方法一样。
例如。 您可以在 setter 方法上使用`@Autowired`注解,以摆脱 XML 配置文件中的`<property>`元素。 当 Spring 找到用于 setter 方法的`@Autowired`注解时,**它将尝试通过在方法上键入自动装配来执行**。
您也可以将`@Autowired`应用于构造函数。 构造函数`@Autowired`注解指示即使在 XML 文件中配置 Bean 时不使用`<constructor-arg>`元素,创建该 Bean 时也应自动构造该构造函数。
```java
public class TextEditor {
private SpellChecker spellChecker;
@Autowired
public TextEditor(SpellChecker spellChecker){
System.out.println("Inside TextEditor constructor." );
this.spellChecker = spellChecker;
}
public void spellCheck(){
spellChecker.checkSpelling();
}
}
```
而且它的配置没有构造函数参数。
```java
<beans>
<context:annotation-config/>
<!-- Definition for textEditor bean without constructor-arg -->
<bean id="textEditor" class="com.howtodoinjava.TextEditor">
</bean>
<!-- Definition for spellChecker bean -->
<bean id="spellChecker" class="com.howtodoinjava.SpellChecker">
</bean>
</beans>
```
## 21\. 用示例解释`@Qualifier`注解?
`@Qualifier`表示哪个 bean 可以在字段上自动装配。 如果 Spring 否则无法使用`@Qualifier`注解消除 Bean 引用的歧义。
参见下面的示例,它将自动将`person` bean 连接到客户的`person`属性中。
```java
public class Customer
{
@Autowired
private Person person;
}
```
对于`Person`类,我们有两个 bean 定义。
```java
<bean id="customer" class="com.howtodoinjava.common.Customer" />
<bean id="personA" class="com.howtodoinjava.common.Person" >
<property name="name" value="lokesh" />
</bean>
<bean id="personB" class="com.howtodoinjava.common.Person" >
<property name="name" value="alex" />
</bean>
```
Spring 会知道应该自动装配哪个人的 bean? 没有。 在上面的示例中运行时,它会在下面的异常中命中:
```java
Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException:
No unique bean of type [com.howtodoinjava.common.Person] is defined:
expected single matching bean but found 2: [personA, personB]
```
要解决上述问题,您需要`@Quanlifier`告诉 Spring 应该自动装配哪个 bean。
```java
public class Customer
{
@Autowired
@Qualifier("personA")
private Person person;
}
```
## 22\. 构造函数注入和 setter 注入之间的区别?
请在下面找到明显的区别:
1. 在 Setter 注入中,可能会部分注入依赖项,这意味着如果我们有 3 个依赖项(如`int`,`string`,`long`),那么如果使用 setter 注入,则不必注入所有值。 如果您不注入,它将采用这些原语的默认值。 在构造函数注入中,不可能部分注入依赖项,因为调用构造函数时必须正确传递所有参数,否则,可能会出错。
2. 如果我们为同一属性编写 setter 和构造函数注入,则 Setter 注入将覆盖构造函数注入值。 但是,构造函数注入不能覆盖 setter 注入的值。 显而易见,因为首先要调用构造函数才能创建实例。
3. 使用 setter 注入,您不能保证是否注入了某些依赖关系,这意味着您可能拥有不完全依赖关系的对象。 另一切面,在准备好依赖项之前,构造函数注入不允许您构造对象。
4. 在构造函数注入中,如果对象 A 和 B 相互依赖,即 A 依赖于 B,反之亦然,则 Spring 在创建 A 和 B 的对象时会抛出`ObjectCurrentlyInCreationException`,因为在创建 B 之前无法创建对象,反之亦然 。 因此 spring 可以通过 setter 注入解决循环依赖关系,因为对象是在调用 setter 方法之前构造的。
## 23\. Spring 框架中有哪些不同类型的事件?
Spring 的`ApplicationContext`提供了在代码中支持事件和监听器的功能。 我们可以创建 bean 来监听通过`ApplicationContext`发布的事件。 通过`ApplicationEvent`类和`ApplicationListener`接口提供`ApplicationContext`中的事件处理。 因此,如果 bean 实现`ApplicationListener`,则每次`ApplicationEvent`发布到`ApplicationContext`时,都会通知该 bean。
```java
public class AllApplicationEventListener implements ApplicationListener < ApplicationEvent >
{
@Override
public void onApplicationEvent(ApplicationEvent applicationEvent)
{
//process event
}
}
```
Spring 提供以下 **5 个标准事件**:
1. `ContextRefreshedEvent`:在初始化或刷新`ApplicationContext`时,将发布此事件。 也可以使用`ConfigurableApplicationContext`接口上的`refresh()`方法来提高它。
2. `ContextStartedEvent`:使用`ConfigurableApplicationContext`接口上的`start()`方法启动`ApplicationContext`时,将发布此事件。 您可以轮询数据库,也可以在收到此事件后重新/启动任何已停止的应用程序。
3. `ContextStoppedEvent`:当使用`ConfigurableApplicationContext`接口上的`stop()`方法停止`ApplicationContext`时,将发布此事件。 收到此活动后,您可以进行必要的整理工作。
4. `ContextClosedEvent`:当使用`ConfigurableApplicationContext`接口上的`close()`方法关闭`ApplicationContext`时,将发布此事件。 关闭的环境已经到了生命的尽头。 它不能刷新或重新启动。
5. `RequestHandledEvent`:这是一个特定于 Web 的事件,告诉所有 Bean HTTP 请求已得到服务。
除上述之外,您可以通过扩展`ApplicationEvent`类来创建自己的自定义事件。 例如
```java
public class CustomApplicationEvent extends ApplicationEvent
{
public CustomApplicationEvent ( Object source, final String msg )
{
super(source);
System.out.println("Created a Custom event");
}
}
```
要监听此事件,请创建如下监听器:
```java
public class CustomEventListener implements ApplicationListener < CustomApplicationEvent >
{
@Override
public void onApplicationEvent(CustomApplicationEvent applicationEvent) {
//handle event
}
}
```
要发布此事件,您将需要`ApplicationContext`实例的帮助。
```java
CustomApplicationEvent customEvent = new CustomApplicationEvent( applicationContext, "Test message" );
applicationContext.publishEvent ( customEvent );
```
## 24\. `FileSystemResource`和`ClassPathResource`之间的区别?
在`FileSystemResource`中,您需要提供`spring-config.xml`(Spring 配置)文件相对于您的项目的路径或文件的绝对位置。
在`ClassPathResource`中,spring 使用`ClassPath`查找文件,因此`spring-config.xml`应该包含在类路径中。 如果`src`中有`spring-config.xml`,则由于`src`默认情况下位于类路径中,因此我们只能给出其名称。
**一句话,`ClassPathResource`在类路径中查找,而`FileSystemResource`在文件系统中查找。**
## 25\. 举出 Spring 框架中使用的一些设计模式吗?
有很多使用不同设计模式的负载,但是有一些显而易见的负载:
* **代理**-在 AOP 和远程调用中大量使用。
* **单例** – Spring 配置文件中定义的 bean 默认为单例。
* **模板方法** – 广泛用于处理样板重复代码,例如[`RestTemplate`](https://howtodoinjava.com/spring/spring-restful/spring-restful-client-resttemplate-example/),`JmsTemplate`和`JpaTemplate`。
* **前端控制器** – Spring 提供`DispatcherServlet`以确保传入的请求被分派到您的控制器。
* **视图助手** -Spring 具有许多自定义 JSP 标签和速度宏,以帮助将代码与视图中的表示分离。
* **依赖项注入** – 以整个`BeanFactory` / `ApplicationContext`概念为中心。
* **工厂模式**-用于创建对象实例的`BeanFactory`。
> **阅读更多:[编写 Spring 配置文件的最佳实践](https://howtodoinjava.com/spring/spring-core/13-best-practices-for-writing-spring-configuration-files/)**
请分享**最新的 Spring 面试问题**,您可能在任何面试中都遇到过这些问题。
学习愉快!
参考文献:
[Spring beans 文档](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/beans.html)
[Spring 事务](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/transaction.html)
[Spring AOP 官方指南](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/aop.html)
- HowToDoInJava Spring 教程
- Spring 5
- Spring 5 教程
- Spring 5 的新功能和增强功能
- Spring 使用注解配置 Bean
- Spring bean – XML 配置
- Spring – @Lazy加载
- Spring DispatcherServlet – 它是如何工作的?
- Spring @PostMapping示例 – @GetMapping示例
- Spring 5 MVC + Hibernate 5 示例
- Spring 和 CORS
- Spring Security 5 – Java 配置
- Spring Security 5 登录表单示例
- Spring
- Spring 教程
- Spring – IoC 容器
- Spring – 控制反转与依赖注入
- Spring 5 – Bean 范围
- Spring – Bean 生命周期
- Spring BeanPostProcessor示例
- SpringBean 自动装配 – @Autowired
- Spring 注解
- Spring – 原型注解
- Spring @Scheduled – 安排任务的 4 种方法
- Spring 定时器任务
- Spring – 应用事件
- Spring i18n – ResourceBundleMessageSource
- Spring ResourceLoaderAware - 在 Spring 中读取文件
- Spring 属性编辑器 – CustomEditorConfigurer示例
- Spring – 使用JavaMailSender发送电子邮件
- Spring 的无版本模式(最新版本)
- Spring 面试问答
- 编写配置文件的 13 个 Spring 最佳实践
- SpringBoot 2
- SpringBoot 教程
- spring-boot-starter-parent示例
- spring-boot-starter Maven 模板
- Spring Boot 多模块 Maven 项目示例
- Spring Boot 注解
- Spring Boot2 @SpringBootApplication自动配置
- Spring Boot 和 AOP
- Spring Boot 日志指南
- Spring Boot Devtools 教程
- Spring Boot WAR 包示例
- Spring Boot 2 REST API 示例
- Spring Boot Crud 操作示例与 Hibernate
- Spring Boot 2 – OAuth2 Auth 和资源服务器
- 在 Spring Boot 2 中进行测试
- Spring RestTemplate – Spring REST 客户端示例
- Spring Boot – CRUD 应用程序
- Spring Boot Hibernate 配置示例
- Spring Boot – 数据源配置
- Spring Boot 异常处理 – @ExceptionHandler示例
- Spring Boot 缓存示例教程
- 使用 Spring Boot 的 SpringRetry 模块示例
- Spring Boot Security Rest 基本身份验证示例
- Spring Boot 和 H2 数据库
- Spring Boot 2 和 ehcache 3 示例
- Spring Boot 2 与 Gson
- Spring Boot Remoting – Spring RMI 注解示例
- SpringBoot – 发送带有附件的电子邮件
- Spring Boot 面试问题
- SpringBoot
- SpringBoot – CommandLineRunner接口示例
- Spring Boot – 配置 Jetty 服务器
- Spring Boot 更改嵌入式服务器的默认端口
- Spring Boot – 更改上下文路径
- Spring Boot SSL(HTTPS)示例
- Spring Boot – 获取所有已加载的带有类类型信息的 bean
- Spring Boot – 自定义PropertyEditor配置示例
- Spring Boot @Scheduled注解示例
- Spring Boot Jersey 示例
- Spring Boot SOAP Web 服务示例
- Spring Boot SOAP 客户端 – WebServiceTemplate示例
- 带有嵌入式 ActiveMQ 的 Spring Boot JMSTemplate
- Spring Boot Hello World 示例 – Spring Boot REST 示例
- Spring Boot JSP 视图解析器示例
- SpringBoot – 执行器
- Spring Boot – 带有 JAX-RS 注解的基于角色的安全性
- Spring Boot RSS feed 和 ROAM
- Spring Boot ehcache 2 示例
- SpringBatch
- Spring Batch + Spring Boot Java 配置示例
- Spring Batch 事件监听器
- Spring Batch ItemProcessor示例
- 使用 Spring TaskScheduler进行 Spring Batch 作业调度
- Spring Batch Quartz Java 配置示例
- Spring Batch + Quartz + H2 Jdbcjobstore 示例
- 在 Quartz 作业中注入 Spring 依赖项
- Spring Batch FlatFileItemReader – 读取 CSV 示例
- Spring Batch FlatFileItemWriter – 写入 CSV 文件
- Spring Batch MultiResourceItemReader – 读取多个 CSV 文件示例
- Spring Batch 读取后删除或存档文件
- Spring Batch 已处理记录的计数示例
- Spring Batch CSV 到数据库 – Java 注解配置示例
- Spring Cloud
- 微服务 – 定义,原理和优势
- 服务监控 – Hystrix,Eureka 管理员和 Spring Boot 管理员
- Hoverfly – 微服务虚拟化示例
- ELK 堆栈示例教程
- Docker 的 Hello World 示例
- 集成 Git 的 Spring Cloud Config Server
- 使用 Netflix Eureka 进行 Spring Cloud 服务发现
- Consul 服务注册和发现示例
- Hystrix 断路器模式 – SpringCloud
- 如何将 Spring Boot 应用程序部署到 Cloud Foundry 平台
- Netflix Zuul 示例 – Zuul API 网关模式 – Spring Cloud 教程
- Spring Cloud Zipkin 和 Sleuth 示例
- Spring cloud ribbon 和 Eureka – 客户端负载均衡器示例
- Spring AOP
- Spring AOP 教程示例
- Spring AOP – AspectJ 注解配置示例
- Spring AOP + AspectJ XML 配置示例
- Spring AOP AspectJ @Before注解示例
- Spring AOP AspectJ @After注解示例
- Spring AOP AspectJ @Around注解示例
- Spring AOP AspectJ @AfterReturning注解示例
- Spring AOP AspectJ @AfterThrowing示例
- Spring AOP 事前建议示例
- Spring AOP 事后建议示例
- Spring AOP 围绕建议示例
- Spring AOP 返回后建议示例
- Spring AOP 抛出后建议示例
- Spring AOP AspectJ 切入点表达式示例
- Spring AOP – 切面顺序
- 带有加载时织入的非公开方法上的 Spring 事务
- Spring 热门 AOP 面试问题及答案
- Spring MVC
- Spring MVC 教程
- Spring MVC Hello World 示例
- 使用 Maven 和 JSTL 的 Spring MVC Hello World 示例
- Spring @RequestMapping注解示例
- Spring MVC 自定义验证器示例
- Spring Bean 验证 – JSR-303 注解
- Spring MVC 填充和验证下拉列表示例
- Spring MVC 示例 – 显示,验证和提交表单
- Spring MessageSourceAware Java Bean 示例
- Spring MVC XmlViewResolver配置示例
- Spring MVC 国际化(i18n)和本地化(i10n)示例
- Spring MVC 拦截器示例 – XML 和 Java 注解配置
- Spring HandlerInterceptor示例
- Spring MVC 在 ajax 和 jquery 中使用进度条上传多个文件
- Spring MVC 多文件上传示例
- Spring MVC 下载文件控制器示例
- Spring MVC 面试问题与答案
- Spring MVC InternalResourceViewResolver配置示例
- Spring MVC ResourceBundleViewResolver配置示例
- Spring MVC SimpleMappingExceptionResolver示例
- Spring MVC:<context:annotation-config>与<context:component-scan>
- ContextLoaderListener与DispatcherServlet
- SpringSecurity
- SpringSecurity 教程
- 具有保护切入点的 Spring 方法安全性
- Spring Security Siteminder 预身份验证示例
- Spring Security 登录表单示例
- 使用 JSP Taglibs 的 Spring 视图层安全
- Spring Security – JDBC 用户服务示例
- Spring Security UserDetailsService示例
- Spring Security 基本身份验证示例
- 使用 JUnit 测试 Spring Security Auth
- 使用@PreAuthorize和@Secured的 Spring 方法安全性
- Spring ORM
- Spring 3.2.5 AbstractRoutingDataSource示例
- Spring 3 和 Hibernate 4 集成示例教程
- Spring Hibernate 集成示例
- Spring REST
- Spring REST JSON 响应示例
- Spring REST XML 响应示例
- Spring REST 控制器示例
- 使用 JPA 配置的 Spring REST CRUD 示例
- Spring REST 异常处理示例
- Spring REST 请求主体和参数验证示例
- Spring REST 自定义令牌认证示例
- Spring REST – 多部分上传和下载示例
- Spring REST Multipart – 多部分上传示例
- Spring REST – HTTP OPTIONS 请求处理器示例
- Spring REST – 访问被拒绝请求的 JSON 响应
- Spring RestTemplate – Spring REST 客户端示例
- Spring WebFlux
- Spring WebFlux 教程
- Spring Boot WebFlux WebSocket 示例
- 使用@WebFluxTest和WebTestClient进行 Spring Boot Webflux 测试
- HowToDoInJava Java 教程
- 核心 Java 教程
- 什么是 Java 编程语言?
- 什么是 Java JDK,JRE 和 JVM – 深入分析
- Java 命名约定
- Java 类路径
- Java 变量
- Java 运算符指南
- Java 关键字
- Java 中的数据类型
- Java 中的原始数据类型
- Java 包装器类 – 自动装箱,拆箱和转换示例
- Java 中的语句类型
- Java 控制流语句
- Java 中的标签语句
- Java 字符串类指南
- Java 创建类 – 如何创建对象?
- 如何在 Java 中创建不可变的类
- Java main()方法
- Java 注释
- Java 按值传递与按引用传递
- Java 系统属性
- Java 静态 – 变量,方法,块,类和导入语句
- Java 中的静态导入语句
- Java hashCode()和equals() – 契约,规则和最佳实践
- Java this和super之间的区别
- 32 位 Java 与 64 位 Java 之间的区别
- java.exe和javaw.exe之间的区别
- Java 查看/生成类文件的字节码
- Java 中的小端和大端
- Java 命令行参数
- 在 Java 中比较浮点数或双精度数的正确方法
- Java 递归指南
- Java 偶对
- Java 元组 – 使用 Java 中的元组
- sun.misc.Unsafe类的用法
- Java UUID 生成器示例
- Java 12 教程
- Java 12 – 新特性和增强特性
- 收集器teeing()方法示例
- 字符串indent(count) – Java 中的行左缩进
- 精简数字格式
- Java 11 教程
- Java 11 的新特性和增强特性
- String.isBlank() – 在 Java 中检查空白或空字符串
- String.lines() – 获取行流 – Java 11
- String.repeat() – 在 Java 中重复字符串 N 次
- String.strip() – 删除开头和结尾的空格
- 文件readString() API – 将文件读取为 Java 中的字符串
- 文件writeString() API – 用 Java 将字符串写入文件
- Java 10 教程
- Java 10 特性和增强特性
- Java 版本 – 基于时间的发行版本控制
- Java var – 局部变量类型推断
- Java 9 教程
- Java 9 特性和增强特性
- Java 9 – 精简字符串改进 [JEP 254]
- Java 模块教程
- Java 9 – JShell
- Java – 日期流
- Java 9 Stream API 的改进
- Java 9 中的不可变集合和工厂方法
- 接口中的私有方法 – Java 9
- Java 8 教程
- Java 8 教程
- Java 8 forEach
- Java 8 流 API
- Java 流装箱示例
- Lambda 表达式
- Java 8 – 函数式接口
- Java 8 方法引用示例
- Java 默认方法教程
- Java 8 Optional:完整参考
- Java 谓词示例 – 谓词过滤器
- Java 8 – 日期和时间示例
- Java 8 列出目录中的所有文件 – 六个示例
- Java 8 – 逐行读取文件
- Java 8 写入文件示例
- Java WatchService API 教程
- Java 8 解析字符串为日期
- Java 8 – 连接字符串数组 – 将数组转换为字符串
- Java Base64 编码和解码示例
- Math 类中的 Java 精确算术运算支持
- Java 8 带有 lambda 的Comparator示例
- 使用Pattern.compile()方法将 Java 正则表达式作为谓词
- Java 字符串连接(CSV)示例
- Java 8 两个日期之间的差异
- Java – 内部与外部迭代
- Java 中的安全随机数生成
- Java 7 教程
- Java 7 的更改,特性和增强
- Java 菱形运算符 – Java 中的<>运算符
- 带字符串的 Java switch case
- Java 7 中的try-with-resources
- Java 7 中数字字面值的下划线
- Java 抑制异常示例
- Java 7 – 异常处理增强
- Fork/Join 框架教程:ForkJoinPool示例
- 自动重新加载属性的 Java WatchService示例
- 面向对象原则
- Java OOP 概念 – 面向对象的原则
- Java 访问修饰符
- Java 构造器
- Java 实例初始化器块
- Java 中的抽象示例
- Java 封装与抽象
- Java 继承
- Java 多态示例
- Java 方法重载与方法重载
- 接口与 Java 中的抽象类
- Java extends与implements关键字
- Java instanceof运算符
- Java 中的多重继承
- 关联,聚合和组合
- Java 并发指南
- Java 并发教程
- Java 多线程的发展和主题
- Java 并发性 – 线程安全性?
- 并发与并行
- Java 比较和交换示例 – CAS 算法
- Java synchronized关键字
- Java 中的对象级别锁与类级别锁
- Java 中Runnable与Thread之间的区别
- 如何在 Java 中使用wait(),notify()和notifyAll()?
- Java 并发性 – yield()和join()之间的区别
- Java 中 sleep()和wait()之间的区别
- 锁和监视器之间的区别 – Java 并发
- Java Callable Future示例
- 如何使用UncaughtExceptionHandler重新启动线程
- 使用ThreadPoolExecutor和Semaphore限制任务提交率
- Java 执行器框架教程和最佳实践
- Java 线程间通信 – PipedReader和PipedWriter
- Java 死锁示例和解决方案
- Java 集合
- Java 中的集合
- Java 中的数组
- Java ArrayList指南
- Java LinkedList类
- Java HashMap指南
- Java Hashtable类
- Java LinkedHashMap类
- Java TreeMap类
- Java HashSet类
- Java LinkedHashSet类
- Java TreeSet类
- Java Comparable接口示例
- Java Comparator接口示例
- Java Iterator接口示例
- Java ListIterator接口
- Java Spliterator接口
- Java PriorityQueue类
- Java PriorityBlockingQueue类
- Java ArrayBlockingQueue类
- Java TransferQueue – Java LinkedTransferQueue类
- Java CopyOnWriteArrayList类
- Java CopyOnWriteArraySet类
- 如何在 Java 中对数组,列表,映射和集合进行排序
- Java 面试的 40 个热门问答集
- Java IO 教程
- Java IO 教程和示例
- Java I/O 如何在较低级别上内部工作?
- Java 标准 IO 与 Java NIO
- 如何在 Java 中复制目录
- 用 Java 递归删除目录
- Java – 创建新文件
- Java – 写入文件
- Java – 附加到文件
- Java 创建只读文件示例
- Java 将文件读取为字符串(已针对 Java 8 更新)
- Java 将文件读取到byte[]数组
- Java – 逐行读取文件 – LineNumberReader
- Java BufferedReader示例
- Java – BufferedWriter
- Java 读写属性文件示例
- 从资源文件夹读取文件 – Spring 示例
- Java – 读写 UTF-8 编码数据
- Java 中如何检查文件是否存在
- Java 文件复制 – 用 Java 复制文件的 4 种方法
- Java FilenameFilter示例 – 查找/删除某些扩展名的文件
- Java FileFilter示例
- Java – 创建临时文件
- Java – 写入临时文件
- Java – 删除临时文件
- Java – 读取控制台输入
- Java – 使用Scanner类读取类型安全输入
- 在 Java 中将字符串转换为InputStream
- 在 Java 中将InputStream转换为字符串
- Java – 创建受密码保护的 Zip 文件
- Java – 解压缩带有子目录的文件
- 使用 Java 在 Linux 中管理不超过 N GB 的系统日志文件
- 在 Java 中生成 SHA 或 MD5 文件校验和哈希
- Java 日期时间教程
- Java – 日期和时间 API
- Java – 日期验证
- Java – 日期格式
- Java LocalDate类
- Java LocalTime类
- Java LocalDateTime类
- Java ZonedDateTime类
- Java 8 – Period
- Java 8 DateTimeFormatter
- Java 8 – TemporalAdjusters
- Java 8 – TemporalQuery
- Java 8 – DayOfWeek
- Java 日期 – 解析,格式和转换
- Java 语言环境 – 创建和设置默认语言环境
- Java 枚举教程
- Java 枚举
- 带有字符串值的 Java 枚举
- 枚举真的是最好的单例吗?
- 枚举器和迭代器之间的区别?
- Java 异常
- Java try-finally块
- Java throw关键字
- Java 受检与非受检的异常
- Java 同步和异步异常
- Java NullPointerException - 如何在 Java 中有效处理空指针
- Java 自定义异常 – 最佳实践
- 构造器可以声明初始化器块中引发的受检异常
- Java 泛型教程
- 完整的 Java 泛型教程
- Java 泛型 PECS - 生产者extends消费者super
- Java 垃圾回收
- Java 垃圾收集算法(直到 Java 9)
- JVM 内存模型/结构和组件
- Java 内存管理 – 垃圾回收算法
- Java 序列化教程
- Java 序列化 – 执行正确的序列化
- Java serialVersionUID – 如何生成serialVersionUID
- Java 外部化示例 – 更有效的序列化
- Java 中Externalizable与Serializable之间的区别
- 将 Java 对象序列化为 XML – XMLEncoder和XMLDecoder示例
- Java 中反序列化过程如何发生?
- 使用readObject和writeObject的 Java 自定义序列化
- 使用内存序列化的 Java 深层复制
- 字符串方法
- Java String.concat()方法示例
- Java String.hashCode()方法示例
- Java String.contains()方法示例
- Java String.compareTo()方法示例
- Java String.compareToIgnoreCase()方法示例
- Java String.equals()方法 – 字符串比较
- Java String.equalsIgnoreCase()方法 – 不区分大小写的比较
- Java String.charAt()方法示例
- Java String.indexOf()方法示例
- Java String.lastIndexOf()方法示例
- Java String.intern()方法示例
- Java String.split()方法示例
- Java String.replace()方法示例
- Java String.replaceFirst()方法示例
- Java String.replaceAll()方法示例
- Java String.substring()方法示例
- Java String.startsWith()示例
- Java String.endsWith()方法示例
- Java String.toUpperCase()方法示例
- Java String.toLowerCase()方法示例
- Java 正则表达式教程
- Java 正则表达式教程
- Java 仅允许字母数字字符的正则表达式
- Java 正则表达式 – 信用卡号验证
- Java 正则表达式 – 加拿大邮政编码验证
- 货币符号的 Java 正则表达式
- 使用 Java 正则表达式进行日期验证
- 使用 Java 正则表达式进行电子邮件验证
- Java 正则表达式密码验证示例
- 适用于希腊语扩展或希腊语脚本的 Java 正则表达式
- 验证 ISBN(国际标准书号)的 Java 正则表达式
- 检查输入文本的最小/最大长度的 Java 正则表达式
- 限制文本中的行数的 Java 正则表达式
- 限制输入中的单词数的 Java 正则表达式
- 验证 SSN(社会安全号码)的 Java 正则表达式
- Java 正则表达式 – 英国邮政编码验证
- Java 正则表达式 – 美国邮政编码验证
- 验证商标符号的 Java 正则表达式
- 验证国际电话号码的 Java 正则表达式
- 北美电话号码的 Java 正则表达式
- Java NIO 教程
- NIO 教程
- 如何创建路径 – Java NIO
- 使用缓冲区 – Java NIO 2.0
- Java 通道教程 – NIO 2.0
- 3 种读取文件的方法 – Java NIO
- Java 8 – 逐行读取文件
- Java 内存映射文件 – Java MappedByteBuffer
- Java NIO – 分散/聚集或向量 IO
- 通道之间的数据传输 – Java NIO
- HowToDoInJava 其它教程
- Maven 教程
- 如何在 Windows 上安装 Maven
- Maven – 设置文件
- Maven – 依赖管理
- Maven 依赖范围
- Maven - POM 文件
- Maven – 父子 POM 示例
- Maven – 本地,远程和中央仓库
- Maven 本地仓库位置以及如何更改?
- M2_REPO – 在 Eclipse 中更改 Maven 仓库的位置
- Maven 代理设置 – Eclipse,命令行和全局设置
- Maven 强制最低 Java 版本
- Maven 创建 Java 项目 – 交互式与非交互式模式
- 在 Eclipse 中逐步创建 Maven Web 项目
- 多模块 Maven 项目 – 控制台
- Eclipse 中的 Maven 多模块项目
- Maven – 创建 Java 源文件夹
- Maven BOM – 物料清单依赖项
- 在 Eclipse 中导入 Maven 远程原型目录
- Eclipse 项目中的 Maven 自定义原型
- 已解决:Java 编译器级别与已安装的 Java 项目方面的版本不匹配
- Maven ant 插件 – 从pom.xml生成build.xml
- Maven IntelliJ IDEA 项目
- Spring MVC JSTL 配置示例
- Tomcat Maven 插件示例
- Maven – Spring Boot 胖/Uber Jar
- Maven Shade 插件 – UberJar/胖 Jar 示例
- Maven – 删除所有损坏的 jar/依赖项
- Gradle 教程 – 安装和 HelloWorld 示例
- Log4j2 教程
- Log4j2 JSON 配置示例
- Log4j2 属性文件示例
- Log4j2 xml 配置示例
- Log4j2 RollingFileAppender示例
- Log4j2 多个附加器示例
- Log4j2 LevelRangeFilter示例
- Log4j2 HTMLLayout配置示例
- Log4j2 ThreadContext – 相同事务的鱼标日志
- Log4j2 – 有用的转换模式示例
- 为 JUnit 测试用例配置 Log4j2
- Log4j 教程
- log4j.properties示例 – Log4j 属性文件示例
- log4j.xml示例 – Log4j xml 配置示例
- Log4j Maven 配置示例
- Log4j 日志级别 – Log4j2 日志级别示例
- Log4j ConsoleAppender配置示例
- Log4jRollingFileAppender配置示例
- Log4j SocketAppender和套接字服务器示例
- Log4j JDBCAppender – 在数据库中创建日志
- Log4j XMLLayout – 以 XML 格式创建日志
- Log4j HTMLLayout – 以 HTML 格式创建日志
- Log4j – 在运行时重新加载日志记录级别
- SLF4j 与 Log4j – 哪个更好?
- RESTEasy + Tomcat 7 + Log4j 日志记录示例
- Dropwizard 教程
- Dropwizard 教程
- Dropwizard 教程 – HelloWorld 示例
- Dropwizard – BasicAuth 安全示例
- Dropwizard 运行状况检查配置示例
- Dropwizard 客户端 – Jersey/HTTP 配置和示例
- [已解决] Dropwizard – 无法解析配置(无法将类型 ID “http”解析为子类型)
- RESTEasy 教程
- JAX-RS 2.0 教程
- RESTEasy + JBOSS 7 HelloWorld 应用
- 面向初学者的 RESTEasy 示例教程
- JAX-RS @Path URI 匹配 – 静态和正则 URI
- Java REST HATEOAS 示例
- RESTEasy + Tomcat 7 + SLF4J 日志示例
- RESTEasy + Tomcat 7 + Log4j 记录示例
- RESTEasy - 文件下载示例
- RESTEasy 文件上传 - HTML 表单示例
- RESTEasy 文件上传 - HttpClient示例
- 使用 Ajax 的 JAX-RS 自定义验证示例
- 使用 Hibernate 验证器供应器进行 RESTEasy Bean 验证
- RESTEasy ContainerRequestFilter - RESTEasy 安全过滤器示例
- RESTEasy 基本认证和授权教程
- RESTEasy JAXB XML 示例
- RESTEasy Jettison JSON 示例
- Jackson 的 RESTEasy JSON 示例
- RESTEasy ExceptionMapper – 异常处理示例
- RESTEasy 客户端 API
- 使用java.net包的 RESTful 客户端
- 使用 RESTful API 的 RESTEasy 客户端
- Apache HttpClient GET 和 POST 示例
- RESTEasy Javascript/Ajax 客户端演示
- JAX-RS 2.0 RESTEasy 3.0.2.Final 客户端 API 示例
- RESTEasy 最佳实践
- RESTEasy - 与ResteasyProviderFactory共享上下文数据
- RESTEasy ExceptionMapper – 异常处理示例
- 使用 ETag 的 RESTEasy 缓存控制示例
- RESTEasy – 启用 Gzip 压缩内容编码
- 比较 SOAP 与 RESTful Web 服务
- Jersey 教程
- Jersey HelloWorld 例子
- Jersey2 HelloWorld 示例 – Jersey2 教程
- jersey-quickstart-webapp HelloWorld 示例
- Jersey 使用过滤器记录请求和响应实体
- Jersey - 如何在 REST API 响应中设置 Cookie
- Jersey 文件下载示例 – StreamingOutput
- Jersey 文件上传示例 – Jersey2 MultiPartFeature
- Jersey - Ajax 多文件上传示例
- Jersey 异常处理 – Jersey ExceptionMapper示例
- Jersey + MOXy JSON 示例
- Jersey + JSONP 示例
- Jersey + Google Gson 示例
- Jersey REST API 安全示例
- Jersey 客户端
- Jersey 客户端示例 – Jersey2 客户端 API
- Jersey REST 客户端认证示例
- Jersey 客户端 - 设置 Cookie 示例
- JDBC 教程
- Java JDBC 教程
- Java – JDBC 连接示例(MySQL)
- Java – JDBC 驱动类型
- JDBC SELECT查询示例
- JDBC SQL INSERT查询示例
- JDBC SQL DELETE查询示例
- Java JDBC PreparedStatement示例
- JDBC 性能优化技巧
- Hiberate 教程
- Hiberate 教程
- Hibernate 示例 – HelloWorld 示例逐步简介
- Hibernate 获取实体示例 – get与load方法
- Hibernate 插入查询教程
- Hiberate 合并和刷新实体
- Hibernate 4 – 获取延迟加载的实体引用
- 从数据库中插入/选择 Blob 的 Hiberate 示例
- Hiberate save()和saveOrUpdate()方法
- Hiberate 实体/持久化生命周期状态
- Hibernate 4:如何构建SessionFactory
- Hiberate 实体等价和等同
- Hibernate JPA 级联类型
- Hibernate 延迟加载教程
- Hiberate 条件查询示例
- Hibernate HQL(Hiberate 查询语言)示例
- Hibernate @NamedQuery教程
- Hibernate – 如何定义实体之间的关联映射
- 通过示例了解 Hibernate 一级缓存
- Hiberate 二级缓存如何工作?
- Hibernate EhCache 配置教程
- Hibernate OSCache 配置示例教程
- Hibernate C3P0 连接池配置教程
- Hiberate 内存数据库
- Hibernate 验证器 – Java Bean 验证示例
- Hibernate 验证器 CDI – @HibernateValidator示例
- [已解决] UnexpectedTypeException - 找不到约束验证器
- Hiberate 注解
- Hibernate / JPA2 持久化注解教程
- Hiberate 注解与映射 – 优缺点
- @Immutable和@NaturalId – 特定于 Hiberate 的注解
- Hibernate @NaturalId示例教程
- Hiberate 一对多映射注解示例
- Hiberate 多对多映射注解示例
- Hiberate 一对一映射注解示例
- JUnit5 教程
- JUnit5 教程
- JUnit5 测试生命周期
- JUnit5 @BeforeAll注解示例
- JUnit5 @BeforeEach注解示例
- JUnit5 @AfterEach注解示例
- JUnit5 @AfterAll注解示例
- JUnit5 @RepeatedTest注解示例
- JUnit5 @Disabled测试示例
- JUnit5 @Tag注解示例
- JUnit5 预期的异常 – assertThrows()示例
- JUnit5 断言示例
- JUnit5 假设示例
- JUnit5 测试套件示例
- JUnit5 和 Gradle
- JUnit5 Maven 依赖项
- JUnit5 – 在 Eclipse 中执行测试
- Eclipse 的 JUnit5 测试模板
- JUnit5 与 JUnit4
- JUnit4 教程
- JUnit 教程
- JUnit 测试套件示例
- JUnit JUnitCore示例
- 使用 Maven 执行 JUnit 测试用例
- JUnit4 – 基于假设的测试用例
- Junit 预期异常测试用例示例
- JUnit 测试监听器– JUnit RunListener示例
- JUnit 测试超时 – JUnit5 超时示例
- JUnit 有序测试执行示例
- JUnit 参数化测试示例
- Junit 参数化测试 – @Theory和@DataPoints
- JUnit – 使用TemporaryFolder和@Rule创建临时文件/文件夹
- TestNG 教程
- TestNG 教程
- TestNG 教程(使用 Eclipse)
- 如何从 Maven 运行testng.xml
- TestNG 注解教程
- TestNG – 预期异常和预期消息教程
- TestNG – 如何禁用/忽略测试方法
- TestNG 并行执行测试,类和套件
- TestNG – 依赖测试示例
- TestNG – 超时测试教程
- TestNG @Parameters – 测试参数示例
- TestNG @DataProvider – 测试参数示例
- TestNG @Factory注解教程
- TestNG – @Factory和@DataProvider之间的区别
- TestNG 的前后注解
- TestNG – 测试组,元组,默认组示例
- Mockito 教程
- Mockito2 教程 – JUnit Mockito 示例
- Mockito 注解– @Mock,@Spy,@Captor,@InjectMock
- Mockito – @Mock和@InjectMock注解之间的区别
- Mockito – 验证具有不同参数的多个方法调用
- Spring Boot,Mockito 和 Junit – 单元测试服务层
- [已解决] IllegalStateException:无法初始化插件MockMaker
- 使用 PowerMock 进行模拟测试(带有 JUnit 和 Mockito)
- TypeScript 教程
- TypeScript 教程
- TypeScript 类型
- TypeScript 联合类型
- 字符串字面值类型
- TypeScript 变量 – var,let和const
- TypeScript 模板字符串
- TypeScript 算术运算符
- TypeScript 逻辑运算符
- TypeScript 比较运算符
- TypeScript for…of循环
- TypeScript 中的展开运算符
- TypeScript 中的数组
- TypeScript 中的枚举
- TypeScript 映射
- TypeScript 集合
- TypeScript 函数 – 剩余,可选和默认参数
- TypeScript 函数或方法重载
- 转译器(Transpiler)与编译器
- JavaScript 中的真值和假值
- 相等运算符(==)与严格相等运算符(===)
- JavaScript 中的undefined vs null
- JavaScript 变量提升
- tsconfig.json – TypeScript 编译器配置
- Angular(2.x)教程
- Angular 开发工作区设置
- [已解决] Npm 安装挂起或时间过长
- 模拟 REST 服务器来伪造在线 API
- Angular 插值
- Angular 组件
- Angular 模板和视图
- Angular 服务示例
- 带有 RxJS Observable的 Angular HttpClient示例
- AngularJS(1.x)教程
- AngularJS 教程 – HelloWorld 示例
- AngularJS – jQueryLite(jqLite)教程
- AngularJS 服务(内置和自定义)
- AngularJS Spring MVC Rest 示例
- JavaScript / jQuery 教程
- Ajax 教程 – 面向初学者的 Ajax 指南
- 完整的 jQuery Ajax($.ajax)教程
- jQuery 深度克隆示例
- jQuery 选择器 – 完整列表
- jQuery – 所有选择器(“*”) – 通用选择器
- jQuery – 检测剪切,复制或粘贴事件
- jQuery 检测ENTER键按下事件
- jQuery – Keypress和Keydown事件之间的区别
- 关于 StackOverflow 的最佳 jQuery 讨论
- JavaScript – 相等(==)与身份(===)运算符
- 您必须知道的 JavaScript 变量范围规则
- JavaScript:定义全局变量的正确方法
- 在 JavaScript 中实现 MVC 和 PubSub
- JavaScript DOM 对象与 jQuery 对象
- Jasmine 单元测试教程及示例
- JavaScript 日志 – 在 JSON 中屏蔽敏感信息
- Android 教程
- Android 教程:关键概念
- Android 教程:在 Windows 上安装 Android
- Android 教程:如何创建 Android 应用/项目
- Android 教程:Android 项目结构,文件和资源
- Android 清单:指定 Android 应用和 SDK 版本
- 如何加快缓慢的 Android AVD / 模拟器
- Hadoop 教程
- Hadoop – 大数据教程
- Hadoop MapReduce 初学者教程
- HDFS – Hadoop 分布式文件系统架构教程
- Brewer 的 CAP 定理简述
- Java 云开发简介和工具
- MongoDB 教程
- MongoDB 简介:为什么选择 MongoDB?
- 如何在 Windows 上安装 MongoDB
- Java MongoDB:使用 GridFS API 获取/保存图像
- Java MongoDB:在集合中插入文档的示例
- MongoDB 查找文档示例
- 微服务 – 定义,原理和好处
- Apache Kafka 教程
- Apache Kafka – 简介
- Apache Kafka – Windows 10 入门
- Kafka 的 Spring Boot – HelloWorld 示例
- Spring Boot Kafka JsonSerializer示例
- JMS 教程
- JMS 教程 – Java 消息服务教程
- JMS 点对点消息示例
- JMS 发布/订阅消息示例
- HornetQ 教程
- HornetQ 单体 – 基本的 JMS 消息传递示例
- 使用 Maven 的 HornetQ 独立服务器示例
- Spring3 Hornetq 独立集成示例
- Gson 教程
- Gson 教程
- Gson 安装
- GSON – 序列化和反序列化 JSON
- Gson – JSON 输出的精美打印
- GSON – 将 JSON 数组解析为 Java 数组或列表
- GSON – 序列化和反序列化 JSON 为集
- Gson – 序列化和反序列化包含自定义对象的HashMap
- Gson – GsonBuilder配置示例
- Gson - 序列化NULL值
- Gson @Since – 版本支持
- Gson @SerializedName
- Gson – 排除或忽略字段
- Gson - JsonReader
- Gson - JsonParser
- Gson – 自定义序列化和反序列化
- Gson – 快速指南
- JAXB 教程
- JAXB 注解
- JAXB @XmlRootElement注解示例
- JAXB @XmlElementWrapper注解示例
- JAXB Marshaller(编组器)示例
- JAXB Unmarshaller(解组器)示例
- JAXB 读取 XML 到 Java 对象的示例
- 使用 Moxy 和 Jaxb 将 JSON 转换为 Java 对象的示例
- JAXB 将 Java 对象写入 XML 的示例
- JAXB 将对象转换为 JSON 的示例
- JAXB – 在 Java 中编组和解组HashMap
- JAXB – 编组和解组对象列表或集合
- 使用 Eclipse 从 JAXB Java 类生成 XSD
- JAXB 模式验证
- [已解决]:javax.xml.bind.JAXBException:java.util.ArrayList或其任何超类不是此上下文的已知类
- [已解决]:线程“main”com.sun.xml.internal.bind.v2.runtime.IllegalAnnotationsException中的异常:3 个IllegalAnnotationExceptions计数
- 没有@XmlRootElement的 JAXB 编组 – 缺少@XmlRootElement错误
- 不带 jaxb 注解的解组
- Jackson 教程
- Jackson2 – 将 Java 对象转换为 JSON,并将 JSON 字符串转换为对象
- Jackson 将对象转换为 json 并将 json 转换为对象
- Jackson – 将 JSON 转换为Map并将Map转换为 JSON
- Java XML 教程
- Java 读取 XML – Java DOM 解析器示例
- Java SAX 解析器 – XML 读取示例
- Java JDOM2 – XML 读取示例
- 使用 Java StAX 解析器读取 XML – 游标和迭代器 API
- DOM 与 Java 中的 SAX 解析器
- Java 将 XML 转换为属性 – 从 XML 文件读取属性
- Java 将属性文件转换为 XML 文件
- Java 字符串到 XML – 将字符串解析为 XML DOM 的示例
- Java XML 转换为字符串 – 将 XML 对象写入文件的示例
- Java XPath 示例 – XPath 教程
- Java xpath 示例 – 在 xml 文件上求值 xpath
- Java8 xpath 示例 – 在字符串上求值 xpath
- Java XPath 表达式示例
- Java XPath NamespaceContext – 命名空间解析示例
- Java XPath 从 XML 获取属性值
- 在 Java 中使用 xpath 查找具有属性值的 xml 元素
- Java XPath – 检查节点或属性是否存在?
- Eclipse 教程
- 在 Eclipse 中导入 Maven 远程原型目录
- 使用 Eclipse 快速搜索插件进行更快的文本搜索
- 如何在 Eclipse 中显示非英文 unicode(例如中文)字符
- 如何在 Eclipse 中增加控制台输出限制
- 创建 Eclipse 模板以加快 Java 编程
- 在 5 分钟内使 Eclipse 更快
- 如何在印地语中编译和运行 Java 程序
- Java 覆盖最终静态方法 – 方法是覆盖还是隐藏?
- [已解决] 在 Eclipse 的 Java 构建路径中找不到超类“javax.servlet.http.HttpServlet”
- 版本控制系统教程
- 分布式版本控制系统如何工作?
- 版本控制系统(VCS)如何工作?
- 如何从 Google Code 项目中签出源代码
- Tomcat 教程
- Tomcat – 架构和server.xml配置
- 如何在默认的 HTTP 端口 80 中运行 tomcat
- Tomcat – 启用/禁用目录列表
- Tomcat SSL 或 HTTPS 配置示例
- 通过单个服务器安装运行 Tomcat 的多个实例
- Tomcat Maven 插件示例
- Spring,Tomcat – 获取负载均衡器后面的真实 IP
- Web 服务器如何工作?
- Linux 教程
- JStack 线程转储分析器
- 使用 Java 在 Linux 中管理系统日志文件不超过 N GB
- Swagger – Spring REST 示例
- GoF 设计模式
- 设计模式
- 创建型设计模式
- Java 单例模式介绍
- Java 中的构建器设计模式
- Java 工厂模式说明
- 抽象工厂模式解释
- Java 中的原型设计模式
- 行为型设计模式
- 责任链设计模式
- 命令设计模式
- 迭代器设计模式
- 中介者设计模式
- 备忘录设计模式
- 观察者设计模式
- 状态设计模式
- 策略设计模式
- 模板方法设计模式
- 访问者设计模式示例
- 结构型设计模式
- Java 中的适配器设计模式
- 桥接设计模式
- 组合设计模式
- Java 中的装饰器设计模式
- 外观设计模式
- 享元设计模式
- 代理设计模式
- 设计原则
- Java 中的 SOLID 原则(含示例)
- 开闭原则
- 单一责任原则
- Java 最佳实践
- Java 最佳实践指南
- 编写好的单元测试的 FIRST 原则
- 您应该如何对 DAO 层进行单元测试
- JUnit 最佳实践指南
- 不良单元测试用例的 8 个迹象
- 20 个 Java 异常处理最佳实践
- 13 个编写 Spring 配置文件的最佳实践
- Java Web 应用性能改进技巧
- Java 算法
- Java 算法和实现
- 冒泡排序 Java 示例
- 插入排序 Java 示例
- 归并排序 Java 示例
- 快速排序 Java 示例
- 选择排序 Java 示例
- Java AES 加密解密示例
- 使用 Soundex 算法实现语音搜索
- Java 比较和交换示例 – CAS 算法
- Python 教程
- Python 教程
- 如何在 Sublime 编辑器中安装 Python 包
- Python – 注释
- Python – 变量
- Python – 数据类型
- Python – 关键字
- Python – 字符串
- Python – 列表
- Python – 元组
- Python max()和min()– 在列表或数组中查找最大值和最小值
- Python 找到 N 个最大的或最小的项目
- Python 读写 CSV 文件
- Python httplib2 – HTTP GET 和 POST 示例
- Python 将元组解包为变量或参数
- Python 解包元组 – 太多值无法解包
- Python 多重字典示例 – 将单个键映射到字典中的多个值
- Python OrderedDict – 有序字典
- Python 字典交集 – 比较两个字典
- Python 优先级队列示例
- RxJava 教程
- 完整的 Java Servlet 教程
- vaadin 教程
- 使用 Maven 的 vaadin HelloWorld Web 应用
- Vaadin ComboBox示例
- vaadin 文本字段示例
- Vaadin Spring Security BasicAuth 示例
- SQL 教程
- SQL – 不使用临时表删除重复行
- 查找员工的第 N 高薪的 SQL 查询
- SQLException:用户root@localhost的访问被拒绝
- Struts2 教程
- Struts2 HelloWorld 示例
- Struts2 HelloWorld 注解示例
- 使用@InterceptorRef的 Struts2 自定义拦截器示例
- Struts2 – 如何正确设置结果路径
- Spring4 + Struts2 + Hibernate 集成教程
- [已解决] 无法找到ref-name引用的拦截器类
- [已解决]:找不到扩展名properties或xml的结果类型
- 数据结构教程
- 使用数组的 Java 栈实现
- Java 中的自定义列表实现示例
- HTML5 教程
- HTML5 – <section>标签示例
- HTML5 字符集 – 字符编码声明
- HTML5 DOCTYPE声明示例
- Java 题目
- Java 面试题目与答案
- Java 中的无效代码和无法访问的代码
- Java 字符串回文 – Java 数字回文示例
- 检测LinkedList中的无限循环的示例
- 复合赋值运算符i += j与 Java 中的i = i + j不同
- Java 中的 HiLo 猜谜游戏
- Java 题目 – 查找所有重复的元素
- Java 题目 – TreeMap的放置操作
- 题目 – 返回所有字符串中的第 N 长字符串
- Java 题目:好的字符串 – 坏的字符串
- 题目 – 检查字符串是否完整(包含所有字母)
- Java 中的反转字符串 - 单词反转字符串
- 用 Java 计算阶乘的 3 种方法
- Java 中的 FizzBuzz 解决方案
- 从 Java 中的序列/数组中查找缺失的数字
- Java – 不使用“new”关键字创建对象
- 面试问题
- Java 面试问题
- Java 字符串面试问题与答案
- Java 核心面试问题 – 第 1 部分
- Java 核心面试问题 – 第 2 部分
- Java 核心面试问题 – 第 3 部分
- Java 面试的 40 个热门问答集
- 中级开发人员的 Java 面试问题
- 针对 Oracle 企业管理器项目的实际 Java 面试问题
- HashMap和ConcurrentHashMap面试问题
- Java 版本和新特性