Spring

1.优点：

　　　1：低侵入式设计

　　　2：独立于各种应用服务器

　　　3：依赖注入特点，将组件关系透明化

　　　4：降低了耦合度

　　　5：面向切面，把一些任务集中式处理

　　　6：与第三方框架良好的整合

2.Spring定义：

　　　轻量级框架当前的主流框架使现有的技术更加易用

3.Spring的设计模式：

　　　1.单例模式：创建bean时

　　　2.简单工厂模式：在BeanFactory和AppliactionContext中都用到了

　　　3.代理模式：在Aop中实现jdk动态代理

　　　4.外观模式：Tomcat中用很多场景都用到了外观模式，因为Tomcat中有很多不同的组件但每个组件需要相互通信，但又不想暴露太多内部信息，所以使用外观模式隔离数据

　　　5.摸版模式：在各种BeanFactory以及ApplicationContext中也用到了

　　　6.策略模式：在java中的应用如comparator这个借口就是为策略模式而生的

　　　7.原型模式：使用原型模式生成一个对象比用new生成一个对象在性能上有很大的区别，因为Object的Clone()这个方法他直接操作内存中的二进制流，特别是在复制大对象时效果非常明显

　　　8.迭代器模式：迭代器模式提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部。主要作用就是来遍历集合

4.IOC容器

　　SpringIOC容器依赖于Dom4j,反射,简单工厂模式

　　1.使用XML文件向ioc注入bean对象

　　xml中：　　

　　　　<bean id="ID名" class=“包名.类名”>

　　　　　　　<property name="属性名" ref="包名.类名"/ value=“值”></property>----------复杂类用ref简单的类型用value

　　　　</bean>

　　方法中：
　　　　//创建IOC容器

　　　　　名=new ClassPathXmlApplicationContext(注入bean的xml文件.xml);

　　　　 //通过容器对象根据bean的id获得bean对象

　　　　类名=名.getBean("ID名");

　　2.Bean单实例和多实例:

　　　　默认是单实例对象无论getbean得到的对象都是同一个，改成多实例再getbean得到的对象就是新的对象

　　　　<bean scope="singleton"></bean>-------单实例对象

　　　　<bean scope="prototype"></bean>-------多实例对象

　　　　IOC容器用的是Context的约束

　　3.IOC注入分类：

　　　　　　　1.设值注入（属性注入）　　　　　

　　　　　　　<bean id="" class="">
　　　　　　　　　<property name=""  value=""></property>
　　　　　　　</bean>

　　　　　　　 2.构造注入　　　　　　　　

　　　　　　　 <bean id="" class="">
　　　　　　　 　　<constructor-arg name="构造参数名" value=“值”>
　　　　　　　 </bean>

　　　　　　 3.坐标注入（坐标从0开始）

     　　　　<bean id="" class="">
　　　　　　　　　<constructor-arg index="位置信息" value=“值”>
　　　　　　　</bean>

　　　　　　　4.根据类型注入　　　　　　　　

　　　　　　　<bean id="" class="">
　　　　　　　　　<constructor-arg type="包名.类名" value=“值”>
　　　　　　　</bean>

　　　　　　5.设值注入与构造注入的区别：

　　　　　　　1.设值注入：                              　2.构造注入：

　　　　　　　　　1.通过set，get访问器实现　　　　　　　　　　　　1.通过构造方法实现

　　　　　　　　　2.灵活性好，但set，get方法过多　　　　　　　　　2.灵活性差，仅靠重载限制太多

　　　　　　　　　3.时效性差　　　　　　　　　　　　　　　　　　   3.时效性好

　　　　　　　　　4.通过无参构造实例化　　　　　　　　　　　　　   4.通过匹配的构造方法实例化

　　　　　　6.使用P命名空间注入属性值：

　　　　　　　 1.引入p的命名空间：xmlns:p="http://www.springframework.org/schema/p"

　　　　　　　 2.使用：　　　　　　

 　　　　　　　　<bean id="" class="" p:属性名=“值”></bean>

　　　　　　7.注入不同的数据类型：

　　　　　　　1.注入直接量：　　　　　　　　　

　　　　　　　　　　<bean id ="" class="">
　　　　　　　　　　　　<property name="属性名">
　　　　　　　　　　　　　　<value>值</value>
　　　　　　　　　　　　</property>
　　　　　　　　　　</bean>

　　　　　　　 2.引用bean注入：　　　　　　　　

　　　　　　　　　　<bean id ="" class="">
　　　　　　　　　　　　<property name="属性名">
　　　　　　　　　　　　　　
　　　　　　　　　　　　　　<ref bean="另一个Bean的id"></ref>
　　　　　　　　　　　　              或
　　　　　　　　　　　　　　<ref local="另一个Bean的id"></ref>

　　　　　　　　　　　　</property>
　　　　　　　　　　 </bean>

　　　　　　local只能在一个配置文件中检索bean的id而bean标签可以在其他配置文件中检索

　　　　　　<null></null>表示空值
　　　　　　<value></value>表示空串

　　　　　　8.使用内部bean

　　　　　　<bean id="" class="">
　　　　　　　　<property name="">
　　　　　　　　　　<bean class="包名。类名"></bean>
　　　　　　　　</property>
　　　　　　</bean>

　　　　　　 9.注入集合类型的属性　　　　　　　　

　　　　　　<bean id="" class=""> 
　　　　　　　　<property name="">
　　　　　　　　　　
　　　　　　　　　　9.1 List
　　　　　　　　　　　　<list>
　　　　　　　　　　　　　　<value>值</value>
　　　　　　　　　　　　</list>
　　　　　　　　　　
　　　　　　　　　　9.2 Set
　　　　　　　　　　　　<set>
　　　　　　　　　　　　　　<value>值<value>
　　　　　　　　　　　　</set>

　　　　　　　　　　9.3 Map
　　　　　　　　　　　　<map>
　　　　　　　　　　　　　　<entry  key="键"  value="值"></entry>
　　　　　　　　　　　　</map>

　　　　　　　　　　9.4 Props
　　　　　　　　　　　　<props>
　　　　　　　　　　　　　　<prop key="键">值</prop>
　　　　　　　　　  　　</props>

　　　　　　　　 </porperty>

　　　　　　　</bean>

　　4.IOC容器注解

　　 注解与注释的区别注解是写给程序看的，程序看到会执行。注释是给程序员看的，程序不会执行。

　　　　　　1.@Component 组件

　　　　　　2.@Controller 控制器

　　　　　　3.@Service 服务

　　　　　　4.@Repository 数据访问

　　　　　　5.@Autowired 自动装配要与@Qualifier("name") 注解一起搭配使用

　　　　　　6.@Resource 自动装配

　　　　　　@Autowired 与@Resource 的区别:

　　　　　　　　　　@Autowired 会按照类型自动装配如果找不到类型就会自动注入null值　　

　　　　　　　　　　@Resource 默认按照类型自动装配如果找不到他会按照名称再次装配一遍

　　5.IOC注解扫描

　　　　　<context:component-scan base-package="要扫描的包名"></context>

5.Aop面向切面

　　　将复杂的需求分解出不同的方面，将散布在系统的公共功能集中解决，在不改变源代码的情况下增加程序功能

　　1.增强处理（Advice）

　　2.切入点(Pointcut)

　　3.连接点（JoinPoint）

　　4.切面（Aspect）

　　5.目标对象（Target Object）

　　6.Aop代理（Aop Proxy）

　　7.织入（weaving）

　　1.切入点表达式：

　　execution(* 空格 包名.类名.方法名（..）)

　　　*代表返回任意值都可以

　　（..）括号中的..表示有参数，没有..的话表演没参数

　　2.增强操作的执行顺序：

　　　　　　前置增强→环绕增强→最终增强→异常抛出增强→环绕增强→后置增强

　　　　　　最终增强不论方法是否报错都会执行

　　 3.增强使用：

　　　　1.引入约束

　　　　2.把增强类放入Ioc容器

　　　　3.配置Aop

　　　　　　<aop : config>
                　　1.配置切入点
        　　　　　　 <aop : pointcut expression="切入点表达式" id="切入点名">

                　　2.配置切面 织入增强
          　　　　　<aop : aspect ref="增强类Id">

                       前置增强    
                　　　　<aop : before method="方法名" pointcat-ref="切入点Id">

                       后置增强
                　　　　<aop : after-returning methord="方法名" pointcat-ref="切入点Id" returning="返回的类型的名"/>----返回的类型名必须和方法中返回的类型名一致不然找不到

                     　异常抛出增强
                　　　　<aop : after-throwing method="方法名" pointcut-ref=“切入点Id” throwing=“抛出的异常名”>

                      环绕增强
                　　　　<aop : around method ="方法名" pointcut-ref="切入点Id">
                
                      最终增强
                　　　　<aop : after method="方法名" pointcut-ref="切入点Id">

　　　　　　 <aop : config>

　　　　　　
　　　　　　异常抛出增强方法中 　　　　　　　　　
　　　　　　public void 方法名（Execption expect）{
 　　　　　　　　　　　　　expect.getmessage();------输出错误 　　　　　　　　　
　　　　　　} 

　　　　　　环绕增强方法中 　　　　　　　
　　　　　　public void 方法名（ProceedingJoinPoint 名）{ 　　　　　　　　　　　　
　　　　　　　　　　　　　　类型 名=名.proceed（）；-------放行的方法 　　　　　　　
　　　　　　}

　　4.Aop注解：

　　　 @Aspect 声明是增强类

　　　 @Pointcut（“切入点表达式”）声明为切入点

　　　　@Before("切入点方法名") 前置增强

　　　 @AfterReturning(“切入点方法名”) 后置增强

　　　　@After("切入点方法名") 最终增强

　　　　@AfterThrowing(value="切入点方法名", throwing="e")异常增强

　　　　@Around(value="切入点方法名")环绕增强

　　5.开启Aop　

　　　<aop : aspectj-autoproxy/>