Spring

Spring框架

1.Spring起到什么作用？

根据当前的理解，spring起到的是，连接struts2和Hibernate的作用，但是Hibernate的技术基本上没怎么用，所以对Hibernate的内容不是很了解，但是起码知道它的作用就是通过操作对象的方式来操作dao层，来减少咱们的sql语句。
Spring的作用是类似于“可插拔”的思想，当我需要什么的时候就把插头插进插座，不需要的时候就进行移除，这里的“插座”就是spring的配置文件，各种bean的管理

2.Spring的核心

IoC（控制反转）和Di（依赖注入），以及AOP（面向切面编程）。

3.Spring简述

目的：解决企业应用开发的复杂性。
功能：使用基本的javabean来代替EJB，并提供了更多的企业应用功能
简述：Spring是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的容器框架。Spring最常见的用途是—使用AOP功能给Hibernate加入自动事务处理的功能。Spring作为容器，他的职责是负责逻辑对象的实例化、初始化、服务调用等。

4.Spring的组成

1. 核心容器：Bean容器–管理Bean，Core–核心容器，Context–上下文（配置文件），spEL表达式
2. AOP：提供切面支持
3. Aspects：这个也是AOP的框架
4. Web：web–用于web开发，Struts–整合Struts
5. DataAccess：JDBC–JdbcTemplate数据库开发，ORM–整合Hibernate

5.Spring开发入门

• Spring的开发在大部分情况下就是编写XML配置文件来组织各种各样的Bean和切面等。
• 使用配置的方式，Spring开发人员可以真正将程序各个部分连接起来，通过使用注释或者XML配置文件的方式，程序运行时Spring能够“按需”创建或初始化所有的对象关系。
• 这种方式的好处是：程序的各个部分可以很轻易的切换到另一个实现，只需要修改注释或XML配置文件，然后再次运行程序即可

6.控制反转（IoC）

6.1 传统的软件框架方法

传统的方法通过内部代码来控制组建之间的关系，使用new关键字实现连组建关系的组合，这种关系造成了组件之间的耦合关系
对应的故事：某家公司总裁要在本周五参加一个重要的会议发言，一种办法就是，他亲自撰写发言稿，这就是传统的方法，相当于我们在编写程序时自己给变量赋值，然后调用。

6.2 控制反转

1. 针对上面的故事：现代话的企业运作中，总裁的发言稿会由助理去准备，包括会议的一切安排，他只需要告诉助理去参加哪个会议即可，当他参加会议时，一切都已经安排好了，这就是控制反转。
2. 把写好的发言稿递给总裁就是“注射”，助理就是框架里面的“注射控制器BeanFactory”，发言稿就是Spring控制下的“JavaBean”，他们之间的桥梁是“XML格式的配置文件”，当两者依赖关系发生变化时，只需要更改XML文件进行依赖注入就可以实现服务的变更。
3. 控制反转是一个重要的面向对象编程法则，用来削减程序之间的耦合度，在传统模式中是类和类之间直接调用，所以耦合度很强，程序的依赖关系无法消除，后期的维护牵扯太多。
4. IoC用配置文件来描述类和类之间的关系，用容器来管理（什么是容器？前面的大图），解决了3中的问题
5. * 最简单的故事*：你想要找女朋友，传统的方式就是：自己找。Spring的IoC方式就是：父母包办（媒婆包办更贴切）

6.3 控制反转的另一个名字–Di（依赖注入）

1. Di使得“调用类对接口的实现类”的关系变成了“由第三方注入”，以移除了“类对接口实现类”的依赖，简单的例子：Service层中–UserService us = new UserServiceImpl()—这也是一种依赖关系啊，咱们也应该进行消除这种依赖
2. Di策略最适合IoC容器的策略，因为它把权利完全交给了容器来处理，也就是它“依赖”容器，受控的对象只要暴露属性和带参数的构造函数，在初始化对象时就可以设置对象间的依赖关系，依赖关系的确定不依赖于特定的API和接口

3. Di的注入方式：

   1. 接口注入

      1. 将要注入的内容设置到一个接口中，
      2. 然后将其注入到它的实现类中，实现类必须实现接口的所有方法
      3. 例如
      4. `public interface Manager{
      5. public void manager(Business business)
      6. }`
      7. 实现类
      8. `public class Boss{
      9. private Business business;
      10. public void manager(…){
      11. ……
      12. }
      13. }`

   2. 基于setter方法的注入

      1. 定义所需的对象，例如：private Manager manager；
      2. 创建它的setter方法
      3. 然后就可以在xml中通过标签中标签来进行注入
   3. 基于构造函数的注入
      
      1. 把一个对象或者属性传入到一个带参数的构造函数中
      2. 然后在xml中就可以通过标签的

         7.Bean和Spring容器

         7.1什么是Bean？

         在介绍Spring的功能的时候说“Spring使用基本的javabean来代替EJB”，可以懂得，Bean指的是JavaBean，但是除此之外，它还指一些数据源（比如Hibernate中的SessionFactory），或者java对象
         Spring通过一个叫做BeanFactory的容器对这些Bean进行管理，比如实例化Bean
         Bean的原型是一个接口

         7.1.1 Spring的Bean和传统的JavaBean有什么不同，

         1. 用处不同，传统的JavaBean适用于值的传递，而Spring的Bean则可以有很多用处
         2. 写法不一样，传统的需要实现getter和setter方法，而Spring的只需实现setter方法
         3. Spring的Bean值域包含5种：Singleton（单例，一次服务器）、Proterty（每次调用都生成一个）、Request（一次请求都生成一次）、Session、全局（固定的常量）。只需在配置文件中指定scope即可，默认是单例。

         7.2 BeanFactory

         1. BeanFactory（容器），核心容器，负责组件生产和装配。
         2. BeanFactory负责读取Bean定义，管理对象的载入、生成，以及对象之间的关系维护，负责Bean的生命周期，对于简单的应用程序来说，使用BeanFactory就已经足够了，但是它的子类ApplicationContext的功能更完善

         7.3 BeanFactory包含的基本方法

         1. public Boolean containsBean(String name):判断Spring容器是否包含id为name的Bean定义
         2. public Object getBean(String name)：返回容器中id为name的Bean
         3. public Object getBean(String name,Class rquiredType):返回容器中id为name，并且类型为requiredType的Bean。
         4. public Class getType（String name）：返回容器中id为name的Bean的类型

         7.4 Bean的实例化方式

         1. Bean的常用属性是id和class，Bean的实例化可以通过BeanFactory的getBean()方法得到
         2. 调用构造器创建一个Bean实例
         3. 通过new关键字创建Bean实例
         4. 通过BeanFactory调用某个类的静态工厂方法创建Bean

         8.AOP编程

         8.1 AOP的主要功能

         1. 将日志记录、性能统计、安全控制、事务处理、异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，可以将他们独立到非指导业务逻辑的方法中，进而在改变这些行为的时候不影响业务逻辑的代码
         2. AOP编程可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能，AOP实际追求的是调用者和被调用者的解耦。

         8.2 AOP的实现原理

         底层采用了代理机制来实现

         8.3 AOP术语

         1. target：目标类，需要被代理的类。例如：UserService
         2. Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法
         3. PointCut 切入点：需要被增强的连接点。例如：addUser()
         4. advice 通知/增强，增强代码。例如：after(关闭事务)、before(开启事务)
         5. Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
         6. proxy 代理类
         7. Aspect(切面): 是切入点pointcut和通知advice的结合
            一个线是一个特殊的面。
            一个切入点和一个通知，组成成一个特殊的面。

         8.4 手动方式实现AOP

         8.4.1 JDK动态代理

         1. JDK动态代理 对“装饰者”设计模式 简化。使用前提：必须有接口
         2. 目标类：接口 + 实现类
         3. 切面类：用于存通知 MyAspect（但实际上切面类应该还需要切入点）
         4. 工厂类：编写工厂生测试

         8.4.2 cglib动态代理

         1. 没有接口，只有实现类。—也就是通过继承的方式来实现
         2. 采用字节码增强框架 cglib，在运行时 创建目标类的子类，从而对目标类进行增强。
         3. 导入jar包：

         8.5 AOP联盟通知类型

         1. 这也就是上面提到的通知
         2. •前置通知 org.springframework.aop.MethodBeforeAdvice(对应的接口)
            •在目标方法执行前实施增强
         3. 后置通知：在目标方法执行后实施增强
         4. 环绕通知：在目标方法执行前后实施增强
         5. 异常抛出通知：在方法抛出异常后实施增强
         6. 引介通知：在目标类中添加一些新的方法和属性
         7. 环绕通知，必须手动执行目标方法
            try{
            //前置通知
            //执行目标方法
            //后置通知
            } catch(){
            //抛出异常通知
            }

         8.5.1 Spring编写代理：半自动–未使用AOP联盟

         1. 让spring 创建代理对象，从spring容器中手动的获取代理对象。
         2. 导入jar包：
            核心：4+1
            AOP：AOP联盟（规范）、spring-aop （实现）

         8.5.2 Spring结合AOP联盟编写代理：全自动

         1. 从spring容器获得目标类，如果配置aop，spring将自动生成代理。
         2. 要确定目标类，aspectj 切入点表达式，导入jar包

         8.6 AspectJ

         8.6.1 介绍

         1. AspectJ是一个基于java语言的AOP框架
         2. Spring2.0以后新增了对AspectJ切点表达式支持
         3. @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面
            新版本Spring框架，建议使用AspectJ方式来开发AOP
         4. 主要用途：自定义开发

         8.6.2 切入点表达式

         8.6.3 AspectJ通知类型

         8.6.3 AspectJ基于xml的使用

         8.6.3 AspectJ基于注解的使用

         9.Spring事务的管理

         10.整合web

         11.整合Junit

         12.整合ssh