目录
一、Spring概述
1、Spring概念
2、Spring体系结构
二、控制反转IOC
1、 了解Bean和工厂类
2、Spring实现IOC步骤
3、spring创建对象的三种方式
4、Spring中Bean对象的作用域
5、Spring中Bean对象的生命周期
三、注入DI
1、注入的方式
2、利用注解管理spring
四、面向切面AOP
1、AOP概述
2、AOP使用场景
3、AOP实现分类
4、SpringAOP
五、配置文件、注解式配置
1、纯配置文件配置
2、半注解半配置文件配置
3、纯注解式配置
六、spring事务管理
1、spring和事务有关的接口
2、事务的7个传播行为
3、事务的4个隔离级别
4、使用注解式管理事务
5、全注解管理事务
简单一句话：spring是一个容器，它是为了更好的管理对象（对象的实例化和生命周期的管理）。
它有两大核心：IOC(Inverse Of Control控制反转）和AOP(aspect oriented programing，面向切面编程)
Spring 是模块化的，允许你只挑选和选择适用于你的模块。
四大核心容器
| 核心容器 | |
|---|---|
| spring-core | 提供了框架的基本组成部分，包括 IoC 和依赖注入功能。 |
| spring-beans | 提供 BeanFactory，工厂模式的微妙实现，它移除了编码式单例的需要，并且可以把配置和依赖从实际编码逻辑中解耦。 |
| spring-context | 建立在由 core和 beans 模块的基础上建立起来的，它以一种类似于 JNDI 注册的方式访问对象。ApplicationContext 接口是 Context 模块的焦点 |
| spring-expression | 提供了强大的表达式语言，用于在运行时查询和操作对象图。 |
Spring的IOC：Inverse Of Control（控制反转），让spring去创建对象，这就是控制反转的意思！spring创建dao、service对象的原理类似于我们自己写的（反射+配置文件）的方式。
它的作用就是解耦，降低程序之间的依赖程度，但是是不能完全解除这种依赖的关系。
1.1 Bean
Bean 是一个被实例化，组装，并通过 Spring IoC 容器所管理的对象。 也就是说，bean并不是程序员编辑的，而是程序运行时，由spring通过反射生成的。
简单来说，Bean就是有可重用特性的组件（比如说Dao和Service），而JavaBean就是用java语言写的具备可重用特性的组件。
Bean 与 Spring 容器的关系
1.2 工厂类
首先要谈到工厂模式，工厂模式（Factory Pattern）就是一个创建对象的接口。不同的子类可以创建不同的对象。 工厂模式是Java的一种创建性的设计模式。
Spring有两个工厂类（容器接口），分别为BeanFactoryg（旧版本，也是顶层接口）和ApplicationContext （新版本）。他们两个的区别就是是否懒加载。BeanFactory是懒加载，当调用getBean方法的时候，才会创建对象，而ApplicationContext在加载配置文件的时候，就会将Spring管理的类实例化。
ApplicationContext: 配置文件加载完成，对象就创建完成了，立刻创建对象的方式，单例。 BeanFactory 的子接口，也被称为 Spring 上下文
ClassPathXmlApplicationContext: 加载的是类路径下的配置文件，常用
FileSystemXmlApplicationContext： 加载磁盘上的任意位置的配置文件， 提供给构造器 XML 文件的完整路径
AnnotationConfigApplicationContext: 注解
BeanFactory（顶层接口），延迟创建对象，当使用getBean方法获取对象时，才会创建对象，多例。常用语安卓，省内存。
XmlBeanFactory： 这个容器从一个 XML 文件中读取配置元数据，由这些元数据来生成一个被配置化的系统或者应用
public static void main(String[] args) {
//1.ApplicationContext 即时加载 配置文件加载完成之后就创建对象了
//创建容器，单例执行初始化
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");// 加载配置文件
AccountService accountService = (AccountService) applicationContext.getBean("service2");// 创建对象
System.out.println(accountService);
//关闭容器,单例执行销毁 调用getBean的时候才创建对象
((ClassPathXmlApplicationContext)applicationContext).close();
// 2.BeanFactory ---延迟加载
Resource resource = new ClassPathResource("bean.xml");// 加载配置文件
BeanFactory beanFactory = new XmlBeanFactory(resource);
AccountService accountService1 = (AccountService) beanFactory.getBean("service2");// 创建对象
System.out.println(accountService1);
}
加入依赖，spring-context
写dao、service层，功能层
创建spring配置文件，将所需要实例化的类配置在配置文件中
从spring容器中利用反射创建对象并获取对象
用默认的构造方法创建对象
实例工厂负责创建对象
静态工厂负责创建对象
| scope | 说明 |
|---|---|
| singleton | 单例（默认） |
| prototype | 多例，每次调用都返回一个新的对象，相当于new一个新的对象。 |
| request | 请求范围内有效 |
| session | 会话范围内有效 |
| global-session | 集群环境下的范围，如果没有集群，则等价于session |
| 生命周期 | |
|---|---|
| 单例 | 实例化：容器创建时就创建了对象 |
| 活着：只要容器不关闭，就一直活着 | |
| 销毁：容器关闭了，对象就销毁了 | |
| 多例 | 实例化：当使用getBean方法获取对象时，对象就产生了 |
| 活着：只要一直使用，就一直活着 | |
| 销毁：当长时间没有使用该对象，且没有其他引用时，才等待垃圾回收器回收 |
三、注入DI
Dependency Injection 依赖注入，一个类中定义的成员变量，都是该类所依赖的，给成员变量赋值，就是注入，因为对象是spring创建的，所以给成员变量赋值也是spring进行注入的。 依赖注入仅仅是控制反转的一个具体的例子。
用构造器注入
用setXXX方法注入
用注解实现注入
p命名空间（了解即可）
西游记 红楼梦 水浒传 三国演义
1班 2班 3班 吃饭 睡觉 打豆豆 打球 99
| 注解实现注入 | 说明 |
|---|---|
| @Autowired | 按照类型注入，如果同种类型对象超过一个，会根据变量名是否等于id去找对象 |
| @Qualifier | 根据id实现注入，这个注解不能单独使用，需要和@Autowired一起使用 |
| @Resource | 按照id注入，name="" |
p命名空间
2.1 注解实现注入（见上）
2.2 注解创建对象
| 注解 | 说明 |
|---|---|
| @Component | 通用注解，了解即可。可以创建任何类型的对象，等价于之前用标签创建对象的方式，使用注解创建的对象的id默认是类名的首字母小写，自己指定id：@Component([value=]"accountService") |
| 一般用以下三种 | 使用注解创建的对象的id默认是类名的首字母小写，自己指定id([value=]"accountService") |
| Controller | 控制层 |
| Service | 业务层 |
| Repository | dao层 |
2.3 注解控住对象的作用域
@Scope： 默认是单例：@Scope("singleton")
多例：@Scope("prototype")
2.4 注解控制对象的生命周期
@PostConstruct：初始化方法使用的注解
@PreDestroy：销毁方法使用的注解
在 OOP（object oriented programing，面向对象编程） 中模块化的关键单元是类，而在 AOP中模块化的关键单元是方面。AOP 帮助你将横切关注点从它们所影响的对象中分离出来，然而依赖注入帮助你将你的应用程序对象从彼此中分离出来。 所谓切面，相当于应用对象间的横切点，我们可以将其单独抽象为单独的模块。
AOP：aspect oriented programing，面向切面编程， 通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。 AOP 要达到的效果是，保证开发者不修改源代码的前提下，去为系统中的业务组件添加某种通用功能。AOP 的本质是由 AOP 框架修改业务组件的多个方法的源代码
定义目标类target：需要被写入功能的类 需要切入的方法叫切入点pointcut
定义切面类aspect：该类中定义的是需要切入的功能 方法叫通知advice
把切面类中的通知切入到目标类中的切入点（织入）weaving--动态代理
Authentication 权限 Caching 缓存 Context passing 内容传递 Error handling 错误处理 Lazy loading 懒加载 Debugging 调试 logging, tracing, profiling and monitoring 记录跟踪 优化 校准 Performance optimization 性能优化 Persistence 持久化 Resource pooling 资源池 Synchronization 同步 Transactions 事务
3.1 静态代理
静态 AOP 实现， AOP 框架在编译阶段对程序源代码进行修改，生成了静态的 AOP 代理类（生成的 *.class 文件已经被改掉了，需要使用特定的编译器），比如 AspectJ。
3.2 动态代理
AOP 框架在运行阶段对动态生成代理对象（在内存中以 JDK 动态代理，或 CGlib 动态地生成 AOP 代理类），如 SpringAOP。
3.2.1 JDK动态代理
使用JDK代理，必须有接口，基于父接口的动态代理
public class AopProxy {
public static void main(String[] args) {
//创建目标类对象
UserService userService = new UserServiceImpl();
//创建切面类对象
MyAspect myAspect = new MyAspect();
//利用jdk动态代理生成代理,实现织入
UserService proxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(), userService.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
myAspect.before();
Object obj = method.invoke(userService, args);
myAspect.after();
return obj;
}
});
proxy.addUser();
}
}
运行结果：
3.2.2 cglib动态代理
没有接口的时候用这种，spring本身就支持cglib动态代理，不需要有接口，代理对象是被代理类的子类对象，基于父类的动态代理
public class CglibProxy {
public static void main(String[] args) {
//创建目标类对象，并没有父接口
UserServiceImpl userServiceImpl = new UserServiceImpl();
//创建切面类对象
MyAspect myAspect = new MyAspect();
//使用cglib生成代理对象
//创建一个增强类对象
Enhancer enhancer = new Enhancer();
//指定代理对象的类型
enhancer.setSuperclass(UserServiceImpl.class);
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
myAspect.before();
Object obj = method.invoke(userServiceImpl, objects);
myAspect.after();
return obj;
}
});
//生成代理对象
UserServiceImpl proxy = (UserServiceImpl) enhancer.create();
proxy.addUser();
}
}
运行结果同上
spring已经实现了aop，spring框架可以生成代理对象。
AOP联盟：制定了切面类的接口规范（接口）。
4.1 声明式实现（基于XML方式）
实现步骤
配置文件中配置pointcut
在java中用编写实际的aspect 类
//切面类 aspect: 在目标类中的方法中要加入的功能
//AOP联盟：制定了切面类的接口规范（接口）
public class MyAspect implements MethodInterceptor {
//环绕通知：在目标类中的切入点之前和之后切入功能
//前置通知，后置通知，异常抛出通知
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
System.out.println("开启事务");
Object obj = methodInvocation.proceed();//执行目标类对象中的方法
System.out.println("提交事务");
return obj;
}
} 针对对切入点进行相关的业务处理。
public class UserServiceImpl implements UserService {
@Override //pointcut :切入点
public void addUser() {
System.out.println("add user...");
}
@Override
public void deleteUser() {
System.out.println("delete user...");
}
@Override
public void updateUser() {
System.out.println("update user...");
}
} 测试
@Test
public void AopTest2(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean_aop2.xml");
UserService userService = (UserService) applicationContext.getBean("userService");
userService.addUser();
} 运行结果
开启事务 add user... 提交事务
4.2 注解式实现（ 基于AspectJ ）
配置文件
