Spring框架

简介

Spring的特点： 轻量级 Spring 是非侵入性的 - 基于 Spring 开发的应用中的对象可以不依赖于 Spring 的 API 依赖注入(DI --- dependency injection、IOC) 面向切面编程(AOP --- aspect oriented programming) 容器 Spring 是一个容器, 因为它包含并且管理应用对象的生命周期 框架 Spring 实现了使用简单的组件配置组合成一个复杂的应用 在 Spring 中可以使用 XML 和 Java 注解组合这些对象 一站式 在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库 （实际上 Spring 自身也提供了展现层的 SpringMVC 和 持久层的 Spring JDBC）

Spring核心两部分：

1).AOP:面向切面编程，扩展功能不需要修改源代码实现

2).IOC:控制反转，比如一个类，里面有很多的方法（不是静态的方法），调用类的方法，创建类的对象，使用对象调用这个类的方法，创建类的对象的过程中，需要new出来对象。

而IOC创建对象不是通过new的方式来实现，而是交给Spring配置，通过配置来创建对象。

Spring 一站式框架

1).Spring在JavaEE中三层结构中，每一层都提供了不同的解决技术

-web层：SpringMVC

-service层：Spring的IOC

-dao层：Spring的jdbcTemplate

IOC基本的入门案例

1.导入jar包

 需要的依赖

<!-- Spring依赖 -->
    <!-- 1.Spring核心依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>
<!-- 2.Spring dao依赖 -->
<!-- spring-jdbc包括了一些如jdbcTemplate的工具类 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- 3.Spring web依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- 4.Spring test依赖：方便做单元测试和集成测试 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>4.3.7.RELEASE</version>
　　</dependency>

3.spring的配置文件 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"
       xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.3.xsd">
   
    <context:component-scan base-package="daoImp,dao,action,entity"/>
    <!-- Ioc入门 -->
    <bean class="action.PrintAction" id="printAction">
        <property name="print">
            <ref bean="Print"></ref>
        </property>
        <property name="paperImp">
        <ref bean="PaperDao"></ref>
    </property>
        <property name="inkImp">
            <ref bean="InkDao"></ref>
        </property>
    </bean>

    <!-- 使用静态工厂来创建对象 -->
    <!--<bean id="bean2" class="com.atwyl.beans.Bean2Factory" factory-method="getBean2"></bean>-->
    <!---->
    <!--&lt;!&ndash; 使用实例工厂来创建工厂对象 &ndash;&gt;-->
    <!--<bean id="bean3Factory" class="com.atwyl.beans.Bean3Factory"></bean>-->
    <!--<bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3" ></bean>-->
</beans>

4.代码编写测试创建对象

Spring中Bean的管理（xml配置方式）

Bean实例化的方式

1. 在Spirng里面可以通过配置文件的方式来创建对象
2. 实例化三种方式

1).使用类里面的无参构造（重点掌握）

这种配置方式采用的是无参的构造，我们可以在无参构造里面打印一句话来证实

当你的类里面没有无参的构造，他会出现如下异常

2).使用静态工厂来创建（很少用）

(1) 在类的里面，创建静态方法，返回类对象

实例：

1.

 

2.

3. 

 

3).使用实例工厂来创建

1.

 

2.

3.

Bean标签的常用属性

以下四个属性比较常用：

1. id:取得名称，可以任意命名

----id的属性值，不能包含一些特殊的符号，一般有一个或多个单词组成

----根据ID得到配置的对象

1. class : 创建对象所属类的全路径

1. name : 跟id本身是一个样子的，区别就是Id不能包含特殊符号，但是name可以包含，但是name现在已经不用了，之前Spring集成Struts1的时候，遗留的一个name属性，现在Struts1不用了，现在用id取代了。

1. scope : 主要掌握前面两个，后面三个了解一下。

----1.singleton：默认值，单例的

 

----2.prototype：多例的，多实例用在Struts的action，他用的就是多实例的，这就是他应用的场景。

 

----3.request：WEB项目中，Spring创建Bean对象，将Bean的对象引入到request作用域中

----4.session：WEB项目中，Spring创建Bean对象，将Bean的对象引入到session作用域中

----5.gloablSession：WEB项目中，应用在Prolet环境，如果没有Prolet环境那么，gloablSession相当于session。（单点登录，例如，百度首页你登录以后，你到知道里面，到贴吧里面，到文库里，都是已经登录的状态，这就是gloablSession，这个技术叫...单点登录）

属性注入介绍

1.向一个类中的属性注入它的值，传统方法有两种

1).通过带参构造可以给属性赋值

2).通过setXXX()方法也可以给属性赋值

那么，我们通过配置的方式，来创建一个类的对象，然后给改对象想的属性赋值，这个就是属相注入。

1. 属性注入的方式介绍（三种方式）

----第一个使用setXXX方法注入，第二个是使用带参构造来注入

----第三个是通过接口来给属性赋值

注意：在Spring框架中，只支持前两种注入方式，不支持接口的注入方式。

1. 在Spring框架中，两种的注入方式

------1).set方法的注入方式

------2).带参构造器注入方式

使用有参构造来注入属性

使用set方法来注入属性

注入对象类型

1.创建Dao类和Service类，在Service里面得到Dao，主要分为两步，【1】在service里面定义一个UserDao类型的变量 【2】 给变量生成setXXX方法

2．配置文件配置对象类型，这里面属性userDao不要注入具体的值了，它要引用上面配置的Dao对象

P名称空间的注入

名称空间：

beans是一个标签，xmlns，xmlns:xsi……  都是标签的属性，在一个标签中，是不能有多个相同名称相同的属性，如上图，xmlns和xmlns:xsi都需要用后面的路径，我们看一下解决方案，是加了一个冒号：后面起了一个名字，叫xsi，其实这就是一种名称空间的用法，理解为用加冒号后面再加上结果字母，可以区分不同的属性。

在一个标签中，不能写多个相同名称属性，我们用名称空间可以表示多个操作。

如何使用P名称空间呢？

1.要引入P名称空间

 2.新建一个类Person

3．配置文件用P名称空间给属性赋值

注入复杂类型的属性

1、 特殊符号

2、 定义的内部的Bean

3、 List集合

4、 数组

5、 Set集合

6、 Map集合

7、 Properties类型

8、 空字符串类型

 9、 null 值

IOC和DI的区别

IOC：控制翻转，把对象创建交给Spring管理

DI：依赖注入，向类里面的属性中，设置它的值。

关系：

依赖注入不能单独存在，它建立在IOC的基础之上。

注：详情请参见文档：Ioc和DI的区别.doc

Spring整合Web项目原理

大家看上面这一行代码，上面这一行代码是加载配置文件，在实际开发过程中，我们的顺序是action调用service的代码，service调用dao里面的代码，意思是说，以上这个加载Spring配置文件的代码肯定是要被执行的，我们可以把上面哪一行代码写道action里面，就可以加载配置文件，但是此时产生一个问题。

Action的对象是一个多实例的，我们每次访问action对象的时候，上面那个代码都要加载一次，这么做功能上没有什么问题，性能会很低。

解决方案：

加载配置文件可以在服务器（Tomcat）启动的时候加载，就是我们已启动服务器就加载上

面哪一行代码；把压力给服务器。

实现原理：

(1). ServletContext 对象

(2).监听器

(3). 具体使用

----在启动服务器的时候，为每个项目创建一个ServletContext对象

----在ServletContext对象创建的时候，使用监听器，可以监听到ServletContext对象什么时候被创建

----使用监听器监听到ServletContext对象创建的时候

----加载Spring的配置文件applicationContext.xml，把配置文件中，配置的对象给你创建

----把创建出来的对象放到一个地方，放到ServletContext域对象中(使用setAttribute方法放入)

----获取对象的时候，到ServletContext域中得到(getAttribute方法取出)

注解创建对象

····1.@Component

····2.@Controller

····3.@Service

····4.@Repository

这四个注解，功能都是一样的，都是用来创建对象的。

但是为什么有这么四个吗？Spring中提供了三个@Component的衍生注解：（功能目前来讲是一样的）

@Controller      ：WEB层

@Service        ：业务层

@Repository     ：持久层

这三个注解是为了让标注类的本身的用途清晰，Spring在后续版本中会对其增强

1.创建对象是一个单实例还是多实例

2.注解注入属性

AOP概念

1． AOP：面向切面（方面）编程，通俗的理解就是：扩展功能不通过修改源代码实现

2． AOP：采用横向抽取机制，取代了传统 纵向 继成体系 重用代码（性能监视，事务管理，安全检查，缓存）

AOP原理

AOP操作术语

1. JoinPoint(连接点)：所谓连接点是指那些被拦截到的点，在Spring中，这些点指的是方法，因为Spring只支持方法类型的连接点。
2. PointCut(切入点)：所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。
3. Advice(通知/增强)：所谓通知是指拦截到Joinpoint之后所要做的事情就是通知，通知分为前置通知，后置通知，异常通知，最终通知，环绕通知 (切面要完成的任务)
4. Aspect(切面)：是切入点和通知(引介)的结合
5. Introduction(引介)：引介是一种特殊的通知，在不修改类的代码的前提下，Introduction可以在运行期间为类动态添加一些方法或者Field
6. Target(目标对象)：代理的目标对象 (要增强的类)
7. Weaving(织入)：把增强的应用到目标过程。【把advice应用到target的过程】
8. Proxy(代理)：一个类被AOP织入增强后，就产生一个结果代理类

解释术语：

 

Spring的AOP的操作

1. 在Spring里面进行AOP的操作，要使用AspectJ。
2. AspectJ框架，是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，所以它有一个专门的编译器用来生成遵循Java字节码规范的Class文件。
3. AspectJ是一个基于Java语言的AOP框架。
4. Spring2.0以后新增了对AspectJ切点表达式支持。
5. 新版的Spring框架，建议使用AspectJ方式来开发AOP。
6. 使用AspectJ需要导入相关jar包。

1. 在配置文件中，导入AOP的约束

使用表达式配置切入点

通过execution函数，可以定义切点的方法切入

语法：

----execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

例如；

---匹配所有类public方法  execution(public * *(..))

---匹配指定包下所有类方法  execution(* cn.atwyl.dao..*(..))

----execution(* cn.atwyl.dao..*(..))  ..*表示包，子孙包下所有类

----匹配指定类所有的方法：execution(* cn.atwyl.service.UserService.*(..))

----匹配实现特定接口所有类方法execution(* cn.atwyl.dao.GenericDAO+*(..))

----匹配所有save开头的方法execution(* save*(..))

比较常用的写法：

(1).execution(* org.atwyl.aop.Book.add(..))

(2).execution(* org.atwyl.aop.Book.*(..))

(3).execution(* *.*(..))

AspectJ的AOP操作

定义两个类，一个是 Book.java 一个是 MyBook， MyBook中的 beforeOne 方法是用来增强Book的add方法的。

 

1.后置增强

 

2.环绕通知/增强

 

log4j介绍

在我们运行Spring程序的时候，控制台总是会出现如下警告：

在Spring中，通过log4j可以看到程序运行过程中，一些更详细的一些信息

比如：我们运行中那些对象创建了，它加载了那些对象，用log4j都可以看到。

····1.经常使用log4j查看日志

····2.使用方法：

----1.导入log4j的jar包

----2.复制log4j的配置文件，到src目录下

----3.可以设置日志的级别

（1） info：看到基本的信息

（2） debug：看到更详细的信息

基于AspecJ的注解Aop

第一步：配置对象

第二步：在Spring核心配置文件中，开启AOP操作

第三步：使用注解

@AspectJ提供不同的通知类型

····@Before前置通知，相当于BeforeAdvice

····@AfterReturning后置通知，相当于AfterReturningAdvice

····@Around环绕通知，相当于MethodInterceptor

····@AfterThrowing抛出通知，相当于ThrowAdvice

····@After最终final通知，不管是否异常，该通知都会执行

 

Spring的jdbcTemplate操作

 

Spring框架是一站式的框架

 

Sping JDBC是Sping提供的持久化技术，简化了JDBC API开发，使用上和Apatch公司的DBUtils框架非常类似

 

1. 针对JavaEE三层，每一层都有解决技术
2. 在dao层，使用jdbcTemplate

 

ORM持久化技术	模板类
JDBC	org.springframework.jdbc.core.JdbcTemplate
Hibernate5.0	org.springframework.orm.hibernate5.HiernateTemplate
IBatis(MyBatis)	org.springframework.orm.ibatis.SqlMapClientTemplate
JPA	org.springframework.orm.jpa.JpaTemplate

(1) jdbcTemplate对JDBC进行了封装

1. jdbcTemplate使用和dbutils使用很相似，都是对我们的数据库进行crud的操作

Spring配置连接池

 

 

最终：

 

Spring里面事务管理

1.Spring事务管理的两种方式：

1) 编程式事务管理（不用）

2) 声明式事务管理

- 声明式其实就是不写代码来实现，

- ① 基于 XML 的方式实现声明式事务

- ② 基于注解方式实现声明式事务

2.Spring进行管理的一些API

-  Spring事务管理高层抽象主要包括3个接口

- ① PlatformTransactionManager 事务管理器

- ② TransactionDefinition（事务定义信息【隔离、传播、超时、只读】）

- ③ TransactionStatus 事务运行时状态

1. Spring针对不同的dao层框架，提供接口不同的实现类。

搭建转账环境

我们新建一个项目来实现转账的功能：

1.导入jar包

 2.dao层

 3.service层

applicationContext.xml

 

开始转账业务环境搭建

 

 测试

声明式事务管理（xml配置）

 

声明式事务管理（注解）