14
2020
08

@Controller annotation

@Controller注解表示该类扮演控制器的角色。Spring不需要继承任何控制器基类或应用Servlet API。69.@RequestMapping annotation@RequestMapping注解用于将URL映射到任何一个类或者一个特定的处理方法上。
03
2020
08

使用spring事件的好处?

1、单一职责原则、代码耦合降低、事件的处理人员只需关注处理的代码、发布人员只需关注发布的代码;2、即可同步 也可异步;
03
2020
08

请解释一下spring中的IOC?

spring中的IoC容器是由spring的 org.springframework.beans 包和 org.springframework.context 包构成的。BeanFactory 接口提供了一个先进的配置机制,使得任何类型的对象的配置成为可能。ApplicationContex 接口对 BeanFactory(是一个子接口)进行了扩展,在 BeanFactory的基础上添加了其他功能,比如与 Spring 的 AOP 更容易集成,也提供了处理 message resource的机制
03
2020
08

什么是IOC?什么是DI?

控制反转是一种思想,将对象的创建、注入、销毁交给spring容器帮我们去做,就是把对象的控制权交给了springIOC容器,开发人员不必去考虑如何进行依赖的注入,而使得代码维护更加容易。不至于出现一处属性的修改,而导致的“牵一发而动全身”。依赖注入是IOC的实现方式,即一个类内部的依赖不再由类内部创建,而在类外部进行创建并进行注入。这就是springIOC思想的具体实现。在 Java 中依赖注入有以下三种实现方式:构造器注入Setter 方法注入接口注入
06
2020
05

Bean 工厂和 Application contexts 有什么区别?

Application contexts提供一种方法处理文本消息,一个通常的做法是加载文件资源(比如镜像),它们可以向注册为监听器的bean发布事件。另外,在容器或容器内的对象上执行的那些不得不由bean工厂以程序化方式处理的操作,可以在Application contexts中以声明的方式处理。Application contexts实现了MessageSource接口,该接口的实现以可插拔的方式提供获取本地化消息的方法。
06
2020
05

什么是Spring框架?

Spring是一种轻量级框架,旨在提高开发人员的开发效率以及系统的可维护性。我们一般说的Spring框架就是Spring Framework,它是很多模块的集合,使用这些模块可以很方便地协助我们进行开发。这些模块是核心容器、数据访问/集成、Web、AOP(面向切面编程)、工具、消息和测试模块。比如Core Container中的Core组件是Spring所有组件的核心,Beans组件和Context组件是实现IOC和DI的基础,AOP组件用来实现面向切面编程。Spring官网(https://s
06
2020
05

列举一些重要的Spring模块?

下图对应的是Spring 4.x的版本,目前最新的5.x版本中Web模块的Portlet组件已经被废弃掉,同时增加了用于异步响应式处理的WebFlux组件。Spring Core:基础,可以说Spring其他所有的功能都依赖于该类库。主要提供IOC和DI功能。Spring Aspects:该模块为与AspectJ的集成提供支持。Spring AOP:提供面向方面的编程实现。Spring JDBC:Java数据库连接。Spring JMS:Java消息服务。Spring ORM:用于支持Hiber
06
2020
05

谈谈自己对于Spring IOC和AOP的理解

IOCIOC(Inversion Of Controll,控制反转)是一种设计思想,就是将原本在程序中手动创建对象的控制权,交由给Spring框架来管理。IOC在其他语言中也有应用,并非Spring特有。IOC容器是Spring用来实现IOC的载体,IOC容器实际上就是一个Map(key, value),Map中存放的是各种对象。将对象之间的相互依赖关系交给IOC容器来管理,并由IOC容器完成对象的注入。这样可以很大程度上简化应用的开发,把应用从复杂的依赖关系中解放出来。IOC容器就像是一个工厂
06
2020
05

Spring中的单例bean的线程安全问题了解吗?

大部分时候我们并没有在系统中使用多线程,所以很少有人会关注这个问题。单例bean存在线程问题,主要是因为当多个线程操作同一个对象的时候,对这个对象的非静态成员变量的写操作会存在线程安全问题。有两种常见的解决方案:1.在bean对象中尽量避免定义可变的成员变量(不太现实)。2.在类中定义一个ThreadLocal成员变量,将需要的可变成员变量保存在ThreadLocal中(推荐的一种方式)。
06
2020
05

Spring中的bean的作用域有哪些?

1.singleton:唯一bean实例,Spring中的bean默认都是单例的。2.prototype:每次请求都会创建一个新的bean实例。3.request:每一次HTTP请求都会产生一个新的bean,该bean仅在当前HTTP request内有效。4.session:每一次HTTP请求都会产生一个新的bean,该bean仅在当前HTTP session内有效。5.global-session:全局session作用域,仅仅在基于Portlet的Web应用中才有意义,Spring5中已经
06
2020
05

Spring AOP和AspectJ AOP有什么区别?

Spring AOP是属于运行时增强,而AspectJ是编译时增强。Spring AOP基于代理(Proxying),而AspectJ基于字节码操作(Bytecode Manipulation)。Spring AOP已经集成了AspectJ,AspectJ应该算得上是Java生态系统中最完整的AOP框架了。AspectJ相比于Spring AOP功能更加强大,但是Spring AOP相对来说更简单。如果我们的切面比较少,那么两者性能差异不大。但是,当切面太多的话,最好选择AspectJ,它比Sp
06
2020
05

Spring中的bean生命周期?

1.Bean容器找到配置文件中Spring Bean的定义。2.Bean容器利用Java Reflection API创建一个Bean的实例。3.如果涉及到一些属性值,利用set()方法设置一些属性值。4.如果Bean实现了BeanNameAware接口,调用setBeanName()方法,传入Bean的名字。5.如果Bean实现了BeanClassLoaderAware接口,调用setBeanClassLoader()方法,传入ClassLoader对象的实例。6.如果Bean实现了BeanF
06
2020
05

说说自己对于Spring MVC的了解?

谈到这个问题,我们不得不提提之前Model1和Model2这两个没有Spring MVC的时代。Model1时代:很多学Java比较晚的后端程序员可能并没有接触过Model1模式下的JavaWeb应用开发。在Model1模式下,整个Web应用几乎全部用JSP页面组成,只用少量的JavaBean来处理数据库连接,访问等操作。这个模式下JSP即是控制层又是表现层。显而易见,这种模式存在很多问题。比如将控制逻辑和表现逻辑混杂在一起,导致代码重用率极低;又比如前端和后端相互依赖,难以进行测试并且开发效率
06
2020
05

Spring MVC的工作原理了解嘛?

流程说明: 1.客户端(浏览器)发送请求,直接请求到DispatcherServlet。 2.DispatcherServlet根据请求信息调用HandlerMapping,解析请求对应的Handler。 3.解析到对应的Handler(也就是我们平常说的Controller控制器)。 4.HandlerAdapter会根据Handler来调用真正的处理器来处理请求和执行相对应的业务逻辑。 5.处理器处理完业务后,会返回一个ModelAndV
06
2020
05

Spring框架中用到了哪些设计模式

1.工厂设计模式:Spring使用工厂模式通过BeanFactory和ApplicationContext创建bean对象。2.代理设计模式:Spring AOP功能的实现。3.单例设计模式:Spring中的bean默认都是单例的。4.模板方法模式:Spring中的jdbcTemplate、hibernateTemplate等以Template结尾的对数据库操作的类,它们就使用到了模板模式。5.包装器设计模式:我们的项目需要连接多个数据库,而且不同的客户在每次访问中根据需要会去访问不同的数据库。
06
2020
05

@Component和@Bean的区别是什么

1.作用对象不同。@Component注解作用于类,而@Bean注解作用于方法。2.@Component注解通常是通过类路径扫描来自动侦测以及自动装配到Spring容器中(我们可以使用@ComponentScan注解定义要扫描的路径)。@Bean注解通常是在标有该注解的方法中定义产生这个bean,告诉Spring这是某个类的实例,当我需要用它的时候还给我。3.@Bean注解比@Component注解的自定义性更强,而且很多地方只能通过@Bean注解来注册bean。比如当引用第三方库的类需要装配到
06
2020
05

将一个类声明为Spring的bean的注解有哪些?

我们一般使用@Autowired注解去自动装配bean。而想要把一个类标识为可以用@Autowired注解自动装配的bean,可以采用以下的注解实现:1.@Component注解。通用的注解,可标注任意类为Spring组件。如果一个Bean不知道属于哪一个层,可以使用@Component注解标注。2.@Repository注解。对应持久层,即Dao层,主要用于数据库相关操作。3.@Service注解。对应服务层,即Service层,主要涉及一些复杂的逻辑,需要用到Dao层(注入)。4.@Cont
06
2020
05

Spring事务管理的方式有几种?

1.编程式事务:在代码中硬编码(不推荐使用)。2.声明式事务:在配置文件中配置(推荐使用),分为基于XML的声明式事务和基于注解的声明式事务。
06
2020
05

Spring事务中的隔离级别有哪几种?

在TransactionDefinition接口中定义了五个表示隔离级别的常量:ISOLATION_DEFAULT:使用后端数据库默认的隔离级别,Mysql默认采用的REPEATABLE_READ隔离级别;Oracle默认采用的READ_COMMITTED隔离级别。ISOLATION_READ_UNCOMMITTED:最低的隔离级别,允许读取尚未提交的数据变更,可能会导致脏读、幻读或不可重复读。ISOLATION_READ_COMMITTED:允许读取并发事务已经提交的数据,可以阻止脏读,但是幻
06
2020
05

Spring事务中有哪几种事务传播行为?

在TransactionDefinition接口中定义了八个表示事务传播行为的常量。支持当前事务的情况:PROPAGATION_REQUIRED:如果当前存在事务,则加入该事务;如果当前没有事务,则创建一个新的事务。PROPAGATION_SUPPORTS: 如果当前存在事务,则加入该事务;如果当前没有事务,则以非事务的方式继续运行。PROPAGATION_MANDATORY: 如果当前存在事务,则加入该事务;如果当前没有事务,则抛出异常。(mandatory:强制性)。不支持当前事务的情况:P
06
2020
05

介绍一下 WebApplicationContext

WebApplicationContext 是 ApplicationContext 的扩展。它具有 Web 应用程序所需的一些额外功能。它与普通的 ApplicationContext 在解析主题和决定与哪个 servlet 关联的能力方面有所不同。
06
2020
05

描述一下 DispatcherServlet 的工作流程

DispatcherServlet 的工作流程可以用一幅图来说明:向服务器发送 HTTP 请求,请求被前端控制器 DispatcherServlet 捕获。DispatcherServlet 根据 -servlet.xml 中的配置对请求的 URL 进行解析,得到请求资源标识符(URI)。然后根据该 URI,调用 HandlerMapping 获得该 Handler 配置的所有相关的对象(包括 Handler 对象以及 Handler 对象对应的拦截器),最后以HandlerExecutionC
06
2020
05

Spring MVC 框架有什么用?

Spring Web MVC 框架提供 模型-视图-控制器 架构和随时可用的组件,用于开发灵活且松散耦合的 Web 应用程序。 MVC 模式有助于分离应用程序的不同方面,如输入逻辑,业务逻辑和 UI 逻辑,同时在所有这些元素之间提供松散耦合。
06
2020
05

什么是编织(Weaving)?

为了创建一个 advice 对象而链接一个 aspect 和其它应用类型或对象,称为编织(Weaving)。在 Spring AOP 中,编织在运行时执行。请参考下图:
06
2020
05

如何理解 Spring 中的代理?

将 Advice 应用于目标对象后创建的对象称为代理。在客户端对象的情况下,目标对象和代理对象是相同的。Advice + Target Object = Proxy
06
2020
05

Spring AOP and AspectJ AOP 有什么区别?

Spring AOP 基于动态代理方式实现;AspectJ 基于静态代理方式实现。Spring AOP 仅支持方法级别的 PointCut;提供了完全的 AOP 支持,它还支持属性级别的 PointCut。
06
2020
05

AOP 有哪些实现方式?

实现 AOP 的技术,主要分为两大类:静态代理 - 指使用 AOP 框架提供的命令进行编译,从而在编译阶段就可生成 AOP 代理类,因此也称为编译时增强;编译时编织(特殊编译器实现)类加载时编织(特殊的类加载器实现)。动态代理 - 在运行时在内存中“临时”生成 AOP 动态代理类,因此也被称为运行时增强。JDK 动态代理CGLIB
06
2020
05

指出在 spring aop 中 concern 和 cross-cutting concern 的不同之处。

concern 是我们想要在应用程序的特定模块中定义的行为。它可以定义为我们想要实现的功能。cross-cutting concern 是一个适用于整个应用的行为,这会影响整个应用程序。例如,日志记录,安全性和数据传输是应用程序几乎每个模块都需要关注的问题,因此它们是跨领域的问题。
06
2020
05

有哪些类型的通知(Advice)?

Before - 这些类型的 Advice 在 joinpoint 方法之前执行,并使用 @Before 注解标记进行配置。After Returning - 这些类型的 Advice 在连接点方法正常执行后执行,并使用@AfterReturning 注解标记进行配置。After Throwing - 这些类型的 Advice 仅在 joinpoint 方法通过抛出异常退出并使用 @AfterThrowing 注解标记配置时执行。After (finally) - 这些类型的 Advice 在连
06
2020
05

什么是通知(Advice)?

特定 JoinPoint 处的 Aspect 所采取的动作称为 Advice。Spring AOP 使用一个 Advice 作为拦截器,在 JoinPoint “周围”维护一系列的拦截器。
06
2020
05

什么是切点(JoinPoint)

程序运行中的一些时间点, 例如一个方法的执行, 或者是一个异常的处理.在 Spring AOP 中, join point 总是方法的执行点。
06
2020
05

什么是 Aspect?

aspect 由 pointcount 和 advice 组成, 它既包含了横切逻辑的定义, 也包括了连接点的定义. Spring AOP 就是负责实施切面的框架, 它将切面所定义的横切逻辑编织到切面所指定的连接点中.AOP 的工作重心在于如何将增强编织目标对象的连接点上, 这里包含两个工作:如何通过 pointcut 和 advice 定位到特定的 joinpoint 上如何在 advice 中编写切面代码.可以简单地认为, 使用 @Aspect 注解的类就是切面.
06
2020
05

什么是 AOP?

AOP(Aspect-Oriented Programming), 即 面向切面编程, 它与 OOP( Object-Oriented Programming, 面向对象编程) 相辅相成, 提供了与 OOP 不同的抽象软件结构的视角.在 OOP 中, 我们以类(class)作为我们的基本单元, 而 AOP 中的基本单元是 Aspect(切面)
06
2020
05

spring 支持哪些 ORM 框架

HibernateiBatisJPAJDOOJB
06
2020
05

列举 spring 支持的事务管理类型

Spring 支持两种类型的事务管理:程序化事务管理:在此过程中,在编程的帮助下管理事务。它为您提供极大的灵活性,但维护起来非常困难。声明式事务管理:在此,事务管理与业务代码分离。仅使用注解或基于 XML 的配置来管理事务。
06
2020
05

使用 Spring 访问 Hibernate 的方法有哪些?

我们可以通过两种方式使用 Spring 访问 Hibernate:使用 Hibernate 模板和回调进行控制反转扩展 HibernateDAOSupport 并应用 AOP 拦截器节点
06
2020
05

spring DAO 有什么用?

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

@RequestMapping 注解有什么用?

@RequestMapping 注解用于将特定 HTTP 请求方法映射到将处理相应请求的控制器中的特定类/方法。此注释可应用于两个级别:类级别:映射请求的 URL方法级别:映射 URL 以及 HTTP 请求方法
06
2020
05

@Qualifier 注解有什么用?

当您创建多个相同类型的 bean 并希望仅使用属性装配其中一个 bean 时,您可以使用@Qualifier 注解和 @Autowired 通过指定应该装配哪个确切的 bean 来消除歧义。例如,这里我们分别有两个类,Employee 和 EmpAccount。在 EmpAccount 中,使用@Qualifier 指定了必须装配 id 为 emp1 的 bean。Employee.javapublic class Employee {    private String n
06
2020
05

@Autowired 注解有什么用?

@Autowired 可以更准确地控制应该在何处以及如何进行自动装配。此注解用于在 setter 方法,构造函数,具有任意名称或多个参数的属性或方法上自动装配 bean。默认情况下,它是类型驱动的注入。public class Employee {    private String name;    @Autowired    public void setName(String name) {     
06
2020
05

@Required 注解有什么用?

@Required 应用于 bean 属性 setter 方法。此注解仅指示必须在配置时使用 bean 定义中的显式属性值或使用自动装配填充受影响的 bean 属性。如果尚未填充受影响的 bean 属性,则容器将抛出 BeanInitializationException。示例:public class Employee {    private String name;    @Required    public void setN
06
2020
05

@Component, @Controller, @Repository, @Service 有何区别?

@Component:这将 java 类标记为 bean。它是任何 Spring 管理组件的通用构造型。spring 的组件扫描机制现在可以将其拾取并将其拉入应用程序环境中。@Controller:这将一个类标记为 Spring Web MVC 控制器。标有它的 Bean 会自动导入到 IoC 容器中。@Service:此注解是组件注解的特化。它不会对 @Component 注解提供任何其他行为。您可以在服务层类中使用 @Service 而不是 @Component,因为它以更好的方式指定了意图
06
2020
05

如何在 spring 中启动注解装配?

默认情况下,Spring 容器中未打开注解装配。因此,要使用基于注解装配,我们必须通过配置<context:annotation-config /> 元素在 Spring 配置文件中启用它。
06
2020
05

什么是基于注解的容器配置

不使用 XML 来描述 bean 装配,开发人员通过在相关的类,方法或字段声明上使用注解将配置移动到组件类本身。它可以作为 XML 设置的替代方案。例如:Spring 的 Java 配置是通过使用 @Bean 和 @Configuration 来实现。@Bean 注解扮演与 元素相同的角色。@Configuration 类允许通过简单地调用同一个类中的其他 @Bean 方法来定义 bean 间依赖关系。例如:@Configurationpublic class StudentConfig {&n
06
2020
05

自动装配有什么局限?

覆盖的可能性 - 您始终可以使用 <constructor-arg> 和 <property> 设置指定依赖项,这将覆盖自动装配。基本元数据类型 - 简单属性(如原数据类型,字符串和类)无法自动装配。令人困惑的性质 - 总是喜欢使用明确的装配,因为自动装配不太精确。
06
2020
05

自动装配有哪些方式?

Spring 容器能够自动装配 bean。也就是说,可以通过检查 BeanFactory 的内容让 Spring 自动解析 bean 的协作者。自动装配的不同模式:no - 这是默认设置,表示没有自动装配。应使用显式 bean 引用进行装配。byName - 它根据 bean 的名称注入对象依赖项。它匹配并装配其属性与 XML 文件中由相同名称定义的 bean。byType - 它根据类型注入对象依赖项。如果属性的类型与 XML 文件中的一个 bean 名称匹配,则匹配并装配属性。构造函数 -
06
2020
05

什么是 spring 装配

当 bean 在 Spring 容器中组合在一起时,它被称为装配或 bean 装配。 Spring 容器需要知道需要什么 bean 以及容器应该如何使用依赖注入来将 bean 绑定在一起,同时装配 bean。
06
2020
05

什么是 spring 的内部 bean?

只有将 bean 用作另一个 bean 的属性时,才能将 bean 声明为内部 bean。为了定义 bean,Spring 的基于 XML 的配置元数据在 <property> 或 <constructor-arg> 中提供了 <bean> 元素的使用。内部 bean 总是匿名的,它们总是作为原型。例如,假设我们有一个 Student 类,其中引用了 Person 类。这里我们将只创建一个 Person 类实例并在 Student 中使用它。Student.j
06
2020
05

spring bean 容器的生命周期是什么样的?

spring bean 容器的生命周期流程如下:Spring 容器根据配置中的 bean 定义中实例化 bean。Spring 使用依赖注入填充所有属性,如 bean 中所定义的配置。如果 bean 实现 BeanNameAware 接口,则工厂通过传递 bean 的 ID 来调用 setBeanName()。如果 bean 实现 BeanFactoryAware 接口,工厂通过传递自身的实例来调用 setBeanFactory()。如果存在与 bean 关联的任何 BeanPostProces
06
2020
05

spring 支持集中 bean scope?

Spring bean 支持 5 种 scope:Singleton - 每个 Spring IoC 容器仅有一个单实例。Prototype - 每次请求都会产生一个新的实例。Request - 每一次 HTTP 请求都会产生一个新的实例,并且该 bean 仅在当前 HTTP 请求内有效。Session - 每一次 HTTP 请求都会产生一个新的 bean,同时该 bean 仅在当前 HTTP session 内有效。Global-session - 类似于标准的 HTTP Session 作用
06
2020
05

spring 提供了哪些配置方式?

基于 xml 配置bean 所需的依赖项和服务在 XML 格式的配置文件中指定。这些配置文件通常包含许多 bean 定义和特定于应用程序的配置选项。它们通常以 bean 标签开头。例如:<bean id="studentbean" class="org.edureka.firstSpring.StudentBean"> <property name="name" value="Edureka&quo
06
2020
05

什么是 spring bean?

它们是构成用户应用程序主干的对象。Bean 由 Spring IoC 容器管理。它们由 Spring IoC 容器实例化,配置,装配和管理。Bean 是基于用户提供给容器的配置元数据创建。
06
2020
05

Spring IoC 的实现机制。

Spring 中的 IoC 的实现原理就是工厂模式加反射机制。示例:interface Fruit {     public abstract void eat();}class Apple implements Fruit {    public void eat(){        System.out.println("Apple");    }}class O
06
2020
05

列举 IoC 的一些好处。

IoC 的一些好处是:它将最小化应用程序中的代码量。它将使您的应用程序易于测试,因为它不需要单元测试用例中的任何单例或 JNDI 查找机制。它以最小的影响和最少的侵入机制促进松耦合。它支持即时的实例化和延迟加载服务。
06
2020
05

区分 BeanFactory 和 ApplicationContext。

BeanFactory:它使用懒加载它使用语法显式提供资源对象不支持国际化不支持基于依赖的注解ApplicationContext:它使用即时加载它自己创建和管理资源对象支持国际化支持基于依赖的注解
06
2020
05

spring 中有多少种 IOC 容器?

BeanFactory - BeanFactory 就像一个包含 bean 集合的工厂类。它会在客户端要求时实例化 bean。ApplicationContext - ApplicationContext 接口扩展了 BeanFactory 接口。它在 BeanFactory 基础上提供了一些额外的功能。
06
2020
05

区分构造函数注入和 setter 注入。

构造函数注入:没有部分注入不会覆盖 setter 属性任意修改都会创建一个新实例适用于设置很多属性setter 注入:有部分注入会覆盖 setter 属性任意修改不会创建一个新实例适用于设置少量属性
06
2020
05

可以通过多少种方式完成依赖注入?

通常,依赖注入可以通过三种方式完成,即:构造函数注入setter 注入接口注入在 Spring Framework 中,仅使用构造函数和 setter 注入。
06
2020
05

什么是依赖注入?

在依赖注入中,您不必创建对象,但必须描述如何创建它们。您不是直接在代码中将组件和服务连接在一起,而是描述配置文件中哪些组件需要哪些服务。由 IoC 容器将它们装配在一起。
06
2020
05

什么是 Spring IOC 容器?

Spring 框架的核心是 Spring 容器。容器创建对象,将它们装配在一起,配置它们并管理它们的完整生命周期。Spring 容器使用依赖注入来管理组成应用程序的组件。容器通过读取提供的配置元数据来接收对象进行实例化,配置和组装的指令。该元数据可以通过 XML,Java 注解或 Java 代码提供。
06
2020
05

使用 Spring 有哪些方式?

使用 Spring 有以下方式:作为一个成熟的 Spring Web 应用程序。作为第三方 Web 框架,使用 Spring Frameworks 中间层。用于远程使用。作为企业级 Java Bean,它可以包装现有的 POJO(Plain Old Java Objects)。
06
2020
05

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

Spring 应用一般有以下组件:接口 - 定义功能。Bean 类 - 它包含属性,setter 和 getter 方法,函数等。Spring 面向切面编程(AOP) - 提供面向切面编程的功能。Bean 配置文件 - 包含类的信息以及如何配置它们。用户程序 - 它使用接口。
06
2020
05

什么是 Spring 配置文件?

Spring 配置文件是 XML 文件。该文件主要包含类信息。它描述了这些类是如何配置以及相互引入的。但是,XML 配置文件冗长且更加干净。如果没有正确规划和编写,那么在大项目中管理变得非常困难。
06
2020
05

Spring Framework 中有多少个模块,它们分别是什么?

Spring 核心容器 – 该层基本上是 Spring Framework 的核心。它包含以下模块:Spring CoreSpring BeanSpEL (Spring Expression Language)Spring Context数据访问/集成 – 该层提供与数据库交互的支持。它包含以下模块:JDBC (Java DataBase Connectivity)ORM (Object Relational Mapping)OXM (Object XML Mappers)JMS (Java M
06
2020
05

Spring Framework 有哪些不同的功能?

轻量级 - Spring 在代码量和透明度方面都很轻便。IOC - 控制反转AOP - 面向切面编程可以将应用业务逻辑和系统服务分离,以实现高内聚。容器 - Spring 负责创建和管理对象(Bean)的生命周期和配置。MVC - 对 web 应用提供了高度可配置性,其他框架的集成也十分方便。事务管理 - 提供了用于事务管理的通用抽象层。Spring 的事务支持也可用于容器较少的环境。JDBC 异常 - Spring 的 JDBC 抽象层提供了一个异常层次结构,简化了错误处理策略。
06
2020
05

列举 Spring Framework 的优点。

由于 Spring Frameworks 的分层架构,用户可以自由选择自己需要的组件。Spring Framework 支持 POJO(Plain Old Java Object) 编程,从而具备持续集成和可测试性。由于依赖注入和控制反转,JDBC 得以简化。它是开源免费的。
06
2020
05

什么是 Spring Framework?

Spring 是一个开源应用框架,旨在降低应用程序开发的复杂度。它是轻量级、松散耦合的。它具有分层体系结构,允许用户选择组件,同时还为 J2EE 应用程序开发提供了一个有凝聚力的框架。它可以集成其他框架,如 Structs、Hibernate、EJB 等,所以又称为框架的框架。
06
2020
05

不同版本的 Spring Framework 有哪些主要功能?

Spring 2.5 发布于 2007 年。这是第一个支持注解的版本。Spring 3.0 发布于 2009 年。它完全利用了 Java5 中的改进,并为 JEE6 提供了支持。Spring 4.0 发布于 2013 年。这是第一个完全支持 JAVA8 的版本。
06
2020
05

@RequestMapping 注解

该注解是用来映射一个URL到一个类或一个特定的方处理法上。
06
2020
05

@Controller 注解

该注解表明该类扮演控制器的角色,Spring不需要你继承任何其他控制器基类或引用Servlet API。
06
2020
05

什么是Spring MVC框架的控制器?

控制器提供一个访问应用程序的行为,此行为通常通过服务接口实现。控制器解析用户输入并将其转换为一个由视图呈现给用户的模型。Spring用一个非常抽象的方式实现了一个控制层,允许用户创建多种用途的控制器。
06
2020
05

WebApplicationContext

WebApplicationContext 继承了ApplicationContext  并增加了一些WEB应用必备的特有功能,它不同于一般的ApplicationContext ,因为它能处理主题,并找到被关联的servlet。
06
2020
05

DispatcherServlet

Spring的MVC框架是围绕DispatcherServlet来设计的,它用来处理所有的HTTP请求和响应。
06
2020
05

什么是Spring的MVC框架?

Spring 配备构建Web 应用的全功能MVC框架。Spring可以很便捷地和其他MVC框架集成,如Struts,Spring 的MVC框架用控制反转把业务对象和控制逻辑清晰地隔离。它也允许以声明的方式把请求参数和业务对象绑定。
06
2020
05

解释基于注解的切面实现

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

解释基于XML Schema方式的切面实现。

在这种情况下,切面由常规类以及基于XML的配置实现。
06
2020
05

什么是织入。什么是织入应用的不同点?

织入是将切面和到其他应用类型或对象连接或创建一个被通知对象的过程。织入可以在编译时,加载时,或运行时完成。
06
2020
05

有几种不同类型的自动代理?

BeanNameAutoProxyCreatorDefaultAdvisorAutoProxyCreatorMetadata autoproxying
06
2020
05

什么是代理?

代理是通知目标对象后创建的对象。从客户端的角度看,代理对象和目标对象是一样的。
06
2020
05

什么是目标对象?

被一个或者多个切面所通知的对象。它通常是一个代理对象。也指被通知(advised)对象。
06
2020
05

什么是引入?

引入允许我们在已存在的类中增加新的方法和属性。
06
2020
05

切点

切入点是一个或一组连接点,通知将在这些位置执行。可以通过表达式或匹配的方式指明切入点。
06
2020
05

通知

通知是个在方法执行前或执行后要做的动作,实际上是程序执行时要通过SpringAOP框架触发的代码段。Spring切面可以应用五种类型的通知:before:前置通知,在一个方法执行前被调用。after: 在方法执行之后调用的通知,无论方法执行是否成功。after-returning: 仅当方法成功完成后执行的通知。after-throwing: 在方法抛出异常退出时执行的通知。around: 在方法执行之前和之后调用的通知。
06
2020
05

连接点

连接点代表一个应用程序的某个位置,在这个位置我们可以插入一个AOP切面,它实际上是个应用程序执行Spring AOP的位置。
06
2020
05

在Spring AOP 中,关注点和横切关注的区别是什么?

关注点是应用中一个模块的行为,一个关注点可能会被定义成一个我们想实现的一个功能。横切关注点是一个关注点,此关注点是整个应用都会使用的功能,并影响整个应用,比如日志,安全和数据传输,几乎应用的每个模块都需要的功能。因此这些都属于横切关注点。
06
2020
05

Aspect 切面

AOP核心就是切面,它将多个类的通用行为封装成可重用的模块,该模块含有一组API提供横切功能。比如,一个日志模块可以被称作日志的AOP切面。根据需求的不同,一个应用程序可以有若干切面。在Spring AOP中,切面通过带有@Aspect注解的类实现。
06
2020
05

你更倾向用那种事务管理类型?

大多数Spring框架的用户选择声明式事务管理,因为它对应用代码的影响最小,因此更符合一个无侵入的轻量级容器的思想。声明式事务管理要优于编程式事务管理,虽然比编程式事务管理(这种方式允许你通过代码控制事务)少了一点灵活性。
06
2020
05

Spring支持的事务管理类型

Spring支持两种类型的事务管理:编程式事务管理:这意味你通过编程的方式管理事务,给你带来极大的灵活性,但是难维护。声明式事务管理:这意味着你可以将业务代码和事务管理分离,你只需用注解和XML配置来管理事务。
06
2020
05

如何通过HibernateDaoSupport将Spring和Hibernate结合起来?

用Spring的 SessionFactory 调用 LocalSessionFactory。集成过程分三步:配置the Hibernate SessionFactory。继承HibernateDaoSupport实现一个DAO。在AOP支持的事务中装配。
06
2020
05

Spring支持的ORM

Spring支持以下ORM:HibernateiBatisJPA (Java Persistence API)TopLinkJDO (Java Data Objects)OJB
06
2020
05

使用Spring通过什么方式访问Hibernate?

在Spring中有两种方式访问Hibernate:控制反转  Hibernate Template和 Callback。继承 HibernateDAOSupport提供一个AOP 拦截器。
06
2020
05

Spring对DAO的支持

Spring对数据访问对象(DAO)的支持旨在简化它和数据访问技术如JDBC,Hibernate or JDO 结合使用。这使我们可以方便切换持久层。编码时也不用担心会捕获每种技术特有的异常。
06
2020
05

JdbcTemplate

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

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

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

@Qualifier 注解

当有多个相同类型的bean却只有一个需要自动装配时,将@Qualifier 注解和@Autowire 注解结合使用以消除这种混淆,指定需要装配的确切的bean。
06
2020
05

@Autowired 注解

@Autowired 注解提供了更细粒度的控制,包括在何处以及如何完成自动装配。它的用法和@Required一样,修饰setter方法、构造器、属性或者具有任意名称和/或多个参数的PN方法。
06
2020
05

@Required 注解

这个注解表明bean的属性必须在配置的时候设置,通过一个bean定义的显式的属性值或通过自动装配,若@Required注解的bean属性未被设置,容器将抛出BeanInitializationException。
06
2020
05

什么是基于注解的容器配置?

相对于XML文件,注解型的配置依赖于通过字节码元数据装配组件,而非尖括号的声明。开发者通过在相应的类,方法或属性上使用注解的方式,直接组件类中进行配置,而不是使用xml表述bean的装配关系。
06
2020
05

你可以在Spring中注入一个null 和一个空字符串吗?

可以。
06
2020
05

自动装配有哪些局限性 ?

自动装配的局限性是:重写: 你仍需用 <constructor-arg>和 <property> 配置来定义依赖,意味着总要重写自动装配。基本数据类型:你不能自动装配简单的属性,如基本数据类型,String字符串,和类。模糊特性:自动装配不如显式装配精确,如果有可能,建议使用显式装配。
06
2020
05

解释不同方式的自动装配 。

有五种自动装配的方式,可以用来指导Spring容器用自动装配方式来进行依赖注入。no:默认的方式是不进行自动装配,通过显式设置ref 属性来进行装配。byName:通过参数名 自动装配,Spring容器在配置文件中发现bean的autowire属性被设置成byname,之后容器试图匹配、装配和该bean的属性具有相同名字的bean。byType::通过参数类型自动装配,Spring容器在配置文件中发现bean的autowire属性被设置成byType,之后容器试图匹配、装配和该bean的属性具有
06
2020
05

什么是bean的自动装配?

Spring 容器能够自动装配相互合作的bean,这意味着容器不需要<constructor-arg>和<property>配置,能通过Bean工厂自动处理bean之间的协作。
06
2020
05

什么是bean装配?

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

什么是Spring的内部bean?

当一个bean仅被用作另一个bean的属性时,它能被声明为一个内部bean,为了定义inner bean,在Spring 的 基于XML的 配置元数据中,可以在 <property/>或 <constructor-arg/> 元素内使用<bean/> 元素,内部bean通常是匿名的,它们的Scope一般是prototype。
06
2020
05

哪些是重要的bean生命周期方法? 你能重载它们吗?

有两个重要的bean 生命周期方法,第一个是setup , 它是在容器加载bean的时候被调用。第二个方法是 teardown  它是在容器卸载类的时候被调用。The bean 标签有两个重要的属性(init-method和destroy-method)。用它们你可以自己定制初始化和注销方法。它们也有相应的注解(@PostConstruct和@PreDestroy)。
06
2020
05

你怎样定义类的作用域?

当定义一个<bean> 在Spring里,我们还能给这个bean声明一个作用域。它可以通过bean 定义中的scope属性来定义。如,当Spring要在需要的时候每次生产一个新的bean实例,bean的scope属性被指定为prototype。另一方面,一个bean每次使用的时候必须返回同一个实例,这个bean的scope 属性 必须设为 singleton。
06
2020
05

如何给Spring 容器提供配置元数据

这里有三种重要的方法给Spring 容器提供配置元数据。XML配置文件。基于注解的配置。基于java的配置。
06
2020
05

一个 Spring Bean 定义 包含什么?

一个Spring Bean 的定义包含容器必知的所有配置元数据,包括如何创建一个bean,它的生命周期详情及它的依赖。
06
2020
05

什么是Spring beans?

Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC容器初始化,装配,和管理。这些beans通过容器中配置的元数据创建。比如,以XML文件中<bean/> 的形式定义。Spring 框架定义的beans都是单件beans。在bean tag中有个属性”singleton”,如果它被赋为TRUE,bean 就是单件,否则就是一个 prototype bean。默认是TRUE,所以所有在Spring框架中的beans 缺省都是单件。
06
2020
05

哪种依赖注入方式你建议使用,构造器注入,还是 Setter方法注入?

你两种依赖方式都可以使用,构造器注入和Setter方法注入。最好的解决方案是用构造器参数实现强制依赖,setter方法实现可选依赖。
06
2020
05

一个Spring的应用看起来象什么?

一个定义了一些功能的接口。这实现包括属性,它的Setter , getter 方法和函数等。Spring AOP。Spring 的XML 配置文件。使用以上功能的客户端程序。
06
2020
05

Bean 工厂和 Application contexts 有什么区别?

Application contexts提供一种方法处理文本消息,一个通常的做法是加载文件资源(比如镜像),它们可以向注册为监听器的bean发布事件。另外,在容器或容器内的对象上执行的那些不得不由bean工厂以程序化方式处理的操作,可以在Application contexts中以声明的方式处理。Application contexts实现了MessageSource接口,该接口的实现以可插拔的方式提供获取本地化消息的方法。
06
2020
05

pplicationContext通常的实现是什么?

FileSystemXmlApplicationContext :此容器从一个XML文件中加载beans的定义,XML Bean 配置文件的全路径名必须提供给它的构造函数。ClassPathXmlApplicationContext:此容器也从一个XML文件中加载beans的定义,这里,你需要正确设置classpath因为这个容器将在classpath里找bean配置。WebXmlApplicationContext:此容器加载一个XML文件,此文件定义了一个WEB应用的所有bean。
06
2020
05

Spring配置文件

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

解释WEB 模块。

Spring的WEB模块是构建在application context 模块基础之上,提供一个适合web应用的上下文。这个模块也包括支持多种面向web的任务,如透明地处理多个文件上传请求和程序级请求参数的绑定到你的业务对象。它也有对Jakarta Struts的支持。
06
2020
05

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

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

解释JDBC抽象和DAO模块。

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

解释AOP模块

AOP模块用于发给我们的Spring应用做面向切面的开发, 很多支持由AOP联盟提供,这样就确保了Spring和其他AOP框架的共通性。这个模块将元数据编程引入Spring。
06
2020
05

Spring由哪些模块组成?

以下是Spring 框架的基本模块:Core moduleBean moduleContext moduleExpression Language moduleJDBC moduleORM moduleOXM moduleJava Messaging Service(JMS) moduleTransaction moduleWeb moduleWeb-Servlet moduleWeb-Struts moduleWeb-Portlet module
06
2020
05

Spring框架中的单例bean是线程安全的吗?

    不,Spring框架中的单例bean不是线程安全的。
06
2020
05

spring核心类有哪些?各有什么作用?

  BeanFactory:产生一个新的实例,可以实现单例模式BeanWrapper:提供统一的get及set方法ApplicationContext:提供框架的实现,包括BeanFactory的所有功能
06
2020
05

怎样开启注解装配?

注解装配在默认情况下是不开启的,为了使用注解装配,我们必须在Spring配置文件中配置 <context:annotation-config/>元素。
06
2020
05

解释Spring支持的几种bean的作用域。

Spring容器中的bean可以分为5个范围:(1)singleton:默认,每个容器中只有一个bean的实例,单例的模式由BeanFactory自身来维护。(2)prototype:为每一个bean请求提供一个实例。(3)request:为每一个网络请求创建一个实例,在请求完成以后,bean会失效并被垃圾回收器回收。(4)session:与request范围类似,确保每个session中有一个bean的实例,在session过期后,bean会随之失效。(5)global-session:全局作
06
2020
05

Spring的自动装配:

在spring中,对象无需自己查找或创建与其关联的其他对象,由容器负责把需要相互协作的对象引用赋予各个对象,使用autowire来配置自动装载模式。在Spring框架xml配置中共有5种自动装配:(1)no:默认的方式是不进行自动装配的,通过手工设置ref属性来进行装配bean。(2)byName:通过bean的名称进行自动装配,如果一个bean的 property 与另一bean 的name 相同,就进行自动装配。 (3)byType:通过参数的数据类型进行自动装配。(4)const
06
2020
05

spring事务的实现及其原理

Spring事务的本质其实就是数据库对事务的支持,没有数据库的事务支持,spring是无法提供事务功能的。(1)Spring事务的种类:spring支持编程式事务管理和声明式事务管理两种方式:①编程式事务管理使用TransactionTemplate。②声明式事务管理建立在AOP之上的。其本质是通过AOP功能,对方法前后进行拦截,将事务处理的功能编织到拦截的方法中,也就是在目标方法开始之前加入一个事务,在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要在业务逻辑代码
06
2020
05

什么是IOC、DI 及其两者的优点 、 有哪几种注入方式

IOC:控制反转,把创建对象的控制权利由代码转移到spring的配置文件中。最直观的表达就是,IOC让对象的创建不用去new了,可以由spring自动生产,使用java的反射机制,根据配置文件在运行时动态的去创建对象以及管理对象,并调用对象的方法的。DI:依赖注入,在程序运行期间,由外部容器动态地将依赖对象注入到组件中。简单定义就是当一个对象需要另一个对象时,可以把另一个对象注入到对象中去。优点就是把应用的代码量降到最低,达到松散耦合度。注入的方式:构造注入Set注入接口注入Spring提供以下
06
2020
05

谈谈对AOP理解?

aop面向切面编程,关键在于代理模式,Spring AOP使用的动态代理,所谓的动态代理就是说AOP框架不会去修改字节码,而是每次运行时在内存中临时为方法生成一个AOP对象,这个AOP对象包含了目标对象的全部方法,并且在特定的切点做了增强处理,并回调原对象的方法。动态代理可以减少系统中的重复代码,降低了模块间的耦合度,同时提高了系统的可维护性。可用于权限认证、日志、事务处理。Spring AOP中的动态代理主要有两种方式,JDK动态代理和CGLIB动态代理:JDK代理:基于接口的代理,不支持类的
06
2020
05

什么是spring、为什么要用spring及其优点、spring有哪些模块组成 ?

什么是springSpring 是个Java企业级应用的开源开发框架。Spring主要用来开发Java应用,但是有些扩展是针对构建J2EE平台的web应用。Spring 框架目标是简化Java企业级应用开发,它使得开发者只需要关心业务需求。spring优点spring属于低侵入式设计,代码的污染极低;spring的DI机制将对象之间的依赖关系交由框架处理,减低组件的耦合性;Spring提供了AOP技术,支持将一些通用任务,如安全、事务、日志、权限等进行集中式管理,从而提供更好的复用。spring
30
2020
03

解释AOP模块

AOP模块用于发给我们的Spring应用做面向切面的开发, 很多支持由AOP联盟提供,这样就确保了Spring和其他AOP框架的共通性。这个模块将元数据编程引入Spring。
30
2020
03

XMLBeanFactory

最常用的就是org.springframework.beans.factory.xml.XmlBeanFactory ,它根据XML文件中的定义加载beans。该容器从XML 文件读取配置元数据并用它去创建一个完全配置的系统或应用。
30
2020
03

BeanFactory – BeanFactory 实现举例。

Bean 工厂是工厂模式的一个实现,提供了控制反转功能,用来把应用的配置和依赖从正真的应用代码中分离。最常用的BeanFactory 实现是XmlBeanFactory 类。
30
2020
03

核心容器(应用上下文) 模块。

这是基本的Spring模块,提供spring 框架的基础功能,BeanFactory 是 任何以spring为基础的应用的核心。Spring 框架建立在此模块之上,它使Spring成为一个容器。
30
2020
03

Spring由哪些模块组成?

以下是Spring 框架的基本模块:Core moduleBean moduleContext moduleExpression Language moduleJDBC moduleORM moduleOXM moduleJava Messaging Service(JMS) moduleTransaction moduleWeb moduleWeb-Servlet moduleWeb-Struts moduleWeb-Portlet module
30
2020
03

什么是spring?

Spring 是个java企业级应用的开源开发框架。Spring主要用来开发Java应用,但是有些扩展是针对构建J2EE平台的web应用。Spring 框架目标是简化Java企业级应用开发,并通过POJO为基础的编程模型促进良好的编程习惯。 
30
2020
03

spring基于xml配置声明式事务管理步骤?

步骤:1.在applicationContext.xml中声明aop和tx的名称空间2.声明事物管理器  也就是声明一个bean3.声明通知 通过<tx:advice>和他里面的各种属性配置其中name是必须的,说明对那个方法进行事物控制4.声明切面  通过<aop:config>配置切面,在里面配置切点和通知Spring声明式事务管理步骤:1.导入所需jar包(Spring3.0之后不再一起发布依赖包,要自行下载) 2.在applicat
30
2020
03

谈谈你所知道的数据库事务管理器?

spring中的平台事物管理器可以根据不同的平台选择相应的事物管理器,有DataSourceTransactionManager,针对jdbctemplate和mybits开发HibernateTransactionManager针对Hibernate开发JpaTransactionManager针对jpa开发事物管理器根据TransactionDefinition定义的事物信息进行事物管理,通过Transactionstatus来描述事物的运行状态
30
2020
03

Dao类可以怎么样使用jdbcTemplate进行数据库操作?

1.通过Autowired注入jdbcTemplate,dao类在spring管理中,jdbcTemplate在spring管理中,在dao类上直接通过autowired注入2.通过property属性注入,dao类在spring管理中,jdbcTemplate在spring管理中,在dao类上添加set方法,在xml文件中配置property属性注入3.dao类继承JdbcDaoSupport,dao类在spring容器中,给他注入属性DataSource,然后在dao 类中直接使用getTe
30
2020
03

谈谈你所知道的数据库连接池?

概念:数据库连接池负责分配、管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是再重新建立一个;释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。阿里的Druid开源连接池,c3p0连接池,Hibernate中sessionFactory内部维护了一个连接池,spring内置的连接池DriverManagerDataSource 
20
2020
03

构造方法注入和设值注入有什么区别?

请注意以下明显的区别:在设值注入方法支持大部分的依赖注入,如果我们仅需要注入int、string和long型的变量,我们不要用设值的方法注入。对于基本类型,如果我们没有注入的话,可以为基本类型设置默认值。在构造方法注入不支持大部分的依赖注入,因为在调用构造方法中必须传入正确的构造参数,否则的话为报错。设值注入不会重写构造方法的值。如果我们对同一个变量同时使用了构造方法注入又使用了设置方法注入的话,那么构造方法将不能覆盖由设值方法注入的值。很明显,因为构造方法尽在对象被创建时调用。在使用设值注入时
20
2020
03

怎样用注解的方式配置Spring?

Spring在2.5版本以后开始支持用注解的方式来配置依赖注入。可以用注解的方式来替代XML方式的bean描述,可以将bean描述转移到组件类的内部,只需要在相关类上、方法上或者字段声明上使用注解即可。注解注入将会被容器在XML注入之前被处理,所以后者会覆盖掉前者对于同一个属性的处理结果。 注解装配在Spring中是默认关闭的。所以需要在Spring文件中配置一下才能使用基于注解的装配模式。如果你想要在你的应用程序中使用关于注解的方法的话,请参考如下的配置。 在 标签配置完成
20
2020
03

如何用基于Java配置的方式配置Spring?

Spring对Java配置的支持是由@Configuration注解和@Bean注解来实现的。由@Bean注解的方法将会实例化、配置和初始化一个新对象,这个对象将由Spring的IoC容器来管理。@Bean声明所起到的作用与 元素类似。被@Configuration所注解的类则表示这个类的主要目的是作为bean定义的资源。被@Configuration声明的类可以通过在同一个类的内部调用@bean方法来设置嵌入bean的依赖关系。 最简单的@Configuration 声明类请参考下面
20
2020
03

如何用基于XML配置的方式配置Spring?

在Spring框架中,依赖和服务需要在专门的配置文件来实现,我常用的XML格式的配置文件。这些配置文件的格式通常用开头,然后一系列的bean定义和专门的应用配置选项组成。 SpringXML配置的主要目的时候是使所有的Spring组件都可以用xml文件的形式来进行配置。这意味着不会出现其他的Spring配置类型(比如声明的方式或基于Java Class的配置方式) Spring的XML配置方式是使用被Spring命名空间的所支持的一系列的XML标签来实现的。Spring有以下
20
2020
03

Spring有几种配置方式?

将Spring配置到应用开发中有以下三种方式: 1. 基于XML的配置 2. 基于注解的配置 3. 基于Java的配置 
20
2020
03

请解释下Spring框架中的IoC?

Spring中的 org.springframework.beans 包和 org.springframework.context包构成了Spring框架IoC容器的基础。 BeanFactory 接口提供了一个先进的配置机制,使得任何类型的对象的配置成为可能。ApplicationContex接口对BeanFactory(是一个子接口)进行了扩展,在BeanFactory的基础上添加了其他功能,比如与Spring的AOP更容易集成,也提供了处理message resource的机制(
20
2020
03

什么是控制反转(IOC)?什么是依赖注入?

控制反转是应用于软件工程领域中的,在运行时被装配器对象来绑定耦合对象的一种编程技巧,对象之间耦合关系在编译时通常是未知的。在传统的编程方式中,业务逻辑的流程是由应用程序中的早已被设定好关联关系的对象来决定的。在使用控制反转的情况下,业务逻辑的流程是由对象关系图来决定的,该对象关系图由装配器负责实例化,这种实现方式还可以将对象之间的关联关系的定义抽象化。而绑定的过程是通过“依赖注入”实现的。 控制反转是一种以给予应用程序中目标组件更多控制为目的设计范式,并在我们的实际工作中起到了有效的作
20
2020
03

使用Spring框架能带来哪些好处?

下面列举了一些使用Spring框架带来的主要好处: • Dependency Injection(DI) 方法使得构造器和JavaBean properties文件中的依赖关系一目了然。 • 与EJB容器相比较,IoC容器更加趋向于轻量级。这样一来IoC容器在有限的内存和CPU资源的情况下进行应用程序的开发和发布就变得十分有利。 • Spring并没有闭门造车,Spring利用了已有的技术比如ORM框架、logging框架、J2EE、Quartz和JDK Timer
20
2020
03

什么是Spring框架?Spring框架有哪些主要模块?

Spring框架是一个为Java应用程序的开发提供了综合、广泛的基础性支持的Java平台。Spring帮助开发者解决了开发中基础性的问题,使得开发人员可以专注于应用程序的开发。Spring框架本身亦是按照设计模式精心打造,这使得我们可以在开发环境中安心的集成Spring框架,不必担心Spring是如何在后台进行工作的。 Spring框架至今已集成了20多个模块。这些模块主要被分为核心容器、数据访问/集成,、Web、AOP(面向切面编程)、工具、消息和测试模块。
19
2020
02

Spring是什么?

Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架,目的是用于简化企业应用程序的开发,它使得开发者只需要关心业务需求。常见的配置方式有三种:基于XML的配置、基于注解的配置、基于Java的配置。主要由以下几个模块组成:Spring Core:核心类库,提供IOC服务;Spring Context:提供框架式的Bean访问方式,以及企业级功能(JNDI、定时任务等);Spring AOP:AOP服务;Spring DAO:对JDBC的抽象,简化了数据访问
19
2020
02

Spring的AOP理解:

OOP面向对象,允许开发者定义纵向的关系,但并适用于定义横向的关系,导致了大量代码的重复,而不利于各个模块的重用。AOP,一般称为面向切面,作为面向对象的一种补充,用于将那些与业务无关,但却对多个对象产生影响的公共行为和逻辑,抽取并封装为一个可重用的模块,这个模块被命名为“切面”(Aspect),减少系统中的重复代码,降低了模块间的耦合度,同时提高了系统的可维护性。可用于权限认证、日志、事务处理。AOP实现的关键在于 代理模式,AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ
19
2020
02

Spring的IoC理解:

(1)IOC就是控制反转,是指创建对象的控制权的转移,以前创建对象的主动权和时机是由自己把控的,而现在这种权力转移到Spring容器中,并由容器根据配置文件去创建实例和管理各个实例之间的依赖关系,对象与对象之间松散耦合,也利于功能的复用。DI依赖注入,和控制反转是同一个概念的不同角度的描述,即 应用程序在运行时依赖IoC容器来动态注入对象需要的外部资源。(2)最直观的表达就是,IOC让对象的创建不用去new了,可以由spring自动生产,使用java的反射机制,根据配置文件在运行时动态的去创建对
19
2020
02

BeanFactory和ApplicationContext有什么区别?

    BeanFactory和ApplicationContext是Spring的两大核心接口,都可以当做Spring的容器。其中ApplicationContext是BeanFactory的子接口。(1)BeanFactory:是Spring里面最底层的接口,包含了各种Bean的定义,读取bean配置文档,管理bean的加载、实例化,控制bean的生命周期,维护bean之间的依赖关系。ApplicationContext接口作为BeanFactory的派生,除了提供Bea
19
2020
02

Spring框架中的单例Beans是线程安全的么?

 Spring框架并没有对单例bean进行任何多线程的封装处理。关于单例bean的线程安全和并发问题需要开发者自行去搞定。但实际上,大部分的Spring bean并没有可变的状态(比如Serview类和DAO类),所以在某种程度上说Spring的单例bean是线程安全的。如果你的bean有多种状态的话(比如 View Model 对象),就需要自行保证线程安全。最浅显的解决办法就是将多态bean的作用域由“singleton”变更为“prototype”。
19
2020
02

Spring基于xml注入bean的几种方式

(1)Set方法注入;(2)构造器注入:①通过index设置参数的位置;②通过type设置参数类型;(3)静态工厂注入;(4)实例工厂;
19
2020
02

Spring 框架中都用到了哪些设计模式?

(1)工厂模式:BeanFactory就是简单工厂模式的体现,用来创建对象的实例;(2)单例模式:Bean默认为单例模式。(3)代理模式:Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术;(4)模板方法:用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。(5)观察者模式:定义对象键一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知被制动更新,如Spring中listener的实现--
19
2020
02

Spring中的隔离级别

① ISOLATION_DEFAULT:这是个 PlatfromTransactionManager 默认的隔离级别,使用数据库默认的事务隔离级别。② ISOLATION_READ_UNCOMMITTED:读未提交,允许另外一个事务可以看到这个事务未提交的数据。③ ISOLATION_READ_COMMITTED:读已提交,保证一个事务修改的数据提交后才能被另一事务读取,而且能看到该事务对已有记录的更新。④ ISOLATION_REPEATABLE_READ:可重复读,保证一个事务修改的数据提交
19
2020
02

spring的事务传播行为

spring事务的传播行为说的是,当多个事务同时存在的时候,spring如何处理这些事务的行为。① PROPAGATION_REQUIRED:如果当前没有事务,就创建一个新事务,如果当前存在事务,就加入该事务,该设置是最常用的设置。② PROPAGATION_SUPPORTS:支持当前事务,如果当前存在事务,就加入该事务,如果当前不存在事务,就以非事务执行。‘③ PROPAGATION_MANDATORY:支持当前事务,如果当前存在事务,就加入该事务,如果当前不存在事务,就抛出异常。④ PROP
19
2020
02

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

Spring事务的本质其实就是数据库对事务的支持,没有数据库的事务支持,spring是无法提供事务功能的。真正的数据库层的事务提交和回滚是通过binlog或者redo log实现的。(1)Spring事务的种类:spring支持编程式事务管理和声明式事务管理两种方式:①编程式事务管理使用TransactionTemplate。②声明式事务管理建立在AOP之上的。其本质是通过AOP功能,对方法前后进行拦截,将事务处理的功能编织到拦截的方法中,也就是在目标方法开始之前加入一个事务,在执行完目标方法之
19
2020
02

解释一下Spring AOP里面的几个名词:

(1)切面(Aspect):被抽取的公共模块,可能会横切多个对象。 在Spring AOP中,切面可以使用通用类(基于模式的风格) 或者在普通类中以 @AspectJ 注解来实现。(2)连接点(Join point):指方法,在Spring AOP中,一个连接点 总是 代表一个方法的执行。 (3)通知(Advice):在切面的某个特定的连接点(Join point)上执行的动作。通知有各种类型,其中包括“around”、“before”和“after”等通知。许多AOP框架,包括Spr
19
2020
02

Spring通知有哪些类型?

(1)前置通知(Before advice):在某连接点(join point)之前执行的通知,但这个通知不能阻止连接点前的执行(除非它抛出一个异常)。(2)返回后通知(After returning advice):在某连接点(join point)正常完成后执行的通知:例如,一个方法没有抛出任何异常,正常返回。 (3)抛出异常后通知(After throwing advice):在方法抛出异常退出时执行的通知。 (4)后通知(After (finally) advice)
21
2019
12

IOC,AOP的实现原理?-Spring面试题

IOC:通过反射机制生成对象注入AOP:动态代理
21
2019
12

Spring主要使用了什么模式?-Spring面试题

工厂模式:每个Bean的创建通过方法单例模式:默认的每个Bean的作用域都是单例代理模式:关于Aop的实现通过代理模式
21
2019
12

Spring DI 的三种方式?-Spring面试题

构造器注入:通过构造方法初始化<constructor-arg index="0" type="java.lang.String" value="宝马"></constructor-arg>setter方法注入:通过setter方法初始化 <property name="id" value="1111">
20
2019
12

Spring下的注解?

注册:@Controller @Service @Component注入:@Autowired @Resource请求地址:@RequestMapping返回具体数据类型而非跳转:@ResponseBody
19
2019
12

Spring的配置文件中的内容?

答:开启事务注解驱动事务管理器开启注解功能,并配置扫描包配置数据库配置SQL会话工厂,别名,映射文件不用编写Dao层的实现类