人工智能uu

这个屌丝很懒，什么也没留下！

热门标签

面试题007-Java-Spring

作者：人工智能uu | 2024-08-21 08:04:53

踩

面试题007-Java-Spring

题目自测

1. 简单介绍一下Spring？
2. Spring的核心模块有哪些？
3. 什么是Spring IoC ?
4. 什么是依赖注入？有哪几种方式可以进行依赖注入？
5. 什么是Spring AOP ？
6. 什么是Spring Bean ? 说一下Bean的生命周期？
7. Spring中Bean的作用域有哪些？
8. 什么是Spring中的代理（Proxy）？JDK动态代理和CGLIB代理有什么区别?
9. Spring是怎么解决循环依赖的？
10. 说一下你对Spring MVC的理解？Spring MVC的工作原理？
11. Spring中是如何实现事务管理的？
12. 拦截器和过滤器了解吗？

题目答案

1. 简单介绍一下Spring？

答：Spring一款开源的轻量级的Java应用框架，它的主旨是为了简化Java企业级应用开发。Spring提供的核心功能主要是 IoC 和 AOP。并且它提供了全面的基础设施支持，可以很方便地对数据库进行访问、集成第三方组件(任务、调度、缓存等)。使开发人员能更能专注业务逻辑开发，而无需处理繁琐的底层细节。

Spring官方：Spring makes it easy to create Java enterprise applications. It provides everything you need to embrace the Java language in an enterprise environment.

2. Spring有哪些模块？

答：Spring的模块主要有：

Core Container(核心容器)：
- spring-core：Spring框架的核心工具类，如控制反转和依赖注入等。
- spring-beans：提供Bean的创建、配置和管理功能的支持。
- spring-context：提供对国际化、事件传播、资源加载等功能的支持。
AOP(面向切面)：
- spring-aspects：该模块为与 AspectJ 的集成提供支持。
- spring-aop：提供了面向切面的编程实现。
Data Access/Integration(数据访问/集成)：
- spring-jdbc：提供了对数据库访问的抽象JDBC。
- spring-orm：提供对 Hibernate、JPA、iBatis 等 ORM 框架的支持。
- spring-tx：提供了对事物的支持。
Web：
- spring-web：对 Web 功能的实现提供一些最基础的支持。
- spring-mvc：提供了基于模型-视图-控制器（MVC）设计模式的Web框架。
- spring-webflux：提供了基于响应式编程模型的Web框架。

3. 什么是Spring IoC ?

答：IoC即控制反转的意思，它是一种创建和获取对象的技术思想，依赖注入(DI)是实现这种技术的一种方式。传统开发过程中，我们需要通过new关键字来创建对象。使用IoC思想开发方式的话，我们不通过new关键字创建对象，而是通过IoC容器来帮我们实例化对象。通过IoC的方式，可以大大降低对象之间的耦合度。

4. 什么是依赖注入？有哪几种方式可以进行依赖注入？

答：依赖注入是一种设计模式，依赖注入用于实现控制反转一种方式。在依赖注入模式下，依赖对象的创建和管理不再由使用该对象的类负责，而是由外部容器(Spring IoC容器)负责，并在需要的时候将这些依赖对象注入到需要他们的类中。实现依赖注入的方式主要有三种，如下

构造方法注入：通过对象的构造函数来注入依赖。

public class MyClass {  
    private MyDependency myDependency;  
    public MyClass(MyDependency myDependency) {  
        this.myDependency = myDependency;  
    }  
}
1
2
3
4
5
6

setter方法注入：通过对象的Setter方法来注入依赖。

public class MyClass {  
	    private MyDependency myDependency;  
	    public void setMyDependency(MyDependency myDependency) {  
	        this.myDependency = myDependency;  
	    }  
	}
1
2
3
4
5
6

接口注入：通过对象实现一个特定的接口来注入依赖。

public interface DependencyInjector {  
    void injectDependency(MyClass myClass);  
}  
public class MyClass implements DependencyInjector {  
    private MyDependency myDependency;  
    @Override  
    public void injectDependency(MyDependency myDependency) {  
        this.myDependency = myDependency;  
    }  
}
1
2
3
4
5
6
7
8
9
10

5. 什么是Spring AOP ？

答：AOP是面向切面编程的意思，用于将横切关注点与业务逻辑代码分离，横切关注点通常指的是分散在多个类中的公共行为，如日志记录、事物管理、权限管理等。通过把这些横切关注点进行封装成独立的模块形成切面，并在运行时动态地将他们植入到应用程序中的普通业务逻辑中。通过Spring AOP可以实现代码的复用和解耦，从而提高代码的可维护性和可扩展性等。

AOP的具体应用-日志记录

// 日志注解
@Target({ElementType.PARAMETER,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {

    /**
     * 描述
     */
    String description() default "";

    /**
     * 方法类型 INSERT DELETE UPDATE OTHER
     */
    MethodType methodType() default MethodType.OTHER;
}

// 日志切面
@Component
@Aspect
public class LogAspect {
  // 切入点，所有被 Log 注解标注的方法
  @Pointcut("@annotation(com.zouhuu.annotation.Log)")
  public void webLog() {
  }

   /**
   * 环绕通知
   */
  @Around("webLog()")
  public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
    // 省略具体的处理逻辑
  }

  // 省略其他代码
}
/**
 * 通过注解实现日志记录
 */
public class MyController() {

    @Log(description = "method1",methodType = MethodType.INSERT)
    public CommonResponse<Object> method1() {
          // 业务逻辑
          xxService.method1();
          // 省略具体的业务处理逻辑
          return CommonResponse.success();
    }
}
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

6. 什么是Spring Bean ? 说一下Bean的生命周期？

答：简单来说Spring Bean是指被Spring IoC容器所管理的对象。Spring容器负责Bean的创建、初始化、配置以及销毁。我们可以通过XML文件或注解等方式去定义Bean。Bean可以是任意类型的Java对象，比如数据访问对象DAO、业务服务对象等。
Bean的生命周期可以分为定义、属性设置、初始化、生存、销毁这五个阶段。

Bean的定义阶段：Spring容器会读取Bean配置(XML文件、Java配置类)，然后通过Java的反射机制来创建Bean实例。
Bean的属性设置阶段：Spring容器根据配置文件中定义的信息，设置Bean的属性，包括注入其他Bean和属性值等。
Bean的初始化阶段：
1. 首先会检查Aware接口的相关实现，Aware接口是为了让Bean有和Spring容器交互的能力。
2. 调用BeanPostProcessor的前置处理方法(postProcessBeforeInitialization)。
3. 调用Bean的初始化方法(afterPropertiesSet和custom init-method)。
4. 调用BeanPostProcessor的后置处理方法(postProcessAfterInitialization)。
Bean的生存阶段：经过初始化的Bean可以被应用程序使用。
Bean的销毁阶段：当Bean的生命周期结束时(如Spring容器关闭)，那么Spring会调用其destroy()方法，如果有自定义的销毁方法，则调用自定义的销毁方法。

7. Spring中Bean的作用域有哪些？

答：Bean的作用域定义了其生命周期内的可见范围，Spring中Bean的作用域默认都是单例的(Singleton)。

单例 Singleton：Spring容器中每个bean只有唯一一个实例，无论被注入多少次，都是返回的同一个实例。
原型 Prototype：每次获取都会创建一个新的bean。
请求 Request：仅在Web应用中有效，每次HTTP请求都会创建一个新的bean实例，请求结束后销毁。
会话 Session：仅在Web应用中有效，每个HTTP会话创建时都会创建一个新的Bean实例，会话结束后销毁。
应用 Application：仅在Web应用中有效，整个Web应用共享一个Bean实例，类似于Servlet上下文。
WebSocket：仅在WebSocket应用中有效。每个WebSocket会话创建时都会创建一个新的Bean实例，结束后销毁。

8. 什么是Spring中的代理（Proxy）？JDK动态代理和CGLIB代理有什么区别?

答：在Spring中代理是一种设计模式，主要用于实现诸如AOP（面向切面编程）这样的功能。代理模式允许在不修改原有对象的前提下，通过创建一个代理对象来包装原始对象，从而增加额外的功能，如日志记录、权限检查、事务管理等。

JDK动态代理：基于Java反射机制实现，要求目标类必须实现一个或多个接口。
CGLIB代理：是一个字节码生成库，它允许在运行时动态生成类。CGLIB代理用于那些没有实现接口的类。

9. Spring是怎么解决循环依赖的？

答：循环依赖是指两个Bean或多个Bean相互依赖，从而形成循环。如当 Spring 创建 A 之后，发现 A 依赖了 B ，又去创建 B，B 依赖了 A ，又去创建 A。

class A {
    // 使用了 B
    private B b;
}
class B {
    // 使用了 A
    private A a;
}
1
2
3
4
5
6
7
8

为了解决这个问题，Spring引入了三级缓存的机制来解决循环依赖。如果发生循环依赖的话，就去三级缓存 singletonFactories 中拿到三级缓存中存储的 ObjectFactory 并调用它的 getObject() 方法来获取这个循环依赖对象的前期暴露对象（虽然还没初始化完成，但是可以拿到该对象在堆中的存储地址了），并且将这个前期暴露对象放到二级缓存中，这样在循环依赖时，就不会重复初始化了。

三级缓存：
- 一级缓存(singletonObjects)：已经完全初始化并可供使用的单例Bean的缓存。
- 二级缓存(earlySingletonObjects)：存放早期单例对象bean，已经实例化但尚未初始化完成的bean。
- 三级缓存(singletonFactories)：存放正在创建中的Bean的工厂方法引用，用于创建代理对象。

10. 说一下你对Spring MVC的理解？Spring MVC的工作原理？

答：MVC是一种设计模式，它提供了一种分离业务逻辑，用户界面，控制流程方式。Spring MVC是实现MVC模式的框架，它可以帮我们以更简洁和模块化的方式构建Web应用。它包含三个核心注解，如下所示：

模型(Model)：负责应用程序的数据和业务逻辑。
视图(View)：负责展示数据，即用户界面。
控制器(Controller)：负责处理用户请求，协调模型和视图之间的交互。

Spring MVC的工作原理：

用户通过浏览器或其他客户端发送HTTP请求。
请求首先会到达DispatcherServlet(前端控制器)，DispatcherServlet根据请求信息调用HandlerMapping，通过HandlerMapping找到对应的处理器，也就是我们Controller。
找到处理器后，DispatcherServlet会调用HandlerAdapter执行处理器中的方法。
处理器中的方法执行完成后，会返回一个ModelAndView对象给DispatcherServlet。
DispatcherServlet会根据视图解析器，找到对应的视图。
视图通过对应的数据进行渲染。
然后将渲染的结果返回给用户。

11. Spring中是如何实现事务管理的？

答：Spring为事物提供了编程式和声明式两种方式来管理事务。通过事务可以确保数据操作的原子性、一致性、隔离性和持久性（ACID）。在Spring中，主要围绕PlatformTransactionManager(事务管理器接口，用于管理和协调事务的生命周期和执行)，TransactionDefinition(事务定义接口，定义事物的传播行为和隔离级别)，TransactionStatus(事务状态接口)来管理事务。

编程式事务管理：通过TransactionTemplate或者TransactionManager手动管理事务

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private PlatformTransactionManager transactionManager;

    public void createUser(User user) {
        TransactionDefinition def = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(def);
        try {
            userRepository.save(user);
            transactionManager.commit(status);
        } catch (Exception e) {
            transactionManager.rollback(status);
            throw e;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

声明式事务管理：主要是通过@Transactional注解的形式

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Transactional
    public void createUser(User user) {
        userRepository.save(user);
    }

    @Transactional(readOnly = true)
    public User getUser(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

12. 拦截器和过滤器了解吗？

答：拦截器和过滤器都是Java Web开发中常用的技术，用于对请求和响应进行处理。可以用于实现身份验证、日志记录、数据转换等功能。

拦截器：拦截器是Spring中一种基于AOP思想的组件，其生命周期由Spring容器所管理。用于请求到达控制器之前和请求完成之后进行处理。主要用于处理业务逻辑相关的，如权限验证等处理。

/**
 * 实现一个拦截器需要实现HandlerInterceptor接口
 */
public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 处理请求前
        System.out.println("Pre-handle");
        return true; // 返回false将终止请求处理
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                           ModelAndView modelAndView) throws Exception {
        // 处理请求后但在视图渲染之前
        System.out.println("Post-handle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        // 完成请求处理后的清理工作
        System.out.println("After completion");
    }
}

/**
 * 在Spring中注册和配置拦截器
 */
@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
    }
}
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

过滤器：属于Servlet规范等一部分，用于在请求到达目标资源（如Servlet、JSP页面）之前和响应返回给客户端之后进行预处理和后处理。主要用于处理通用的，与Servlet规范相关的逻辑，如字符编码设置，安全检查等。

/**
 * 实现Filter接口
 */
public class MyFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化代码
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 处理请求前
        System.out.println("Request received at filter");
        chain.doFilter(request, response);
        // 处理请求后
        System.out.println("Response returned at filter");
    }

    @Override
    public void destroy() {
        // 销毁代码
    }
}
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

参考资料

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/1010912

面试题007-Java-Spring