spring框架的讲解

spring框架

导读模块

1.spring:是一个java的开源框架，主要通过applicationContext.xml这个文件实现对项目中代码进行解耦的，以达到软件工程追求的高内聚低耦合的效果

2.怎么样才能实现解耦：依靠IOC或者DI

3.怎样实现ＩＯＣ或者ＤＩ：
　　　　　　　　　　　　　通过在applicationContext.xml配置bean就可以实现

1.spring框架非web项目的使用

1.1导入需要的jar包

网上搜索

1.2创建spring.xml文件放到src下面

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

</beans>

写入以上代码到xml文件中

测试类：

 ClassPathResource rs = new  ClassPathResource("spring.xml"); //找到项目中的spring.xml
	 XmlBeanFactory beanFactory = new XmlBeanFactory(rs); //加载当前的xml文件且构建出一个bean工厂
	类名：car
    Car car1 = (Car) beanFactory.getBean("car"); 
    System.out.println( car1 ); 
    
    Car car11 = (Car) beanFactory.getBean("car"); 
    System.out.println( car11 ); 

1.3Spring框架的两个主要概念

1.3.1 控制反转（IoC = Inversion of Control）

 IoC，用白话来讲，就是由容器控制程序之间的关系，而非传统实现中由程序代码直接操控。 
这也就是所谓“控制反转”的概念所在：控制权由应用代码（java代码）中转到了外部容器（spring框架的xx.xml文件）,控制权的转移,是所谓反转 

1.3.1 依赖注入（DI = Dependency Injection）

所谓依赖注入，即组件(可以理解是javabean)之间的依赖关系由容器(spring框架的spring.xml文件)在运行期决定，形象的来说，即由容器（spring.xml）动态的将某种依赖关系注入到组件之中。

1.4注入的方式

1.4.1 设值注入

1.4.2 构造注入

1.4.3 注解注入

1.5自动装配

1.自动装配：所谓的自动装配其实是一个概念，意思是指当类中的属性需要什么样的值的时候，spring框架的容器就会给它自动的赋予什么样的值

2.自动装配的特点：虽然使用起来简单，但是降低了代码的可读性。自动装配一般应用到组件依赖不复杂的应用程序中

3.自动装配实现的手段：
1）通过XML实现自动装配
2）通过注解实现自动装配

补充模块：
Spring支持5种自动装配模式，如下：

no 　　——默认情况下，不自动装配，通过“ref”attribute手动设定。

byName ——根据Property的Name自动装配，如果一个bean的name，和另一个bean中的Property的name相同，则自动装配这个bean到Property中。

byType 　　——根据Property的数据类型（Type）自动装配，如果一个bean的数据类型，兼容另一个bean中Property的数据类型，则自动装配。

constructor ——根据构造函数参数的数据类型，进行byType模式的自动装配。

autodetect ——如果发现默认的构造函数，用constructor模式，否则，用byType模式。

2.spring框架的高级使用

2.1spring框架在web项目中的使用

1.添加jar包
2.在web.xml中配置监听器，其目的是为了启动spring框架

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

3.在WEB-INF文件夹下创建applicationContext.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 
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd" >
        
        
        
</beans>

2.2spring框架与其他框架的整合

1）每个框架还要用到自己的功能点：例如与struts2框架整合那么struts2的传参，转向，标签取值还要用到

2）整合就是让spring接受和融合其他框架，为什么这样说呢，因为spring框架主要是用来进行解耦的所以所谓的整合就是将别的框架与spring框架实现对接和协调配合工作

3）spring能不能与其他的框架的整合，这个要看被整合的框架是怎样的，同时也要看spring框架是否有支持的接口，一般的框架都能与spring框架整合，因为他们都要实现解耦

2.2.1与Struts2的整合

导读模块：所谓的整合，就是将两个框架都应用到项目中，且要实现协同工作

步骤
1)添加两个框架的jar包
2)在web.xml中配置：
filter:启动Struts2框架
listener:启动Spring框架
3)在src下直接创建struts.xml
在WEB-INF下创建applicationContext.xml
4)创建UserAction,UserService ,UserServiceImpl
5.)将D层注入给M层,将M层注入给C 层

2.3一致的DAO支持抽象类

导读模块：为了便于以一种一致的方式使用各种数据访问技术，如JDBC、JDO和Hibernate， Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，通过它们你可以 获得与数据访问技术相关的数据源和其他配置信息。
换言之：Spring提供的有能够整合好多种数据库持久化操作的框架或者技术

其中常用到的有： 、
1）JdbcDaoSupport ： JDBC数据访问对象的基类。 需要一个DataSource，同时为子类提供 JdbcTemplate。

2）HibernateDaoSupport ： Hibernate数据访问对象的基类。 需要一个SessionFactory，同时为子类提供 HibernateTemplate。
也可以选择直接通过 提供一个HibernateTemplate来初始化， 这样就可以重用后者的设置，例如SessionFactory， flush模式，异常翻译器（exception translator）等等。

3）JdoDaoSupport ： JDO数据访问对象的基类。 需要设置一个PersistenceManagerFactory， 同时为子类提供JdoTemplate。

4）JpaDaoSupport ： JPA数据访问对象的基类。 需要一个EntityManagerFactory，同时 为子类提供JpaTemplate

2.4.事务和事务原理

事务有哪些特性 ：

		**原子性**：一个事务是一个不可分割的工作单位，事务中包括的操作要么全执行 要么全不执行
		   **一致性**：事务必须是使数据库从一个一致性状态变成另一个一致性状态
		   **隔离性**：一个事务的执行不受其他事务的干扰
		   **持久性**：一个事务一旦提交，他对数据库中数据的改变是永久性的

事务产生的原理是： 是基于AOP这种技术
AOP是什么: AOP面向切面编程是OOP的延续，它是一种可以通过预编译方式和运行期间动态代
理来实现在不修改源代码的情况下给程序动态 地统一添加功能的一种技术，它是软件工程“开-闭”原则的一种实现
体现AOP的地方：事务管理，日志管理

使用流程:

						1)添加jar包:    org.springframework.aop-3.0.6.RELEASE.jar
                          2)创建被监控的类和接口:Man,ManImpl
                          3)建立事件拦截器。（通知):采用的是前置通知（MethodBeforeAdvice）
                          4）配置通知和被通知的JavaBean
                          5）测试

2.5Spring之AOP

1.面向切面编程（Aspect Oriented Programming）提供了另一种角度来思考程序的结构，通过这种方式弥补面向对象编程(Object Oriented Programming)的不足。除了类以外，AOP提供了切面，切面对关注点进行模块化，例如横切多个类型和对象的事务管理（这些关注点术语通常称作横切(crosscutting)关注点）。Spring AOP是Spring的一个重要组件，但是Spring IOC并不依赖于Spring AOP，这意味着你可以自由选择是否使用AOP，AOP提供了强大的中间件解决方案，这使得Spring IOC更加完善。我们可以通过AOP来实现日志监听，事务管理，权限控制等等。

简而言之： AOP面向切面编程是OOP的延续，它是一种可以通过预编译方式和运行期间动态代 理来实现在不修改源代码的情况下给程序动态 地统一添加功能的一种技术，它是软件工程“开-闭”原则的一种实现
体现AOP的地方：事务管理，日志管理

继续进一步：AOP实现的原理：代理–>动态代理---->jdk代理或者cglib代理

回顾备注：事务的的原理的是依靠AOP
AOP的原理是依靠代理

2.AOP的一些相关概念的理解：

Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。
Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
Target（目标对象）：植入 Advice 的目标对象.。
Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程

然后举一个容易理解的例子：
看完了上面的理论部分知识, 我相信还是会有不少朋友感觉到 AOP 的概念还是很模糊, 对 AOP 中的各种概念理解的还不是很透彻. 其实这很正常, 因为 AOP 中的概念是在是太多了, 我当时也是花了老大劲才梳理清楚的.
下面我以一个简单的例子来比喻一下 AOP 中 Aspect, Joint point, Pointcut 与 Advice之间的关系.
让我们来假设一下, 从前有一个叫爪哇的小县城, 在一个月黑风高的晚上, 这个县城中发生了命案. 作案的凶手十分狡猾, 现场没有留下什么有价值的线索. 不过万幸的是, 刚从隔壁回来的老王恰好在这时候无意中发现了凶手行凶的过程, 但是由于天色已晚, 加上凶手蒙着面, 老王并没有看清凶手的面目, 只知道凶手是个男性, 身高约七尺五寸. 爪哇县的县令根据老王的描述, 对守门的士兵下命令说: 凡是发现有身高七尺五寸的男性, 都要抓过来审问. 士兵当然不敢违背县令的命令, 只好把进出城的所有符合条件的人都抓了起来.

来让我们看一下上面的一个小故事和 AOP 到底有什么对应关系.
首先我们知道, 在 Spring AOP 中 Joint point 指代的是所有方法的执行点, 而 point cut 是一个描述信息, 它修饰的是 Joint point, 通过 point cut, 我们就可以确定哪些 Joint point 可以被织入 Advice. 对应到我们在上面举的例子, 我们可以做一个简单的类比, Joint point 就相当于 爪哇的小县城里的百姓,pointcut 就相当于 老王所做的指控, 即凶手是个男性, 身高约七尺五寸, 而 Advice 则是施加在符合老王所描述的嫌疑人的动作: 抓过来审问.
为什么可以这样类比呢?

Joint point ： 爪哇的小县城里的百姓: 因为根据定义, Joint point 是所有可能被织入 Advice 的候选的点, 在 Spring AOP中, 则可以认为所有方法执行点都是 Joint point. 而在我们上面的例子中, 命案发生在小县城中, 按理说在此县城中的所有人都有可能是嫌疑人.

Pointcut ：男性, 身高约七尺五寸: 我们知道, 所有的方法(joint point) 都可以织入 Advice, 但是我们并不希望在所有方法上都织入 Advice, 而 Pointcut 的作用就是提供一组规则来匹配joinpoint, 给满足规则的 joinpoint 添加 Advice. 同理, 对于县令来说, 他再昏庸, 也知道不能把县城中的所有百姓都抓起来审问, 而是根据凶手是个男性, 身高约七尺五寸, 把符合条件的人抓起来. 在这里 凶手是个男性, 身高约七尺五寸 就是一个修饰谓语, 它限定了凶手的范围, 满足此修饰规则的百姓都是嫌疑人, 都需要抓起来审问.

Advice ：抓过来审问, Advice 是一个动作, 即一段 Java 代码, 这段 Java 代码是作用于 point cut 所限定的那些 Joint point 上的. 同理, 对比到我们的例子中, 抓过来审问 这个动作就是对作用于那些满足 男性, 身高约七尺五寸 的爪哇的小县城里的百姓.

Aspect:：Aspect 是 point cut 与 Advice 的组合, 因此在这里我们就可以类比: “根据老王的线索, 凡是发现有身高七尺五寸的男性, 都要抓过来审问” 这一整个动作可以被认为是一个 Aspect

或者可以类比理解：打卡的这个事
上课之前打卡：前置通知
上课之后打卡：后置通知
打卡没成功申请补卡：异常通知
上午上课前打卡和下课后打卡：环绕通知
3.Spring系列之AOP实现的两种方式
AOP常用的实现方式有两种，一种是采用声明的方式来实现（基于XML），一种是采用注解的方式来实现（基于AspectJ）。

4.通知(Advice)的类型：

前置通知（Before advice）：在某个连接点（Join point）之前执行的通知，但这个通知不能阻止连接点的执行（除非它抛出一个异常）。
返回后通知（After returning advice）：在某个连接点（Join point）正常完成后执行的通知。例如，一个方法没有抛出任何异常正常返回。
抛出异常后通知（After throwing advice）：在方法抛出异常后执行的通知。
后置通知（After（finally）advice）：当某个连接点（Join point）退出的时候执行的通知（不论是正常返回还是发生异常退出）。
环绕通知（Around advice）：包围一个连接点（Join point）的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。