spring

1.spring 四大核心组块：core --beans--context--expression，spring：轻量级开源的JavaEE框架。两大核心：IOC和Aop.

2.bean配置对象--<bean id="01" class="包名.对象类"></beans>，再创建一个主类，写一个实现bean的方法，用ApplicationContext context =new ClassPathXmlApplicationContext("bean.xml")；
然后定义一个对象类的对象，接收context传回来的对象，利用该对象就可以调用类方法，不用new新对象。 eg： 对象类 user=context.get("id",对象类名.class)； user.method

3.IOC容器：控制反转，把创建对象过程交给Spring进行管理。底层原理：xml解析，工厂模式，反射。
工厂模式-----class A{}，class B{ Void add(){}}，class 工厂{static B getB(){return new B ()}。A通过new工厂对象获取B的对象，然后调用B的方法。降低了耦合度。

4.AOP：面向切面，不修改源码源代码进行功能增强。双击shift---Set background

5.IOC容器： 第一步：xml配置文件，配置创建对象-----<bean id="" class="类路径"></bean>。
第二部：创建工厂类---class FactoryUser{
public static User getUser(){
String classValue=class属性值 ---------xml解析
Class clazz =Class.forname(classValue)--------反射类
return（User）clazz.newInstance();--------返回反射创建对象
}
}

6.IOC(接口)：1.BeanFactory----IOC容器基本实现，spring内部接口，不提供开发人员进行使用。
：2.ApplicationContext:BeanFactory接口的子接口。在加载文件时候就会把配置文件的对象创建。 主要用ApplicationContext

7.IOC操作Bean管理 ：Bean管理指的是两个操作----Spring创建对象(<bean>)---spring注入属性（成员变量的set方法给变量赋值）
Bean管理操作方式:(1)基于xml配置文件方式实现：在<bean>标签实现
***** 注入属性值基本类型--- <property name="属性名" value="值"></property>.
***** 当属性值是类类型-------<property name="属性名" ,ref="注入对象"></property> ---------------内部bean注入属性，属性为类类型
*****

***** 注入构造函数值--------<c........... name="属性名" value=”值“></c........>
***** 注入属性值-----空值-----<property name="name" ><null/></property>---------------特殊值----- <property name="name" >
<value><![CDATA[《南京》]]></value> ----------------cdata后面没有空格 紧跟[]
</property>
***** 注入基本类型的集合-----数组,list集合,set集合注入属性操作--- <property>-<array> <value>值</v></a> </P>，<property>-<list> <value>值</v></list> </P>
<property>-<set> <value>值</v></set> </P>。。。。。。map集合-----<property>-<map> <entry key="" value=""></entry></map> </P>

***** 注入某类类型的集合<list集合>-------方法一:创建集合类型的对象，注入属性后，在向该集合通过<ref bean="">注入属性 。--<property><list><ref bean="注入的对象"></ref></list> 。
方法二：添加命名空间-- xmlns:util="http://www.springframework.org/schema/util"
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
先向该list集合存放数据，然后在调用该集合。--eg： bean2.xml--35行

***** FactoryBean(相当于类的多态)---类实现FactoryBean接口，并定义泛型类型，然后在实现接口的getObject方法中new泛型对象，并返回。 getBean时，将类名改为泛型的类。

8.Bean的作用域：一。多实例对象，scope=prototype，即每次getBean（）创建的对象不一样。 在getBeans（）才创建对象。
二。单实例(默认) scope=singleton, 每次getbean（）都是同一个对象，因为在<bean>标签配置文件时就创建了对象。
eg： <bean id="duoshili" class="factoryBean.Person" scope="prototype"></bean>
eg： <bean id="danshili" class="factoryBean.Person" scope="singleton"></bean>

9.Bean的生命周期以及(bean)的后置： 1.bean配置文件中利用构造器注入对象。
： 2.bean配置文件中注入属性。
： （3.创建一个新的类并实现BeanPostProcessor接口，重写 postProcessBeforeInitialization--初始化之前执行的方法, postProcessAfterInitialization--初始化之后执行）。
： （4.配置接口类的对象，该配置对当前配置文件的所有bean对象都作用，即所有配置bean生命周器的对象都要后置）。
： 3.在对象类中创建init-method以及destroy-method对应的方法---即初始化之前执行的方法和配置销毁的方法。--------调用初始化的方法
： 4.实例化bean对象。(初始化)
： 5.contex.close()调用销毁方法------注意close()的类型。 与配置文件路径的类型一致。

10.自动装配（xml自动注入属性-类类型）：不需要手动<property>注入，在<bean>标签里，autowire=“byname”--按照属性名称来自动注入，注入的<bean>对象id必须与属性名的名字一致。否则自动注入无法找到属性名字。
一般用注解完成自动装配。 autowire=“bytype” 唯一性---按照属性类型来自动注入，在配置属性类时，只能配置一个对象，否则自动注入无法判断注入哪个对象。

11.注解：需要导入spring-aop jar包。@Component，@Controller,@Service,@Repository --都可以注解创建对象。-功能一样
注解创建对象 1.在类上写上注解并定义value值@Component(value="")，默认是该类的首字母小写。
2.添加命名空间context：xmlns:context="http://www.springframework.org/schema/context"，
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
3.配置xml文件： <context:component-scan base-package="zhujie"></context:component-scan> ------组件扫描，多个包用逗号隔开。扫描包中包，用外层包的目录即可。
4. 实例化context，在getbean中第一个参数为注解的value。 注解创建对象完毕。

12.组件扫描： 1<context:component-scan base-package="zhujie" ></context:component-scan> -----扫描所有注解
： 2<context:component-scan base-package="zhujie" use -default-filters="false">
<context:include-filter type="annoatation" expression="org.springframework.stereotype.注解名"/>
</context:component-scan> ----------------------------------------------------includ-filter 只扫描表达式中的注解。
：3. <context:component-scan base-package="zhujie">
<context:exclude-filter type="annoatation" expression="org.springframework.stereotype.注解名"/>
</context:component-scan> ------------------------------------------------------exclude 除了表达式中的注解不扫描，其余都扫描

13.注解注入属性：1.@autowaird---根据类型注入属性 -------------------spring自带注解
：2.@Qualifier-----根据名称注入属性，和@autowaird一起使用-------------------spring自带注解
：3.@Resource-----可以根据类型注入，也可以根据属性注入----java自带注解。
：4.@value ---------注入普通类型的属性。------------------@value(value ="值")
123 注入对象类型的属性，4注入普通类型的属性。

14.完全注解开发模式（springBoot）：创建注解配置类替代xml配置文件。1.配置类@Configuration @ComponentScan（basePackages={扫描组件的包}）。
实例化context对象：ApplicationContext context=new AnnotationConfigApplicationContext(configxml.class) ;//参数填配置类-------------IDEA-springconfig

15.AOP：不通过修改源代码方式添加新的功能。登录例子说明AOP
16.AOP动态代理：1.有接口动态代理（JDK动态代理）----创建代理对象，不是实现接口new出来的对象。2.没有接口的动态代理（CGLIB动态代理）。-----创建当前类的子类的代理对象。
17.JDK实现动态代理：实现接口InvoactionHandler ，使用proxy类创建代理对象。

18.AOP操作术语：1.连接点：类里面有哪些方法可以被增强，这些方法发称为连接点。 2.切入点：实际被增强的方法叫切入点。
： 3.通知(增强):实际增强的逻辑部分称为通知。**前置通知@Before。**后置通知@After。**环绕通知@Around。**异常通知@AfterTrowing。**最终通知@AfterReturning。
： 4.切面：把通知应用到切入点的过程。

19.Aop操作：AspectJ实现AOP操作。基于xml，基于注解，引入AOP依赖AspectJ.jar，
切入点表达式：作用--知道对那个类里面的哪个方法进行增强。 语法结构：execution（[权限修饰符] [返回值类型][类全路径][方法名称]([方法的参数列表])）。
eg：对A包里B类的add方法进行增强。execution（*A.B.add（..））..表示方法的参数列表
对A包里B类所有方法进行增强 。 ----execution(*A.B*(..))
对A包里的所有类所有方法增强。----------execution（*.A .*.*(.. )）

20.注解实现对AspectJ进行操作。需要注解对象，所以需要配置xml 命名空间扫描注解，还要配置xml命名空间创建代理对象。
1.配置xml文件。xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
2.注解创建对象，并在增强方法的类上添加注解@Aspect
3.创建增强方法并添加注解表示什么类型的通知。并在注解中为value写上切入点表达式。eg@Before(value = " execution(* Aspectj.Student.move(..))")
4.正常步骤测试。

21.相同切入点的抽取：@Pointcut（value=切入点表达式）此注写在任意方法上。
多个增强类同一个方法进行增强，在增强类上加@order(int ),int值越小，增强就越先执行。

<!-- JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--注入datasource，将jdbcTemplate对象传给datasource-->
<property name="dataSource" ref="dataSource"></property>
</bean>

22.事务@Transational：eg：转账出现异常，则转账不成功，金额不会变，事务回滚。
1.xml文件配置：1.添加命名空间tx。 2.创建事务管理器（注入对象） <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
3.向事务管理器中注入数据源： <property name="dataSource" ref="dataSource"></property>
4.开启事务管理器： <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>。

@Transational可以添加在类上和方法上，添加在类上，则该类所有方法都是事务，添加到方法上，则该方法为事务。
事务方法：对数据库数据进行变化的操作（增删改）。

23.@Transational的参数配置1.propagation传播行为@Transation(propagation=Popagation.?)2.ioslation--事务的隔离级别
传播行为：多事务进行操作，有事务的方法调用没有事务的方法，或者调用和被调用的方法都有事务。----
eg：在A方法里面调用B方法。--
传播处理1.******Requred：如果A有事务，则B使用A的事务。如果A没有事务，则调用B之后创建一个新的事务。
2.*******Requred_NEW:无论A是否有事务，调用B之后都创建一个新的事务。