第六章：Spring
Spring容器是Spring的核心，一切Spring bean都存储在Spring容器内，并由其通过IoC技术管理。Spring容器也就是一个bean工厂（BeanFactory）。应用中bean的实例化，获取，销毁等都是由这个bean工厂管理的。
org.springframework.context.ApplicationContext接口用于完成容器的配置，初始化，管理bean。一个Spring容器就是某个实现了ApplicationContext接口的类的实例。也就是说，从代码层面，Spring容器其实就是一个ApplicationContext。
在普通的JAVA工程中，我们可以通过代码显式new一个ClassPathXmlApplicationContext或者FileSystemXmlApplicationContext来初始化一个Spring容器。
在Web工程中，我们一般是通过配置web.xml的方式来初始化Spring容器。
1）框架特征
轻量--从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的:典型地，Spring应用中的对象不依赖于Spring的特定类。
控制反转-Spring通过一种称作控制反转(IoC)的技术促进了低耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反--不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
面向切面--Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务(例如审计(auditing)和事务(transaction)管理)进行内聚性的开发。应用对象只实现它们应该做的--完成业务逻辑--仅此而已。它们并不负责(甚至是意识)其它的系统级关注点，例如日志或事务支持。
容器--Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建--基于一个可配置原型(prototype)，你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例--以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
框架--Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能(事务管理、持久化框架集成等等)，将应用逻辑的开发留给了你。
MVC--Spring的作用是整合，但不仅仅限于整合，Spring 框架可以被看做是一个企业解决方案级别的框架。客户端发送请求，服务器控制器(由DispatcherServlet实现的)完成请求的转发，控制器调用一个用于映射的类HandlerMapping，该类用于将请求映射到对应的处理器来处理请求。HandlerMapping 将请求映射到对应的处理器Controller(相当于Action)在Spring 当中如果写一些处理器组件，一般实现Controller 接口，在Controller 中就可以调用一些Service 或DAO 来进行数据操作 ModelAndView 用于存放从DAO 中取出的数据，还可以存放响应视图的一些数据。 如果想将处理结果返回给用户，那么在Spring 框架中还提供一个视图组件ViewResolver，该组件根据Controller 返回的标示，找到对应的视图，将响应response 返回给用户。
所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。
2）不仅仅是容器
spring容器工厂：spring对所有对象都可以进行管理，然后通过单例模式创建一个全局唯一的一个实例对象，通过工厂模式在调用注入的接口时实例化对象。
Spring模式包含：单例模式和工厂模式
单例模式： a.单例模式限制了类实例的创建，但采用这种模式设计的类，可以保证仅有一个实例，并可提供访问该实例的全局访问点。b.J2EE应用的大量组件，都需要保证一个类只有一个实例，比如数据库引擎访问只有一个。c.但是更多时候，为了提高性能，程序应尽量减少Java 对象的创建和销毁时的开销。使用单例模式可避免Java 类被多次实例化。d. 为了防止单态模式的类被多次实例化，应将类的构造器设成私有，这样就保证了只能通过静态方法获得类实例。
工厂模式：a.工厂模式是根据调用数据返回某个类的一个实例，此类可以是多个类的某一个类。b.通常，这些类满足共同的规则(接口)或父类。调用者只关心工厂生产的实例是否满足某种规范，即实现的某个接口是否可供自己正常调用(调用者仅仅使用)。c.该模式给对象之间作出了清晰的角色划分，降低程序的耦合。d.接口产生的全部实例通常用于实现相同接口，接口里定义了全部实例共同拥有的方法，这些方法在不同的实现类中实现的方式不同。f.从而使程序调用者无须关心方法的具体实现，降低了系统异构的代价。
3）IOC（控制反转）与 DI（依赖注入）
IoC 不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。
其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。
IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。
DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。
IoC（Inversion of Control，控制反转）。这是spring的核心，贯穿始终。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。
Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。
IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。
4）AOP（面向切面编程）
AOP编程思想：横向重复代码，纵向抽取；就是说多个地方重复的代码可以抽取出来公用（过滤器等可以体现）
动态代理：动态代理可以体现AOP思想；对目标方法进行增强
SpringAOP开发：封装了动态代理代码（包括cglib代理），可以对任何类进行代理增强
AOP（Aspect Orient Programming），作为面向对象编程的一种补充，广泛应用于处理一些具有横切性质的系统级服务，如事务管理、安全检查、缓存、对象池管理等。AOP 实现的关键就在于 AOP 框架自动创建的 AOP 代理，AOP 代理则可分为静态代理和动态代理两大类，其中静态代理是指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强；而动态代理则在运行时借助于 JDK 动态代理、CGLIB 等在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。
Spring 的 AOP 代理由 Spring 的 IoC 容器负责生成、管理，其依赖关系也由 IoC 容器负责管理。因此，AOP 代理可以直接使用容器中的其他 Bean 实例作为目标，这种关系可由 IoC 容器的依赖注入提供。
纵观 AOP 编程，其中需要程序员参与的只有 3 个部分：
-
定义普通业务组件。
-
定义切入点，一个切入点可能横切多个业务组件。
-
定义增强处理，增强处理就是在 AOP 框架为普通业务组件织入的处理动作。
上面 3 个部分的第一个部分是最平常不过的事情，无须额外说明。那么进行 AOP 编程的关键就是定义切入点和定义增强处理。一旦定义了合适的切入点和增强处理，AOP 框架将会自动生成 AOP 代理
5）spring基础知识
spring的一些基本概念：
1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
5
6 <!-- spring：管理对象的容器 -->
7 <!-- spring IOC:控制反转，通过spring创建对象（无需手动创建） -->
8 <!-- DI：依赖注入；就是给对象的某些属性赋值 -->
9
10 <!-- 将User对象交给spring管理 -->
11 <!-- bean元素：描述需要spring管理的对象；name属性：给对象取个别名，获取对象时需要；
12 class属性：被管理对象的完整类名；id属性：与name属性一模一样，不可重复，不能使用特殊字符（因此要name）-->
13 <!-- 创建方式一：spring调用无参构造创建对象 -->
14 <!-- scope:singleton:表示单例对象，在spring容器中只会存在一个实例 -->
15 <!-- scope:prototype:表示多例对象，每次获取都会创建一个新的对象；整合struts2时必须为多例 -->
16 <!-- 生命周期方法配置init,destroy -->
17 <bean name="user" class="com.bean.User" scope="singleton" init-method="init" destroy-method="destroy"></bean>
18
19 <!-- 创建方式二：通过静态工厂的某个方法创建一个user对象 -->
20 <bean name="user1" class="com.bean.UserFactory" factory-method="createUser"></bean>
21
22 <!-- 创建方式三：实例工厂创建对象 -->
23 <bean name="user2" factory-bean="userFactory" factory-method="createUser2"></bean>
24 <bean name="userFactory" class="com.bean.UserFactory"></bean>
25
26 <!-- 模块化配置，可以导入其他spring配置文件 -->
27 <!--<import resource="applicationContext.xml"/>-->
28 </beans>
spring依赖注入方式：
1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4 xmlns:p="http://www.springframework.org/schema/p"
5 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
6
7 <!-- set方式注入 -->
8 <bean name="user" class="com.bean.User">
9 <!-- 值类型注入 -->
10 <property name="name" value="xdzy"/>
11 <property name="age" value="18"/>
12 <!-- 引用类型注入 -->
13 <property name="car" ref="car"/>
14 </bean>
15
16 <!-- 将car对象配置到spring容器 -->
17 <bean name="car" class="com.bean.Car">
18 <property name="name" value="兰博基尼"/>
19 <property name="color" value="红色"/>
20 </bean>
21
22 <!-- 构造函数注入 -->
23 <bean name="user1" class="com.bean.User">
24 <!-- 当构造方法参数位置不同，可以通过index确定参数位置 -->
25 <!-- 当构造方法参数类型不同，可以通过type确定参数类型 -->
26 <constructor-arg name="name" value="xdzy" index="0" type="java.lang.String"/>
27 <constructor-arg name="car" ref="car"/>
28 </bean>
29
30 <!-- p属性注入 -->
31 <!-- 需加入xmlns:p="http://www.springframework.org/schema/p" -->
32 <bean name="user2" class="com.bean.User" p:name="xdzy" p:age="18" p:car-ref="car"/>
33
34 <!-- spel表达式注入;可以实现动态注入 -->
35 <bean name="user3" class="com.bean.User">
36 <property name="name" value="#{user.name}"/>
37 <property name="age" value="#{user2.age}"/>
38 <property name="car" ref="car"/>
39 </bean>
40
41 <!-- 数组注入 -->
42 <bean name="cb" class="com.bean.CollectionBean">
43 <!-- 只有一个值时 -->
44 <!--<property name="arr" value="tom"/>-->
45 <!-- 多值多元素注入 -->
46 <property name="arr">
47 <array>
48 <value>xdzy</value>
49 <value>jady</value>
50 <ref bean="user3"/>
51 </array>
52 </property>
53 </bean>
54
55 <!-- 集合注入 -->
56 <bean name="cb2" class="com.bean.CollectionBean">
57 <!-- 只有一个值时 -->
58 <!--<property name="list" value="tom"/>-->
59 <!-- 多值多元素注入 -->
60 <property name="list">
61 <list>
62 <value>xdzy</value>
63 <value>jady</value>
64 <ref bean="user3"/>
65 </list>
66 </property>
67 </bean>
68
69 <!-- map注入 -->
70 <bean name="cb3" class="com.bean.CollectionBean">
71 <property name="map">
72 <map>
73 <entry key="name" value="xdzy"/>
74 <entry key="user" value-ref="user3"/>
75 <entry key-ref="user1" value-ref="user2"/>
76 </map>
77 </property>
78 </bean>
79
80 <!-- 资源注入 -->
81 <bean name="cb4" class="com.bean.CollectionBean">
82 <property name="properties">
83 <props>
84 <prop key="driverClass">com.jdbc.mysql.Driver</prop>
85 <prop key="userName">admin</prop>
86 <prop key="password">123</prop>
87 </props>
88 </property>
89 </bean>
90 </beans>
spring的通知类型：
1 package com.aspect;
2
3 import org.aspectj.lang.ProceedingJoinPoint;
4 /**
5 * @author: 肖德子裕
6 * @date: 2018/9/7 08:23
7 * @description: 通知
8 * 前置通知：目标方法运行之前
9 * 后置通知（如果出现异常不会调用）：之后
10 * 环绕通知：之前之后
11 * 异常拦截通知：出现异常调用
12 * 后置通知（无论是否出现异常都会调用）：之后
13 */
14 public class MyAdvice {
15 //前置通知：目标方法运行之前
16 public void before(){
17 System.out.println("前置通知");
18 }
19 //后置通知（如果出现异常不会调用）：之后
20 public void afterReturning(){
21 System.out.println("后置通知（如果出现异常不会调用）");
22 }
23 //环绕通知：之前之后
24 public Object around(ProceedingJoinPoint pjp) throws Throwable{
25 System.out.println("环绕通知之前部分");
26 //调用目标方法
27 Object proceed=pjp.proceed();
28 System.out.println("环绕通知之后部分");
29 return proceed;
30 }
31 //异常拦截通知：出现异常调用
32 public void afterException(){
33 System.out.println("出现异常调用");
34 }
35 //后置通知（无论是否出现异常都会调用）：之后
36 public void after(){
37 System.out.println("后置通知（无论是否出现异常都会调用）");
38 }
39 }
6）JDK动态代理与CGLIB动态代理
JDK动态代理：
1 package com.service;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Method;
5 import java.lang.reflect.Proxy;
6
7 /**
8 * @author: 肖德子裕
9 * @date: 2018/9/6 20:25
10 * @description: 动态代理
11 * 被代理对象必须要实现接口，才能产生代理对象，如果没有接口将不能使用动态代理技术
12 * 动态代理可对方法进行增强，如增加事务的打开与提交
13 * 个人理解：它是对service实现类里所有的方法进行了增强；
14 * 在不破坏原有结构的情况下，生成动态代理对象，对原有方法进行增强
15 */
16 public class UserServiceProxyFactory implements InvocationHandler {
17 private UserService us;
18
19 public UserServiceProxyFactory(UserService us) {
20 this.us = us;
21 }
22
23 public UserService getUserServiceProxy(){
24 //生成动态代理
25 UserService userProxy=(UserService) Proxy.newProxyInstance(UserServiceProxyFactory.class.getClassLoader(),
26 UserServiceImpl.class.getInterfaces(),
27 this);
28 //返回一个动态代理对象
29 return userProxy;
30 }
31
32 @Override
33 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
34 System.out.println("打开事务");
35 Object invoke=method.invoke(us,args);
36 System.out.println("提交事务");
37 return invoke;
38 }
39 }
cglib动态代理：
1 package com.service;
2
3 import org.springframework.cglib.proxy.Enhancer;
4 import org.springframework.cglib.proxy.MethodInterceptor;
5 import org.springframework.cglib.proxy.MethodProxy;
6
7 import java.lang.reflect.Method;
8 /**
9 * @author: 肖德子裕
10 * @date: 2018/9/6 20:25
11 * @description: cglib代理
12 * 可以对任何类生成代理，对目标对象进行继承代理
13 */
14 public class UserServiceProxyFactory2 implements MethodInterceptor {
15 public UserService getUserServiceProxy(){
16 //生成代理对象
17 Enhancer en=new Enhancer();
18 //对谁进行代理
19 en.setSuperclass(UserServiceImpl.class);
20 //代理要做什么
21 en.setCallback(this);
22 //创建代理对象
23 UserService us=(UserService) en.create();
24 return us;
25 }
26
27 @Override
28 public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
29 //打开事务
30 System.out.println("打开事务");
31 //调用原有方法
32 Object returnValue=methodProxy.invokeSuper(o,objects);
33 //提交事务
34 System.out.println("提交事务");
35 return returnValue;
36 }
37 }