springaop源码

㈠ 怎么阅读Spring源码

准备工作
1. 安装github：现在spring源代码都在github管理，所以首先需要下载githup，下；
2. 安装gradle构建工具： 下载完后进行解压到任意盘符，然后增加环境变量GRADLE_HOME，并在环境变量bin中增加%GRADLE_HOME%/bin，打开DOS窗口，运行gradle -v，出现版本号等信息，表示安装成功；
3. 下载Spring源码：首先打开git shell，切换到你的工作目录，然后输入以下命令：git clone git://github.com/SpringSource/Spring-framework.git，后面一串是源码下载地址。大概半小时的样子，就可以下载完成，这时候在你的工作目录中就会出现Spring-framework的目录，里面有Spring各组件的源码包；

4. 构建导入：下载下来的代码不能直接导入Eclipse，要先转换成Eclipse能读取的形式。因为所有组件都会依赖spring-core，所有我们首先要转换Spring-core工程，在命令窗口切换到Spring-core工程，运行gradle cleanidea eclipse命令，我们会看到开始下载工程所依赖的jar包，几分钟后执行完毕，再来看Spring-core文件夹，多了.classpath、.project等文件，这是Eclipse工程所必须的，然后可以把他导入到eclipse。因为大部分Spring组件都会用到 spring-beans、spring-context、spring-aop，而他们又依赖spring-expression、spring-instrument，所以我们干脆先把这些工程都进行转换并导入eclipse。
我初次导入过程并不顺利，拿spring-core为例，其中以来的一个jar包是Spring-framework/spring-core/build/libs/spring-asm-repack-4.0.jar，但我工程里面并没有他，只好在网上下载了一个，并加入构建路径，其次我还发现少commons-pool-1.5.3.jar、spring-cglib-repack-3.0.jar，都一一下载，最后还是报错没有java.util.concurrent.ForkJoinPool类，发现这个版本必须使用jdk1.7以上，1.6没有这个包。折腾半天，终于几个工程没变异错误了，向前迈进了一步。

㈡ spring的ioc和aop都是什么

什么是IoC

Ioc—Inversion of
Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：

控制是什么：传统Java
SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对象的创建；谁控制谁？当然是IoC
容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

IoC能做什么

IoC不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。

IoC和DI

DI—Dependency
Injection，即“依赖注入”：是组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

注：如果想要更加深入的了解IoC和DI，请参考大师级人物Martin Fowler的一篇经典文章《Inversion of Control
Containers and the Dependency Injection
pattern》，原文地址：http://www.martinfowler.com/articles/injection.html。

AOP：面向切面编程

什么是AOP：

概念：在软件业，AOP为Aspect Oriented
Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。（网络）

简单的说：就是将程序中重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

AOP的作用和优势：

作用：从定义中来看，就是为了在程序运行期间，不修改源码对已有方法进行增强。

优势：减少重复代码 提交了开发效率 维护方便

实现方式： 就是动态代理的技术

具体的作用：实现事务的控制 日志 和 安全模块

想系统的学习编程可以来我这看看，希望对您有所帮助！~

㈢ 如何理解Spring的AOP

Spring的AOP面向切面编程，就是横向的，比如程序运行时都要建日志，相当于SQL的触发器。

Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。

㈣ 如何查看spring源码

1.准备工作：在官网上下载了Spring源代码之后，导入Eclipse，以方便查询。
2.打开我们使用Spring的项目工程，找到Web.xml这个网站系统配置文件，在其中找到Spring的初始化信息：

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

由配置信息可知，我们开始的入口就这里ContextLoaderListener这个监听器。
在源代码中我们找到了这个类，它的定义是：
public class ContextLoaderListener extends ContextLoader
implements ServletContextListener {
…
/**
* Initialize the root web application context.
*/
public void contextInitialized(ServletContextEvent event) {
this.contextLoader = createContextLoader();
if (this.contextLoader == null) {
this.contextLoader = this;
}
this.contextLoader.initWebApplicationContext(event.getServletContext());
}
...
}

该类继续了ContextLoader并实现了监听器，关于Spring的信息载入配置、初始化便是从这里开始了，具体其他阅读另外写文章来深入了解。
二、关于IOC和AOP
关于Spring IOC 网上很多相关的文章可以阅读，那么我们从中了解到的知识点是什么？
1）IOC容器和AOP切面依赖注入是Spring是核心。
IOC容器为开发者管理对象之间的依赖关系提供了便利和基础服务，其中Bean工厂（BeanFactory）和上下文（ApplicationContext）就是IOC的表现形式。BeanFactory是个接口类，只是对容器提供的最基本服务提供了定义，而DefaultListTableBeanFactory、XmlBeanFactory、ApplicationContext等都是具体的实现。
接口：

public interface BeanFactory {
//这里是对工厂Bean的转义定义，因为如果使用bean的名字检索IOC容器得到的对象是工厂Bean生成的对象，
//如果需要得到工厂Bean本身，需要使用转义的名字来向IOC容器检索
String FACTORY_BEAN_PREFIX = "&";
//这里根据bean的名字，在IOC容器中得到bean实例，这个IOC容器就象一个大的抽象工厂，用户可以根据名字得到需要的bean
//在Spring中，Bean和普通的JAVA对象不同在于：
//Bean已经包含了我们在Bean定义信息中的依赖关系的处理，同时Bean是已经被放到IOC容器中进行管理了，有它自己的生命周期
Object getBean(String name) throws BeansException;
//这里根据bean的名字和Class类型来得到bean实例，和上面的方法不同在于它会抛出异常：如果根名字取得的bean实例的Class类型和需要的不同的话。
Object getBean(String name, Class requiredType) throws BeansException;
//这里提供对bean的检索，看看是否在IOC容器有这个名字的bean
boolean containsBean(String name);
//这里根据bean名字得到bean实例，并同时判断这个bean是不是单件，在配置的时候，默认的Bean被配置成单件形式,如果不需要单件形式，需要用户在Bean定义信息中标注出来，这样IOC容器在每次接受到用户的getBean要求的时候，会生成一个新的Bean返回给客户使用 - 这就是Prototype形式
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
//这里对得到bean实例的Class类型
Class getType(String name) throws NoSuchBeanDefinitionException;
//这里得到bean的别名，如果根据别名检索，那么其原名也会被检索出来
String[] getAliases(String name);
}

实现：
XmlBeanFactory的实现是这样的：
public class XmlBeanFactory extends DefaultListableBeanFactory {
//这里为容器定义了一个默认使用的bean定义读取器，在Spring的使用中，Bean定义信息的读取是容器初始化的一部分，但是在实现上是和容器的注册以及依赖的注入是分开的，这样可以使用灵活的 bean定义读取机制。
private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
//这里需要一个Resource类型的Bean定义信息，实际上的定位过程是由Resource的构建过程来完成的。
public XmlBeanFactory(Resource resource) throws BeansException {
this(resource, null);
}
//在初始化函数中使用读取器来对资源进行读取，得到bean定义信息。这里完成整个IOC容器对Bean定义信息的载入和注册过程
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws
BeansException {
super(parentBeanFactory);
this.reader.loadBeanDefinitions(resource);
}

㈤ spring源码深度解析这本书怎么样

您好，希望以下回答能帮助您
《SPRING技术内幕——深入解析SPRING架构与设计原理》

该书讲了spring的ioc容器原理,在xml的spring配置文件中，对象是如何解析并生成的。
spring的aop，面向切面编程。这两块是比较重要的，属于核心部分。
其他的如spring mvc ，spring jdbc与hibernate,ibatise集成，spring事务，spring security，
spring 任务调度都有介绍。
大体来说，属于跟着代码走向，一个类一个类介绍了一下。其实代码都是有英文注释的。
跟着作都的思路看过来也还是可以的，最好是对照类图分析。
如您还有疑问可继续追问。

㈥ 读过完整Spring源码的来领分

不为领分，谈点个人看法

不要过于急于掌握，先明白什么是spring，spring的本质是什么，对象间关系，为什么要通过IoC这样的方式来管理。

学习资料：
spring2.0中文手册 http://www.redsaga.com/spring_ref/2.0/html/

推荐书籍：expert one-on-one J2EE Development without EJB 有中文版

//-------------------------
// www.1x3x.net/blog
//-------------------------

㈦ [事物唯一性]spring AOP 事物回滚不同步

总结-spring事物同步回滚/提交：

1.保证事物传播机制正确配置
2.session会话管理配置
3.DataAccess层异常是否抛出，如果抛出，service也需要抛出(throw e)，要么全不抛，要么全抛，直至Web层catch().
4.保证抛出的异常是否在spring aop事物管理范围内，RuntimeException异常，UncheckException异常。如自定义异常需继承运行时异常。在抛出。
5.如service层需抛出自定义异常，异常又不为运行时异常，需织入一个检查异常，spring默认只处理RuntimeException的子类和Error，自定义异常需transactionAttribute节点底下定义你自己的rollback rules才能被Spring正确管理，源码：RuleBasedTransactionAttribute。

问题解决。

㈧ Spring整合rabbitmq实践（一）：基础

Spring整合rabbitmq实践（二）：扩展
Spring整合rabbitmq实践（三）：源码

procer：消息生产者；

consumer：消息消费者；

queue：消息队列；

exchange：接收procer发送的消息按照binding规则转发给相应的queue；

binding：exchange与queue之间的关系；

virtualHost：每个virtualHost持有自己的exchange、queue、binding，用户只能在virtualHost粒度控制权限。

fanout：

群发到所有绑定的queue；

direct：

根据routing key routing到相应的queue，routing不到任何queue的消息扔掉；可以不同的key绑到同一个queue，也可以同一个key绑到不同的queue；

topic：

类似direct，区别是routing key是由一组以“.”分隔的单词组成，可以有通配符，“*”匹配一个单词，“#”匹配0个或多个单词；

headers：

根据arguments来routing。

arguments为一组key-value对，任意设置。

“x-match”是一个特殊的key，值为“all”时必须匹配所有argument，值为“any”时只需匹配任意一个argument，不设置默认为“all”。

通过以下配置，可以获得最基础的发送消息到queue，以及从queue接收消息的功能。

这个包同时包含了一些其它的包：spring-context、spring-tx、spring-web、spring-messaging、spring-retry、spring-amqp、amqp-client，如果想单纯一点，可以单独引入。

最主要的是以下几个包，

spring-amqp：

spring-rabbit：

amqp-client：

个人理解就是，spring-amqp是spring整合的amqp，spring-rabbit是spring整合的rabbitmq（rabbitmq是amqp的一个实现，所以可能spring-rabbit也是类似关系），amqp-client提供操作rabbitmq的java api。

目前最新的是2.0.5.RELEASE版本。如果编译报错，以下信息或许能有所帮助：

(1)

解决方案：spring-amqp版本改为2.0.5.RELEASE。

(2)

解决方案：spring-context版本改为5.0.7.RELEASE。

(3)

解决方案：spring-core版本改为5.0.7.RELEASE。

(4)

解决方案：spring-beans版本改为5.0.7.RELEASE。

(5)

解决方案：spring-aop版本改为5.0.7.RELEASE。

总之，需要5.0.7.RELEASE版本的spring，及相匹配版本的amqp-client。

后面所讲的这些bean配置，spring-amqp中都有默认配置，如果不需要修改默认配置，则不用人为配置这些bean。后面这些配置也没有涉及到所有的属性。

这里的ConnectionFactory指的是spring-rabbit包下面的ConnectionFactory接口，不是amqp-client包下面的ConnectionFactory类。

上面这个bean是spring-amqp的核心，不论是发送消息还是接收消息都需要这个bean，下面描述一下里面这些配置的含义。

setAddresses ：设置了rabbitmq的地址、端口，集群部署的情况下可填写多个，“,”分隔。

setUsername ：设置rabbitmq的用户名。

setPassword ：设置rabbitmq的用户密码。

setVirtualHost ：设置virtualHost。

setCacheMode ：设置缓存模式，共有两种， CHANNEL 和 CONNECTION 模式。

CHANNEL 模式，程序运行期间ConnectionFactory会维护着一个Connection，所有的操作都会使用这个Connection，但一个Connection中可以有多个Channel，操作rabbitmq之前都必须先获取到一个Channel，否则就会阻塞（可以通过setChannelCheckoutTimeout()设置等待时间），这些Channel会被缓存（缓存的数量可以通过setChannelCacheSize()设置）；

CONNECTION 模式，这个模式下允许创建多个Connection，会缓存一定数量的Connection，每个Connection中同样会缓存一些Channel，除了可以有多个Connection，其它都跟CHANNEL模式一样。

这里的Connection和Channel是spring-amqp中的概念，并非rabbitmq中的概念，官方文档对Connection和Channel有这样的描述：

关于 CONNECTION 模式中，可以存在多个Connection的使用场景，官方文档的描述：

setChannelCacheSize ：设置每个Connection中（注意是每个Connection）可以缓存的Channel数量，注意只是缓存的Channel数量，不是Channel的数量上限，操作rabbitmq之前（send/receive message等）要先获取到一个Channel，获取Channel时会先从缓存中找闲置的Channel，如果没有则创建新的Channel，当Channel数量大于缓存数量时，多出来没法放进缓存的会被关闭。

注意，改变这个值不会影响已经存在的Connection，只影响之后创建的Connection。

setChannelCheckoutTimeout ：当这个值大于0时， channelCacheSize 不仅是缓存数量，同时也会变成数量上限，从缓存获取不到可用的Channel时，不会创建新的Channel，会等待这个值设置的毫秒数，到时间仍然获取不到可用的Channel会抛出AmqpTimeoutException异常。

同时，在 CONNECTION 模式，这个值也会影响获取Connection的等待时间，超时获取不到Connection也会抛出AmqpTimeoutException异常。

setPublisherReturns、setPublisherConfirms ：procer端的消息确认机制（confirm和return），设为true后开启相应的机制，后文详述。

官方文档描述publisherReturns设为true打开return机制，publisherComfirms设为true打开confirm机制，但测试结果（2.0.5.RELEASE版本）是，任意一个设为true，两个都会打开。

addConnectionListener、addChannelListener、setRecoveryListener ：添加或设置相应的Listener，后文详述。

setConnectionCacheSize ：仅在 CONNECTION 模式使用，设置Connection的缓存数量。

setConnectionLimit ：仅在 CONNECTION 模式使用，设置Connection的数量上限。

上面的bean配置，除了需要注入的几个listener bean以外，其它设置的都是其默认值（2.0.5.RELEASE版本），后面的bean示例配置也是一样，部分属性不同版本的默认值可能有所不同。

一般不用配置这个bean，这里简单提一下。

这个ConnectionFactory是rabbit api中的ConnectionFactory类，这里面是连接rabbitmq节点的Connection配置。

如果想修改这些配置，可以按如下方式配置：

consumer端如果通过@RabbitListener注解的方式接收消息，不需要这个bean。

不建议直接通过ConnectionFactory获取Channel操作rabbitmq，建议通过amqpTemplate操作。

setConnectionFactory ：设置spring-amqp的ConnectionFactory。

setRetryTemplate ：设置重试机制，详情见后文。

setMessageConverter ：设置MessageConverter，用于java对象与Message对象（实际发送和接收的消息对象）之间的相互转换，详情见后文。

setChannelTransacted ：打开或关闭Channel的事务，关于amqp的事务后文描述。

setReturnCallback、setConfirmCallback ：return和confirm机制的回调接口，后文详述。

setMandatory ：设为true使ReturnCallback生效。

这个bean仅在consumer端通过@RabbitListener注解的方式接收消息时使用，每一个@RabbitListener注解的方法都会由这个创建一个MessageListenerContainer，负责接收消息。

setConnectionFactory ：设置spring-amqp的ConnectionFactory。

setMessageConverter ：对于consumer端，MessageConverter也可以在这里配置。

setAcknowledgeMode ：设置consumer端的应答模式，共有三种：NONE、AUTO、MANUAL。

NONE，无应答，这种模式下rabbitmq默认consumer能正确处理所有发出的消息，所以不管消息有没有被consumer收到，有没有正确处理都不会恢复；

AUTO，由Container自动应答，正确处理发出ack信息，处理失败发出nack信息，rabbitmq发出消息后将会等待consumer端的应答，只有收到ack确认信息才会把消息清除掉，收到nack信息的处理办法由setDefaultRequeueRejected()方法设置，所以在这种模式下，发生错误的消息是可以恢复的。

MANUAL，基本同AUTO模式，区别是需要人为调用方法给应答。

setConcurrentConsumers ：设置每个MessageListenerContainer将会创建的Consumer的最小数量，默认是1个。

setMaxConcurrentConsumers ：设置每个MessageListenerContainer将会创建的Consumer的最大数量，默认等于最小数量。

setPrefetchCount ：设置每次请求发送给每个Consumer的消息数量。

setChannelTransacted ：设置Channel的事务。

setTxSize ：设置事务当中可以处理的消息数量。

setDefaultRequeueRejected ：设置当rabbitmq收到nack/reject确认信息时的处理方式，设为true，扔回queue头部，设为false，丢弃。

setErrorHandler ：实现ErrorHandler接口设置进去，所有未catch的异常都会由ErrorHandler处理。

AmqpTamplate里面有下面几个方法可以向queue发送消息：

这里，exchange必须存在，否则消息发不出去，会看到错误日志，但不影响程序运行：

Message是org.springframework.amqp.core.Message类，spring-amqp发送和接收的都是这个Message。

从Message类源码可以看到消息内容放在byte[]里面，MessageProperties对象包含了非常多的一些其它信息，如Header、exchange、routing key等。

这种方式，需要将消息内容（String，或其它Object）转换为byte[]，示例：

也可以直接调用下面几个方法，Object将会自动转为Message对象发送：

有两种方法接收消息：

1.polling consumer，轮询调用方法一次获取一条；

2.asynchronous consumer，listener异步接收消息。

polling consumer

直接通过AmqpTemplate的方法从queue获取消息，有如下方法：

如果queue里面没有消息，会立刻返回null；传入timeoutMillis参数后可阻塞等待一段时间。

如果想直接从queue获取想要的java对象，可调用下面这一组方法：

后面4个方法是带泛型的，示例如下：

使用这四个方法需要配置org.springframework.amqp.support.converter.SmartMessageConverter，这是一个接口，Jackson2JsonMessageConverter已经实现了这个接口，所以只要将Jackson2JsonMessageConverter设置到RabbitTemplate中即可。

asynchronous consumer

有多种方式可以实现，详情参考官方文档。

最简单的实现方式是@RabbitListener注解，示例：

这里接收消息的对象用的是Message，也可以是自定义的java对象，但调用Converter转换失败会报错。

注解上指定的queue必须是已经存在并且绑定到某个exchange的，否则会报错：

如果在@RabbitListener注解中指明binding信息，就能自动创建queue、exchange并建立binding关系。

direct和topic类型的exchange需要routingKey，示例：

fanout类型的exchange，示例：

2.0版本之后，可以指定多个routingKey，示例：

并且支持arguments属性，可用于headers类型的exchange，示例：

@Queue有两个参数exclusive和autoDelete顺便解释一下：

exclusive，排他队列，只对创建这个queue的Connection可见，Connection关闭queue删除；

autoDelete，没有consumer对这个queue消费时删除。

对于这两种队列，rable=true是不起作用的。

另外，如果注解申明的queue和exchange及binding关系都已经存在，但与已存在的设置不同，比如，已存在的exchange的是direct类型，这里尝试改为fanout类型，结果是不会有任何影响，不论是修改或者新增参数都不会生效。

如果queue存在，exchange存在，但没有binding，那么程序启动后会自动建立起binding关系。

㈨ spring源码要怎么讲

《SPRING技术内幕——深入解析SPRING架构与设计原理》

该书讲了spring的ioc容器原理,在xml的spring配置文件中，对象是如何解析并生成的。
spring的aop，面向切面编程。这两块是比较重要的，属于核心部分。
其他的如spring mvc ，spring jdbc与hibernate,ibatise集成，spring事务，spring security，
spring 任务调度都有介绍。
大体来说，属于跟着代码走向，一个类一个类介绍了一下。其实代码都是有英文注释的。
跟着作都的思路看过来也还是可以的，最好是对照类图分析。

㈩ 如何评价spring源码深度解析

您好，希望以下回答能帮助您 《SPRING技术内幕——深入解析SPRING架构与设计原理》 该书讲了spring的ioc容器原理,在xml的spring配置文件中，对象是如何解析并生成的。 spring的aop，面向切面编程。这两块是比较重要的，属于核心部分。 其他的如spring mvc ，spring jdbc与hibernate,ibatise集成，spring事务，spring security， spring 任务调度都有介绍。 大体来说，属于跟着代码走向，一个类一个类介绍了一下。其实代码都是有英文注释的。 跟着作都的思路看过来也还是可以的，最好是对照类图分析。 如您还有疑问可继续追问。