Spring框架核心理解 (未完成)

什么是Spring ?

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作
Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。
框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。
Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。
从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。
简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

1. Spring 的IOC容器(控制反转)及实现原理 (工厂模式+xml)

IOC -- Inverse of Control , 控制反转,将对象创建权反正给spring !!! 使用IOC可以解决的程序耦合性高的问题！！ 将new对象大大减少。

IOC解耦合，这个问题，我一直想不通。
1. 如果说用xml配置，确实只需要加代码，然后xml配置bean可以实现不修改代码。
2. 用new 对象的方式,一样可以也只加代码,淘汰之前的代码，只是看着有些臃肿，销毁对象耗费资源,可xml方式,直接放弃之前的接口,一样臃肿。
3. 如果用注解的方式，注解是直接写在代码里面的，若要修改肯定会改代码。所以跟很多人说IOC就一定解耦的理念对不。
4. 如果把上面的想法都抛掉，从ioc的设计角度理解，所有的bean交给IOC容器管理，好像还是有点解耦和的感觉，但还是证据不充分。

可能是理解的角度不对吧，比如异步通信mq,这都说是解耦和吧，这里的解耦和就是从程序运行的角度理解。
当你把数据传给mq后，跟程序本身就没有关系了，实现了解耦和，如果从这个角度理解ioc的解耦和，我们把所有的Bean交给IOC容器管理，
也就是对象的创建权跟我们写的代码本身没有关系，这样实现了解耦。

感觉自己居然能说服自己，我也真是服了,就是不知道理解对不对。

IOC 测试使用：
创建一个web工程。
引入spring的IOC的必须jar包
    spring-core-4.2.4.RELEASE.jar
    spring-beans-4.2.4.RELEASE.jar
    spring-context-4.2.4.RELEASE.jar
    spring-expression-4.2.4.RELEASE.jar

编写配置文件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"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">
	
   	<!-- 使用bean标签 -->
   	<bean id="userService" class="com.wqm.demo.UserServiceImpl">
   		<property name="name" value="小凤"/>
   	</bean>

</beans>

编写代码 （接口，接口实现类，测试类）

接口：
public interface UserService {
	
	public void sayHello();

}

实现类：
public class UserServiceImpl implements UserService {
	
	private String name;
	public void setName(String name) {
		this.name = name;
	}
	
	public void sayHello() {
		System.out.println("Hello Spring!! "+name);
	}
	
	public void init(){
		// 编写任何代码
		System.out.println("初始化...");
	}
	
	public void destory(){
		System.out.println("销毁...");
	}
}

测试类：

测试类：
public class Demo {
	
	/**
	 * 原来的方式
	 */
	@Test
	public void run1(){
		// 创建实现类
		UserServiceImpl us = new UserServiceImpl();
		us.setName("美美");
		// UserService us = new UserServiceImpl();
		us.sayHello();
	}
	
	/**
	 * 使用的是Spring框架的方式，可以加载多个配置文件
	 */
	@Test
	public void run2(){
		// 创建工厂，加载核心配置文件
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");
		// 从工厂中获取到对象
		UserServiceImpl usi = (UserServiceImpl) ac.getBean("userService");
		// 调用对象的方法执行
		usi.sayHello();
	}
	
	/**
	 * 接口的方式
	 */
	@Test
	public void run3(){
		// 创建工厂，加载核心配置文件
        这个是新工厂，spring目前用这个工厂：
        现在是当加载applicationContext.xml的时候，就已经创建了Bean对象的实例，还有一些其他功能
           * 时间传递
           * 自动装配
           * 各种不同应用层的Context实现
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		// 从工厂中获取到对象
		UserService us = (UserService) ac.getBean("userService");
		// 调用对象的方法执行
		us.sayHello();
	}
	
	/**
	 * 老的工厂版本 BeanFactory
	 */
	@Test
	public void run4(){
        这里说一下老工厂方式：老工厂采用延迟加载的方式，第一次getBean的时候才会初始Bean
		BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
		UserService us = (UserService) factory.getBean("userService");
		us.sayHello();
	}
	
	/**
	 * 演示销毁的方法
	 */
	@Test
	public void run5(){
		// 创建工厂，加载核心配置文件
		ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		// 从工厂中获取到对象
		UserServiceImpl usi = (UserServiceImpl) ac.getBean("userService");
		// 调用对象的方法执行
		usi.sayHello();
		
		// 关闭工厂，工厂关闭了，对象都会销毁
		ac.close();
	}
	
	
	/**
	 * 依赖注入概念的解释：
	 */
	@Test
	public void run6(){
		// 创建工厂，加载核心配置文件
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		// 从工厂中获取到对象
		UserService us = (UserService) ac.getBean("userService");
		// 调用对象的方法执行
		us.sayHello();
	}
	
}

 2. Spring 的AOP(面向切面编程)技术及实现原理 (动态代理)

1. 什么是AOP的技术？
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程
AOP是一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构
AOP最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范
通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术
AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率
	
2. AOP:面向切面编程.(思想.---解决OOP遇到一些问题)
3. AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存）
	
4. 为什么要学习AOP
可以在不修改源代码的前提下，对程序进行增强！！	

3. Spring 的事务管理

4. Spring 的DI (依赖注入)

DI -- Dependency Injection，依赖注入，在Spring框架负责创建Bean对象时，动态的将依赖对象注入到Bean组件中！！

5. Spring 的Bean的作用范围及生命周期