Spring框架知识点总结
一、Spring本质和功能
1、本质
spring本质就是一个map集合，事先创建并存储了项目中所需的全部对象，当项目中哪里需要对象了，通过键获取即可；我们把map集合称为spring容器对象，项目开发中以后不需要用new创建对象了。spring框架应用在持久层，业务层和控制层。
2、功能
（1）创建对象并根据依赖关系为属性赋值
（2）AOP思想
（3）整合3大框架
二、控制反转与依赖注入
1、控制反转(IOC)
以前对象的创建是由我们开发人员自己完成，包括依赖关系也是自己注入。 使用spring之后对象的创建以及依赖关系由spring完成创建和注入。控制反转是反转了对象的创建方式，从开发人员自己创建反转给了spring框架。通过依赖关系为对象属性赋值，解耦合才是spring真正价值所在。
2、依赖注入(DI)
控制反转另一个种名称，通过依赖关系为对象属性赋值。
注入方式：
1）set方法注入
2）构造方法注入
注入类型：
1）值类型注入 (8大基本类型，String)
2）引用类型注入(对象、数组、集合)
三、使用spring创建对象并赋值
1、spring开发4步骤:
（1）导入jar包；
（2）编程需要生成对象的类；
（3）编写spring配置文件；
（4）编写代码创建spring容器对象，获取对象。
2、如何编写applicationContext.xml配置文件
<!-- 注册对象 -->
<bean name="注册对象名" class="对象类全名" scope="signleton/prototype">
<!-- 1.基本属性赋值 -->
<property name="属性名" value="基本属性值"></property>
<!-- 2.对象属性赋值 -->
<property name="属性名" ref="注册对象名"></property>
<!-- 3.List集合属性赋值 -->
<property name="属性名">
<list>
<value>值</value>
<ref bean=""/>
</list>
</property>
<!-- 4.Map集合属性赋值 -->
<property name="属性名">
<map>
<entry key="键" value="值"></entry>
<entry key="" value-ref="值-注册对象名"></entry>
<entry key-ref="键-注册对象名" value-ref=""></entry>
</map>
</property>
<!-- 5.数组属性赋值 -->
<property name="属性名">
<array>
<value>值</value>
<ref bean="注册对象名"/>
</array>
</property>
<!-- 6.Properties集合属性赋值 -->
<property name="属性名">
<props>
<prop key="键">值</prop>
</props>
</property>
<!-- 7.构造方法注入属性 -->
<constructor-arg name="属性名" value="基本属性值"></constructor-arg>
<constructor-arg name="属性名" ref="注册对象名"></constructor-arg>
<constructor-arg name="" ref="" index="参数下标，0" type="参数类型">
</constructor-arg>
</bean>
3、spring注解开发项目5步骤:
（1）导入jar包
（2）编程需要生成对象的类
（3）在核心配置文件开启注解配置的开关
<context:component-scan base-package="包名"/> //开启注解配置的开关
（4）在类中使用注解完成配置
（5）编写代码创建spring容器对象，获取具体类对象
4、相关注解
1）注册对象---类级别
@Component("myuser")：
@Service("myuser")：业务层
@Controller("myuser")：控制层
@Repository("myuser")：持久层
2）指定单例对象还是多例对象---类级别
@Scope(scopeName="singleton")：singleton：单例对象；prototype:多例对象
3）给基本属性赋值---方法级别、属性级别
@Value("基本属性值")
4）给对象属性赋值---属性级别
@Resource(name="注册对象名")
5）给对象属性赋值---属性级别（组合使用）
@Autowired
@Qualifier("注册对象名")
6）@PostConstruct：在对象被创建后调用,对象生命周期开始方法，方法级别
7）@PreDestroy：在销毁之前调用,对象生命周期结束的方法，方法级别
四、使用spring实现AOP思想
1、AOP思想
辅助功能代码只写一遍，让一个类的多个方法或者多个类的多个方法，在运行前(后)都能执行一遍辅助功能代码，专注开发核心功能，实现辅助功能的复用。
有3种实现方式：一是过滤器Filter、二是动态代理模式、三spring框架实现
总结：横向重复，纵向抽取语句 (比喻只挥一刀砍倒多颗大树)
2、spring的AOP的底层实现原理
1）动态代理(优先):
目标对象必须要实现接口，如果没有接口将不能使用动态代理技术
2）cglib代理机制(没有接口时使用):
第三方代理技术，需要导入jar包，借助第三方类实现代理机制。目标对象不需要实现接口。可以对任何类生成代理，代理对象作为目标对象的子类。如果目标对象被final修饰.那么该类无法被cglib代理。
springAOP在底层实现了对这2种代理的封装
3、spring AOP名词解释
1）Pointcut(切入点)：目标对象中确定要进行增强的方法
2）Advice(通知)：增强的代码，需要在目标方法执行前运行的语句
3）Weaving(织入)：将通知应用到切入点的过程
4）aspect(切面)：切入点+通知
5）Target(目标对象)：目标方法所有的对象
6）Proxy(代理对象)：讲通知织入到目标方法后,形成的代理对象
通知的类别：通知用方法实现
1)前置通知：目标方法运行之前调用
2)后置通知：目标方法运行之后调用(如果目标方法发生异常则不执行)
3)环绕通知：在目标方法运行之前和之后都需要执行代码
注意:在目标方法运行前后都加代码,需要在环绕通知方法内部书写代码调用目标方法，而其他通知方法内不需要书写代码调用目标方法。
-----------------------------------------------------------------------------------------------------------
//环绕通知
public Object around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("这是环绕通知之前的部分!!");
Object proceed = pjp.proceed();//调用目标方法
System.out.println("这是环绕通知之后的部分!!");
return proceed;
}
-----------------------------------------------------------------------------------------------------------
4)异常拦截通知：目标方法运行之后调用，目标方法中抛出异常则被调用
5)最终通知：目标方法运行之后调用(无论是否出现异常都会被调用)
4、xml配置实现aop思想5步骤
（1）导入jar包
（2）定义目标类准备目标方法
（3）定义通知类准备通知方法
（4）在核心配置文件中注册目标对象，注册通知对象，用<aop:config>标签把通知织入目标方法
（5）编写代码创建spring容器对象,获取代理对象调用方法
----------------------------------------------------------------------------------------------------------
<aop:config>
<aop:pointcut expression="execution(* cn.t1.*ServiceImpl.*(..))" id="pc"/>
<aop:aspect ref="通知类的注册名称" >
<aop:before method="方法名" pointcut-ref="pc" />
<aop:after-returning method="方法名" pointcut-ref="pc" />
<aop:around method="方法名" pointcut-ref="pc" />
<aop:after-throwing method="方法名" pointcut-ref="pc"/>
<aop:after method="方法名" pointcut-ref="pc"/>
</aop:aspect>
</aop:config>
-----------------------------------------------------------------------------------------------------------
5、注解方式实现aop思想6步骤
（1）导入jar包
（2）定义目标类准备目标方法
（3）定义通知类准备通知方法
（4）在核心配置文件中，开启使用注解完成织入开关，开启注解配置的开关
<context:component-scan base-package="包名"/> //开启注解配置的开关
<aop:aspectj-autoproxy></aop:aspectj-autoproxy> //开启使用注解完成织入
（5）用注解注册目标对象和通知类对象,用注解将通知织入目标方法
（6）编写代码创建spring容器对象,获取代理对象调用方法
6、相关注解：
1）@Aspect：说明该类是一个通知类，类级别
2）@Before("execution(* com.t1.*.*(..))")：指定该方法是前置通知,并指定切入点
3）@AfterReturning("execution(* com.t1.*ServiceImpl.*(..))")：后置通知
4）@Around("execution(* com.t1.*ServiceImpl.*(..))")：环绕通知
5）@AfterThrowing("execution(* com.t1.*ServiceImpl.*(..))")：异常拦截通知
6）@After("execution(* com.t1.*ServiceImpl.*(..))")：最终通知
7）@Pointcut("execution(* com.t1.*ServiceImpl.*(..))")：配置切入点路径，方法级别
public void pc(){}
五、使用spring实现事务管理
1、事务
多个sql语句的组合，这些sql语句要么都执行，要么都不执行。功能：事务保障表中数据的准确性
2、spring框架处理事务的原理
1）spring框架在业务层处理事务
2）spring框架为了实现对各种技术进行统一的事务管理，提供事务接口TransactionManager，TransactionManager是spring中的事务管理的核心接口，称为核心事务管理器。
3）配置与事务相关的属性：可以通过改变这些属性值来配置事务
1>事务是否只读: read-only="false"
2>事务传播行为: propagation="REQUIRED"
3>事务的隔离级别: isolation="READ_COMMITTED"
4）spring框架已经提供了写好的事务管理的通知，需要进行事务管理的方法是切入点，只需要我们使用xml或注解配置把spring已经提供的通知织入切入点即可。环绕通知：负责调用TransactionManager实现类的开启事务，提交事务等方法实现事务管理。
3、xml配置方式事务管理5步骤
（1）核心配置文件中注册核心事务管理器的实现类对象，注册数据源对象，代理数据源对象
（2）定义目标类准备目标方法
（3）注册spring提供的通知对象
（4）配置通知，织入目标方法
（5）编写代码创建spring容器对象，获取代理对象，调用方法
-----------------------------------------------------------------------------------------------------------
配置通知类：
<tx:advice id="通知类对象名" transaction-manager="spring核心事物管理器" >
<tx:attributes>
<tx:method name="transfer" read-only="false" isolation="READ_COMMITTED" propagation="REQUIRED"/>
<tx:method name="save*" />
</tx:attributes>
</tx:advice>
织入：
<aop:config>
<aop:pointcut expression="execution(* cn.t1.*ServiceImpl.*(..))" id="txPc"/>
<aop:advisor advice-ref="通知类对象名" pointcut-ref=" txPc " />
</aop:config>
-----------------------------------------------------------------------------------------------------------
4、注解配置方式事务管理5步骤
（1）核心配置文件中注册核心事务管理器的实现类对象，注册数据源对象，代理数据源对象
（2）定义目标类准备目标方法
（3）开启注解管理aop事务开关
<context:component-scan base-package="包名"/> //开启注解配置的开关
<aop:aspectj-autoproxy></aop:aspectj-autoproxy> //开启使用注解完成织入
<tx:annotation-driven transaction-manager="核心事务管理器"/> //开启注解管理事务开关
（4）使用注解实现事务
（5）遍写代码创建spring容器对象,获取代理对象,调用方法
相关注解：
@Transactional(isolation= READ_COMMITTED,propagation= REQUIRED,readOnly=false)----为方法织入事务通知，方法级别
六、相关类
1、ApplicationContext:接口
包：org.springframework.context.*
功能：该接口是spring工厂对象，xml文件中注册过的所有对象都存储在本接口的实现类中，并对所有对象进行管理
方法：public Object getBean(String id)；//根据xml文件中name值从spring容器中获取实际类对象。
2、ClassPathXmlApplicationContext:实现类
包：org.springframework.context.support.*
方法：public ClassPathXmlApplicationContext(String path)；
功能：创建spring工厂对象，在创建该对象同时，自动创建xml文件注册过的所有类对象；参数：字符串，核心配置文件的路径。
3、DataSourceTransactionManager
包：(org.springframework.jdbc.datasource.*)
功能：核心事务管理器,封装了所有事务操作.提供开启事务等方法. 依赖于连接池;
4、ComboPooledDataSource
包：(com.mchange.v2.c3p0.*)
功能：c3p0数据源，不能提供事务处理
5、TransactionAwareDataSourceProxy
包：（org.springframework.jdbc.datasource.）
功能：封装数据源，可以提供事务处理
方法：public TransactionAwareDataSourceProxy(DataSource)
6、QueryRunner
包：（org.apache.commons.dbutils）
功能：dbutils构架核心处理类
方法：public QueryRunner(DataSource)
