• 关于

    依赖注入容器

    的搜索结果

回答

1.1、IoC是什么  Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。如何理解好Ioc呢?理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了”,那我们来深入分析一下:  ●谁控制谁,控制什么:传统Java SE程序设计,我们直接在对象内部通过new进行创建对象,是程序主动去创建依赖对象;而IoC是有专门一个容器来创建这些对象,即由Ioc容器来控制对 象的创建;谁控制谁?当然是IoC 容器控制了对象;控制什么?那就是主要控制了外部资源获取(不只是对象包括比如文件等)。  ●为何是反转,哪些方面反转了:有反转就有正转,传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象,也就是正转;而反转则是由容器来帮忙创建及注入依赖对象;为何是反转?因为由容器帮我们查找及注入依赖对象,对象只是被动的接受依赖对象,所以是反转;哪些方面反转了?依赖对象的获取被反转了。  用图例说明一下,传统程序设计如图2-1,都是主动去创建相关对象然后再组合起来:图1-1 传统应用程序示意图  当有了IoC/DI的容器后,在客户端类中不再主动去创建这些对象了,如图2-2所示:图1-2有IoC/DI容器后程序结构示意图1.2、IoC能做什么  IoC 不是一种技术,只是一种思想,一个重要的面向对象编程的法则,它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象,从而导致类与类之间高耦合,难于测试;有了IoC容器后,把创建和查找依赖对象的控制权交给了容器,由容器进行注入组合对象,所以对象与对象之间是 松散耦合,这样也方便测试,利于功能复用,更重要的是使得程序的整个体系结构变得非常灵活。  其实IoC对编程带来的最大改变不是从代码上,而是从思想上,发生了“主从换位”的变化。应用程序原本是老大,要获取什么资源都是主动出击,但是在IoC/DI思想中,应用程序就变成被动的了,被动的等待IoC容器来创建并注入它所需要的资源了。  IoC很好的体现了面向对象设计法则之一—— 好莱坞法则:“别找我们,我们找你”;即由IoC容器帮对象找相应的依赖对象并注入,而不是由对象主动去找。1.3、IoC和DI  DI—Dependency Injection,即“依赖注入”:组件之间依赖关系由容器在运行期决定,形象的说,即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能,而是为了提升组件重用的频率,并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制,我们只需要通过简单的配置,而无需任何代码就可指定目标需要的资源,完成自身的业务逻辑,而不需要关心具体的资源来自何处,由谁实现。  理解DI的关键是:“谁依赖谁,为什么需要依赖,谁注入谁,注入了什么”,那我们来深入分析一下:  ●谁依赖于谁:当然是应用程序依赖于IoC容器;  ●为什么需要依赖:应用程序需要IoC容器来提供对象需要的外部资源;  ●谁注入谁:很明显是IoC容器注入应用程序某个对象,应用程序依赖的对象;  ●注入了什么:就是注入某个对象所需要的外部资源(包括对象、资源、常量数据)。  IoC和DI由什么关系呢?其实它们是同一个概念的不同角度描述,由于控制反转概念比较含糊(可能只是理解为容器控制对象这一个层面,很难让人想到谁来维护对象关系),所以2004年大师级人物Martin Fowler又给出了一个新的名字:“依赖注入”,相对IoC 而言,“依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”。  看过很多对Spring的Ioc理解的文章,好多人对Ioc和DI的解释都晦涩难懂,反正就是一种说不清,道不明的感觉,读完之后依然是一头雾水,感觉就是开涛这位技术牛人写得特别通俗易懂,他清楚地解释了IoC(控制反转) 和DI(依赖注入)中的每一个字,读完之后给人一种豁然开朗的感觉。我相信对于初学Spring框架的人对Ioc的理解应该是有很大帮助的。

wangccsy 2019-12-02 01:49:09 0 浏览量 回答数 0

回答

首先, spring作为容器就是为了解决代码中大量new操作的,因为new操作涉及到其他依赖对象的创举,你的TestBooks就是自己new操作的,但是没有设置各个依赖对象,所以会报空指针。因为你的代码是自己new的BookDao对象,而不是靠Spring容器创建的bean对象,BookDao对象中的依赖的其他对象当然不会自动被注入了。其次,依赖bean是由Spring注入的,所以在创建实例时应该通过spring容器创建 而不是自己new操作来创建实例。Spring创建对象的方法:修正你的main方法如下: ApplicationContext context= new FileSystemXmlApplicationContext("applicationContext.xml"); BooksDao booksDao = context.getBean("booksDao"); 这样通过spring容器创建的bean的依赖对象才会被自动注入了。

小旋风柴进 2019-12-02 01:57:15 0 浏览量 回答数 0

回答

对IoC和DI的理解:1. 依赖注入和控制反转是从两个角度表达的同一个概念,前者从Spring角度,后者从调用者角度。2. 控制反转:当某个Java对象(调用者)需要调用另一个Java对象(被调用者,也就是被依赖对象)时,通常调用者会采用“new 被调用者”来创建对象,这样有一个痛点就是增强了调用者和被调用者之间的代码耦合,后期不好维护等等。所以在Spring框架中,对象的实例不再由调用者来创建了,而是由Spring容器来创建,控制权由我们写的代码(new 被调用者)转移到了Spring容器,这就是所谓的控制反转。2. 依赖注入:是从Spring角度看的,Spring容器负责将被依赖对象(被调用者)赋值给调用者,这相当于为调用者注入了它依赖的实例,这就是所谓的依赖注入。再给一张图:

kissjz 2019-12-02 02:36:08 0 浏览量 回答数 0

阿里云域名特惠专场,热门域名1元抢购!

全网低价特惠,顶级域名低至1元,更有96元/年服务器限时抢购!

回答

目前也正在学Spring,说一下我整理的理解,对IoC和DI的理解:1. 依赖注入和控制反转是从两个角度表达的同一个概念,前者从Spring角度,后者从调用者角度。2. 控制反转:当某个Java对象(调用者)需要调用另一个Java对象(被调用者,也就是被依赖对象)时,通常调用者会采用“new 被调用者”来创建对象,这样有一个痛点就是增强了调用者和被调用者之间的代码耦合,后期不好维护等等。所以在Spring框架中,对象的实例不再由调用者来创建了,而是由Spring容器来创建,控制权由我们写的代码(new 被调用者)转移到了Spring容器,这就是所谓的控制反转。2. 依赖注入:是从Spring角度看的,Spring容器负责将被依赖对象(被调用者)赋值给调用者,这相当于为调用者注入了它依赖的实例,这就是所谓的依赖注入。[图片]

kissjz 2019-12-02 01:54:56 0 浏览量 回答数 0

回答

一、spring 中的概念 ##beanFactory容器1、容器是spring框架的核心,容器使用ioc依赖注入来管理所有组成应用系统的组件。 2、spring中的两种容器: beanFactory 这个容器提供了基础的依赖注入支持,而且是延迟加载的,而 applicationcontext是对beanFactory 这个容器的扩展, 3、beanFactory :beanFactory就是一个Bean工厂,使用了工厂模式,但bean工厂不像一般的工厂,只提供特定类的bean而是一个通用的工厂,可以创建和分发各种类型的bean,beanFactory不仅仅只是创建和分发bean因为我们知道,这个bean工厂知道应用中的很多对象,在创建这些对象的时候,创建出了这些对象之间的关联关系,bean工厂还管理这些对象的生命周期。4、beanFactory 接口的实现类有很多,我们这里就举一个常用的类: XMLBeanFactory, XMLBeanFactory构造方法的参数是一个inputStream对象,而传递进来的就是我们定义bean的xml文件 5、实例:BeanFactory beanfactory = new XMLBeanFactory(newFileInputStream(bean.xml)); 这样beanFactory就获取了配置文件中bean的信息,但是bean是延迟实例化的所以现在只是加载进来了,但还是没有创建实例,只有在使用的时候尽心创建 6、 User user=(User)beanfactory.getBean("user"); 当我们调用getBean()时工厂会实例化并且会依赖注入设置相关属性值。 ApplicationContext 容器 1、applicationcontext和beanFactory看来都是一样的,都是加载bean的信息,配置bean和分发bean,但是application context作为beanFactory的扩展有一些额外的功能:(1)文本信息解析工具,包括对国际化的支持(2)应用上下文提供了载入文件资源的通用方法(3)应用上下文可以向注册为监听器的bean发送事件,因为application context的额外功能所以在应用中大都使用application context而beanFactory在资源较少的移动设备上使用 2、ApplicationContext的实现:ClassPathXmlApplicationContext()类路劲中的xml文件中载入上下文信息,FileSystemXmlApplicationContext()文件系统xml获取上下文信息 XmlWebApplicationContext()从网络获取上下文信息。3、我们知道 ApplicationContext是对beanFactory的扩展所以我们同样可以使用 .getBean("User")来获取对象,但是这里有点不同,那就是在beanFactory中使用的就是懒加载,在调用getBean()的时候才会创建实例而ApplicationContext () 在上下文预加载的时候就创建了实例,在使用的时候不用等待创建而是直接使用。 Spring中bean的周期 1、容器寻找bean的定义信息,并且实例化bean2、使用依赖注入,spring按照bean定义信息配置bean的所有属性3、如果bean实现了BeanNameAware接口则工厂调用bean的setBeanName() 方法传递bean的Id4、如果bean实现了beanFacgtoryAware 接口则工厂调用 setBeanFactory()方法传入工厂本身。5、如果有BeanPostProcess和bean关联那么他们的PostProcessBeforeInitialzation()方法将被调用6、如果bean指定了init-method 方法则将被调用7、如果有BeanPostProcess和bean关联那么他们的PostProcessAfterInitialzation()方法将被调用 到这里bean就可以在系统中被使用了,并将一直保存在BeanFactory 中直到他不在使用。8、删除: spring 中有两种方式:(1)、如果bean实现了Disposable接口则destory方法将会被调用(2)、自己定义定义了销毁方法则执行他 destroy-method 依赖注入 1、所谓依赖注入,即组件之间的依赖关系由容器在运行期决定,形象地说,即由容器动态地将某种依赖关系注入到组件之中。装配在spring容器内拼凑bean叫做装配,装配bean的时候你是在告诉容器需要哪些bean,以及容器如何使用依赖注入将他们配合在一起。 实例化1、在使用spring容器进行bean类的管理的时候,我们获取bean类有两种类型,一种就是在spring中使用了单例模式,获取的都是第一次加载的时候创建的那个bean实例,第二种就是在spring中没有定义单例模式,每获取一次就会产生一个新的bean实例。 区别这两种的配置: <beanid="user" class="com.inspur.User" singleton=off> </bean> // singleton(单一的 唯一的) 这里关闭了单例模式,所以每次获取的bean对象都是新的,而在spring中singleton默认是开着的,因为像数据库连接池,网络资源等创建新对象很浪费资源,所以还是使用单例模式比较好,如果没有特别需求还是使用单例模式比较好!

小旋风柴进 2019-12-02 01:58:02 0 浏览量 回答数 0

回答

DI:依赖注入,指的是spring创建对象的过程中,将对象依赖属性通过配置的方式进行注入 IOC:控制反转,指将对象的创建权,反转到Spring容器,不再是由调用者去new对象了,二十由spring容器去创建对象,两者之间的关系是从不同的角度的描述的同一件事情,就是指通过引入IOC容器,利用依赖关系注入的方式,实现对象之间的解耦。di是ioc的实现方式  

有头发的程序猿 2019-12-02 03:15:02 0 浏览量 回答数 0

问题

spring使用最基本的依赖注入,导包的问题?报错

爱吃鱼的程序员 2020-06-06 21:09:39 0 浏览量 回答数 1

回答

所以控制反转IoC(Inversion of Control)是说创建对象的控制权进行转移,以前创建对象的主动权和创建时机是由自己把控的,而现在这种权力转移到第三方,比如转移交给了IoC容器,它就是一个专门用来创建对象的工厂,你要什么对象,它就给你什么对象,有了 IoC容器,依赖关系就变了,原先的依赖关系就没了,它们都依赖IoC容器了,通过IoC容器来建立它们之间的关系。DI(依赖注入)其实就是IOC的一种类型,还有一种是DL(Dependency Lookup依赖查找)。 DL由Martin Fowler 在2004年初的一篇论文中首次提出的。他总结:控制的什么被反转了?就是:获得依赖对象的方式反转了。

wangccsy 2019-12-02 01:39:42 0 浏览量 回答数 0

回答

自动装配是在spring环境下当使用该类的实例时由spring容器完成了类的实例化过程,当然包括对依赖对象的实例化过程。而通过反射创建实例时,是根据你调用的构造函数完成的实例化过程,没有容器的自动化创建实例了,所以需要自己对依赖对象进行注入。所以依赖spring容器实例化和自己用反射实例化是两种独立的方式,不能相互渗透的。

小旋风柴进 2019-12-02 01:57:22 0 浏览量 回答数 0

回答

可以。 spring依赖注入知的三种实现形式分别为: 1、 接口注入 2、 设置注入 3.构造子函数注入 接口注入:而接口注入则更方便道动态注入。简单的说,接口注入就是在运专行期,加载接口实现并创建其实例的工作由容器完成。如下例子: public class ClassA { private InterfaceB clzB; public Object doSomething(InterfaceB b) { clzB = b; return clzB.doIt(); } …… } 在运行期,InterfaceB实例将由spring容器提供。而spingIOC概念的提出也是把动属态注入在spring体现了。

剑曼红尘 2020-05-04 09:46:26 0 浏览量 回答数 0

回答

IoC(Inversion of Control) (1). IoC(Inversion of Control)是指容器控制程序对象之间的关系,而不是传统实现中,由程序代码直接操控。控制权由应用代码中转到了外部容器,控制权的转移是所谓反转。 对于Spring而言,就是由Spring来控制对象的生命周期和对象之间的关系;IoC还有另外一个名字——“依赖注入(Dependency Injection)”。从名字上理解,所谓依赖注入,即组件之间的依赖关系由容器在运行期决定,即由容器动态地将某种依赖关系注入到组件之中。 (2). 在Spring的工作方式中,所有的类都会在spring容器中登记,告诉spring这是个什么东西,你需要什么东西,然后spring会在系统运行到适当的时候,把你要的东西主动给你,同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制,也就是说控制对象生存周期的不再是引用它的对象,而是spring。对于某个具体的对象而言,以前是它控制其他对象,现在是所有对象都被spring控制,所以这叫控制反转。(3). 在系统运行中,动态的向某个对象提供它所需要的其他对象。 (4). 依赖注入的思想是通过反射机制实现的,在实例化一个类时,它通过反射调用类中set方法将事先保存在HashMap中的类属性注入到类中。 总而言之,在传统的对象创建方式中,通常由调用者来创建被调用者的实例,而在Spring中创建被调用者的工作由Spring来完成,然后注入调用者,即所谓的依赖注入or控制反转。 注入方式有两种:依赖注入和设置注入; IoC的优点:降低了组件之间的耦合,降低了业务对象之间替换的复杂性,使之能够灵活的管理对象。AOP(Aspect Oriented Programming)(1). AOP面向方面编程基于IoC,是对OOP的有益补充;(2). AOP利用一种称为“横切”的技术,剖解开封装的对象内部,并将那些影响了 多个类的公共行为封装到一个可重用模块,并将其名为“Aspect”,即方面。所谓“方面”,简单地说,就是将那些与业务无关,却为业务模块所共同调用的 逻辑或责任封装起来,比如日志记录,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。(3). AOP代表的是一个横向的关 系,将“对象”比作一个空心的圆柱体,其中封装的是对象的属性和行为;则面向方面编程的方法,就是将这个圆柱体以切面形式剖开,选择性的提供业务逻辑。而 剖开的切面,也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原,不留痕迹,但完成了效果。(4). 实现AOP的技术,主要分为两大类:一是采用动态代理技术,利用截取消息的方式,对该消息进行装饰,以取代原有对象行为的执行;二是采用静态织入的方式,引入特定的语法创建“方面”,从而使得编译器可以在编译期间织入有关“方面”的代码。(5). Spring实现AOP:JDK动态代理和CGLIB代理 JDK动态代理:其代理对象必须是某个接口的实现,它是通过在运行期间创建一个接口的实现类来完成对目标对象的代理;其核心的两个类是InvocationHandler和Proxy。 CGLIB代理:实现原理类似于JDK动态代理,只是它在运行期间生成的代理对象是针对目标类扩展的子类。CGLIB是高效的代码生成包,底层是依靠ASM(开源的java字节码编辑类库)操作字节码实现的,性能比JDK强;需要引入包asm.jar和cglib.jar。 使用AspectJ注入式切面和@AspectJ注解驱动的切面实际上底层也是通过动态代理实现的。(6). AOP使用场景: Authentication 权限检查 Caching 缓存 Context passing 内容传递 Error handling 错误处理 Lazy loading 延迟加载 Debugging  调试 logging, tracing, profiling and monitoring 日志记录,跟踪,优化,校准 Performance optimization 性能优化,效率检查 Persistence  持久化 Resource pooling 资源池 Synchronization 同步 Transactions 事务管理 另外Filter的实现和struts2的拦截器的实现都是AOP思想的体现。

wangccsy 2019-12-02 01:50:38 0 浏览量 回答数 0

回答

这个面试题应该是 Spring Bean的生命周期,作为java 的容器,1、首先Spring IOC 容器启动后,会加载配置信息,判断scope,比如是单例、还是request还是session模式、prototype,2、实例化bean,根据Bean定义信息配置信息,注入依赖,3、 之后,就可以正式注入Bean了,4、对于scope为singleton的Bean,Spring的ioc容器中会缓存一份该bean的实例,5、而对于scope为request的Bean,每次被调用都会创建新bean,6、Spring 容器关闭后,会销毁对象,

徐雷frank 2019-12-02 01:50:24 0 浏览量 回答数 0

回答

Spring的AOP实现最底层还是 通过 Cglib或JdkProxy 2中方式生成代理对象完成IOC:则是通过配置bean之间的依赖关系,由Bean容器完成bean的依赖注入

空境 2019-12-02 01:50:38 0 浏览量 回答数 0

回答

不会直接在代码中连接组件和服务,而是描述配置文件中的哪些组件需要哪些服务。然后,容器(在 Spring 框架中,IOC 容器)负责将其全部挂钩。 即,应用 IoC,对象在创建时由协调系统中每个对象的外部实体授予其依赖关系。也就是说,依赖项将注入到对象中。因此,IoC 意味着对对象如何获取对协作对象的引用的责任倒置。

YDYK 2020-04-24 21:35:23 0 浏览量 回答数 0

回答

Spring AOP:代理机制 Spring提供的自动代理机制Spring的IoC来实组件之间的依赖关系注入, 使控制层与业务实现分离,即客户通过调用业务委托接口来调用具体的业务组件的实例,避免控制层与业务层的藕合带来的维护或升级困难。由Spring为DAO生成代理对象来为DAO添加事务服务,由IoC容器DAO的代理实例注入到业务组件中业务组件通过DAO的委托接口调用DAO对象,使得上层组件不直接依赖于DAO的实现类,使得持久层更换或修改不影响上层组件。

YDYK 2020-04-25 13:29:08 0 浏览量 回答数 0

回答

<p>“注入”是spring容器做的事情 我们要做的是告诉容器我们要“注入”什么东西 ,当你使用面向接口式编程时会发现在代码中写死new 就不那么好使了,你可能会选择将要new的子类名称写到配置文件然后通过反射方式来创建对象 这时候你就会发现spring其实挺好用的</p> 比如说有个接口Service,实现类叫ServiceImpl, spring通过 <bean id="serviceImpl" class="*.ServiceImpl" /> 创建了对象,是不是用的时候要这样: Service service =ApplicationContext.getBean("serviceImpl"); 这不是也是挺麻烦的啊...... <p>只依赖context,但是context包自身依赖其他的一些包,如果你是手动处理依赖的话,那就要手动加这些依赖包了,手动处理依赖关系很麻烦的,最好用maven或gradle来管理。</p> 关于spring的作用,当你需要测试某个方法,但是这个方法的对象依赖许多其他的对象的时候;又或者你需要整合其他框架的时候,你就会感谢spring了。 spring默认产生的对象是单例的,通常是无状态的对象,这种对象本身就可以重复使用,频繁创建和销毁除了占用资源和消耗时间之外没用其他作用。你要是需要那种new完就扔的对象spring也可以帮你做,你只要把bean声明成原型类型就行了。

爱吃鱼的程序员 2020-06-06 21:09:56 0 浏览量 回答数 0

回答

介绍过FactoryBean的用法后,我们就可以了解bean加载的过程了。前面已经提到过,单例在Spring的同一个容器内只会被创建一次,后续再获取bean直接从单例缓存中获取,当然这里也只是尝试加载,首先尝试从缓存中加载,然后再次尝试尝试从singletonFactories中加载。因为在创建单例bean的时候会存在依赖注入的情况,而在创建依赖的时候为了避免循环依赖,Spring创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光加入到缓存中,一旦下一个bean创建时需要依赖上个bean,则直接使用ObjectFactory。

星尘linger 2020-04-12 20:23:24 0 浏览量 回答数 0

回答

对于使用配置的 Slet 容器配置的 JNDI DataSource,我们需要在Spring Bean配置文件中配置它,然后将其作为依赖项注入弹簧 bean。然后,我们可以用它来执行数据库操作。JdbcTemplate

YDYK 2020-04-25 21:55:38 0 浏览量 回答数 0

回答

Spring 的依赖配置方式与 Spring 框架的内核自身是松耦合设计的。然而,直到 Spring 3.0 以前,使用 XML 进行依赖配置几乎是唯一的选择。Spring 3.0 的出现改变了这一状况,它提供了一系列的针对依赖注入的注解,这使得 Spring IoC 在 XML 文件之外多了一种可行的选择。从 2.0 版本开始,Spring 的每一次更新都会提供更多新的注解供开发者使用。这满足了注解爱好者的胃口。但是正如前面所说,Spring 提供更多的注解并不是为了有朝一日取代 XML 配置方式,而是为了给开发者多一种选择。两种声明 Bean 的方式各有特色,XML 方式更加灵活,并且发展的相对成熟,这种配置方式为大多数 Spring 开发者熟悉;注解方式使用起来非常简洁,但是尚处于发展阶段。我们很难说两种配置方式孰优孰劣,但是如果能够灵活搭配两种方式,一定能够进一步提升开发效率。spring注解带来的问题:1、缺乏明晰的设置装备摆设导致轨范的依靠注入关系不明晰。  2、晦气于模块化的装配。  3、给维护带来麻烦,因为你要按照源代码找到依靠关系。  4、通用性欠好。如不美观你哪天抛开了Spring,换了此外Ioc容器,那么你的注解要一个个的删除。

小旋风柴进 2019-12-02 01:57:37 0 浏览量 回答数 0

回答

首先,你问bean初始化的东西什么用?举个通俗的例子,如果一个家庭想要一个小孩,那他们就需要通过人工运动来创建一个孩子,这是普通的获取一个对象的方法。而bean创建对象,就是这个spring容器就像孤儿院,它本身就有很多已经创建好的小孩,如果一个家庭想要一个小孩,他们只需要去把那些创建的小孩领出来就可以了。这个spring 目的就是方便开发者使用对象,而不再需要创建对象,就是所谓的拿来主义。第二个问题:程序中怎么使用这个bean,在spring中如果想让spring创建一个bean,有两种方式,一种是通过xml文件配置来管理bean ,另一种方式是通过注解来管理bean,这两种方式各有秋千。如果你要使用这个bean,只需要在引用这个bean的类里面加入@resource这样的注解,即可食用。第三个问题:hibernate可以注入,自己的还有什么用。通俗的来说,如果你已经有管理beand的容器,那么你就不需要自己在费力的new一个对象了,也就是说,你直接使用依赖注入就好了,干嘛还要自己去费时new对象,浪费内存。

a123456678 2019-12-02 02:13:27 0 浏览量 回答数 0

回答

无: 默认值,没有自动布线,通过"ref"属性手动设置它,正如我们通过 settor 方法帖子在依赖项注入中所做的那样。 按名称: 按属性名称自动布线。Spring 容器查看在 XML 配置文件中将autowire属性设置为name的 bean 的属性,并尝试将其与 xml 配置文件中的 bean 名称匹配。 按类型: 按属性数据类型自动布线。弹簧容器查看在 XML 配置文件中按Type将自动线属性设置为 bean 的属性。然后,如果属性的类型与配置文件中的一个 bean 名称完全匹配,则它尝试匹配和连接属性。如果存在多个此类 bean,则引发致命异常。 协调器: 构造函数参数中的按类型模式。 自动检测: 弹簧首先尝试使用构造函数的自动线线,如果它不工作,Spring 尝试按类型自动布线 。

YDYK 2020-04-24 21:45:30 0 浏览量 回答数 0

回答

Spring整合Hibernate是一个比较大的问题,根据我的理解,概括来说有以下步骤:1.Spring声明DataSource数据源的SpringBean实例;2.Spring声明Hibernate的SessionFactory,Spring中有对Hibernate的SessionFactory类的封装类,通常只需要声明Spring中的Hibernate封装类即可,然后利用Spring容器的依赖注入,把数据源(dataSource)注入给同样是Spring Bean实例的SessionFactory对象,同时列出所有的持久化(PO)类。3.把SessionFactory对象再注入给Dao方法,在Dao方法中利用SessionFactory实例对数据进行CRUD;4.Dao类一般仅用于单一的CRUD,真正的业务逻辑实现通常被定义在Service类中,Dao类的实例通过Spring依赖注入被注入给Service类实例;5.在真正的企业应用中,利用Spring对Hibernate进行事务管理也是十分重要的,而事务管理通常是利用Spring的面向切面编程(AOP)对Service类进行增强从而达到事务控制的目的。以下是一个配置文件示例,我假定楼主已经有了Spring和Hibernate的基础: <?xml version="1.0" encoding="GBK"?> xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd"> <!--定义数据源bean,使用C3P0数据源实现,并注入数据源的必要信息--> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close" p:driverClass="oracle.jdbc.OracleDriver" p:jdbcUrl="jdbc:oracle:thin:@localhost:1521:orcl" p:user="scott" p:password="tiger" p:maxPoolSize="5" p:minPoolSize="2" p:initialPoolSize="2" p:maxIdleTime="30"/> <!--定义Hibernate的SessionFactory,SessionFactory需要依赖注入源,注入dataSource--> <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean" p:dataSource-ref="dataSource"> <!-- 指定持久化(PO)类--> <property name="annotatedClasses"> <list> <value>org.hrsystem.domain.Aoo</value> </list> </property> <!-- 指定Hibernate的属性配置--> <property name="hibernateProperties"> <value> hibernate.dialect=org.hibernate.dialect.Oracle10gDialect hibernate.hbm2ddl.auto=update hibernate.show_sql=true hibernate.format_sql=false hibernate.cache.use_second_level_cache=true hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory </value> </property> </bean> <!--把sessionFactory注入给employeeDao Bean实例--> <bean id="employeeDao" class="org.hrsystem.dao.impl.EmployeeDaoImpl" p:sessionFactory-ref="sessionFactory"/> <!--把employeeDao注入给empManager Bean实例--> <bean id="empManager" class="org.hrsystem.service.impl.EmpManagerImpl" p:employeeDao-ref="employeeDao"/> <!-- 以下是利用Spring的AOP对Hibernate进行事务控制 --> <!-- 配置Hibernate的声明事务管理器,并依赖注入SessionFactory --> <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/> </bean> <!-- 配置事务增强Bean,依赖注入事务管理器 --> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <!-- 配置详细的事务定义,这些配置放在tx:attributes元素中 --> <tx:attributes> <!-- 定义对可以作为AOP切入点的所有方法都进行事务增强 name属性指定AOP切入点中需要进行事务增强的方法, 用*(通配符)指代所有方法,或get*指代所有以get开头的方法; isolation属性指定隔离级别,用默认的隔离级别; propagation属性指定事务的传播性,REQUIRED指如果调用该方法的线程处于事务中, 则直接调用;如果当前执行线程不处于事务环境中,则启动新的事务后执行该方法; timeout事务超时的时间,以秒为单位; --> <tx:method name="*" isolation="DEFAULT" propagation="REQUIRED" timeout="5"/> </tx:attributes> </tx:advice> <aop:config> <!-- 定义切入点,此时仅仅指定empManager实例作为需要增强的实例, 也可以使用Spring EL表达式来指定具有相同特征的一批类作为切入点 --> <aop:pointcut id="myPoint" expression="bean(empManager)"/> <!-- 使用aop:advisor元素指定在myPoint切入点使用txAdvice进行事务增强处理 --> <aop:advisor advice-ref="txAdvice" pointcut-ref="myPoint"/> </aop:config>

云栖技术 2019-12-02 02:32:27 0 浏览量 回答数 0

问题

详解 Spring 3.0 基于 Annotation 的依赖注入实现 配置报错 

kun坤 2020-06-01 09:44:47 3 浏览量 回答数 1

回答

最优的解决方案就是不用struts2了,改用springmvc,我保证,你用了之后就会再也不想用回来struts2的######真的吗?谢谢。######要获取session不应该使用这种方式,在省城bean的时候这个方法返回的还是空指针,要获取session应该是实现相应的接口,完成依赖注入######回复 @颖辉小居 : 没毛病啊,不就是存值取值嘛,这里面的值和httpsession的值是对应的。@controller注解原先是给springmvc使用的,默认是单例,但是struts2用的时候不要单例,每次请求新建######回复 @阿信sxq : 这个拿到的是map不是HttpSession @Override public void setSession(Map<String, Object> session) { this.session=session; }######回复 @阿信sxq : 谢谢,还有一个问题:spring配置action时该使用单例还是其他的作用域?######回复 @颖辉小居 : 实现“org.apache.struts2.interceptor.SessionAware“即可######可以说的详细点吗?######自己顶 ######异常原因分析:因为action加了注解,而容器使用的是ApplicationContext(默认启动容器立即加载Bean)。在action中使用了父类BaseAction的属性session,所以启动Spring容器时就会调用session的初始化方法ServletActionContext.getRequest() .getSession();此时,没有用户访问,也就没有请求,所以request为空,调用.getSession()方法时报空指针。 ######新的疑问:spring容器applicationContext默认创建Bean是单例作用域。Struts2的action是多例的,如果给action加上注解被Spring管理。会不会在作用域上又冲突?######第三种办法:不在action上加Spring注解(即不被Spring管理)。Struts2会自动为每一次请求创建一个action实例(线程安全),未发现什么问题。######第二种办法IOC注入: BaseAction实现接口ServletRequestAware 并实现方法setServletRequest。可以注入HttpRequest实例,通过request.getSession()获得HttpSession######找到一个解决办法给ACTION加注解@Lazy(true),但是感觉这个不是最好的办法。######想不到还有人在使用struts。。。。。

kun坤 2020-05-27 17:25:05 0 浏览量 回答数 0

回答

最优的解决方案就是不用struts2了,改用springmvc,我保证,你用了之后就会再也不想用回来struts2的######真的吗?谢谢。######要获取session不应该使用这种方式,在省城bean的时候这个方法返回的还是空指针,要获取session应该是实现相应的接口,完成依赖注入######回复 @颖辉小居 : 没毛病啊,不就是存值取值嘛,这里面的值和httpsession的值是对应的。@controller注解原先是给springmvc使用的,默认是单例,但是struts2用的时候不要单例,每次请求新建######回复 @阿信sxq : 这个拿到的是map不是HttpSession @Override public void setSession(Map<String, Object> session) { this.session=session; }######回复 @阿信sxq : 谢谢,还有一个问题:spring配置action时该使用单例还是其他的作用域?######回复 @颖辉小居 : 实现“org.apache.struts2.interceptor.SessionAware“即可######可以说的详细点吗?######自己顶 ######异常原因分析:因为action加了注解,而容器使用的是ApplicationContext(默认启动容器立即加载Bean)。在action中使用了父类BaseAction的属性session,所以启动Spring容器时就会调用session的初始化方法ServletActionContext.getRequest() .getSession();此时,没有用户访问,也就没有请求,所以request为空,调用.getSession()方法时报空指针。 ######新的疑问:spring容器applicationContext默认创建Bean是单例作用域。Struts2的action是多例的,如果给action加上注解被Spring管理。会不会在作用域上又冲突?######第三种办法:不在action上加Spring注解(即不被Spring管理)。Struts2会自动为每一次请求创建一个action实例(线程安全),未发现什么问题。######第二种办法IOC注入: BaseAction实现接口ServletRequestAware 并实现方法setServletRequest。可以注入HttpRequest实例,通过request.getSession()获得HttpSession######找到一个解决办法给ACTION加注解@Lazy(true),但是感觉这个不是最好的办法。######想不到还有人在使用struts。。。。。

kun坤 2020-06-06 20:06:16 0 浏览量 回答数 0

回答

最优的解决方案就是不用struts2了,改用springmvc,我保证,你用了之后就会再也不想用回来struts2的######真的吗?谢谢。######要获取session不应该使用这种方式,在省城bean的时候这个方法返回的还是空指针,要获取session应该是实现相应的接口,完成依赖注入######回复 @颖辉小居 : 没毛病啊,不就是存值取值嘛,这里面的值和httpsession的值是对应的。@controller注解原先是给springmvc使用的,默认是单例,但是struts2用的时候不要单例,每次请求新建######回复 @阿信sxq : 这个拿到的是map不是HttpSession @Override public void setSession(Map<String, Object> session) { this.session=session; }######回复 @阿信sxq : 谢谢,还有一个问题:spring配置action时该使用单例还是其他的作用域?######回复 @颖辉小居 : 实现“org.apache.struts2.interceptor.SessionAware“即可######可以说的详细点吗?######自己顶 ######异常原因分析:因为action加了注解,而容器使用的是ApplicationContext(默认启动容器立即加载Bean)。在action中使用了父类BaseAction的属性session,所以启动Spring容器时就会调用session的初始化方法ServletActionContext.getRequest() .getSession();此时,没有用户访问,也就没有请求,所以request为空,调用.getSession()方法时报空指针。 ######新的疑问:spring容器applicationContext默认创建Bean是单例作用域。Struts2的action是多例的,如果给action加上注解被Spring管理。会不会在作用域上又冲突?######第三种办法:不在action上加Spring注解(即不被Spring管理)。Struts2会自动为每一次请求创建一个action实例(线程安全),未发现什么问题。######第二种办法IOC注入: BaseAction实现接口ServletRequestAware 并实现方法setServletRequest。可以注入HttpRequest实例,通过request.getSession()获得HttpSession######找到一个解决办法给ACTION加注解@Lazy(true),但是感觉这个不是最好的办法。######想不到还有人在使用struts。。。。。

montos 2020-05-31 08:12:29 0 浏览量 回答数 0

回答

最优的解决方案就是不用struts2了,改用springmvc,我保证,你用了之后就会再也不想用回来struts2的真的吗?谢谢。要获取session不应该使用这种方式,在省城bean的时候这个方法返回的还是空指针,要获取session应该是实现相应的接口,完成依赖注入回复<aclass='referer'target='_blank'>@颖辉小居:没毛病啊,不就是存值取值嘛,这里面的值和httpsession的值是对应的。@controller注解原先是给springmvc使用的,默认是单例,但是struts2用的时候不要单例,每次请求新建回复<aclass='referer'target='_blank'>@阿信sxq:这个拿到的是map不是HttpSession@OverridepublicvoidsetSession(Map<String,Object>session){this.session=session;}回复<aclass='referer'target='_blank'>@阿信sxq:谢谢,还有一个问题:spring配置action时该使用单例还是其他的作用域?回复<aclass='referer'target='_blank'>@颖辉小居:实现“org.apache.struts2.interceptor.SessionAware“即可可以说的详细点吗?自己顶 异常原因分析:因为action加了注解,而容器使用的是ApplicationContext(默认启动容器立即加载Bean)。在action中使用了父类BaseAction的属性session,所以启动Spring容器时就会调用session的初始化方法ServletActionContext.getRequest().getSession();此时,没有用户访问,也就没有请求,所以request为空,调用.getSession()方法时报空指针。新的疑问:spring容器applicationContext默认创建Bean是单例作用域。Struts2的action是多例的,如果给action加上注解被Spring管理。会不会在作用域上又冲突?第三种办法:不在action上加Spring注解(即不被Spring管理)。Struts2会自动为每一次请求创建一个action实例(线程安全),未发现什么问题。第二种办法IOC注入:BaseAction实现接口ServletRequestAware并实现方法setServletRequest。可以注入HttpRequest实例,通过request.getSession()获得HttpSession找到一个解决办法给ACTION加注解@Lazy(true),但是感觉这个不是最好的办法。想不到还有人在使用struts。。。。。

爱吃鱼的程序员 2020-06-10 13:50:58 0 浏览量 回答数 0

回答

AOP AOP(Aspect Oriented Programming),即面向切面编程,可以说是OOP(Object Oriented Programming,面向对象编程)的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构,用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系,但并不适合定义横向的关系,例如日志功能。日志代码往往横向地散布在所有对象层次中,而与它对应的对象的核心功能毫无关系对于其他类型的代码,如安全性、异常处理和透明的持续性也都是如此,这种散布在各处的无关的代码被称为横切(cross cutting),在OOP设计中,它导致了大量代码的重复,而不利于各个模块的重用。 AOP技术恰恰相反,它利用一种称为"横切"的技术,剖解开封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,并将其命名为"Aspect",即切面。所谓"切面",简单说就是那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块之间的耦合度,并有利于未来的可操作性和可维护性。 使用"横切"技术,AOP把软件系统分为两个部分:核心关注点和横切关注点。业务处理的主要流程是核心关注点,与之关系不大的部分是横切关注点。横切关注点的一个特点是,他们经常发生在核心关注点的多处,而各处基本相似,比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点,将核心关注点和横切关注点分离开来。 AOP核心概念 1、横切关注点 对哪些方法进行拦截,拦截后怎么处理,这些关注点称之为横切关注点 2、切面(aspect) 类是对物体特征的抽象,切面就是对横切关注点的抽象 3、连接点(joinpoint) 被拦截到的点,因为Spring只支持方法类型的连接点,所以在Spring中连接点指的就是被拦截到的方法,实际上连接点还可以是字段或者构造器 4、切入点(pointcut) 对连接点进行拦截的定义 5、通知(advice) 所谓通知指的就是指拦截到连接点之后要执行的代码,通知分为前置、后置、异常、最终、环绕通知五类 6、目标对象 代理的目标对象 7、织入(weave) 将切面应用到目标对象并导致代理对象创建的过程 8、引入(introduction) 在不修改代码的前提下,引入可以在运行期为类动态地添加一些方法或字段 Spring对AOP的支持 Spring中AOP代理由Spring的IOC容器负责生成、管理,其依赖关系也由IOC容器负责管理。因此,AOP代理可以直接使用容器中的其它bean实例作为目标,这种关系可由IOC容器的依赖注入提供。Spring创建代理的规则为: 1、默认使用Java动态代理来创建AOP代理,这样就可以为任何接口实例创建代理了 2、当需要代理的类不是代理接口的时候,Spring会切换为使用CGLIB代理,也可强制使用CGLIB AOP编程其实是很简单的事情,纵观AOP编程,程序员只需要参与三个部分: 1、定义普通业务组件 2、定义切入点,一个切入点可能横切多个业务组件 3、定义增强处理,增强处理就是在AOP框架为普通业务组件织入的处理动作 所以进行AOP编程的关键就是定义切入点和定义增强处理,一旦定义了合适的切入点和增强处理,AOP框架将自动生成AOP代理,即:代理对象的方法=增强处理+被代理对象的方法。

万立超 2019-12-02 01:01:51 0 浏览量 回答数 0

回答

spring boot就是一个大框架里面包含了许许多多的东西,其中spring就是最核心的内容之一,当然就包含spring mvc。 spring mvc 是只是spring 处理web层请求的一个模块。 因此他们的关系大概就是这样: spring mvc < spring spring boot 我理解就是把 spring spring mvc spring data jpa 等等的一些常用的常用的基础框架组合起来,提供默认的配置,然后提供可插拔的设计,就是各种 starter ,来方便开发者使用这一系列的技术,套用官方的一句话, spring 家族发展到今天,已经很庞大了,作为一个开发者,如果想要使用 spring 家族一系列的技术,需要一个一个的搞配置,然后还有个版本兼容性问题,其实挺麻烦的,偶尔也会有小坑出现,其实蛮影响开发进度, spring boot 就是来解决这个问题,提供了一个解决方案吧,可以先不关心如何配置,可以快速的启动开发,进行业务逻辑编写,各种需要的技术,加入 starter 就配置好了,直接使用,可以说追求开箱即用的效果吧. spring 框架有超多的延伸产品例如 boot security jpa etc... 但它的基础就是 spring 的 ioc 和 aop ioc 提供了依赖注入的容器 aop 解决了面向横切面的编程 然后在此两者的基础上实现了其他延伸产品的高级功能 Spring MVC 呢是基于 Servlet 的一个 MVC 框架 主要解决 WEB 开发的问题 因为 Spring 的配置太复杂了 各种 XML JavaConfig hin 麻烦 于是懒人改变世界推出了 Spring boot 约定优于配置 简化了 spring 的配置流程. Spring 最初利用“工厂模式”( DI )和“代理模式”( AOP )解耦应用组件。大家觉得挺好用,于是按照这种模式搞了一个 MVC 框架(一些用 Spring 解耦的组件),用开发 web 应用( SpringMVC )。然后有发现每次开发都要搞很多依赖,写很多样板代码很麻烦,于是搞了一些懒人整合包( starter ),这套就是 Spring Boot 。

huanhuanming 2019-12-02 01:50:29 0 浏览量 回答数 0

回答

轻量级: 弹簧在尺寸和透明度方面很轻。弹簧框架的基本版本约为 1MB。而且处理开销也非常有限。 控制反转(IOC): 依赖项注入或控制反转的基本概念是,程序员不需要创建对象,而只需描述应该如何创建对象。 面向方面(AOP): 弹簧支持面向方面的编程。 面向方面的编程是指将辅助函数或支持函数与主程序的业务逻辑隔离开来的编程范式。AOP 是一种用于分离横切问题的技术,在面向对象的编程中通常很难做到。应用程序的模块化以这种方式增加,其维护变得大大容易。 容器: 弹簧包含和管理应用程序对象的生命周期和配置。 MVC 框架: Spring 附带了 MVC Web 应用程序框架,构建在核心 Spring 功能之上。此框架可通过策略接口高度配置,并适合多种视图技术,如 JSP、Velocity、切片、iText 和 POI。 交易管理: Spring 框架为事务管理提供了一个通用抽象层。这允许开发人员添加可插拔的事务管理器,并便于在不处理低级问题的情况下对事务进行划分。 JDBC 异常处理: Spring 的 JDBC 抽象层提供了一个有意义的异常层次结构,简化了错误处理策略。与希伯纳特、JDO 和 iBATIS 集成:Spring 提供最佳集成服务,包括海伯纳特、JDO 和 iBATIS

YDYK 2020-04-24 21:33:17 0 浏览量 回答数 0
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 企业信息查询 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 2020阿里巴巴研发效能峰会 企业建站模板 云效成长地图 高端建站