基于Spring4的Bean的装配和依赖注入
由于准备着手研究一下Spring Boot 和Spring Cloud,所以抽空把Spring对Bean的装配和Spring容器的依赖注入重新整理了一下，理解了一下内在本质！
今天主要整理的是基于注解的方式对Bean的管理,下面是具体的Demo！
Maven依赖:
org.springframework
spring-context
4.3.9.RELEASE
javax.inject
javax.inject
1
Demo01：
//通过加入组建
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class, User.class, UserDao.class,UserService.class,UserController.class);
//通过扫描包
//AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext("com.harry.**");
注: 首先获取Spring容器applicationContext,这里通过添加配置类组建的方式或者扫描包的方式来让Spring对Bean进行装配,接着通过容器才对Bean进行一系列操作。
MyConfig.Java
package com.harry.spring4.demo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Scope;
/**
* Bean的配置类，类似于applicationContext.xml里配置的各种Bean
*
* @author Harry Wan
*
*/
@Configuration
public class MyConfig {
/**
* 表示配置了一个Bean,name默认为方法名 "createMyBean"
*
* @return
*/
@Bean
@Scope(scopeName = "prototype")
public MyBean createMyBean() {
return new MyBean();
}
/**
* 自定义Bean的name，从容器中获取时按定义的名称获取
*
* @return
*/
@Bean(name = "myBean")
@Scope(scopeName = "prototype")
public MyBean createMyBeanWithRename() {
return new MyBean();
}
@Bean
public MyFactoryBean createMyFactoryBean() {
return new MyFactoryBean();
}
@Bean
public MyCustomFactory createMyCustomFactory() {
return new MyCustomFactory();
}
@Bean
public MyBean createMyBeanByCustomFactory(MyCustomFactory factory) {
return factory.createMyBean();
}
@Bean
public MyBean2 createMyBean2ByCustomFactory(MyCustomFactory factory) {
return factory.createMyBean2();
}
@Bean
public MyBean3 createMyBean3() {
return new MyBean3();
}
@Bean(initMethod = "init", destroyMethod = "destroy")
public MyBean4 createMyBean4() {
return new MyBean4();
}
@Bean
public MyBean5 createMyBean5() {
return new MyBean5();
}
@Bean
//@Primary
public UserDao createUserDao(){
return new UserDao();
}
}
注: 这里通过@Configuration注解表示当前为配置类，类似于项目中的applicationContext.xml，同时通过@Bean来标识自定义实例化的Bean
实例化Bean的四种方式:
第一种:
/**第一种方式: 通过自定义创建实例化Bean，交给Spring来管理**/
//从容器中通过类型来获取.
//注: 若容器中有多个实例化Bean的方法，此时通过类型来获取，会Bean匹配错误
//System.out.println(applicationContext.getBean(MyBean.class));
//从容器中通过名称来获取
System.out.println(applicationContext.getBean("createMyBean"));
System.out.println(applicationContext.getBean("myBean"));配置:
/**
* 表示配置了一个Bean,name默认为方法名 "createMyBean"
*
* @return
*/
@Bean
@Scope(scopeName = "prototype")
public MyBean createMyBean() {
return new MyBean();
}
/**
* 自定义Bean的name，从容器中获取时按定义的名称获取
*
* @return
*/
@Bean(name = "myBean")
@Scope(scopeName = "prototype")
public MyBean createMyBeanWithRename() {
return new MyBean();
}
注:在配置类中自定义实例化Bean方法，并且使用@Bean注解标识，交给Spring管理，最后通过容器获取Bean实例.在通过类型获取时，如果在容器中有多个实例化Bean的方法，Spring会报匹配错误，在通过名称获取时，如果不自定义@Bean(name = "myBean"),默认的名称为实例化Bean的方法名applicationContext.getBean("createMyBean")
第二种:
/** 第二种方式: 通过BeanFactory来创建实例化Bean**/
//通过类型获取FactoryBean创建的Bean的实例对象
//System.out.println(applicationContext.getBean(MyBean2.class));
//通过名字来获取FactoryBean创建的Bean的实例对象
System.out.println(applicationContext.getBean("createMyFactoryBean"));
//通过类型获取到的是MyFactoryBean本身,并非MyFactoryBean创建出来的Bean
System.out.println(applicationContext.getBean(MyFactoryBean.class));
//通过名称获取到的是MyFactoryBean本身,并非MyFactoryBean创建出来的Bean
System.out.println(applicationContext.getBean("&createMyFactoryBean"));MyFactoryBean.java
package com.harry.spring4.demo;
import org.springframework.beans.factory.FactoryBean;
/**
* 通过FactoryBean 来创建对象
* @author Harry Wan
*
*/
public class MyFactoryBean implements FactoryBean {
//获取到FactoryBean所创建的实力对象
public MyBean2 getObject() throws Exception {
return new MyBean2();
}
//获取Bean的类型
public Class getObjectType() {
return MyBean2.class;
}
public boolean isSingleton() {
return true;
}
}
注:这里通过实现FactoryBean接口传入需要实例化的Bean类型，实现对应的方法,再将我们自定义的MyFactoryBean添加到配置类中，最终来获取我们需要实例化的Bean对象。
由于FactoryBean也可以抽象成Bean的一种，所以在获取时要区分我们需要的目标Bean对象和FactoryBean对象
第三种:
/** 第三种方式: 通过自定义Factory来创建Bean实例,把自定义的Factory也当作Bean交给Spring来管理 **/
//可以通过类型来获取MyBean.class,为了避免通过类型匹配到多个实例化Bean的方法，改为通过Name来获取
System.out.println(applicationContext.getBean("createMyBeanByCustomFactory"));
System.out.println(applicationContext.getBean("createMyBean2ByCustomFactory"));自定义实例化Bean的工厂类MyCustomFactory.java:
package com.harry.spring4.demo;
public class MyCustomFactory {
public MyBean createMyBean() {
return new MyBean();
}
public MyBean2 createMyBean2() {
return new MyBean2();
}
}
配置类MyConfig.java:
@Bean
public MyCustomFactory createMyCustomFactory() {
return new MyCustomFactory();
}
@Bean
public MyBean createMyBeanByCustomFactory(MyCustomFactory factory) {
return factory.createMyBean();
}
@Bean
public MyBean2 createMyBean2ByCustomFactory(MyCustomFactory factory) {
return factory.createMyBean2();
}注: 这里将自定义Bean的工厂类加入到Spring容器中进行管理,在实例化目标Bean时,对于需要的工厂类参数，Spring会自动去匹配当前容器中已经装配好的对应工厂对象进行传入
第四种:
/**第四种方式: 通过使用@Component组件相关注解，交给Spring容器装配**/
//注: 实际开发中通常使用scan扫描包自动加入Spring容器(new AnnotationConfigApplicationContext("com.harry.**");),如若其他方式要手动加入到Spring容器中
System.out.println(applicationContext.getBeansOfType(User.class));//获取Spring容器管理Bean时该Bean使用的默认名称(Map: 名称 = 实例化对象)
//@Component
System.out.println(applicationContext.getBean(User.class));
System.out.println(applicationContext.getBean("myUser"));
//@Repository
System.out.println(applicationContext.getBean(UserDao.class));
//@Service
System.out.println(applicationContext.getBean(UserService.class));
//@Controller
System.out.println(applicationContext.getBean(UserController.class));
//---------------------------------------------------------这是一道华丽的分界线------------------------------------------------------
实现Bean在被Spring容器加载之后和被销毁之后自定义添加业务逻辑的三种方式
第一种:
/**第一种方式: 目标Bean实现InitializingBean, DisposableBean接口，实现对应的afterPropertiesSet()和destroy()方法**/
System.out.println(applicationContext.getBean("createMyBean3"));package com.harry.spring4.demo;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
public class MyBean3 implements InitializingBean, DisposableBean {
/**
* 当Bean被Spring加载之后会执行
*/
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("==It will be executed after being Loaded==");
}
/**
* 当Bean销毁之后会执行
*/
@Override
public void destroy() throws Exception {
System.out.println("==It will be executed after being Destroyed==");
}
}
注：目标Bean通过实现InitializingBean, DisposableBean接口，实现对应的afterPropertiesSet()和destroy()方法
第二种
/**第二种方式: 在注解@Bean是指定(initMethod = "init", destroyMethod = "destroy")**/
System.out.println(applicationContext.getBean("createMyBean4"));@Bean(initMethod = "init", destroyMethod = "destroy")
public MyBean4 createMyBean4() {
return new MyBean4();
}目标Bean：
package com.harry.spring4.demo;
public class MyBean4 {
/**
* 当Bean被Spring加载之后会执行
*/
public void init() {
System.out.println("==It will be executed after being Loaded==");
}
/**
* 当Bean销毁之后会执行
*/
public void destroy(){
System.out.println("==It will be executed after being Destroyed==");
}
}
注：这里通过在配置类注解@Bean中标注initMethod , destroyMethod方法来实现，这也是实际开发中最常用的方式，基于Spring提供的@Bean注解的配置
第三种
/**第三种方式: 通过Javax(JSR-250)注解@PostConstruct和@PreDestroy方式**/
System.out.println(applicationContext.getBean("createMyBean5"));package com.harry.spring4.demo;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
public class MyBean5 {
/**
* 当Bean被Spring加载之后会执行
*/
@PostConstruct
public void init() {
System.out.println("==It will be executed after being Loaded==");
}
/**
* 当Bean销毁之后会执行
*/
@PreDestroy
public void destroy(){
System.out.println("==It will be executed after being Destroyed==");
}
}
注：通过使用Javax注解@PostConstruct和@PreDestroy实现
//---------------------------------------这是一道华丽的分界线----------------------------------------------------
注入容器的三种方式
package com.harry.spring4.demo;
import javax.annotation.Resource;
import javax.inject.Inject;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.stereotype.Repository;
/**
* Spring 依赖注入
* @author Harry Wan
*
*/
public class MyDemo2 {
public static void main(String[] args) {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext("com.harry.**");
//使用@Repository注解装配
System.out.println(applicationContext.getBean("userDao"));
//使用@Bean 自定义实例化对象装配
System.out.println(applicationContext.getBean("createUserDao"));
/**注入的三种方式**/
//@Autowired 依赖 UserDao ---Spring提供的注入方式,可以指定具体装配哪一个
//@Resource 依赖User ----JSR-250提供的注入方式(JDK自带)
//@Inject 依赖MyBean ----JSR-330提供的注入方式(需要添加依赖)
UserService userService = applicationContext.getBean(UserService.class);
//在有多个实例化Bean的情况下,默认情况下，Spring优先会注入@Repository注解的组建Bean,
//可以在@Autowired下使用@Qualifier(value = "createUserDao")或者在@Bean下使用@Primary来指定装配哪一个
System.out.println(userService);
applicationContext.close();
}
}
package com.harry.spring4.demo;
import javax.annotation.Resource;
import javax.inject.Inject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
public class UserService {
@Autowired
@Qualifier(value="createUserDao")
private UserDao userDao;
//JSR-250提供的注入方式(JDK自带)
@Resource
private User user;
//JSR-330提供的注入方式(需要添加依赖)
@Inject
private MyBean myBean;
@Override
public String toString() {
return "UserService [userDao=" + userDao + ", user=" + user + ", myBean=" + myBean + "]";
}
}
@Bean
//@Primary
public UserDao createUserDao(){
return new UserDao();
}
注：第一种方式: 最常用的方法，使用Spring提供的@Autowired注解,当容器中有多个依赖注入的Bean对象时，可以使用
@Qualifier(value = "createUserDao")或者在@Bean下使用@Primary来指定装配哪一个
第二种方式:使用JSR-250提供的注入方式(JDK自带),基于注解@Resource依赖注入
第三种方式:使用JSR-330提供的注入方式(需要添加依赖), 基于注解@Inject实现依赖注入
//-------------------------------这是一道华丽的分界线----------------------------------------------------
基于注解设置在Spring扫描包时自动忽略相应Bean的装配:
package com.harry.spring4.demo;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.FilterType;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.stereotype.Service;
public class MyDemo3 {
public static void main(String[] args) {
/**
* 把扫描包的注解配置信息添加在AnnotationScanConfig中，通过Spring容器读取配置文件的方式加载扫描配置
* @ComponentScan(basePackages="com.harry.**",excludeFilters=@Filter(type=FilterType.ASSIGNABLE_TYPE,classes={UserService.class,MyConfig.class}))
* 排除用@Service注解的UserService和在MyConfig中自定义配置的Bean的扫描
*
* 如若使用@Component注解注释的Bean,可直接排除
* 如若使用Config配置文件自定义实例化Bean的方式，不能直接排除Bean的本身，要填写Config配置类，从而来排除配置文件中配置的Bean
*
*/
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AnnotationScanConfig.class);
System.out.println(applicationContext.getBean(User.class));
System.out.println(applicationContext.getBean(UserService.class));
System.out.println(applicationContext.getBean(MyBean.class));
applicationContext.close();
}
}
扫描配置AnnotationScanConfig.java
package com.harry.spring4.demo;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
@Configuration
@ComponentScan(basePackages="com.harry.**",excludeFilters=@Filter(type=FilterType.ASSIGNABLE_TYPE,classes={UserService.class,MyConfig.class}))
public class AnnotationScanConfig {
}
注: 使用@Configuration表示当前为以配置类加入到Spring容器中, @ComponentScan表示Spring扫描的配置信息,通过指定excludeFilters来过滤相应Bean的装配，FilterType.ASSIGNABLE_TYPE表示我们传入指定的要忽略的目标Bean的类型或者Bean所在的配置类。
如果Bean使用的是@Component等注解标识,可以直接在Filter中指定该Bean的类型，从而忽略装配
如果Bean使用的是配置类的方式，在配置类中使用@Bean的注解自定义实例化Bean，我们需要将配置类加到Filter中，从而对该Bean进行忽略，若加Bean本身，而非其Bean所在的配置类,则达不到忽略的效果
最后，由于Bean都是默认以单例的形式装配在Spring容器中,我们可以通过@Scope(scopeName = "prototype")来标识，表示每次从容器中获取该Bean是都是重新实例化一个新的对象。
Demo运行示例：
