Spring - 悦读

简介

Spring:春天---->给软件行业带来了春天
2002,首次推出了spring框架的雏形:interface21框架!
Spring框架即以interface21框架为基础,经过重新设计,并不断丰富其内涵,
Rod Johnson很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
spring理念:使现有的技术更加容易使用,本身是一个大杂烩.整合了现有所有的技术框架.
SSH: Struct2 + Spring + Hibernate !
SSM: SpringMVC + Spring + Mybatis !

官网:https://spring.io/projects/spring-framework/
官方下载地址: http://repo.spring.io/release/org/springframework/spring

 <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

优点

Spring是一个开源的免费的框架(容器)
是一个轻量级的,非入侵式的框架
控制反转(IOC),面向切面编程(AOP)
支持事务的处理,对框架整合的支持

总结:spring就是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的框架.

组成:

在这里插入图片描述

拓展

Spring Boot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速开发单个微服务
- 约定大于配置
Spring Cloud
- SpringCloud是基于SpringBoot实现的

因为现在大多数公司都在使用SpringBoot进行快速开发,学习SpringBoot的前提,需要完全掌握Spring及SpringMVC.

弊端:发展了太久之后,违背了原来的理念.配置十分繁琐,人称:"配置地狱"

IOC的理论推论

UserDao 接口
UserDaoImpl 实现类
UserService 业务接口
UserServiceImpl 业务实现类

在我们之前的业务中,用户的需求可能影响我们原来的代码,我们需要根据用户的需求去修改我们的源代码!如果程序代码量非常大,修改一次成本十分昂贵!

我们使用一个Set接口实现

private UserDao userDao;

//利用set进行动态值的注入!

public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

之前,程序是主动创建对象,控制权在程序员手上.
使用Set注入后,程序不再具有主动性,而是变成了被动的接受对象.

这种思想从本质上解决了问题,我们程序员不用再去管理对象的创建了.系统的耦合性大大降低,可以更加专注的在业务的实现上.这就是IOC原型!

控制反转(Inversion of Control),是一种思想,DI(依赖注入)是实现IoC的一种方法,也有人认为DI只是IoC的另一种说法.没有IoC的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象转移给第三方,个人认为所谓控制反转就是:获得依赖对象的方式反转了.

采用XML方式配置Bean的时候,Bean的定义信息和实现分离的,而采用注解的方式可以把两者何为一体,Bean的定义信息直接以注解的形式定义在实现类中,从而达到了零配置的目的.
控制反转是一种通过描述(XML或者注解)并通过第三方生产或获取特定对象的方式.在Spring中实现控制反转的是IoC容器,其实现方法是依赖注入(Dependency Injection,DI).

HelloSpring

在这里插入图片描述
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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="mysqlImpl" class="com.n7.dao.UserDaoMysqlImpl"/>
    <bean id="orcaleImpl" class="com.n7.dao.UserDaoOracleImpl"/>
    <bean id="UserServiceImpl" class="com.n7.service.UserServiceImpl">
        <!-- ref:引用Spring容器中创建好的对象
            value: 具体的值,基本数据类型!
        -->
        <property name="userDao" ref="orcaleImpl"/>
    </bean>

</beans>

测试:

//获取ApplicationContext; 拿到spring容器
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//需要什么直接get什么
UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl");

userServiceImpl.getUser();

IOC的对象的创建

1.使用无参构造创建对象,默认!
2.假设我们要使用有参构造创建对象.
下标赋值:

<!-- 下标赋值 -->
<bean id="user" class="com.n7.pojo.User">
    <constructor-arg index="0" value="死神"/>
</bean>

类型:

<!-- 第二种方式: 通过类型创建 不建议使用 -->
<bean id="user" class="com.n7.pojo.User">
    <constructor-arg type="java.lang.String" value="死神"/>
</bean>

参数名:

<!-- 第三种 直接通过参数名来设置 -->
<bean id="user" class="com.n7.pojo.User">
    <constructor-arg name="name" value="死神"/>
</bean>

总结:在配置文件加载的时候,容器中管理的对象就已经初始化了.

Spring的配置

别名

<!-- 别名,如果添加了别名,我们也可以使用别名获取到这个对象 -->
<alias name="user" alias="userNewName"/>

Bean的配置

<!--
    id: bean的唯一标识符,也就是相当于我们学过的变量名
    class: bean 对象所对应的限定名 : 包名加类型
    name : 也是别名,而且name 可以同时取多个别名
-->
<bean id="user" class="com.n7.pojo.User" name="user2,u2">
    <constructor-arg name="name" value="死神"/>
</bean>

import

这个import,一般用于团队开发,它可以将多个配置文件,导入合并成一个.
假设,现在项目中有多个人开发,这三个人复制不同的类开发,不同的类需要注册在不同的bean中,我们可以用import将所有人的beans.xml合并到一起
张三
李四
王五
applicationContext.xml

<import resource="beans1.xml">
<import resource="beans2.xml">
<import resource="beans3.xml">

使用的时候,直接配总的就可以

依赖注入

构造器注入

前面说过了

Set方式注入[重点]

依赖注入:set注入
- 依赖: bean对象的创建依赖于容器
- 注入: bean对象的所有属性,由容器来注入.

环境搭建:

复杂类型:

public class Address {
private String address;

public String getAddress() {
    return address;
}

public void setAddress(String address) {
    this.address = address;
}

真实测试对象:

	public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String, String> card;
    private Set<String> games;
    private String wife;
    private Properties info;
    }

3.beans.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="student" class="com.n7.pojo.Student">
        <property name="name" value="郑仕成"/>
    </bean>
    <bean id="address" class="com.n7.pojo.Address">

    </bean>

</beans>

4.测试类:

public class MyTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.getName());
    }
}

完善注入信息

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="address" class="com.n7.pojo.Address">
        <property name="address" value="北京"/>
    </bean>
    <bean id="student" class="com.n7.pojo.Student">
        <!-- 第一种,普通值注入,value -->
        <property name="name" value="郑仕成"/>
        <!-- 第二种,Bean注入,ref -->
        <property name="address" ref="address"/>
        <!-- 数组注入 -->
        <property name="books">
            <array>
                <value>西游记</value>
                <value>水浒传</value>
                <value>三国演义</value>
                <value>红楼梦</value>
            </array>
        </property>
        <!-- List -->
        <property name="hobbies">
            <list>
                <value>篮球</value>
                <value>音乐</value>
                <value>运动</value>
            </list>
        </property>
        <!-- Map -->
        <property name="card">
            <map>
                <entry key="身份证" value="19961216"/>
                <entry key="银行卡" value="11122334"/>
            </map>
        </property>
        <!-- Set -->
        <property name="games">
            <set>
                <value>梦三国</value>
                <value>英雄</value>
                <value>地下城</value>
            </set>
        </property>
        <!-- null -->
        <property name="wife">
            <null/>
        </property>
        <!-- Properties -->
        <property name="info">
            <props>
                <prop key="driver">jdbc</prop>
                <prop key="url">tomcat</prop>
                <prop key="username">root</prop>
                <prop key="password">root</prop>
            </props>
        </property>
    </bean>
</beans>

拓展方式注入

我们可以使用p命名空间和c命名空间进行注入
官方解释:
在这里插入图片描述

<?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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

        <!-- p命名空间注入,可以直接注入属性的值:property -->
        <bean id="user" class="com.n7.pojo.User" p:name="郑仕成" p:age="25"/>
        <!-- c命名空间注入,通过构造器注入:construct-args -->
        <bean id="user2" class="com.n7.pojo.User" c:name="郑仕成" c:age="25"/>
</beans>

测试:

@Test
public void test2(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
    User user = context.getBean("user2", User.class);
    System.out.println(user);
}

注意:p命名空间和c命名空间不能直接使用,需要导入xml约束.

	xmlns:p="http://www.springframework.org/schema/p"
   
    xmlns:c="http://www.springframework.org/schema/c"

bean的作用域

在这里插入图片描述
1.单例模式(Spring默认机制)

<bean id="user2" class="com.n7.pojo.User" c:name="郑仕成" c:age="25" scope="singleton"/>

2.原型模式:每次从容器中get的时候,都会产生一个新对象!

<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>

3.其余的request,session,application, 这些只能在web中开发中使用

Bean的自动装配

自动装配是Spring满足bean依赖的一种方式
Spring会在上下文中自动寻找,并自动给bean装配属性!

在spring中有三种装配的方式
1.在xml中显示的配置
2.在java中显示的配置
3.隐式的自动装配bean [重要]

测试

环境搭建:一个人有两个宠物

ByName自动装配

<!--
byName:会自动在容器上下文中查找,和自己对象set方法后面的值对应的bean id;
-->
<bean id="people" class="com.n7.pojo.People" autowire="byName">
    <property name="name" value="死神"/>
</bean>

ByType自动装配

 <bean class="com.n7.pojo.Cat"/>
        <bean class="com.n7.pojo.Dog"/>
        <!--
        byName:会自动在容器上下文中查找,和自己对象set方法后面的值对应的bean id;
        byType:会自动在容器上下文中查找,和自己对象属性类型相同的bean;
        -->
        <bean id="people" class="com.n7.pojo.People" autowire="byType">
            <property name="name" value="死神"/>
        </bean>

小结:
byName的时候,需要保证所有的bean的id的唯一,并且这个bean需要和自动注入的属性的值的set方法的值一致.
byType的时候,需要保证所有的bean的class唯一,并且这个bean需要和自动注入的属性的类型一致.

注解实现自动装配

jdk1.5支持注解,Spring2.5支持注解.
要使用注解须知:
1.导入约束 : context约束
2.配置注解的支持 : context:annotation-config/

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

@Autowired
直接在属性上使用即可~ 也可以在set方式上使用.
使用Autowired我们可以不用编写set方法,前提是你这个自动装配的属性在IOC容器中存在,且符合名字byName.
科普:

@nullable 字段标记了这个注解,说明这个字段可以为null

public @interface Autowired {
boolean required() default true; }

如果@Autowired自动装配的环境比较复杂,自动装配无法通过一个注解完成的时候,我们可以使用@Qualifier(value=“xxx”)去配置@Autowired的使用,指定一个唯一的bean对象注入!

public class people{
@Autowired
@Qualifier(value = "cat111")
private Cat cat;
@Autowired
@Qualifier(value = "dog222")
}

@Resource注解

public class People {
    @Resource(name = "cat111")
    private Cat cat;
    @Resource
    private Dog dog;
    }

小结:
@Resource和@Autowired的区别:

都是用来自动装配的,都可以放在属性字段上
Autowired通过byType方式实现,而且必须要求这个对象存在(常用)
@Resource 默认通过byName的方式实现,如果找不到名字,则通过byTepy实现.如果两个都找不到,就会报错.
执行顺序不同:@Autowired 通过byType的方式实现.@Resource 默认通过byName的方式实现.

使用注解开发

在Spring4之后,要使用注解开发,必须保证aop的包导入了
1.bean
在这里插入图片描述
使用注解需要导入Context约束,增加注解的支持

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd"> 

    <context:annotation-config/>

</beans>

@Component: 组件,放在类上,说明这个类被Spring管理了,就是bean.

2.属性如何注入

//等价于<bean id="user" class="com.n7.pojo.User"/>
//@Component 组件
@Component
public class User {


    public String name;
    //相当于<property name="name" value="郑仕成"/>
    @Value("郑仕成")
    public void setName(String name) {
        this.name = name;
    }
}

3.衍生的注解
@Component有几个衍生注解,我们在web开发中,会按照mvc三层架构分层.

dao @Repository
service @Service
controller @Controller
这四个注解功能是一样的,都是代表将某个类注册到Spring容器中,装配Bean.
4.自动装配
@Autowired : 自动装配通过类型.名字
如果Autowired不能唯一自动装配上属性,则需要通过@Qualifier(value=“xxx”)
@Nullable:字段标记了这个注解,说明这个字段可以为null
@Resource:自动装配通过名字,类型
5.作用域

@Component
@Scope("prototype")
public class User {


    public String name;
    //相当于<property name="name" value="郑仕成"/>
    @Value("郑仕成")
    public void setName(String name) {
        this.name = name;
    }

6.小结
xml与注解:

xml更加万能,适用于任何场合,维护简单方便.
注解不是自己的类使用不了,维护相对复杂.

xml与注解最佳实践:

xml用来管理bean;
注解只负责完成属性的注入;
我们在使用的过程中,只需要注意一个问题,必须要让注解生效就需要开启注解的支持.

      <!-- 指定要扫描的包,这个包下的注解就会生效 -->
    <context:component-scan base-package="com.n7"/>
    <context:annotation-config/>

使用java的方式配置Spring

我们现在要完全不使用Spring的xml的配置了,全权交给java来做.
javaConfig是Spring一个子项目,在spring4之后,它成为了一个核心功能.
在这里插入图片描述
实体类:

//这里这个注解的意思,就是说明这个类被Spring接管了,注册到了容器中
@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }
    @Value("郑总")//属性注入值
    public void setName(String name) {
        this.name = name;
    }

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

配置文件:

@Configuration
@ComponentScan("com.n7.pojo")
@Import({MyConfig2.class})
public class MyConfig2 {
    //注册一个bean,就相当于我们之前写的一个bean标签
    //这个方法的名字,就相当于bean标签的id属性
    //这个方法的返回值,就相当于bean标签的class属性
    @Bean
    public User user(){
        return new User();// 就是返回要注入到bean的对象!
    }
}

测试类:

public class MyTest {
    public static void main(String[] args) {
        //如果完全使用了配置类方式去做,我们只能通过AnnotationConfig 上下文来获取容器,通过配置类的class对象加载!
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        User getUser = context.getBean("user", User.class);
        System.out.println(getUser.getName());
    }
}

这种纯Java的配置方式,在SpringBoot中随处可见.

代理模式

为什么要学习代理模式? 因为这就是SpringAOP的底层! [SpringAOP和SpringMVC]
代理模式分类:

静态代理
动态代理

静态代理

角色分析:

抽象角色:一般会使用接口或者抽象类来解决
真是角色:被代理的角色
代理角色:代理真实角色,代理真实角色后,我们一般会做一些附属操作
客户:访问代理对象的人

步骤:
1.接口

//租房
public interface Rent {
    public void rent();
}

2.真实角色

//房东
public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

3.代理角色

public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }
    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        hetong();
        fare();
    }
    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }
    //签合同
    public void hetong(){
        System.out.println("签租赁合同");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

4.客户端访问代理角色

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理,中介帮房东租房子,但是,代理角色一般会有一些附属操作!
        Proxy proxy = new Proxy(host);
        //你不用面对房东,直接找中介即可
        proxy.rent();
    }
}

代理模式的好处:

可以使真实模式的操作更加纯粹.不用去关注一些公共的业务.
公共业务就交给了代理角色.实现了业务的分工.
公共业务发生拓展的时候,方便集中管理.

缺点:

一个真实的角色就会产生一个代理对象,代码量会翻倍.开发效率会变低.

加深理解

代码:对应08-demo02;
聊聊AOP
在这里插入图片描述

动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的,不是我们写好的
动态代理分为两大类:基于接口的动态代理, 基于类的动态代理.
基于接口—JDK的动态代理 [我们在这里使用]
基于类的 : cglib
java字节码实现 : javasist
需要了解两个类 : Proxy 代理, InvocationHandler 调用处理程序

动态代理的好处:

可以使真实角色的操作更加纯粹.不用去关注一些公共的业务
公共也就交给代理角色,实现了业务的分工
公共业务发生拓展的时候,方便集中管理
一个动态代理类代理的是一个接口,一般就是对应的一个业务
一个动态代理类可以代理多个类,只要是实现了同一个接口即可

AOP

什么是AOP

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP在Spring中的作用

提供声明式事务:允许用户自定义切面

横切关注点:跨越应用程序多个模块的方法或功能.既是,与我们业务逻辑无关,但是我们需要关注的部分,就是横切关注点.如日志,安全,缓存,事务等…
切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知执行的 “地点”的定义。
连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中,通过Advice定义横切逻辑,Spring中支持5种类型的Advice:

即AOP在不改变原有代码的情况下,去增加新的功能.

使用Spring实现AOP
重点:使用AOP织入,需要导入一个依赖包

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

方式一:使用Spring的API接口 [主要是SpringAPI接口实现]
方式二:自定义类来实现AOP [主要是切面定义]
方式三:使用注解实现!

<?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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

    <!-- 方式三 -->
    <bean id="AnnotationPointCut" class="com.n7.diy.AnnotationPointCut"/>
    <!-- 开启注解支持 -->
    <aop:aspectj-autoproxy/>

<!-- 注册bean -->
    <bean id="userService" class="com.n7.service.UserServiceImpl"/>
    <bean id="log" class="com.n7.log.Log"/>
    <bean id="afterLog" class="com.n7.log.AfterLog"/>
    <!- 方式一: 使用原生的Spring API接口 -->
    <!-- 配置AOP:需要导入AOP的约束 -->
    <aop:config>
        &lt;!&ndash; 切入点 expression:表达式 execution(要执行的位置!)&ndash;&gt;
        <aop:pointcut id ="pointcut" expression="execution(* com.n7.service.UserServiceImpl.*(..))"/>
        &lt;!&ndash; 执行环绕增加 &ndash;&gt;
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    </aop:config>

    <!-- 方式二: 自定义类 -->
    <bean id="diy" class="com.n7.diy.DiyPointCut"/>

   <aop:config>
        &lt;!&ndash; 自定义切面,ref要引用的类 &ndash;&gt;
        <aop:aspect ref="diy">
            &lt;!&ndash; 切入点 &ndash;&gt;
            <aop:pointcut id="point" expression="execution(* com.n7.service.UserServiceImpl.*(..))"/>
            &lt;!&ndash; 通知 &ndash;&gt;
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

</beans>

整合Mybatis

步骤:

导入相关jar包
junit
mybatis
mysql数据库
spring相关的
aop织入
mybatis-spring
编写配置
编写测试

回顾mybatis

1.编写实体类
2.编写核心配置文件
3.编写接口
4.编写Mapper.xml
5.测试

Mybatis-spring

1.编写数据源
2.sqlSesstionFactory
3.sqlSesstionTemplate
4.需要给接口加实现类
5.将自己写的实现类,注入到Spring中,
6.测试使用即可

声明式事务

<!-- 配置声明式事务 -->
<bean id="transationManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <constructor-arg ref="datasource"/>
</bean>

回顾事务

把一组一个业务来做,要么都成功,要么都失败
事务在项目开发中十分的重要,涉及到数据的一致性问题,不能马虎
确保完整性和一致性.
事务的ACID原则:
原子性
一致性
隔离性:多个业务可能操作同一个资源,防止数据损坏.
持久性:事务一旦提交,无论系统发生什么问题,结果都不会被再影响,被持久化的写到存储器中.

Spring中的事务管理

声明式事务:AOP
编程式事务: 需要在代码中,进行事务管理
思考:
为什么需要事务?
如果不配置事务,可能存在数据提交不一致的情况下.
如果我们不再Sring中去配置声明式事务,我们就需要代码中使用手动配置事务!
事务在项目的开发中十分重要,设计到数据的一致性和完整性问题,不容马虎.