Spring 是为了简化企业级开发而创建的,在 Spring 框架全家桶中绝对是不可或缺技术。
为了降低Java开发的复杂性,Spring 采用了以下四种关键策略:
Spring 所做的事情都是围绕这几点展开。
依赖注入 依赖注入( Dependency Injection , DI ) 听起来让人生畏,实际上并没有听上去那么复杂。
IoC (Inversion of Control,缩写为IoC)也称为依赖注入 ( Dependency Injection , DI )。是指“一个对象被创建时,先定义其构造方法的参数或者工厂方法的参数(即其使用的对象),然后容器在创建 bean 时注入这些依赖项的过程”。
对比区别:
面向切面编程 ( AOP )
AOP ( Aspect Oriented Programming ) ,面向切面编程。其中的 Aspect 指 切面,中文的意思可理解为“维度”。
AOP是“关注点分离”的一项技术,软件系统往往由多个组件/模块组成,每个组件各负责一块特定的功能。这些组件往往还承担额外的职责,比如日志,事务,安全控制等系统服务逻辑,和业务功能混合在一起。这些系统服务逻辑会在多个组件/模块中存在,被称为“横切关注点”。
这些模块中调用的系统服务逻辑分散到多个组件/模块中去,导致你需要维护多个组件的代码,带来复杂性。即使把这些关注点抽离成一个独立的模块,但方法的调用还是出现在各个模块中。
而AOP可以使得这些关注点切面模块化,以声明的方式应用到具体业务组件/模块中去,使得这些业务模块更加内聚和更加关注自身的业务。
AOP
使用模块消除 “ 样板代码 ” 样板代码是指重复的代码,比如 传统JDBC 中要开启数据库连接,构造预处理语句等,每次都要写很多。借助使用 模板 Template 封装可以帮助消除样板代码,简化复杂性,模板 使得你的代码更关注与自身的业务职责。
Spring 容器,依赖注入( Dependency Injection , DI ),和面向切面编程( Aspect-Orientd Programming, AOP ) 是 Spring 框架的核心。下面分别介绍。
org.springframework.context.ApplicationContext 接口代表 Spring IoC 容器,负责实例化、配置和组装 bean。
ApplicationContext 基于 BeanFactory 构建,BeanFactory 提供了配置框架和基本功能, 而 ApplicationContext 添加了更多企业特定的功能。我们更多使用的是 ApplicationContext 。
Spring 提供了几种 ApplicationContext 实现
示例:
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");
有了容器,容器负责创建和管理Bean,还要进一步了解下 Bean 的生命周期:
Bean 声明周期
依赖类库 以 Maven 方式时,添加 spring-context 依赖。
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.4</version>
</dependency>
</dependencies>
Spring 支持多种方式加载配置
XML 使用 ClassPathXmlApplicationContext 或者 FileSystemXmlApplicationContext 从一个 XML 文件中初始化容器对象。
示例: xml 文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="hero" class="cn.zyfvir.demo.Hero">
<constructor-arg ref="swordAction"/>
</bean>
<bean id="swordAction" class="cn.zyfvir.demo.SwordAction">
<constructor-arg name="printStream" value="#{T(System).out}"/>
</bean>
</beans>
// 使用 xml 方式 配置 spring
private static void demoXmlSpring() {
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
Hero bean = context.getBean(Hero.class);
bean.play();
}
AnnotationConfigApplicationContext 上下文支持从注解和Java代码方式配置对象。
示例:
@Configuration
public class HeroConfig {
@Bean
public Hero hero() {
return new Hero(action());
}
@Bean
public Action action() {
return new SwordAction(System.out);
}
}
// 使用java 方式
private static void demoJavaSpring() {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
// 启用组件扫描,扫描查找任何带 @Component ,@Configuration 注解的类
context.scan("cn.zyfvir.demo");
context.refresh();
Hero bean = context.getBean(Hero.class);
bean.play();
}
我的 demo 示例代码见:https://github.com/vir56k/java_demo/tree/master/spring_demo1
装配( Wiring ): 在 Spring 中,对象无需自己查找和创建与其关联的其他对象。由 容器 负责把需要协作的各个对象赋予对象。创建对象之间协作关系的行为成为 装配( Wiring )。这也是依赖注入 DI 的本质
Spring 提供了三种 Bean 的装配方式:
怎么选择呢?一些建议是:
如果 Spring 能自己装配的话,何必再用 XML 等方式具体声明呢?自动装配能带来很多的便利。
Spring 从两个角度实现自动装配:
@Component 注解可以作用于一个 类上,用于声明一个bean对象。 @ComponentScan 注解用于启用组件扫描。默认会扫描与其处于相同包下的类。它也可以通过 basePackages属性指定具体包。 @Autowired 注解声明了自动装配,Spring 会选择匹配合适的Bean来装配。它可以作用在构造方法和set方法上。
@Configuration 声明了这个类是个配置类,它不是必须的。 通过 @Bean 注解声明这个方法返回一个对象,这个对象要注册到 Spring 的上下文中。
比如:
@Configuration
public class AppConfig {
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}
通过<bean> 标签描述。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="..." class="..."> </bean>
<bean id="myService" class="com.acme.services.MyServiceImpl"/>
</beans>
使用 @Import , 或者 @ImportResource 等注解。 详细参考:https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-introduction
下面编写一个自动装配的示例:
/**
* @description: 光盘
* @author: zhangyunfei
* @date: 2021/7/3 22:22
*/
public interface CompactDisc {
void play();
}
/**
* @description: VCD 光盘
* @author: zhangyunfei
* @date: 2021/7/3 22:25
*/
@Component
public class VcdCompactDisc implements CompactDisc {
private String title = "经典歌曲-忘情水";
public void play() {
System.out.println(String.format(" %s 正在播放...", title));
}
}
在使用时,关键在于 Autowired 的注解,它会自动寻找到合适的对象注入到这里。
/**
* @description: 播放器
* @author: zhangyunfei
* @date: 2021/7/3 22:16
*/
@Component
public class Player {
private CompactDisc compactDisc;
// 自动装配
@Autowired
void insertCompactDisc(CompactDisc action) {
this.compactDisc = action;
}
/**
* 开始播放
*/
void startPlay() {
compactDisc.play();
}
}
还要配置“ 自动扫描要装配的组件 ”, ComponentScan 用于声明搜索当前的包,我这里是个空的类。
@Configuration
@ComponentScan
public class PlayerConfig {
}
main 方法演示如何调用:
public class MainClass {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(PlayerConfig.class);
Player bean = context.getBean(Player.class);
bean.startPlay();
}
}
我的代码示例见:https://github.com/vir56k/java_demo/tree/master/spring_demo2_autowired
AOP ( Aspect Oriented Programming, AOP ) 面向切面编程,是指在编译时期方式或者运行时期动态代理的方式,将代码织入到指定位置(具体的类的方法)上的一种编程思想,就是面向切面的编程。
为什么要用AOP 具体要看场景和时机,比如下图:
AOP
类似于 日志,事务这样的功能要想模块化的话面临一些选择,比如对象继承和委托。继承的话整个 应用中都有同样的基类,往往导致一个脆弱的对象体系,而委托可能需要对委托对象进行复杂的调用。
在各个业务模块挨个写调用也太麻烦了,不利于维护。而 切面是一个可供选择方案,使用AOP可以以声明的方式的方式在外部应用,而不用修改(影响)到具体的业务功能模块。这也是 “关注点分离”的体现,每个关注点都集中于一个地方,而不是分散到各处的代码。
多种AOP实现 AOP 是一种编程范式,可以有多种方式实现:
代理方式分为静态代理和动态代理,静态代理可理解为自己写的代理或者字节码方式的代理。动态代理是在运行时生成一个代理类(实现类)再由其去访问目标对象的方式。
Spring AOP
Spring AOP 是通过 动态代理
的方式实现的AOP
AspectJ 是编译成class时织入的,拥有更强大的能力。
类加载期是在目标类加载到JVM时织入,需要特殊的类加载器,比如 AspectJ 5 的load-time weaving,LTW 就支持这种方式。
AOP 术语:
Spring AOP 通知的类型:
代码示例 (1) 引用类库
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.3.4</version>
</dependency>
(2) 声明 启用 Aspect 的自动代理配置
// 启用:组件搜索
// 启用:aspect 的自动代理
@Component
@ComponentScan
@EnableAspectJAutoProxy
public class MySrpingConfig {
}
编写AOP通知的切入点
// 博客服务
interface BlogService {
public void postBlog(String blogContet);
}
@Component
class BlogServiceImpl implements BlogService {
public void postBlog(String blogContet) {
System.out.println("发布了一遍博客");
}
}
// 日志记录员
// 把自己也注册成 Spring 组件
@Aspect
@Component
class LogAspect {
// 切点表达式
@Pointcut("execution(* cn.zyfvir.demo.BlogService.postBlog(..))")
public void doPostPoint() {
}
@Before("doPostPoint()")
public void before() {
System.out.println("## before...");
}
@After("doPostPoint()")
public void after() {
System.out.println("## after...");
}
@AfterReturning("doPostPoint()")
public void afterReturning() {
System.out.println("## AfterReturning...");
}
@AfterThrowing("doPostPoint()")
public void afterThrowing() {
System.out.println("## AfterThrowing...");
}
}
通过AOP,达到了对实际的业务调用无影响,正常使用即可,示例:
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MySrpingConfig.class);
BlogService bean = context.getBean(BlogService.class);
bean.postBlog("《从入门到精通》");
System.out.println("执行结束," + bean);
}
而在执行过程中,日志记录类会被触发和工作。 我的代码示例见:https://github.com/vir56k/java_demo/tree/master/spring_demo5_aop
在实际开发中经常会有多个环境,比如 dev 开发环境,test 测试环境,product 正式环境。Spring 对环境做了一层抽象,允许你定义多个环境,和激活使用的某个环境。
关键点是:
使用 @Profile 可以声明某个bean只在某个环境下可用(被激活)。比如下面的示例,它使用 @Profile 的注解来声明了 这个类 只有在 development 环境下才可用。
@Configuration
@Profile("development")
public class StandaloneDataConfig {
@Bean
public DataSource dataSource() {
return new EmbeddedDatabaseBuilder()
.setType(EmbeddedDatabaseType.HSQL)
.addScript("classpath:com/bank/config/sql/schema.sql")
.addScript("classpath:com/bank/config/sql/test-data.sql")
.build();
}
}
激活 配置的环境,可以使用代码的方式,比如:
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.getEnvironment().setActiveProfiles("development");
ctx.register(SomeConfig.class, StandaloneDataConfig.class, JndiDataConfig.class);
ctx.refresh();
也可以在 以java 命令行启动时指定: 使用 环境变量 “ spring.profiles.active ” 来声明激活的环境,如以下示例所示:
-Dspring.profiles.active="profile1,profile2"
实际上面说的 @Profile 也是通过 @Conditional 注解来实现的。 @Conditional 注解可用于指示在特定情况下才 注册某个 Bean。
示例:
@Configuration
public class PersonConfig {
@Bean()
@Conditional({ConditionalDemo1.class})
public Person person1(){
return new Person("Bill Gates",62);
}
}
上面的示例使用了 @Conditional 注解,它指定了参数ConditionalDemo1.class 。@Conditional 的参数实际是这么一个接口,你可以根据你的需要来实现:
public interface Condition {
boolean matches(ConditionContext var1, AnnotatedTypeMetadata var2);
}
比如,@Profile 注解实际是这么实现的:
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
// Read the @Profile annotation attributes
MultiValueMap<String, Object> attrs = metadata.getAllAnnotationAttributes(Profile.class.getName());
if (attrs != null) {
for (Object value : attrs.get("value")) {
if (context.getEnvironment().acceptsProfiles(((String[]) value))) {
return true;
}
}
return false;
}
return true;
}
在自动装配时,如果有多个可被选中的对象无法被确定时,就出现异常了。 比如遇到下面的情形:
// 甜点
interface Dessert {
String getName();
}
@Component
class IceCream implements Dessert{
private String name = "冰淇淋";
public String getName() {
return name;
}
}
@Component
class Chocolate implements Dessert{
private String name = "巧克力";
public String getName() {
return name;
}
}
@Component
class Lollipop implements Dessert{
private String name = "棒棒糖";
public String getName() {
return name;
}
}
上面的示例实现了多个 甜点 类,小朋友不知吃哪个了。
@Component
public class Child {
Dessert dessert;
// 想要
@Autowired
public void wantDessert(Dessert dessert) {
this.dessert = dessert;
}
public void eating() {
System.out.println(String.format("正在吃 %s ...", dessert.getName()));
}
}
这时,可以选择处理歧义的方式:
示例:
// 想要
@Autowired
@Qualifier("lollipop") // @Qualifier 声明了一个 优先选择的 限定名。
public void wantDessert(Dessert dessert) {
this.dessert = dessert;
}
我的代码示例见:https://github.com/vir56k/java_demo/tree/master/spring_demo3
默认情况下,Spring 创建的实例 是都单例的,即 singleton。
Sping 支持多种 作用域(Scope),包括:
Scope | 描述 |
---|---|
singleton | 单个实例 |
prototype | 每次都创建一个新的实例 |
request | Web应用的一次请求期间 |
session | Web应用的会话期间 |
application | Web应用期间 |
websocket | websocket 范围 |
使用 @Scope 注解可以为一个 Bean 指定 Scope,示例:
@Scope("prototype")
@Component
class IceCream implements Dessert{
...
}
运行时装配的场景,比如动态获取 配置文件中的内容,或者 某个方法的执行结果,或者一个随机数,或者某个 表达式结果。
@Configuration
@PropertySource("classpath:myproperty_config.properties")
public class MyPropertyConfig {
// 读取 配置文件中的 author.name
@Value("${author.name}")
public String authorName;
}
SpEL 是指 Spring 表达式语言( Spring Expression Language , SpEL ),它能够以简洁和强大的方式将值装配到Bean的属性中,使用表达式会在运行时计算得到值。
SpEL 特性:
SpEL 的格式: #{ .. } 它以 # 开头。
示例:
设置默认值
@Value("#{ systemProperties['user.region'] }")
private String defaultLocale;
@Configuration
@PropertySource("classpath:myproperty_config.properties")
public class MyPropertyConfig {
// 读取 配置文件中的 author.name
@Value("${author.name}")
public String authorName;
@Value("#{3.1415}")
public String pi;
@Value("#{'xxxxx'}")
public String string1;
@Value("#{myPropertyConfig.getMyName().toUpperCase()}")
public String myName;
@Value("#{T(java.lang.Math).PI}")
public String PI;
@Value("#{T(java.lang.Math).random()}")
public String random;
@Value("#{ myPropertyConfig.pi == 3.14 }")
public boolean is3_14;
@Value("#{ myPropertyConfig.pi ?:'333' }")
public String stirng2;
public String getMyName() {
return "zhang3";
}
@Value("#{ myPropertyConfig.getArray() }")
public String[] array;
@Value("#{ myPropertyConfig.array[1] }")
public String array1;
public String[] getArray() {
String[] arr = new String[3];
arr[0] = "#1";
arr[1] = "#2";
arr[2] = "#3";
return arr;
}
}
https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans
https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Artifacts