Spring揭秘：IOC与AOP学习笔记

来源：互联网发布：淘宝哪个店铺能套现编辑：程序博客网时间：2024/05/17 09:41

Book2： Spring揭秘(245/673)

########################################################################################

######## 20161207～20161208 ##############################

########################################################################################

1、我搭建的第一个Spring测试环境。导入了以下6个jar包，参考：http://www.importnew.com/13246.html

org.springframework.aop-3.2.9
org.springframework.aspects-3.2.9
org.springframework.beans-3.2.9
org.springframework.context-3.2.9
org.springframework.context.support-3.2.9
org.springframework.core-3.2.9
org.springframework.expression-3.2.9
commons-logging-1.2

2、实例：

package com.importnew;

public classHelloWorld {

private String message;

public voidsetMessage(String message){

this.message = message;

}

public String getMessage(){

return this.message;

}

public voidprintMessage(){

System.out.println("Your Message : "+ message);

}

配置：

<?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

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

</bean>

</beans>

package com.importnew;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {

public static void main(String[] args) {

ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

HelloWorld obj = (HelloWorld) context.getBean("helloWorld");

obj.printMessage();

}

另外一种方式：

BeanFactory beanFactory = new ClassPathXmlApplicationContext("chapter2/namingbean2.xml”);

HelloApi bean = beanFactory.getBean("bean", HelloApi.class);

bean.sayHello();

3、注释：

1、两个最基本最重要的包是 org.springframework.beans 和 org.springframework.context.

这两个包中的代码为Spring的反向控制特性（也叫作依赖注射）提供了基础。

2、ApplicationContext是BeanFactory的子类。

3、org.springframework.beans.factory.xml.XmlBeanFactory是接口BeanFactory的一个实现

4、在ApplicationContext的诸多实现中，有三个经常用到：

ClassPathXmlApplicationContext:从类路径中的XML文件载入上下文定义信息，把上下文定义文件当作类路径资源。

FileSystemXmlApplicationContext:从文件系统中的XML文件载入上下文定义信息。

XmlWebApplicationContext：从Web系统中的XMl文件载入上下文信息。

4、aop的原理即是java的动态代理？

5、配置简写

让我们来总结一下依赖注入配置及简写形式，其实我们已经在以上部分穿插着进行简化配置了：

一、构造器注入：

1）常量值

简写：<constructor-arg index="0" value="常量"/>

全写：<constructor-arg index="0"><value>常量</value></constructor-arg>

2）引用

简写：<constructor-arg index="0" ref="引用"/>

全写：<constructor-arg index="0"><ref bean="引用"/></constructor-arg>

二、setter注入：

1）常量值

简写：<property name="message" value="常量"/>

全写：<property name="message"><value>常量</value></ property>

2）引用

简写：<property name="message" ref="引用"/>

全写：<property name="message"><ref bean="引用"/></ property>

3）数组：<array>没有简写形式

4）列表：<list>没有简写形式

5）集合：<set>没有简写形式

6）字典

简写：<map>

</map>

全写：<map>

</map>

################################################################################

######## 20161209 ###########################################

################################################################################

1、延迟初始化Bean： lazy-init

延迟初始化也叫做惰性初始化，指不提前初始化Bean，而是只有在真正使用时才创建及初始化Bean。

不建议使用：除非是那种消耗资源大，且不常用的bean。

2、depends-on

3、依赖检查

上一节介绍的自动装配，很可能发生没有匹配的Bean进行自动装配，如果此种情况发生，只有在程序运行过程中发生了空指针异常才能发现错误，如果能提前发现该多好啊，这就是依赖检查的作用。依赖检查：用于检查Bean定义的属性都注入数据了，不管是自动装配的还是配置方式注入的都能检查，如果没有注入数据将报错，从而提前发现注入错误，只检查具有setter方法的属性。Spring3+也不推荐配置方式依赖检查了，建议采用Java5+ @Required注解方式，测试时请将XML schema降低为2.5版本的，和自动装配中“autodetect”配置方式的xsd一样。

依赖检查有none、simple、object、all四种方式，接下来让我们详细介绍一下：

一、none：默认方式，表示不检查；

二、objects：检查除基本类型外的依赖对象，配置方式为：dependency-check="objects"，此处我们为HelloApiDecorator添加一个String类型属

性“message”，来测试如果有简单数据类型的属性为null，也不报错；

<bean id="helloApi" class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>
<bean id="bean"
class="cn.javass.spring.chapter3.bean.HelloApiDecorator"
dependency-check="objects">
<property name="message" value="Haha"/>
</bean>

注意由于我们没有注入bean需要的依赖“helloApi”，所以应该抛出异常UnsatisfiedDependencyException，表示没有发现满

足的依赖：

三、simple：对基本类型进行依赖检查，包括数组类型，其他依赖不报错；配置方式为：dependency-check="simple"，以下配置中没有注入message属性，所以会抛出异常：

四、all：对所以类型进行依赖检查，配置方式为：dependency-check="all"，如下配置方式中如果两个属性其中一个没配置将报错。

#####################################################################################

######## 20161210 #############################################

#####################################################################################

Bean的作用域

singleton：指“singleton”作用域的Bean只会在每个Spring IoC容器中存在一个实例，而且其完整生命周期完全由Spring容器管理。对于所有获取该Bean的操作Spring容器将只返回同一个Bean。

prototype：即原型，指每次向Spring容器请求获取Bean都返回一个全新的Bean，相对于“singleton”来说就是不缓存Bean，每次都是一个根据Bean定义创建的全新Bean。

######################################################################################

######## 20161211 ###### 201612114 ###########################

######################################################################################

1、AOP：低耦合的新增一些功能。

用于横切关注点的分离和织入横切关注点到系统；比如上边提到的日志等等；
完善OOP；
降低组件和模块之间的耦合性；
使系统容易扩展；
而且由于关注点分离从而可以获得组件的更好复用。

AOP代理就是AOP框架通过代理模式创建的对象，Spring使用JDK动态代理或CGLIB代理来实现，Spring缺省使用JDK

动态代理来实现，从而任何接口都可别代理，如果被代理的对象实现不是接口将默认使用CGLIB代理，不过CGLIB代理当

然也可应用到接口。

2、需要新增一个包啦：

###################################################################################

######## 20170216 #########################################

###################################################################################

3、aop基本概率

在进行AOP开发前，先熟悉几个概念：

连接点（Jointpoint）：表示需要在程序中插入横切关注点的扩展点，连接点可能是类初始化、方法执行、方法调用、字段调用或处理异常等等，Spring只支持方法执行连接点，在AOP中表示为“在哪里干”；
切入点（Pointcut）：选择一组相关连接点的模式，即可以认为连接点的集合，Spring支持perl5正则表达式和AspectJ切入点模式，Spring默认使用AspectJ语法，在AOP中表示为“在哪里干的集合”；
通知（Advice）：在连接点上执行的行为，通知提供了在AOP中需要在切入点所选择的连接点处进行扩展现有行为的手段；包括前置通知（before advice）、后置通知(after advice)、环绕通知（around advice），在Spring中通过代理模式实现AOP，并通过拦截器模式以环绕连接点的拦截器链织入通知；在AOP中表示为“干什么”；
方面/切面（Aspect）：横切关注点的模块化，比如上边提到的日志组件。可以认为是通知、引入和切入点的组合；在Spring中可以使用Schema和@AspectJ方式进行组织实现；在AOP中表示为“在哪干和干什么集合”；
引入（inter-type declaration）：也称为内部类型声明，为已有的类添加额外新的字段或方法，Spring允许引入新的接口（必须对应一个实现）到所有被代理对象（目标对象）, 在AOP中表示为“干什么（引入什么）”；
目标对象（Target Object）：需要被织入横切关注点的对象，即该对象是切入点选择的对象，需要被通知的对象，从而也可称为“被通知对象”；由于Spring AOP 通过代理模式实现，从而这个对象永远是被代理对象，在AOP中表示为“对谁干”；
AOP代理（AOP Proxy）：AOP框架使用代理模式创建的对象，从而实现在连接点处插入通知（即应用切面），就是通过代理来对目标对象应用切面。在Spring中，AOP代理可以用JDK动态代理或CGLIB代理实现，而通过拦截器模型应用切面。
织入（Weaving）：织入是一个过程，是将切面应用到目标对象从而创建出AOP代理对象的过程，织入可以在编译期、类装载期、运行期进行。

接下来再让我们具体看看Spring有哪些通知类型：

前置通知（Before Advice）:在切入点选择的连接点处的方法之前执行的通知，该通知不影响正常程序执行流程（除非该通知抛出异常，该异常将中断当前方法链的执行而返回）。
后置通知（After Advice）:在切入点选择的连接点处的方法之后执行的通知，包括如下类型的后置通知：
- 后置返回通知（After returning Advice）:在切入点选择的连接点处的方法正常执行完毕时执行的通知，必须是连接点处的方法没抛出任何异常正常返回时才调用后置通知。
- 后置异常通知（After throwing Advice）: 在切入点选择的连接点处的方法抛出异常返回时执行的通知，必须是连接点处的方法抛出任何异常返回时才调用异常通知。
- 后置最终通知（After finally Advice）: 在切入点选择的连接点处的方法返回时执行的通知，不管抛没抛出异常都执行，类似于Java中的finally块。
环绕通知（Around Advices）：环绕着在切入点选择的连接点处的方法所执行的通知，环绕通知可以在方法调用之前和之后自定义任何行为，并且可以决定是否执行连接点处的方法、替换返回值、抛出异常等等。

4、基于schema的aop实例

定义目标接口：

package cn.javass.spring.chapter6.service;
public interface IHelloWorldService {
public void sayHello();
}

定义目标接口实现：

package cn.javass.spring.chapter6.service.impl;
import cn.javass.spring.chapter6.service.IHelloWorldService;
public class HelloWorldService implements IHelloWorldService {
@Override
public void sayHello() {
System.out.println("============Hello World!");
}
}

定义切面支持类

package cn.javass.spring.chapter6.aop;
public class HelloWorldAspect {
//前置通知
public void beforeAdvice() {
System.out.println("===========before advice");
}
//后置最终通知
public void afterFinallyAdvice() {
System.out.println("===========after finally advice");
}
}

此处HelloWorldAspect类不是真正的切面实现，只是定义了通知实现的类，在此我们可以把它看作就是缺少了切入点的切面。

在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"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd”>
<bean id="helloWorldService” class="cn.javass.spring.chapter6.service.impl.HelloWorldService”/>
<bean id="aspect" class="cn.javass.spring.chapter6.aop.HelloWorldAspect"/>
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* cn.javass..*.*(..))"/>
<aop:aspect ref="aspect">
<aop:before pointcut-ref="pointcut" method="beforeAdvice"/>
<aop:after pointcut="execution(* cn.javass..*.*(..))" method="afterFinallyAdvice"/>
</aop:aspect>
</aop:config>
</beans>

切入点使用<aop:config>标签下的<aop:pointcut>配置，expression属性用于定义切入点模式，默认是AspectJ语法，“execution(* cn.javass..*.*(..))”表示匹配cn.javass包及子包下的任何方法执行。切面使用<aop:config>标签下的<aop:aspect>标签配置，其中“ref”用来引用切面支持类的方法。

前置通知使用<aop:aspect>标签下的<aop:before>标签来定义，pointcut-ref属性用于引用切入点Bean，而method用来引用切面通知实现类中的方法，该方法就是通知实现，即在目标类方法执行之前调用的方法。pointcut和pointcut-ref：二者选一，指定切入点；

最终通知使用<aop:aspect>标签下的<aop:after >标签来定义，切入点除了使用pointcut-ref属性来引用已经存在的切入点，也可以使用pointcut属性来定义，如pointcut="execution(* cn.javass..*.*(..))"，method属性同样是指定通知实现，即在目标类方法执行之后调用的方法。

5、aop原理

静态代理的缺陷：每次都需要创建一个代理类，不实用。

aop的两种实现原理：

1.动态代理：通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来实现。

动态代理要求：被代理的对象必须实现接口。即必须针对接口编程，因此有了CGLIB。

2.CGLIB：通过实现net.sf.cglib.proxy.MethodInterceptor接口（或者其扩展接口：MethodInterceptor接口）

CGLIB要求：无法对final方法进行覆写。

Spring揭秘第九章第一代aop需仔细阅读，搞清楚原理。

###################################################################################

######## 20170217 ##########################################

###################################################################################

6、aop：基于@AspectJ的aop

1）使用@Aspect将POJO声明为切面；

2）使用@Pointcut进行命名切入点声明，同时指定目标方法第一个参数类型必须是java.lang.String，对于其他匹配的方法但参数类型不一致的将也是不匹配的，通过

argNames = "param"指定了将把该匹配的目标方法参数传递给通知同名的参数上；

3）使用@Before进行前置通知声明，其中value用于定义切入点表达式或引用命名切入点；

4）配置文件需要使用<aop:aspectj-autoproxy/>来开启注解风格的@AspectJ支持；

5）需要将切面注册为Bean，如“aspect”Bean；

6）测试代码完全一样。

通配符：

* ：匹配任何数量字符；

.. ：（两个点）匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数。

+ ：匹配指定类型的子类型；仅能作为后缀放在类型模式后边。

实例：

声明切面：使用@Aspect

@Aspect()

public class Aspect{

@Pointcut(value="execution(* cn.javass..*.sayAdvisorBefore(..)) && args(param)”,

argNames = "param”)

public void beforePointcut(String param) {}

@Before(value = "beforePointcut(param)”,

argNames = "param”)

public void beforeAdvice(String param) {

System.out.println("===========before advice param:" + param);

}

@AfterReturning(value = "beforePointcut(param)”,

argNames="retVal”,

returning="retVal”)

public void afterReturningAdvice(Object retVal) {

System.out.println("===========after returning advice retVal:" + retVal);

}

@AfterThrowing( value="execution(* cn.javass..*.sayAfterThrowing(..))",

argNames="exception”,

throwing="exception")

public void afterThrowingAdvice(Exception exception) {

System.out.println("===========after throwing advice exception:" + exception);

}

@After(value="execution(* cn.javass..*.sayAfterFinally(..))")

public void afterFinallyAdvice() {

System.out.println("===========after finally advice");

}

//看他的参数：ProceedingJoinPoint pjp，与其他通知不同

@Around(value="execution(* cn.javass..*.sayAround(..))")

public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {

System.out.println("===========around before advice");

Object retVal = pjp.proceed(new Object[] {"replace"});

System.out.println("===========around after advice");

return retVal;

}

切面需在配置文件中声明，Spring就能自动识别并进行aop方面的配置：

###############################################################################

######## 20170221 ##################################

###############################################################################

7、BeanFactory的XML之旅

<beans>作为所有<bean>的“统帅”,它拥有相应的属性(attribute)对所辖的<bean>进行统一的默认行为设置,包括如下几个：

default-lazy-init。其值可以指定为true或者false,默认值为false。用来标志是否对所有的<bean>进行延迟初始化。

default-autowire。可以取值为no、byName、byType、constructor以及autodetect。默认值为no,如果使用自动绑定的话,用来标志全体bean使用哪一种默认绑定方式。

default-dependency-check。可以取值none、objects、simple以及all,默认值为none,即不做依赖检查。

default-init-method。如果所管辖的<bean>按照某种规则,都有同样名称的初始化方法的话,可以在这里统一指定这个初始化方法名。

default-destroy-method。与default-init-method相对应,如果所管辖的bean有按照某种规则使用了相同名称的对象销毁方法。

其中default-lazy-init是配置全局的懒加载模式，也可以单独在每个bean上进行配置：<bean id="lazy-init-bean" class="..." lazy-init="true"/>

其中default-autowire是配置全局的自动配置模式，也可以单独在每个bean上进行配置。

自动绑定和手动明确绑定各有利弊。自动绑定的优点有如下两点：

(1) 某种程度上可以有效减少手动敲入配置信息的工作量。

(2) 某些情况下,即使为当前对象增加了新的依赖关系,但只要容器中存在相应的依赖对象,就不需要更改任何配置信息。

自动绑定的缺点有如下几点：

(1) 自动绑定不如明确依赖关系一目了然。我们可以根据明确的依赖关系对整个系统有一个明确的认识,但使用自动绑定的话,就可能需要在类定义以及配置文件之间,甚至各个配置文件之间来回转换以取得相应的信息。

(2) 某些情况下,自动绑定无法满足系统需要,甚至导致系统行为异常或者不可预知。根据类型(byType)匹配进行的自动绑定,如果系统中增加了另一个相同类型的bean定义,那么整个系统就会崩溃;根据名字(byName)匹配进行的自动绑定,如果把原来系统中相同名称的 bean定义类型给换掉,就会造成问题,而这些可能都是在不经意间发生的。

(3) 使用自动绑定,我们可能无法获得某些工具的良好支持,比如Spring IDE。

标记为singleton的bean是由容器来保证这种类型的bean在同一个容器中只存在一个共享实例; 而Singleton模式则是保证在同一个Classloader中只存在一个这种类型的实例。通常情况下,如果你不指定bean的scope，singleton便是容器默认的scope。以下三种定义都代表是singleton的scope的：

<bean id="mockObject1" class="...MockBusinessObject" scope="singleton"/

针对声明为拥有prototype scope的bean定义,容器在接到该类型对象的请求的时候,会每次都重新生成一个新的对象实例给请求方：

###############################################################################

#######20170222 ##################################

###############################################################################

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

容器启动阶段

Configuration MetaData

|| 加载并分析配置信息

BeanDefinition

|| 注册

BeanDefinitionRegister

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

Bean实例化阶段

getBean

BeanFactoryPostProcessor：干预容器启动阶段

该机制允许我们在容器实例化相应对象之前，对注册到容器的BeanDefinition所保存的信息做相应的修改，

比如修改其中bean定义的某些属性，为bean定义增加其他信息等。配置信息，修改一些配置参数

具体用其两个实现类：

org.springframework.beans.factory.config.PropertyPlaceholderConfigurer

org.springframework.beans.factory.config.PropertyOverrideConfigurer

BeanPostProcessor接口：

public interface BeanPostProcessor

Object postProcessBeforeInitialization(Object bean, String beanName) throws ➥ BeansException;

Object postProcessAfterInitialization(Object bean, String beanName) throws ➥ BeansException;

}

我们看下其中一个方法的实现：

只要某个bean实现了某一个aware接口，就会被BeanPostProcessor进行处理。BeanPostProcessor的两个方法中都传入了原来的对象实例的引用,

这为我们扩展容器的对象实例化过程中的行为提供了极大的便利,我们几乎可以对传入的对象实例执行任何的操作。

我们可以自定义BeanPostProcessor，通过实现BeanPostProcessor接口即可，但需要将自定义的BeanPostProcessor注册到容器。

除了检查标记接口以便应用自定义逻辑,还可以通过BeanPostProcessor对当前对象实例做更多的处理。比如替换当前对象实例或者字节码增强当前对象实例等。

Spring的AOP则更多地使用 BeanPostProcessor来为对象生成相应的代理对象,如org.springframework.aop.framework. autoproxy.BeanNameAutoProxyCreator。

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

###############################################################################

#######20170222 1818 ##################################

###############################################################################

1、ApplicationContext

BeanFactory：XmlBeanFactory实现。

ApplicationContext：三种实现

1 0