Spring学习笔记

　　这里以dao层举例，最开始的方式就是写一个UserDao接口，然后写一个UserDaoImpl和UserDaoPPImpl进行实现，这时需要UserDaoIMpl对象，创建对象的时候就是 UserDao userDao = new UserDaoImpl(); 这样假设后面需求发生变化,需要的是UserDaoPPImpl的对象，我们就需要修改源码为 UserDao userDao = new UserDaoPPImpl(); 如果有一百的地方这样写了，就需要修改一百次，这是因为接口与实现类之间有耦合。

　　这里就演变出了工厂模式，我们将获取对象的功能单独抽出来做成一个工具类，有以下代码
class Beanfactory {
　　public static UserDao getUserDao() {
　　　　return new UserDaoImpl();
      }
}        
这样就可以在需要改成获取UserDaoPPImpl() 时，只修改一处代码。但这样虽然解除了接口与实现类之间的耦合，但接口与工厂之间有了耦合。

　　于是，Spring中使用了工厂 + 反射 + 配置文件的方式降低耦合，具体就是创建applicationContext.xml对一些Bean进行注册，然后在工厂方法中，解析配置文件，获取想要创建实例的类对象，然后利用反射创建实例，代码如下：
applicationContext.xml文件

<bean name="userDAO" class="com.itheima.spring.demo1.UserDAOImpl" ></bean>

工厂

class BeanFactory{

　　public static Object getBean(String name) {

　　　　// 解析XML文件，根据name找到指定类

　　　　...

　　　　// 反射

　　　　Class clazz = Class.forName(name);

　　　　return clazz.newInstance();

　　}

}

2.2 IOC与DI(依赖注入)

DI(Dependency Injection)：依赖注入，前提是必须有IOC环境，Spring管理这个类的时候将类依赖的属性注入进来。

　　其实不管是控制反转还是依赖注入，他们都可以这样理解：当某个Java实例（调用者）需要另一个Java实例（被调用者）时，在传统的程序设计过程中，通常有调用者来创建被调用者的实例。但是在依赖注入/控制反转模式下，创建被调用者的工作不再是有调用者来完成，而是由Spring容器来完成，然后注入调用者。

　　依赖注入通常有如下两种：

        　　 1、  设置注入：IoC容器使用属性的setter方法来注入被依赖的实例。

        　　 2、  构造注入：IoC容器使用构造器来注入被依赖的实例。

前提条件：Java类的定义按照JavaBean的规范进行创建

介绍JavaBean的博客：Java Bean 简介及其应用   参考博客：Spring读书笔记-----Spring核心机制：依赖注入

设置注入：set方法进行依赖注入的代码示例

　　首先是一个按照JavaBean标准定义的Car类

 1 public class Car {
 2     private String name;
 3     private int price;
 4 
 5     public Car() {
 6     }
 7 
 8     public Car(String name, int price) {
 9         this.name = name;
10         this.price = price;
11     }
12 
13     public String getName() {
14         return name;
15     }
16 
17     public void setName(String name) {
18         this.name = name;
19     }
20 
21     public int getPrice() {
22         return price;
23     }
24 
25     public void setPrice(int price) {
26         this.price = price;
27     }
28 
29     @Override
30     public String toString() {
31         return "Car{" +
32                 "name='" + name + '\'' +
33                 ", price=" + price +
34                 '}';
35     }
36 }

　　然后对其在spring-config.xml文件中进行配置，这里就用到了<property>标签，Spring会在调用无参数的构造器、创建默认的Bean实例后，调用相应的setter方法为程序注入属性值。<property…/>定义的属性值将不再有该Bean来主动设置、管理，而是接受Spring的注入。

<bean id="car" class="com.xidian.demo.Car">
　　<property name="name" value="奥迪"></property>
　　<property name="price" value="400000"></property>
</bean>

　　测试输出结果

ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
Car car = context.getBean("car", Car.class);
System.out.println(car);

设置注入代码示例2：属性有自定义的对象类型

　　首先我们创建轮胎类，然后在前面提到的Car类中添加一个轮胎对象的属性，并重写toString()方法

public class Tire {
    private String name;
    private int price;

    public Tire() {
    }

    public Tire(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

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

 　　private Tire tires;

    public Tire getTires() {
        return tires;
    }

    public void setTires(Tire tires) {
        this.tires = tires;
    }

　　对其在spring-config.xml文件中进行配置，这里就用了<ref>这个标签

    <bean id="tire" class="com.panlei.demo.Tire">
        <property name="name" value="朝阳"></property>
        <property name="price" value="3000"></property>
    </bean>

    <bean id="car" class="com.panlei.demo.Car">
        <property name="name" value="奥迪"></property>
        <property name="price" value="400000"></property>
        <property name="tires" ref="tire"></property>
    </bean>

　　最终测试结果　

构造注入

Car中的构造方法

public Car(String name, int price, Tire tires) {
        this.name = name;
        this.price = price;
        this.tires = tires;
    }

spring-config.xml中的配置，这里就可以不用无参构造方法了，直接使用有参构造

<bean id="car" class="com.panlei.demo.Car">
　　<constructor-arg name="name" value="奔驰"></constructor-arg>
　　<constructor-arg name="price" value="400000"></constructor-arg>
　　<constructor-arg name="tires" ref="tire"></constructor-arg>
</bean>

测试结果：

2.3 Spring工厂类

BeanFactory ：老版本的工厂类

　　　　BeanFactory：调用getBean的时候，才会生成类的实例。

ApplicationContext ：新版本的工厂类

　　　　ApplicationContext：加载配置文件的时候，就会将Spring管理的类都实例化。

　　ApplicationContext有两个实现类

　　　　ClassPathXmlApplicationContext ：加载类路径下的配置文件

　　　　FileSystemXmlApplicationContext ：加载文件系统下的配置文件

2.4 Spring的Bean的作用范围

scope ：Bean的作用范围

singleton ：默认的，Spring会采用单例模式创建这个对象。

prototype ：多例模式。（Struts2和Spring整合一定会用到）

request ：应用在web项目中，Spring创建这个类以后，将这个类存入到request范围中。

session ：应用在web项目中，Spring创建这个类以后，将这个类存入到session范围中。

globalsession ：应用在web项目中，必须在porlet环境下使用。但是如果没有这种环境，相对于session。
<bean id="car" class="com.test.spring.demo2" scope="prototype" init-method="setup" destroy-method="destroy"/>

3、Spring的Bean管理（注解方式）

前面介绍的Spring的依赖注入是Spring的Bean管理的一种方式，是基于XML的方式，还有另外一种方式，就是注解方式

3.1 注解方式简单使用

1、在spring-config.xml中引入相关约束

<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.xsd">

</beans>

2、编写测试类，仍以上面的Car类作为示例

3、在xml中配置注解的组件扫描

<context:component-scan base-package="com.panlei.demo"/>

4、在相关类上添加注解。使用注解，可以没有set方法，需要将注解添加到属性处，有set方法就添加到set方法上

package com.panlei.demo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component("car")     // 相当于<bean id="car" class="com.panlei.demo.Car"/>
public class Car  {
    private String name;
    private int price;

    public Car() {
    }

    public Car(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    @Value("奥拓")
    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    @Value("10000")
       public void setPrice(int price) {
        this.price = price;
    }

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

5、测试输出

ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
Car car = context.getBean("car", Car.class);
System.out.println(car);

3.2 IOC注解详解

@Component：组件，作用在类上

Spring提供了@Component的三种衍生注解，为了更好的区分不同的层，让标注类本身的用途清晰：

　　@Controller:WEB层

　　@Service:业务层

　　@Repository:持久层

属性注入的注解：

@Value：用于注入普通类型

@Autowired:自动装配，会按照注解的类型进行装配

若想要@Autowired按照名称进行注入，需结合 @Qualifier 强制使用名称注入

@Resource:相当于@Autowired与@Qualifier一起使用

Bean作用范围的注解：

@Scope：

　　singleton:单例

　　prototype:多例

Bean生命周期的配置：

@PostConstruct:相当于 init-method

@PreDestroy:　相当于destroy-method

XML方式与注解方式的比较：

　　XML：结构清晰

　　注解：开发方便，便于思考的连续性

实际开发中还有一种XML与注解整合的开发方式：也就是Bean在XML中进行配置，但是属性使用注解进行注入，需要在xml文件中声明，就不需要声明组件扫描
<context:annotation-config></context:annotation-config>

4、AOP概述

4.1 AOP介绍

AOP(Aspect Oriented Programming，面向切面的编程)。利用AOP对业务逻辑各个部分进行隔离，降低耦合度

4.2 AOP底层原理简单了解

利用了代理机制：Spring 的 AOP 的底层用到两种代理机制

JDK 的动态代理 :针对实现了接口的类产生代理。

Cglib 的动态代理 :针对没有实现接口的类产生代理，应用的是底层字节码增强技术应用的是底层字节码增强技术，生成当前类的子类对象 .

4.3 AOP相关术语及知识

Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.

Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.

Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)

Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

Target(目标对象):代理的目标对象

Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程. spring采用动态代理织入，而AspectJ采用编译期织入和类装在期织入

Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类

Aspect(切面): 是切入点和通知（引介）的结合

4.4 AOP开发入门(基于AspectJ的XML方式)

SpringAOP与AspectJ的关系

　　AOP面向切面编程是一种编程思想，是对OOP面向对象编程的一种补充。对于AOP这种编程思想，很多框架都进行了实现。Spring就是其中之一，可以完成面向切面编程。

　　而AspectJ也实现了AOP的功能，且其实现方式更为简捷，使用更为方便，而且还支持注解式开发。所以，Spring又将AspectJ的对于AOP的实现也引入到了自己的框架中。

使用时需要引入相关的jar包：

　　引入AOP联盟的jar包，这是AOP的规范

　　引入AspectJ的jar包，这是对上面AOP规范的实现

　　引入整合Spring和AspectJ的jar包

　　引入Spring的AOP jar包，因为上面Spring和AspectJ的整合jar包用到了Spring的AOP jar包　　

　　

1、Spring配置文件中关于AOP的配置

2、编写接口及其实现类，并在配置文件中进行<bean>配置

3、编写自己的切面类，并在配置文件中进行<bean>配置

4、针对具体类中的方法进行具体的AOP的切入点的配置

通知类型

前置通知：在目标方法执行之前执行

后置通知：在目标方法执行之后执行，可以获取被代理方法的返回值，注意参数名字的一致性

切面类中的方法可以有返回值，其返回值是如何处理的？待解决

环绕通知：注意需要调用被代理的方法

异常抛出通知：可以接收异常信息

最终通知：

切入点表达式

execution( 表达式 )

表达式 : [方法访问修饰符 ] 方法返回值包名 .类名 .方法名 (方法的参数)

public * com.panlei.spring.dao.*.*(..)

* com.panlei.spring.dao.*.*(..)　　　　　　　　// 包下面的所有类所有方法

* com.panlei.spring.dao.UserDao+.save(..) 　　// + 代表当前类及其子类的save方法

* com.panlei.spring.dao..*.*(..) 　　　　　　　　// 这个包以及其子包下面的所有类所有方法

4.5 基于AspectJ的注解的AOP开发

继续使用上面的项目，我们还是编写好目标类以及切面类，并在spring的配置文件中进行相应的bean配置，然后根IOC注解开发类似，我们需要在spring配置文件中配置一开启注解AOP开发的语句

然后就可以在切面类上进行注解开发，使用的语法仍然是切入点表达式，如下图为前置通知的注解

同样，也有后置通知，也可以接收被代理类的返回值

环绕通知

异常抛出通知

最终通知

另外，针对每一个方法配置其切入点太麻烦，我们可以单独配置切入点，然后直接引用方法名即可

5、JDBC模板

以C3P0作为数据库连接池

1、引入jar包，在Spring配置文件中配置C3P0数据库连接池和JDBC模板，其中数据库的配置使用单独的配置文件，然后在Spring配置文件中引入该配置文件

2、简单使用其进行数据库操作

查询测试

6、Spring的事务管理

6.1 Spring事务管理的相关API

PlatformTransactionManager：平台事务管理器，是一个接口类，Spring用于管理事务的真正对象，有两个实现类
　　DataSourceTransactionManager ：底层使用JDBC管理事务　　
　　HibernateTransactionManager ：底层使用Hibernate管理事务

TransactionDefinition ：事务定义信息，用于定义事务的相关的信息，隔离级别、超时信息、传播行为、是否只读等

TransactionStatus：事务的状态，用于记录在事务管理过程中，事务的状态的对象

它们之间的关系：

　　Spring进行事务管理的时候，首先平台事务管理器根据事务定义信息进行事务的管理，在事务管理过程中，产生各种状态，将这些状态的信息记录到事务状态的对象中。

6.2 Spring的事务传播行为

Spring中提供了七种事务的传播行为

6.3 Spring的编程式事务管理

我们以一个事务讲解常用的银行转账的案例作为例子

1、首先先搭建好一个转账的环境，也就是定义好Service层与Dao层，并在配置文件中配置bean以及数据库连接池

这里注意一点，由于我们需要JdbcTemplate进行数据相关的增删改查的操作，但如果给每一个Dao中都定义一个JdbcTemplate的话，其实获取的都是同一个对象，Spring考虑到了这种需求，就将其写为JdbcDaoSupport这个类，我们只需要继承这个类，这个类中就有一个JdbcTemplate对象，调用get方法获取即可，在配置Dao的时候要设置一个dataSource参数，用来初始化JdbcTemplate对象。这样就不需要在配置文件中配置JdbcTemplate了。

2、配置平台事务管理器以及事务管理的模板类，并在Service中注入事务管理的模板

3、在Service层编写事务管理的代码

4、运行测试

当我们故意在转账操作之间加入异常时，会发现不会出现一边已经扣钱，另一边还没有加钱的情况。

6.4 Spring的声明式事务管理(基于XML方式)

声明式事务管理是底层基于AOP的，也就是需要引入aop的jar包以及在配置文件中配置一些aop

1、仍然使用上一节的例子，配置好Service与Dao、数据库连接池以及平台事务管理器

2、配置事务的增强：因为事务的管理是一个固定的模式，也就是切面的增强是固定的，所以切面类不需要自己写，只需要进行配置即可。配置的信息主要是事务的配置，<tx:advice>中主要事务的一些配置，主要的配置信息在<tx:method>中，name表示的是应用事务的方法，里面可以使用通配符，比如save*表示save开头的方法，还可以定义传播行为等信息。然后就是aop的配置，用<aop:advisor>将一个<tx:advice>与切入点联合起来。

3、运行测试

当我们故意在转账操作之间加入异常时，会发现不会出现一边已经扣钱，另一边还没有加钱的情况。

6.5 Spring的声明式事务管理(基于注解的方式)

1、仍然使用上一节的例子，配置好Service与Dao、数据库连接池以及平台事务管理器

2、开启注解事务

3、在具体的service代码中添加事务注解，本例中指的是AccountServiceImpl。在注解中可以添加事务的各种定义信息

4、运行测试

当我们故意在转账操作之间加入异常时，会发现不会出现一边已经扣钱，另一边还没有加钱的情况。