一、Spring详细概括

1、spring是一个开源的轻量级(体积小、jar包少、不需要依赖其他jar)的JavaEE框架
2、spring核心部分IOC、AOP（1）IOC：创建对象由ioc负责不需要New对象（2）Aop：不修改源代码就可以实现对功能的添加
3、Spring特点：（1）方便解耦，简化开发（2）方便整合框架（3）降低JavaEE Api的使用难度（例：对JDBC进行封装）

二、IOC底层原理

1、简单使用

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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="user唯一标识" class="cn.dao.User" /></bean>实体类：public void user{public void add(){System.out.println("wdnmd");}}测试：public static void main(String[] args) throws Exception {ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");//加载配置文件User us = ctx.getBean("user唯一标识",User.class);//对象创建成功us.add();}

2、IOC介绍

控制反转，对象的控制权移交给外部容器。解耦。IOC通过 XML解析、工厂模式、反射进行管理。例：（Start调用User的add方法）1、原始（耦合太高，User中add方法变化，Start调用里要跟着变而且调用一次new一次）User us = new User();us.add();2、工厂模式（为了解耦而出现）(1)、创建UserFactory类public void UserFactory(){public static User getUser(){return new User();}}(2)、调用User use = UserFactory.getUser();use.add();3、IOC（最终进化版 XML解析+工厂模式+反射）(1)、xml文件进行配置<bean id="唯一标识" class="zz.User"/>(2)、创建工厂public void UserFactory(){public static User getUser(){String classvalue = class属性值	       //1、XML解析。Class clazz = Class.forName(classValue)//2、反射创建对象。return (User)clazz.newInstance();}}

3、IOC重要接口

1、IOC思想基于IOC容器完成，IOC容器底层就是对象工厂2、Spring提供两种IOC容器实现方式：（两个接口）
都是加载配置文件==》获取配置创建对象	(1)、BeanFactory：（最基本方式，Spring自带接口，一般Spring内部使用不提供开发人员使用）(2)、ApplicationContext：（BeanFactory的子接口，提供更多更强大的功能，一般开发人员使用）区别：BeanFactory加载配置文件不会去创建对象，获取时才创建对象。ApplicationContext会把加载配置文件的对象创建。好处：放在Tomcat时启动项目时就把耗时耗资源的操作加载出来，BeanFactory不行用的时候才加载ApplicationContext接口有实现类(1)、FileSystemXmlApplicationContext：盘符路径(2)、ClassPathXmlApplicationContext：类路径

4、IOC操作bean管理（xml基本就不用基本都用注解撒）

bean管理具体指的是两个操作创建对象 和注入属性
而且bean管理有两种实现方式基于XML配置文件方式和基于注解方式

(1)、IOC操作bean管理（基于XML实现bean管理）

DI：依赖注入（是IOC的一部分）
1、xml方式创建对象<bean id="user" class="cn.entity.User"/>id属性：唯一标识		class：类路径				
注：默认也是执行类无参构造方法2、xml方式注入属性(1)、有参构造注入（提供有参构造）<bean id="user" class="cn.entity.User">//通过定义单参构造方法为userserviceimpl的dao属性赋值//外部bean注入属性<constructor-arg><ref bean="引用bean"/></constructor-arg><constructor-arg name="name" value="有参构造注入"></constructor-arg></bean>//内部bean太鸡肋有印象就行。(2)、set注入（提供set方法）<bean id="user" class="cn.dao.User"><property name="name" value="WDNMD"></property></bean>(3)、P命名空间注入(需要引入   xmlns:p="http://www.springframework.org/schema/p")<bean id="user" class="cn.dao.User" p：name="WDNMD"></bean>注：p:属性名=“属性值”		p：属性名-ref=“nean的id”(4)、注入不同的数据类型1、简单类型、特殊字符<property><value><![CDATA[$&#$@##@$]]></value></property>2、List<bean id="user" class="entity.User"><property name="hobbies"><list><value>1</value><value>2</value></list></property></bean>3、Map<bean id="user" class="entity.User"><property name="hobbies"><map><entry><key><value>键</value></key><value>值</value></entry></map></property></bean>4、空字符串注入<value></value>	<bean name="user"><null/></bean>（5）、级联赋值（撕~好多鱼）方法1：<bean id="teachers" class="entity.teacher"><property name="对象(一对多)" ref="引用bean的唯一标识"></property></bean><bean id="引用bean的唯一标识" class="entity.students"><property name="student" value="张三"></property></bean>方法2：<bean id="teacher" class="entity.teacher"><property name="对象(一对多)" value="引用bean的唯一标识"></property>//需要提供get方法<property name="student.student" value="张三"></property></bean>

(2)、IOC操作bean管理（Factorybean）

Spring有两种bean
1、普通bean(bean的class定义类型和返回类型必须一致)

2、工厂(Factory为了创建bean过程不被暴漏)bean(bean的class定义类型和返回类型可以一致)

工厂bean使用方法
第一步：创建类，让此类成为工厂类，实现Factory接口即可
第二部：实现接口中的方法，在方法中定义bean的返回类型public class Mybean implents Factory<随意类型>(){public 随意类型 getObject()throws Execption{随意类型 名字 = new 随意类型();名字.属性="赋值";return 名字;}}XML中：<bean id="mybean" class="conf.Mybean"></bean>测试： ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");//容器初始化随意类型 名字 = ctx.getBean("mybean",随意类型.class);//对象创建成功

(3)、IOC操作bean管理(bean作用域和生命周期)

作用域：bean默认是单例模式，可以设置成多例模

1、设置单例 || 多例单例：（默认，加载配置文件时就创建）<bean id="wdnmd" class="WDNMD" scope="singleton"</bean>多例：(每次请求创建新的实例bean，getbean获取时才创建)<bean id="wdnmd" class="WDNMD" scope=""prototype></bean>2、生命周期（1）通过构造器创建bean实例（无参构造）（2）为bean的属性设置值||引用（set方法设置）（3）调用bean的初始化方法（自己写方法名随意）xml中：<bean id="wdnmd" class="entity.WDNMD" init-method="initmethod"></bean>实体类中：public void initmethod(){System.out.Print("bean初始化");}（4）获取bean对象随意类型 名字 = ctx.getBean("mybean",随意类型.class);//对象创建成功（5）容器关闭，销毁bean（自己写方法名随意）xml中：<bean id="wdnmd" class="entity.WDNMD" destory-method="destorymethod"></bean>实体类中：public void destorymethod(){System.out.Print("bean销毁");}//测试类中//手动销毁，销毁后才会调用上面销毁方法加载配置文件所创建的对象.close();第三步前后还有一个操作把bean实例传递给后置处理器。

(4)、IOC操作bean管理(bean自动装配)

byName：根据名称自动装配（）<bean id="teacher" class="entity.teachers" autowrie="btName"></bean>//id必须对应teacher中的student属性名称	<bean id="student" class="entity.student"></bean>
byType：根据类型自动装配还是别用了太鸡肋了跟上面一样类型一致就行，但是多个bean他就不知道用那个了

(5：重点)、IOC操作bean管理(基于注解实现bean管理)

注解简化xml配置

注：所有注解都是创建bean对象。@MapperScan扫描指定包下注解，想要用注解需要开启扫描，不然Spring不知道做什么
@MapperScan=<context:component-scan base-package=”com.eric.spring”>(xml方式配置)@component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。@component默认值为(value="指定类的名字把首字母小写")@Service用于标注业务层组件@controller用于标注控制层组件@Repository用于标注数据访问组件，即DAO组件@Configuration标注此类为配置类加载配置类：ApplicationContext con = new AnnotationConfigApplicationContext(配置类名字.class);常用的注解注入@Autowired：根据属性类型进行注入			@Qualifier：根据属性名称注入@Resource：可以根据类型也可以根据属性注入	@Value：普通属性注入（标注在属性上）区别：多个实现类情况下@Autowired+@Qualifier（value="指定一个实现类首字母小写"）而Resource就牛逼了多个实现类@Resource(name="指定一个实现类首字母小写")Java提供@Resource	Spring提供@Autowired和@Qualifier

三、AOP的底层学习

AOP为面向切面编程（不改变源代码，为项目添加新功能）,对业务逻辑各个部分进行隔离，
从而降低耦合度提高可重用性

1、底层原理

AOP底层使用动态代理1、动态代理有两种情况（1）、有接口，使用JDK动态代理（创建接口实现类代理实现增强）//调用Proxy中的newProxyInstance方法（有三个参数）//参数一：类加载器  参数二：增加类方法的接口（支持多接口） 参数三：增强的部分	1、创建接口public class Subject(){	public interface history(int age){					return age;}}2、实现接口public class SubjectImpl implements Subject(){public int history(int age){return age;}}3、创建一个代理类JDKProxy(名字按照规范即可)public class JDKProxy(){public static void main(String[]args){//创建接口代实现类代理对象Class interfaces[] = {Subject.class};SubjectImpl Subjects = new SubjectImpl();Subject sub =(Subject)Proxy.newProxyInstance(JDKProxy.class.getClassLoder,interfaces,new Strong(Subjects));}			}4、创建一个类实现InvocationHandler接口//把创建的是谁的代理对象，就传谁过来private Object obj;public Subject(Object obj){this.obj=obj}public class Strong implements InvocationHandler(){@Override//根据method判断增强那个方法，如果方法a，如果方法bpublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//写增强逻辑//方法执行前System.out.print("方法名称："+method.getName()+"传递的参数："+Arrays.toString(args));//执行原有方法Object res = method.invoke(obj,args);//方法之后System.out.print(obj);return res;}	    }（2）、无接口，使用CGLIB动态代理（创建当前类子类的代理对象）

2、AOP术语

(1)、连接点类的哪些方法可以被增强，这些方法就叫做连接点(2)、切入点实际被真正增强的方法，叫做切入点(3)、通知(增强)实际增强的逻辑部分问叫做通知。（有5种类型）1、前置通知方法之前做的通知2、后置通知方法之后做的通知(有异常就不通知)3、环绕通知方法前后都做的通知4、异常通知出现异常时做的通知5、最终通知不管是否有异常都会通知(4)、(切面)把通知应用到切入点的过程叫做切面

3、AOP准备操作

Spring一般基于AspectJ实现AOP操作
AspectJ是Spring的组成部分，独立AOP框架，一般把AspectJ和Spring一起使用进行AOP操作,基于AspectJ实现AOP有两种方式

1、xml方式      2、注解方式

//切入点表达式（为了知道对那个类中那个方法增强）
语法：execution([权限修饰符][返回类型][类全路径][方法名称]([参数列表]))
例：	//单个方法					//所有方法直接.*execution(* 空格 [代表匹配所有修饰符]nb.Dao.UserDao.add(...[代表参数列表]))1、通过注解实现AOP（AspectJ,要开启注解扫描@MapperScan）(1)、创建类，再类里定义方法@Compomentpublic class wdnmd(){public void dnmd(){System.out.printl("WDNMD");}}(2)、创建增强类并创建方法@Compoment@Aspectpublic class StrongProxy(){//前置通知@Before(execution(* 类路径.需要增强的方法名称(..)))public void before(){System.out.printl("前置增强！");}}(3)、配置<?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/beansxmlns:context="http://www.springframework.org/schema/context" http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"><!--开启注解扫描，可以扫描com.mq包下的所有bean  --><context:component-scan base-package="com.mq"/><!-- 启动AspectJ支持 -->  <aop:aspectj-autoproxy /> 		     </beans> (4)、配置不同类型通知//什么类通知在通知方法上加什么类型注解//前置通知@Before(execution(* 类路径.需要增强的方法名称(..)))//方法后执行		//返回值之后执行			//异常通知		@After(最终通知)		@AfterReturning(后置通知)	@AfterThrowing		//环绕通知@Around(5)、相同切入点抽取@Pointcut(value="execution(* 空格 [代表匹配所有修饰符]nb.Dao.UserDao.add(...[代表参数列表])")public void pubs(){}//通知就可以简化@Before(value="pubs()")(6)、多个增强类对同一个方法进行增强，设置增强优先级//在代理类加@Order(0-~ 0的优先级最高)实现增强的优先级

四、事务(不包含查询)

事务是数据库操作最进本的单元，逻辑上的一组操作,要么都成功，一个是失败全部失败

1、事务概念

(1)、原子性要么都成功，一个失败全部失败
(2)、一致性操作前后总量一致
(3)、隔离性两人同时间操作同一条数据不会产生影响
(4)、持久性对数据库中的数据的改变就是永久性的

2、Spring中事务的使用

(1)、开启事务
(2)、逻辑操作
(3)、事务(Spring有两种事务方式)1、编程式事务管理try{//事务开启//编写业务逻辑//事务提交}catch(Execption e){//事务回滚}2、声明式事务管理(又分为两种)(1)、xml方式（知道有就好。。。。。就不写了。。。。嗯。。。。）(2)、注解方式步骤一、在spring配置文件中引入<tx:>命名空间<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.0.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-2.0.xsd"><bean id="defaultTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><!-- 使用annotation定义事务 --><tx:annotation-driven transaction-manager="defaultTransactionManager" proxy-target-class="true"/></beans>步骤二、在service的类 || 方法上添加事务注解(@Transactional)//添加到类上所有方法添加事务，添加方法上单个方法添加事务	

3、Spring中事务参数详解

事务参数

属性	类型	描述
value	String	可选的限定描述符，指定使用的事务管理器
propagation	enum: Propagation	可选的事务传播行为设置
isolation	enum: Isolation	可选的事务隔离级别设置
readOnly	boolean	读写或只读事务，默认读写
timeout	int (in seconds granularity)	事务超时时间设置
rollbackFor	Class对象数组，必须继承自Throwable	导致事务回滚的异常类数组
rollbackForClassName	类名数组，必须继承自Throwable	导致事务回滚的异常类名字数组
noRollbackFor	Class对象数组，必须继承自Throwable	不会导致事务回滚的异常类数组
noRollbackForClassName	类名数组，必须继承自Throwable	不会导致事务回滚的异常类名字数组

(1)、传播设置：(propagation )Spring在TransactionDefinition类中定义了以下7种传播特性PROPAGATION_REQUIRED：如果不存在外层事务，就主动创建事务；否则使用外层事务PROPAGATION_SUPPORTS：如果不存在外层事务，就不开启事务；否则使用外层事务PROPAGATION_MANDATORY：如果不存在外层事务，就抛出异常；否则使用外层事务PROPAGATION_REQUIRES_NEW：总是主动开启事务；如果存在外层事务，就将外层事务挂起PROPAGATION_NOT_SUPPORTED：总是不开启事务；如果存在外层事务，就将外层事务挂起PROPAGATION_NEVER：总是不开启事务；如果存在外层事务，则抛出异常PROPAGATION_NESTED：如果不存在外层事务，就主动创建事务；否则创建嵌套的子事务示例：@Transactional(propagation=PROPAGATION.REQUIRED)(2)、隔离级别（isolation 解决并发时出现问题）：多事务操作之间不会产生影响 不使用有三个问题：脏读：读取到了别的事务回滚前的数据，例如B事务修改数据库X，在未提交前A事务读取了X的值，而B事务发生了回滚。不可重复读：一个事务在两次读取同一个数据的值不一致。例如A事务读取X，在中间过程中B事务修改了X的值，事务A再次读取X时值发生了改变。幻读：查询得到的数据条数发生了改变，例如A事务搜索数据时有10条数据，在这时B事务插入了一条数据，A事务再搜索时发现数据有11条了。参数可以使用的值：READ-UNCOMMITTED：未提交读（脏读、不可重复读、幻读）READ-COMMITTED：已提交读（不可重复读、幻读），大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。REPEATABLE-READ（mysql默认）：可重复读（幻读），保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。SERIALIZABLE：串行化最严格的级别，事务串行执行，资源消耗最大示例：@Transactional(isolation=Isolation.REPEATABLE-READ)(3)、超时时间(timeout)//事务在规定时间内提交，否则进行回滚。默认为-1单位秒示例：@Transactional(timeout="5")(4)、是否只读(readOnly)	//默认为false，如果为true则只能进行查询操作示例：@Transactional(readOnly=true || false)(5)、异常回滚(rollbackFor )//出现那些异常进行回滚示例：@Transactional(rollbackFor=Execption)(6)、异常不回滚(noRollbackFor)//出现那些异常不进行回滚示例：@Transactional(norollbackFor=Execption)