Spring框架；Spring中IOC简介及搭建；Spring中AOP简介；

一，Spring介绍

Spring 的全称： Spring Framework

Spring是一个优秀的开源的轻量级的企业应用开发框架，是为了解决企业应用程序开发复杂性而创建的。它大大简化了java企业级开发的复杂性，提供了强大，稳定的功能，能够创建出松耦合，易测试，易扩展，易维护的java应用系统，又没有带来额外的负担。它坚持一个原则：不重新发明轮子。已经有较好解决方案的领域，Spring绝不做重复性的实现。例如对象持久化和ORM，Spring只是对现有的JDBC，mybatis，等技术提供支持，使之更易用，而不是重新做一个实现。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件。

整个项目的开发始终贯彻着如下的核心架构理念：

A.降低开发成本，方便使用，促进良好的编程习惯

B.整合各类框架，遵守轮子理论（不重复的造轮子，使用现有的轮子）

C.易于选择，方便测试

D.统一配置，灵活可扩展

E.非侵入式

F.提供最好的IOC解决方案

G.提供最好的AOP解决方案

二，介绍Spring的架构图

Spring框架由大约20个功能模块组成。组成Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。

每个模块的功能如下：

Spring Core：核心容器提供Spring 框架的基本功能，为Spring提供了基础服务支持，核心容器的主要组件是BeanFactory 。

通过BeanFactory，Spring使用工厂模式来实现控制反转（IOC ），将应用程序的配置和依赖关系与实际的应用程序代码分开。

Spring之所以称为容器，就是由于BeanFactory的自动装备和注入。

Spring Context：Spring 上下文是一个配置文件，向Spring 框架提供上下文信息。主要用于加载属性文件,扫描本地的包等

BeanFactory使Spring成为容器，上下文模块使Spring成为框架。

这个模块对BeanFactory进行了扩展，添加了对I18N，系统生命周期事件以及验证的支持。这个模块提供了许多企业级服务，例如：邮件服务、JNDI访问、EJB集成、远程调用以及定时服务，并且支持与模板框架的集成。

Spring AOP ：通过配置管理特性，Spring AOP 模块直接将面向切面编程功能集成到了Spring 框架中（AOP把一个业务流程分成几部分，例如权限检查、业务处理、日志记录，每个部分单独处理，然后把它们组装成完整的业务流程。每个部分被称为切面）。所以，可以很容易地使Spring 框架管理的任何对象支持AOP 。Spring AOP 模块为基于Spring 的应用程序中的对象提供了事务管理服务

Spring JDBC：这个模块封装了数据库连接的创建、语句对象生成、结果集处理、连接关闭等操作，而且重构了所有数据库系统的异常信息，用户不在需要处理数据库异常了。提供了JDBC的抽象层，简化了JDBC编码，同时使代码更健壮。在这个模块中，利用了Spring的AOP模块完成了为系统中对象提供事务管理的服务。

Spring ORM ：Spring没有实现自己的ORM方案，而是为当前主流的ORM框架预留了整合接口，包括Mybatis,Hibernate等。所有这些都遵从Spring 的通用事务和DAO 异常层次结构。 Spring的事务管理支持所有这些ORM框架以及JDBC。

Spring web：集成各种优秀的web层框架的模块（Struts、Springmvc）

三，Spring 学习的核心内容：

1) IOC：控制反转--帮助我们创建对象的控制权发生反转

2) AOP：面向切面编程---提升代码的扩展性，有点像过滤器.针对方法.

3) TX：声明式事务管理---强大事务管理机制.事务过程不需要程序员编写,只需要声明出哪些方法需要进行事务管理.

四，Spring IOC简介和环境搭建

1，简介

责任链

我们在使用MVC进行开发的时候数据在各层之间进行传递，数据传递的时候在业务上形成一个链条，这个链条称之为责任链

基于责任链模式开发的缺点

层和层之间的相互调用造成了耦合性比较高

解决的方案

Spring IOC :控制反转英文全称：Inversion of Control

控制:对类实例化的控制.指的是创建对象这个事情.

反转:以前由程序员实例化的过程,转交给Spring进行实例化. 通俗解释:由Spring帮助实化对象,释放程序员对对象的关注度,所有的关注度都放在业务上.同时还可以达到解耦的效果.

项目应用场景

1.帮助创建SqlSessionFactory

2.管理所有Mapper接口,管理所有BizImpl类.

2，（maven版）环境搭建步骤:

1) pom.xml里添加依赖：

	<!--进行junit单元测试 -->
 	<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

	<!--依赖于commons-logging日志管理 -->
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.2</version>
    </dependency>

	<!--提供了框架的基本组成部分,包括IOC 和 DI-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.1.6.RELEASE</version>
    </dependency>

	<!-- 提供了BeanFactory-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.1.6.RELEASE</version>
    </dependency>

	<!--上下文配置对象，提供一个框架式的对象访问方式-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.1.6.RELEASE</version>
    </dependency>
    
	<!--提供了强大的表达式语言-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.1.6.RELEASE</version>
    </dependency>

2) resources下创建applicationContext.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/beans    http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--User  user =new User();
        id:通过这个属性获取类的对象
    	class:配置哪个类的对象
     -->
       <bean id="us" class="com.jr.pojo.User"></bean>
</beans>

3) 测试类代码：

//[1]解析applicationContext.xml

//Spring配置文件运行后产生ApplicationContext接口对象.
//Spring中所有内容都放入到ApplicationContext容器中.

 ApplicationContext  app =new ClassPathXmlApplicationContext("applicationContext.xml") ;

 //[2]获得user对象
 User us = (User) app.getBean("us");
 
 // getBean(“<bean>id属性值”,对象是什么类型);
 // 如果省略第二个参数,getBean()返回值为Object

 us.eat();

3，（java版）环境搭建步骤：

1）创建Java项目，导入jar包：

2）.src下创建applicationContext.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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    


</beans>

3）.创建实体类User：

public class User {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }

    public void eat(){
        System.out.println(name+"在吃汉堡。。。");
    }
}

4）.编写applicationContext.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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.jr.pojo.User"/>

    
</beans>

5）.编写测试类：

public class MyTest {

    @Test
    public void testioc(){
        //1.加载Spring核心配置文件
      ApplicationContext applicationContext =new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.根据bean id获得user对象
        User user=applicationContext.getBean("user",User.class);
        user.setName("娜娜");
        user.eat();
    }
}

五，Spring AOP

1，介绍AOP

AOP的概念：Aspect Oriented Programming AOP的中文：面向切面编程

AOP有特定的应用场合，它只适合具有横切逻辑的应用场合，如：性能检测，访问控制，事务控制，日志记录等。就像面向对象编程的关注点在于对象即类；而面向切面编程的关注的在于切面；

那么什么是切面？可以理解为程序执行时的某个节点，或者更具体一点，在某个方法执行之前，执行之后等节点。

使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑——比如权限管理，事务管理，日志记录等等。这些系统性的编程工作都可以独立编码实现，然后通过AOP技术再切入进系统即可。从而达到了将不同的关注点分离出来的效果。

举个例子：我现在要实现一个删除功能，在Servlet里调用了业务逻辑层里的删除方法。而在业务逻辑层Service实现类里，需要在删除方法前进行权限检查，在删除方法后进行日志记录。那我就将权限检查和日志记录两个方法提取出来，放到单独的一个类里去，而不是跟删除的业务代码杂糅在一块。最后在通过AOP技术动态织入到删除方法周围。在service实现类里的删除方法就是切点/连接点（连接点范围更大，管符合一定条件规则的连接点叫切点）；而权限检查和日志记录就是切面；切面的工作内容叫做通知同时通知也规定了什么时候执行切面。

2，使用AOP目的

按照软件重构思想的理念，在OOP中通过抽象把相同的代码抽取到父类中（纵向抽取），但无法通过抽象父类的方式消除重复性的横切代码（如事务处理这种非业务性的重复代码），而AOP就是为了解决将分散在各个业务逻辑代码中的相同代码通过横向切割的方式抽取到一个独立的模块中。

3.AOP中的几个要素

1） Aspect ：切面，切入系统的一个切面。比如事务管理是一个切面，权限管理也是一个切面；

2） Join point ：连接点，也就是可以进行横向切入的位置；

3） Advice ：通知，切面在某个连接点执行的操作(分为: Before advice , After returning advice , After throwing advice , After (finally) advice , Around advice )；

4） Pointcut ：切点，符合切点表达式的连接点，也就是真正被切入的地方；

4.AOP的分类：

AOP分为静态AOP和动态AOP。静态AOP他是将切面代码直接编译到Java类文件中。动态AOP是指先将切面代码统一放到一个切面类里去，然后进行动态织入到指定的切点方法周围，从而实现AOP。Spring的AOP为动态AOP，实现的技术为： JDK提供的动态代理技术和 CGLIB(动态字节码增强技术) 。尽管实现技术不一样，但都是基于代理模式，都是生成一个代理对象。