在xml中声明bean和注入bean (setter注入,构造器注入)
在xml中声明bean和自动装配bean(byName、byType、constructor、autodetect)
注解注入Bean(@Autowired、@Qualifier、@Resource、@Inject)
自动扫描bean(
对自动扫描bean增加约束条件
首次接触spring请参考 Spring 3.0 学习-环境搭建和三种形式访问 而在本文中,你将看到第四种形式,即测试类自动加载xml配置文件。
0、新的声明
在@Autawired 类似的注解注入出现之前,代码中一直使用的是 setter注入 或者 构造器注入;
假设我们已在在xml文件中声明了两个 Spring bean ,BeanA 和 BeanB
针对需求-BeanB需要引用到BeanA,我们进行以下的讨论:
0.1、setter注入的解决方案:setter 注入的前提是 BeanA 在 BeanB 中作为全局变量进行声明且提供 BeanA变量的setter方法,
public class BeanB ...{
private BeanA beanA;
private String str;
public void setBeanA(BeanA beanA){
this.beanA=beanA;
}
public void setStr(String str){
this.str=str;
}
}
其次是在xml方法中增加 proterty属性,如果是普通变量用value="",如果注入bean 则使用 ref="beanA".
0.2、构造器注入解决方案:构造器注入的前提是BeanB提供两个构造方法,第一个是默认构造方法,第二个是含参数构造方法
且BeanB中需要将BeanA 声明为全局变量,并在构造方法中进行赋值.
public class BeanB ...{
private BeanA beanA;
private String str;
public BeanB(BeanA beanA){
this.str=str;
this.beaA=beanA;
}
}
并在xml 增增加
0.3、自动装配 byName、byType、constructor、autodetect
自动装配是对 setter、构造器 装配的补充,其最直接的表现是可以去除 xml 配置中对属性对注入配置,但是Java代码中的 setter 方法和构造器依旧需要存在,下面说下他们的具体用法和区别
声明位置有两种,可以同时存在
全局xml文件全局声明 default-autowired="byName"
每一个bean 单独声明,这个粒度更细,
byName、byType、constructor、autodetect 的区别
byName 没啥好说的,只要BeanB中声明的BeanA的变量名字和Spring中BeanA 的id一致即可,如果BeanA没有指定id,则就是BeanA的类(首字母小写)
byType 是按照类型注入的,如果BeanB 引用BeanA,但是BeanA 是个接口,且有两个实现类,那么按照类型注入就会报错,这个时候需要将多余的bean 增加
byName 和 byType 可以和xml 的 property 配置一起用,既可以补充,也可以覆盖,以xml为主
constructor 的话要么全部使用xml,要么全部使用自动装配
autodetect 默认是constructor,如果失败则使用byType
0.4、@Autowired 自动注入的作用是完全去除 xml 和 setter、构造方法 的注入
需要在xml文件中增加标签
使用 @Autowired 注入仅仅需要在BeanB 中 声明 BeanA 的全局变量,并且给该变量增加@Autowired注解
更多和@Autowired 类型的注解和特性(https://blog.csdn.net/bestcxx/article/details/79203756#_Autowired__ResourceInject_133)
public class BeanB ...{
@Autowired
private BeanA beanA;
}
但是 将 BeanA 和 BeanB声明为Sping bean的工作依旧是必不可少的,声明
0.4、声明Spring Bean 的简单方式-扫描加注解
context:include-filter 和 annotation-config="true" 不是必须写的,前者用于限制某类注解被注册为Spring Bean,后者这是将默认启动注解注入(@Autowired)显示出来,当然如果你想关闭自动注入
需要被注册为 Spring Bean 的类需要加注解 @Component 、@Controller 等(https://blog.csdn.net/bestcxx/article/details/79203756#ComponentRepositoryServiceControllerNamed_161)
如下
0.5、关于循环注入的问题
第一点:区别循环注入和循环调用
循环调用就是,BeanA的方法A 引用 BeanB的方法B,BeanB的方法B引用BeanA的方法A,这样肯定会栈溢出
循环注入的意思是,BeanA需要注入BeanB,BeanB需要注入BeanA,
第二点:Spring bean 的作用域
singleton 在每一个Spring容器中,一个Bean定义只有一个对象实例(默认)。
prototype 允许Bean的定义可以被实例化任意次(每次调用都创建一个实例)。
request 在一次HTTP请求中,每个Bean定义对应一个实例,该作用域仅在基于Web的Spring上下文(例如Spring MVC)中才有效。
session 在一个HTTPSession中,每个Bean定义对应一个实例。该作用域仅在基于Web的Spring上下文中才有效。
global-session 在一个全局HTTP Session中,每个bean定义对应一个实例。该作用域在portlet才有效。
结论如下:
@Autuwird只支持 单例作用域的相互注入,@Autowired 默认可以避免循环注入,因为Spring 默认就是单例的,@Autowired 增加作用域注解(https://blog.csdn.net/bestcxx/article/details/79203756#Scopeprototype_ScopeConfigurableBeanFactorySCOPE_PROTOTYPE_170)
完全使用 xml 配置注入时,setter注入仅支持 单例作用域的相互注入
完全使用xml配置注入时,构造器注入 不支持相互注入
自动装配模式下,使用 autowire="constructor" 或者 autowire="byName"都支持所有作用域都相互依赖
自动装配模式下,autowire="byType"和完全使用xml 配置注入的setter 注入一致,仅支持 单例作用域的相互注入
bean的本质是某个接口的实现类,或者某个实现了接口的实现类的继承类,比如连接数据库,总之其可以返回具备某个功能的对象。
所有的Spring bean 默认都是单例。即当容器分配一个Bean时,只要是spring容器装配或者调用容器的getBean()方法,它总是返回bean的同一个实例。
作用域 定义
singleton 在每一个Spring容器中,一个Bean定义只有一个对象实例(默认)。
prototype 允许Bean的定义可以被实例化任意次(每次调用都创建一个实例)。
request 在一次HTTP请求中,每个Bean定义对应一个实例,该作用域仅在基于Web的Spring上下文(例如Spring MVC)中才有效。
session 在一个HTTPSession中,每个Bean定义对应一个实例。该作用域仅在基于Web的Spring上下文中才有效。
global-session 在一个全局HTTP Session中,每个bean定义对应一个实例。该作用域在portlet才有效。
四种类型的自动装配
byName 适用于 setter 类型,可以结合 xml 的 property 属性适用
byType 适用于 setter 类型,可以结合 xml 的 property属性使用
Constructor 必须自动装配所有入参,而不能对一部分参数使用
Autodetect 先是选择constructor,如果没有匹配的选择byType
实例的创建和调用是分开的,工厂模式还可以分为简单工厂模式和工厂方法模式。
简单工厂模式是指工厂是实例的,产品由抽象接口和实际产品组成。实际工厂具有返回抽象产品的实际方法,而且是具有多个这样的实际方法,即返回的产品是确定的,但是抽象产品的实现是由多个具体的抽象产品的实现类决定的。
(具体工厂返回抽象产品的实现)+抽象产品的多个实现
工厂方法模式是指,工厂是抽象的工厂加实际继承抽象的实际工厂,抽象工厂有返回抽象产品的抽象方法,实际工厂则实现抽象工厂,实际工厂是多个,抽象产品的实现也是多个,不同的实际工厂返回不同的产品接口的实现。
抽象工厂的多个实现+(抽象工厂返回抽象产品-具体工厂返回抽象产品的实现)+抽象产品的多个实现
自动配置加显示配置可以同时使用,最终以显示配置为准。
application.properties的内容,下面都是以取 “test.age”来进行试验的。
applicationContextSpEL.xml的内容
applicationContextPlaceholder.xml的内容,下面的测试方法要用到
classpath:config/application.properties
classpath:config/jdbc.properties
由于我们借助于spring自身的测试方法,所以在初始阶段使用了@Autowired注入,具体用法下下面提到
package stu.bestcxx.spring.impl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;
import stu.bestcxx.springtest.facade.Performer;
@DirtiesContext
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:spring/applicationContextPlaceholder.xml"})
@TransactionConfiguration(transactionManager = "defaultTransactionManager",defaultRollback=false)
public class PerformInstrumentPlaceholderTest {
/*
* Performer 是接口
* juggerpoem2是spring XML 配置文件中的bean名字
*
*/
@Autowired
private Performer performer;
@Test
public void testperform(){
performer.perform();
}
}
需要注意的是,Spring容器默认禁用注解装配。启动方式是,使用Spring的context命名空间配置中的
@Autowired 相当于byType,所以在存在多个接口实现类时,需要额外使用标注@Qualifier("kuaishu_instrument"),这样联合使用的效果就和使用byName差不多了。
@Autowired与@Resource的区别:点击打开链接
Performer.java内容:
package stu.bestcxx.springtest.facade;
/**
* spring通过调用接口,而接口由不同的实现类来执行具体的实现,
* 通过spring的配置文件或者注解完成"依赖注入"(DI)
*
* @author WuJieJecket
*/
public interface Performer {
public void perform();
}
package stu.bestcxx.springtest.facade;
/**
* 接口类
* 鼓手
* @author WuJieJecket
*/
public interface Instrument {
/*
* 鼓手表演什么?
*/
public void play();
}
InstrumentFengyang.java内容:
package stu.bestcxx.spring.impl;
import stu.bestcxx.springtest.facade.Instrument;
public class InstrumentFengyang implements Instrument{
@Override
public void play() {
// TODO Auto-generated method stub
System.out.println("鼓手表扬了凤阳大鼓:咚咚锵,咚咚锵");
}
}
InstrumentKuaishu.java内容:
package stu.bestcxx.spring.impl;
import stu.bestcxx.springtest.facade.Instrument;
public class InstrumentKuaishu implements Instrument{
@Override
public void play() {
// TODO Auto-generated method stub
System.out.println("选手表扬了山东快书:浪里格朗,浪里格朗");
}
}
applicationContextannotation.xml
application.xml
PerformInstrumentAnnotation.java内容:
package stu.bestcxx.spring.impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import stu.bestcxx.springtest.facade.Instrument;
import stu.bestcxx.springtest.facade.Performer;
public class PerformInstrumentAnnotation implements Performer {
/*
* 使用面向注解的注入,不必提供set、get 方法
*/
@Autowired
@Value("《彩云追月1》")//直接赋值
private String song;
@Autowired
@Value("#{settings['test.age']}")//SpEL的赋值
private int age;
@Autowired(required=false)//默认注入的类不存在则报错,即不允许为null,这里required=false是允许为null的意思
@Qualifier("kuaishu_instrument")//@Autowired 相当于 byType,凤阳鼓和山东快书都实现了乐器接口,所以需要额外使用@Qualifier("kuaishu_instrument")注解 ,就相当于byName了 ,如果只有一个实现乐器的接口则可以去掉@Autowired
private Instrument instrument;
@Override
public void perform() {
// TODO Auto-generated method stub
System.out.println("表演者年龄是 "+age+" 使用乐器表扬的歌曲是 "+song+" 请欣赏 ");
//乐器表扬
instrument.play();
}
}
PerformInstrumentAnnotationTest.java内容:
package stu.bestcxx.spring.impl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;
import stu.bestcxx.springtest.facade.Performer;
@DirtiesContext
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:spring/applicationContextannotation.xml"})
@TransactionConfiguration(transactionManager = "defaultTransactionManager",defaultRollback=false)
public class PerformInstrumentAnnotationTest{
/*
* Performer 是接口
* juggerpoem2是spring XML 配置文件中的bean名字
*/
@Autowired
private Performer performer;
@Test
public void testperform(){
performer.perform();
}
}
这个是需要一个jar包支持的,即javax.inject.jar
import javax.inject.Inject;
下载路径:http://download.csdn.net/detail/bestcxx/9633326
为了统一各种依赖注入框架的编程模型,JCP(Java Community Process)发布了Java依赖注入规范,JCP将其称为JSP-330,更常见的叫法是@inject。从Spring3开始,Spring已经开始兼容该依赖注入模型。
上面的Spring的@Autowired和@Qualifier是搭配的,在Java注入规范中,是@Inject和@Named搭配,即@Autowired可以用@inject代替,@Qualifier可以用@Named代替。
但是注意,@Autowired有一种格式允许注解不存在,@Autowired(required=false),但是@inject是必须存在的。
我们已经实现了这样的过程:构造器注入、set\get注入,然后是自动注入去掉了xml文件中一些bean的引用代码
我们需要使用
如果不加构造型注解,系统不会将其视为bean?在默认情况下是这样的,但是在有其他条件的情况下,可以不加注解也被扫描,具体看17.3。
ScanSingerFacade.java内容:
package stu.bestcxx.springtest.facade;
/**
* 歌手接口
* @author WuJieJecket
*
*/
public interface ScanSingerFacade {
/**
* 表演唱歌
*/
public void sing();
}
有两个java实现类,刚才已经说过,“如果不加构造型注解,系统不会将其视为bean?在默认情况下是这样的,但是在有其他条件的情况下,可以不加注解也被扫描,具体看17.3。”
Singerscan01.java是对比类,放开里面的注释报错证明注解是byType,仅这一个实现类也报错证明默认情况下,没有注解没有实现类被识别,内容:
package stu.bestcxx.springtest.scanimpl;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import stu.bestcxx.springtest.facade.ScanSingerFacade;
/*
* 不加 构造器注解,scan默认不会扫描
* 如果增加,注解相当于byType,具有多个实现类被注解会报错
* @Component @Component("demoname") demoname是自定义的
*/
//@Component//可以将这个注解放开和注释分别运行测试类 Singerscan0Test.java
public class Singerscan01 implements ScanSingerFacade {
@Value("#{settings['test.song']}")
private String song;
@Override
public void sing() {
// TODO Auto-generated method stub
System.out.println("singer1 表演:"+song);
}
}
Singerscanannotation.java内容:
package stu.bestcxx.springtest.scanimpl;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import stu.bestcxx.springtest.facade.ScanSingerFacade;
//@Compoent 自动扫描注册为通用bean,如果需要制定名字就加括号,否则默认bean名字为 无限定类名-singer1
@Component("singer1")
public class Singerscanannotation implements ScanSingerFacade {
@Value("#{settings['test.song']}")
private String song;
@Override
public void sing() {
// TODO Auto-generated method stub
System.out.println("singer1 表演:"+song);
}
}
这种模式下,需要被识别为bean的必须加注解标识,不加注解的方法参考17.3
applicationContextscan.xml内容:
Singerscan0Test.java内容
package stu.bestcxx.springtest.scanimpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;
import stu.bestcxx.springtest.facade.ScanSingerFacade;
@DirtiesContext
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:spring/applicationContextscan.xml"})
@TransactionConfiguration(transactionManager="defaultTransactionManager",defaultRollback=false)
public class Singerscan0Test {
@Autowired
private ScanSingerFacade ssfade;
@Test
public void testsing(){
ssfade.sing();
}
}
在使用scan功能时,默认情况下所有的构造型注解标注(@Component,@Service,@Repository,@Controller)的实现类都会被注册为bean
但是在具有限定功能的情况下,可以减小Spring扫描的粒度,提升效率。
下面的规则都可以分为正向的和反向的,即该类型的需要扫描以及该类型的不需要扫描。
正向的写在
反向的写在
如果应用扫描的话,默认是需要加注解的,但是在非annotation限定模式下则可以不加注解也可以自动识别,具体看下面的例子。
17.3.2.1 type=annotation,必须由注解,过滤器扫描使用指定注解所标注的那些类。具体来说,就是@Component,@Service,@Repository,@Controller这几个构造型注解所在的类。
expression=有4个值,这种限定方式是必须有@Component等注解的。
org.springframework.stereotype.Component;
org.springframework.stereotype.Controller;
org.springframework.stereotype.Repository;
org.springframework.stereotype.Service;
举例:
17.3.2.2 type=assignable,注解不是必要的,过滤器扫描派生于expression属性所指定类型的那些类,所谓的派生,具体的实现类的路径。
expression=接口类路径
举例:
接口类:
ScanSinger2Facade.java代码:
package stu.bestcxx.springtest.facade;
/**
* 歌手接口
* @author WuJieJecket
*
*/
public interface ScanSinger2Facade {
/**
* 表演唱歌
*/
public void sing();
}
实现类:
Singerscanassignable.java内容:
package stu.bestcxx.springtest.scanimpl;
import org.springframework.beans.factory.annotation.Value;
import stu.bestcxx.springtest.facade.ScanSinger2Facade;
//在scan-assignable 模式下,可以去掉结构型注解
public class Singerscanassignable implements ScanSinger2Facade {
@Value("#{settings['test.song']}")
private String song;
@Override
public void sing() {
// TODO Auto-generated method stub
System.out.println("singer1 表演:"+song);
}
}
配置文件applicationContextscanassignable.xml
内容:
测试类SingerscanassignableTest.java
内容:
package stu.bestcxx.springtest.scanimpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;
import stu.bestcxx.springtest.facade.ScanSingerFacade;
@DirtiesContext
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:spring/applicationContextscanassignable.xml"})
@TransactionConfiguration(transactionManager="defaultTransactionManager",defaultRollback=false)
public class SingerscanassignableTest {
@Autowired
private ScanSingerFacade ssfade;
@Test
public void testsing(){
ssfade.sing();
}
}
17.3.2.3 type=aspectj,过滤器扫描与expression属性所指定的AspectJ表达式所匹配的那些类。
expression=暂无
17.3.2.4 type=custom,使用自定义的org.springframework.core.type.TypeFilter实现类,该类由expression属性指定。
expression=暂无
17.3.2.5 type=regex,过滤器扫描类的名称与expression属性所指定的正则表达式所匹配的那些类。
expression=暂无
依旧需要极少的xml配置,只是注解的名字变了
Java代码中,类名上增加注解@Configuration,告知spring该类中包含一个或多个Spring Bean的定义,需要注册为bean的方法上增加注解@Bean,如下
@Configuration
Public class SpringIdolConfig{
@Bean
public Performer duck(){
return new anotherBeanName(BeanName);
}
}
如果需要在junit控制回滚的话,需要测试类继承 AbstractTransactionalJUnit4SpringContextTests
public class TClassServiceTest extends AbstractTransactionalJUnit4SpringContextTests{
不要构建成bean1引用bean2,然后bean2直接引用bean1或者间接引用bean1的情况,Spring 会报错,会造成bean的调用形成死循环
如果使用构造器注入,Requested bean is currently in creation: Is there an unresolvable circular reference?
如果使用set方法注入,java.lang.StackOverflowError
只有一种情况可以避免这种问题,就是使用Spring 的单例作用域,循环注入不同于循环调用方法
循环调用对方方法-报错
@Component
public class AInterfaceImpl implements AInterface {
@Autowired
private BInterface bInterface;
@Override
public void testA() {
System.out.println("a");
bInterface.testB();
}
}
@Component
public class BInterfaceImpl implements BInterface {
@Autowired
private AInterface aInterface;
@Override
public void testB() {
System.out.println("B");
aInterface.testA();
}
}
测试内容和报错信息:
@Autowired
private AInterface aInterface;
@Test
public void test() {
aInterface.testA();
}
但是这是代码逻辑问题,a引用b,b引用a
单独声明是没问题的,即 A中声明B,B中声明A,A中声明自己都没有问题.
自己注入自己-可以
@Component
public class AInterfaceImpl implements AInterface {
@Autowired
private AInterface aInterface;
@Override
public void testA() {
System.out.println("a");
//bInterface.testB();
}
}
接口Top ,类A实现接口 Top, 类A 和 其子类 B 可以同时被注册为Spring bean
事实上,类A 不实现接口Top也可以
# 接口类
public interface InterfaceTop {
void methodTop();
}
# 类A 实现接口Top
import org.springframework.stereotype.Component;
@Component("aaa")
public class ClassA implements InterfaceTop{
public void test1() {
System.out.println("ClassA.test1()");
}
@Override
public void methodTop() {
System.out.println("ClassA.methodTop");
}
}
# 类B 集成 类A
import org.springframework.stereotype.Component;
@Component("bbb")
public class ClassB extends ClassA {
public void test2() {
System.out.println("CLassB.test2()");
}
}
# 测试方法
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestDel {
public static void main(String[] args) {
ApplicationContext application=new ClassPathXmlApplicationContext("classpath:application-del.xml");
InterfaceTop classB=application.getBean("bbb", ClassB.class);
classB.methodTop();
InterfaceTop classA=application.getBean("aaa",ClassA.class);
classA.methodTop();
}
}
# 输出结果
ClassA.methodTop
ClassA.methodTop